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