?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] md: make /proc/mdstat pollable
[linux-2.6.git] / drivers / md / md.c
blob6101879a730f537c26d2ed4ea8e74ae5e5e58ebc
1 /*
2 md.c : Multiple Devices driver for Linux
3 Copyright (C) 1998, 1999, 2000 Ingo Molnar
4
5 completely rewritten, based on the MD driver code from Marc Zyngier
6
7 Changes:
8
9 - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
10 - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
11 - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
12 - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
13 - kmod support by: Cyrus Durgin
14 - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
15 - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
16
17 - lots of fixes and improvements to the RAID1/RAID5 and generic
18 RAID code (such as request based resynchronization):
19
20 Neil Brown <neilb@cse.unsw.edu.au>.
21
22 - persistent bitmap code
23 Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
24
25 This program is free software; you can redistribute it and/or modify
26 it under the terms of the GNU General Public License as published by
27 the Free Software Foundation; either version 2, or (at your option)
28 any later version.
29
30 You should have received a copy of the GNU General Public License
31 (for example /usr/src/linux/COPYING); if not, write to the Free
32 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33 */
34
35 #include <linux/module.h>
36 #include <linux/config.h>
37 #include <linux/kthread.h>
38 #include <linux/linkage.h>
39 #include <linux/raid/md.h>
40 #include <linux/raid/bitmap.h>
41 #include <linux/sysctl.h>
42 #include <linux/devfs_fs_kernel.h>
43 #include <linux/buffer_head.h> /* for invalidate_bdev */
44 #include <linux/suspend.h>
45 #include <linux/poll.h>
46
47 #include <linux/init.h>
48
49 #include <linux/file.h>
50
51 #ifdef CONFIG_KMOD
52 #include <linux/kmod.h>
53 #endif
54
55 #include <asm/unaligned.h>
56
57 #define MAJOR_NR MD_MAJOR
58 #define MD_DRIVER
59
60 /* 63 partitions with the alternate major number (mdp) */
61 #define MdpMinorShift 6
62
63 #define DEBUG 0
64 #define dprintk(x...) ((void)(DEBUG && printk(x)))
65
66
67 #ifndef MODULE
68 static void autostart_arrays (int part);
69 #endif
70
71 static mdk_personality_t *pers[MAX_PERSONALITY];
72 static DEFINE_SPINLOCK(pers_lock);
73
74 /*
75 * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
76 * is 1000 KB/sec, so the extra system load does not show up that much.
77 * Increase it if you want to have more _guaranteed_ speed. Note that
78 * the RAID driver will use the maximum available bandwidth if the IO
79 * subsystem is idle. There is also an 'absolute maximum' reconstruction
80 * speed limit - in case reconstruction slows down your system despite
81 * idle IO detection.
82 *
83 * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
84 */
85
86 static int sysctl_speed_limit_min = 1000;
87 static int sysctl_speed_limit_max = 200000;
88
89 static struct ctl_table_header *raid_table_header;
90
91 static ctl_table raid_table[] = {
92 {
93 .ctl_name = DEV_RAID_SPEED_LIMIT_MIN,
94 .procname = "speed_limit_min",
95 .data = &sysctl_speed_limit_min,
96 .maxlen = sizeof(int),
97 .mode = 0644,
98 .proc_handler = &proc_dointvec,
99 },
100 {
101 .ctl_name = DEV_RAID_SPEED_LIMIT_MAX,
102 .procname = "speed_limit_max",
103 .data = &sysctl_speed_limit_max,
104 .maxlen = sizeof(int),
105 .mode = 0644,
106 .proc_handler = &proc_dointvec,
107 },
108 { .ctl_name = 0 }
109 };
110
111 static ctl_table raid_dir_table[] = {
112 {
113 .ctl_name = DEV_RAID,
114 .procname = "raid",
115 .maxlen = 0,
116 .mode = 0555,
117 .child = raid_table,
118 },
119 { .ctl_name = 0 }
120 };
121
122 static ctl_table raid_root_table[] = {
123 {
124 .ctl_name = CTL_DEV,
125 .procname = "dev",
126 .maxlen = 0,
127 .mode = 0555,
128 .child = raid_dir_table,
129 },
130 { .ctl_name = 0 }
131 };
132
133 static struct block_device_operations md_fops;
134
135 static int start_readonly;
136
137 /*
138 * We have a system wide 'event count' that is incremented
139 * on any 'interesting' event, and readers of /proc/mdstat
140 * can use 'poll' or 'select' to find out when the event
141 * count increases.
142 *
143 * Events are:
144 * start array, stop array, error, add device, remove device,
145 * start build, activate spare
146 */
147 DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
148 static atomic_t md_event_count;
149 void md_new_event(mddev_t *mddev)
150 {
151 atomic_inc(&md_event_count);
152 wake_up(&md_event_waiters);
153 }
154
155 /*
156 * Enables to iterate over all existing md arrays
157 * all_mddevs_lock protects this list.
158 */
159 static LIST_HEAD(all_mddevs);
160 static DEFINE_SPINLOCK(all_mddevs_lock);
161
162
163 /*
164 * iterates through all used mddevs in the system.
165 * We take care to grab the all_mddevs_lock whenever navigating
166 * the list, and to always hold a refcount when unlocked.
167 * Any code which breaks out of this loop while own
168 * a reference to the current mddev and must mddev_put it.
169 */
170 #define ITERATE_MDDEV(mddev,tmp) \
171 \
172 for (({ spin_lock(&all_mddevs_lock); \
173 tmp = all_mddevs.next; \
174 mddev = NULL;}); \
175 ({ if (tmp != &all_mddevs) \
176 mddev_get(list_entry(tmp, mddev_t, all_mddevs));\
177 spin_unlock(&all_mddevs_lock); \
178 if (mddev) mddev_put(mddev); \
179 mddev = list_entry(tmp, mddev_t, all_mddevs); \
180 tmp != &all_mddevs;}); \
181 ({ spin_lock(&all_mddevs_lock); \
182 tmp = tmp->next;}) \
183 )
184
185
186 static int md_fail_request (request_queue_t *q, struct bio *bio)
187 {
188 bio_io_error(bio, bio->bi_size);
189 return 0;
190 }
191
192 static inline mddev_t *mddev_get(mddev_t *mddev)
193 {
194 atomic_inc(&mddev->active);
195 return mddev;
196 }
197
198 static void mddev_put(mddev_t *mddev)
199 {
200 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
201 return;
202 if (!mddev->raid_disks && list_empty(&mddev->disks)) {
203 list_del(&mddev->all_mddevs);
204 blk_put_queue(mddev->queue);
205 kobject_unregister(&mddev->kobj);
206 }
207 spin_unlock(&all_mddevs_lock);
208 }
209
210 static mddev_t * mddev_find(dev_t unit)
211 {
212 mddev_t *mddev, *new = NULL;
213
214 retry:
215 spin_lock(&all_mddevs_lock);
216 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
217 if (mddev->unit == unit) {
218 mddev_get(mddev);
219 spin_unlock(&all_mddevs_lock);
220 kfree(new);
221 return mddev;
222 }
223
224 if (new) {
225 list_add(&new->all_mddevs, &all_mddevs);
226 spin_unlock(&all_mddevs_lock);
227 return new;
228 }
229 spin_unlock(&all_mddevs_lock);
230
231 new = (mddev_t *) kmalloc(sizeof(*new), GFP_KERNEL);
232 if (!new)
233 return NULL;
234
235 memset(new, 0, sizeof(*new));
236
237 new->unit = unit;
238 if (MAJOR(unit) == MD_MAJOR)
239 new->md_minor = MINOR(unit);
240 else
241 new->md_minor = MINOR(unit) >> MdpMinorShift;
242
243 init_MUTEX(&new->reconfig_sem);
244 INIT_LIST_HEAD(&new->disks);
245 INIT_LIST_HEAD(&new->all_mddevs);
246 init_timer(&new->safemode_timer);
247 atomic_set(&new->active, 1);
248 spin_lock_init(&new->write_lock);
249 init_waitqueue_head(&new->sb_wait);
250
251 new->queue = blk_alloc_queue(GFP_KERNEL);
252 if (!new->queue) {
253 kfree(new);
254 return NULL;
255 }
256
257 blk_queue_make_request(new->queue, md_fail_request);
258
259 goto retry;
260 }
261
262 static inline int mddev_lock(mddev_t * mddev)
263 {
264 return down_interruptible(&mddev->reconfig_sem);
265 }
266
267 static inline void mddev_lock_uninterruptible(mddev_t * mddev)
268 {
269 down(&mddev->reconfig_sem);
270 }
271
272 static inline int mddev_trylock(mddev_t * mddev)
273 {
274 return down_trylock(&mddev->reconfig_sem);
275 }
276
277 static inline void mddev_unlock(mddev_t * mddev)
278 {
279 up(&mddev->reconfig_sem);
280
281 md_wakeup_thread(mddev->thread);
282 }
283
284 mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
285 {
286 mdk_rdev_t * rdev;
287 struct list_head *tmp;
288
289 ITERATE_RDEV(mddev,rdev,tmp) {
290 if (rdev->desc_nr == nr)
291 return rdev;
292 }
293 return NULL;
294 }
295
296 static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
297 {
298 struct list_head *tmp;
299 mdk_rdev_t *rdev;
300
301 ITERATE_RDEV(mddev,rdev,tmp) {
302 if (rdev->bdev->bd_dev == dev)
303 return rdev;
304 }
305 return NULL;
306 }
307
308 static inline sector_t calc_dev_sboffset(struct block_device *bdev)
309 {
310 sector_t size = bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
311 return MD_NEW_SIZE_BLOCKS(size);
312 }
313
314 static sector_t calc_dev_size(mdk_rdev_t *rdev, unsigned chunk_size)
315 {
316 sector_t size;
317
318 size = rdev->sb_offset;
319
320 if (chunk_size)
321 size &= ~((sector_t)chunk_size/1024 - 1);
322 return size;
323 }
324
325 static int alloc_disk_sb(mdk_rdev_t * rdev)
326 {
327 if (rdev->sb_page)
328 MD_BUG();
329
330 rdev->sb_page = alloc_page(GFP_KERNEL);
331 if (!rdev->sb_page) {
332 printk(KERN_ALERT "md: out of memory.\n");
333 return -EINVAL;
334 }
335
336 return 0;
337 }
338
339 static void free_disk_sb(mdk_rdev_t * rdev)
340 {
341 if (rdev->sb_page) {
342 page_cache_release(rdev->sb_page);
343 rdev->sb_loaded = 0;
344 rdev->sb_page = NULL;
345 rdev->sb_offset = 0;
346 rdev->size = 0;
347 }
348 }
349
350
351 static int super_written(struct bio *bio, unsigned int bytes_done, int error)
352 {
353 mdk_rdev_t *rdev = bio->bi_private;
354 mddev_t *mddev = rdev->mddev;
355 if (bio->bi_size)
356 return 1;
357
358 if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags))
359 md_error(mddev, rdev);
360
361 if (atomic_dec_and_test(&mddev->pending_writes))
362 wake_up(&mddev->sb_wait);
363 bio_put(bio);
364 return 0;
365 }
366
367 static int super_written_barrier(struct bio *bio, unsigned int bytes_done, int error)
368 {
369 struct bio *bio2 = bio->bi_private;
370 mdk_rdev_t *rdev = bio2->bi_private;
371 mddev_t *mddev = rdev->mddev;
372 if (bio->bi_size)
373 return 1;
374
375 if (!test_bit(BIO_UPTODATE, &bio->bi_flags) &&
376 error == -EOPNOTSUPP) {
377 unsigned long flags;
378 /* barriers don't appear to be supported :-( */
379 set_bit(BarriersNotsupp, &rdev->flags);
380 mddev->barriers_work = 0;
381 spin_lock_irqsave(&mddev->write_lock, flags);
382 bio2->bi_next = mddev->biolist;
383 mddev->biolist = bio2;
384 spin_unlock_irqrestore(&mddev->write_lock, flags);
385 wake_up(&mddev->sb_wait);
386 bio_put(bio);
387 return 0;
388 }
389 bio_put(bio2);
390 bio->bi_private = rdev;
391 return super_written(bio, bytes_done, error);
392 }
393
394 void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
395 sector_t sector, int size, struct page *page)
396 {
397 /* write first size bytes of page to sector of rdev
398 * Increment mddev->pending_writes before returning
399 * and decrement it on completion, waking up sb_wait
400 * if zero is reached.
401 * If an error occurred, call md_error
402 *
403 * As we might need to resubmit the request if BIO_RW_BARRIER
404 * causes ENOTSUPP, we allocate a spare bio...
405 */
406 struct bio *bio = bio_alloc(GFP_NOIO, 1);
407 int rw = (1<<BIO_RW) | (1<<BIO_RW_SYNC);
408
409 bio->bi_bdev = rdev->bdev;
410 bio->bi_sector = sector;
411 bio_add_page(bio, page, size, 0);
412 bio->bi_private = rdev;
413 bio->bi_end_io = super_written;
414 bio->bi_rw = rw;
415
416 atomic_inc(&mddev->pending_writes);
417 if (!test_bit(BarriersNotsupp, &rdev->flags)) {
418 struct bio *rbio;
419 rw |= (1<<BIO_RW_BARRIER);
420 rbio = bio_clone(bio, GFP_NOIO);
421 rbio->bi_private = bio;
422 rbio->bi_end_io = super_written_barrier;
423 submit_bio(rw, rbio);
424 } else
425 submit_bio(rw, bio);
426 }
427
428 void md_super_wait(mddev_t *mddev)
429 {
430 /* wait for all superblock writes that were scheduled to complete.
431 * if any had to be retried (due to BARRIER problems), retry them
432 */
433 DEFINE_WAIT(wq);
434 for(;;) {
435 prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
436 if (atomic_read(&mddev->pending_writes)==0)
437 break;
438 while (mddev->biolist) {
439 struct bio *bio;
440 spin_lock_irq(&mddev->write_lock);
441 bio = mddev->biolist;
442 mddev->biolist = bio->bi_next ;
443 bio->bi_next = NULL;
444 spin_unlock_irq(&mddev->write_lock);
445 submit_bio(bio->bi_rw, bio);
446 }
447 schedule();
448 }
449 finish_wait(&mddev->sb_wait, &wq);
450 }
451
452 static int bi_complete(struct bio *bio, unsigned int bytes_done, int error)
453 {
454 if (bio->bi_size)
455 return 1;
456
457 complete((struct completion*)bio->bi_private);
458 return 0;
459 }
460
461 int sync_page_io(struct block_device *bdev, sector_t sector, int size,
462 struct page *page, int rw)
463 {
464 struct bio *bio = bio_alloc(GFP_NOIO, 1);
465 struct completion event;
466 int ret;
467
468 rw |= (1 << BIO_RW_SYNC);
469
470 bio->bi_bdev = bdev;
471 bio->bi_sector = sector;
472 bio_add_page(bio, page, size, 0);
473 init_completion(&event);
474 bio->bi_private = &event;
475 bio->bi_end_io = bi_complete;
476 submit_bio(rw, bio);
477 wait_for_completion(&event);
478
479 ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
480 bio_put(bio);
481 return ret;
482 }
483 EXPORT_SYMBOL(sync_page_io);
484
485 static int read_disk_sb(mdk_rdev_t * rdev, int size)
486 {
487 char b[BDEVNAME_SIZE];
488 if (!rdev->sb_page) {
489 MD_BUG();
490 return -EINVAL;
491 }
492 if (rdev->sb_loaded)
493 return 0;
494
495
496 if (!sync_page_io(rdev->bdev, rdev->sb_offset<<1, size, rdev->sb_page, READ))
497 goto fail;
498 rdev->sb_loaded = 1;
499 return 0;
500
501 fail:
502 printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
503 bdevname(rdev->bdev,b));
504 return -EINVAL;
505 }
506
507 static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
508 {
509 if ( (sb1->set_uuid0 == sb2->set_uuid0) &&
510 (sb1->set_uuid1 == sb2->set_uuid1) &&
511 (sb1->set_uuid2 == sb2->set_uuid2) &&
512 (sb1->set_uuid3 == sb2->set_uuid3))
513
514 return 1;
515
516 return 0;
517 }
518
519
520 static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
521 {
522 int ret;
523 mdp_super_t *tmp1, *tmp2;
524
525 tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
526 tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
527
528 if (!tmp1 || !tmp2) {
529 ret = 0;
530 printk(KERN_INFO "md.c: sb1 is not equal to sb2!\n");
531 goto abort;
532 }
533
534 *tmp1 = *sb1;
535 *tmp2 = *sb2;
536
537 /*
538 * nr_disks is not constant
539 */
540 tmp1->nr_disks = 0;
541 tmp2->nr_disks = 0;
542
543 if (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4))
544 ret = 0;
545 else
546 ret = 1;
547
548 abort:
549 kfree(tmp1);
550 kfree(tmp2);
551 return ret;
552 }
553
554 static unsigned int calc_sb_csum(mdp_super_t * sb)
555 {
556 unsigned int disk_csum, csum;
557
558 disk_csum = sb->sb_csum;
559 sb->sb_csum = 0;
560 csum = csum_partial((void *)sb, MD_SB_BYTES, 0);
561 sb->sb_csum = disk_csum;
562 return csum;
563 }
564
565
566 /*
567 * Handle superblock details.
568 * We want to be able to handle multiple superblock formats
569 * so we have a common interface to them all, and an array of
570 * different handlers.
571 * We rely on user-space to write the initial superblock, and support
572 * reading and updating of superblocks.
573 * Interface methods are:
574 * int load_super(mdk_rdev_t *dev, mdk_rdev_t *refdev, int minor_version)
575 * loads and validates a superblock on dev.
576 * if refdev != NULL, compare superblocks on both devices
577 * Return:
578 * 0 - dev has a superblock that is compatible with refdev
579 * 1 - dev has a superblock that is compatible and newer than refdev
580 * so dev should be used as the refdev in future
581 * -EINVAL superblock incompatible or invalid
582 * -othererror e.g. -EIO
583 *
584 * int validate_super(mddev_t *mddev, mdk_rdev_t *dev)
585 * Verify that dev is acceptable into mddev.
586 * The first time, mddev->raid_disks will be 0, and data from
587 * dev should be merged in. Subsequent calls check that dev
588 * is new enough. Return 0 or -EINVAL
589 *
590 * void sync_super(mddev_t *mddev, mdk_rdev_t *dev)
591 * Update the superblock for rdev with data in mddev
592 * This does not write to disc.
593 *
594 */
595
596 struct super_type {
597 char *name;
598 struct module *owner;
599 int (*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version);
600 int (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
601 void (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
602 };
603
604 /*
605 * load_super for 0.90.0
606 */
607 static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
608 {
609 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
610 mdp_super_t *sb;
611 int ret;
612 sector_t sb_offset;
613
614 /*
615 * Calculate the position of the superblock,
616 * it's at the end of the disk.
617 *
618 * It also happens to be a multiple of 4Kb.
619 */
620 sb_offset = calc_dev_sboffset(rdev->bdev);
621 rdev->sb_offset = sb_offset;
622
623 ret = read_disk_sb(rdev, MD_SB_BYTES);
624 if (ret) return ret;
625
626 ret = -EINVAL;
627
628 bdevname(rdev->bdev, b);
629 sb = (mdp_super_t*)page_address(rdev->sb_page);
630
631 if (sb->md_magic != MD_SB_MAGIC) {
632 printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
633 b);
634 goto abort;
635 }
636
637 if (sb->major_version != 0 ||
638 sb->minor_version != 90) {
639 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
640 sb->major_version, sb->minor_version,
641 b);
642 goto abort;
643 }
644
645 if (sb->raid_disks <= 0)
646 goto abort;
647
648 if (csum_fold(calc_sb_csum(sb)) != csum_fold(sb->sb_csum)) {
649 printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
650 b);
651 goto abort;
652 }
653
654 rdev->preferred_minor = sb->md_minor;
655 rdev->data_offset = 0;
656 rdev->sb_size = MD_SB_BYTES;
657
658 if (sb->level == LEVEL_MULTIPATH)
659 rdev->desc_nr = -1;
660 else
661 rdev->desc_nr = sb->this_disk.number;
662
663 if (refdev == 0)
664 ret = 1;
665 else {
666 __u64 ev1, ev2;
667 mdp_super_t *refsb = (mdp_super_t*)page_address(refdev->sb_page);
668 if (!uuid_equal(refsb, sb)) {
669 printk(KERN_WARNING "md: %s has different UUID to %s\n",
670 b, bdevname(refdev->bdev,b2));
671 goto abort;
672 }
673 if (!sb_equal(refsb, sb)) {
674 printk(KERN_WARNING "md: %s has same UUID"
675 " but different superblock to %s\n",
676 b, bdevname(refdev->bdev, b2));
677 goto abort;
678 }
679 ev1 = md_event(sb);
680 ev2 = md_event(refsb);
681 if (ev1 > ev2)
682 ret = 1;
683 else
684 ret = 0;
685 }
686 rdev->size = calc_dev_size(rdev, sb->chunk_size);
687
688 abort:
689 return ret;
690 }
691
692 /*
693 * validate_super for 0.90.0
694 */
695 static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
696 {
697 mdp_disk_t *desc;
698 mdp_super_t *sb = (mdp_super_t *)page_address(rdev->sb_page);
699
700 rdev->raid_disk = -1;
701 rdev->flags = 0;
702 if (mddev->raid_disks == 0) {
703 mddev->major_version = 0;
704 mddev->minor_version = sb->minor_version;
705 mddev->patch_version = sb->patch_version;
706 mddev->persistent = ! sb->not_persistent;
707 mddev->chunk_size = sb->chunk_size;
708 mddev->ctime = sb->ctime;
709 mddev->utime = sb->utime;
710 mddev->level = sb->level;
711 mddev->layout = sb->layout;
712 mddev->raid_disks = sb->raid_disks;
713 mddev->size = sb->size;
714 mddev->events = md_event(sb);
715 mddev->bitmap_offset = 0;
716 mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
717
718 if (sb->state & (1<<MD_SB_CLEAN))
719 mddev->recovery_cp = MaxSector;
720 else {
721 if (sb->events_hi == sb->cp_events_hi &&
722 sb->events_lo == sb->cp_events_lo) {
723 mddev->recovery_cp = sb->recovery_cp;
724 } else
725 mddev->recovery_cp = 0;
726 }
727
728 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
729 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
730 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
731 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
732
733 mddev->max_disks = MD_SB_DISKS;
734
735 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
736 mddev->bitmap_file == NULL) {
737 if (mddev->level != 1 && mddev->level != 5 && mddev->level != 6
738 && mddev->level != 10) {
739 /* FIXME use a better test */
740 printk(KERN_WARNING "md: bitmaps not supported for this level.\n");
741 return -EINVAL;
742 }
743 mddev->bitmap_offset = mddev->default_bitmap_offset;
744 }
745
746 } else if (mddev->pers == NULL) {
747 /* Insist on good event counter while assembling */
748 __u64 ev1 = md_event(sb);
749 ++ev1;
750 if (ev1 < mddev->events)
751 return -EINVAL;
752 } else if (mddev->bitmap) {
753 /* if adding to array with a bitmap, then we can accept an
754 * older device ... but not too old.
755 */
756 __u64 ev1 = md_event(sb);
757 if (ev1 < mddev->bitmap->events_cleared)
758 return 0;
759 } else /* just a hot-add of a new device, leave raid_disk at -1 */
760 return 0;
761
762 if (mddev->level != LEVEL_MULTIPATH) {
763 desc = sb->disks + rdev->desc_nr;
764
765 if (desc->state & (1<<MD_DISK_FAULTY))
766 set_bit(Faulty, &rdev->flags);
767 else if (desc->state & (1<<MD_DISK_SYNC) &&
768 desc->raid_disk < mddev->raid_disks) {
769 set_bit(In_sync, &rdev->flags);
770 rdev->raid_disk = desc->raid_disk;
771 }
772 if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
773 set_bit(WriteMostly, &rdev->flags);
774 } else /* MULTIPATH are always insync */
775 set_bit(In_sync, &rdev->flags);
776 return 0;
777 }
778
779 /*
780 * sync_super for 0.90.0
781 */
782 static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
783 {
784 mdp_super_t *sb;
785 struct list_head *tmp;
786 mdk_rdev_t *rdev2;
787 int next_spare = mddev->raid_disks;
788
789
790 /* make rdev->sb match mddev data..
791 *
792 * 1/ zero out disks
793 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
794 * 3/ any empty disks < next_spare become removed
795 *
796 * disks[0] gets initialised to REMOVED because
797 * we cannot be sure from other fields if it has
798 * been initialised or not.
799 */
800 int i;
801 int active=0, working=0,failed=0,spare=0,nr_disks=0;
802
803 rdev->sb_size = MD_SB_BYTES;
804
805 sb = (mdp_super_t*)page_address(rdev->sb_page);
806
807 memset(sb, 0, sizeof(*sb));
808
809 sb->md_magic = MD_SB_MAGIC;
810 sb->major_version = mddev->major_version;
811 sb->minor_version = mddev->minor_version;
812 sb->patch_version = mddev->patch_version;
813 sb->gvalid_words = 0; /* ignored */
814 memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
815 memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
816 memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
817 memcpy(&sb->set_uuid3, mddev->uuid+12,4);
818
819 sb->ctime = mddev->ctime;
820 sb->level = mddev->level;
821 sb->size = mddev->size;
822 sb->raid_disks = mddev->raid_disks;
823 sb->md_minor = mddev->md_minor;
824 sb->not_persistent = !mddev->persistent;
825 sb->utime = mddev->utime;
826 sb->state = 0;
827 sb->events_hi = (mddev->events>>32);
828 sb->events_lo = (u32)mddev->events;
829
830 if (mddev->in_sync)
831 {
832 sb->recovery_cp = mddev->recovery_cp;
833 sb->cp_events_hi = (mddev->events>>32);
834 sb->cp_events_lo = (u32)mddev->events;
835 if (mddev->recovery_cp == MaxSector)
836 sb->state = (1<< MD_SB_CLEAN);
837 } else
838 sb->recovery_cp = 0;
839
840 sb->layout = mddev->layout;
841 sb->chunk_size = mddev->chunk_size;
842
843 if (mddev->bitmap && mddev->bitmap_file == NULL)
844 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
845
846 sb->disks[0].state = (1<<MD_DISK_REMOVED);
847 ITERATE_RDEV(mddev,rdev2,tmp) {
848 mdp_disk_t *d;
849 int desc_nr;
850 if (rdev2->raid_disk >= 0 && test_bit(In_sync, &rdev2->flags)
851 && !test_bit(Faulty, &rdev2->flags))
852 desc_nr = rdev2->raid_disk;
853 else
854 desc_nr = next_spare++;
855 rdev2->desc_nr = desc_nr;
856 d = &sb->disks[rdev2->desc_nr];
857 nr_disks++;
858 d->number = rdev2->desc_nr;
859 d->major = MAJOR(rdev2->bdev->bd_dev);
860 d->minor = MINOR(rdev2->bdev->bd_dev);
861 if (rdev2->raid_disk >= 0 && test_bit(In_sync, &rdev2->flags)
862 && !test_bit(Faulty, &rdev2->flags))
863 d->raid_disk = rdev2->raid_disk;
864 else
865 d->raid_disk = rdev2->desc_nr; /* compatibility */
866 if (test_bit(Faulty, &rdev2->flags)) {
867 d->state = (1<<MD_DISK_FAULTY);
868 failed++;
869 } else if (test_bit(In_sync, &rdev2->flags)) {
870 d->state = (1<<MD_DISK_ACTIVE);
871 d->state |= (1<<MD_DISK_SYNC);
872 active++;
873 working++;
874 } else {
875 d->state = 0;
876 spare++;
877 working++;
878 }
879 if (test_bit(WriteMostly, &rdev2->flags))
880 d->state |= (1<<MD_DISK_WRITEMOSTLY);
881 }
882 /* now set the "removed" and "faulty" bits on any missing devices */
883 for (i=0 ; i < mddev->raid_disks ; i++) {
884 mdp_disk_t *d = &sb->disks[i];
885 if (d->state == 0 && d->number == 0) {
886 d->number = i;
887 d->raid_disk = i;
888 d->state = (1<<MD_DISK_REMOVED);
889 d->state |= (1<<MD_DISK_FAULTY);
890 failed++;
891 }
892 }
893 sb->nr_disks = nr_disks;
894 sb->active_disks = active;
895 sb->working_disks = working;
896 sb->failed_disks = failed;
897 sb->spare_disks = spare;
898
899 sb->this_disk = sb->disks[rdev->desc_nr];
900 sb->sb_csum = calc_sb_csum(sb);
901 }
902
903 /*
904 * version 1 superblock
905 */
906
907 static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
908 {
909 unsigned int disk_csum, csum;
910 unsigned long long newcsum;
911 int size = 256 + le32_to_cpu(sb->max_dev)*2;
912 unsigned int *isuper = (unsigned int*)sb;
913 int i;
914
915 disk_csum = sb->sb_csum;
916 sb->sb_csum = 0;
917 newcsum = 0;
918 for (i=0; size>=4; size -= 4 )
919 newcsum += le32_to_cpu(*isuper++);
920
921 if (size == 2)
922 newcsum += le16_to_cpu(*(unsigned short*) isuper);
923
924 csum = (newcsum & 0xffffffff) + (newcsum >> 32);
925 sb->sb_csum = disk_csum;
926 return cpu_to_le32(csum);
927 }
928
929 static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
930 {
931 struct mdp_superblock_1 *sb;
932 int ret;
933 sector_t sb_offset;
934 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
935 int bmask;
936
937 /*
938 * Calculate the position of the superblock.
939 * It is always aligned to a 4K boundary and
940 * depeding on minor_version, it can be:
941 * 0: At least 8K, but less than 12K, from end of device
942 * 1: At start of device
943 * 2: 4K from start of device.
944 */
945 switch(minor_version) {
946 case 0:
947 sb_offset = rdev->bdev->bd_inode->i_size >> 9;
948 sb_offset -= 8*2;
949 sb_offset &= ~(sector_t)(4*2-1);
950 /* convert from sectors to K */
951 sb_offset /= 2;
952 break;
953 case 1:
954 sb_offset = 0;
955 break;
956 case 2:
957 sb_offset = 4;
958 break;
959 default:
960 return -EINVAL;
961 }
962 rdev->sb_offset = sb_offset;
963
964 /* superblock is rarely larger than 1K, but it can be larger,
965 * and it is safe to read 4k, so we do that
966 */
967 ret = read_disk_sb(rdev, 4096);
968 if (ret) return ret;
969
970
971 sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
972
973 if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
974 sb->major_version != cpu_to_le32(1) ||
975 le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
976 le64_to_cpu(sb->super_offset) != (rdev->sb_offset<<1) ||
977 (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
978 return -EINVAL;
979
980 if (calc_sb_1_csum(sb) != sb->sb_csum) {
981 printk("md: invalid superblock checksum on %s\n",
982 bdevname(rdev->bdev,b));
983 return -EINVAL;
984 }
985 if (le64_to_cpu(sb->data_size) < 10) {
986 printk("md: data_size too small on %s\n",
987 bdevname(rdev->bdev,b));
988 return -EINVAL;
989 }
990 rdev->preferred_minor = 0xffff;
991 rdev->data_offset = le64_to_cpu(sb->data_offset);
992
993 rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
994 bmask = queue_hardsect_size(rdev->bdev->bd_disk->queue)-1;
995 if (rdev->sb_size & bmask)
996 rdev-> sb_size = (rdev->sb_size | bmask)+1;
997
998 if (refdev == 0)
999 return 1;
1000 else {
1001 __u64 ev1, ev2;
1002 struct mdp_superblock_1 *refsb =
1003 (struct mdp_superblock_1*)page_address(refdev->sb_page);
1004
1005 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1006 sb->level != refsb->level ||
1007 sb->layout != refsb->layout ||
1008 sb->chunksize != refsb->chunksize) {
1009 printk(KERN_WARNING "md: %s has strangely different"
1010 " superblock to %s\n",
1011 bdevname(rdev->bdev,b),
1012 bdevname(refdev->bdev,b2));
1013 return -EINVAL;
1014 }
1015 ev1 = le64_to_cpu(sb->events);
1016 ev2 = le64_to_cpu(refsb->events);
1017
1018 if (ev1 > ev2)
1019 return 1;
1020 }
1021 if (minor_version)
1022 rdev->size = ((rdev->bdev->bd_inode->i_size>>9) - le64_to_cpu(sb->data_offset)) / 2;
1023 else
1024 rdev->size = rdev->sb_offset;
1025 if (rdev->size < le64_to_cpu(sb->data_size)/2)
1026 return -EINVAL;
1027 rdev->size = le64_to_cpu(sb->data_size)/2;
1028 if (le32_to_cpu(sb->chunksize))
1029 rdev->size &= ~((sector_t)le32_to_cpu(sb->chunksize)/2 - 1);
1030 return 0;
1031 }
1032
1033 static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
1034 {
1035 struct mdp_superblock_1 *sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
1036
1037 rdev->raid_disk = -1;
1038 rdev->flags = 0;
1039 if (mddev->raid_disks == 0) {
1040 mddev->major_version = 1;
1041 mddev->patch_version = 0;
1042 mddev->persistent = 1;
1043 mddev->chunk_size = le32_to_cpu(sb->chunksize) << 9;
1044 mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
1045 mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
1046 mddev->level = le32_to_cpu(sb->level);
1047 mddev->layout = le32_to_cpu(sb->layout);
1048 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
1049 mddev->size = le64_to_cpu(sb->size)/2;
1050 mddev->events = le64_to_cpu(sb->events);
1051 mddev->bitmap_offset = 0;
1052 mddev->default_bitmap_offset = 1024;
1053
1054 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1055 memcpy(mddev->uuid, sb->set_uuid, 16);
1056
1057 mddev->max_disks = (4096-256)/2;
1058
1059 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1060 mddev->bitmap_file == NULL ) {
1061 if (mddev->level != 1 && mddev->level != 5 && mddev->level != 6
1062 && mddev->level != 10) {
1063 printk(KERN_WARNING "md: bitmaps not supported for this level.\n");
1064 return -EINVAL;
1065 }
1066 mddev->bitmap_offset = (__s32)le32_to_cpu(sb->bitmap_offset);
1067 }
1068 } else if (mddev->pers == NULL) {
1069 /* Insist of good event counter while assembling */
1070 __u64 ev1 = le64_to_cpu(sb->events);
1071 ++ev1;
1072 if (ev1 < mddev->events)
1073 return -EINVAL;
1074 } else if (mddev->bitmap) {
1075 /* If adding to array with a bitmap, then we can accept an
1076 * older device, but not too old.
1077 */
1078 __u64 ev1 = le64_to_cpu(sb->events);
1079 if (ev1 < mddev->bitmap->events_cleared)
1080 return 0;
1081 } else /* just a hot-add of a new device, leave raid_disk at -1 */
1082 return 0;
1083
1084 if (mddev->level != LEVEL_MULTIPATH) {
1085 int role;
1086 rdev->desc_nr = le32_to_cpu(sb->dev_number);
1087 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
1088 switch(role) {
1089 case 0xffff: /* spare */
1090 break;
1091 case 0xfffe: /* faulty */
1092 set_bit(Faulty, &rdev->flags);
1093 break;
1094 default:
1095 set_bit(In_sync, &rdev->flags);
1096 rdev->raid_disk = role;
1097 break;
1098 }
1099 if (sb->devflags & WriteMostly1)
1100 set_bit(WriteMostly, &rdev->flags);
1101 } else /* MULTIPATH are always insync */
1102 set_bit(In_sync, &rdev->flags);
1103
1104 return 0;
1105 }
1106
1107 static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
1108 {
1109 struct mdp_superblock_1 *sb;
1110 struct list_head *tmp;
1111 mdk_rdev_t *rdev2;
1112 int max_dev, i;
1113 /* make rdev->sb match mddev and rdev data. */
1114
1115 sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
1116
1117 sb->feature_map = 0;
1118 sb->pad0 = 0;
1119 memset(sb->pad1, 0, sizeof(sb->pad1));
1120 memset(sb->pad2, 0, sizeof(sb->pad2));
1121 memset(sb->pad3, 0, sizeof(sb->pad3));
1122
1123 sb->utime = cpu_to_le64((__u64)mddev->utime);
1124 sb->events = cpu_to_le64(mddev->events);
1125 if (mddev->in_sync)
1126 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
1127 else
1128 sb->resync_offset = cpu_to_le64(0);
1129
1130 if (mddev->bitmap && mddev->bitmap_file == NULL) {
1131 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_offset);
1132 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1133 }
1134
1135 max_dev = 0;
1136 ITERATE_RDEV(mddev,rdev2,tmp)
1137 if (rdev2->desc_nr+1 > max_dev)
1138 max_dev = rdev2->desc_nr+1;
1139
1140 sb->max_dev = cpu_to_le32(max_dev);
1141 for (i=0; i<max_dev;i++)
1142 sb->dev_roles[i] = cpu_to_le16(0xfffe);
1143
1144 ITERATE_RDEV(mddev,rdev2,tmp) {
1145 i = rdev2->desc_nr;
1146 if (test_bit(Faulty, &rdev2->flags))
1147 sb->dev_roles[i] = cpu_to_le16(0xfffe);
1148 else if (test_bit(In_sync, &rdev2->flags))
1149 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1150 else
1151 sb->dev_roles[i] = cpu_to_le16(0xffff);
1152 }
1153
1154 sb->recovery_offset = cpu_to_le64(0); /* not supported yet */
1155 sb->sb_csum = calc_sb_1_csum(sb);
1156 }
1157
1158
1159 static struct super_type super_types[] = {
1160 [0] = {
1161 .name = "0.90.0",
1162 .owner = THIS_MODULE,
1163 .load_super = super_90_load,
1164 .validate_super = super_90_validate,
1165 .sync_super = super_90_sync,
1166 },
1167 [1] = {
1168 .name = "md-1",
1169 .owner = THIS_MODULE,
1170 .load_super = super_1_load,
1171 .validate_super = super_1_validate,
1172 .sync_super = super_1_sync,
1173 },
1174 };
1175
1176 static mdk_rdev_t * match_dev_unit(mddev_t *mddev, mdk_rdev_t *dev)
1177 {
1178 struct list_head *tmp;
1179 mdk_rdev_t *rdev;
1180
1181 ITERATE_RDEV(mddev,rdev,tmp)
1182 if (rdev->bdev->bd_contains == dev->bdev->bd_contains)
1183 return rdev;
1184
1185 return NULL;
1186 }
1187
1188 static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
1189 {
1190 struct list_head *tmp;
1191 mdk_rdev_t *rdev;
1192
1193 ITERATE_RDEV(mddev1,rdev,tmp)
1194 if (match_dev_unit(mddev2, rdev))
1195 return 1;
1196
1197 return 0;
1198 }
1199
1200 static LIST_HEAD(pending_raid_disks);
1201
1202 static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
1203 {
1204 mdk_rdev_t *same_pdev;
1205 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1206 struct kobject *ko;
1207
1208 if (rdev->mddev) {
1209 MD_BUG();
1210 return -EINVAL;
1211 }
1212 same_pdev = match_dev_unit(mddev, rdev);
1213 if (same_pdev)
1214 printk(KERN_WARNING
1215 "%s: WARNING: %s appears to be on the same physical"
1216 " disk as %s. True\n protection against single-disk"
1217 " failure might be compromised.\n",
1218 mdname(mddev), bdevname(rdev->bdev,b),
1219 bdevname(same_pdev->bdev,b2));
1220
1221 /* Verify rdev->desc_nr is unique.
1222 * If it is -1, assign a free number, else
1223 * check number is not in use
1224 */
1225 if (rdev->desc_nr < 0) {
1226 int choice = 0;
1227 if (mddev->pers) choice = mddev->raid_disks;
1228 while (find_rdev_nr(mddev, choice))
1229 choice++;
1230 rdev->desc_nr = choice;
1231 } else {
1232 if (find_rdev_nr(mddev, rdev->desc_nr))
1233 return -EBUSY;
1234 }
1235 bdevname(rdev->bdev,b);
1236 if (kobject_set_name(&rdev->kobj, "dev-%s", b) < 0)
1237 return -ENOMEM;
1238
1239 list_add(&rdev->same_set, &mddev->disks);
1240 rdev->mddev = mddev;
1241 printk(KERN_INFO "md: bind<%s>\n", b);
1242
1243 rdev->kobj.parent = &mddev->kobj;
1244 kobject_add(&rdev->kobj);
1245
1246 if (rdev->bdev->bd_part)
1247 ko = &rdev->bdev->bd_part->kobj;
1248 else
1249 ko = &rdev->bdev->bd_disk->kobj;
1250 sysfs_create_link(&rdev->kobj, ko, "block");
1251 return 0;
1252 }
1253
1254 static void unbind_rdev_from_array(mdk_rdev_t * rdev)
1255 {
1256 char b[BDEVNAME_SIZE];
1257 if (!rdev->mddev) {
1258 MD_BUG();
1259 return;
1260 }
1261 list_del_init(&rdev->same_set);
1262 printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
1263 rdev->mddev = NULL;
1264 sysfs_remove_link(&rdev->kobj, "block");
1265 kobject_del(&rdev->kobj);
1266 }
1267
1268 /*
1269 * prevent the device from being mounted, repartitioned or
1270 * otherwise reused by a RAID array (or any other kernel
1271 * subsystem), by bd_claiming the device.
1272 */
1273 static int lock_rdev(mdk_rdev_t *rdev, dev_t dev)
1274 {
1275 int err = 0;
1276 struct block_device *bdev;
1277 char b[BDEVNAME_SIZE];
1278
1279 bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
1280 if (IS_ERR(bdev)) {
1281 printk(KERN_ERR "md: could not open %s.\n",
1282 __bdevname(dev, b));
1283 return PTR_ERR(bdev);
1284 }
1285 err = bd_claim(bdev, rdev);
1286 if (err) {
1287 printk(KERN_ERR "md: could not bd_claim %s.\n",
1288 bdevname(bdev, b));
1289 blkdev_put(bdev);
1290 return err;
1291 }
1292 rdev->bdev = bdev;
1293 return err;
1294 }
1295
1296 static void unlock_rdev(mdk_rdev_t *rdev)
1297 {
1298 struct block_device *bdev = rdev->bdev;
1299 rdev->bdev = NULL;
1300 if (!bdev)
1301 MD_BUG();
1302 bd_release(bdev);
1303 blkdev_put(bdev);
1304 }
1305
1306 void md_autodetect_dev(dev_t dev);
1307
1308 static void export_rdev(mdk_rdev_t * rdev)
1309 {
1310 char b[BDEVNAME_SIZE];
1311 printk(KERN_INFO "md: export_rdev(%s)\n",
1312 bdevname(rdev->bdev,b));
1313 if (rdev->mddev)
1314 MD_BUG();
1315 free_disk_sb(rdev);
1316 list_del_init(&rdev->same_set);
1317 #ifndef MODULE
1318 md_autodetect_dev(rdev->bdev->bd_dev);
1319 #endif
1320 unlock_rdev(rdev);
1321 kobject_put(&rdev->kobj);
1322 }
1323
1324 static void kick_rdev_from_array(mdk_rdev_t * rdev)
1325 {
1326 unbind_rdev_from_array(rdev);
1327 export_rdev(rdev);
1328 }
1329
1330 static void export_array(mddev_t *mddev)
1331 {
1332 struct list_head *tmp;
1333 mdk_rdev_t *rdev;
1334
1335 ITERATE_RDEV(mddev,rdev,tmp) {
1336 if (!rdev->mddev) {
1337 MD_BUG();
1338 continue;
1339 }
1340 kick_rdev_from_array(rdev);
1341 }
1342 if (!list_empty(&mddev->disks))
1343 MD_BUG();
1344 mddev->raid_disks = 0;
1345 mddev->major_version = 0;
1346 }
1347
1348 static void print_desc(mdp_disk_t *desc)
1349 {
1350 printk(" DISK<N:%d,(%d,%d),R:%d,S:%d>\n", desc->number,
1351 desc->major,desc->minor,desc->raid_disk,desc->state);
1352 }
1353
1354 static void print_sb(mdp_super_t *sb)
1355 {
1356 int i;
1357
1358 printk(KERN_INFO
1359 "md: SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n",
1360 sb->major_version, sb->minor_version, sb->patch_version,
1361 sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3,
1362 sb->ctime);
1363 printk(KERN_INFO "md: L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n",
1364 sb->level, sb->size, sb->nr_disks, sb->raid_disks,
1365 sb->md_minor, sb->layout, sb->chunk_size);
1366 printk(KERN_INFO "md: UT:%08x ST:%d AD:%d WD:%d"
1367 " FD:%d SD:%d CSUM:%08x E:%08lx\n",
1368 sb->utime, sb->state, sb->active_disks, sb->working_disks,
1369 sb->failed_disks, sb->spare_disks,
1370 sb->sb_csum, (unsigned long)sb->events_lo);
1371
1372 printk(KERN_INFO);
1373 for (i = 0; i < MD_SB_DISKS; i++) {
1374 mdp_disk_t *desc;
1375
1376 desc = sb->disks + i;
1377 if (desc->number || desc->major || desc->minor ||
1378 desc->raid_disk || (desc->state && (desc->state != 4))) {
1379 printk(" D %2d: ", i);
1380 print_desc(desc);
1381 }
1382 }
1383 printk(KERN_INFO "md: THIS: ");
1384 print_desc(&sb->this_disk);
1385
1386 }
1387
1388 static void print_rdev(mdk_rdev_t *rdev)
1389 {
1390 char b[BDEVNAME_SIZE];
1391 printk(KERN_INFO "md: rdev %s, SZ:%08llu F:%d S:%d DN:%u\n",
1392 bdevname(rdev->bdev,b), (unsigned long long)rdev->size,
1393 test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags),
1394 rdev->desc_nr);
1395 if (rdev->sb_loaded) {
1396 printk(KERN_INFO "md: rdev superblock:\n");
1397 print_sb((mdp_super_t*)page_address(rdev->sb_page));
1398 } else
1399 printk(KERN_INFO "md: no rdev superblock!\n");
1400 }
1401
1402 void md_print_devices(void)
1403 {
1404 struct list_head *tmp, *tmp2;
1405 mdk_rdev_t *rdev;
1406 mddev_t *mddev;
1407 char b[BDEVNAME_SIZE];
1408
1409 printk("\n");
1410 printk("md: **********************************\n");
1411 printk("md: * <COMPLETE RAID STATE PRINTOUT> *\n");
1412 printk("md: **********************************\n");
1413 ITERATE_MDDEV(mddev,tmp) {
1414
1415 if (mddev->bitmap)
1416 bitmap_print_sb(mddev->bitmap);
1417 else
1418 printk("%s: ", mdname(mddev));
1419 ITERATE_RDEV(mddev,rdev,tmp2)
1420 printk("<%s>", bdevname(rdev->bdev,b));
1421 printk("\n");
1422
1423 ITERATE_RDEV(mddev,rdev,tmp2)
1424 print_rdev(rdev);
1425 }
1426 printk("md: **********************************\n");
1427 printk("\n");
1428 }
1429
1430
1431 static void sync_sbs(mddev_t * mddev)
1432 {
1433 mdk_rdev_t *rdev;
1434 struct list_head *tmp;
1435
1436 ITERATE_RDEV(mddev,rdev,tmp) {
1437 super_types[mddev->major_version].
1438 sync_super(mddev, rdev);
1439 rdev->sb_loaded = 1;
1440 }
1441 }
1442
1443 static void md_update_sb(mddev_t * mddev)
1444 {
1445 int err;
1446 struct list_head *tmp;
1447 mdk_rdev_t *rdev;
1448 int sync_req;
1449
1450 repeat:
1451 spin_lock_irq(&mddev->write_lock);
1452 sync_req = mddev->in_sync;
1453 mddev->utime = get_seconds();
1454 mddev->events ++;
1455
1456 if (!mddev->events) {
1457 /*
1458 * oops, this 64-bit counter should never wrap.
1459 * Either we are in around ~1 trillion A.C., assuming
1460 * 1 reboot per second, or we have a bug:
1461 */
1462 MD_BUG();
1463 mddev->events --;
1464 }
1465 mddev->sb_dirty = 2;
1466 sync_sbs(mddev);
1467
1468 /*
1469 * do not write anything to disk if using
1470 * nonpersistent superblocks
1471 */
1472 if (!mddev->persistent) {
1473 mddev->sb_dirty = 0;
1474 spin_unlock_irq(&mddev->write_lock);
1475 wake_up(&mddev->sb_wait);
1476 return;
1477 }
1478 spin_unlock_irq(&mddev->write_lock);
1479
1480 dprintk(KERN_INFO
1481 "md: updating %s RAID superblock on device (in sync %d)\n",
1482 mdname(mddev),mddev->in_sync);
1483
1484 err = bitmap_update_sb(mddev->bitmap);
1485 ITERATE_RDEV(mddev,rdev,tmp) {
1486 char b[BDEVNAME_SIZE];
1487 dprintk(KERN_INFO "md: ");
1488 if (test_bit(Faulty, &rdev->flags))
1489 dprintk("(skipping faulty ");
1490
1491 dprintk("%s ", bdevname(rdev->bdev,b));
1492 if (!test_bit(Faulty, &rdev->flags)) {
1493 md_super_write(mddev,rdev,
1494 rdev->sb_offset<<1, rdev->sb_size,
1495 rdev->sb_page);
1496 dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
1497 bdevname(rdev->bdev,b),
1498 (unsigned long long)rdev->sb_offset);
1499
1500 } else
1501 dprintk(")\n");
1502 if (mddev->level == LEVEL_MULTIPATH)
1503 /* only need to write one superblock... */
1504 break;
1505 }
1506 md_super_wait(mddev);
1507 /* if there was a failure, sb_dirty was set to 1, and we re-write super */
1508
1509 spin_lock_irq(&mddev->write_lock);
1510 if (mddev->in_sync != sync_req|| mddev->sb_dirty == 1) {
1511 /* have to write it out again */
1512 spin_unlock_irq(&mddev->write_lock);
1513 goto repeat;
1514 }
1515 mddev->sb_dirty = 0;
1516 spin_unlock_irq(&mddev->write_lock);
1517 wake_up(&mddev->sb_wait);
1518
1519 }
1520
1521 struct rdev_sysfs_entry {
1522 struct attribute attr;
1523 ssize_t (*show)(mdk_rdev_t *, char *);
1524 ssize_t (*store)(mdk_rdev_t *, const char *, size_t);
1525 };
1526
1527 static ssize_t
1528 state_show(mdk_rdev_t *rdev, char *page)
1529 {
1530 char *sep = "";
1531 int len=0;
1532
1533 if (test_bit(Faulty, &rdev->flags)) {
1534 len+= sprintf(page+len, "%sfaulty",sep);
1535 sep = ",";
1536 }
1537 if (test_bit(In_sync, &rdev->flags)) {
1538 len += sprintf(page+len, "%sin_sync",sep);
1539 sep = ",";
1540 }
1541 if (!test_bit(Faulty, &rdev->flags) &&
1542 !test_bit(In_sync, &rdev->flags)) {
1543 len += sprintf(page+len, "%sspare", sep);
1544 sep = ",";
1545 }
1546 return len+sprintf(page+len, "\n");
1547 }
1548
1549 static struct rdev_sysfs_entry
1550 rdev_state = __ATTR_RO(state);
1551
1552 static ssize_t
1553 super_show(mdk_rdev_t *rdev, char *page)
1554 {
1555 if (rdev->sb_loaded && rdev->sb_size) {
1556 memcpy(page, page_address(rdev->sb_page), rdev->sb_size);
1557 return rdev->sb_size;
1558 } else
1559 return 0;
1560 }
1561 static struct rdev_sysfs_entry rdev_super = __ATTR_RO(super);
1562
1563 static struct attribute *rdev_default_attrs[] = {
1564 &rdev_state.attr,
1565 &rdev_super.attr,
1566 NULL,
1567 };
1568 static ssize_t
1569 rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
1570 {
1571 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
1572 mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
1573
1574 if (!entry->show)
1575 return -EIO;
1576 return entry->show(rdev, page);
1577 }
1578
1579 static ssize_t
1580 rdev_attr_store(struct kobject *kobj, struct attribute *attr,
1581 const char *page, size_t length)
1582 {
1583 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
1584 mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
1585
1586 if (!entry->store)
1587 return -EIO;
1588 return entry->store(rdev, page, length);
1589 }
1590
1591 static void rdev_free(struct kobject *ko)
1592 {
1593 mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj);
1594 kfree(rdev);
1595 }
1596 static struct sysfs_ops rdev_sysfs_ops = {
1597 .show = rdev_attr_show,
1598 .store = rdev_attr_store,
1599 };
1600 static struct kobj_type rdev_ktype = {
1601 .release = rdev_free,
1602 .sysfs_ops = &rdev_sysfs_ops,
1603 .default_attrs = rdev_default_attrs,
1604 };
1605
1606 /*
1607 * Import a device. If 'super_format' >= 0, then sanity check the superblock
1608 *
1609 * mark the device faulty if:
1610 *
1611 * - the device is nonexistent (zero size)
1612 * - the device has no valid superblock
1613 *
1614 * a faulty rdev _never_ has rdev->sb set.
1615 */
1616 static mdk_rdev_t *md_import_device(dev_t newdev, int super_format, int super_minor)
1617 {
1618 char b[BDEVNAME_SIZE];
1619 int err;
1620 mdk_rdev_t *rdev;
1621 sector_t size;
1622
1623 rdev = (mdk_rdev_t *) kmalloc(sizeof(*rdev), GFP_KERNEL);
1624 if (!rdev) {
1625 printk(KERN_ERR "md: could not alloc mem for new device!\n");
1626 return ERR_PTR(-ENOMEM);
1627 }
1628 memset(rdev, 0, sizeof(*rdev));
1629
1630 if ((err = alloc_disk_sb(rdev)))
1631 goto abort_free;
1632
1633 err = lock_rdev(rdev, newdev);
1634 if (err)
1635 goto abort_free;
1636
1637 rdev->kobj.parent = NULL;
1638 rdev->kobj.ktype = &rdev_ktype;
1639 kobject_init(&rdev->kobj);
1640
1641 rdev->desc_nr = -1;
1642 rdev->flags = 0;
1643 rdev->data_offset = 0;
1644 atomic_set(&rdev->nr_pending, 0);
1645 atomic_set(&rdev->read_errors, 0);
1646
1647 size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
1648 if (!size) {
1649 printk(KERN_WARNING
1650 "md: %s has zero or unknown size, marking faulty!\n",
1651 bdevname(rdev->bdev,b));
1652 err = -EINVAL;
1653 goto abort_free;
1654 }
1655
1656 if (super_format >= 0) {
1657 err = super_types[super_format].
1658 load_super(rdev, NULL, super_minor);
1659 if (err == -EINVAL) {
1660 printk(KERN_WARNING
1661 "md: %s has invalid sb, not importing!\n",
1662 bdevname(rdev->bdev,b));
1663 goto abort_free;
1664 }
1665 if (err < 0) {
1666 printk(KERN_WARNING
1667 "md: could not read %s's sb, not importing!\n",
1668 bdevname(rdev->bdev,b));
1669 goto abort_free;
1670 }
1671 }
1672 INIT_LIST_HEAD(&rdev->same_set);
1673
1674 return rdev;
1675
1676 abort_free:
1677 if (rdev->sb_page) {
1678 if (rdev->bdev)
1679 unlock_rdev(rdev);
1680 free_disk_sb(rdev);
1681 }
1682 kfree(rdev);
1683 return ERR_PTR(err);
1684 }
1685
1686 /*
1687 * Check a full RAID array for plausibility
1688 */
1689
1690
1691 static void analyze_sbs(mddev_t * mddev)
1692 {
1693 int i;
1694 struct list_head *tmp;
1695 mdk_rdev_t *rdev, *freshest;
1696 char b[BDEVNAME_SIZE];
1697
1698 freshest = NULL;
1699 ITERATE_RDEV(mddev,rdev,tmp)
1700 switch (super_types[mddev->major_version].
1701 load_super(rdev, freshest, mddev->minor_version)) {
1702 case 1:
1703 freshest = rdev;
1704 break;
1705 case 0:
1706 break;
1707 default:
1708 printk( KERN_ERR \
1709 "md: fatal superblock inconsistency in %s"
1710 " -- removing from array\n",
1711 bdevname(rdev->bdev,b));
1712 kick_rdev_from_array(rdev);
1713 }
1714
1715
1716 super_types[mddev->major_version].
1717 validate_super(mddev, freshest);
1718
1719 i = 0;
1720 ITERATE_RDEV(mddev,rdev,tmp) {
1721 if (rdev != freshest)
1722 if (super_types[mddev->major_version].
1723 validate_super(mddev, rdev)) {
1724 printk(KERN_WARNING "md: kicking non-fresh %s"
1725 " from array!\n",
1726 bdevname(rdev->bdev,b));
1727 kick_rdev_from_array(rdev);
1728 continue;
1729 }
1730 if (mddev->level == LEVEL_MULTIPATH) {
1731 rdev->desc_nr = i++;
1732 rdev->raid_disk = rdev->desc_nr;
1733 set_bit(In_sync, &rdev->flags);
1734 }
1735 }
1736
1737
1738
1739 if (mddev->recovery_cp != MaxSector &&
1740 mddev->level >= 1)
1741 printk(KERN_ERR "md: %s: raid array is not clean"
1742 " -- starting background reconstruction\n",
1743 mdname(mddev));
1744
1745 }
1746
1747 static ssize_t
1748 level_show(mddev_t *mddev, char *page)
1749 {
1750 mdk_personality_t *p = mddev->pers;
1751 if (p == NULL && mddev->raid_disks == 0)
1752 return 0;
1753 if (mddev->level >= 0)
1754 return sprintf(page, "raid%d\n", mddev->level);
1755 else
1756 return sprintf(page, "%s\n", p->name);
1757 }
1758
1759 static struct md_sysfs_entry md_level = __ATTR_RO(level);
1760
1761 static ssize_t
1762 raid_disks_show(mddev_t *mddev, char *page)
1763 {
1764 if (mddev->raid_disks == 0)
1765 return 0;
1766 return sprintf(page, "%d\n", mddev->raid_disks);
1767 }
1768
1769 static struct md_sysfs_entry md_raid_disks = __ATTR_RO(raid_disks);
1770
1771 static ssize_t
1772 action_show(mddev_t *mddev, char *page)
1773 {
1774 char *type = "idle";
1775 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
1776 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) {
1777 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
1778 if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
1779 type = "resync";
1780 else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
1781 type = "check";
1782 else
1783 type = "repair";
1784 } else
1785 type = "recover";
1786 }
1787 return sprintf(page, "%s\n", type);
1788 }
1789
1790 static ssize_t
1791 action_store(mddev_t *mddev, const char *page, size_t len)
1792 {
1793 if (!mddev->pers || !mddev->pers->sync_request)
1794 return -EINVAL;
1795
1796 if (strcmp(page, "idle")==0 || strcmp(page, "idle\n")==0) {
1797 if (mddev->sync_thread) {
1798 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
1799 md_unregister_thread(mddev->sync_thread);
1800 mddev->sync_thread = NULL;
1801 mddev->recovery = 0;
1802 }
1803 return len;
1804 }
1805
1806 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
1807 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
1808 return -EBUSY;
1809 if (strcmp(page, "resync")==0 || strcmp(page, "resync\n")==0 ||
1810 strcmp(page, "recover")==0 || strcmp(page, "recover\n")==0)
1811 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
1812 else {
1813 if (strcmp(page, "check")==0 || strcmp(page, "check\n")==0)
1814 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
1815 else if (strcmp(page, "repair")!=0 && strcmp(page, "repair\n")!=0)
1816 return -EINVAL;
1817 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
1818 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
1819 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
1820 }
1821 md_wakeup_thread(mddev->thread);
1822 return len;
1823 }
1824
1825 static ssize_t
1826 mismatch_cnt_show(mddev_t *mddev, char *page)
1827 {
1828 return sprintf(page, "%llu\n",
1829 (unsigned long long) mddev->resync_mismatches);
1830 }
1831
1832 static struct md_sysfs_entry
1833 md_scan_mode = __ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
1834
1835
1836 static struct md_sysfs_entry
1837 md_mismatches = __ATTR_RO(mismatch_cnt);
1838
1839 static struct attribute *md_default_attrs[] = {
1840 &md_level.attr,
1841 &md_raid_disks.attr,
1842 NULL,
1843 };
1844
1845 static struct attribute *md_redundancy_attrs[] = {
1846 &md_scan_mode.attr,
1847 &md_mismatches.attr,
1848 NULL,
1849 };
1850 static struct attribute_group md_redundancy_group = {
1851 .name = NULL,
1852 .attrs = md_redundancy_attrs,
1853 };
1854
1855
1856 static ssize_t
1857 md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
1858 {
1859 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
1860 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
1861 ssize_t rv;
1862
1863 if (!entry->show)
1864 return -EIO;
1865 mddev_lock(mddev);
1866 rv = entry->show(mddev, page);
1867 mddev_unlock(mddev);
1868 return rv;
1869 }
1870
1871 static ssize_t
1872 md_attr_store(struct kobject *kobj, struct attribute *attr,
1873 const char *page, size_t length)
1874 {
1875 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
1876 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
1877 ssize_t rv;
1878
1879 if (!entry->store)
1880 return -EIO;
1881 mddev_lock(mddev);
1882 rv = entry->store(mddev, page, length);
1883 mddev_unlock(mddev);
1884 return rv;
1885 }
1886
1887 static void md_free(struct kobject *ko)
1888 {
1889 mddev_t *mddev = container_of(ko, mddev_t, kobj);
1890 kfree(mddev);
1891 }
1892
1893 static struct sysfs_ops md_sysfs_ops = {
1894 .show = md_attr_show,
1895 .store = md_attr_store,
1896 };
1897 static struct kobj_type md_ktype = {
1898 .release = md_free,
1899 .sysfs_ops = &md_sysfs_ops,
1900 .default_attrs = md_default_attrs,
1901 };
1902
1903 int mdp_major = 0;
1904
1905 static struct kobject *md_probe(dev_t dev, int *part, void *data)
1906 {
1907 static DECLARE_MUTEX(disks_sem);
1908 mddev_t *mddev = mddev_find(dev);
1909 struct gendisk *disk;
1910 int partitioned = (MAJOR(dev) != MD_MAJOR);
1911 int shift = partitioned ? MdpMinorShift : 0;
1912 int unit = MINOR(dev) >> shift;
1913
1914 if (!mddev)
1915 return NULL;
1916
1917 down(&disks_sem);
1918 if (mddev->gendisk) {
1919 up(&disks_sem);
1920 mddev_put(mddev);
1921 return NULL;
1922 }
1923 disk = alloc_disk(1 << shift);
1924 if (!disk) {
1925 up(&disks_sem);
1926 mddev_put(mddev);
1927 return NULL;
1928 }
1929 disk->major = MAJOR(dev);
1930 disk->first_minor = unit << shift;
1931 if (partitioned) {
1932 sprintf(disk->disk_name, "md_d%d", unit);
1933 sprintf(disk->devfs_name, "md/d%d", unit);
1934 } else {
1935 sprintf(disk->disk_name, "md%d", unit);
1936 sprintf(disk->devfs_name, "md/%d", unit);
1937 }
1938 disk->fops = &md_fops;
1939 disk->private_data = mddev;
1940 disk->queue = mddev->queue;
1941 add_disk(disk);
1942 mddev->gendisk = disk;
1943 up(&disks_sem);
1944 mddev->kobj.parent = &disk->kobj;
1945 mddev->kobj.k_name = NULL;
1946 snprintf(mddev->kobj.name, KOBJ_NAME_LEN, "%s", "md");
1947 mddev->kobj.ktype = &md_ktype;
1948 kobject_register(&mddev->kobj);
1949 return NULL;
1950 }
1951
1952 void md_wakeup_thread(mdk_thread_t *thread);
1953
1954 static void md_safemode_timeout(unsigned long data)
1955 {
1956 mddev_t *mddev = (mddev_t *) data;
1957
1958 mddev->safemode = 1;
1959 md_wakeup_thread(mddev->thread);
1960 }
1961
1962 static int start_dirty_degraded;
1963
1964 static int do_md_run(mddev_t * mddev)
1965 {
1966 int pnum, err;
1967 int chunk_size;
1968 struct list_head *tmp;
1969 mdk_rdev_t *rdev;
1970 struct gendisk *disk;
1971 char b[BDEVNAME_SIZE];
1972
1973 if (list_empty(&mddev->disks))
1974 /* cannot run an array with no devices.. */
1975 return -EINVAL;
1976
1977 if (mddev->pers)
1978 return -EBUSY;
1979
1980 /*
1981 * Analyze all RAID superblock(s)
1982 */
1983 if (!mddev->raid_disks)
1984 analyze_sbs(mddev);
1985
1986 chunk_size = mddev->chunk_size;
1987 pnum = level_to_pers(mddev->level);
1988
1989 if ((pnum != MULTIPATH) && (pnum != RAID1)) {
1990 if (!chunk_size) {
1991 /*
1992 * 'default chunksize' in the old md code used to
1993 * be PAGE_SIZE, baaad.
1994 * we abort here to be on the safe side. We don't
1995 * want to continue the bad practice.
1996 */
1997 printk(KERN_ERR
1998 "no chunksize specified, see 'man raidtab'\n");
1999 return -EINVAL;
2000 }
2001 if (chunk_size > MAX_CHUNK_SIZE) {
2002 printk(KERN_ERR "too big chunk_size: %d > %d\n",
2003 chunk_size, MAX_CHUNK_SIZE);
2004 return -EINVAL;
2005 }
2006 /*
2007 * chunk-size has to be a power of 2 and multiples of PAGE_SIZE
2008 */
2009 if ( (1 << ffz(~chunk_size)) != chunk_size) {
2010 printk(KERN_ERR "chunk_size of %d not valid\n", chunk_size);
2011 return -EINVAL;
2012 }
2013 if (chunk_size < PAGE_SIZE) {
2014 printk(KERN_ERR "too small chunk_size: %d < %ld\n",
2015 chunk_size, PAGE_SIZE);
2016 return -EINVAL;
2017 }
2018
2019 /* devices must have minimum size of one chunk */
2020 ITERATE_RDEV(mddev,rdev,tmp) {
2021 if (test_bit(Faulty, &rdev->flags))
2022 continue;
2023 if (rdev->size < chunk_size / 1024) {
2024 printk(KERN_WARNING
2025 "md: Dev %s smaller than chunk_size:"
2026 " %lluk < %dk\n",
2027 bdevname(rdev->bdev,b),
2028 (unsigned long long)rdev->size,
2029 chunk_size / 1024);
2030 return -EINVAL;
2031 }
2032 }
2033 }
2034
2035 #ifdef CONFIG_KMOD
2036 if (!pers[pnum])
2037 {
2038 request_module("md-personality-%d", pnum);
2039 }
2040 #endif
2041
2042 /*
2043 * Drop all container device buffers, from now on
2044 * the only valid external interface is through the md
2045 * device.
2046 * Also find largest hardsector size
2047 */
2048 ITERATE_RDEV(mddev,rdev,tmp) {
2049 if (test_bit(Faulty, &rdev->flags))
2050 continue;
2051 sync_blockdev(rdev->bdev);
2052 invalidate_bdev(rdev->bdev, 0);
2053 }
2054
2055 md_probe(mddev->unit, NULL, NULL);
2056 disk = mddev->gendisk;
2057 if (!disk)
2058 return -ENOMEM;
2059
2060 spin_lock(&pers_lock);
2061 if (!pers[pnum] || !try_module_get(pers[pnum]->owner)) {
2062 spin_unlock(&pers_lock);
2063 printk(KERN_WARNING "md: personality %d is not loaded!\n",
2064 pnum);
2065 return -EINVAL;
2066 }
2067
2068 mddev->pers = pers[pnum];
2069 spin_unlock(&pers_lock);
2070
2071 mddev->recovery = 0;
2072 mddev->resync_max_sectors = mddev->size << 1; /* may be over-ridden by personality */
2073 mddev->barriers_work = 1;
2074 mddev->ok_start_degraded = start_dirty_degraded;
2075
2076 if (start_readonly)
2077 mddev->ro = 2; /* read-only, but switch on first write */
2078
2079 err = mddev->pers->run(mddev);
2080 if (!err && mddev->pers->sync_request) {
2081 err = bitmap_create(mddev);
2082 if (err) {
2083 printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
2084 mdname(mddev), err);
2085 mddev->pers->stop(mddev);
2086 }
2087 }
2088 if (err) {
2089 printk(KERN_ERR "md: pers->run() failed ...\n");
2090 module_put(mddev->pers->owner);
2091 mddev->pers = NULL;
2092 bitmap_destroy(mddev);
2093 return err;
2094 }
2095 if (mddev->pers->sync_request)
2096 sysfs_create_group(&mddev->kobj, &md_redundancy_group);
2097 else if (mddev->ro == 2) /* auto-readonly not meaningful */
2098 mddev->ro = 0;
2099
2100 atomic_set(&mddev->writes_pending,0);
2101 mddev->safemode = 0;
2102 mddev->safemode_timer.function = md_safemode_timeout;
2103 mddev->safemode_timer.data = (unsigned long) mddev;
2104 mddev->safemode_delay = (20 * HZ)/1000 +1; /* 20 msec delay */
2105 mddev->in_sync = 1;
2106
2107 ITERATE_RDEV(mddev,rdev,tmp)
2108 if (rdev->raid_disk >= 0) {
2109 char nm[20];
2110 sprintf(nm, "rd%d", rdev->raid_disk);
2111 sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
2112 }
2113
2114 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2115 md_wakeup_thread(mddev->thread);
2116
2117 if (mddev->sb_dirty)
2118 md_update_sb(mddev);
2119
2120 set_capacity(disk, mddev->array_size<<1);
2121
2122 /* If we call blk_queue_make_request here, it will
2123 * re-initialise max_sectors etc which may have been
2124 * refined inside -> run. So just set the bits we need to set.
2125 * Most initialisation happended when we called
2126 * blk_queue_make_request(..., md_fail_request)
2127 * earlier.
2128 */
2129 mddev->queue->queuedata = mddev;
2130 mddev->queue->make_request_fn = mddev->pers->make_request;
2131
2132 mddev->changed = 1;
2133 md_new_event(mddev);
2134 return 0;
2135 }
2136
2137 static int restart_array(mddev_t *mddev)
2138 {
2139 struct gendisk *disk = mddev->gendisk;
2140 int err;
2141
2142 /*
2143 * Complain if it has no devices
2144 */
2145 err = -ENXIO;
2146 if (list_empty(&mddev->disks))
2147 goto out;
2148
2149 if (mddev->pers) {
2150 err = -EBUSY;
2151 if (!mddev->ro)
2152 goto out;
2153
2154 mddev->safemode = 0;
2155 mddev->ro = 0;
2156 set_disk_ro(disk, 0);
2157
2158 printk(KERN_INFO "md: %s switched to read-write mode.\n",
2159 mdname(mddev));
2160 /*
2161 * Kick recovery or resync if necessary
2162 */
2163 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2164 md_wakeup_thread(mddev->thread);
2165 err = 0;
2166 } else {
2167 printk(KERN_ERR "md: %s has no personality assigned.\n",
2168 mdname(mddev));
2169 err = -EINVAL;
2170 }
2171
2172 out:
2173 return err;
2174 }
2175
2176 static int do_md_stop(mddev_t * mddev, int ro)
2177 {
2178 int err = 0;
2179 struct gendisk *disk = mddev->gendisk;
2180
2181 if (mddev->pers) {
2182 if (atomic_read(&mddev->active)>2) {
2183 printk("md: %s still in use.\n",mdname(mddev));
2184 return -EBUSY;
2185 }
2186
2187 if (mddev->sync_thread) {
2188 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
2189 md_unregister_thread(mddev->sync_thread);
2190 mddev->sync_thread = NULL;
2191 }
2192
2193 del_timer_sync(&mddev->safemode_timer);
2194
2195 invalidate_partition(disk, 0);
2196
2197 if (ro) {
2198 err = -ENXIO;
2199 if (mddev->ro==1)
2200 goto out;
2201 mddev->ro = 1;
2202 } else {
2203 bitmap_flush(mddev);
2204 md_super_wait(mddev);
2205 if (mddev->ro)
2206 set_disk_ro(disk, 0);
2207 blk_queue_make_request(mddev->queue, md_fail_request);
2208 mddev->pers->stop(mddev);
2209 if (mddev->pers->sync_request)
2210 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
2211
2212 module_put(mddev->pers->owner);
2213 mddev->pers = NULL;
2214 if (mddev->ro)
2215 mddev->ro = 0;
2216 }
2217 if (!mddev->in_sync) {
2218 /* mark array as shutdown cleanly */
2219 mddev->in_sync = 1;
2220 md_update_sb(mddev);
2221 }
2222 if (ro)
2223 set_disk_ro(disk, 1);
2224 }
2225
2226 bitmap_destroy(mddev);
2227 if (mddev->bitmap_file) {
2228 atomic_set(&mddev->bitmap_file->f_dentry->d_inode->i_writecount, 1);
2229 fput(mddev->bitmap_file);
2230 mddev->bitmap_file = NULL;
2231 }
2232 mddev->bitmap_offset = 0;
2233
2234 /*
2235 * Free resources if final stop
2236 */
2237 if (!ro) {
2238 mdk_rdev_t *rdev;
2239 struct list_head *tmp;
2240 struct gendisk *disk;
2241 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
2242
2243 ITERATE_RDEV(mddev,rdev,tmp)
2244 if (rdev->raid_disk >= 0) {
2245 char nm[20];
2246 sprintf(nm, "rd%d", rdev->raid_disk);
2247 sysfs_remove_link(&mddev->kobj, nm);
2248 }
2249
2250 export_array(mddev);
2251
2252 mddev->array_size = 0;
2253 disk = mddev->gendisk;
2254 if (disk)
2255 set_capacity(disk, 0);
2256 mddev->changed = 1;
2257 } else
2258 printk(KERN_INFO "md: %s switched to read-only mode.\n",
2259 mdname(mddev));
2260 err = 0;
2261 md_new_event(mddev);
2262 out:
2263 return err;
2264 }
2265
2266 static void autorun_array(mddev_t *mddev)
2267 {
2268 mdk_rdev_t *rdev;
2269 struct list_head *tmp;
2270 int err;
2271
2272 if (list_empty(&mddev->disks))
2273 return;
2274
2275 printk(KERN_INFO "md: running: ");
2276
2277 ITERATE_RDEV(mddev,rdev,tmp) {
2278 char b[BDEVNAME_SIZE];
2279 printk("<%s>", bdevname(rdev->bdev,b));
2280 }
2281 printk("\n");
2282
2283 err = do_md_run (mddev);
2284 if (err) {
2285 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
2286 do_md_stop (mddev, 0);
2287 }
2288 }
2289
2290 /*
2291 * lets try to run arrays based on all disks that have arrived
2292 * until now. (those are in pending_raid_disks)
2293 *
2294 * the method: pick the first pending disk, collect all disks with
2295 * the same UUID, remove all from the pending list and put them into
2296 * the 'same_array' list. Then order this list based on superblock
2297 * update time (freshest comes first), kick out 'old' disks and
2298 * compare superblocks. If everything's fine then run it.
2299 *
2300 * If "unit" is allocated, then bump its reference count
2301 */
2302 static void autorun_devices(int part)
2303 {
2304 struct list_head candidates;
2305 struct list_head *tmp;
2306 mdk_rdev_t *rdev0, *rdev;
2307 mddev_t *mddev;
2308 char b[BDEVNAME_SIZE];
2309
2310 printk(KERN_INFO "md: autorun ...\n");
2311 while (!list_empty(&pending_raid_disks)) {
2312 dev_t dev;
2313 rdev0 = list_entry(pending_raid_disks.next,
2314 mdk_rdev_t, same_set);
2315
2316 printk(KERN_INFO "md: considering %s ...\n",
2317 bdevname(rdev0->bdev,b));
2318 INIT_LIST_HEAD(&candidates);
2319 ITERATE_RDEV_PENDING(rdev,tmp)
2320 if (super_90_load(rdev, rdev0, 0) >= 0) {
2321 printk(KERN_INFO "md: adding %s ...\n",
2322 bdevname(rdev->bdev,b));
2323 list_move(&rdev->same_set, &candidates);
2324 }
2325 /*
2326 * now we have a set of devices, with all of them having
2327 * mostly sane superblocks. It's time to allocate the
2328 * mddev.
2329 */
2330 if (rdev0->preferred_minor < 0 || rdev0->preferred_minor >= MAX_MD_DEVS) {
2331 printk(KERN_INFO "md: unit number in %s is bad: %d\n",
2332 bdevname(rdev0->bdev, b), rdev0->preferred_minor);
2333 break;
2334 }
2335 if (part)
2336 dev = MKDEV(mdp_major,
2337 rdev0->preferred_minor << MdpMinorShift);
2338 else
2339 dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
2340
2341 md_probe(dev, NULL, NULL);
2342 mddev = mddev_find(dev);
2343 if (!mddev) {
2344 printk(KERN_ERR
2345 "md: cannot allocate memory for md drive.\n");
2346 break;
2347 }
2348 if (mddev_lock(mddev))
2349 printk(KERN_WARNING "md: %s locked, cannot run\n",
2350 mdname(mddev));
2351 else if (mddev->raid_disks || mddev->major_version
2352 || !list_empty(&mddev->disks)) {
2353 printk(KERN_WARNING
2354 "md: %s already running, cannot run %s\n",
2355 mdname(mddev), bdevname(rdev0->bdev,b));
2356 mddev_unlock(mddev);
2357 } else {
2358 printk(KERN_INFO "md: created %s\n", mdname(mddev));
2359 ITERATE_RDEV_GENERIC(candidates,rdev,tmp) {
2360 list_del_init(&rdev->same_set);
2361 if (bind_rdev_to_array(rdev, mddev))
2362 export_rdev(rdev);
2363 }
2364 autorun_array(mddev);
2365 mddev_unlock(mddev);
2366 }
2367 /* on success, candidates will be empty, on error
2368 * it won't...
2369 */
2370 ITERATE_RDEV_GENERIC(candidates,rdev,tmp)
2371 export_rdev(rdev);
2372 mddev_put(mddev);
2373 }
2374 printk(KERN_INFO "md: ... autorun DONE.\n");
2375 }
2376
2377 /*
2378 * import RAID devices based on one partition
2379 * if possible, the array gets run as well.
2380 */
2381
2382 static int autostart_array(dev_t startdev)
2383 {
2384 char b[BDEVNAME_SIZE];
2385 int err = -EINVAL, i;
2386 mdp_super_t *sb = NULL;
2387 mdk_rdev_t *start_rdev = NULL, *rdev;
2388
2389 start_rdev = md_import_device(startdev, 0, 0);
2390 if (IS_ERR(start_rdev))
2391 return err;
2392
2393
2394 /* NOTE: this can only work for 0.90.0 superblocks */
2395 sb = (mdp_super_t*)page_address(start_rdev->sb_page);
2396 if (sb->major_version != 0 ||
2397 sb->minor_version != 90 ) {
2398 printk(KERN_WARNING "md: can only autostart 0.90.0 arrays\n");
2399 export_rdev(start_rdev);
2400 return err;
2401 }
2402
2403 if (test_bit(Faulty, &start_rdev->flags)) {
2404 printk(KERN_WARNING
2405 "md: can not autostart based on faulty %s!\n",
2406 bdevname(start_rdev->bdev,b));
2407 export_rdev(start_rdev);
2408 return err;
2409 }
2410 list_add(&start_rdev->same_set, &pending_raid_disks);
2411
2412 for (i = 0; i < MD_SB_DISKS; i++) {
2413 mdp_disk_t *desc = sb->disks + i;
2414 dev_t dev = MKDEV(desc->major, desc->minor);
2415
2416 if (!dev)
2417 continue;
2418 if (dev == startdev)
2419 continue;
2420 if (MAJOR(dev) != desc->major || MINOR(dev) != desc->minor)
2421 continue;
2422 rdev = md_import_device(dev, 0, 0);
2423 if (IS_ERR(rdev))
2424 continue;
2425
2426 list_add(&rdev->same_set, &pending_raid_disks);
2427 }
2428
2429 /*
2430 * possibly return codes
2431 */
2432 autorun_devices(0);
2433 return 0;
2434
2435 }
2436
2437
2438 static int get_version(void __user * arg)
2439 {
2440 mdu_version_t ver;
2441
2442 ver.major = MD_MAJOR_VERSION;
2443 ver.minor = MD_MINOR_VERSION;
2444 ver.patchlevel = MD_PATCHLEVEL_VERSION;
2445
2446 if (copy_to_user(arg, &ver, sizeof(ver)))
2447 return -EFAULT;
2448
2449 return 0;
2450 }
2451
2452 static int get_array_info(mddev_t * mddev, void __user * arg)
2453 {
2454 mdu_array_info_t info;
2455 int nr,working,active,failed,spare;
2456 mdk_rdev_t *rdev;
2457 struct list_head *tmp;
2458
2459 nr=working=active=failed=spare=0;
2460 ITERATE_RDEV(mddev,rdev,tmp) {
2461 nr++;
2462 if (test_bit(Faulty, &rdev->flags))
2463 failed++;
2464 else {
2465 working++;
2466 if (test_bit(In_sync, &rdev->flags))
2467 active++;
2468 else
2469 spare++;
2470 }
2471 }
2472
2473 info.major_version = mddev->major_version;
2474 info.minor_version = mddev->minor_version;
2475 info.patch_version = MD_PATCHLEVEL_VERSION;
2476 info.ctime = mddev->ctime;
2477 info.level = mddev->level;
2478 info.size = mddev->size;
2479 info.nr_disks = nr;
2480 info.raid_disks = mddev->raid_disks;
2481 info.md_minor = mddev->md_minor;
2482 info.not_persistent= !mddev->persistent;
2483
2484 info.utime = mddev->utime;
2485 info.state = 0;
2486 if (mddev->in_sync)
2487 info.state = (1<<MD_SB_CLEAN);
2488 if (mddev->bitmap && mddev->bitmap_offset)
2489 info.state = (1<<MD_SB_BITMAP_PRESENT);
2490 info.active_disks = active;
2491 info.working_disks = working;
2492 info.failed_disks = failed;
2493 info.spare_disks = spare;
2494
2495 info.layout = mddev->layout;
2496 info.chunk_size = mddev->chunk_size;
2497
2498 if (copy_to_user(arg, &info, sizeof(info)))
2499 return -EFAULT;
2500
2501 return 0;
2502 }
2503
2504 static int get_bitmap_file(mddev_t * mddev, void __user * arg)
2505 {
2506 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
2507 char *ptr, *buf = NULL;
2508 int err = -ENOMEM;
2509
2510 file = kmalloc(sizeof(*file), GFP_KERNEL);
2511 if (!file)
2512 goto out;
2513
2514 /* bitmap disabled, zero the first byte and copy out */
2515 if (!mddev->bitmap || !mddev->bitmap->file) {
2516 file->pathname[0] = '\0';
2517 goto copy_out;
2518 }
2519
2520 buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
2521 if (!buf)
2522 goto out;
2523
2524 ptr = file_path(mddev->bitmap->file, buf, sizeof(file->pathname));
2525 if (!ptr)
2526 goto out;
2527
2528 strcpy(file->pathname, ptr);
2529
2530 copy_out:
2531 err = 0;
2532 if (copy_to_user(arg, file, sizeof(*file)))
2533 err = -EFAULT;
2534 out:
2535 kfree(buf);
2536 kfree(file);
2537 return err;
2538 }
2539
2540 static int get_disk_info(mddev_t * mddev, void __user * arg)
2541 {
2542 mdu_disk_info_t info;
2543 unsigned int nr;
2544 mdk_rdev_t *rdev;
2545
2546 if (copy_from_user(&info, arg, sizeof(info)))
2547 return -EFAULT;
2548
2549 nr = info.number;
2550
2551 rdev = find_rdev_nr(mddev, nr);
2552 if (rdev) {
2553 info.major = MAJOR(rdev->bdev->bd_dev);
2554 info.minor = MINOR(rdev->bdev->bd_dev);
2555 info.raid_disk = rdev->raid_disk;
2556 info.state = 0;
2557 if (test_bit(Faulty, &rdev->flags))
2558 info.state |= (1<<MD_DISK_FAULTY);
2559 else if (test_bit(In_sync, &rdev->flags)) {
2560 info.state |= (1<<MD_DISK_ACTIVE);
2561 info.state |= (1<<MD_DISK_SYNC);
2562 }
2563 if (test_bit(WriteMostly, &rdev->flags))
2564 info.state |= (1<<MD_DISK_WRITEMOSTLY);
2565 } else {
2566 info.major = info.minor = 0;
2567 info.raid_disk = -1;
2568 info.state = (1<<MD_DISK_REMOVED);
2569 }
2570
2571 if (copy_to_user(arg, &info, sizeof(info)))
2572 return -EFAULT;
2573
2574 return 0;
2575 }
2576
2577 static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
2578 {
2579 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
2580 mdk_rdev_t *rdev;
2581 dev_t dev = MKDEV(info->major,info->minor);
2582
2583 if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
2584 return -EOVERFLOW;
2585
2586 if (!mddev->raid_disks) {
2587 int err;
2588 /* expecting a device which has a superblock */
2589 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
2590 if (IS_ERR(rdev)) {
2591 printk(KERN_WARNING
2592 "md: md_import_device returned %ld\n",
2593 PTR_ERR(rdev));
2594 return PTR_ERR(rdev);
2595 }
2596 if (!list_empty(&mddev->disks)) {
2597 mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
2598 mdk_rdev_t, same_set);
2599 int err = super_types[mddev->major_version]
2600 .load_super(rdev, rdev0, mddev->minor_version);
2601 if (err < 0) {
2602 printk(KERN_WARNING
2603 "md: %s has different UUID to %s\n",
2604 bdevname(rdev->bdev,b),
2605 bdevname(rdev0->bdev,b2));
2606 export_rdev(rdev);
2607 return -EINVAL;
2608 }
2609 }
2610 err = bind_rdev_to_array(rdev, mddev);
2611 if (err)
2612 export_rdev(rdev);
2613 return err;
2614 }
2615
2616 /*
2617 * add_new_disk can be used once the array is assembled
2618 * to add "hot spares". They must already have a superblock
2619 * written
2620 */
2621 if (mddev->pers) {
2622 int err;
2623 if (!mddev->pers->hot_add_disk) {
2624 printk(KERN_WARNING
2625 "%s: personality does not support diskops!\n",
2626 mdname(mddev));
2627 return -EINVAL;
2628 }
2629 if (mddev->persistent)
2630 rdev = md_import_device(dev, mddev->major_version,
2631 mddev->minor_version);
2632 else
2633 rdev = md_import_device(dev, -1, -1);
2634 if (IS_ERR(rdev)) {
2635 printk(KERN_WARNING
2636 "md: md_import_device returned %ld\n",
2637 PTR_ERR(rdev));
2638 return PTR_ERR(rdev);
2639 }
2640 /* set save_raid_disk if appropriate */
2641 if (!mddev->persistent) {
2642 if (info->state & (1<<MD_DISK_SYNC) &&
2643 info->raid_disk < mddev->raid_disks)
2644 rdev->raid_disk = info->raid_disk;
2645 else
2646 rdev->raid_disk = -1;
2647 } else
2648 super_types[mddev->major_version].
2649 validate_super(mddev, rdev);
2650 rdev->saved_raid_disk = rdev->raid_disk;
2651
2652 clear_bit(In_sync, &rdev->flags); /* just to be sure */
2653 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
2654 set_bit(WriteMostly, &rdev->flags);
2655
2656 rdev->raid_disk = -1;
2657 err = bind_rdev_to_array(rdev, mddev);
2658 if (err)
2659 export_rdev(rdev);
2660
2661 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2662 md_wakeup_thread(mddev->thread);
2663 return err;
2664 }
2665
2666 /* otherwise, add_new_disk is only allowed
2667 * for major_version==0 superblocks
2668 */
2669 if (mddev->major_version != 0) {
2670 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
2671 mdname(mddev));
2672 return -EINVAL;
2673 }
2674
2675 if (!(info->state & (1<<MD_DISK_FAULTY))) {
2676 int err;
2677 rdev = md_import_device (dev, -1, 0);
2678 if (IS_ERR(rdev)) {
2679 printk(KERN_WARNING
2680 "md: error, md_import_device() returned %ld\n",
2681 PTR_ERR(rdev));
2682 return PTR_ERR(rdev);
2683 }
2684 rdev->desc_nr = info->number;
2685 if (info->raid_disk < mddev->raid_disks)
2686 rdev->raid_disk = info->raid_disk;
2687 else
2688 rdev->raid_disk = -1;
2689
2690 rdev->flags = 0;
2691
2692 if (rdev->raid_disk < mddev->raid_disks)
2693 if (info->state & (1<<MD_DISK_SYNC))
2694 set_bit(In_sync, &rdev->flags);
2695
2696 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
2697 set_bit(WriteMostly, &rdev->flags);
2698
2699 err = bind_rdev_to_array(rdev, mddev);
2700 if (err) {
2701 export_rdev(rdev);
2702 return err;
2703 }
2704
2705 if (!mddev->persistent) {
2706 printk(KERN_INFO "md: nonpersistent superblock ...\n");
2707 rdev->sb_offset = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
2708 } else
2709 rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
2710 rdev->size = calc_dev_size(rdev, mddev->chunk_size);
2711
2712 if (!mddev->size || (mddev->size > rdev->size))
2713 mddev->size = rdev->size;
2714 }
2715
2716 return 0;
2717 }
2718
2719 static int hot_remove_disk(mddev_t * mddev, dev_t dev)
2720 {
2721 char b[BDEVNAME_SIZE];
2722 mdk_rdev_t *rdev;
2723
2724 if (!mddev->pers)
2725 return -ENODEV;
2726
2727 rdev = find_rdev(mddev, dev);
2728 if (!rdev)
2729 return -ENXIO;
2730
2731 if (rdev->raid_disk >= 0)
2732 goto busy;
2733
2734 kick_rdev_from_array(rdev);
2735 md_update_sb(mddev);
2736 md_new_event(mddev);
2737
2738 return 0;
2739 busy:
2740 printk(KERN_WARNING "md: cannot remove active disk %s from %s ... \n",
2741 bdevname(rdev->bdev,b), mdname(mddev));
2742 return -EBUSY;
2743 }
2744
2745 static int hot_add_disk(mddev_t * mddev, dev_t dev)
2746 {
2747 char b[BDEVNAME_SIZE];
2748 int err;
2749 unsigned int size;
2750 mdk_rdev_t *rdev;
2751
2752 if (!mddev->pers)
2753 return -ENODEV;
2754
2755 if (mddev->major_version != 0) {
2756 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
2757 " version-0 superblocks.\n",
2758 mdname(mddev));
2759 return -EINVAL;
2760 }
2761 if (!mddev->pers->hot_add_disk) {
2762 printk(KERN_WARNING
2763 "%s: personality does not support diskops!\n",
2764 mdname(mddev));
2765 return -EINVAL;
2766 }
2767
2768 rdev = md_import_device (dev, -1, 0);
2769 if (IS_ERR(rdev)) {
2770 printk(KERN_WARNING
2771 "md: error, md_import_device() returned %ld\n",
2772 PTR_ERR(rdev));
2773 return -EINVAL;
2774 }
2775
2776 if (mddev->persistent)
2777 rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
2778 else
2779 rdev->sb_offset =
2780 rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
2781
2782 size = calc_dev_size(rdev, mddev->chunk_size);
2783 rdev->size = size;
2784
2785 if (size < mddev->size) {
2786 printk(KERN_WARNING
2787 "%s: disk size %llu blocks < array size %llu\n",
2788 mdname(mddev), (unsigned long long)size,
2789 (unsigned long long)mddev->size);
2790 err = -ENOSPC;
2791 goto abort_export;
2792 }
2793
2794 if (test_bit(Faulty, &rdev->flags)) {
2795 printk(KERN_WARNING
2796 "md: can not hot-add faulty %s disk to %s!\n",
2797 bdevname(rdev->bdev,b), mdname(mddev));
2798 err = -EINVAL;
2799 goto abort_export;
2800 }
2801 clear_bit(In_sync, &rdev->flags);
2802 rdev->desc_nr = -1;
2803 bind_rdev_to_array(rdev, mddev);
2804
2805 /*
2806 * The rest should better be atomic, we can have disk failures
2807 * noticed in interrupt contexts ...
2808 */
2809
2810 if (rdev->desc_nr == mddev->max_disks) {
2811 printk(KERN_WARNING "%s: can not hot-add to full array!\n",
2812 mdname(mddev));
2813 err = -EBUSY;
2814 goto abort_unbind_export;
2815 }
2816
2817 rdev->raid_disk = -1;
2818
2819 md_update_sb(mddev);
2820
2821 /*
2822 * Kick recovery, maybe this spare has to be added to the
2823 * array immediately.
2824 */
2825 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2826 md_wakeup_thread(mddev->thread);
2827 md_new_event(mddev);
2828 return 0;
2829
2830 abort_unbind_export:
2831 unbind_rdev_from_array(rdev);
2832
2833 abort_export:
2834 export_rdev(rdev);
2835 return err;
2836 }
2837
2838 /* similar to deny_write_access, but accounts for our holding a reference
2839 * to the file ourselves */
2840 static int deny_bitmap_write_access(struct file * file)
2841 {
2842 struct inode *inode = file->f_mapping->host;
2843
2844 spin_lock(&inode->i_lock);
2845 if (atomic_read(&inode->i_writecount) > 1) {
2846 spin_unlock(&inode->i_lock);
2847 return -ETXTBSY;
2848 }
2849 atomic_set(&inode->i_writecount, -1);
2850 spin_unlock(&inode->i_lock);
2851
2852 return 0;
2853 }
2854
2855 static int set_bitmap_file(mddev_t *mddev, int fd)
2856 {
2857 int err;
2858
2859 if (mddev->pers) {
2860 if (!mddev->pers->quiesce)
2861 return -EBUSY;
2862 if (mddev->recovery || mddev->sync_thread)
2863 return -EBUSY;
2864 /* we should be able to change the bitmap.. */
2865 }
2866
2867
2868 if (fd >= 0) {
2869 if (mddev->bitmap)
2870 return -EEXIST; /* cannot add when bitmap is present */
2871 mddev->bitmap_file = fget(fd);
2872
2873 if (mddev->bitmap_file == NULL) {
2874 printk(KERN_ERR "%s: error: failed to get bitmap file\n",
2875 mdname(mddev));
2876 return -EBADF;
2877 }
2878
2879 err = deny_bitmap_write_access(mddev->bitmap_file);
2880 if (err) {
2881 printk(KERN_ERR "%s: error: bitmap file is already in use\n",
2882 mdname(mddev));
2883 fput(mddev->bitmap_file);
2884 mddev->bitmap_file = NULL;
2885 return err;
2886 }
2887 mddev->bitmap_offset = 0; /* file overrides offset */
2888 } else if (mddev->bitmap == NULL)
2889 return -ENOENT; /* cannot remove what isn't there */
2890 err = 0;
2891 if (mddev->pers) {
2892 mddev->pers->quiesce(mddev, 1);
2893 if (fd >= 0)
2894 err = bitmap_create(mddev);
2895 if (fd < 0 || err)
2896 bitmap_destroy(mddev);
2897 mddev->pers->quiesce(mddev, 0);
2898 } else if (fd < 0) {
2899 if (mddev->bitmap_file)
2900 fput(mddev->bitmap_file);
2901 mddev->bitmap_file = NULL;
2902 }
2903
2904 return err;
2905 }
2906
2907 /*
2908 * set_array_info is used two different ways
2909 * The original usage is when creating a new array.
2910 * In this usage, raid_disks is > 0 and it together with
2911 * level, size, not_persistent,layout,chunksize determine the
2912 * shape of the array.
2913 * This will always create an array with a type-0.90.0 superblock.
2914 * The newer usage is when assembling an array.
2915 * In this case raid_disks will be 0, and the major_version field is
2916 * use to determine which style super-blocks are to be found on the devices.
2917 * The minor and patch _version numbers are also kept incase the
2918 * super_block handler wishes to interpret them.
2919 */
2920 static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
2921 {
2922
2923 if (info->raid_disks == 0) {
2924 /* just setting version number for superblock loading */
2925 if (info->major_version < 0 ||
2926 info->major_version >= sizeof(super_types)/sizeof(super_types[0]) ||
2927 super_types[info->major_version].name == NULL) {
2928 /* maybe try to auto-load a module? */
2929 printk(KERN_INFO
2930 "md: superblock version %d not known\n",
2931 info->major_version);
2932 return -EINVAL;
2933 }
2934 mddev->major_version = info->major_version;
2935 mddev->minor_version = info->minor_version;
2936 mddev->patch_version = info->patch_version;
2937 return 0;
2938 }
2939 mddev->major_version = MD_MAJOR_VERSION;
2940 mddev->minor_version = MD_MINOR_VERSION;
2941 mddev->patch_version = MD_PATCHLEVEL_VERSION;
2942 mddev->ctime = get_seconds();
2943
2944 mddev->level = info->level;
2945 mddev->size = info->size;
2946 mddev->raid_disks = info->raid_disks;
2947 /* don't set md_minor, it is determined by which /dev/md* was
2948 * openned
2949 */
2950 if (info->state & (1<<MD_SB_CLEAN))
2951 mddev->recovery_cp = MaxSector;
2952 else
2953 mddev->recovery_cp = 0;
2954 mddev->persistent = ! info->not_persistent;
2955
2956 mddev->layout = info->layout;
2957 mddev->chunk_size = info->chunk_size;
2958
2959 mddev->max_disks = MD_SB_DISKS;
2960
2961 mddev->sb_dirty = 1;
2962
2963 mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
2964 mddev->bitmap_offset = 0;
2965
2966 /*
2967 * Generate a 128 bit UUID
2968 */
2969 get_random_bytes(mddev->uuid, 16);
2970
2971 return 0;
2972 }
2973
2974 /*
2975 * update_array_info is used to change the configuration of an
2976 * on-line array.
2977 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
2978 * fields in the info are checked against the array.
2979 * Any differences that cannot be handled will cause an error.
2980 * Normally, only one change can be managed at a time.
2981 */
2982 static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
2983 {
2984 int rv = 0;
2985 int cnt = 0;
2986 int state = 0;
2987
2988 /* calculate expected state,ignoring low bits */
2989 if (mddev->bitmap && mddev->bitmap_offset)
2990 state |= (1 << MD_SB_BITMAP_PRESENT);
2991
2992 if (mddev->major_version != info->major_version ||
2993 mddev->minor_version != info->minor_version ||
2994 /* mddev->patch_version != info->patch_version || */
2995 mddev->ctime != info->ctime ||
2996 mddev->level != info->level ||
2997 /* mddev->layout != info->layout || */
2998 !mddev->persistent != info->not_persistent||
2999 mddev->chunk_size != info->chunk_size ||
3000 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
3001 ((state^info->state) & 0xfffffe00)
3002 )
3003 return -EINVAL;
3004 /* Check there is only one change */
3005 if (mddev->size != info->size) cnt++;
3006 if (mddev->raid_disks != info->raid_disks) cnt++;
3007 if (mddev->layout != info->layout) cnt++;
3008 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) cnt++;
3009 if (cnt == 0) return 0;
3010 if (cnt > 1) return -EINVAL;
3011
3012 if (mddev->layout != info->layout) {
3013 /* Change layout
3014 * we don't need to do anything at the md level, the
3015 * personality will take care of it all.
3016 */
3017 if (mddev->pers->reconfig == NULL)
3018 return -EINVAL;
3019 else
3020 return mddev->pers->reconfig(mddev, info->layout, -1);
3021 }
3022 if (mddev->size != info->size) {
3023 mdk_rdev_t * rdev;
3024 struct list_head *tmp;
3025 if (mddev->pers->resize == NULL)
3026 return -EINVAL;
3027 /* The "size" is the amount of each device that is used.
3028 * This can only make sense for arrays with redundancy.
3029 * linear and raid0 always use whatever space is available
3030 * We can only consider changing the size if no resync
3031 * or reconstruction is happening, and if the new size
3032 * is acceptable. It must fit before the sb_offset or,
3033 * if that is <data_offset, it must fit before the
3034 * size of each device.
3035 * If size is zero, we find the largest size that fits.
3036 */
3037 if (mddev->sync_thread)
3038 return -EBUSY;
3039 ITERATE_RDEV(mddev,rdev,tmp) {
3040 sector_t avail;
3041 int fit = (info->size == 0);
3042 if (rdev->sb_offset > rdev->data_offset)
3043 avail = (rdev->sb_offset*2) - rdev->data_offset;
3044 else
3045 avail = get_capacity(rdev->bdev->bd_disk)
3046 - rdev->data_offset;
3047 if (fit && (info->size == 0 || info->size > avail/2))
3048 info->size = avail/2;
3049 if (avail < ((sector_t)info->size << 1))
3050 return -ENOSPC;
3051 }
3052 rv = mddev->pers->resize(mddev, (sector_t)info->size *2);
3053 if (!rv) {
3054 struct block_device *bdev;
3055
3056 bdev = bdget_disk(mddev->gendisk, 0);
3057 if (bdev) {
3058 down(&bdev->bd_inode->i_sem);
3059 i_size_write(bdev->bd_inode, mddev->array_size << 10);
3060 up(&bdev->bd_inode->i_sem);
3061 bdput(bdev);
3062 }
3063 }
3064 }
3065 if (mddev->raid_disks != info->raid_disks) {
3066 /* change the number of raid disks */
3067 if (mddev->pers->reshape == NULL)
3068 return -EINVAL;
3069 if (info->raid_disks <= 0 ||
3070 info->raid_disks >= mddev->max_disks)
3071 return -EINVAL;
3072 if (mddev->sync_thread)
3073 return -EBUSY;
3074 rv = mddev->pers->reshape(mddev, info->raid_disks);
3075 if (!rv) {
3076 struct block_device *bdev;
3077
3078 bdev = bdget_disk(mddev->gendisk, 0);
3079 if (bdev) {
3080 down(&bdev->bd_inode->i_sem);
3081 i_size_write(bdev->bd_inode, mddev->array_size << 10);
3082 up(&bdev->bd_inode->i_sem);
3083 bdput(bdev);
3084 }
3085 }
3086 }
3087 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
3088 if (mddev->pers->quiesce == NULL)
3089 return -EINVAL;
3090 if (mddev->recovery || mddev->sync_thread)
3091 return -EBUSY;
3092 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
3093 /* add the bitmap */
3094 if (mddev->bitmap)
3095 return -EEXIST;
3096 if (mddev->default_bitmap_offset == 0)
3097 return -EINVAL;
3098 mddev->bitmap_offset = mddev->default_bitmap_offset;
3099 mddev->pers->quiesce(mddev, 1);
3100 rv = bitmap_create(mddev);
3101 if (rv)
3102 bitmap_destroy(mddev);
3103 mddev->pers->quiesce(mddev, 0);
3104 } else {
3105 /* remove the bitmap */
3106 if (!mddev->bitmap)
3107 return -ENOENT;
3108 if (mddev->bitmap->file)
3109 return -EINVAL;
3110 mddev->pers->quiesce(mddev, 1);
3111 bitmap_destroy(mddev);
3112 mddev->pers->quiesce(mddev, 0);
3113 mddev->bitmap_offset = 0;
3114 }
3115 }
3116 md_update_sb(mddev);
3117 return rv;
3118 }
3119
3120 static int set_disk_faulty(mddev_t *mddev, dev_t dev)
3121 {
3122 mdk_rdev_t *rdev;
3123
3124 if (mddev->pers == NULL)
3125 return -ENODEV;
3126
3127 rdev = find_rdev(mddev, dev);
3128 if (!rdev)
3129 return -ENODEV;
3130
3131 md_error(mddev, rdev);
3132 return 0;
3133 }
3134
3135 static int md_ioctl(struct inode *inode, struct file *file,
3136 unsigned int cmd, unsigned long arg)
3137 {
3138 int err = 0;
3139 void __user *argp = (void __user *)arg;
3140 struct hd_geometry __user *loc = argp;
3141 mddev_t *mddev = NULL;
3142
3143 if (!capable(CAP_SYS_ADMIN))
3144 return -EACCES;
3145
3146 /*
3147 * Commands dealing with the RAID driver but not any
3148 * particular array:
3149 */
3150 switch (cmd)
3151 {
3152 case RAID_VERSION:
3153 err = get_version(argp);
3154 goto done;
3155
3156 case PRINT_RAID_DEBUG:
3157 err = 0;
3158 md_print_devices();
3159 goto done;
3160
3161 #ifndef MODULE
3162 case RAID_AUTORUN:
3163 err = 0;
3164 autostart_arrays(arg);
3165 goto done;
3166 #endif
3167 default:;
3168 }
3169
3170 /*
3171 * Commands creating/starting a new array:
3172 */
3173
3174 mddev = inode->i_bdev->bd_disk->private_data;
3175
3176 if (!mddev) {
3177 BUG();
3178 goto abort;
3179 }
3180
3181
3182 if (cmd == START_ARRAY) {
3183 /* START_ARRAY doesn't need to lock the array as autostart_array
3184 * does the locking, and it could even be a different array
3185 */
3186 static int cnt = 3;
3187 if (cnt > 0 ) {
3188 printk(KERN_WARNING
3189 "md: %s(pid %d) used deprecated START_ARRAY ioctl. "
3190 "This will not be supported beyond July 2006\n",
3191 current->comm, current->pid);
3192 cnt--;
3193 }
3194 err = autostart_array(new_decode_dev(arg));
3195 if (err) {
3196 printk(KERN_WARNING "md: autostart failed!\n");
3197 goto abort;
3198 }
3199 goto done;
3200 }
3201
3202 err = mddev_lock(mddev);
3203 if (err) {
3204 printk(KERN_INFO
3205 "md: ioctl lock interrupted, reason %d, cmd %d\n",
3206 err, cmd);
3207 goto abort;
3208 }
3209
3210 switch (cmd)
3211 {
3212 case SET_ARRAY_INFO:
3213 {
3214 mdu_array_info_t info;
3215 if (!arg)
3216 memset(&info, 0, sizeof(info));
3217 else if (copy_from_user(&info, argp, sizeof(info))) {
3218 err = -EFAULT;
3219 goto abort_unlock;
3220 }
3221 if (mddev->pers) {
3222 err = update_array_info(mddev, &info);
3223 if (err) {
3224 printk(KERN_WARNING "md: couldn't update"
3225 " array info. %d\n", err);
3226 goto abort_unlock;
3227 }
3228 goto done_unlock;
3229 }
3230 if (!list_empty(&mddev->disks)) {
3231 printk(KERN_WARNING
3232 "md: array %s already has disks!\n",
3233 mdname(mddev));
3234 err = -EBUSY;
3235 goto abort_unlock;
3236 }
3237 if (mddev->raid_disks) {
3238 printk(KERN_WARNING
3239 "md: array %s already initialised!\n",
3240 mdname(mddev));
3241 err = -EBUSY;
3242 goto abort_unlock;
3243 }
3244 err = set_array_info(mddev, &info);
3245 if (err) {
3246 printk(KERN_WARNING "md: couldn't set"
3247 " array info. %d\n", err);
3248 goto abort_unlock;
3249 }
3250 }
3251 goto done_unlock;
3252
3253 default:;
3254 }
3255
3256 /*
3257 * Commands querying/configuring an existing array:
3258 */
3259 /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
3260 * RUN_ARRAY, and SET_BITMAP_FILE are allowed */
3261 if (!mddev->raid_disks && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
3262 && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE) {
3263 err = -ENODEV;
3264 goto abort_unlock;
3265 }
3266
3267 /*
3268 * Commands even a read-only array can execute:
3269 */
3270 switch (cmd)
3271 {
3272 case GET_ARRAY_INFO:
3273 err = get_array_info(mddev, argp);
3274 goto done_unlock;
3275
3276 case GET_BITMAP_FILE:
3277 err = get_bitmap_file(mddev, argp);
3278 goto done_unlock;
3279
3280 case GET_DISK_INFO:
3281 err = get_disk_info(mddev, argp);
3282 goto done_unlock;
3283
3284 case RESTART_ARRAY_RW:
3285 err = restart_array(mddev);
3286 goto done_unlock;
3287
3288 case STOP_ARRAY:
3289 err = do_md_stop (mddev, 0);
3290 goto done_unlock;
3291
3292 case STOP_ARRAY_RO:
3293 err = do_md_stop (mddev, 1);
3294 goto done_unlock;
3295
3296 /*
3297 * We have a problem here : there is no easy way to give a CHS
3298 * virtual geometry. We currently pretend that we have a 2 heads
3299 * 4 sectors (with a BIG number of cylinders...). This drives
3300 * dosfs just mad... ;-)
3301 */
3302 case HDIO_GETGEO:
3303 if (!loc) {
3304 err = -EINVAL;
3305 goto abort_unlock;
3306 }
3307 err = put_user (2, (char __user *) &loc->heads);
3308 if (err)
3309 goto abort_unlock;
3310 err = put_user (4, (char __user *) &loc->sectors);
3311 if (err)
3312 goto abort_unlock;
3313 err = put_user(get_capacity(mddev->gendisk)/8,
3314 (short __user *) &loc->cylinders);
3315 if (err)
3316 goto abort_unlock;
3317 err = put_user (get_start_sect(inode->i_bdev),
3318 (long __user *) &loc->start);
3319 goto done_unlock;
3320 }
3321
3322 /*
3323 * The remaining ioctls are changing the state of the
3324 * superblock, so we do not allow them on read-only arrays.
3325 * However non-MD ioctls (e.g. get-size) will still come through
3326 * here and hit the 'default' below, so only disallow
3327 * 'md' ioctls, and switch to rw mode if started auto-readonly.
3328 */
3329 if (_IOC_TYPE(cmd) == MD_MAJOR &&
3330 mddev->ro && mddev->pers) {
3331 if (mddev->ro == 2) {
3332 mddev->ro = 0;
3333 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3334 md_wakeup_thread(mddev->thread);
3335
3336 } else {
3337 err = -EROFS;
3338 goto abort_unlock;
3339 }
3340 }
3341
3342 switch (cmd)
3343 {
3344 case ADD_NEW_DISK:
3345 {
3346 mdu_disk_info_t info;
3347 if (copy_from_user(&info, argp, sizeof(info)))
3348 err = -EFAULT;
3349 else
3350 err = add_new_disk(mddev, &info);
3351 goto done_unlock;
3352 }
3353
3354 case HOT_REMOVE_DISK:
3355 err = hot_remove_disk(mddev, new_decode_dev(arg));
3356 goto done_unlock;
3357
3358 case HOT_ADD_DISK:
3359 err = hot_add_disk(mddev, new_decode_dev(arg));
3360 goto done_unlock;
3361
3362 case SET_DISK_FAULTY:
3363 err = set_disk_faulty(mddev, new_decode_dev(arg));
3364 goto done_unlock;
3365
3366 case RUN_ARRAY:
3367 err = do_md_run (mddev);
3368 goto done_unlock;
3369
3370 case SET_BITMAP_FILE:
3371 err = set_bitmap_file(mddev, (int)arg);
3372 goto done_unlock;
3373
3374 default:
3375 if (_IOC_TYPE(cmd) == MD_MAJOR)
3376 printk(KERN_WARNING "md: %s(pid %d) used"
3377 " obsolete MD ioctl, upgrade your"
3378 " software to use new ictls.\n",
3379 current->comm, current->pid);
3380 err = -EINVAL;
3381 goto abort_unlock;
3382 }
3383
3384 done_unlock:
3385 abort_unlock:
3386 mddev_unlock(mddev);
3387
3388 return err;
3389 done:
3390 if (err)
3391 MD_BUG();
3392 abort:
3393 return err;
3394 }
3395
3396 static int md_open(struct inode *inode, struct file *file)
3397 {
3398 /*
3399 * Succeed if we can lock the mddev, which confirms that
3400 * it isn't being stopped right now.
3401 */
3402 mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
3403 int err;
3404
3405 if ((err = mddev_lock(mddev)))
3406 goto out;
3407
3408 err = 0;
3409 mddev_get(mddev);
3410 mddev_unlock(mddev);
3411
3412 check_disk_change(inode->i_bdev);
3413 out:
3414 return err;
3415 }
3416
3417 static int md_release(struct inode *inode, struct file * file)
3418 {
3419 mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
3420
3421 if (!mddev)
3422 BUG();
3423 mddev_put(mddev);
3424
3425 return 0;
3426 }
3427
3428 static int md_media_changed(struct gendisk *disk)
3429 {
3430 mddev_t *mddev = disk->private_data;
3431
3432 return mddev->changed;
3433 }
3434
3435 static int md_revalidate(struct gendisk *disk)
3436 {
3437 mddev_t *mddev = disk->private_data;
3438
3439 mddev->changed = 0;
3440 return 0;
3441 }
3442 static struct block_device_operations md_fops =
3443 {
3444 .owner = THIS_MODULE,
3445 .open = md_open,
3446 .release = md_release,
3447 .ioctl = md_ioctl,
3448 .media_changed = md_media_changed,
3449 .revalidate_disk= md_revalidate,
3450 };
3451
3452 static int md_thread(void * arg)
3453 {
3454 mdk_thread_t *thread = arg;
3455
3456 /*
3457 * md_thread is a 'system-thread', it's priority should be very
3458 * high. We avoid resource deadlocks individually in each
3459 * raid personality. (RAID5 does preallocation) We also use RR and
3460 * the very same RT priority as kswapd, thus we will never get
3461 * into a priority inversion deadlock.
3462 *
3463 * we definitely have to have equal or higher priority than
3464 * bdflush, otherwise bdflush will deadlock if there are too
3465 * many dirty RAID5 blocks.
3466 */
3467
3468 allow_signal(SIGKILL);
3469 while (!kthread_should_stop()) {
3470
3471 /* We need to wait INTERRUPTIBLE so that
3472 * we don't add to the load-average.
3473 * That means we need to be sure no signals are
3474 * pending
3475 */
3476 if (signal_pending(current))
3477 flush_signals(current);
3478
3479 wait_event_interruptible_timeout
3480 (thread->wqueue,
3481 test_bit(THREAD_WAKEUP, &thread->flags)
3482 || kthread_should_stop(),
3483 thread->timeout);
3484 try_to_freeze();
3485
3486 clear_bit(THREAD_WAKEUP, &thread->flags);
3487
3488 thread->run(thread->mddev);
3489 }
3490
3491 return 0;
3492 }
3493
3494 void md_wakeup_thread(mdk_thread_t *thread)
3495 {
3496 if (thread) {
3497 dprintk("md: waking up MD thread %s.\n", thread->tsk->comm);
3498 set_bit(THREAD_WAKEUP, &thread->flags);
3499 wake_up(&thread->wqueue);
3500 }
3501 }
3502
3503 mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
3504 const char *name)
3505 {
3506 mdk_thread_t *thread;
3507
3508 thread = kmalloc(sizeof(mdk_thread_t), GFP_KERNEL);
3509 if (!thread)
3510 return NULL;
3511
3512 memset(thread, 0, sizeof(mdk_thread_t));
3513 init_waitqueue_head(&thread->wqueue);
3514
3515 thread->run = run;
3516 thread->mddev = mddev;
3517 thread->timeout = MAX_SCHEDULE_TIMEOUT;
3518 thread->tsk = kthread_run(md_thread, thread, name, mdname(thread->mddev));
3519 if (IS_ERR(thread->tsk)) {
3520 kfree(thread);
3521 return NULL;
3522 }
3523 return thread;
3524 }
3525
3526 void md_unregister_thread(mdk_thread_t *thread)
3527 {
3528 dprintk("interrupting MD-thread pid %d\n", thread->tsk->pid);
3529
3530 kthread_stop(thread->tsk);
3531 kfree(thread);
3532 }
3533
3534 void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
3535 {
3536 if (!mddev) {
3537 MD_BUG();
3538 return;
3539 }
3540
3541 if (!rdev || test_bit(Faulty, &rdev->flags))
3542 return;
3543 /*
3544 dprintk("md_error dev:%s, rdev:(%d:%d), (caller: %p,%p,%p,%p).\n",
3545 mdname(mddev),
3546 MAJOR(rdev->bdev->bd_dev), MINOR(rdev->bdev->bd_dev),
3547 __builtin_return_address(0),__builtin_return_address(1),
3548 __builtin_return_address(2),__builtin_return_address(3));
3549 */
3550 if (!mddev->pers->error_handler)
3551 return;
3552 mddev->pers->error_handler(mddev,rdev);
3553 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
3554 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3555 md_wakeup_thread(mddev->thread);
3556 md_new_event(mddev);
3557 }
3558
3559 /* seq_file implementation /proc/mdstat */
3560
3561 static void status_unused(struct seq_file *seq)
3562 {
3563 int i = 0;
3564 mdk_rdev_t *rdev;
3565 struct list_head *tmp;
3566
3567 seq_printf(seq, "unused devices: ");
3568
3569 ITERATE_RDEV_PENDING(rdev,tmp) {
3570 char b[BDEVNAME_SIZE];
3571 i++;
3572 seq_printf(seq, "%s ",
3573 bdevname(rdev->bdev,b));
3574 }
3575 if (!i)
3576 seq_printf(seq, "<none>");
3577
3578 seq_printf(seq, "\n");
3579 }
3580
3581
3582 static void status_resync(struct seq_file *seq, mddev_t * mddev)
3583 {
3584 unsigned long max_blocks, resync, res, dt, db, rt;
3585
3586 resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
3587
3588 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
3589 max_blocks = mddev->resync_max_sectors >> 1;
3590 else
3591 max_blocks = mddev->size;
3592
3593 /*
3594 * Should not happen.
3595 */
3596 if (!max_blocks) {
3597 MD_BUG();
3598 return;
3599 }
3600 res = (resync/1024)*1000/(max_blocks/1024 + 1);
3601 {
3602 int i, x = res/50, y = 20-x;
3603 seq_printf(seq, "[");
3604 for (i = 0; i < x; i++)
3605 seq_printf(seq, "=");
3606 seq_printf(seq, ">");
3607 for (i = 0; i < y; i++)
3608 seq_printf(seq, ".");
3609 seq_printf(seq, "] ");
3610 }
3611 seq_printf(seq, " %s =%3lu.%lu%% (%lu/%lu)",
3612 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
3613 "resync" : "recovery"),
3614 res/10, res % 10, resync, max_blocks);
3615
3616 /*
3617 * We do not want to overflow, so the order of operands and
3618 * the * 100 / 100 trick are important. We do a +1 to be
3619 * safe against division by zero. We only estimate anyway.
3620 *
3621 * dt: time from mark until now
3622 * db: blocks written from mark until now
3623 * rt: remaining time
3624 */
3625 dt = ((jiffies - mddev->resync_mark) / HZ);
3626 if (!dt) dt++;
3627 db = resync - (mddev->resync_mark_cnt/2);
3628 rt = (dt * ((max_blocks-resync) / (db/100+1)))/100;
3629
3630 seq_printf(seq, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
3631
3632 seq_printf(seq, " speed=%ldK/sec", db/dt);
3633 }
3634
3635 static void *md_seq_start(struct seq_file *seq, loff_t *pos)
3636 {
3637 struct list_head *tmp;
3638 loff_t l = *pos;
3639 mddev_t *mddev;
3640
3641 if (l >= 0x10000)
3642 return NULL;
3643 if (!l--)
3644 /* header */
3645 return (void*)1;
3646
3647 spin_lock(&all_mddevs_lock);
3648 list_for_each(tmp,&all_mddevs)
3649 if (!l--) {
3650 mddev = list_entry(tmp, mddev_t, all_mddevs);
3651 mddev_get(mddev);
3652 spin_unlock(&all_mddevs_lock);
3653 return mddev;
3654 }
3655 spin_unlock(&all_mddevs_lock);
3656 if (!l--)
3657 return (void*)2;/* tail */
3658 return NULL;
3659 }
3660
3661 static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3662 {
3663 struct list_head *tmp;
3664 mddev_t *next_mddev, *mddev = v;
3665
3666 ++*pos;
3667 if (v == (void*)2)
3668 return NULL;
3669
3670 spin_lock(&all_mddevs_lock);
3671 if (v == (void*)1)
3672 tmp = all_mddevs.next;
3673 else
3674 tmp = mddev->all_mddevs.next;
3675 if (tmp != &all_mddevs)
3676 next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs));
3677 else {
3678 next_mddev = (void*)2;
3679 *pos = 0x10000;
3680 }
3681 spin_unlock(&all_mddevs_lock);
3682
3683 if (v != (void*)1)
3684 mddev_put(mddev);
3685 return next_mddev;
3686
3687 }
3688
3689 static void md_seq_stop(struct seq_file *seq, void *v)
3690 {
3691 mddev_t *mddev = v;
3692
3693 if (mddev && v != (void*)1 && v != (void*)2)
3694 mddev_put(mddev);
3695 }
3696
3697 struct mdstat_info {
3698 int event;
3699 };
3700
3701 static int md_seq_show(struct seq_file *seq, void *v)
3702 {
3703 mddev_t *mddev = v;
3704 sector_t size;
3705 struct list_head *tmp2;
3706 mdk_rdev_t *rdev;
3707 struct mdstat_info *mi = seq->private;
3708 int i;
3709 struct bitmap *bitmap;
3710
3711 if (v == (void*)1) {
3712 seq_printf(seq, "Personalities : ");
3713 spin_lock(&pers_lock);
3714 for (i = 0; i < MAX_PERSONALITY; i++)
3715 if (pers[i])
3716 seq_printf(seq, "[%s] ", pers[i]->name);
3717
3718 spin_unlock(&pers_lock);
3719 seq_printf(seq, "\n");
3720 mi->event = atomic_read(&md_event_count);
3721 return 0;
3722 }
3723 if (v == (void*)2) {
3724 status_unused(seq);
3725 return 0;
3726 }
3727
3728 if (mddev_lock(mddev)!=0)
3729 return -EINTR;
3730 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
3731 seq_printf(seq, "%s : %sactive", mdname(mddev),
3732 mddev->pers ? "" : "in");
3733 if (mddev->pers) {
3734 if (mddev->ro==1)
3735 seq_printf(seq, " (read-only)");
3736 if (mddev->ro==2)
3737 seq_printf(seq, "(auto-read-only)");
3738 seq_printf(seq, " %s", mddev->pers->name);
3739 }
3740
3741 size = 0;
3742 ITERATE_RDEV(mddev,rdev,tmp2) {
3743 char b[BDEVNAME_SIZE];
3744 seq_printf(seq, " %s[%d]",
3745 bdevname(rdev->bdev,b), rdev->desc_nr);
3746 if (test_bit(WriteMostly, &rdev->flags))
3747 seq_printf(seq, "(W)");
3748 if (test_bit(Faulty, &rdev->flags)) {
3749 seq_printf(seq, "(F)");
3750 continue;
3751 } else if (rdev->raid_disk < 0)
3752 seq_printf(seq, "(S)"); /* spare */
3753 size += rdev->size;
3754 }
3755
3756 if (!list_empty(&mddev->disks)) {
3757 if (mddev->pers)
3758 seq_printf(seq, "\n %llu blocks",
3759 (unsigned long long)mddev->array_size);
3760 else
3761 seq_printf(seq, "\n %llu blocks",
3762 (unsigned long long)size);
3763 }
3764 if (mddev->persistent) {
3765 if (mddev->major_version != 0 ||
3766 mddev->minor_version != 90) {
3767 seq_printf(seq," super %d.%d",
3768 mddev->major_version,
3769 mddev->minor_version);
3770 }
3771 } else
3772 seq_printf(seq, " super non-persistent");
3773
3774 if (mddev->pers) {
3775 mddev->pers->status (seq, mddev);
3776 seq_printf(seq, "\n ");
3777 if (mddev->pers->sync_request) {
3778 if (mddev->curr_resync > 2) {
3779 status_resync (seq, mddev);
3780 seq_printf(seq, "\n ");
3781 } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
3782 seq_printf(seq, "\tresync=DELAYED\n ");
3783 else if (mddev->recovery_cp < MaxSector)
3784 seq_printf(seq, "\tresync=PENDING\n ");
3785 }
3786 } else
3787 seq_printf(seq, "\n ");
3788
3789 if ((bitmap = mddev->bitmap)) {
3790 unsigned long chunk_kb;
3791 unsigned long flags;
3792 spin_lock_irqsave(&bitmap->lock, flags);
3793 chunk_kb = bitmap->chunksize >> 10;
3794 seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "
3795 "%lu%s chunk",
3796 bitmap->pages - bitmap->missing_pages,
3797 bitmap->pages,
3798 (bitmap->pages - bitmap->missing_pages)
3799 << (PAGE_SHIFT - 10),
3800 chunk_kb ? chunk_kb : bitmap->chunksize,
3801 chunk_kb ? "KB" : "B");
3802 if (bitmap->file) {
3803 seq_printf(seq, ", file: ");
3804 seq_path(seq, bitmap->file->f_vfsmnt,
3805 bitmap->file->f_dentry," \t\n");
3806 }
3807
3808 seq_printf(seq, "\n");
3809 spin_unlock_irqrestore(&bitmap->lock, flags);
3810 }
3811
3812 seq_printf(seq, "\n");
3813 }
3814 mddev_unlock(mddev);
3815
3816 return 0;
3817 }
3818
3819 static struct seq_operations md_seq_ops = {
3820 .start = md_seq_start,
3821 .next = md_seq_next,
3822 .stop = md_seq_stop,
3823 .show = md_seq_show,
3824 };
3825
3826 static int md_seq_open(struct inode *inode, struct file *file)
3827 {
3828 int error;
3829 struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL);
3830 if (mi == NULL)
3831 return -ENOMEM;
3832
3833 error = seq_open(file, &md_seq_ops);
3834 if (error)
3835 kfree(mi);
3836 else {
3837 struct seq_file *p = file->private_data;
3838 p->private = mi;
3839 mi->event = atomic_read(&md_event_count);
3840 }
3841 return error;
3842 }
3843
3844 static int md_seq_release(struct inode *inode, struct file *file)
3845 {
3846 struct seq_file *m = file->private_data;
3847 struct mdstat_info *mi = m->private;
3848 m->private = NULL;
3849 kfree(mi);
3850 return seq_release(inode, file);
3851 }
3852
3853 static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
3854 {
3855 struct seq_file *m = filp->private_data;
3856 struct mdstat_info *mi = m->private;
3857 int mask;
3858
3859 poll_wait(filp, &md_event_waiters, wait);
3860
3861 /* always allow read */
3862 mask = POLLIN | POLLRDNORM;
3863
3864 if (mi->event != atomic_read(&md_event_count))
3865 mask |= POLLERR | POLLPRI;
3866 return mask;
3867 }
3868
3869 static struct file_operations md_seq_fops = {
3870 .open = md_seq_open,
3871 .read = seq_read,
3872 .llseek = seq_lseek,
3873 .release = md_seq_release,
3874 .poll = mdstat_poll,
3875 };
3876
3877 int register_md_personality(int pnum, mdk_personality_t *p)
3878 {
3879 if (pnum >= MAX_PERSONALITY) {
3880 printk(KERN_ERR
3881 "md: tried to install personality %s as nr %d, but max is %lu\n",
3882 p->name, pnum, MAX_PERSONALITY-1);
3883 return -EINVAL;
3884 }
3885
3886 spin_lock(&pers_lock);
3887 if (pers[pnum]) {
3888 spin_unlock(&pers_lock);
3889 return -EBUSY;
3890 }
3891
3892 pers[pnum] = p;
3893 printk(KERN_INFO "md: %s personality registered as nr %d\n", p->name, pnum);
3894 spin_unlock(&pers_lock);
3895 return 0;
3896 }
3897
3898 int unregister_md_personality(int pnum)
3899 {
3900 if (pnum >= MAX_PERSONALITY)
3901 return -EINVAL;
3902
3903 printk(KERN_INFO "md: %s personality unregistered\n", pers[pnum]->name);
3904 spin_lock(&pers_lock);
3905 pers[pnum] = NULL;
3906 spin_unlock(&pers_lock);
3907 return 0;
3908 }
3909
3910 static int is_mddev_idle(mddev_t *mddev)
3911 {
3912 mdk_rdev_t * rdev;
3913 struct list_head *tmp;
3914 int idle;
3915 unsigned long curr_events;
3916
3917 idle = 1;
3918 ITERATE_RDEV(mddev,rdev,tmp) {
3919 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
3920 curr_events = disk_stat_read(disk, sectors[0]) +
3921 disk_stat_read(disk, sectors[1]) -
3922 atomic_read(&disk->sync_io);
3923 /* The difference between curr_events and last_events
3924 * will be affected by any new non-sync IO (making
3925 * curr_events bigger) and any difference in the amount of
3926 * in-flight syncio (making current_events bigger or smaller)
3927 * The amount in-flight is currently limited to
3928 * 32*64K in raid1/10 and 256*PAGE_SIZE in raid5/6
3929 * which is at most 4096 sectors.
3930 * These numbers are fairly fragile and should be made
3931 * more robust, probably by enforcing the
3932 * 'window size' that md_do_sync sort-of uses.
3933 *
3934 * Note: the following is an unsigned comparison.
3935 */
3936 if ((curr_events - rdev->last_events + 4096) > 8192) {
3937 rdev->last_events = curr_events;
3938 idle = 0;
3939 }
3940 }
3941 return idle;
3942 }
3943
3944 void md_done_sync(mddev_t *mddev, int blocks, int ok)
3945 {
3946 /* another "blocks" (512byte) blocks have been synced */
3947 atomic_sub(blocks, &mddev->recovery_active);
3948 wake_up(&mddev->recovery_wait);
3949 if (!ok) {
3950 set_bit(MD_RECOVERY_ERR, &mddev->recovery);
3951 md_wakeup_thread(mddev->thread);
3952 // stop recovery, signal do_sync ....
3953 }
3954 }
3955
3956
3957 /* md_write_start(mddev, bi)
3958 * If we need to update some array metadata (e.g. 'active' flag
3959 * in superblock) before writing, schedule a superblock update
3960 * and wait for it to complete.
3961 */
3962 void md_write_start(mddev_t *mddev, struct bio *bi)
3963 {
3964 if (bio_data_dir(bi) != WRITE)
3965 return;
3966
3967 BUG_ON(mddev->ro == 1);
3968 if (mddev->ro == 2) {
3969 /* need to switch to read/write */
3970 mddev->ro = 0;
3971 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3972 md_wakeup_thread(mddev->thread);
3973 }
3974 atomic_inc(&mddev->writes_pending);
3975 if (mddev->in_sync) {
3976 spin_lock_irq(&mddev->write_lock);
3977 if (mddev->in_sync) {
3978 mddev->in_sync = 0;
3979 mddev->sb_dirty = 1;
3980 md_wakeup_thread(mddev->thread);
3981 }
3982 spin_unlock_irq(&mddev->write_lock);
3983 }
3984 wait_event(mddev->sb_wait, mddev->sb_dirty==0);
3985 }
3986
3987 void md_write_end(mddev_t *mddev)
3988 {
3989 if (atomic_dec_and_test(&mddev->writes_pending)) {
3990 if (mddev->safemode == 2)
3991 md_wakeup_thread(mddev->thread);
3992 else
3993 mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
3994 }
3995 }
3996
3997 static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
3998
3999 #define SYNC_MARKS 10
4000 #define SYNC_MARK_STEP (3*HZ)
4001 static void md_do_sync(mddev_t *mddev)
4002 {
4003 mddev_t *mddev2;
4004 unsigned int currspeed = 0,
4005 window;
4006 sector_t max_sectors,j, io_sectors;
4007 unsigned long mark[SYNC_MARKS];
4008 sector_t mark_cnt[SYNC_MARKS];
4009 int last_mark,m;
4010 struct list_head *tmp;
4011 sector_t last_check;
4012 int skipped = 0;
4013
4014 /* just incase thread restarts... */
4015 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
4016 return;
4017
4018 /* we overload curr_resync somewhat here.
4019 * 0 == not engaged in resync at all
4020 * 2 == checking that there is no conflict with another sync
4021 * 1 == like 2, but have yielded to allow conflicting resync to
4022 * commense
4023 * other == active in resync - this many blocks
4024 *
4025 * Before starting a resync we must have set curr_resync to
4026 * 2, and then checked that every "conflicting" array has curr_resync
4027 * less than ours. When we find one that is the same or higher
4028 * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
4029 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
4030 * This will mean we have to start checking from the beginning again.
4031 *
4032 */
4033
4034 do {
4035 mddev->curr_resync = 2;
4036
4037 try_again:
4038 if (kthread_should_stop()) {
4039 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4040 goto skip;
4041 }
4042 ITERATE_MDDEV(mddev2,tmp) {
4043 if (mddev2 == mddev)
4044 continue;
4045 if (mddev2->curr_resync &&
4046 match_mddev_units(mddev,mddev2)) {
4047 DEFINE_WAIT(wq);
4048 if (mddev < mddev2 && mddev->curr_resync == 2) {
4049 /* arbitrarily yield */
4050 mddev->curr_resync = 1;
4051 wake_up(&resync_wait);
4052 }
4053 if (mddev > mddev2 && mddev->curr_resync == 1)
4054 /* no need to wait here, we can wait the next
4055 * time 'round when curr_resync == 2
4056 */
4057 continue;
4058 prepare_to_wait(&resync_wait, &wq, TASK_UNINTERRUPTIBLE);
4059 if (!kthread_should_stop() &&
4060 mddev2->curr_resync >= mddev->curr_resync) {
4061 printk(KERN_INFO "md: delaying resync of %s"
4062 " until %s has finished resync (they"
4063 " share one or more physical units)\n",
4064 mdname(mddev), mdname(mddev2));
4065 mddev_put(mddev2);
4066 schedule();
4067 finish_wait(&resync_wait, &wq);
4068 goto try_again;
4069 }
4070 finish_wait(&resync_wait, &wq);
4071 }
4072 }
4073 } while (mddev->curr_resync < 2);
4074
4075 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
4076 /* resync follows the size requested by the personality,
4077 * which defaults to physical size, but can be virtual size
4078 */
4079 max_sectors = mddev->resync_max_sectors;
4080 mddev->resync_mismatches = 0;
4081 } else
4082 /* recovery follows the physical size of devices */
4083 max_sectors = mddev->size << 1;
4084
4085 printk(KERN_INFO "md: syncing RAID array %s\n", mdname(mddev));
4086 printk(KERN_INFO "md: minimum _guaranteed_ reconstruction speed:"
4087 " %d KB/sec/disc.\n", sysctl_speed_limit_min);
4088 printk(KERN_INFO "md: using maximum available idle IO bandwidth "
4089 "(but not more than %d KB/sec) for reconstruction.\n",
4090 sysctl_speed_limit_max);
4091
4092 is_mddev_idle(mddev); /* this also initializes IO event counters */
4093 /* we don't use the checkpoint if there's a bitmap */
4094 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) && !mddev->bitmap
4095 && ! test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
4096 j = mddev->recovery_cp;
4097 else
4098 j = 0;
4099 io_sectors = 0;
4100 for (m = 0; m < SYNC_MARKS; m++) {
4101 mark[m] = jiffies;
4102 mark_cnt[m] = io_sectors;
4103 }
4104 last_mark = 0;
4105 mddev->resync_mark = mark[last_mark];
4106 mddev->resync_mark_cnt = mark_cnt[last_mark];
4107
4108 /*
4109 * Tune reconstruction:
4110 */
4111 window = 32*(PAGE_SIZE/512);
4112 printk(KERN_INFO "md: using %dk window, over a total of %llu blocks.\n",
4113 window/2,(unsigned long long) max_sectors/2);
4114
4115 atomic_set(&mddev->recovery_active, 0);
4116 init_waitqueue_head(&mddev->recovery_wait);
4117 last_check = 0;
4118
4119 if (j>2) {
4120 printk(KERN_INFO
4121 "md: resuming recovery of %s from checkpoint.\n",
4122 mdname(mddev));
4123 mddev->curr_resync = j;
4124 }
4125
4126 while (j < max_sectors) {
4127 sector_t sectors;
4128
4129 skipped = 0;
4130 sectors = mddev->pers->sync_request(mddev, j, &skipped,
4131 currspeed < sysctl_speed_limit_min);
4132 if (sectors == 0) {
4133 set_bit(MD_RECOVERY_ERR, &mddev->recovery);
4134 goto out;
4135 }
4136
4137 if (!skipped) { /* actual IO requested */
4138 io_sectors += sectors;
4139 atomic_add(sectors, &mddev->recovery_active);
4140 }
4141
4142 j += sectors;
4143 if (j>1) mddev->curr_resync = j;
4144 if (last_check == 0)
4145 /* this is the earliers that rebuilt will be
4146 * visible in /proc/mdstat
4147 */
4148 md_new_event(mddev);
4149
4150 if (last_check + window > io_sectors || j == max_sectors)
4151 continue;
4152
4153 last_check = io_sectors;
4154
4155 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery) ||
4156 test_bit(MD_RECOVERY_ERR, &mddev->recovery))
4157 break;
4158
4159 repeat:
4160 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
4161 /* step marks */
4162 int next = (last_mark+1) % SYNC_MARKS;
4163
4164 mddev->resync_mark = mark[next];
4165 mddev->resync_mark_cnt = mark_cnt[next];
4166 mark[next] = jiffies;
4167 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
4168 last_mark = next;
4169 }
4170
4171
4172 if (kthread_should_stop()) {
4173 /*
4174 * got a signal, exit.
4175 */
4176 printk(KERN_INFO
4177 "md: md_do_sync() got signal ... exiting\n");
4178 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4179 goto out;
4180 }
4181
4182 /*
4183 * this loop exits only if either when we are slower than
4184 * the 'hard' speed limit, or the system was IO-idle for
4185 * a jiffy.
4186 * the system might be non-idle CPU-wise, but we only care
4187 * about not overloading the IO subsystem. (things like an
4188 * e2fsck being done on the RAID array should execute fast)
4189 */
4190 mddev->queue->unplug_fn(mddev->queue);
4191 cond_resched();
4192
4193 currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
4194 /((jiffies-mddev->resync_mark)/HZ +1) +1;
4195
4196 if (currspeed > sysctl_speed_limit_min) {
4197 if ((currspeed > sysctl_speed_limit_max) ||
4198 !is_mddev_idle(mddev)) {
4199 msleep(500);
4200 goto repeat;
4201 }
4202 }
4203 }
4204 printk(KERN_INFO "md: %s: sync done.\n",mdname(mddev));
4205 /*
4206 * this also signals 'finished resyncing' to md_stop
4207 */
4208 out:
4209 mddev->queue->unplug_fn(mddev->queue);
4210
4211 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
4212
4213 /* tell personality that we are finished */
4214 mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
4215
4216 if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
4217 mddev->curr_resync > 2 &&
4218 mddev->curr_resync >= mddev->recovery_cp) {
4219 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
4220 printk(KERN_INFO
4221 "md: checkpointing recovery of %s.\n",
4222 mdname(mddev));
4223 mddev->recovery_cp = mddev->curr_resync;
4224 } else
4225 mddev->recovery_cp = MaxSector;
4226 }
4227
4228 skip:
4229 mddev->curr_resync = 0;
4230 wake_up(&resync_wait);
4231 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
4232 md_wakeup_thread(mddev->thread);
4233 }
4234
4235
4236 /*
4237 * This routine is regularly called by all per-raid-array threads to
4238 * deal with generic issues like resync and super-block update.
4239 * Raid personalities that don't have a thread (linear/raid0) do not
4240 * need this as they never do any recovery or update the superblock.
4241 *
4242 * It does not do any resync itself, but rather "forks" off other threads
4243 * to do that as needed.
4244 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
4245 * "->recovery" and create a thread at ->sync_thread.
4246 * When the thread finishes it sets MD_RECOVERY_DONE (and might set MD_RECOVERY_ERR)
4247 * and wakeups up this thread which will reap the thread and finish up.
4248 * This thread also removes any faulty devices (with nr_pending == 0).
4249 *
4250 * The overall approach is:
4251 * 1/ if the superblock needs updating, update it.
4252 * 2/ If a recovery thread is running, don't do anything else.
4253 * 3/ If recovery has finished, clean up, possibly marking spares active.
4254 * 4/ If there are any faulty devices, remove them.
4255 * 5/ If array is degraded, try to add spares devices
4256 * 6/ If array has spares or is not in-sync, start a resync thread.
4257 */
4258 void md_check_recovery(mddev_t *mddev)
4259 {
4260 mdk_rdev_t *rdev;
4261 struct list_head *rtmp;
4262
4263
4264 if (mddev->bitmap)
4265 bitmap_daemon_work(mddev->bitmap);
4266
4267 if (mddev->ro)
4268 return;
4269
4270 if (signal_pending(current)) {
4271 if (mddev->pers->sync_request) {
4272 printk(KERN_INFO "md: %s in immediate safe mode\n",
4273 mdname(mddev));
4274 mddev->safemode = 2;
4275 }
4276 flush_signals(current);
4277 }
4278
4279 if ( ! (
4280 mddev->sb_dirty ||
4281 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
4282 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
4283 (mddev->safemode == 1) ||
4284 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
4285 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
4286 ))
4287 return;
4288
4289 if (mddev_trylock(mddev)==0) {
4290 int spares =0;
4291
4292 spin_lock_irq(&mddev->write_lock);
4293 if (mddev->safemode && !atomic_read(&mddev->writes_pending) &&
4294 !mddev->in_sync && mddev->recovery_cp == MaxSector) {
4295 mddev->in_sync = 1;
4296 mddev->sb_dirty = 1;
4297 }
4298 if (mddev->safemode == 1)
4299 mddev->safemode = 0;
4300 spin_unlock_irq(&mddev->write_lock);
4301
4302 if (mddev->sb_dirty)
4303 md_update_sb(mddev);
4304
4305
4306 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
4307 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
4308 /* resync/recovery still happening */
4309 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4310 goto unlock;
4311 }
4312 if (mddev->sync_thread) {
4313 /* resync has finished, collect result */
4314 md_unregister_thread(mddev->sync_thread);
4315 mddev->sync_thread = NULL;
4316 if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
4317 !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
4318 /* success...*/
4319 /* activate any spares */
4320 mddev->pers->spare_active(mddev);
4321 }
4322 md_update_sb(mddev);
4323
4324 /* if array is no-longer degraded, then any saved_raid_disk
4325 * information must be scrapped
4326 */
4327 if (!mddev->degraded)
4328 ITERATE_RDEV(mddev,rdev,rtmp)
4329 rdev->saved_raid_disk = -1;
4330
4331 mddev->recovery = 0;
4332 /* flag recovery needed just to double check */
4333 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4334 md_new_event(mddev);
4335 goto unlock;
4336 }
4337 /* Clear some bits that don't mean anything, but
4338 * might be left set
4339 */
4340 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4341 clear_bit(MD_RECOVERY_ERR, &mddev->recovery);
4342 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
4343 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
4344
4345 /* no recovery is running.
4346 * remove any failed drives, then
4347 * add spares if possible.
4348 * Spare are also removed and re-added, to allow
4349 * the personality to fail the re-add.
4350 */
4351 ITERATE_RDEV(mddev,rdev,rtmp)
4352 if (rdev->raid_disk >= 0 &&
4353 (test_bit(Faulty, &rdev->flags) || ! test_bit(In_sync, &rdev->flags)) &&
4354 atomic_read(&rdev->nr_pending)==0) {
4355 if (mddev->pers->hot_remove_disk(mddev, rdev->raid_disk)==0) {
4356 char nm[20];
4357 sprintf(nm,"rd%d", rdev->raid_disk);
4358 sysfs_remove_link(&mddev->kobj, nm);
4359 rdev->raid_disk = -1;
4360 }
4361 }
4362
4363 if (mddev->degraded) {
4364 ITERATE_RDEV(mddev,rdev,rtmp)
4365 if (rdev->raid_disk < 0
4366 && !test_bit(Faulty, &rdev->flags)) {
4367 if (mddev->pers->hot_add_disk(mddev,rdev)) {
4368 char nm[20];
4369 sprintf(nm, "rd%d", rdev->raid_disk);
4370 sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
4371 spares++;
4372 md_new_event(mddev);
4373 } else
4374 break;
4375 }
4376 }
4377
4378 if (spares) {
4379 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4380 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
4381 } else if (mddev->recovery_cp < MaxSector) {
4382 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4383 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
4384 /* nothing to be done ... */
4385 goto unlock;
4386
4387 if (mddev->pers->sync_request) {
4388 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
4389 if (spares && mddev->bitmap && ! mddev->bitmap->file) {
4390 /* We are adding a device or devices to an array
4391 * which has the bitmap stored on all devices.
4392 * So make sure all bitmap pages get written
4393 */
4394 bitmap_write_all(mddev->bitmap);
4395 }
4396 mddev->sync_thread = md_register_thread(md_do_sync,
4397 mddev,
4398 "%s_resync");
4399 if (!mddev->sync_thread) {
4400 printk(KERN_ERR "%s: could not start resync"
4401 " thread...\n",
4402 mdname(mddev));
4403 /* leave the spares where they are, it shouldn't hurt */
4404 mddev->recovery = 0;
4405 } else
4406 md_wakeup_thread(mddev->sync_thread);
4407 md_new_event(mddev);
4408 }
4409 unlock:
4410 mddev_unlock(mddev);
4411 }
4412 }
4413
4414 static int md_notify_reboot(struct notifier_block *this,
4415 unsigned long code, void *x)
4416 {
4417 struct list_head *tmp;
4418 mddev_t *mddev;
4419
4420 if ((code == SYS_DOWN) || (code == SYS_HALT) || (code == SYS_POWER_OFF)) {
4421
4422 printk(KERN_INFO "md: stopping all md devices.\n");
4423
4424 ITERATE_MDDEV(mddev,tmp)
4425 if (mddev_trylock(mddev)==0)
4426 do_md_stop (mddev, 1);
4427 /*
4428 * certain more exotic SCSI devices are known to be
4429 * volatile wrt too early system reboots. While the
4430 * right place to handle this issue is the given
4431 * driver, we do want to have a safe RAID driver ...
4432 */
4433 mdelay(1000*1);
4434 }
4435 return NOTIFY_DONE;
4436 }
4437
4438 static struct notifier_block md_notifier = {
4439 .notifier_call = md_notify_reboot,
4440 .next = NULL,
4441 .priority = INT_MAX, /* before any real devices */
4442 };
4443
4444 static void md_geninit(void)
4445 {
4446 struct proc_dir_entry *p;
4447
4448 dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
4449
4450 p = create_proc_entry("mdstat", S_IRUGO, NULL);
4451 if (p)
4452 p->proc_fops = &md_seq_fops;
4453 }
4454
4455 static int __init md_init(void)
4456 {
4457 int minor;
4458
4459 printk(KERN_INFO "md: md driver %d.%d.%d MAX_MD_DEVS=%d,"
4460 " MD_SB_DISKS=%d\n",
4461 MD_MAJOR_VERSION, MD_MINOR_VERSION,
4462 MD_PATCHLEVEL_VERSION, MAX_MD_DEVS, MD_SB_DISKS);
4463 printk(KERN_INFO "md: bitmap version %d.%d\n", BITMAP_MAJOR_HI,
4464 BITMAP_MINOR);
4465
4466 if (register_blkdev(MAJOR_NR, "md"))
4467 return -1;
4468 if ((mdp_major=register_blkdev(0, "mdp"))<=0) {
4469 unregister_blkdev(MAJOR_NR, "md");
4470 return -1;
4471 }
4472 devfs_mk_dir("md");
4473 blk_register_region(MKDEV(MAJOR_NR, 0), MAX_MD_DEVS, THIS_MODULE,
4474 md_probe, NULL, NULL);
4475 blk_register_region(MKDEV(mdp_major, 0), MAX_MD_DEVS<<MdpMinorShift, THIS_MODULE,
4476 md_probe, NULL, NULL);
4477
4478 for (minor=0; minor < MAX_MD_DEVS; ++minor)
4479 devfs_mk_bdev(MKDEV(MAJOR_NR, minor),
4480 S_IFBLK|S_IRUSR|S_IWUSR,
4481 "md/%d", minor);
4482
4483 for (minor=0; minor < MAX_MD_DEVS; ++minor)
4484 devfs_mk_bdev(MKDEV(mdp_major, minor<<MdpMinorShift),
4485 S_IFBLK|S_IRUSR|S_IWUSR,
4486 "md/mdp%d", minor);
4487
4488
4489 register_reboot_notifier(&md_notifier);
4490 raid_table_header = register_sysctl_table(raid_root_table, 1);
4491
4492 md_geninit();
4493 return (0);
4494 }
4495
4496
4497 #ifndef MODULE
4498
4499 /*
4500 * Searches all registered partitions for autorun RAID arrays
4501 * at boot time.
4502 */
4503 static dev_t detected_devices[128];
4504 static int dev_cnt;
4505
4506 void md_autodetect_dev(dev_t dev)
4507 {
4508 if (dev_cnt >= 0 && dev_cnt < 127)
4509 detected_devices[dev_cnt++] = dev;
4510 }
4511
4512
4513 static void autostart_arrays(int part)
4514 {
4515 mdk_rdev_t *rdev;
4516 int i;
4517
4518 printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
4519
4520 for (i = 0; i < dev_cnt; i++) {
4521 dev_t dev = detected_devices[i];
4522
4523 rdev = md_import_device(dev,0, 0);
4524 if (IS_ERR(rdev))
4525 continue;
4526
4527 if (test_bit(Faulty, &rdev->flags)) {
4528 MD_BUG();
4529 continue;
4530 }
4531 list_add(&rdev->same_set, &pending_raid_disks);
4532 }
4533 dev_cnt = 0;
4534
4535 autorun_devices(part);
4536 }
4537
4538 #endif
4539
4540 static __exit void md_exit(void)
4541 {
4542 mddev_t *mddev;
4543 struct list_head *tmp;
4544 int i;
4545 blk_unregister_region(MKDEV(MAJOR_NR,0), MAX_MD_DEVS);
4546 blk_unregister_region(MKDEV(mdp_major,0), MAX_MD_DEVS << MdpMinorShift);
4547 for (i=0; i < MAX_MD_DEVS; i++)
4548 devfs_remove("md/%d", i);
4549 for (i=0; i < MAX_MD_DEVS; i++)
4550 devfs_remove("md/d%d", i);
4551
4552 devfs_remove("md");
4553
4554 unregister_blkdev(MAJOR_NR,"md");
4555 unregister_blkdev(mdp_major, "mdp");
4556 unregister_reboot_notifier(&md_notifier);
4557 unregister_sysctl_table(raid_table_header);
4558 remove_proc_entry("mdstat", NULL);
4559 ITERATE_MDDEV(mddev,tmp) {
4560 struct gendisk *disk = mddev->gendisk;
4561 if (!disk)
4562 continue;
4563 export_array(mddev);
4564 del_gendisk(disk);
4565 put_disk(disk);
4566 mddev->gendisk = NULL;
4567 mddev_put(mddev);
4568 }
4569 }
4570
4571 module_init(md_init)
4572 module_exit(md_exit)
4573
4574 static int get_ro(char *buffer, struct kernel_param *kp)
4575 {
4576 return sprintf(buffer, "%d", start_readonly);
4577 }
4578 static int set_ro(const char *val, struct kernel_param *kp)
4579 {
4580 char *e;
4581 int num = simple_strtoul(val, &e, 10);
4582 if (*val && (*e == '\0' || *e == '\n')) {
4583 start_readonly = num;
4584 return 0;;
4585 }
4586 return -EINVAL;
4587 }
4588
4589 module_param_call(start_ro, set_ro, get_ro, NULL, 0600);
4590 module_param(start_dirty_degraded, int, 0644);
4591
4592
4593 EXPORT_SYMBOL(register_md_personality);
4594 EXPORT_SYMBOL(unregister_md_personality);
4595 EXPORT_SYMBOL(md_error);
4596 EXPORT_SYMBOL(md_done_sync);
4597 EXPORT_SYMBOL(md_write_start);
4598 EXPORT_SYMBOL(md_write_end);
4599 EXPORT_SYMBOL(md_register_thread);
4600 EXPORT_SYMBOL(md_unregister_thread);
4601 EXPORT_SYMBOL(md_wakeup_thread);
4602 EXPORT_SYMBOL(md_print_devices);
4603 EXPORT_SYMBOL(md_check_recovery);
4604 MODULE_LICENSE("GPL");
4605 MODULE_ALIAS("md");
4606 MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);
Linus' kernel tree