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 - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
11 - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
12 - kmod support by: Cyrus Durgin
13 - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
14 - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
15
16 - lots of fixes and improvements to the RAID1/RAID5 and generic
17 RAID code (such as request based resynchronization):
18
19 Neil Brown <neilb@cse.unsw.edu.au>.
20
21 This program is free software; you can redistribute it and/or modify
22 it under the terms of the GNU General Public License as published by
23 the Free Software Foundation; either version 2, or (at your option)
24 any later version.
25
26 You should have received a copy of the GNU General Public License
27 (for example /usr/src/linux/COPYING); if not, write to the Free
28 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 */
30
31 #include <linux/module.h>
32 #include <linux/config.h>
33 #include <linux/raid/md.h>
34 #include <linux/sysctl.h>
35 #include <linux/raid/xor.h>
36 #include <linux/devfs_fs_kernel.h>
37
38 #include <linux/init.h>
39
40 #ifdef CONFIG_KMOD
41 #include <linux/kmod.h>
42 #endif
43
44 #define __KERNEL_SYSCALLS__
45 #include <linux/unistd.h>
46
47 #include <asm/unaligned.h>
48
49 extern asmlinkage int sys_sched_yield(void);
50 extern asmlinkage long sys_setsid(void);
51
52 #define MAJOR_NR MD_MAJOR
53 #define MD_DRIVER
54
55 #include <linux/blk.h>
56
57 #define DEBUG 0
58 #if DEBUG
59 # define dprintk(x...) printk(x)
60 #else
61 # define dprintk(x...) do { } while(0)
62 #endif
63
64 static mdk_personality_t *pers[MAX_PERSONALITY];
65
66 /*
67 * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
68 * is 100 KB/sec, so the extra system load does not show up that much.
69 * Increase it if you want to have more _guaranteed_ speed. Note that
70 * the RAID driver will use the maximum available bandwith if the IO
71 * subsystem is idle. There is also an 'absolute maximum' reconstruction
72 * speed limit - in case reconstruction slows down your system despite
73 * idle IO detection.
74 *
75 * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
76 */
77
78 static int sysctl_speed_limit_min = 100;
79 static int sysctl_speed_limit_max = 100000;
80
81 static struct ctl_table_header *raid_table_header;
82
83 static ctl_table raid_table[] = {
84 {DEV_RAID_SPEED_LIMIT_MIN, "speed_limit_min",
85 &sysctl_speed_limit_min, sizeof(int), 0644, NULL, &proc_dointvec},
86 {DEV_RAID_SPEED_LIMIT_MAX, "speed_limit_max",
87 &sysctl_speed_limit_max, sizeof(int), 0644, NULL, &proc_dointvec},
88 {0}
89 };
90
91 static ctl_table raid_dir_table[] = {
92 {DEV_RAID, "raid", NULL, 0, 0555, raid_table},
93 {0}
94 };
95
96 static ctl_table raid_root_table[] = {
97 {CTL_DEV, "dev", NULL, 0, 0555, raid_dir_table},
98 {0}
99 };
100
101 /*
102 * these have to be allocated separately because external
103 * subsystems want to have a pre-defined structure
104 */
105 struct hd_struct md_hd_struct[MAX_MD_DEVS];
106 static int md_blocksizes[MAX_MD_DEVS];
107 static int md_hardsect_sizes[MAX_MD_DEVS];
108 static int md_maxreadahead[MAX_MD_DEVS];
109 static mdk_thread_t *md_recovery_thread;
110
111 int md_size[MAX_MD_DEVS];
112
113 extern struct block_device_operations md_fops;
114 static devfs_handle_t devfs_handle;
115
116 static struct gendisk md_gendisk=
117 {
118 major: MD_MAJOR,
119 major_name: "md",
120 minor_shift: 0,
121 max_p: 1,
122 part: md_hd_struct,
123 sizes: md_size,
124 nr_real: MAX_MD_DEVS,
125 real_devices: NULL,
126 next: NULL,
127 fops: &md_fops,
128 };
129
130 /*
131 * Enables to iterate over all existing md arrays
132 */
133 static MD_LIST_HEAD(all_mddevs);
134
135 /*
136 * The mapping between kdev and mddev is not necessary a simple
137 * one! Eg. HSM uses several sub-devices to implement Logical
138 * Volumes. All these sub-devices map to the same mddev.
139 */
140 dev_mapping_t mddev_map[MAX_MD_DEVS];
141
142 void add_mddev_mapping (mddev_t * mddev, kdev_t dev, void *data)
143 {
144 unsigned int minor = MINOR(dev);
145
146 if (MAJOR(dev) != MD_MAJOR) {
147 MD_BUG();
148 return;
149 }
150 if (mddev_map[minor].mddev != NULL) {
151 MD_BUG();
152 return;
153 }
154 mddev_map[minor].mddev = mddev;
155 mddev_map[minor].data = data;
156 }
157
158 void del_mddev_mapping (mddev_t * mddev, kdev_t dev)
159 {
160 unsigned int minor = MINOR(dev);
161
162 if (MAJOR(dev) != MD_MAJOR) {
163 MD_BUG();
164 return;
165 }
166 if (mddev_map[minor].mddev != mddev) {
167 MD_BUG();
168 return;
169 }
170 mddev_map[minor].mddev = NULL;
171 mddev_map[minor].data = NULL;
172 }
173
174 static int md_make_request (request_queue_t *q, int rw, struct buffer_head * bh)
175 {
176 mddev_t *mddev = kdev_to_mddev(bh->b_rdev);
177
178 if (mddev && mddev->pers)
179 return mddev->pers->make_request(mddev, rw, bh);
180 else {
181 buffer_IO_error(bh);
182 return 0;
183 }
184 }
185
186 static mddev_t * alloc_mddev (kdev_t dev)
187 {
188 mddev_t *mddev;
189
190 if (MAJOR(dev) != MD_MAJOR) {
191 MD_BUG();
192 return 0;
193 }
194 mddev = (mddev_t *) kmalloc(sizeof(*mddev), GFP_KERNEL);
195 if (!mddev)
196 return NULL;
197
198 memset(mddev, 0, sizeof(*mddev));
199
200 mddev->__minor = MINOR(dev);
201 init_MUTEX(&mddev->reconfig_sem);
202 init_MUTEX(&mddev->recovery_sem);
203 init_MUTEX(&mddev->resync_sem);
204 MD_INIT_LIST_HEAD(&mddev->disks);
205 MD_INIT_LIST_HEAD(&mddev->all_mddevs);
206 atomic_set(&mddev->active, 0);
207
208 /*
209 * The 'base' mddev is the one with data NULL.
210 * personalities can create additional mddevs
211 * if necessary.
212 */
213 add_mddev_mapping(mddev, dev, 0);
214 md_list_add(&mddev->all_mddevs, &all_mddevs);
215
216 MOD_INC_USE_COUNT;
217
218 return mddev;
219 }
220
221 struct gendisk * find_gendisk (kdev_t dev)
222 {
223 struct gendisk *tmp = gendisk_head;
224
225 while (tmp != NULL) {
226 if (tmp->major == MAJOR(dev))
227 return (tmp);
228 tmp = tmp->next;
229 }
230 return (NULL);
231 }
232
233 mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
234 {
235 mdk_rdev_t * rdev;
236 struct md_list_head *tmp;
237
238 ITERATE_RDEV(mddev,rdev,tmp) {
239 if (rdev->desc_nr == nr)
240 return rdev;
241 }
242 return NULL;
243 }
244
245 mdk_rdev_t * find_rdev(mddev_t * mddev, kdev_t dev)
246 {
247 struct md_list_head *tmp;
248 mdk_rdev_t *rdev;
249
250 ITERATE_RDEV(mddev,rdev,tmp) {
251 if (rdev->dev == dev)
252 return rdev;
253 }
254 return NULL;
255 }
256
257 static MD_LIST_HEAD(device_names);
258
259 char * partition_name (kdev_t dev)
260 {
261 struct gendisk *hd;
262 static char nomem [] = "<nomem>";
263 dev_name_t *dname;
264 struct md_list_head *tmp = device_names.next;
265
266 while (tmp != &device_names) {
267 dname = md_list_entry(tmp, dev_name_t, list);
268 if (dname->dev == dev)
269 return dname->name;
270 tmp = tmp->next;
271 }
272
273 dname = (dev_name_t *) kmalloc(sizeof(*dname), GFP_KERNEL);
274
275 if (!dname)
276 return nomem;
277 /*
278 * ok, add this new device name to the list
279 */
280 hd = find_gendisk (dev);
281 dname->name = NULL;
282 if (hd)
283 dname->name = disk_name (hd, MINOR(dev), dname->namebuf);
284 if (!dname->name) {
285 sprintf (dname->namebuf, "[dev %s]", kdevname(dev));
286 dname->name = dname->namebuf;
287 }
288
289 dname->dev = dev;
290 MD_INIT_LIST_HEAD(&dname->list);
291 md_list_add(&dname->list, &device_names);
292
293 return dname->name;
294 }
295
296 static unsigned int calc_dev_sboffset (kdev_t dev, mddev_t *mddev,
297 int persistent)
298 {
299 unsigned int size = 0;
300
301 if (blk_size[MAJOR(dev)])
302 size = blk_size[MAJOR(dev)][MINOR(dev)];
303 if (persistent)
304 size = MD_NEW_SIZE_BLOCKS(size);
305 return size;
306 }
307
308 static unsigned int calc_dev_size (kdev_t dev, mddev_t *mddev, int persistent)
309 {
310 unsigned int size;
311
312 size = calc_dev_sboffset(dev, mddev, persistent);
313 if (!mddev->sb) {
314 MD_BUG();
315 return size;
316 }
317 if (mddev->sb->chunk_size)
318 size &= ~(mddev->sb->chunk_size/1024 - 1);
319 return size;
320 }
321
322 static unsigned int zoned_raid_size (mddev_t *mddev)
323 {
324 unsigned int mask;
325 mdk_rdev_t * rdev;
326 struct md_list_head *tmp;
327
328 if (!mddev->sb) {
329 MD_BUG();
330 return -EINVAL;
331 }
332 /*
333 * do size and offset calculations.
334 */
335 mask = ~(mddev->sb->chunk_size/1024 - 1);
336
337 ITERATE_RDEV(mddev,rdev,tmp) {
338 rdev->size &= mask;
339 md_size[mdidx(mddev)] += rdev->size;
340 }
341 return 0;
342 }
343
344 /*
345 * We check wether all devices are numbered from 0 to nb_dev-1. The
346 * order is guaranteed even after device name changes.
347 *
348 * Some personalities (raid0, linear) use this. Personalities that
349 * provide data have to be able to deal with loss of individual
350 * disks, so they do their checking themselves.
351 */
352 int md_check_ordering (mddev_t *mddev)
353 {
354 int i, c;
355 mdk_rdev_t *rdev;
356 struct md_list_head *tmp;
357
358 /*
359 * First, all devices must be fully functional
360 */
361 ITERATE_RDEV(mddev,rdev,tmp) {
362 if (rdev->faulty) {
363 printk("md: md%d's device %s faulty, aborting.\n",
364 mdidx(mddev), partition_name(rdev->dev));
365 goto abort;
366 }
367 }
368
369 c = 0;
370 ITERATE_RDEV(mddev,rdev,tmp) {
371 c++;
372 }
373 if (c != mddev->nb_dev) {
374 MD_BUG();
375 goto abort;
376 }
377 if (mddev->nb_dev != mddev->sb->raid_disks) {
378 printk("md: md%d, array needs %d disks, has %d, aborting.\n",
379 mdidx(mddev), mddev->sb->raid_disks, mddev->nb_dev);
380 goto abort;
381 }
382 /*
383 * Now the numbering check
384 */
385 for (i = 0; i < mddev->nb_dev; i++) {
386 c = 0;
387 ITERATE_RDEV(mddev,rdev,tmp) {
388 if (rdev->desc_nr == i)
389 c++;
390 }
391 if (!c) {
392 printk("md: md%d, missing disk #%d, aborting.\n",
393 mdidx(mddev), i);
394 goto abort;
395 }
396 if (c > 1) {
397 printk("md: md%d, too many disks #%d, aborting.\n",
398 mdidx(mddev), i);
399 goto abort;
400 }
401 }
402 return 0;
403 abort:
404 return 1;
405 }
406
407 static void remove_descriptor (mdp_disk_t *disk, mdp_super_t *sb)
408 {
409 if (disk_active(disk)) {
410 sb->working_disks--;
411 } else {
412 if (disk_spare(disk)) {
413 sb->spare_disks--;
414 sb->working_disks--;
415 } else {
416 sb->failed_disks--;
417 }
418 }
419 sb->nr_disks--;
420 disk->major = 0;
421 disk->minor = 0;
422 mark_disk_removed(disk);
423 }
424
425 #define BAD_MAGIC KERN_ERR \
426 "md: invalid raid superblock magic on %s\n"
427
428 #define BAD_MINOR KERN_ERR \
429 "md: %s: invalid raid minor (%x)\n"
430
431 #define OUT_OF_MEM KERN_ALERT \
432 "md: out of memory.\n"
433
434 #define NO_SB KERN_ERR \
435 "md: disabled device %s, could not read superblock.\n"
436
437 #define BAD_CSUM KERN_WARNING \
438 "md: invalid superblock checksum on %s\n"
439
440 static int alloc_array_sb (mddev_t * mddev)
441 {
442 if (mddev->sb) {
443 MD_BUG();
444 return 0;
445 }
446
447 mddev->sb = (mdp_super_t *) __get_free_page (GFP_KERNEL);
448 if (!mddev->sb)
449 return -ENOMEM;
450 md_clear_page(mddev->sb);
451 return 0;
452 }
453
454 static int alloc_disk_sb (mdk_rdev_t * rdev)
455 {
456 if (rdev->sb)
457 MD_BUG();
458
459 rdev->sb = (mdp_super_t *) __get_free_page(GFP_KERNEL);
460 if (!rdev->sb) {
461 printk (OUT_OF_MEM);
462 return -EINVAL;
463 }
464 md_clear_page(rdev->sb);
465
466 return 0;
467 }
468
469 static void free_disk_sb (mdk_rdev_t * rdev)
470 {
471 if (rdev->sb) {
472 free_page((unsigned long) rdev->sb);
473 rdev->sb = NULL;
474 rdev->sb_offset = 0;
475 rdev->size = 0;
476 } else {
477 if (!rdev->faulty)
478 MD_BUG();
479 }
480 }
481
482 static void mark_rdev_faulty (mdk_rdev_t * rdev)
483 {
484 if (!rdev) {
485 MD_BUG();
486 return;
487 }
488 free_disk_sb(rdev);
489 rdev->faulty = 1;
490 }
491
492 static int read_disk_sb (mdk_rdev_t * rdev)
493 {
494 int ret = -EINVAL;
495 struct buffer_head *bh = NULL;
496 kdev_t dev = rdev->dev;
497 mdp_super_t *sb;
498 unsigned long sb_offset;
499
500 if (!rdev->sb) {
501 MD_BUG();
502 goto abort;
503 }
504
505 /*
506 * Calculate the position of the superblock,
507 * it's at the end of the disk
508 */
509 sb_offset = calc_dev_sboffset(rdev->dev, rdev->mddev, 1);
510 rdev->sb_offset = sb_offset;
511 printk("(read) %s's sb offset: %ld", partition_name(dev), sb_offset);
512 fsync_dev(dev);
513 set_blocksize (dev, MD_SB_BYTES);
514 bh = bread (dev, sb_offset / MD_SB_BLOCKS, MD_SB_BYTES);
515
516 if (bh) {
517 sb = (mdp_super_t *) bh->b_data;
518 memcpy (rdev->sb, sb, MD_SB_BYTES);
519 } else {
520 printk (NO_SB,partition_name(rdev->dev));
521 goto abort;
522 }
523 printk(" [events: %08lx]\n", (unsigned long)rdev->sb->events_lo);
524 ret = 0;
525 abort:
526 if (bh)
527 brelse (bh);
528 return ret;
529 }
530
531 static unsigned int calc_sb_csum (mdp_super_t * sb)
532 {
533 unsigned int disk_csum, csum;
534
535 disk_csum = sb->sb_csum;
536 sb->sb_csum = 0;
537 csum = csum_partial((void *)sb, MD_SB_BYTES, 0);
538 sb->sb_csum = disk_csum;
539 return csum;
540 }
541
542 /*
543 * Check one RAID superblock for generic plausibility
544 */
545
546 static int check_disk_sb (mdk_rdev_t * rdev)
547 {
548 mdp_super_t *sb;
549 int ret = -EINVAL;
550
551 sb = rdev->sb;
552 if (!sb) {
553 MD_BUG();
554 goto abort;
555 }
556
557 if (sb->md_magic != MD_SB_MAGIC) {
558 printk (BAD_MAGIC, partition_name(rdev->dev));
559 goto abort;
560 }
561
562 if (sb->md_minor >= MAX_MD_DEVS) {
563 printk (BAD_MINOR, partition_name(rdev->dev),
564 sb->md_minor);
565 goto abort;
566 }
567
568 if (calc_sb_csum(sb) != sb->sb_csum)
569 printk(BAD_CSUM, partition_name(rdev->dev));
570 ret = 0;
571 abort:
572 return ret;
573 }
574
575 static kdev_t dev_unit(kdev_t dev)
576 {
577 unsigned int mask;
578 struct gendisk *hd = find_gendisk(dev);
579
580 if (!hd)
581 return 0;
582 mask = ~((1 << hd->minor_shift) - 1);
583
584 return MKDEV(MAJOR(dev), MINOR(dev) & mask);
585 }
586
587 static mdk_rdev_t * match_dev_unit(mddev_t *mddev, kdev_t dev)
588 {
589 struct md_list_head *tmp;
590 mdk_rdev_t *rdev;
591
592 ITERATE_RDEV(mddev,rdev,tmp)
593 if (dev_unit(rdev->dev) == dev_unit(dev))
594 return rdev;
595
596 return NULL;
597 }
598
599 static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
600 {
601 struct md_list_head *tmp;
602 mdk_rdev_t *rdev;
603
604 ITERATE_RDEV(mddev1,rdev,tmp)
605 if (match_dev_unit(mddev2, rdev->dev))
606 return 1;
607
608 return 0;
609 }
610
611 static MD_LIST_HEAD(all_raid_disks);
612 static MD_LIST_HEAD(pending_raid_disks);
613
614 static void bind_rdev_to_array (mdk_rdev_t * rdev, mddev_t * mddev)
615 {
616 mdk_rdev_t *same_pdev;
617
618 if (rdev->mddev) {
619 MD_BUG();
620 return;
621 }
622 same_pdev = match_dev_unit(mddev, rdev->dev);
623 if (same_pdev)
624 printk( KERN_WARNING
625 "md%d: WARNING: %s appears to be on the same physical disk as %s. True\n"
626 " protection against single-disk failure might be compromised.\n",
627 mdidx(mddev), partition_name(rdev->dev),
628 partition_name(same_pdev->dev));
629
630 md_list_add(&rdev->same_set, &mddev->disks);
631 rdev->mddev = mddev;
632 mddev->nb_dev++;
633 printk("bind<%s,%d>\n", partition_name(rdev->dev), mddev->nb_dev);
634 }
635
636 static void unbind_rdev_from_array (mdk_rdev_t * rdev)
637 {
638 if (!rdev->mddev) {
639 MD_BUG();
640 return;
641 }
642 md_list_del(&rdev->same_set);
643 MD_INIT_LIST_HEAD(&rdev->same_set);
644 rdev->mddev->nb_dev--;
645 printk("unbind<%s,%d>\n", partition_name(rdev->dev),
646 rdev->mddev->nb_dev);
647 rdev->mddev = NULL;
648 }
649
650 /*
651 * prevent the device from being mounted, repartitioned or
652 * otherwise reused by a RAID array (or any other kernel
653 * subsystem), by opening the device. [simply getting an
654 * inode is not enough, the SCSI module usage code needs
655 * an explicit open() on the device]
656 */
657 static int lock_rdev (mdk_rdev_t *rdev)
658 {
659 int err = 0;
660 struct block_device *bdev;
661
662 bdev = bdget(rdev->dev);
663 if (bdev == NULL)
664 return -ENOMEM;
665 err = blkdev_get(bdev, FMODE_READ|FMODE_WRITE, 0, BDEV_FILE);
666 if (!err) {
667 rdev->bdev = bdev;
668 }
669 return err;
670 }
671
672 static void unlock_rdev (mdk_rdev_t *rdev)
673 {
674 if (!rdev->bdev)
675 MD_BUG();
676 blkdev_put(rdev->bdev, BDEV_FILE);
677 bdput(rdev->bdev);
678 rdev->bdev = NULL;
679 }
680
681 static void export_rdev (mdk_rdev_t * rdev)
682 {
683 printk("export_rdev(%s)\n",partition_name(rdev->dev));
684 if (rdev->mddev)
685 MD_BUG();
686 unlock_rdev(rdev);
687 free_disk_sb(rdev);
688 md_list_del(&rdev->all);
689 MD_INIT_LIST_HEAD(&rdev->all);
690 if (rdev->pending.next != &rdev->pending) {
691 printk("(%s was pending)\n",partition_name(rdev->dev));
692 md_list_del(&rdev->pending);
693 MD_INIT_LIST_HEAD(&rdev->pending);
694 }
695 rdev->dev = 0;
696 rdev->faulty = 0;
697 kfree(rdev);
698 }
699
700 static void kick_rdev_from_array (mdk_rdev_t * rdev)
701 {
702 unbind_rdev_from_array(rdev);
703 export_rdev(rdev);
704 }
705
706 static void export_array (mddev_t *mddev)
707 {
708 struct md_list_head *tmp;
709 mdk_rdev_t *rdev;
710 mdp_super_t *sb = mddev->sb;
711
712 if (mddev->sb) {
713 mddev->sb = NULL;
714 free_page((unsigned long) sb);
715 }
716
717 ITERATE_RDEV(mddev,rdev,tmp) {
718 if (!rdev->mddev) {
719 MD_BUG();
720 continue;
721 }
722 kick_rdev_from_array(rdev);
723 }
724 if (mddev->nb_dev)
725 MD_BUG();
726 }
727
728 static void free_mddev (mddev_t *mddev)
729 {
730 if (!mddev) {
731 MD_BUG();
732 return;
733 }
734
735 export_array(mddev);
736 md_size[mdidx(mddev)] = 0;
737 md_hd_struct[mdidx(mddev)].nr_sects = 0;
738
739 /*
740 * Make sure nobody else is using this mddev
741 * (careful, we rely on the global kernel lock here)
742 */
743 while (md_atomic_read(&mddev->resync_sem.count) != 1)
744 schedule();
745 while (md_atomic_read(&mddev->recovery_sem.count) != 1)
746 schedule();
747
748 del_mddev_mapping(mddev, MKDEV(MD_MAJOR, mdidx(mddev)));
749 md_list_del(&mddev->all_mddevs);
750 MD_INIT_LIST_HEAD(&mddev->all_mddevs);
751 kfree(mddev);
752 MOD_DEC_USE_COUNT;
753 }
754
755 #undef BAD_CSUM
756 #undef BAD_MAGIC
757 #undef OUT_OF_MEM
758 #undef NO_SB
759
760 static void print_desc(mdp_disk_t *desc)
761 {
762 printk(" DISK<N:%d,%s(%d,%d),R:%d,S:%d>\n", desc->number,
763 partition_name(MKDEV(desc->major,desc->minor)),
764 desc->major,desc->minor,desc->raid_disk,desc->state);
765 }
766
767 static void print_sb(mdp_super_t *sb)
768 {
769 int i;
770
771 printk(" SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n",
772 sb->major_version, sb->minor_version, sb->patch_version,
773 sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3,
774 sb->ctime);
775 printk(" L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n", sb->level,
776 sb->size, sb->nr_disks, sb->raid_disks, sb->md_minor,
777 sb->layout, sb->chunk_size);
778 printk(" UT:%08x ST:%d AD:%d WD:%d FD:%d SD:%d CSUM:%08x E:%08lx\n",
779 sb->utime, sb->state, sb->active_disks, sb->working_disks,
780 sb->failed_disks, sb->spare_disks,
781 sb->sb_csum, (unsigned long)sb->events_lo);
782
783 for (i = 0; i < MD_SB_DISKS; i++) {
784 mdp_disk_t *desc;
785
786 desc = sb->disks + i;
787 printk(" D %2d: ", i);
788 print_desc(desc);
789 }
790 printk(" THIS: ");
791 print_desc(&sb->this_disk);
792
793 }
794
795 static void print_rdev(mdk_rdev_t *rdev)
796 {
797 printk(" rdev %s: O:%s, SZ:%08ld F:%d DN:%d ",
798 partition_name(rdev->dev), partition_name(rdev->old_dev),
799 rdev->size, rdev->faulty, rdev->desc_nr);
800 if (rdev->sb) {
801 printk("rdev superblock:\n");
802 print_sb(rdev->sb);
803 } else
804 printk("no rdev superblock!\n");
805 }
806
807 void md_print_devices (void)
808 {
809 struct md_list_head *tmp, *tmp2;
810 mdk_rdev_t *rdev;
811 mddev_t *mddev;
812
813 printk("\n");
814 printk(" **********************************\n");
815 printk(" * <COMPLETE RAID STATE PRINTOUT> *\n");
816 printk(" **********************************\n");
817 ITERATE_MDDEV(mddev,tmp) {
818 printk("md%d: ", mdidx(mddev));
819
820 ITERATE_RDEV(mddev,rdev,tmp2)
821 printk("<%s>", partition_name(rdev->dev));
822
823 if (mddev->sb) {
824 printk(" array superblock:\n");
825 print_sb(mddev->sb);
826 } else
827 printk(" no array superblock.\n");
828
829 ITERATE_RDEV(mddev,rdev,tmp2)
830 print_rdev(rdev);
831 }
832 printk(" **********************************\n");
833 printk("\n");
834 }
835
836 static int sb_equal ( mdp_super_t *sb1, mdp_super_t *sb2)
837 {
838 int ret;
839 mdp_super_t *tmp1, *tmp2;
840
841 tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
842 tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
843
844 if (!tmp1 || !tmp2) {
845 ret = 0;
846 goto abort;
847 }
848
849 *tmp1 = *sb1;
850 *tmp2 = *sb2;
851
852 /*
853 * nr_disks is not constant
854 */
855 tmp1->nr_disks = 0;
856 tmp2->nr_disks = 0;
857
858 if (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4))
859 ret = 0;
860 else
861 ret = 1;
862
863 abort:
864 if (tmp1)
865 kfree(tmp1);
866 if (tmp2)
867 kfree(tmp2);
868
869 return ret;
870 }
871
872 static int uuid_equal(mdk_rdev_t *rdev1, mdk_rdev_t *rdev2)
873 {
874 if ( (rdev1->sb->set_uuid0 == rdev2->sb->set_uuid0) &&
875 (rdev1->sb->set_uuid1 == rdev2->sb->set_uuid1) &&
876 (rdev1->sb->set_uuid2 == rdev2->sb->set_uuid2) &&
877 (rdev1->sb->set_uuid3 == rdev2->sb->set_uuid3))
878
879 return 1;
880
881 return 0;
882 }
883
884 static mdk_rdev_t * find_rdev_all (kdev_t dev)
885 {
886 struct md_list_head *tmp;
887 mdk_rdev_t *rdev;
888
889 tmp = all_raid_disks.next;
890 while (tmp != &all_raid_disks) {
891 rdev = md_list_entry(tmp, mdk_rdev_t, all);
892 if (rdev->dev == dev)
893 return rdev;
894 tmp = tmp->next;
895 }
896 return NULL;
897 }
898
899 #define GETBLK_FAILED KERN_ERR \
900 "md: getblk failed for device %s\n"
901
902 static int write_disk_sb(mdk_rdev_t * rdev)
903 {
904 struct buffer_head *bh;
905 kdev_t dev;
906 unsigned long sb_offset, size;
907 mdp_super_t *sb;
908
909 if (!rdev->sb) {
910 MD_BUG();
911 return -1;
912 }
913 if (rdev->faulty) {
914 MD_BUG();
915 return -1;
916 }
917 if (rdev->sb->md_magic != MD_SB_MAGIC) {
918 MD_BUG();
919 return -1;
920 }
921
922 dev = rdev->dev;
923 sb_offset = calc_dev_sboffset(dev, rdev->mddev, 1);
924 if (rdev->sb_offset != sb_offset) {
925 printk("%s's sb offset has changed from %ld to %ld, skipping\n", partition_name(dev), rdev->sb_offset, sb_offset);
926 goto skip;
927 }
928 /*
929 * If the disk went offline meanwhile and it's just a spare, then
930 * it's size has changed to zero silently, and the MD code does
931 * not yet know that it's faulty.
932 */
933 size = calc_dev_size(dev, rdev->mddev, 1);
934 if (size != rdev->size) {
935 printk("%s's size has changed from %ld to %ld since import, skipping\n", partition_name(dev), rdev->size, size);
936 goto skip;
937 }
938
939 printk("(write) %s's sb offset: %ld\n", partition_name(dev), sb_offset);
940 fsync_dev(dev);
941 set_blocksize(dev, MD_SB_BYTES);
942 bh = getblk(dev, sb_offset / MD_SB_BLOCKS, MD_SB_BYTES);
943 if (!bh) {
944 printk(GETBLK_FAILED, partition_name(dev));
945 return 1;
946 }
947 memset(bh->b_data,0,bh->b_size);
948 sb = (mdp_super_t *) bh->b_data;
949 memcpy(sb, rdev->sb, MD_SB_BYTES);
950
951 mark_buffer_uptodate(bh, 1);
952 mark_buffer_dirty(bh);
953 ll_rw_block(WRITE, 1, &bh);
954 wait_on_buffer(bh);
955 brelse(bh);
956 fsync_dev(dev);
957 skip:
958 return 0;
959 }
960 #undef GETBLK_FAILED
961
962 static void set_this_disk(mddev_t *mddev, mdk_rdev_t *rdev)
963 {
964 int i, ok = 0;
965 mdp_disk_t *desc;
966
967 for (i = 0; i < MD_SB_DISKS; i++) {
968 desc = mddev->sb->disks + i;
969 #if 0
970 if (disk_faulty(desc)) {
971 if (MKDEV(desc->major,desc->minor) == rdev->dev)
972 ok = 1;
973 continue;
974 }
975 #endif
976 if (MKDEV(desc->major,desc->minor) == rdev->dev) {
977 rdev->sb->this_disk = *desc;
978 rdev->desc_nr = desc->number;
979 ok = 1;
980 break;
981 }
982 }
983
984 if (!ok) {
985 MD_BUG();
986 }
987 }
988
989 static int sync_sbs(mddev_t * mddev)
990 {
991 mdk_rdev_t *rdev;
992 mdp_super_t *sb;
993 struct md_list_head *tmp;
994
995 ITERATE_RDEV(mddev,rdev,tmp) {
996 if (rdev->faulty)
997 continue;
998 sb = rdev->sb;
999 *sb = *mddev->sb;
1000 set_this_disk(mddev, rdev);
1001 sb->sb_csum = calc_sb_csum(sb);
1002 }
1003 return 0;
1004 }
1005
1006 int md_update_sb(mddev_t * mddev)
1007 {
1008 int first, err, count = 100;
1009 struct md_list_head *tmp;
1010 mdk_rdev_t *rdev;
1011
1012 repeat:
1013 mddev->sb->utime = CURRENT_TIME;
1014 if ((++mddev->sb->events_lo)==0)
1015 ++mddev->sb->events_hi;
1016
1017 if ((mddev->sb->events_lo|mddev->sb->events_hi)==0) {
1018 /*
1019 * oops, this 64-bit counter should never wrap.
1020 * Either we are in around ~1 trillion A.C., assuming
1021 * 1 reboot per second, or we have a bug:
1022 */
1023 MD_BUG();
1024 mddev->sb->events_lo = mddev->sb->events_hi = 0xffffffff;
1025 }
1026 sync_sbs(mddev);
1027
1028 /*
1029 * do not write anything to disk if using
1030 * nonpersistent superblocks
1031 */
1032 if (mddev->sb->not_persistent)
1033 return 0;
1034
1035 printk(KERN_INFO "md: updating md%d RAID superblock on device\n",
1036 mdidx(mddev));
1037
1038 first = 1;
1039 err = 0;
1040 ITERATE_RDEV(mddev,rdev,tmp) {
1041 if (!first) {
1042 first = 0;
1043 printk(", ");
1044 }
1045 if (rdev->faulty)
1046 printk("(skipping faulty ");
1047 printk("%s ", partition_name(rdev->dev));
1048 if (!rdev->faulty) {
1049 printk("[events: %08lx]",
1050 (unsigned long)rdev->sb->events_lo);
1051 err += write_disk_sb(rdev);
1052 } else
1053 printk(")\n");
1054 }
1055 printk(".\n");
1056 if (err) {
1057 printk("errors occured during superblock update, repeating\n");
1058 if (--count)
1059 goto repeat;
1060 printk("excessive errors occured during superblock update, exiting\n");
1061 }
1062 return 0;
1063 }
1064
1065 /*
1066 * Import a device. If 'on_disk', then sanity check the superblock
1067 *
1068 * mark the device faulty if:
1069 *
1070 * - the device is nonexistent (zero size)
1071 * - the device has no valid superblock
1072 *
1073 * a faulty rdev _never_ has rdev->sb set.
1074 */
1075 static int md_import_device (kdev_t newdev, int on_disk)
1076 {
1077 int err;
1078 mdk_rdev_t *rdev;
1079 unsigned int size;
1080
1081 if (find_rdev_all(newdev))
1082 return -EEXIST;
1083
1084 rdev = (mdk_rdev_t *) kmalloc(sizeof(*rdev), GFP_KERNEL);
1085 if (!rdev) {
1086 printk("could not alloc mem for %s!\n", partition_name(newdev));
1087 return -ENOMEM;
1088 }
1089 memset(rdev, 0, sizeof(*rdev));
1090
1091 if (get_super(newdev)) {
1092 printk("md: can not import %s, has active inodes!\n",
1093 partition_name(newdev));
1094 err = -EBUSY;
1095 goto abort_free;
1096 }
1097
1098 if ((err = alloc_disk_sb(rdev)))
1099 goto abort_free;
1100
1101 rdev->dev = newdev;
1102 if (lock_rdev(rdev)) {
1103 printk("md: could not lock %s, zero-size? Marking faulty.\n",
1104 partition_name(newdev));
1105 err = -EINVAL;
1106 goto abort_free;
1107 }
1108 rdev->desc_nr = -1;
1109 rdev->faulty = 0;
1110
1111 size = 0;
1112 if (blk_size[MAJOR(newdev)])
1113 size = blk_size[MAJOR(newdev)][MINOR(newdev)];
1114 if (!size) {
1115 printk("md: %s has zero size, marking faulty!\n",
1116 partition_name(newdev));
1117 err = -EINVAL;
1118 goto abort_free;
1119 }
1120
1121 if (on_disk) {
1122 if ((err = read_disk_sb(rdev))) {
1123 printk("md: could not read %s's sb, not importing!\n",
1124 partition_name(newdev));
1125 goto abort_free;
1126 }
1127 if ((err = check_disk_sb(rdev))) {
1128 printk("md: %s has invalid sb, not importing!\n",
1129 partition_name(newdev));
1130 goto abort_free;
1131 }
1132
1133 rdev->old_dev = MKDEV(rdev->sb->this_disk.major,
1134 rdev->sb->this_disk.minor);
1135 rdev->desc_nr = rdev->sb->this_disk.number;
1136 }
1137 md_list_add(&rdev->all, &all_raid_disks);
1138 MD_INIT_LIST_HEAD(&rdev->pending);
1139
1140 if (rdev->faulty && rdev->sb)
1141 free_disk_sb(rdev);
1142 return 0;
1143
1144 abort_free:
1145 if (rdev->sb) {
1146 if (rdev->bdev)
1147 unlock_rdev(rdev);
1148 free_disk_sb(rdev);
1149 }
1150 kfree(rdev);
1151 return err;
1152 }
1153
1154 /*
1155 * Check a full RAID array for plausibility
1156 */
1157
1158 #define INCONSISTENT KERN_ERR \
1159 "md: fatal superblock inconsistency in %s -- removing from array\n"
1160
1161 #define OUT_OF_DATE KERN_ERR \
1162 "md: superblock update time inconsistency -- using the most recent one\n"
1163
1164 #define OLD_VERSION KERN_ALERT \
1165 "md: md%d: unsupported raid array version %d.%d.%d\n"
1166
1167 #define NOT_CLEAN_IGNORE KERN_ERR \
1168 "md: md%d: raid array is not clean -- starting background reconstruction\n"
1169
1170 #define UNKNOWN_LEVEL KERN_ERR \
1171 "md: md%d: unsupported raid level %d\n"
1172
1173 static int analyze_sbs (mddev_t * mddev)
1174 {
1175 int out_of_date = 0, i;
1176 struct md_list_head *tmp, *tmp2;
1177 mdk_rdev_t *rdev, *rdev2, *freshest;
1178 mdp_super_t *sb;
1179
1180 /*
1181 * Verify the RAID superblock on each real device
1182 */
1183 ITERATE_RDEV(mddev,rdev,tmp) {
1184 if (rdev->faulty) {
1185 MD_BUG();
1186 goto abort;
1187 }
1188 if (!rdev->sb) {
1189 MD_BUG();
1190 goto abort;
1191 }
1192 if (check_disk_sb(rdev))
1193 goto abort;
1194 }
1195
1196 /*
1197 * The superblock constant part has to be the same
1198 * for all disks in the array.
1199 */
1200 sb = NULL;
1201
1202 ITERATE_RDEV(mddev,rdev,tmp) {
1203 if (!sb) {
1204 sb = rdev->sb;
1205 continue;
1206 }
1207 if (!sb_equal(sb, rdev->sb)) {
1208 printk (INCONSISTENT, partition_name(rdev->dev));
1209 kick_rdev_from_array(rdev);
1210 continue;
1211 }
1212 }
1213
1214 /*
1215 * OK, we have all disks and the array is ready to run. Let's
1216 * find the freshest superblock, that one will be the superblock
1217 * that represents the whole array.
1218 */
1219 if (!mddev->sb)
1220 if (alloc_array_sb(mddev))
1221 goto abort;
1222 sb = mddev->sb;
1223 freshest = NULL;
1224
1225 ITERATE_RDEV(mddev,rdev,tmp) {
1226 __u64 ev1, ev2;
1227 /*
1228 * if the checksum is invalid, use the superblock
1229 * only as a last resort. (decrease it's age by
1230 * one event)
1231 */
1232 if (calc_sb_csum(rdev->sb) != rdev->sb->sb_csum) {
1233 if (rdev->sb->events_lo || rdev->sb->events_hi)
1234 if ((rdev->sb->events_lo--)==0)
1235 rdev->sb->events_hi--;
1236 }
1237
1238 printk("%s's event counter: %08lx\n", partition_name(rdev->dev),
1239 (unsigned long)rdev->sb->events_lo);
1240 if (!freshest) {
1241 freshest = rdev;
1242 continue;
1243 }
1244 /*
1245 * Find the newest superblock version
1246 */
1247 ev1 = md_event(rdev->sb);
1248 ev2 = md_event(freshest->sb);
1249 if (ev1 != ev2) {
1250 out_of_date = 1;
1251 if (ev1 > ev2)
1252 freshest = rdev;
1253 }
1254 }
1255 if (out_of_date) {
1256 printk(OUT_OF_DATE);
1257 printk("freshest: %s\n", partition_name(freshest->dev));
1258 }
1259 memcpy (sb, freshest->sb, sizeof(*sb));
1260
1261 /*
1262 * at this point we have picked the 'best' superblock
1263 * from all available superblocks.
1264 * now we validate this superblock and kick out possibly
1265 * failed disks.
1266 */
1267 ITERATE_RDEV(mddev,rdev,tmp) {
1268 /*
1269 * Kick all non-fresh devices faulty
1270 */
1271 __u64 ev1, ev2;
1272 ev1 = md_event(rdev->sb);
1273 ev2 = md_event(sb);
1274 ++ev1;
1275 if (ev1 < ev2) {
1276 printk("md: kicking non-fresh %s from array!\n",
1277 partition_name(rdev->dev));
1278 kick_rdev_from_array(rdev);
1279 continue;
1280 }
1281 }
1282
1283 /*
1284 * Fix up changed device names ... but only if this disk has a
1285 * recent update time. Use faulty checksum ones too.
1286 */
1287 ITERATE_RDEV(mddev,rdev,tmp) {
1288 __u64 ev1, ev2, ev3;
1289 if (rdev->faulty) { /* REMOVEME */
1290 MD_BUG();
1291 goto abort;
1292 }
1293 ev1 = md_event(rdev->sb);
1294 ev2 = md_event(sb);
1295 ev3 = ev2;
1296 --ev3;
1297 if ((rdev->dev != rdev->old_dev) &&
1298 ((ev1 == ev2) || (ev1 == ev3))) {
1299 mdp_disk_t *desc;
1300
1301 printk("md: device name has changed from %s to %s since last import!\n", partition_name(rdev->old_dev), partition_name(rdev->dev));
1302 if (rdev->desc_nr == -1) {
1303 MD_BUG();
1304 goto abort;
1305 }
1306 desc = &sb->disks[rdev->desc_nr];
1307 if (rdev->old_dev != MKDEV(desc->major, desc->minor)) {
1308 MD_BUG();
1309 goto abort;
1310 }
1311 desc->major = MAJOR(rdev->dev);
1312 desc->minor = MINOR(rdev->dev);
1313 desc = &rdev->sb->this_disk;
1314 desc->major = MAJOR(rdev->dev);
1315 desc->minor = MINOR(rdev->dev);
1316 }
1317 }
1318
1319 /*
1320 * Remove unavailable and faulty devices ...
1321 *
1322 * note that if an array becomes completely unrunnable due to
1323 * missing devices, we do not write the superblock back, so the
1324 * administrator has a chance to fix things up. The removal thus
1325 * only happens if it's nonfatal to the contents of the array.
1326 */
1327 for (i = 0; i < MD_SB_DISKS; i++) {
1328 int found;
1329 mdp_disk_t *desc;
1330 kdev_t dev;
1331
1332 desc = sb->disks + i;
1333 dev = MKDEV(desc->major, desc->minor);
1334
1335 /*
1336 * We kick faulty devices/descriptors immediately.
1337 */
1338 if (disk_faulty(desc)) {
1339 found = 0;
1340 ITERATE_RDEV(mddev,rdev,tmp) {
1341 if (rdev->desc_nr != desc->number)
1342 continue;
1343 printk("md%d: kicking faulty %s!\n",
1344 mdidx(mddev),partition_name(rdev->dev));
1345 kick_rdev_from_array(rdev);
1346 found = 1;
1347 break;
1348 }
1349 if (!found) {
1350 if (dev == MKDEV(0,0))
1351 continue;
1352 printk("md%d: removing former faulty %s!\n",
1353 mdidx(mddev), partition_name(dev));
1354 }
1355 remove_descriptor(desc, sb);
1356 continue;
1357 }
1358
1359 if (dev == MKDEV(0,0))
1360 continue;
1361 /*
1362 * Is this device present in the rdev ring?
1363 */
1364 found = 0;
1365 ITERATE_RDEV(mddev,rdev,tmp) {
1366 if (rdev->desc_nr == desc->number) {
1367 found = 1;
1368 break;
1369 }
1370 }
1371 if (found)
1372 continue;
1373
1374 printk("md%d: former device %s is unavailable, removing from array!\n", mdidx(mddev), partition_name(dev));
1375 remove_descriptor(desc, sb);
1376 }
1377
1378 /*
1379 * Double check wether all devices mentioned in the
1380 * superblock are in the rdev ring.
1381 */
1382 for (i = 0; i < MD_SB_DISKS; i++) {
1383 mdp_disk_t *desc;
1384 kdev_t dev;
1385
1386 desc = sb->disks + i;
1387 dev = MKDEV(desc->major, desc->minor);
1388
1389 if (dev == MKDEV(0,0))
1390 continue;
1391
1392 if (disk_faulty(desc)) {
1393 MD_BUG();
1394 goto abort;
1395 }
1396
1397 rdev = find_rdev(mddev, dev);
1398 if (!rdev) {
1399 MD_BUG();
1400 goto abort;
1401 }
1402 }
1403
1404 /*
1405 * Do a final reality check.
1406 */
1407 ITERATE_RDEV(mddev,rdev,tmp) {
1408 if (rdev->desc_nr == -1) {
1409 MD_BUG();
1410 goto abort;
1411 }
1412 /*
1413 * is the desc_nr unique?
1414 */
1415 ITERATE_RDEV(mddev,rdev2,tmp2) {
1416 if ((rdev2 != rdev) &&
1417 (rdev2->desc_nr == rdev->desc_nr)) {
1418 MD_BUG();
1419 goto abort;
1420 }
1421 }
1422 /*
1423 * is the device unique?
1424 */
1425 ITERATE_RDEV(mddev,rdev2,tmp2) {
1426 if ((rdev2 != rdev) &&
1427 (rdev2->dev == rdev->dev)) {
1428 MD_BUG();
1429 goto abort;
1430 }
1431 }
1432 }
1433
1434 /*
1435 * Check if we can support this RAID array
1436 */
1437 if (sb->major_version != MD_MAJOR_VERSION ||
1438 sb->minor_version > MD_MINOR_VERSION) {
1439
1440 printk (OLD_VERSION, mdidx(mddev), sb->major_version,
1441 sb->minor_version, sb->patch_version);
1442 goto abort;
1443 }
1444
1445 if ((sb->state != (1 << MD_SB_CLEAN)) && ((sb->level == 1) ||
1446 (sb->level == 4) || (sb->level == 5)))
1447 printk (NOT_CLEAN_IGNORE, mdidx(mddev));
1448
1449 return 0;
1450 abort:
1451 return 1;
1452 }
1453
1454 #undef INCONSISTENT
1455 #undef OUT_OF_DATE
1456 #undef OLD_VERSION
1457 #undef OLD_LEVEL
1458
1459 static int device_size_calculation (mddev_t * mddev)
1460 {
1461 int data_disks = 0, persistent;
1462 unsigned int readahead;
1463 mdp_super_t *sb = mddev->sb;
1464 struct md_list_head *tmp;
1465 mdk_rdev_t *rdev;
1466
1467 /*
1468 * Do device size calculation. Bail out if too small.
1469 * (we have to do this after having validated chunk_size,
1470 * because device size has to be modulo chunk_size)
1471 */
1472 persistent = !mddev->sb->not_persistent;
1473 ITERATE_RDEV(mddev,rdev,tmp) {
1474 if (rdev->faulty)
1475 continue;
1476 if (rdev->size) {
1477 MD_BUG();
1478 continue;
1479 }
1480 rdev->size = calc_dev_size(rdev->dev, mddev, persistent);
1481 if (rdev->size < sb->chunk_size / 1024) {
1482 printk (KERN_WARNING
1483 "Dev %s smaller than chunk_size: %ldk < %dk\n",
1484 partition_name(rdev->dev),
1485 rdev->size, sb->chunk_size / 1024);
1486 return -EINVAL;
1487 }
1488 }
1489
1490 switch (sb->level) {
1491 case -3:
1492 data_disks = 1;
1493 break;
1494 case -2:
1495 data_disks = 1;
1496 break;
1497 case -1:
1498 zoned_raid_size(mddev);
1499 data_disks = 1;
1500 break;
1501 case 0:
1502 zoned_raid_size(mddev);
1503 data_disks = sb->raid_disks;
1504 break;
1505 case 1:
1506 data_disks = 1;
1507 break;
1508 case 4:
1509 case 5:
1510 data_disks = sb->raid_disks-1;
1511 break;
1512 default:
1513 printk (UNKNOWN_LEVEL, mdidx(mddev), sb->level);
1514 goto abort;
1515 }
1516 if (!md_size[mdidx(mddev)])
1517 md_size[mdidx(mddev)] = sb->size * data_disks;
1518
1519 readahead = MD_READAHEAD;
1520 if ((sb->level == 0) || (sb->level == 4) || (sb->level == 5)) {
1521 readahead = (mddev->sb->chunk_size>>PAGE_SHIFT) * 4 * data_disks;
1522 if (readahead < data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2)
1523 readahead = data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2;
1524 } else {
1525 if (sb->level == -3)
1526 readahead = 0;
1527 }
1528 md_maxreadahead[mdidx(mddev)] = readahead;
1529
1530 printk(KERN_INFO "md%d: max total readahead window set to %ldk\n",
1531 mdidx(mddev), readahead*(PAGE_SIZE/1024));
1532
1533 printk(KERN_INFO
1534 "md%d: %d data-disks, max readahead per data-disk: %ldk\n",
1535 mdidx(mddev), data_disks, readahead/data_disks*(PAGE_SIZE/1024));
1536 return 0;
1537 abort:
1538 return 1;
1539 }
1540
1541
1542 #define TOO_BIG_CHUNKSIZE KERN_ERR \
1543 "too big chunk_size: %d > %d\n"
1544
1545 #define TOO_SMALL_CHUNKSIZE KERN_ERR \
1546 "too small chunk_size: %d < %ld\n"
1547
1548 #define BAD_CHUNKSIZE KERN_ERR \
1549 "no chunksize specified, see 'man raidtab'\n"
1550
1551 static int do_md_run (mddev_t * mddev)
1552 {
1553 int pnum, err;
1554 int chunk_size;
1555 struct md_list_head *tmp;
1556 mdk_rdev_t *rdev;
1557
1558
1559 if (!mddev->nb_dev) {
1560 MD_BUG();
1561 return -EINVAL;
1562 }
1563
1564 if (mddev->pers)
1565 return -EBUSY;
1566
1567 /*
1568 * Resize disks to align partitions size on a given
1569 * chunk size.
1570 */
1571 md_size[mdidx(mddev)] = 0;
1572
1573 /*
1574 * Analyze all RAID superblock(s)
1575 */
1576 if (analyze_sbs(mddev)) {
1577 MD_BUG();
1578 return -EINVAL;
1579 }
1580
1581 chunk_size = mddev->sb->chunk_size;
1582 pnum = level_to_pers(mddev->sb->level);
1583
1584 mddev->param.chunk_size = chunk_size;
1585 mddev->param.personality = pnum;
1586
1587 if (chunk_size > MAX_CHUNK_SIZE) {
1588 printk(TOO_BIG_CHUNKSIZE, chunk_size, MAX_CHUNK_SIZE);
1589 return -EINVAL;
1590 }
1591 /*
1592 * chunk-size has to be a power of 2 and multiples of PAGE_SIZE
1593 */
1594 if ( (1 << ffz(~chunk_size)) != chunk_size) {
1595 MD_BUG();
1596 return -EINVAL;
1597 }
1598 if (chunk_size < PAGE_SIZE) {
1599 printk(TOO_SMALL_CHUNKSIZE, chunk_size, PAGE_SIZE);
1600 return -EINVAL;
1601 }
1602
1603 if (pnum >= MAX_PERSONALITY) {
1604 MD_BUG();
1605 return -EINVAL;
1606 }
1607
1608 if ((pnum != RAID1) && (pnum != LINEAR) && !chunk_size) {
1609 /*
1610 * 'default chunksize' in the old md code used to
1611 * be PAGE_SIZE, baaad.
1612 * we abort here to be on the safe side. We dont
1613 * want to continue the bad practice.
1614 */
1615 printk(BAD_CHUNKSIZE);
1616 return -EINVAL;
1617 }
1618
1619 if (!pers[pnum])
1620 {
1621 #ifdef CONFIG_KMOD
1622 char module_name[80];
1623 sprintf (module_name, "md-personality-%d", pnum);
1624 request_module (module_name);
1625 if (!pers[pnum])
1626 #endif
1627 return -EINVAL;
1628 }
1629
1630 if (device_size_calculation(mddev))
1631 return -EINVAL;
1632
1633 /*
1634 * Drop all container device buffers, from now on
1635 * the only valid external interface is through the md
1636 * device.
1637 * Also find largest hardsector size
1638 */
1639 md_hardsect_sizes[mdidx(mddev)] = 512;
1640 ITERATE_RDEV(mddev,rdev,tmp) {
1641 if (rdev->faulty)
1642 continue;
1643 fsync_dev(rdev->dev);
1644 invalidate_buffers(rdev->dev);
1645 if (get_hardsect_size(rdev->dev)
1646 > md_hardsect_sizes[mdidx(mddev)])
1647 md_hardsect_sizes[mdidx(mddev)] =
1648 get_hardsect_size(rdev->dev);
1649 }
1650 md_blocksizes[mdidx(mddev)] = 1024;
1651 if (md_blocksizes[mdidx(mddev)] < md_hardsect_sizes[mdidx(mddev)])
1652 md_blocksizes[mdidx(mddev)] = md_hardsect_sizes[mdidx(mddev)];
1653 mddev->pers = pers[pnum];
1654
1655 err = mddev->pers->run(mddev);
1656 if (err) {
1657 printk("pers->run() failed ...\n");
1658 mddev->pers = NULL;
1659 return -EINVAL;
1660 }
1661
1662 mddev->sb->state &= ~(1 << MD_SB_CLEAN);
1663 md_update_sb(mddev);
1664
1665 /*
1666 * md_size has units of 1K blocks, which are
1667 * twice as large as sectors.
1668 */
1669 md_hd_struct[mdidx(mddev)].start_sect = 0;
1670 md_hd_struct[mdidx(mddev)].nr_sects = md_size[mdidx(mddev)] << 1;
1671
1672 read_ahead[MD_MAJOR] = 1024;
1673 return (0);
1674 }
1675
1676 #undef TOO_BIG_CHUNKSIZE
1677 #undef BAD_CHUNKSIZE
1678
1679 #define OUT(x) do { err = (x); goto out; } while (0)
1680
1681 static int restart_array (mddev_t *mddev)
1682 {
1683 int err = 0;
1684
1685 /*
1686 * Complain if it has no devices
1687 */
1688 if (!mddev->nb_dev)
1689 OUT(-ENXIO);
1690
1691 if (mddev->pers) {
1692 if (!mddev->ro)
1693 OUT(-EBUSY);
1694
1695 mddev->ro = 0;
1696 set_device_ro(mddev_to_kdev(mddev), 0);
1697
1698 printk (KERN_INFO
1699 "md%d switched to read-write mode.\n", mdidx(mddev));
1700 /*
1701 * Kick recovery or resync if necessary
1702 */
1703 md_recover_arrays();
1704 if (mddev->pers->restart_resync)
1705 mddev->pers->restart_resync(mddev);
1706 } else
1707 err = -EINVAL;
1708
1709 out:
1710 return err;
1711 }
1712
1713 #define STILL_MOUNTED KERN_WARNING \
1714 "md: md%d still mounted.\n"
1715 #define STILL_IN_USE \
1716 "md: md%d still in use.\n"
1717
1718 static int do_md_stop (mddev_t * mddev, int ro)
1719 {
1720 int err = 0, resync_interrupted = 0;
1721 kdev_t dev = mddev_to_kdev(mddev);
1722
1723 if (atomic_read(&mddev->active)>1) {
1724 printk(STILL_IN_USE, mdidx(mddev));
1725 OUT(-EBUSY);
1726 }
1727
1728 /* this shouldn't be needed as above would have fired */
1729 if (!ro && get_super(dev)) {
1730 printk (STILL_MOUNTED, mdidx(mddev));
1731 OUT(-EBUSY);
1732 }
1733
1734 if (mddev->pers) {
1735 /*
1736 * It is safe to call stop here, it only frees private
1737 * data. Also, it tells us if a device is unstoppable
1738 * (eg. resyncing is in progress)
1739 */
1740 if (mddev->pers->stop_resync)
1741 if (mddev->pers->stop_resync(mddev))
1742 resync_interrupted = 1;
1743
1744 if (mddev->recovery_running)
1745 md_interrupt_thread(md_recovery_thread);
1746
1747 /*
1748 * This synchronizes with signal delivery to the
1749 * resync or reconstruction thread. It also nicely
1750 * hangs the process if some reconstruction has not
1751 * finished.
1752 */
1753 down(&mddev->recovery_sem);
1754 up(&mddev->recovery_sem);
1755
1756 /*
1757 * sync and invalidate buffers because we cannot kill the
1758 * main thread with valid IO transfers still around.
1759 * the kernel lock protects us from new requests being
1760 * added after invalidate_buffers().
1761 */
1762 fsync_dev (mddev_to_kdev(mddev));
1763 fsync_dev (dev);
1764 invalidate_buffers (dev);
1765
1766 if (ro) {
1767 if (mddev->ro)
1768 OUT(-ENXIO);
1769 mddev->ro = 1;
1770 } else {
1771 if (mddev->ro)
1772 set_device_ro(dev, 0);
1773 if (mddev->pers->stop(mddev)) {
1774 if (mddev->ro)
1775 set_device_ro(dev, 1);
1776 OUT(-EBUSY);
1777 }
1778 if (mddev->ro)
1779 mddev->ro = 0;
1780 }
1781 if (mddev->sb) {
1782 /*
1783 * mark it clean only if there was no resync
1784 * interrupted.
1785 */
1786 if (!mddev->recovery_running && !resync_interrupted) {
1787 printk("marking sb clean...\n");
1788 mddev->sb->state |= 1 << MD_SB_CLEAN;
1789 }
1790 md_update_sb(mddev);
1791 }
1792 if (ro)
1793 set_device_ro(dev, 1);
1794 }
1795
1796 /*
1797 * Free resources if final stop
1798 */
1799 if (!ro) {
1800 printk (KERN_INFO "md%d stopped.\n", mdidx(mddev));
1801 free_mddev(mddev);
1802
1803 } else
1804 printk (KERN_INFO
1805 "md%d switched to read-only mode.\n", mdidx(mddev));
1806 out:
1807 return err;
1808 }
1809
1810 #undef OUT
1811
1812 /*
1813 * We have to safely support old arrays too.
1814 */
1815 int detect_old_array (mdp_super_t *sb)
1816 {
1817 if (sb->major_version > 0)
1818 return 0;
1819 if (sb->minor_version >= 90)
1820 return 0;
1821
1822 return -EINVAL;
1823 }
1824
1825
1826 static void autorun_array (mddev_t *mddev)
1827 {
1828 mdk_rdev_t *rdev;
1829 struct md_list_head *tmp;
1830 int err;
1831
1832 if (mddev->disks.prev == &mddev->disks) {
1833 MD_BUG();
1834 return;
1835 }
1836
1837 printk("running: ");
1838
1839 ITERATE_RDEV(mddev,rdev,tmp) {
1840 printk("<%s>", partition_name(rdev->dev));
1841 }
1842 printk("\nnow!\n");
1843
1844 err = do_md_run (mddev);
1845 if (err) {
1846 printk("do_md_run() returned %d\n", err);
1847 /*
1848 * prevent the writeback of an unrunnable array
1849 */
1850 mddev->sb_dirty = 0;
1851 do_md_stop (mddev, 0);
1852 }
1853 }
1854
1855 /*
1856 * lets try to run arrays based on all disks that have arrived
1857 * until now. (those are in the ->pending list)
1858 *
1859 * the method: pick the first pending disk, collect all disks with
1860 * the same UUID, remove all from the pending list and put them into
1861 * the 'same_array' list. Then order this list based on superblock
1862 * update time (freshest comes first), kick out 'old' disks and
1863 * compare superblocks. If everything's fine then run it.
1864 *
1865 * If "unit" is allocated, then bump its reference count
1866 */
1867 static void autorun_devices (kdev_t countdev)
1868 {
1869 struct md_list_head candidates;
1870 struct md_list_head *tmp;
1871 mdk_rdev_t *rdev0, *rdev;
1872 mddev_t *mddev;
1873 kdev_t md_kdev;
1874
1875
1876 printk("autorun ...\n");
1877 while (pending_raid_disks.next != &pending_raid_disks) {
1878 rdev0 = md_list_entry(pending_raid_disks.next,
1879 mdk_rdev_t, pending);
1880
1881 printk("considering %s ...\n", partition_name(rdev0->dev));
1882 MD_INIT_LIST_HEAD(&candidates);
1883 ITERATE_RDEV_PENDING(rdev,tmp) {
1884 if (uuid_equal(rdev0, rdev)) {
1885 if (!sb_equal(rdev0->sb, rdev->sb)) {
1886 printk("%s has same UUID as %s, but superblocks differ ...\n", partition_name(rdev->dev), partition_name(rdev0->dev));
1887 continue;
1888 }
1889 printk(" adding %s ...\n", partition_name(rdev->dev));
1890 md_list_del(&rdev->pending);
1891 md_list_add(&rdev->pending, &candidates);
1892 }
1893 }
1894 /*
1895 * now we have a set of devices, with all of them having
1896 * mostly sane superblocks. It's time to allocate the
1897 * mddev.
1898 */
1899 md_kdev = MKDEV(MD_MAJOR, rdev0->sb->md_minor);
1900 mddev = kdev_to_mddev(md_kdev);
1901 if (mddev) {
1902 printk("md%d already running, cannot run %s\n",
1903 mdidx(mddev), partition_name(rdev0->dev));
1904 ITERATE_RDEV_GENERIC(candidates,pending,rdev,tmp)
1905 export_rdev(rdev);
1906 continue;
1907 }
1908 mddev = alloc_mddev(md_kdev);
1909 if (mddev == NULL) {
1910 printk("md: cannot allocate memory for md drive.\n");
1911 break;
1912 }
1913 if (md_kdev == countdev)
1914 atomic_inc(&mddev->active);
1915 printk("created md%d\n", mdidx(mddev));
1916 ITERATE_RDEV_GENERIC(candidates,pending,rdev,tmp) {
1917 bind_rdev_to_array(rdev, mddev);
1918 md_list_del(&rdev->pending);
1919 MD_INIT_LIST_HEAD(&rdev->pending);
1920 }
1921 autorun_array(mddev);
1922 }
1923 printk("... autorun DONE.\n");
1924 }
1925
1926 /*
1927 * import RAID devices based on one partition
1928 * if possible, the array gets run as well.
1929 */
1930
1931 #define BAD_VERSION KERN_ERR \
1932 "md: %s has RAID superblock version 0.%d, autodetect needs v0.90 or higher\n"
1933
1934 #define OUT_OF_MEM KERN_ALERT \
1935 "md: out of memory.\n"
1936
1937 #define NO_DEVICE KERN_ERR \
1938 "md: disabled device %s\n"
1939
1940 #define AUTOADD_FAILED KERN_ERR \
1941 "md: auto-adding devices to md%d FAILED (error %d).\n"
1942
1943 #define AUTOADD_FAILED_USED KERN_ERR \
1944 "md: cannot auto-add device %s to md%d, already used.\n"
1945
1946 #define AUTORUN_FAILED KERN_ERR \
1947 "md: auto-running md%d FAILED (error %d).\n"
1948
1949 #define MDDEV_BUSY KERN_ERR \
1950 "md: cannot auto-add to md%d, already running.\n"
1951
1952 #define AUTOADDING KERN_INFO \
1953 "md: auto-adding devices to md%d, based on %s's superblock.\n"
1954
1955 #define AUTORUNNING KERN_INFO \
1956 "md: auto-running md%d.\n"
1957
1958 static int autostart_array (kdev_t startdev, kdev_t countdev)
1959 {
1960 int err = -EINVAL, i;
1961 mdp_super_t *sb = NULL;
1962 mdk_rdev_t *start_rdev = NULL, *rdev;
1963
1964 if (md_import_device(startdev, 1)) {
1965 printk("could not import %s!\n", partition_name(startdev));
1966 goto abort;
1967 }
1968
1969 start_rdev = find_rdev_all(startdev);
1970 if (!start_rdev) {
1971 MD_BUG();
1972 goto abort;
1973 }
1974 if (start_rdev->faulty) {
1975 printk("can not autostart based on faulty %s!\n",
1976 partition_name(startdev));
1977 goto abort;
1978 }
1979 md_list_add(&start_rdev->pending, &pending_raid_disks);
1980
1981 sb = start_rdev->sb;
1982
1983 err = detect_old_array(sb);
1984 if (err) {
1985 printk("array version is too old to be autostarted, use raidtools 0.90 mkraid --upgrade\nto upgrade the array without data loss!\n");
1986 goto abort;
1987 }
1988
1989 for (i = 0; i < MD_SB_DISKS; i++) {
1990 mdp_disk_t *desc;
1991 kdev_t dev;
1992
1993 desc = sb->disks + i;
1994 dev = MKDEV(desc->major, desc->minor);
1995
1996 if (dev == MKDEV(0,0))
1997 continue;
1998 if (dev == startdev)
1999 continue;
2000 if (md_import_device(dev, 1)) {
2001 printk("could not import %s, trying to run array nevertheless.\n", partition_name(dev));
2002 continue;
2003 }
2004 rdev = find_rdev_all(dev);
2005 if (!rdev) {
2006 MD_BUG();
2007 goto abort;
2008 }
2009 md_list_add(&rdev->pending, &pending_raid_disks);
2010 }
2011
2012 /*
2013 * possibly return codes
2014 */
2015 autorun_devices(countdev);
2016 return 0;
2017
2018 abort:
2019 if (start_rdev)
2020 export_rdev(start_rdev);
2021 return err;
2022 }
2023
2024 #undef BAD_VERSION
2025 #undef OUT_OF_MEM
2026 #undef NO_DEVICE
2027 #undef AUTOADD_FAILED_USED
2028 #undef AUTOADD_FAILED
2029 #undef AUTORUN_FAILED
2030 #undef AUTOADDING
2031 #undef AUTORUNNING
2032
2033 struct {
2034 int set;
2035 int noautodetect;
2036 } raid_setup_args md__initdata;
2037
2038 void md_setup_drive (void) md__init;
2039
2040 /*
2041 * Searches all registered partitions for autorun RAID arrays
2042 * at boot time.
2043 */
2044 static int detected_devices[128] md__initdata;
2045 static int dev_cnt;
2046
2047 void md_autodetect_dev(kdev_t dev)
2048 {
2049 if (dev_cnt >= 0 && dev_cnt < 127)
2050 detected_devices[dev_cnt++] = dev;
2051 }
2052
2053
2054 static void autostart_arrays (void)
2055 {
2056 mdk_rdev_t *rdev;
2057 int i;
2058
2059 printk(KERN_INFO "autodetecting RAID arrays\n");
2060
2061 for (i=0; i<dev_cnt; i++) {
2062 kdev_t dev = detected_devices[i];
2063
2064 if (md_import_device(dev,1)) {
2065 printk(KERN_ALERT "could not import %s!\n",
2066 partition_name(dev));
2067 continue;
2068 }
2069 /*
2070 * Sanity checks:
2071 */
2072 rdev = find_rdev_all(dev);
2073 if (!rdev) {
2074 MD_BUG();
2075 continue;
2076 }
2077 if (rdev->faulty) {
2078 MD_BUG();
2079 continue;
2080 }
2081 md_list_add(&rdev->pending, &pending_raid_disks);
2082 }
2083
2084 autorun_devices(-1);
2085 }
2086
2087 int md__init md_run_setup(void)
2088 {
2089 if (raid_setup_args.noautodetect)
2090 printk(KERN_INFO "skipping autodetection of RAID arrays\n");
2091 else
2092 autostart_arrays();
2093 dev_cnt = -1; /* make sure further calls to md_autodetect_dev are ignored */
2094 md_setup_drive();
2095 return 0;
2096 }
2097
2098 static int get_version (void * arg)
2099 {
2100 mdu_version_t ver;
2101
2102 ver.major = MD_MAJOR_VERSION;
2103 ver.minor = MD_MINOR_VERSION;
2104 ver.patchlevel = MD_PATCHLEVEL_VERSION;
2105
2106 if (md_copy_to_user(arg, &ver, sizeof(ver)))
2107 return -EFAULT;
2108
2109 return 0;
2110 }
2111
2112 #define SET_FROM_SB(x) info.x = mddev->sb->x
2113 static int get_array_info (mddev_t * mddev, void * arg)
2114 {
2115 mdu_array_info_t info;
2116
2117 if (!mddev->sb)
2118 return -EINVAL;
2119
2120 SET_FROM_SB(major_version);
2121 SET_FROM_SB(minor_version);
2122 SET_FROM_SB(patch_version);
2123 SET_FROM_SB(ctime);
2124 SET_FROM_SB(level);
2125 SET_FROM_SB(size);
2126 SET_FROM_SB(nr_disks);
2127 SET_FROM_SB(raid_disks);
2128 SET_FROM_SB(md_minor);
2129 SET_FROM_SB(not_persistent);
2130
2131 SET_FROM_SB(utime);
2132 SET_FROM_SB(state);
2133 SET_FROM_SB(active_disks);
2134 SET_FROM_SB(working_disks);
2135 SET_FROM_SB(failed_disks);
2136 SET_FROM_SB(spare_disks);
2137
2138 SET_FROM_SB(layout);
2139 SET_FROM_SB(chunk_size);
2140
2141 if (md_copy_to_user(arg, &info, sizeof(info)))
2142 return -EFAULT;
2143
2144 return 0;
2145 }
2146 #undef SET_FROM_SB
2147
2148 #define SET_FROM_SB(x) info.x = mddev->sb->disks[nr].x
2149 static int get_disk_info (mddev_t * mddev, void * arg)
2150 {
2151 mdu_disk_info_t info;
2152 unsigned int nr;
2153
2154 if (!mddev->sb)
2155 return -EINVAL;
2156
2157 if (md_copy_from_user(&info, arg, sizeof(info)))
2158 return -EFAULT;
2159
2160 nr = info.number;
2161 if (nr >= mddev->sb->nr_disks)
2162 return -EINVAL;
2163
2164 SET_FROM_SB(major);
2165 SET_FROM_SB(minor);
2166 SET_FROM_SB(raid_disk);
2167 SET_FROM_SB(state);
2168
2169 if (md_copy_to_user(arg, &info, sizeof(info)))
2170 return -EFAULT;
2171
2172 return 0;
2173 }
2174 #undef SET_FROM_SB
2175
2176 #define SET_SB(x) mddev->sb->disks[nr].x = info->x
2177
2178 static int add_new_disk (mddev_t * mddev, mdu_disk_info_t *info)
2179 {
2180 int err, size, persistent;
2181 mdk_rdev_t *rdev;
2182 unsigned int nr;
2183 kdev_t dev;
2184 dev = MKDEV(info->major,info->minor);
2185
2186 if (find_rdev_all(dev)) {
2187 printk("device %s already used in a RAID array!\n",
2188 partition_name(dev));
2189 return -EBUSY;
2190 }
2191 if (!mddev->sb) {
2192 /* expecting a device which has a superblock */
2193 err = md_import_device(dev, 1);
2194 if (err) {
2195 printk("md error, md_import_device returned %d\n", err);
2196 return -EINVAL;
2197 }
2198 rdev = find_rdev_all(dev);
2199 if (!rdev) {
2200 MD_BUG();
2201 return -EINVAL;
2202 }
2203 if (mddev->nb_dev) {
2204 mdk_rdev_t *rdev0 = md_list_entry(mddev->disks.next,
2205 mdk_rdev_t, same_set);
2206 if (!uuid_equal(rdev0, rdev)) {
2207 printk("md: %s has different UUID to %s\n", partition_name(rdev->dev), partition_name(rdev0->dev));
2208 export_rdev(rdev);
2209 return -EINVAL;
2210 }
2211 if (!sb_equal(rdev0->sb, rdev->sb)) {
2212 printk("md: %s has same UUID but different superblock to %s\n", partition_name(rdev->dev), partition_name(rdev0->dev));
2213 export_rdev(rdev);
2214 return -EINVAL;
2215 }
2216 }
2217 bind_rdev_to_array(rdev, mddev);
2218 return 0;
2219 }
2220
2221 nr = info->number;
2222 if (nr >= mddev->sb->nr_disks)
2223 return -EINVAL;
2224
2225 SET_SB(number);
2226 SET_SB(major);
2227 SET_SB(minor);
2228 SET_SB(raid_disk);
2229 SET_SB(state);
2230
2231 if ((info->state & (1<<MD_DISK_FAULTY))==0) {
2232 err = md_import_device (dev, 0);
2233 if (err) {
2234 printk("md: error, md_import_device() returned %d\n", err);
2235 return -EINVAL;
2236 }
2237 rdev = find_rdev_all(dev);
2238 if (!rdev) {
2239 MD_BUG();
2240 return -EINVAL;
2241 }
2242
2243 rdev->old_dev = dev;
2244 rdev->desc_nr = info->number;
2245
2246 bind_rdev_to_array(rdev, mddev);
2247
2248 persistent = !mddev->sb->not_persistent;
2249 if (!persistent)
2250 printk("nonpersistent superblock ...\n");
2251 if (!mddev->sb->chunk_size)
2252 printk("no chunksize?\n");
2253
2254 size = calc_dev_size(dev, mddev, persistent);
2255 rdev->sb_offset = calc_dev_sboffset(dev, mddev, persistent);
2256
2257 if (!mddev->sb->size || (mddev->sb->size > size))
2258 mddev->sb->size = size;
2259 }
2260
2261 /*
2262 * sync all other superblocks with the main superblock
2263 */
2264 sync_sbs(mddev);
2265
2266 return 0;
2267 }
2268 #undef SET_SB
2269
2270 static int hot_remove_disk (mddev_t * mddev, kdev_t dev)
2271 {
2272 int err;
2273 mdk_rdev_t *rdev;
2274 mdp_disk_t *disk;
2275
2276 if (!mddev->pers)
2277 return -ENODEV;
2278
2279 printk("trying to remove %s from md%d ... \n",
2280 partition_name(dev), mdidx(mddev));
2281
2282 if (!mddev->pers->diskop) {
2283 printk("md%d: personality does not support diskops!\n",
2284 mdidx(mddev));
2285 return -EINVAL;
2286 }
2287
2288 rdev = find_rdev(mddev, dev);
2289 if (!rdev)
2290 return -ENXIO;
2291
2292 if (rdev->desc_nr == -1) {
2293 MD_BUG();
2294 return -EINVAL;
2295 }
2296 disk = &mddev->sb->disks[rdev->desc_nr];
2297 if (disk_active(disk))
2298 goto busy;
2299 if (disk_removed(disk)) {
2300 MD_BUG();
2301 return -EINVAL;
2302 }
2303
2304 err = mddev->pers->diskop(mddev, &disk, DISKOP_HOT_REMOVE_DISK);
2305 if (err == -EBUSY)
2306 goto busy;
2307 if (err) {
2308 MD_BUG();
2309 return -EINVAL;
2310 }
2311
2312 remove_descriptor(disk, mddev->sb);
2313 kick_rdev_from_array(rdev);
2314 mddev->sb_dirty = 1;
2315 md_update_sb(mddev);
2316
2317 return 0;
2318 busy:
2319 printk("cannot remove active disk %s from md%d ... \n",
2320 partition_name(dev), mdidx(mddev));
2321 return -EBUSY;
2322 }
2323
2324 static int hot_add_disk (mddev_t * mddev, kdev_t dev)
2325 {
2326 int i, err, persistent;
2327 unsigned int size;
2328 mdk_rdev_t *rdev;
2329 mdp_disk_t *disk;
2330
2331 if (!mddev->pers)
2332 return -ENODEV;
2333
2334 printk("trying to hot-add %s to md%d ... \n",
2335 partition_name(dev), mdidx(mddev));
2336
2337 if (!mddev->pers->diskop) {
2338 printk("md%d: personality does not support diskops!\n",
2339 mdidx(mddev));
2340 return -EINVAL;
2341 }
2342
2343 persistent = !mddev->sb->not_persistent;
2344 size = calc_dev_size(dev, mddev, persistent);
2345
2346 if (size < mddev->sb->size) {
2347 printk("md%d: disk size %d blocks < array size %d\n",
2348 mdidx(mddev), size, mddev->sb->size);
2349 return -ENOSPC;
2350 }
2351
2352 rdev = find_rdev(mddev, dev);
2353 if (rdev)
2354 return -EBUSY;
2355
2356 err = md_import_device (dev, 0);
2357 if (err) {
2358 printk("md: error, md_import_device() returned %d\n", err);
2359 return -EINVAL;
2360 }
2361 rdev = find_rdev_all(dev);
2362 if (!rdev) {
2363 MD_BUG();
2364 return -EINVAL;
2365 }
2366 if (rdev->faulty) {
2367 printk("md: can not hot-add faulty %s disk to md%d!\n",
2368 partition_name(dev), mdidx(mddev));
2369 err = -EINVAL;
2370 goto abort_export;
2371 }
2372 bind_rdev_to_array(rdev, mddev);
2373
2374 /*
2375 * The rest should better be atomic, we can have disk failures
2376 * noticed in interrupt contexts ...
2377 */
2378 rdev->old_dev = dev;
2379 rdev->size = size;
2380 rdev->sb_offset = calc_dev_sboffset(dev, mddev, persistent);
2381
2382 disk = mddev->sb->disks + mddev->sb->raid_disks;
2383 for (i = mddev->sb->raid_disks; i < MD_SB_DISKS; i++) {
2384 disk = mddev->sb->disks + i;
2385
2386 if (!disk->major && !disk->minor)
2387 break;
2388 if (disk_removed(disk))
2389 break;
2390 }
2391 if (i == MD_SB_DISKS) {
2392 printk("md%d: can not hot-add to full array!\n", mdidx(mddev));
2393 err = -EBUSY;
2394 goto abort_unbind_export;
2395 }
2396
2397 if (disk_removed(disk)) {
2398 /*
2399 * reuse slot
2400 */
2401 if (disk->number != i) {
2402 MD_BUG();
2403 err = -EINVAL;
2404 goto abort_unbind_export;
2405 }
2406 } else {
2407 disk->number = i;
2408 }
2409
2410 disk->raid_disk = disk->number;
2411 disk->major = MAJOR(dev);
2412 disk->minor = MINOR(dev);
2413
2414 if (mddev->pers->diskop(mddev, &disk, DISKOP_HOT_ADD_DISK)) {
2415 MD_BUG();
2416 err = -EINVAL;
2417 goto abort_unbind_export;
2418 }
2419
2420 mark_disk_spare(disk);
2421 mddev->sb->nr_disks++;
2422 mddev->sb->spare_disks++;
2423 mddev->sb->working_disks++;
2424
2425 mddev->sb_dirty = 1;
2426
2427 md_update_sb(mddev);
2428
2429 /*
2430 * Kick recovery, maybe this spare has to be added to the
2431 * array immediately.
2432 */
2433 md_recover_arrays();
2434
2435 return 0;
2436
2437 abort_unbind_export:
2438 unbind_rdev_from_array(rdev);
2439
2440 abort_export:
2441 export_rdev(rdev);
2442 return err;
2443 }
2444
2445 #define SET_SB(x) mddev->sb->x = info->x
2446 static int set_array_info (mddev_t * mddev, mdu_array_info_t *info)
2447 {
2448
2449 if (alloc_array_sb(mddev))
2450 return -ENOMEM;
2451
2452 mddev->sb->major_version = MD_MAJOR_VERSION;
2453 mddev->sb->minor_version = MD_MINOR_VERSION;
2454 mddev->sb->patch_version = MD_PATCHLEVEL_VERSION;
2455 mddev->sb->ctime = CURRENT_TIME;
2456
2457 SET_SB(level);
2458 SET_SB(size);
2459 SET_SB(nr_disks);
2460 SET_SB(raid_disks);
2461 SET_SB(md_minor);
2462 SET_SB(not_persistent);
2463
2464 SET_SB(state);
2465 SET_SB(active_disks);
2466 SET_SB(working_disks);
2467 SET_SB(failed_disks);
2468 SET_SB(spare_disks);
2469
2470 SET_SB(layout);
2471 SET_SB(chunk_size);
2472
2473 mddev->sb->md_magic = MD_SB_MAGIC;
2474
2475 /*
2476 * Generate a 128 bit UUID
2477 */
2478 get_random_bytes(&mddev->sb->set_uuid0, 4);
2479 get_random_bytes(&mddev->sb->set_uuid1, 4);
2480 get_random_bytes(&mddev->sb->set_uuid2, 4);
2481 get_random_bytes(&mddev->sb->set_uuid3, 4);
2482
2483 return 0;
2484 }
2485 #undef SET_SB
2486
2487 static int set_disk_info (mddev_t * mddev, void * arg)
2488 {
2489 printk("not yet");
2490 return -EINVAL;
2491 }
2492
2493 static int clear_array (mddev_t * mddev)
2494 {
2495 printk("not yet");
2496 return -EINVAL;
2497 }
2498
2499 static int write_raid_info (mddev_t * mddev)
2500 {
2501 printk("not yet");
2502 return -EINVAL;
2503 }
2504
2505 static int protect_array (mddev_t * mddev)
2506 {
2507 printk("not yet");
2508 return -EINVAL;
2509 }
2510
2511 static int unprotect_array (mddev_t * mddev)
2512 {
2513 printk("not yet");
2514 return -EINVAL;
2515 }
2516
2517 static int set_disk_faulty (mddev_t *mddev, kdev_t dev)
2518 {
2519 int ret;
2520
2521 fsync_dev(mddev_to_kdev(mddev));
2522 ret = md_error(mddev_to_kdev(mddev), dev);
2523 return ret;
2524 }
2525
2526 static int md_ioctl (struct inode *inode, struct file *file,
2527 unsigned int cmd, unsigned long arg)
2528 {
2529 unsigned int minor;
2530 int err = 0;
2531 struct hd_geometry *loc = (struct hd_geometry *) arg;
2532 mddev_t *mddev = NULL;
2533 kdev_t dev;
2534
2535 if (!md_capable_admin())
2536 return -EACCES;
2537
2538 dev = inode->i_rdev;
2539 minor = MINOR(dev);
2540 if (minor >= MAX_MD_DEVS)
2541 return -EINVAL;
2542
2543 /*
2544 * Commands dealing with the RAID driver but not any
2545 * particular array:
2546 */
2547 switch (cmd)
2548 {
2549 case RAID_VERSION:
2550 err = get_version((void *)arg);
2551 goto done;
2552
2553 case PRINT_RAID_DEBUG:
2554 err = 0;
2555 md_print_devices();
2556 goto done_unlock;
2557
2558 case RAID_AUTORUN:
2559 err = 0;
2560 autostart_arrays();
2561 goto done;
2562
2563 case BLKGETSIZE: /* Return device size */
2564 if (!arg) {
2565 err = -EINVAL;
2566 goto abort;
2567 }
2568 err = md_put_user(md_hd_struct[minor].nr_sects,
2569 (long *) arg);
2570 goto done;
2571
2572 case BLKFLSBUF:
2573 fsync_dev(dev);
2574 invalidate_buffers(dev);
2575 goto done;
2576
2577 case BLKRASET:
2578 if (arg > 0xff) {
2579 err = -EINVAL;
2580 goto abort;
2581 }
2582 read_ahead[MAJOR(dev)] = arg;
2583 goto done;
2584
2585 case BLKRAGET:
2586 if (!arg) {
2587 err = -EINVAL;
2588 goto abort;
2589 }
2590 err = md_put_user (read_ahead[
2591 MAJOR(dev)], (long *) arg);
2592 goto done;
2593 default:
2594 }
2595
2596 /*
2597 * Commands creating/starting a new array:
2598 */
2599
2600 mddev = kdev_to_mddev(dev);
2601
2602 switch (cmd)
2603 {
2604 case SET_ARRAY_INFO:
2605 case START_ARRAY:
2606 if (mddev) {
2607 printk("array md%d already exists!\n",
2608 mdidx(mddev));
2609 err = -EEXIST;
2610 goto abort;
2611 }
2612 default:
2613 }
2614 switch (cmd)
2615 {
2616 case SET_ARRAY_INFO:
2617 mddev = alloc_mddev(dev);
2618 if (!mddev) {
2619 err = -ENOMEM;
2620 goto abort;
2621 }
2622 atomic_inc(&mddev->active);
2623
2624 /*
2625 * alloc_mddev() should possibly self-lock.
2626 */
2627 err = lock_mddev(mddev);
2628 if (err) {
2629 printk("ioctl, reason %d, cmd %d\n", err, cmd);
2630 goto abort;
2631 }
2632
2633 if (mddev->sb) {
2634 printk("array md%d already has a superblock!\n",
2635 mdidx(mddev));
2636 err = -EBUSY;
2637 goto abort_unlock;
2638 }
2639 if (arg) {
2640 mdu_array_info_t info;
2641 if (md_copy_from_user(&info, (void*)arg, sizeof(info))) {
2642 err = -EFAULT;
2643 goto abort_unlock;
2644 }
2645 err = set_array_info(mddev, &info);
2646 if (err) {
2647 printk("couldnt set array info. %d\n", err);
2648 goto abort_unlock;
2649 }
2650 }
2651 goto done_unlock;
2652
2653 case START_ARRAY:
2654 /*
2655 * possibly make it lock the array ...
2656 */
2657 err = autostart_array((kdev_t)arg, dev);
2658 if (err) {
2659 printk("autostart %s failed!\n",
2660 partition_name((kdev_t)arg));
2661 goto abort;
2662 }
2663 goto done;
2664
2665 default:
2666 }
2667
2668 /*
2669 * Commands querying/configuring an existing array:
2670 */
2671
2672 if (!mddev) {
2673 err = -ENODEV;
2674 goto abort;
2675 }
2676 err = lock_mddev(mddev);
2677 if (err) {
2678 printk("ioctl lock interrupted, reason %d, cmd %d\n",err, cmd);
2679 goto abort;
2680 }
2681 /* if we don't have a superblock yet, only ADD_NEW_DISK or STOP_ARRAY is allowed */
2682 if (!mddev->sb && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY && cmd != RUN_ARRAY) {
2683 err = -ENODEV;
2684 goto abort_unlock;
2685 }
2686
2687 /*
2688 * Commands even a read-only array can execute:
2689 */
2690 switch (cmd)
2691 {
2692 case GET_ARRAY_INFO:
2693 err = get_array_info(mddev, (void *)arg);
2694 goto done_unlock;
2695
2696 case GET_DISK_INFO:
2697 err = get_disk_info(mddev, (void *)arg);
2698 goto done_unlock;
2699
2700 case RESTART_ARRAY_RW:
2701 err = restart_array(mddev);
2702 goto done_unlock;
2703
2704 case STOP_ARRAY:
2705 if (!(err = do_md_stop (mddev, 0)))
2706 mddev = NULL;
2707 goto done_unlock;
2708
2709 case STOP_ARRAY_RO:
2710 err = do_md_stop (mddev, 1);
2711 goto done_unlock;
2712
2713 /*
2714 * We have a problem here : there is no easy way to give a CHS
2715 * virtual geometry. We currently pretend that we have a 2 heads
2716 * 4 sectors (with a BIG number of cylinders...). This drives
2717 * dosfs just mad... ;-)
2718 */
2719 case HDIO_GETGEO:
2720 if (!loc) {
2721 err = -EINVAL;
2722 goto abort_unlock;
2723 }
2724 err = md_put_user (2, (char *) &loc->heads);
2725 if (err)
2726 goto abort_unlock;
2727 err = md_put_user (4, (char *) &loc->sectors);
2728 if (err)
2729 goto abort_unlock;
2730 err = md_put_user (md_hd_struct[mdidx(mddev)].nr_sects/8,
2731 (short *) &loc->cylinders);
2732 if (err)
2733 goto abort_unlock;
2734 err = md_put_user (md_hd_struct[minor].start_sect,
2735 (long *) &loc->start);
2736 goto done_unlock;
2737 }
2738
2739 /*
2740 * The remaining ioctls are changing the state of the
2741 * superblock, so we do not allow read-only arrays
2742 * here:
2743 */
2744 if (mddev->ro) {
2745 err = -EROFS;
2746 goto abort_unlock;
2747 }
2748
2749 switch (cmd)
2750 {
2751 case CLEAR_ARRAY:
2752 err = clear_array(mddev);
2753 goto done_unlock;
2754
2755 case ADD_NEW_DISK:
2756 {
2757 mdu_disk_info_t info;
2758 if (md_copy_from_user(&info, (void*)arg, sizeof(info)))
2759 err = -EFAULT;
2760 else
2761 err = add_new_disk(mddev, &info);
2762 goto done_unlock;
2763 }
2764 case HOT_REMOVE_DISK:
2765 err = hot_remove_disk(mddev, (kdev_t)arg);
2766 goto done_unlock;
2767
2768 case HOT_ADD_DISK:
2769 err = hot_add_disk(mddev, (kdev_t)arg);
2770 goto done_unlock;
2771
2772 case SET_DISK_INFO:
2773 err = set_disk_info(mddev, (void *)arg);
2774 goto done_unlock;
2775
2776 case WRITE_RAID_INFO:
2777 err = write_raid_info(mddev);
2778 goto done_unlock;
2779
2780 case UNPROTECT_ARRAY:
2781 err = unprotect_array(mddev);
2782 goto done_unlock;
2783
2784 case PROTECT_ARRAY:
2785 err = protect_array(mddev);
2786 goto done_unlock;
2787
2788 case SET_DISK_FAULTY:
2789 err = set_disk_faulty(mddev, (kdev_t)arg);
2790 goto done_unlock;
2791
2792 case RUN_ARRAY:
2793 {
2794 /* The data is never used....
2795 mdu_param_t param;
2796 err = md_copy_from_user(¶m, (mdu_param_t *)arg,
2797 sizeof(param));
2798 if (err)
2799 goto abort_unlock;
2800 */
2801 err = do_md_run (mddev);
2802 /*
2803 * we have to clean up the mess if
2804 * the array cannot be run for some
2805 * reason ...
2806 */
2807 if (err) {
2808 mddev->sb_dirty = 0;
2809 if (!do_md_stop (mddev, 0))
2810 mddev = NULL;
2811 }
2812 goto done_unlock;
2813 }
2814
2815 default:
2816 printk(KERN_WARNING "%s(pid %d) used obsolete MD ioctl, upgrade your software to use new ictls.\n", current->comm, current->pid);
2817 err = -EINVAL;
2818 goto abort_unlock;
2819 }
2820
2821 done_unlock:
2822 abort_unlock:
2823 if (mddev)
2824 unlock_mddev(mddev);
2825
2826 return err;
2827 done:
2828 if (err)
2829 printk("huh12?\n");
2830 abort:
2831 return err;
2832 }
2833
2834 static int md_open (struct inode *inode, struct file *file)
2835 {
2836 /*
2837 * Always succeed, but increment the usage count
2838 */
2839 mddev_t *mddev = kdev_to_mddev(inode->i_rdev);
2840 if (mddev)
2841 atomic_inc(&mddev->active);
2842 return (0);
2843 }
2844
2845 static int md_release (struct inode *inode, struct file * file)
2846 {
2847 mddev_t *mddev = kdev_to_mddev(inode->i_rdev);
2848 if (mddev)
2849 atomic_dec(&mddev->active);
2850 return 0;
2851 }
2852
2853 static struct block_device_operations md_fops=
2854 {
2855 open: md_open,
2856 release: md_release,
2857 ioctl: md_ioctl,
2858 };
2859
2860
2861 int md_thread(void * arg)
2862 {
2863 mdk_thread_t *thread = arg;
2864
2865 md_lock_kernel();
2866
2867 /*
2868 * Detach thread
2869 */
2870
2871 daemonize();
2872
2873 sprintf(current->comm, thread->name);
2874 md_init_signals();
2875 md_flush_signals();
2876 thread->tsk = current;
2877
2878 /*
2879 * md_thread is a 'system-thread', it's priority should be very
2880 * high. We avoid resource deadlocks individually in each
2881 * raid personality. (RAID5 does preallocation) We also use RR and
2882 * the very same RT priority as kswapd, thus we will never get
2883 * into a priority inversion deadlock.
2884 *
2885 * we definitely have to have equal or higher priority than
2886 * bdflush, otherwise bdflush will deadlock if there are too
2887 * many dirty RAID5 blocks.
2888 */
2889 current->policy = SCHED_OTHER;
2890 current->nice = -20;
2891 // md_unlock_kernel();
2892
2893 up(thread->sem);
2894
2895 for (;;) {
2896 DECLARE_WAITQUEUE(wait, current);
2897
2898 add_wait_queue(&thread->wqueue, &wait);
2899 set_task_state(current, TASK_INTERRUPTIBLE);
2900 if (!test_bit(THREAD_WAKEUP, &thread->flags)) {
2901 dprintk("thread %p went to sleep.\n", thread);
2902 schedule();
2903 dprintk("thread %p woke up.\n", thread);
2904 }
2905 current->state = TASK_RUNNING;
2906 remove_wait_queue(&thread->wqueue, &wait);
2907 clear_bit(THREAD_WAKEUP, &thread->flags);
2908
2909 if (thread->run) {
2910 thread->run(thread->data);
2911 run_task_queue(&tq_disk);
2912 } else
2913 break;
2914 if (md_signal_pending(current)) {
2915 printk("%8s(%d) flushing signals.\n", current->comm,
2916 current->pid);
2917 md_flush_signals();
2918 }
2919 }
2920 up(thread->sem);
2921 return 0;
2922 }
2923
2924 void md_wakeup_thread(mdk_thread_t *thread)
2925 {
2926 dprintk("waking up MD thread %p.\n", thread);
2927 set_bit(THREAD_WAKEUP, &thread->flags);
2928 wake_up(&thread->wqueue);
2929 }
2930
2931 mdk_thread_t *md_register_thread (void (*run) (void *),
2932 void *data, const char *name)
2933 {
2934 mdk_thread_t *thread;
2935 int ret;
2936 DECLARE_MUTEX_LOCKED(sem);
2937
2938 thread = (mdk_thread_t *) kmalloc
2939 (sizeof(mdk_thread_t), GFP_KERNEL);
2940 if (!thread)
2941 return NULL;
2942
2943 memset(thread, 0, sizeof(mdk_thread_t));
2944 md_init_waitqueue_head(&thread->wqueue);
2945
2946 thread->sem = &sem;
2947 thread->run = run;
2948 thread->data = data;
2949 thread->name = name;
2950 ret = kernel_thread(md_thread, thread, 0);
2951 if (ret < 0) {
2952 kfree(thread);
2953 return NULL;
2954 }
2955 down(&sem);
2956 return thread;
2957 }
2958
2959 void md_interrupt_thread (mdk_thread_t *thread)
2960 {
2961 if (!thread->tsk) {
2962 MD_BUG();
2963 return;
2964 }
2965 printk("interrupting MD-thread pid %d\n", thread->tsk->pid);
2966 send_sig(SIGKILL, thread->tsk, 1);
2967 }
2968
2969 void md_unregister_thread (mdk_thread_t *thread)
2970 {
2971 DECLARE_MUTEX_LOCKED(sem);
2972
2973 thread->sem = &sem;
2974 thread->run = NULL;
2975 thread->name = NULL;
2976 if (!thread->tsk) {
2977 MD_BUG();
2978 return;
2979 }
2980 md_interrupt_thread(thread);
2981 down(&sem);
2982 }
2983
2984 void md_recover_arrays (void)
2985 {
2986 if (!md_recovery_thread) {
2987 MD_BUG();
2988 return;
2989 }
2990 md_wakeup_thread(md_recovery_thread);
2991 }
2992
2993
2994 int md_error (kdev_t dev, kdev_t rdev)
2995 {
2996 mddev_t *mddev;
2997 mdk_rdev_t * rrdev;
2998 int rc;
2999
3000 mddev = kdev_to_mddev(dev);
3001 /* printk("md_error dev:(%d:%d), rdev:(%d:%d), (caller: %p,%p,%p,%p).\n",MAJOR(dev),MINOR(dev),MAJOR(rdev),MINOR(rdev), __builtin_return_address(0),__builtin_return_address(1),__builtin_return_address(2),__builtin_return_address(3));
3002 */
3003 if (!mddev) {
3004 MD_BUG();
3005 return 0;
3006 }
3007 rrdev = find_rdev(mddev, rdev);
3008 mark_rdev_faulty(rrdev);
3009 /*
3010 * if recovery was running, stop it now.
3011 */
3012 if (mddev->pers->stop_resync)
3013 mddev->pers->stop_resync(mddev);
3014 if (mddev->recovery_running)
3015 md_interrupt_thread(md_recovery_thread);
3016 if (mddev->pers->error_handler) {
3017 rc = mddev->pers->error_handler(mddev, rdev);
3018 md_recover_arrays();
3019 return rc;
3020 }
3021 return 0;
3022 }
3023
3024 static int status_unused (char * page)
3025 {
3026 int sz = 0, i = 0;
3027 mdk_rdev_t *rdev;
3028 struct md_list_head *tmp;
3029
3030 sz += sprintf(page + sz, "unused devices: ");
3031
3032 ITERATE_RDEV_ALL(rdev,tmp) {
3033 if (!rdev->same_set.next && !rdev->same_set.prev) {
3034 /*
3035 * The device is not yet used by any array.
3036 */
3037 i++;
3038 sz += sprintf(page + sz, "%s ",
3039 partition_name(rdev->dev));
3040 }
3041 }
3042 if (!i)
3043 sz += sprintf(page + sz, "<none>");
3044
3045 sz += sprintf(page + sz, "\n");
3046 return sz;
3047 }
3048
3049
3050 static int status_resync (char * page, mddev_t * mddev)
3051 {
3052 int sz = 0;
3053 unsigned long max_blocks, resync, res, dt, db, rt;
3054
3055 resync = mddev->curr_resync - atomic_read(&mddev->recovery_active);
3056 max_blocks = mddev->sb->size;
3057
3058 /*
3059 * Should not happen.
3060 */
3061 if (!max_blocks) {
3062 MD_BUG();
3063 return 0;
3064 }
3065 res = (resync/1024)*1000/(max_blocks/1024 + 1);
3066 {
3067 int i, x = res/50, y = 20-x;
3068 sz += sprintf(page + sz, "[");
3069 for (i = 0; i < x; i++)
3070 sz += sprintf(page + sz, "=");
3071 sz += sprintf(page + sz, ">");
3072 for (i = 0; i < y; i++)
3073 sz += sprintf(page + sz, ".");
3074 sz += sprintf(page + sz, "] ");
3075 }
3076 if (!mddev->recovery_running)
3077 /*
3078 * true resync
3079 */
3080 sz += sprintf(page + sz, " resync =%3lu.%lu%% (%lu/%lu)",
3081 res/10, res % 10, resync, max_blocks);
3082 else
3083 /*
3084 * recovery ...
3085 */
3086 sz += sprintf(page + sz, " recovery =%3lu.%lu%% (%lu/%lu)",
3087 res/10, res % 10, resync, max_blocks);
3088
3089 /*
3090 * We do not want to overflow, so the order of operands and
3091 * the * 100 / 100 trick are important. We do a +1 to be
3092 * safe against division by zero. We only estimate anyway.
3093 *
3094 * dt: time from mark until now
3095 * db: blocks written from mark until now
3096 * rt: remaining time
3097 */
3098 dt = ((jiffies - mddev->resync_mark) / HZ);
3099 if (!dt) dt++;
3100 db = resync - mddev->resync_mark_cnt;
3101 rt = (dt * ((max_blocks-resync) / (db/100+1)))/100;
3102
3103 sz += sprintf(page + sz, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
3104
3105 sz += sprintf(page + sz, " speed=%ldK/sec", db/dt);
3106
3107 return sz;
3108 }
3109
3110 static int md_status_read_proc(char *page, char **start, off_t off,
3111 int count, int *eof, void *data)
3112 {
3113 int sz = 0, j, size;
3114 struct md_list_head *tmp, *tmp2;
3115 mdk_rdev_t *rdev;
3116 mddev_t *mddev;
3117
3118 sz += sprintf(page + sz, "Personalities : ");
3119 for (j = 0; j < MAX_PERSONALITY; j++)
3120 if (pers[j])
3121 sz += sprintf(page+sz, "[%s] ", pers[j]->name);
3122
3123 sz += sprintf(page+sz, "\n");
3124
3125
3126 sz += sprintf(page+sz, "read_ahead ");
3127 if (read_ahead[MD_MAJOR] == INT_MAX)
3128 sz += sprintf(page+sz, "not set\n");
3129 else
3130 sz += sprintf(page+sz, "%d sectors\n", read_ahead[MD_MAJOR]);
3131
3132 ITERATE_MDDEV(mddev,tmp) {
3133 sz += sprintf(page + sz, "md%d : %sactive", mdidx(mddev),
3134 mddev->pers ? "" : "in");
3135 if (mddev->pers) {
3136 if (mddev->ro)
3137 sz += sprintf(page + sz, " (read-only)");
3138 sz += sprintf(page + sz, " %s", mddev->pers->name);
3139 }
3140
3141 size = 0;
3142 ITERATE_RDEV(mddev,rdev,tmp2) {
3143 sz += sprintf(page + sz, " %s[%d]",
3144 partition_name(rdev->dev), rdev->desc_nr);
3145 if (rdev->faulty) {
3146 sz += sprintf(page + sz, "(F)");
3147 continue;
3148 }
3149 size += rdev->size;
3150 }
3151
3152 if (mddev->nb_dev) {
3153 if (mddev->pers)
3154 sz += sprintf(page + sz, "\n %d blocks",
3155 md_size[mdidx(mddev)]);
3156 else
3157 sz += sprintf(page + sz, "\n %d blocks", size);
3158 }
3159
3160 if (!mddev->pers) {
3161 sz += sprintf(page+sz, "\n");
3162 continue;
3163 }
3164
3165 sz += mddev->pers->status (page+sz, mddev);
3166
3167 sz += sprintf(page+sz, "\n ");
3168 if (mddev->curr_resync) {
3169 sz += status_resync (page+sz, mddev);
3170 } else {
3171 if (md_atomic_read(&mddev->resync_sem.count) != 1)
3172 sz += sprintf(page + sz, " resync=DELAYED");
3173 }
3174 sz += sprintf(page + sz, "\n");
3175 }
3176 sz += status_unused (page + sz);
3177
3178 return sz;
3179 }
3180
3181 int register_md_personality (int pnum, mdk_personality_t *p)
3182 {
3183 if (pnum >= MAX_PERSONALITY)
3184 return -EINVAL;
3185
3186 if (pers[pnum])
3187 return -EBUSY;
3188
3189 pers[pnum] = p;
3190 printk(KERN_INFO "%s personality registered\n", p->name);
3191 return 0;
3192 }
3193
3194 int unregister_md_personality (int pnum)
3195 {
3196 if (pnum >= MAX_PERSONALITY)
3197 return -EINVAL;
3198
3199 printk(KERN_INFO "%s personality unregistered\n", pers[pnum]->name);
3200 pers[pnum] = NULL;
3201 return 0;
3202 }
3203
3204 static mdp_disk_t *get_spare(mddev_t *mddev)
3205 {
3206 mdp_super_t *sb = mddev->sb;
3207 mdp_disk_t *disk;
3208 mdk_rdev_t *rdev;
3209 struct md_list_head *tmp;
3210
3211 ITERATE_RDEV(mddev,rdev,tmp) {
3212 if (rdev->faulty)
3213 continue;
3214 if (!rdev->sb) {
3215 MD_BUG();
3216 continue;
3217 }
3218 disk = &sb->disks[rdev->desc_nr];
3219 if (disk_faulty(disk)) {
3220 MD_BUG();
3221 continue;
3222 }
3223 if (disk_active(disk))
3224 continue;
3225 return disk;
3226 }
3227 return NULL;
3228 }
3229
3230 static unsigned int sync_io[DK_MAX_MAJOR][DK_MAX_DISK];
3231 void md_sync_acct(kdev_t dev, unsigned long nr_sectors)
3232 {
3233 unsigned int major = MAJOR(dev);
3234 unsigned int index;
3235
3236 index = disk_index(dev);
3237 if ((index >= DK_MAX_DISK) || (major >= DK_MAX_MAJOR))
3238 return;
3239
3240 sync_io[major][index] += nr_sectors;
3241 }
3242
3243 static int is_mddev_idle (mddev_t *mddev)
3244 {
3245 mdk_rdev_t * rdev;
3246 struct md_list_head *tmp;
3247 int idle;
3248 unsigned long curr_events;
3249
3250 idle = 1;
3251 ITERATE_RDEV(mddev,rdev,tmp) {
3252 int major = MAJOR(rdev->dev);
3253 int idx = disk_index(rdev->dev);
3254
3255 if ((idx >= DK_MAX_DISK) || (major >= DK_MAX_MAJOR))
3256 continue;
3257
3258 curr_events = kstat.dk_drive_rblk[major][idx] +
3259 kstat.dk_drive_wblk[major][idx] ;
3260 curr_events -= sync_io[major][idx];
3261 // printk("events(major: %d, idx: %d): %ld\n", major, idx, curr_events);
3262 if (curr_events != rdev->last_events) {
3263 // printk("!I(%ld)", curr_events - rdev->last_events);
3264 rdev->last_events = curr_events;
3265 idle = 0;
3266 }
3267 }
3268 return idle;
3269 }
3270
3271 MD_DECLARE_WAIT_QUEUE_HEAD(resync_wait);
3272
3273 void md_done_sync(mddev_t *mddev, int blocks, int ok)
3274 {
3275 /* another "blocks" (1K) blocks have been synced */
3276 atomic_sub(blocks, &mddev->recovery_active);
3277 wake_up(&mddev->recovery_wait);
3278 if (!ok) {
3279 // stop recovery, signal do_sync ....
3280 }
3281 }
3282
3283 #define SYNC_MARKS 10
3284 #define SYNC_MARK_STEP (3*HZ)
3285 int md_do_sync(mddev_t *mddev, mdp_disk_t *spare)
3286 {
3287 mddev_t *mddev2;
3288 unsigned int max_blocks, currspeed,
3289 j, window, err, serialize;
3290 kdev_t read_disk = mddev_to_kdev(mddev);
3291 unsigned long mark[SYNC_MARKS];
3292 unsigned long mark_cnt[SYNC_MARKS];
3293 int last_mark,m;
3294 struct md_list_head *tmp;
3295 unsigned long last_check;
3296
3297
3298 err = down_interruptible(&mddev->resync_sem);
3299 if (err)
3300 goto out_nolock;
3301
3302 recheck:
3303 serialize = 0;
3304 ITERATE_MDDEV(mddev2,tmp) {
3305 if (mddev2 == mddev)
3306 continue;
3307 if (mddev2->curr_resync && match_mddev_units(mddev,mddev2)) {
3308 printk(KERN_INFO "md: serializing resync, md%d shares one or more physical units with md%d!\n", mdidx(mddev), mdidx(mddev2));
3309 serialize = 1;
3310 break;
3311 }
3312 }
3313 if (serialize) {
3314 interruptible_sleep_on(&resync_wait);
3315 if (md_signal_pending(current)) {
3316 md_flush_signals();
3317 err = -EINTR;
3318 goto out;
3319 }
3320 goto recheck;
3321 }
3322
3323 mddev->curr_resync = 1;
3324
3325 max_blocks = mddev->sb->size;
3326
3327 printk(KERN_INFO "md: syncing RAID array md%d\n", mdidx(mddev));
3328 printk(KERN_INFO "md: minimum _guaranteed_ reconstruction speed: %d KB/sec/disc.\n",
3329 sysctl_speed_limit_min);
3330 printk(KERN_INFO "md: using maximum available idle IO bandwith (but not more than %d KB/sec) for reconstruction.\n", sysctl_speed_limit_max);
3331
3332 /*
3333 * Resync has low priority.
3334 */
3335 current->nice = 19;
3336
3337 is_mddev_idle(mddev); /* this also initializes IO event counters */
3338 for (m = 0; m < SYNC_MARKS; m++) {
3339 mark[m] = jiffies;
3340 mark_cnt[m] = 0;
3341 }
3342 last_mark = 0;
3343 mddev->resync_mark = mark[last_mark];
3344 mddev->resync_mark_cnt = mark_cnt[last_mark];
3345
3346 /*
3347 * Tune reconstruction:
3348 */
3349 window = MAX_READAHEAD*(PAGE_SIZE/1024);
3350 printk(KERN_INFO "md: using %dk window, over a total of %d blocks.\n",window,max_blocks);
3351
3352 atomic_set(&mddev->recovery_active, 0);
3353 init_waitqueue_head(&mddev->recovery_wait);
3354 last_check = 0;
3355 for (j = 0; j < max_blocks;) {
3356 int blocks;
3357
3358 blocks = mddev->pers->sync_request(mddev, j);
3359
3360 if (blocks < 0) {
3361 err = blocks;
3362 goto out;
3363 }
3364 atomic_add(blocks, &mddev->recovery_active);
3365 j += blocks;
3366 mddev->curr_resync = j;
3367
3368 if (last_check + window > j)
3369 continue;
3370
3371 run_task_queue(&tq_disk); //??
3372
3373 if (jiffies >= mark[last_mark] + SYNC_MARK_STEP ) {
3374 /* step marks */
3375 int next = (last_mark+1) % SYNC_MARKS;
3376
3377 mddev->resync_mark = mark[next];
3378 mddev->resync_mark_cnt = mark_cnt[next];
3379 mark[next] = jiffies;
3380 mark_cnt[next] = j - atomic_read(&mddev->recovery_active);
3381 last_mark = next;
3382 }
3383
3384
3385 if (md_signal_pending(current)) {
3386 /*
3387 * got a signal, exit.
3388 */
3389 mddev->curr_resync = 0;
3390 printk("md_do_sync() got signal ... exiting\n");
3391 md_flush_signals();
3392 err = -EINTR;
3393 goto out;
3394 }
3395
3396 /*
3397 * this loop exits only if either when we are slower than
3398 * the 'hard' speed limit, or the system was IO-idle for
3399 * a jiffy.
3400 * the system might be non-idle CPU-wise, but we only care
3401 * about not overloading the IO subsystem. (things like an
3402 * e2fsck being done on the RAID array should execute fast)
3403 */
3404 repeat:
3405 if (md_need_resched(current))
3406 schedule();
3407
3408 currspeed = (j-mddev->resync_mark_cnt)/((jiffies-mddev->resync_mark)/HZ +1) +1;
3409
3410 if (currspeed > sysctl_speed_limit_min) {
3411 current->nice = 19;
3412
3413 if ((currspeed > sysctl_speed_limit_max) ||
3414 !is_mddev_idle(mddev)) {
3415 current->state = TASK_INTERRUPTIBLE;
3416 md_schedule_timeout(HZ/4);
3417 if (!md_signal_pending(current))
3418 goto repeat;
3419 }
3420 } else
3421 current->nice = -20;
3422 }
3423 fsync_dev(read_disk);
3424 printk(KERN_INFO "md: md%d: sync done.\n",mdidx(mddev));
3425 err = 0;
3426 /*
3427 * this also signals 'finished resyncing' to md_stop
3428 */
3429 out:
3430 wait_event(mddev->recovery_wait, atomic_read(&mddev->recovery_active)==0);
3431 up(&mddev->resync_sem);
3432 out_nolock:
3433 mddev->curr_resync = 0;
3434 wake_up(&resync_wait);
3435 return err;
3436 }
3437
3438
3439 /*
3440 * This is a kernel thread which syncs a spare disk with the active array
3441 *
3442 * the amount of foolproofing might seem to be a tad excessive, but an
3443 * early (not so error-safe) version of raid1syncd synced the first 0.5 gigs
3444 * of my root partition with the first 0.5 gigs of my /home partition ... so
3445 * i'm a bit nervous ;)
3446 */
3447 void md_do_recovery (void *data)
3448 {
3449 int err;
3450 mddev_t *mddev;
3451 mdp_super_t *sb;
3452 mdp_disk_t *spare;
3453 struct md_list_head *tmp;
3454
3455 printk(KERN_INFO "md: recovery thread got woken up ...\n");
3456 restart:
3457 ITERATE_MDDEV(mddev,tmp) {
3458 sb = mddev->sb;
3459 if (!sb)
3460 continue;
3461 if (mddev->recovery_running)
3462 continue;
3463 if (sb->active_disks == sb->raid_disks)
3464 continue;
3465 if (!sb->spare_disks) {
3466 printk(KERN_ERR "md%d: no spare disk to reconstruct array! -- continuing in degraded mode\n", mdidx(mddev));
3467 continue;
3468 }
3469 /*
3470 * now here we get the spare and resync it.
3471 */
3472 if ((spare = get_spare(mddev)) == NULL)
3473 continue;
3474 printk(KERN_INFO "md%d: resyncing spare disk %s to replace failed disk\n", mdidx(mddev), partition_name(MKDEV(spare->major,spare->minor)));
3475 if (!mddev->pers->diskop)
3476 continue;
3477 if (mddev->pers->diskop(mddev, &spare, DISKOP_SPARE_WRITE))
3478 continue;
3479 down(&mddev->recovery_sem);
3480 mddev->recovery_running = 1;
3481 err = md_do_sync(mddev, spare);
3482 if (err == -EIO) {
3483 printk(KERN_INFO "md%d: spare disk %s failed, skipping to next spare.\n", mdidx(mddev), partition_name(MKDEV(spare->major,spare->minor)));
3484 if (!disk_faulty(spare)) {
3485 mddev->pers->diskop(mddev,&spare,DISKOP_SPARE_INACTIVE);
3486 mark_disk_faulty(spare);
3487 mark_disk_nonsync(spare);
3488 mark_disk_inactive(spare);
3489 sb->spare_disks--;
3490 sb->working_disks--;
3491 sb->failed_disks++;
3492 }
3493 } else
3494 if (disk_faulty(spare))
3495 mddev->pers->diskop(mddev, &spare,
3496 DISKOP_SPARE_INACTIVE);
3497 if (err == -EINTR || err == -ENOMEM) {
3498 /*
3499 * Recovery got interrupted, or ran out of mem ...
3500 * signal back that we have finished using the array.
3501 */
3502 mddev->pers->diskop(mddev, &spare,
3503 DISKOP_SPARE_INACTIVE);
3504 up(&mddev->recovery_sem);
3505 mddev->recovery_running = 0;
3506 continue;
3507 } else {
3508 mddev->recovery_running = 0;
3509 up(&mddev->recovery_sem);
3510 }
3511 if (!disk_faulty(spare)) {
3512 /*
3513 * the SPARE_ACTIVE diskop possibly changes the
3514 * pointer too
3515 */
3516 mddev->pers->diskop(mddev, &spare, DISKOP_SPARE_ACTIVE);
3517 mark_disk_sync(spare);
3518 mark_disk_active(spare);
3519 sb->active_disks++;
3520 sb->spare_disks--;
3521 }
3522 mddev->sb_dirty = 1;
3523 md_update_sb(mddev);
3524 goto restart;
3525 }
3526 printk(KERN_INFO "md: recovery thread finished ...\n");
3527
3528 }
3529
3530 int md_notify_reboot(struct notifier_block *this,
3531 unsigned long code, void *x)
3532 {
3533 struct md_list_head *tmp;
3534 mddev_t *mddev;
3535
3536 if ((code == MD_SYS_DOWN) || (code == MD_SYS_HALT)
3537 || (code == MD_SYS_POWER_OFF)) {
3538
3539 printk(KERN_INFO "stopping all md devices.\n");
3540
3541 ITERATE_MDDEV(mddev,tmp)
3542 do_md_stop (mddev, 1);
3543 /*
3544 * certain more exotic SCSI devices are known to be
3545 * volatile wrt too early system reboots. While the
3546 * right place to handle this issue is the given
3547 * driver, we do want to have a safe RAID driver ...
3548 */
3549 md_mdelay(1000*1);
3550 }
3551 return NOTIFY_DONE;
3552 }
3553
3554 struct notifier_block md_notifier = {
3555 md_notify_reboot,
3556 NULL,
3557 0
3558 };
3559 #ifndef MODULE
3560 static int md__init raid_setup(char *str)
3561 {
3562 int len, pos;
3563
3564 len = strlen(str) + 1;
3565 pos = 0;
3566
3567 while (pos < len) {
3568 char *comma = strchr(str+pos, ',');
3569 int wlen;
3570 if (comma)
3571 wlen = (comma-str)-pos;
3572 else wlen = (len-1)-pos;
3573
3574 if (strncmp(str, "noautodetect", wlen) == 0)
3575 raid_setup_args.noautodetect = 1;
3576 pos += wlen+1;
3577 }
3578 raid_setup_args.set = 1;
3579 return 1;
3580 }
3581 __setup("raid=", raid_setup);
3582 #endif
3583 static void md_geninit (void)
3584 {
3585 int i;
3586
3587 for(i = 0; i < MAX_MD_DEVS; i++) {
3588 md_blocksizes[i] = 1024;
3589 md_size[i] = 0;
3590 md_hardsect_sizes[i] = 512;
3591 md_maxreadahead[i] = MD_READAHEAD;
3592 register_disk(&md_gendisk, MKDEV(MAJOR_NR,i), 1, &md_fops, 0);
3593 }
3594 blksize_size[MAJOR_NR] = md_blocksizes;
3595 blk_size[MAJOR_NR] = md_size;
3596 max_readahead[MAJOR_NR] = md_maxreadahead;
3597 hardsect_size[MAJOR_NR] = md_hardsect_sizes;
3598
3599 printk("md.c: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
3600
3601 #ifdef CONFIG_PROC_FS
3602 create_proc_read_entry("mdstat", 0, NULL, md_status_read_proc, NULL);
3603 #endif
3604 }
3605
3606 int md__init md_init (void)
3607 {
3608 static char * name = "mdrecoveryd";
3609
3610 printk (KERN_INFO "md driver %d.%d.%d MAX_MD_DEVS=%d, MD_SB_DISKS=%d\n",
3611 MD_MAJOR_VERSION, MD_MINOR_VERSION,
3612 MD_PATCHLEVEL_VERSION, MAX_MD_DEVS, MD_SB_DISKS);
3613
3614 if (devfs_register_blkdev (MAJOR_NR, "md", &md_fops))
3615 {
3616 printk (KERN_ALERT "Unable to get major %d for md\n", MAJOR_NR);
3617 return (-1);
3618 }
3619 devfs_handle = devfs_mk_dir (NULL, "md", NULL);
3620 devfs_register_series (devfs_handle, "%u",MAX_MD_DEVS,DEVFS_FL_DEFAULT,
3621 MAJOR_NR, 0, S_IFBLK | S_IRUSR | S_IWUSR,
3622 &md_fops, NULL);
3623
3624 /* forward all md request to md_make_request */
3625 blk_queue_make_request(BLK_DEFAULT_QUEUE(MAJOR_NR), md_make_request);
3626
3627
3628 read_ahead[MAJOR_NR] = INT_MAX;
3629 md_gendisk.next = gendisk_head;
3630
3631 gendisk_head = &md_gendisk;
3632
3633 md_recovery_thread = md_register_thread(md_do_recovery, NULL, name);
3634 if (!md_recovery_thread)
3635 printk(KERN_ALERT "bug: couldn't allocate md_recovery_thread\n");
3636
3637 md_register_reboot_notifier(&md_notifier);
3638 raid_table_header = register_sysctl_table(raid_root_table, 1);
3639
3640 md_geninit();
3641 return (0);
3642 }
3643
3644 static struct {
3645 char device_set [MAX_MD_DEVS];
3646 int pers[MAX_MD_DEVS];
3647 int chunk[MAX_MD_DEVS];
3648 kdev_t devices[MAX_MD_DEVS][MD_SB_DISKS];
3649 } md_setup_args md__initdata;
3650
3651 /*
3652 * Parse the command-line parameters given our kernel, but do not
3653 * actually try to invoke the MD device now; that is handled by
3654 * md_setup_drive after the low-level disk drivers have initialised.
3655 *
3656 * 27/11/1999: Fixed to work correctly with the 2.3 kernel (which
3657 * assigns the task of parsing integer arguments to the
3658 * invoked program now). Added ability to initialise all
3659 * the MD devices (by specifying multiple "md=" lines)
3660 * instead of just one. -- KTK
3661 * 18May2000: Added support for persistant-superblock arrays:
3662 * md=n,0,factor,fault,device-list uses RAID0 for device n
3663 * md=n,-1,factor,fault,device-list uses LINEAR for device n
3664 * md=n,device-list reads a RAID superblock from the devices
3665 * elements in device-list are read by name_to_kdev_t so can be
3666 * a hex number or something like /dev/hda1 /dev/sdb
3667 */
3668 extern kdev_t name_to_kdev_t(char *line) md__init;
3669 static int md__init md_setup(char *str)
3670 {
3671 int minor, level, factor, fault, i=0;
3672 kdev_t device;
3673 char *devnames, *pername = "";
3674
3675 if(get_option(&str, &minor) != 2) { /* MD Number */
3676 printk("md: Too few arguments supplied to md=.\n");
3677 return 0;
3678 }
3679 if (minor >= MAX_MD_DEVS) {
3680 printk ("md: Minor device number too high.\n");
3681 return 0;
3682 } else if (md_setup_args.device_set[minor]) {
3683 printk ("md: Warning - md=%d,... has been specified twice;\n"
3684 " will discard the first definition.\n", minor);
3685 }
3686 switch(get_option(&str, &level)) { /* RAID Personality */
3687 case 2: /* could be 0 or -1.. */
3688 if (level == 0 || level == -1) {
3689 if (get_option(&str, &factor) != 2 || /* Chunk Size */
3690 get_option(&str, &fault) != 2) {
3691 printk("md: Too few arguments supplied to md=.\n");
3692 return 0;
3693 }
3694 md_setup_args.pers[minor] = level;
3695 md_setup_args.chunk[minor] = 1 << (factor+12);
3696 switch(level) {
3697 case -1:
3698 level = LINEAR;
3699 pername = "linear";
3700 break;
3701 case 0:
3702 level = RAID0;
3703 pername = "raid0";
3704 break;
3705 default:
3706 printk ("md: The kernel has not been configured for raid%d"
3707 " support!\n", level);
3708 return 0;
3709 }
3710 md_setup_args.pers[minor] = level;
3711 break;
3712 }
3713 /* FALL THROUGH */
3714 case 1: /* the first device is numeric */
3715 md_setup_args.devices[minor][i++] = level;
3716 /* FALL THROUGH */
3717 case 0:
3718 md_setup_args.pers[minor] = 0;
3719 pername="super-block";
3720 }
3721 devnames = str;
3722 for (; i<MD_SB_DISKS && str; i++) {
3723 if ((device = name_to_kdev_t(str))) {
3724 md_setup_args.devices[minor][i] = device;
3725 } else {
3726 printk ("md: Unknown device name, %s.\n", str);
3727 return 0;
3728 }
3729 if ((str = strchr(str, ',')) != NULL)
3730 str++;
3731 }
3732 if (!i) {
3733 printk ("md: No devices specified for md%d?\n", minor);
3734 return 0;
3735 }
3736
3737 printk ("md: Will configure md%d (%s) from %s, below.\n",
3738 minor, pername, devnames);
3739 md_setup_args.devices[minor][i] = (kdev_t) 0;
3740 md_setup_args.device_set[minor] = 1;
3741 return 1;
3742 }
3743
3744 void md__init md_setup_drive(void)
3745 {
3746 int minor, i;
3747 kdev_t dev;
3748 mddev_t*mddev;
3749
3750 for (minor = 0; minor < MAX_MD_DEVS; minor++) {
3751 mdu_disk_info_t dinfo;
3752
3753 int err = 0;
3754 if (!md_setup_args.device_set[minor])
3755 continue;
3756 printk("md: Loading md%d.\n", minor);
3757 if (mddev_map[minor].mddev) {
3758 printk(".. md%d already autodetected - use raid=noautodetect\n", minor);
3759 continue;
3760 }
3761 mddev = alloc_mddev(MKDEV(MD_MAJOR,minor));
3762 if (md_setup_args.pers[minor]) {
3763 /* non-persistent */
3764 mdu_array_info_t ainfo;
3765 ainfo.level = pers_to_level(md_setup_args.pers[minor]);
3766 ainfo.size = 0;
3767 ainfo.nr_disks =0;
3768 ainfo.raid_disks =0;
3769 ainfo.md_minor =minor;
3770 ainfo.not_persistent = 1;
3771
3772 ainfo.state = MD_SB_CLEAN;
3773 ainfo.active_disks = 0;
3774 ainfo.working_disks = 0;
3775 ainfo.failed_disks = 0;
3776 ainfo.spare_disks = 0;
3777 ainfo.layout = 0;
3778 ainfo.chunk_size = md_setup_args.chunk[minor];
3779 err = set_array_info(mddev, &ainfo);
3780 for (i = 0; !err && (dev = md_setup_args.devices[minor][i]); i++) {
3781 dinfo.number = i;
3782 dinfo.raid_disk = i;
3783 dinfo.state = (1<<MD_DISK_ACTIVE)|(1<<MD_DISK_SYNC);
3784 dinfo.major = MAJOR(dev);
3785 dinfo.minor = MINOR(dev);
3786 mddev->sb->nr_disks++;
3787 mddev->sb->raid_disks++;
3788 mddev->sb->active_disks++;
3789 mddev->sb->working_disks++;
3790 err = add_new_disk (mddev, &dinfo);
3791 }
3792 } else {
3793 /* persistent */
3794 for (i = 0; (dev = md_setup_args.devices[minor][i]); i++) {
3795 dinfo.major = MAJOR(dev);
3796 dinfo.minor = MINOR(dev);
3797 add_new_disk (mddev, &dinfo);
3798 }
3799 }
3800 if (!err)
3801 err = do_md_run(mddev);
3802 if (err) {
3803 mddev->sb_dirty = 0;
3804 do_md_stop(mddev, 0);
3805 printk("md: starting md%d failed\n", minor);
3806 }
3807 }
3808 }
3809
3810 __setup("md=", md_setup);
3811
3812 #ifdef MODULE
3813 int init_module (void)
3814 {
3815 return md_init();
3816 }
3817
3818 static void free_device_names(void)
3819 {
3820 while (device_names.next != &device_names) {
3821 struct list_head *tmp = device_names.next;
3822 list_del(tmp);
3823 kfree(tmp);
3824 }
3825 }
3826
3827
3828 void cleanup_module (void)
3829 {
3830 struct gendisk **gendisk_ptr;
3831
3832 md_unregister_thread(md_recovery_thread);
3833 devfs_unregister(devfs_handle);
3834
3835 devfs_unregister_blkdev(MAJOR_NR,"md");
3836 unregister_reboot_notifier(&md_notifier);
3837 unregister_sysctl_table(raid_table_header);
3838 #ifdef CONFIG_PROC_FS
3839 remove_proc_entry("mdstat", NULL);
3840 #endif
3841
3842 gendisk_ptr = &gendisk_head;
3843 while (*gendisk_ptr) {
3844 if (*gendisk_ptr == &md_gendisk) {
3845 *gendisk_ptr = md_gendisk.next;
3846 break;
3847 }
3848 gendisk_ptr = & (*gendisk_ptr)->next;
3849 }
3850 blk_dev[MAJOR_NR].queue = NULL;
3851 blksize_size[MAJOR_NR] = NULL;
3852 blk_size[MAJOR_NR] = NULL;
3853 max_readahead[MAJOR_NR] = NULL;
3854 hardsect_size[MAJOR_NR] = NULL;
3855
3856 free_device_names();
3857
3858 }
3859 #endif
3860
3861 __initcall(md_init);
3862 __initcall(md_run_setup);
3863
3864 MD_EXPORT_SYMBOL(md_size);
3865 MD_EXPORT_SYMBOL(register_md_personality);
3866 MD_EXPORT_SYMBOL(unregister_md_personality);
3867 MD_EXPORT_SYMBOL(partition_name);
3868 MD_EXPORT_SYMBOL(md_error);
3869 MD_EXPORT_SYMBOL(md_do_sync);
3870 MD_EXPORT_SYMBOL(md_sync_acct);
3871 MD_EXPORT_SYMBOL(md_done_sync);
3872 MD_EXPORT_SYMBOL(md_recover_arrays);
3873 MD_EXPORT_SYMBOL(md_register_thread);
3874 MD_EXPORT_SYMBOL(md_unregister_thread);
3875 MD_EXPORT_SYMBOL(md_update_sb);
3876 MD_EXPORT_SYMBOL(md_wakeup_thread);
3877 MD_EXPORT_SYMBOL(md_print_devices);
3878 MD_EXPORT_SYMBOL(find_rdev_nr);
3879 MD_EXPORT_SYMBOL(md_interrupt_thread);
3880 MD_EXPORT_SYMBOL(mddev_map);
3881 MD_EXPORT_SYMBOL(md_check_ordering);
3882
3883
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.