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