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