]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/md/md.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
md-cluster: only call kick_rdev_from_array after remove disk successfully
[mirror_ubuntu-artful-kernel.git] / drivers / md / md.c
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/fs.h>
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/module.h>
47 #include <linux/reboot.h>
48 #include <linux/file.h>
49 #include <linux/compat.h>
50 #include <linux/delay.h>
51 #include <linux/raid/md_p.h>
52 #include <linux/raid/md_u.h>
53 #include <linux/slab.h>
54 #include "md.h"
55 #include "bitmap.h"
56 #include "md-cluster.h"
57
58 #ifndef MODULE
59 static void autostart_arrays(int part);
60 #endif
61
62 /* pers_list is a list of registered personalities protected
63 * by pers_lock.
64 * pers_lock does extra service to protect accesses to
65 * mddev->thread when the mutex cannot be held.
66 */
67 static LIST_HEAD(pers_list);
68 static DEFINE_SPINLOCK(pers_lock);
69
70 struct md_cluster_operations *md_cluster_ops;
71 EXPORT_SYMBOL(md_cluster_ops);
72 struct module *md_cluster_mod;
73 EXPORT_SYMBOL(md_cluster_mod);
74
75 static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
76 static struct workqueue_struct *md_wq;
77 static struct workqueue_struct *md_misc_wq;
78
79 static int remove_and_add_spares(struct mddev *mddev,
80 struct md_rdev *this);
81 static void mddev_detach(struct mddev *mddev);
82
83 /*
84 * Default number of read corrections we'll attempt on an rdev
85 * before ejecting it from the array. We divide the read error
86 * count by 2 for every hour elapsed between read errors.
87 */
88 #define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
89 /*
90 * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
91 * is 1000 KB/sec, so the extra system load does not show up that much.
92 * Increase it if you want to have more _guaranteed_ speed. Note that
93 * the RAID driver will use the maximum available bandwidth if the IO
94 * subsystem is idle. There is also an 'absolute maximum' reconstruction
95 * speed limit - in case reconstruction slows down your system despite
96 * idle IO detection.
97 *
98 * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
99 * or /sys/block/mdX/md/sync_speed_{min,max}
100 */
101
102 static int sysctl_speed_limit_min = 1000;
103 static int sysctl_speed_limit_max = 200000;
104 static inline int speed_min(struct mddev *mddev)
105 {
106 return mddev->sync_speed_min ?
107 mddev->sync_speed_min : sysctl_speed_limit_min;
108 }
109
110 static inline int speed_max(struct mddev *mddev)
111 {
112 return mddev->sync_speed_max ?
113 mddev->sync_speed_max : sysctl_speed_limit_max;
114 }
115
116 static struct ctl_table_header *raid_table_header;
117
118 static struct ctl_table raid_table[] = {
119 {
120 .procname = "speed_limit_min",
121 .data = &sysctl_speed_limit_min,
122 .maxlen = sizeof(int),
123 .mode = S_IRUGO|S_IWUSR,
124 .proc_handler = proc_dointvec,
125 },
126 {
127 .procname = "speed_limit_max",
128 .data = &sysctl_speed_limit_max,
129 .maxlen = sizeof(int),
130 .mode = S_IRUGO|S_IWUSR,
131 .proc_handler = proc_dointvec,
132 },
133 { }
134 };
135
136 static struct ctl_table raid_dir_table[] = {
137 {
138 .procname = "raid",
139 .maxlen = 0,
140 .mode = S_IRUGO|S_IXUGO,
141 .child = raid_table,
142 },
143 { }
144 };
145
146 static struct ctl_table raid_root_table[] = {
147 {
148 .procname = "dev",
149 .maxlen = 0,
150 .mode = 0555,
151 .child = raid_dir_table,
152 },
153 { }
154 };
155
156 static const struct block_device_operations md_fops;
157
158 static int start_readonly;
159
160 /* bio_clone_mddev
161 * like bio_clone, but with a local bio set
162 */
163
164 struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
165 struct mddev *mddev)
166 {
167 struct bio *b;
168
169 if (!mddev || !mddev->bio_set)
170 return bio_alloc(gfp_mask, nr_iovecs);
171
172 b = bio_alloc_bioset(gfp_mask, nr_iovecs, mddev->bio_set);
173 if (!b)
174 return NULL;
175 return b;
176 }
177 EXPORT_SYMBOL_GPL(bio_alloc_mddev);
178
179 struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
180 struct mddev *mddev)
181 {
182 if (!mddev || !mddev->bio_set)
183 return bio_clone(bio, gfp_mask);
184
185 return bio_clone_bioset(bio, gfp_mask, mddev->bio_set);
186 }
187 EXPORT_SYMBOL_GPL(bio_clone_mddev);
188
189 /*
190 * We have a system wide 'event count' that is incremented
191 * on any 'interesting' event, and readers of /proc/mdstat
192 * can use 'poll' or 'select' to find out when the event
193 * count increases.
194 *
195 * Events are:
196 * start array, stop array, error, add device, remove device,
197 * start build, activate spare
198 */
199 static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
200 static atomic_t md_event_count;
201 void md_new_event(struct mddev *mddev)
202 {
203 atomic_inc(&md_event_count);
204 wake_up(&md_event_waiters);
205 }
206 EXPORT_SYMBOL_GPL(md_new_event);
207
208 /* Alternate version that can be called from interrupts
209 * when calling sysfs_notify isn't needed.
210 */
211 static void md_new_event_inintr(struct mddev *mddev)
212 {
213 atomic_inc(&md_event_count);
214 wake_up(&md_event_waiters);
215 }
216
217 /*
218 * Enables to iterate over all existing md arrays
219 * all_mddevs_lock protects this list.
220 */
221 static LIST_HEAD(all_mddevs);
222 static DEFINE_SPINLOCK(all_mddevs_lock);
223
224 /*
225 * iterates through all used mddevs in the system.
226 * We take care to grab the all_mddevs_lock whenever navigating
227 * the list, and to always hold a refcount when unlocked.
228 * Any code which breaks out of this loop while own
229 * a reference to the current mddev and must mddev_put it.
230 */
231 #define for_each_mddev(_mddev,_tmp) \
232 \
233 for (({ spin_lock(&all_mddevs_lock); \
234 _tmp = all_mddevs.next; \
235 _mddev = NULL;}); \
236 ({ if (_tmp != &all_mddevs) \
237 mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\
238 spin_unlock(&all_mddevs_lock); \
239 if (_mddev) mddev_put(_mddev); \
240 _mddev = list_entry(_tmp, struct mddev, all_mddevs); \
241 _tmp != &all_mddevs;}); \
242 ({ spin_lock(&all_mddevs_lock); \
243 _tmp = _tmp->next;}) \
244 )
245
246 /* Rather than calling directly into the personality make_request function,
247 * IO requests come here first so that we can check if the device is
248 * being suspended pending a reconfiguration.
249 * We hold a refcount over the call to ->make_request. By the time that
250 * call has finished, the bio has been linked into some internal structure
251 * and so is visible to ->quiesce(), so we don't need the refcount any more.
252 */
253 static void md_make_request(struct request_queue *q, struct bio *bio)
254 {
255 const int rw = bio_data_dir(bio);
256 struct mddev *mddev = q->queuedata;
257 unsigned int sectors;
258 int cpu;
259
260 blk_queue_split(q, &bio, q->bio_split);
261
262 if (mddev == NULL || mddev->pers == NULL
263 || !mddev->ready) {
264 bio_io_error(bio);
265 return;
266 }
267 if (mddev->ro == 1 && unlikely(rw == WRITE)) {
268 if (bio_sectors(bio) != 0)
269 bio->bi_error = -EROFS;
270 bio_endio(bio);
271 return;
272 }
273 smp_rmb(); /* Ensure implications of 'active' are visible */
274 rcu_read_lock();
275 if (mddev->suspended) {
276 DEFINE_WAIT(__wait);
277 for (;;) {
278 prepare_to_wait(&mddev->sb_wait, &__wait,
279 TASK_UNINTERRUPTIBLE);
280 if (!mddev->suspended)
281 break;
282 rcu_read_unlock();
283 schedule();
284 rcu_read_lock();
285 }
286 finish_wait(&mddev->sb_wait, &__wait);
287 }
288 atomic_inc(&mddev->active_io);
289 rcu_read_unlock();
290
291 /*
292 * save the sectors now since our bio can
293 * go away inside make_request
294 */
295 sectors = bio_sectors(bio);
296 mddev->pers->make_request(mddev, bio);
297
298 cpu = part_stat_lock();
299 part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
300 part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors);
301 part_stat_unlock();
302
303 if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
304 wake_up(&mddev->sb_wait);
305 }
306
307 /* mddev_suspend makes sure no new requests are submitted
308 * to the device, and that any requests that have been submitted
309 * are completely handled.
310 * Once mddev_detach() is called and completes, the module will be
311 * completely unused.
312 */
313 void mddev_suspend(struct mddev *mddev)
314 {
315 BUG_ON(mddev->suspended);
316 mddev->suspended = 1;
317 synchronize_rcu();
318 wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
319 mddev->pers->quiesce(mddev, 1);
320
321 del_timer_sync(&mddev->safemode_timer);
322 }
323 EXPORT_SYMBOL_GPL(mddev_suspend);
324
325 void mddev_resume(struct mddev *mddev)
326 {
327 mddev->suspended = 0;
328 wake_up(&mddev->sb_wait);
329 mddev->pers->quiesce(mddev, 0);
330
331 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
332 md_wakeup_thread(mddev->thread);
333 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
334 }
335 EXPORT_SYMBOL_GPL(mddev_resume);
336
337 int mddev_congested(struct mddev *mddev, int bits)
338 {
339 struct md_personality *pers = mddev->pers;
340 int ret = 0;
341
342 rcu_read_lock();
343 if (mddev->suspended)
344 ret = 1;
345 else if (pers && pers->congested)
346 ret = pers->congested(mddev, bits);
347 rcu_read_unlock();
348 return ret;
349 }
350 EXPORT_SYMBOL_GPL(mddev_congested);
351 static int md_congested(void *data, int bits)
352 {
353 struct mddev *mddev = data;
354 return mddev_congested(mddev, bits);
355 }
356
357 /*
358 * Generic flush handling for md
359 */
360
361 static void md_end_flush(struct bio *bio)
362 {
363 struct md_rdev *rdev = bio->bi_private;
364 struct mddev *mddev = rdev->mddev;
365
366 rdev_dec_pending(rdev, mddev);
367
368 if (atomic_dec_and_test(&mddev->flush_pending)) {
369 /* The pre-request flush has finished */
370 queue_work(md_wq, &mddev->flush_work);
371 }
372 bio_put(bio);
373 }
374
375 static void md_submit_flush_data(struct work_struct *ws);
376
377 static void submit_flushes(struct work_struct *ws)
378 {
379 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
380 struct md_rdev *rdev;
381
382 INIT_WORK(&mddev->flush_work, md_submit_flush_data);
383 atomic_set(&mddev->flush_pending, 1);
384 rcu_read_lock();
385 rdev_for_each_rcu(rdev, mddev)
386 if (rdev->raid_disk >= 0 &&
387 !test_bit(Faulty, &rdev->flags)) {
388 /* Take two references, one is dropped
389 * when request finishes, one after
390 * we reclaim rcu_read_lock
391 */
392 struct bio *bi;
393 atomic_inc(&rdev->nr_pending);
394 atomic_inc(&rdev->nr_pending);
395 rcu_read_unlock();
396 bi = bio_alloc_mddev(GFP_NOIO, 0, mddev);
397 bi->bi_end_io = md_end_flush;
398 bi->bi_private = rdev;
399 bi->bi_bdev = rdev->bdev;
400 atomic_inc(&mddev->flush_pending);
401 submit_bio(WRITE_FLUSH, bi);
402 rcu_read_lock();
403 rdev_dec_pending(rdev, mddev);
404 }
405 rcu_read_unlock();
406 if (atomic_dec_and_test(&mddev->flush_pending))
407 queue_work(md_wq, &mddev->flush_work);
408 }
409
410 static void md_submit_flush_data(struct work_struct *ws)
411 {
412 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
413 struct bio *bio = mddev->flush_bio;
414
415 if (bio->bi_iter.bi_size == 0)
416 /* an empty barrier - all done */
417 bio_endio(bio);
418 else {
419 bio->bi_rw &= ~REQ_FLUSH;
420 mddev->pers->make_request(mddev, bio);
421 }
422
423 mddev->flush_bio = NULL;
424 wake_up(&mddev->sb_wait);
425 }
426
427 void md_flush_request(struct mddev *mddev, struct bio *bio)
428 {
429 spin_lock_irq(&mddev->lock);
430 wait_event_lock_irq(mddev->sb_wait,
431 !mddev->flush_bio,
432 mddev->lock);
433 mddev->flush_bio = bio;
434 spin_unlock_irq(&mddev->lock);
435
436 INIT_WORK(&mddev->flush_work, submit_flushes);
437 queue_work(md_wq, &mddev->flush_work);
438 }
439 EXPORT_SYMBOL(md_flush_request);
440
441 void md_unplug(struct blk_plug_cb *cb, bool from_schedule)
442 {
443 struct mddev *mddev = cb->data;
444 md_wakeup_thread(mddev->thread);
445 kfree(cb);
446 }
447 EXPORT_SYMBOL(md_unplug);
448
449 static inline struct mddev *mddev_get(struct mddev *mddev)
450 {
451 atomic_inc(&mddev->active);
452 return mddev;
453 }
454
455 static void mddev_delayed_delete(struct work_struct *ws);
456
457 static void mddev_put(struct mddev *mddev)
458 {
459 struct bio_set *bs = NULL;
460
461 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
462 return;
463 if (!mddev->raid_disks && list_empty(&mddev->disks) &&
464 mddev->ctime == 0 && !mddev->hold_active) {
465 /* Array is not configured at all, and not held active,
466 * so destroy it */
467 list_del_init(&mddev->all_mddevs);
468 bs = mddev->bio_set;
469 mddev->bio_set = NULL;
470 if (mddev->gendisk) {
471 /* We did a probe so need to clean up. Call
472 * queue_work inside the spinlock so that
473 * flush_workqueue() after mddev_find will
474 * succeed in waiting for the work to be done.
475 */
476 INIT_WORK(&mddev->del_work, mddev_delayed_delete);
477 queue_work(md_misc_wq, &mddev->del_work);
478 } else
479 kfree(mddev);
480 }
481 spin_unlock(&all_mddevs_lock);
482 if (bs)
483 bioset_free(bs);
484 }
485
486 static void md_safemode_timeout(unsigned long data);
487
488 void mddev_init(struct mddev *mddev)
489 {
490 mutex_init(&mddev->open_mutex);
491 mutex_init(&mddev->reconfig_mutex);
492 mutex_init(&mddev->bitmap_info.mutex);
493 INIT_LIST_HEAD(&mddev->disks);
494 INIT_LIST_HEAD(&mddev->all_mddevs);
495 setup_timer(&mddev->safemode_timer, md_safemode_timeout,
496 (unsigned long) mddev);
497 atomic_set(&mddev->active, 1);
498 atomic_set(&mddev->openers, 0);
499 atomic_set(&mddev->active_io, 0);
500 spin_lock_init(&mddev->lock);
501 atomic_set(&mddev->flush_pending, 0);
502 init_waitqueue_head(&mddev->sb_wait);
503 init_waitqueue_head(&mddev->recovery_wait);
504 mddev->reshape_position = MaxSector;
505 mddev->reshape_backwards = 0;
506 mddev->last_sync_action = "none";
507 mddev->resync_min = 0;
508 mddev->resync_max = MaxSector;
509 mddev->level = LEVEL_NONE;
510 }
511 EXPORT_SYMBOL_GPL(mddev_init);
512
513 static struct mddev *mddev_find(dev_t unit)
514 {
515 struct mddev *mddev, *new = NULL;
516
517 if (unit && MAJOR(unit) != MD_MAJOR)
518 unit &= ~((1<<MdpMinorShift)-1);
519
520 retry:
521 spin_lock(&all_mddevs_lock);
522
523 if (unit) {
524 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
525 if (mddev->unit == unit) {
526 mddev_get(mddev);
527 spin_unlock(&all_mddevs_lock);
528 kfree(new);
529 return mddev;
530 }
531
532 if (new) {
533 list_add(&new->all_mddevs, &all_mddevs);
534 spin_unlock(&all_mddevs_lock);
535 new->hold_active = UNTIL_IOCTL;
536 return new;
537 }
538 } else if (new) {
539 /* find an unused unit number */
540 static int next_minor = 512;
541 int start = next_minor;
542 int is_free = 0;
543 int dev = 0;
544 while (!is_free) {
545 dev = MKDEV(MD_MAJOR, next_minor);
546 next_minor++;
547 if (next_minor > MINORMASK)
548 next_minor = 0;
549 if (next_minor == start) {
550 /* Oh dear, all in use. */
551 spin_unlock(&all_mddevs_lock);
552 kfree(new);
553 return NULL;
554 }
555
556 is_free = 1;
557 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
558 if (mddev->unit == dev) {
559 is_free = 0;
560 break;
561 }
562 }
563 new->unit = dev;
564 new->md_minor = MINOR(dev);
565 new->hold_active = UNTIL_STOP;
566 list_add(&new->all_mddevs, &all_mddevs);
567 spin_unlock(&all_mddevs_lock);
568 return new;
569 }
570 spin_unlock(&all_mddevs_lock);
571
572 new = kzalloc(sizeof(*new), GFP_KERNEL);
573 if (!new)
574 return NULL;
575
576 new->unit = unit;
577 if (MAJOR(unit) == MD_MAJOR)
578 new->md_minor = MINOR(unit);
579 else
580 new->md_minor = MINOR(unit) >> MdpMinorShift;
581
582 mddev_init(new);
583
584 goto retry;
585 }
586
587 static struct attribute_group md_redundancy_group;
588
589 void mddev_unlock(struct mddev *mddev)
590 {
591 if (mddev->to_remove) {
592 /* These cannot be removed under reconfig_mutex as
593 * an access to the files will try to take reconfig_mutex
594 * while holding the file unremovable, which leads to
595 * a deadlock.
596 * So hold set sysfs_active while the remove in happeing,
597 * and anything else which might set ->to_remove or my
598 * otherwise change the sysfs namespace will fail with
599 * -EBUSY if sysfs_active is still set.
600 * We set sysfs_active under reconfig_mutex and elsewhere
601 * test it under the same mutex to ensure its correct value
602 * is seen.
603 */
604 struct attribute_group *to_remove = mddev->to_remove;
605 mddev->to_remove = NULL;
606 mddev->sysfs_active = 1;
607 mutex_unlock(&mddev->reconfig_mutex);
608
609 if (mddev->kobj.sd) {
610 if (to_remove != &md_redundancy_group)
611 sysfs_remove_group(&mddev->kobj, to_remove);
612 if (mddev->pers == NULL ||
613 mddev->pers->sync_request == NULL) {
614 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
615 if (mddev->sysfs_action)
616 sysfs_put(mddev->sysfs_action);
617 mddev->sysfs_action = NULL;
618 }
619 }
620 mddev->sysfs_active = 0;
621 } else
622 mutex_unlock(&mddev->reconfig_mutex);
623
624 /* As we've dropped the mutex we need a spinlock to
625 * make sure the thread doesn't disappear
626 */
627 spin_lock(&pers_lock);
628 md_wakeup_thread(mddev->thread);
629 spin_unlock(&pers_lock);
630 }
631 EXPORT_SYMBOL_GPL(mddev_unlock);
632
633 struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr)
634 {
635 struct md_rdev *rdev;
636
637 rdev_for_each_rcu(rdev, mddev)
638 if (rdev->desc_nr == nr)
639 return rdev;
640
641 return NULL;
642 }
643 EXPORT_SYMBOL_GPL(md_find_rdev_nr_rcu);
644
645 static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)
646 {
647 struct md_rdev *rdev;
648
649 rdev_for_each(rdev, mddev)
650 if (rdev->bdev->bd_dev == dev)
651 return rdev;
652
653 return NULL;
654 }
655
656 static struct md_rdev *find_rdev_rcu(struct mddev *mddev, dev_t dev)
657 {
658 struct md_rdev *rdev;
659
660 rdev_for_each_rcu(rdev, mddev)
661 if (rdev->bdev->bd_dev == dev)
662 return rdev;
663
664 return NULL;
665 }
666
667 static struct md_personality *find_pers(int level, char *clevel)
668 {
669 struct md_personality *pers;
670 list_for_each_entry(pers, &pers_list, list) {
671 if (level != LEVEL_NONE && pers->level == level)
672 return pers;
673 if (strcmp(pers->name, clevel)==0)
674 return pers;
675 }
676 return NULL;
677 }
678
679 /* return the offset of the super block in 512byte sectors */
680 static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
681 {
682 sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
683 return MD_NEW_SIZE_SECTORS(num_sectors);
684 }
685
686 static int alloc_disk_sb(struct md_rdev *rdev)
687 {
688 rdev->sb_page = alloc_page(GFP_KERNEL);
689 if (!rdev->sb_page) {
690 printk(KERN_ALERT "md: out of memory.\n");
691 return -ENOMEM;
692 }
693
694 return 0;
695 }
696
697 void md_rdev_clear(struct md_rdev *rdev)
698 {
699 if (rdev->sb_page) {
700 put_page(rdev->sb_page);
701 rdev->sb_loaded = 0;
702 rdev->sb_page = NULL;
703 rdev->sb_start = 0;
704 rdev->sectors = 0;
705 }
706 if (rdev->bb_page) {
707 put_page(rdev->bb_page);
708 rdev->bb_page = NULL;
709 }
710 kfree(rdev->badblocks.page);
711 rdev->badblocks.page = NULL;
712 }
713 EXPORT_SYMBOL_GPL(md_rdev_clear);
714
715 static void super_written(struct bio *bio)
716 {
717 struct md_rdev *rdev = bio->bi_private;
718 struct mddev *mddev = rdev->mddev;
719
720 if (bio->bi_error) {
721 printk("md: super_written gets error=%d\n", bio->bi_error);
722 md_error(mddev, rdev);
723 }
724
725 if (atomic_dec_and_test(&mddev->pending_writes))
726 wake_up(&mddev->sb_wait);
727 bio_put(bio);
728 }
729
730 void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
731 sector_t sector, int size, struct page *page)
732 {
733 /* write first size bytes of page to sector of rdev
734 * Increment mddev->pending_writes before returning
735 * and decrement it on completion, waking up sb_wait
736 * if zero is reached.
737 * If an error occurred, call md_error
738 */
739 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, mddev);
740
741 bio->bi_bdev = rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev;
742 bio->bi_iter.bi_sector = sector;
743 bio_add_page(bio, page, size, 0);
744 bio->bi_private = rdev;
745 bio->bi_end_io = super_written;
746
747 atomic_inc(&mddev->pending_writes);
748 submit_bio(WRITE_FLUSH_FUA, bio);
749 }
750
751 void md_super_wait(struct mddev *mddev)
752 {
753 /* wait for all superblock writes that were scheduled to complete */
754 wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
755 }
756
757 int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
758 struct page *page, int rw, bool metadata_op)
759 {
760 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev);
761 int ret;
762
763 bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
764 rdev->meta_bdev : rdev->bdev;
765 if (metadata_op)
766 bio->bi_iter.bi_sector = sector + rdev->sb_start;
767 else if (rdev->mddev->reshape_position != MaxSector &&
768 (rdev->mddev->reshape_backwards ==
769 (sector >= rdev->mddev->reshape_position)))
770 bio->bi_iter.bi_sector = sector + rdev->new_data_offset;
771 else
772 bio->bi_iter.bi_sector = sector + rdev->data_offset;
773 bio_add_page(bio, page, size, 0);
774 submit_bio_wait(rw, bio);
775
776 ret = !bio->bi_error;
777 bio_put(bio);
778 return ret;
779 }
780 EXPORT_SYMBOL_GPL(sync_page_io);
781
782 static int read_disk_sb(struct md_rdev *rdev, int size)
783 {
784 char b[BDEVNAME_SIZE];
785
786 if (rdev->sb_loaded)
787 return 0;
788
789 if (!sync_page_io(rdev, 0, size, rdev->sb_page, READ, true))
790 goto fail;
791 rdev->sb_loaded = 1;
792 return 0;
793
794 fail:
795 printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
796 bdevname(rdev->bdev,b));
797 return -EINVAL;
798 }
799
800 static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
801 {
802 return sb1->set_uuid0 == sb2->set_uuid0 &&
803 sb1->set_uuid1 == sb2->set_uuid1 &&
804 sb1->set_uuid2 == sb2->set_uuid2 &&
805 sb1->set_uuid3 == sb2->set_uuid3;
806 }
807
808 static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
809 {
810 int ret;
811 mdp_super_t *tmp1, *tmp2;
812
813 tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
814 tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
815
816 if (!tmp1 || !tmp2) {
817 ret = 0;
818 printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
819 goto abort;
820 }
821
822 *tmp1 = *sb1;
823 *tmp2 = *sb2;
824
825 /*
826 * nr_disks is not constant
827 */
828 tmp1->nr_disks = 0;
829 tmp2->nr_disks = 0;
830
831 ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
832 abort:
833 kfree(tmp1);
834 kfree(tmp2);
835 return ret;
836 }
837
838 static u32 md_csum_fold(u32 csum)
839 {
840 csum = (csum & 0xffff) + (csum >> 16);
841 return (csum & 0xffff) + (csum >> 16);
842 }
843
844 static unsigned int calc_sb_csum(mdp_super_t *sb)
845 {
846 u64 newcsum = 0;
847 u32 *sb32 = (u32*)sb;
848 int i;
849 unsigned int disk_csum, csum;
850
851 disk_csum = sb->sb_csum;
852 sb->sb_csum = 0;
853
854 for (i = 0; i < MD_SB_BYTES/4 ; i++)
855 newcsum += sb32[i];
856 csum = (newcsum & 0xffffffff) + (newcsum>>32);
857
858 #ifdef CONFIG_ALPHA
859 /* This used to use csum_partial, which was wrong for several
860 * reasons including that different results are returned on
861 * different architectures. It isn't critical that we get exactly
862 * the same return value as before (we always csum_fold before
863 * testing, and that removes any differences). However as we
864 * know that csum_partial always returned a 16bit value on
865 * alphas, do a fold to maximise conformity to previous behaviour.
866 */
867 sb->sb_csum = md_csum_fold(disk_csum);
868 #else
869 sb->sb_csum = disk_csum;
870 #endif
871 return csum;
872 }
873
874 /*
875 * Handle superblock details.
876 * We want to be able to handle multiple superblock formats
877 * so we have a common interface to them all, and an array of
878 * different handlers.
879 * We rely on user-space to write the initial superblock, and support
880 * reading and updating of superblocks.
881 * Interface methods are:
882 * int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
883 * loads and validates a superblock on dev.
884 * if refdev != NULL, compare superblocks on both devices
885 * Return:
886 * 0 - dev has a superblock that is compatible with refdev
887 * 1 - dev has a superblock that is compatible and newer than refdev
888 * so dev should be used as the refdev in future
889 * -EINVAL superblock incompatible or invalid
890 * -othererror e.g. -EIO
891 *
892 * int validate_super(struct mddev *mddev, struct md_rdev *dev)
893 * Verify that dev is acceptable into mddev.
894 * The first time, mddev->raid_disks will be 0, and data from
895 * dev should be merged in. Subsequent calls check that dev
896 * is new enough. Return 0 or -EINVAL
897 *
898 * void sync_super(struct mddev *mddev, struct md_rdev *dev)
899 * Update the superblock for rdev with data in mddev
900 * This does not write to disc.
901 *
902 */
903
904 struct super_type {
905 char *name;
906 struct module *owner;
907 int (*load_super)(struct md_rdev *rdev,
908 struct md_rdev *refdev,
909 int minor_version);
910 int (*validate_super)(struct mddev *mddev,
911 struct md_rdev *rdev);
912 void (*sync_super)(struct mddev *mddev,
913 struct md_rdev *rdev);
914 unsigned long long (*rdev_size_change)(struct md_rdev *rdev,
915 sector_t num_sectors);
916 int (*allow_new_offset)(struct md_rdev *rdev,
917 unsigned long long new_offset);
918 };
919
920 /*
921 * Check that the given mddev has no bitmap.
922 *
923 * This function is called from the run method of all personalities that do not
924 * support bitmaps. It prints an error message and returns non-zero if mddev
925 * has a bitmap. Otherwise, it returns 0.
926 *
927 */
928 int md_check_no_bitmap(struct mddev *mddev)
929 {
930 if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
931 return 0;
932 printk(KERN_ERR "%s: bitmaps are not supported for %s\n",
933 mdname(mddev), mddev->pers->name);
934 return 1;
935 }
936 EXPORT_SYMBOL(md_check_no_bitmap);
937
938 /*
939 * load_super for 0.90.0
940 */
941 static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
942 {
943 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
944 mdp_super_t *sb;
945 int ret;
946
947 /*
948 * Calculate the position of the superblock (512byte sectors),
949 * it's at the end of the disk.
950 *
951 * It also happens to be a multiple of 4Kb.
952 */
953 rdev->sb_start = calc_dev_sboffset(rdev);
954
955 ret = read_disk_sb(rdev, MD_SB_BYTES);
956 if (ret) return ret;
957
958 ret = -EINVAL;
959
960 bdevname(rdev->bdev, b);
961 sb = page_address(rdev->sb_page);
962
963 if (sb->md_magic != MD_SB_MAGIC) {
964 printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
965 b);
966 goto abort;
967 }
968
969 if (sb->major_version != 0 ||
970 sb->minor_version < 90 ||
971 sb->minor_version > 91) {
972 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
973 sb->major_version, sb->minor_version,
974 b);
975 goto abort;
976 }
977
978 if (sb->raid_disks <= 0)
979 goto abort;
980
981 if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
982 printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
983 b);
984 goto abort;
985 }
986
987 rdev->preferred_minor = sb->md_minor;
988 rdev->data_offset = 0;
989 rdev->new_data_offset = 0;
990 rdev->sb_size = MD_SB_BYTES;
991 rdev->badblocks.shift = -1;
992
993 if (sb->level == LEVEL_MULTIPATH)
994 rdev->desc_nr = -1;
995 else
996 rdev->desc_nr = sb->this_disk.number;
997
998 if (!refdev) {
999 ret = 1;
1000 } else {
1001 __u64 ev1, ev2;
1002 mdp_super_t *refsb = page_address(refdev->sb_page);
1003 if (!uuid_equal(refsb, sb)) {
1004 printk(KERN_WARNING "md: %s has different UUID to %s\n",
1005 b, bdevname(refdev->bdev,b2));
1006 goto abort;
1007 }
1008 if (!sb_equal(refsb, sb)) {
1009 printk(KERN_WARNING "md: %s has same UUID"
1010 " but different superblock to %s\n",
1011 b, bdevname(refdev->bdev, b2));
1012 goto abort;
1013 }
1014 ev1 = md_event(sb);
1015 ev2 = md_event(refsb);
1016 if (ev1 > ev2)
1017 ret = 1;
1018 else
1019 ret = 0;
1020 }
1021 rdev->sectors = rdev->sb_start;
1022 /* Limit to 4TB as metadata cannot record more than that.
1023 * (not needed for Linear and RAID0 as metadata doesn't
1024 * record this size)
1025 */
1026 if (rdev->sectors >= (2ULL << 32) && sb->level >= 1)
1027 rdev->sectors = (2ULL << 32) - 2;
1028
1029 if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
1030 /* "this cannot possibly happen" ... */
1031 ret = -EINVAL;
1032
1033 abort:
1034 return ret;
1035 }
1036
1037 /*
1038 * validate_super for 0.90.0
1039 */
1040 static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
1041 {
1042 mdp_disk_t *desc;
1043 mdp_super_t *sb = page_address(rdev->sb_page);
1044 __u64 ev1 = md_event(sb);
1045
1046 rdev->raid_disk = -1;
1047 clear_bit(Faulty, &rdev->flags);
1048 clear_bit(In_sync, &rdev->flags);
1049 clear_bit(Bitmap_sync, &rdev->flags);
1050 clear_bit(WriteMostly, &rdev->flags);
1051
1052 if (mddev->raid_disks == 0) {
1053 mddev->major_version = 0;
1054 mddev->minor_version = sb->minor_version;
1055 mddev->patch_version = sb->patch_version;
1056 mddev->external = 0;
1057 mddev->chunk_sectors = sb->chunk_size >> 9;
1058 mddev->ctime = sb->ctime;
1059 mddev->utime = sb->utime;
1060 mddev->level = sb->level;
1061 mddev->clevel[0] = 0;
1062 mddev->layout = sb->layout;
1063 mddev->raid_disks = sb->raid_disks;
1064 mddev->dev_sectors = ((sector_t)sb->size) * 2;
1065 mddev->events = ev1;
1066 mddev->bitmap_info.offset = 0;
1067 mddev->bitmap_info.space = 0;
1068 /* bitmap can use 60 K after the 4K superblocks */
1069 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
1070 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
1071 mddev->reshape_backwards = 0;
1072
1073 if (mddev->minor_version >= 91) {
1074 mddev->reshape_position = sb->reshape_position;
1075 mddev->delta_disks = sb->delta_disks;
1076 mddev->new_level = sb->new_level;
1077 mddev->new_layout = sb->new_layout;
1078 mddev->new_chunk_sectors = sb->new_chunk >> 9;
1079 if (mddev->delta_disks < 0)
1080 mddev->reshape_backwards = 1;
1081 } else {
1082 mddev->reshape_position = MaxSector;
1083 mddev->delta_disks = 0;
1084 mddev->new_level = mddev->level;
1085 mddev->new_layout = mddev->layout;
1086 mddev->new_chunk_sectors = mddev->chunk_sectors;
1087 }
1088
1089 if (sb->state & (1<<MD_SB_CLEAN))
1090 mddev->recovery_cp = MaxSector;
1091 else {
1092 if (sb->events_hi == sb->cp_events_hi &&
1093 sb->events_lo == sb->cp_events_lo) {
1094 mddev->recovery_cp = sb->recovery_cp;
1095 } else
1096 mddev->recovery_cp = 0;
1097 }
1098
1099 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
1100 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
1101 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
1102 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
1103
1104 mddev->max_disks = MD_SB_DISKS;
1105
1106 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
1107 mddev->bitmap_info.file == NULL) {
1108 mddev->bitmap_info.offset =
1109 mddev->bitmap_info.default_offset;
1110 mddev->bitmap_info.space =
1111 mddev->bitmap_info.default_space;
1112 }
1113
1114 } else if (mddev->pers == NULL) {
1115 /* Insist on good event counter while assembling, except
1116 * for spares (which don't need an event count) */
1117 ++ev1;
1118 if (sb->disks[rdev->desc_nr].state & (
1119 (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
1120 if (ev1 < mddev->events)
1121 return -EINVAL;
1122 } else if (mddev->bitmap) {
1123 /* if adding to array with a bitmap, then we can accept an
1124 * older device ... but not too old.
1125 */
1126 if (ev1 < mddev->bitmap->events_cleared)
1127 return 0;
1128 if (ev1 < mddev->events)
1129 set_bit(Bitmap_sync, &rdev->flags);
1130 } else {
1131 if (ev1 < mddev->events)
1132 /* just a hot-add of a new device, leave raid_disk at -1 */
1133 return 0;
1134 }
1135
1136 if (mddev->level != LEVEL_MULTIPATH) {
1137 desc = sb->disks + rdev->desc_nr;
1138
1139 if (desc->state & (1<<MD_DISK_FAULTY))
1140 set_bit(Faulty, &rdev->flags);
1141 else if (desc->state & (1<<MD_DISK_SYNC) /* &&
1142 desc->raid_disk < mddev->raid_disks */) {
1143 set_bit(In_sync, &rdev->flags);
1144 rdev->raid_disk = desc->raid_disk;
1145 rdev->saved_raid_disk = desc->raid_disk;
1146 } else if (desc->state & (1<<MD_DISK_ACTIVE)) {
1147 /* active but not in sync implies recovery up to
1148 * reshape position. We don't know exactly where
1149 * that is, so set to zero for now */
1150 if (mddev->minor_version >= 91) {
1151 rdev->recovery_offset = 0;
1152 rdev->raid_disk = desc->raid_disk;
1153 }
1154 }
1155 if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
1156 set_bit(WriteMostly, &rdev->flags);
1157 } else /* MULTIPATH are always insync */
1158 set_bit(In_sync, &rdev->flags);
1159 return 0;
1160 }
1161
1162 /*
1163 * sync_super for 0.90.0
1164 */
1165 static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
1166 {
1167 mdp_super_t *sb;
1168 struct md_rdev *rdev2;
1169 int next_spare = mddev->raid_disks;
1170
1171 /* make rdev->sb match mddev data..
1172 *
1173 * 1/ zero out disks
1174 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
1175 * 3/ any empty disks < next_spare become removed
1176 *
1177 * disks[0] gets initialised to REMOVED because
1178 * we cannot be sure from other fields if it has
1179 * been initialised or not.
1180 */
1181 int i;
1182 int active=0, working=0,failed=0,spare=0,nr_disks=0;
1183
1184 rdev->sb_size = MD_SB_BYTES;
1185
1186 sb = page_address(rdev->sb_page);
1187
1188 memset(sb, 0, sizeof(*sb));
1189
1190 sb->md_magic = MD_SB_MAGIC;
1191 sb->major_version = mddev->major_version;
1192 sb->patch_version = mddev->patch_version;
1193 sb->gvalid_words = 0; /* ignored */
1194 memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
1195 memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
1196 memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
1197 memcpy(&sb->set_uuid3, mddev->uuid+12,4);
1198
1199 sb->ctime = mddev->ctime;
1200 sb->level = mddev->level;
1201 sb->size = mddev->dev_sectors / 2;
1202 sb->raid_disks = mddev->raid_disks;
1203 sb->md_minor = mddev->md_minor;
1204 sb->not_persistent = 0;
1205 sb->utime = mddev->utime;
1206 sb->state = 0;
1207 sb->events_hi = (mddev->events>>32);
1208 sb->events_lo = (u32)mddev->events;
1209
1210 if (mddev->reshape_position == MaxSector)
1211 sb->minor_version = 90;
1212 else {
1213 sb->minor_version = 91;
1214 sb->reshape_position = mddev->reshape_position;
1215 sb->new_level = mddev->new_level;
1216 sb->delta_disks = mddev->delta_disks;
1217 sb->new_layout = mddev->new_layout;
1218 sb->new_chunk = mddev->new_chunk_sectors << 9;
1219 }
1220 mddev->minor_version = sb->minor_version;
1221 if (mddev->in_sync)
1222 {
1223 sb->recovery_cp = mddev->recovery_cp;
1224 sb->cp_events_hi = (mddev->events>>32);
1225 sb->cp_events_lo = (u32)mddev->events;
1226 if (mddev->recovery_cp == MaxSector)
1227 sb->state = (1<< MD_SB_CLEAN);
1228 } else
1229 sb->recovery_cp = 0;
1230
1231 sb->layout = mddev->layout;
1232 sb->chunk_size = mddev->chunk_sectors << 9;
1233
1234 if (mddev->bitmap && mddev->bitmap_info.file == NULL)
1235 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
1236
1237 sb->disks[0].state = (1<<MD_DISK_REMOVED);
1238 rdev_for_each(rdev2, mddev) {
1239 mdp_disk_t *d;
1240 int desc_nr;
1241 int is_active = test_bit(In_sync, &rdev2->flags);
1242
1243 if (rdev2->raid_disk >= 0 &&
1244 sb->minor_version >= 91)
1245 /* we have nowhere to store the recovery_offset,
1246 * but if it is not below the reshape_position,
1247 * we can piggy-back on that.
1248 */
1249 is_active = 1;
1250 if (rdev2->raid_disk < 0 ||
1251 test_bit(Faulty, &rdev2->flags))
1252 is_active = 0;
1253 if (is_active)
1254 desc_nr = rdev2->raid_disk;
1255 else
1256 desc_nr = next_spare++;
1257 rdev2->desc_nr = desc_nr;
1258 d = &sb->disks[rdev2->desc_nr];
1259 nr_disks++;
1260 d->number = rdev2->desc_nr;
1261 d->major = MAJOR(rdev2->bdev->bd_dev);
1262 d->minor = MINOR(rdev2->bdev->bd_dev);
1263 if (is_active)
1264 d->raid_disk = rdev2->raid_disk;
1265 else
1266 d->raid_disk = rdev2->desc_nr; /* compatibility */
1267 if (test_bit(Faulty, &rdev2->flags))
1268 d->state = (1<<MD_DISK_FAULTY);
1269 else if (is_active) {
1270 d->state = (1<<MD_DISK_ACTIVE);
1271 if (test_bit(In_sync, &rdev2->flags))
1272 d->state |= (1<<MD_DISK_SYNC);
1273 active++;
1274 working++;
1275 } else {
1276 d->state = 0;
1277 spare++;
1278 working++;
1279 }
1280 if (test_bit(WriteMostly, &rdev2->flags))
1281 d->state |= (1<<MD_DISK_WRITEMOSTLY);
1282 }
1283 /* now set the "removed" and "faulty" bits on any missing devices */
1284 for (i=0 ; i < mddev->raid_disks ; i++) {
1285 mdp_disk_t *d = &sb->disks[i];
1286 if (d->state == 0 && d->number == 0) {
1287 d->number = i;
1288 d->raid_disk = i;
1289 d->state = (1<<MD_DISK_REMOVED);
1290 d->state |= (1<<MD_DISK_FAULTY);
1291 failed++;
1292 }
1293 }
1294 sb->nr_disks = nr_disks;
1295 sb->active_disks = active;
1296 sb->working_disks = working;
1297 sb->failed_disks = failed;
1298 sb->spare_disks = spare;
1299
1300 sb->this_disk = sb->disks[rdev->desc_nr];
1301 sb->sb_csum = calc_sb_csum(sb);
1302 }
1303
1304 /*
1305 * rdev_size_change for 0.90.0
1306 */
1307 static unsigned long long
1308 super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1309 {
1310 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1311 return 0; /* component must fit device */
1312 if (rdev->mddev->bitmap_info.offset)
1313 return 0; /* can't move bitmap */
1314 rdev->sb_start = calc_dev_sboffset(rdev);
1315 if (!num_sectors || num_sectors > rdev->sb_start)
1316 num_sectors = rdev->sb_start;
1317 /* Limit to 4TB as metadata cannot record more than that.
1318 * 4TB == 2^32 KB, or 2*2^32 sectors.
1319 */
1320 if (num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1)
1321 num_sectors = (2ULL << 32) - 2;
1322 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1323 rdev->sb_page);
1324 md_super_wait(rdev->mddev);
1325 return num_sectors;
1326 }
1327
1328 static int
1329 super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset)
1330 {
1331 /* non-zero offset changes not possible with v0.90 */
1332 return new_offset == 0;
1333 }
1334
1335 /*
1336 * version 1 superblock
1337 */
1338
1339 static __le32 calc_sb_1_csum(struct mdp_superblock_1 *sb)
1340 {
1341 __le32 disk_csum;
1342 u32 csum;
1343 unsigned long long newcsum;
1344 int size = 256 + le32_to_cpu(sb->max_dev)*2;
1345 __le32 *isuper = (__le32*)sb;
1346
1347 disk_csum = sb->sb_csum;
1348 sb->sb_csum = 0;
1349 newcsum = 0;
1350 for (; size >= 4; size -= 4)
1351 newcsum += le32_to_cpu(*isuper++);
1352
1353 if (size == 2)
1354 newcsum += le16_to_cpu(*(__le16*) isuper);
1355
1356 csum = (newcsum & 0xffffffff) + (newcsum >> 32);
1357 sb->sb_csum = disk_csum;
1358 return cpu_to_le32(csum);
1359 }
1360
1361 static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
1362 int acknowledged);
1363 static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
1364 {
1365 struct mdp_superblock_1 *sb;
1366 int ret;
1367 sector_t sb_start;
1368 sector_t sectors;
1369 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1370 int bmask;
1371
1372 /*
1373 * Calculate the position of the superblock in 512byte sectors.
1374 * It is always aligned to a 4K boundary and
1375 * depeding on minor_version, it can be:
1376 * 0: At least 8K, but less than 12K, from end of device
1377 * 1: At start of device
1378 * 2: 4K from start of device.
1379 */
1380 switch(minor_version) {
1381 case 0:
1382 sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;
1383 sb_start -= 8*2;
1384 sb_start &= ~(sector_t)(4*2-1);
1385 break;
1386 case 1:
1387 sb_start = 0;
1388 break;
1389 case 2:
1390 sb_start = 8;
1391 break;
1392 default:
1393 return -EINVAL;
1394 }
1395 rdev->sb_start = sb_start;
1396
1397 /* superblock is rarely larger than 1K, but it can be larger,
1398 * and it is safe to read 4k, so we do that
1399 */
1400 ret = read_disk_sb(rdev, 4096);
1401 if (ret) return ret;
1402
1403 sb = page_address(rdev->sb_page);
1404
1405 if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
1406 sb->major_version != cpu_to_le32(1) ||
1407 le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
1408 le64_to_cpu(sb->super_offset) != rdev->sb_start ||
1409 (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
1410 return -EINVAL;
1411
1412 if (calc_sb_1_csum(sb) != sb->sb_csum) {
1413 printk("md: invalid superblock checksum on %s\n",
1414 bdevname(rdev->bdev,b));
1415 return -EINVAL;
1416 }
1417 if (le64_to_cpu(sb->data_size) < 10) {
1418 printk("md: data_size too small on %s\n",
1419 bdevname(rdev->bdev,b));
1420 return -EINVAL;
1421 }
1422 if (sb->pad0 ||
1423 sb->pad3[0] ||
1424 memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1])))
1425 /* Some padding is non-zero, might be a new feature */
1426 return -EINVAL;
1427
1428 rdev->preferred_minor = 0xffff;
1429 rdev->data_offset = le64_to_cpu(sb->data_offset);
1430 rdev->new_data_offset = rdev->data_offset;
1431 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) &&
1432 (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
1433 rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset);
1434 atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
1435
1436 rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
1437 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1438 if (rdev->sb_size & bmask)
1439 rdev->sb_size = (rdev->sb_size | bmask) + 1;
1440
1441 if (minor_version
1442 && rdev->data_offset < sb_start + (rdev->sb_size/512))
1443 return -EINVAL;
1444 if (minor_version
1445 && rdev->new_data_offset < sb_start + (rdev->sb_size/512))
1446 return -EINVAL;
1447
1448 if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
1449 rdev->desc_nr = -1;
1450 else
1451 rdev->desc_nr = le32_to_cpu(sb->dev_number);
1452
1453 if (!rdev->bb_page) {
1454 rdev->bb_page = alloc_page(GFP_KERNEL);
1455 if (!rdev->bb_page)
1456 return -ENOMEM;
1457 }
1458 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
1459 rdev->badblocks.count == 0) {
1460 /* need to load the bad block list.
1461 * Currently we limit it to one page.
1462 */
1463 s32 offset;
1464 sector_t bb_sector;
1465 u64 *bbp;
1466 int i;
1467 int sectors = le16_to_cpu(sb->bblog_size);
1468 if (sectors > (PAGE_SIZE / 512))
1469 return -EINVAL;
1470 offset = le32_to_cpu(sb->bblog_offset);
1471 if (offset == 0)
1472 return -EINVAL;
1473 bb_sector = (long long)offset;
1474 if (!sync_page_io(rdev, bb_sector, sectors << 9,
1475 rdev->bb_page, READ, true))
1476 return -EIO;
1477 bbp = (u64 *)page_address(rdev->bb_page);
1478 rdev->badblocks.shift = sb->bblog_shift;
1479 for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
1480 u64 bb = le64_to_cpu(*bbp);
1481 int count = bb & (0x3ff);
1482 u64 sector = bb >> 10;
1483 sector <<= sb->bblog_shift;
1484 count <<= sb->bblog_shift;
1485 if (bb + 1 == 0)
1486 break;
1487 if (md_set_badblocks(&rdev->badblocks,
1488 sector, count, 1) == 0)
1489 return -EINVAL;
1490 }
1491 } else if (sb->bblog_offset != 0)
1492 rdev->badblocks.shift = 0;
1493
1494 if (!refdev) {
1495 ret = 1;
1496 } else {
1497 __u64 ev1, ev2;
1498 struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
1499
1500 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1501 sb->level != refsb->level ||
1502 sb->layout != refsb->layout ||
1503 sb->chunksize != refsb->chunksize) {
1504 printk(KERN_WARNING "md: %s has strangely different"
1505 " superblock to %s\n",
1506 bdevname(rdev->bdev,b),
1507 bdevname(refdev->bdev,b2));
1508 return -EINVAL;
1509 }
1510 ev1 = le64_to_cpu(sb->events);
1511 ev2 = le64_to_cpu(refsb->events);
1512
1513 if (ev1 > ev2)
1514 ret = 1;
1515 else
1516 ret = 0;
1517 }
1518 if (minor_version) {
1519 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9);
1520 sectors -= rdev->data_offset;
1521 } else
1522 sectors = rdev->sb_start;
1523 if (sectors < le64_to_cpu(sb->data_size))
1524 return -EINVAL;
1525 rdev->sectors = le64_to_cpu(sb->data_size);
1526 return ret;
1527 }
1528
1529 static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
1530 {
1531 struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
1532 __u64 ev1 = le64_to_cpu(sb->events);
1533
1534 rdev->raid_disk = -1;
1535 clear_bit(Faulty, &rdev->flags);
1536 clear_bit(In_sync, &rdev->flags);
1537 clear_bit(Bitmap_sync, &rdev->flags);
1538 clear_bit(WriteMostly, &rdev->flags);
1539
1540 if (mddev->raid_disks == 0) {
1541 mddev->major_version = 1;
1542 mddev->patch_version = 0;
1543 mddev->external = 0;
1544 mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
1545 mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
1546 mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
1547 mddev->level = le32_to_cpu(sb->level);
1548 mddev->clevel[0] = 0;
1549 mddev->layout = le32_to_cpu(sb->layout);
1550 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
1551 mddev->dev_sectors = le64_to_cpu(sb->size);
1552 mddev->events = ev1;
1553 mddev->bitmap_info.offset = 0;
1554 mddev->bitmap_info.space = 0;
1555 /* Default location for bitmap is 1K after superblock
1556 * using 3K - total of 4K
1557 */
1558 mddev->bitmap_info.default_offset = 1024 >> 9;
1559 mddev->bitmap_info.default_space = (4096-1024) >> 9;
1560 mddev->reshape_backwards = 0;
1561
1562 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1563 memcpy(mddev->uuid, sb->set_uuid, 16);
1564
1565 mddev->max_disks = (4096-256)/2;
1566
1567 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1568 mddev->bitmap_info.file == NULL) {
1569 mddev->bitmap_info.offset =
1570 (__s32)le32_to_cpu(sb->bitmap_offset);
1571 /* Metadata doesn't record how much space is available.
1572 * For 1.0, we assume we can use up to the superblock
1573 * if before, else to 4K beyond superblock.
1574 * For others, assume no change is possible.
1575 */
1576 if (mddev->minor_version > 0)
1577 mddev->bitmap_info.space = 0;
1578 else if (mddev->bitmap_info.offset > 0)
1579 mddev->bitmap_info.space =
1580 8 - mddev->bitmap_info.offset;
1581 else
1582 mddev->bitmap_info.space =
1583 -mddev->bitmap_info.offset;
1584 }
1585
1586 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
1587 mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1588 mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1589 mddev->new_level = le32_to_cpu(sb->new_level);
1590 mddev->new_layout = le32_to_cpu(sb->new_layout);
1591 mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
1592 if (mddev->delta_disks < 0 ||
1593 (mddev->delta_disks == 0 &&
1594 (le32_to_cpu(sb->feature_map)
1595 & MD_FEATURE_RESHAPE_BACKWARDS)))
1596 mddev->reshape_backwards = 1;
1597 } else {
1598 mddev->reshape_position = MaxSector;
1599 mddev->delta_disks = 0;
1600 mddev->new_level = mddev->level;
1601 mddev->new_layout = mddev->layout;
1602 mddev->new_chunk_sectors = mddev->chunk_sectors;
1603 }
1604
1605 } else if (mddev->pers == NULL) {
1606 /* Insist of good event counter while assembling, except for
1607 * spares (which don't need an event count) */
1608 ++ev1;
1609 if (rdev->desc_nr >= 0 &&
1610 rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
1611 le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < 0xfffe)
1612 if (ev1 < mddev->events)
1613 return -EINVAL;
1614 } else if (mddev->bitmap) {
1615 /* If adding to array with a bitmap, then we can accept an
1616 * older device, but not too old.
1617 */
1618 if (ev1 < mddev->bitmap->events_cleared)
1619 return 0;
1620 if (ev1 < mddev->events)
1621 set_bit(Bitmap_sync, &rdev->flags);
1622 } else {
1623 if (ev1 < mddev->events)
1624 /* just a hot-add of a new device, leave raid_disk at -1 */
1625 return 0;
1626 }
1627 if (mddev->level != LEVEL_MULTIPATH) {
1628 int role;
1629 if (rdev->desc_nr < 0 ||
1630 rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
1631 role = 0xffff;
1632 rdev->desc_nr = -1;
1633 } else
1634 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
1635 switch(role) {
1636 case 0xffff: /* spare */
1637 break;
1638 case 0xfffe: /* faulty */
1639 set_bit(Faulty, &rdev->flags);
1640 break;
1641 default:
1642 rdev->saved_raid_disk = role;
1643 if ((le32_to_cpu(sb->feature_map) &
1644 MD_FEATURE_RECOVERY_OFFSET)) {
1645 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
1646 if (!(le32_to_cpu(sb->feature_map) &
1647 MD_FEATURE_RECOVERY_BITMAP))
1648 rdev->saved_raid_disk = -1;
1649 } else
1650 set_bit(In_sync, &rdev->flags);
1651 rdev->raid_disk = role;
1652 break;
1653 }
1654 if (sb->devflags & WriteMostly1)
1655 set_bit(WriteMostly, &rdev->flags);
1656 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT)
1657 set_bit(Replacement, &rdev->flags);
1658 } else /* MULTIPATH are always insync */
1659 set_bit(In_sync, &rdev->flags);
1660
1661 return 0;
1662 }
1663
1664 static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
1665 {
1666 struct mdp_superblock_1 *sb;
1667 struct md_rdev *rdev2;
1668 int max_dev, i;
1669 /* make rdev->sb match mddev and rdev data. */
1670
1671 sb = page_address(rdev->sb_page);
1672
1673 sb->feature_map = 0;
1674 sb->pad0 = 0;
1675 sb->recovery_offset = cpu_to_le64(0);
1676 memset(sb->pad3, 0, sizeof(sb->pad3));
1677
1678 sb->utime = cpu_to_le64((__u64)mddev->utime);
1679 sb->events = cpu_to_le64(mddev->events);
1680 if (mddev->in_sync)
1681 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
1682 else
1683 sb->resync_offset = cpu_to_le64(0);
1684
1685 sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
1686
1687 sb->raid_disks = cpu_to_le32(mddev->raid_disks);
1688 sb->size = cpu_to_le64(mddev->dev_sectors);
1689 sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
1690 sb->level = cpu_to_le32(mddev->level);
1691 sb->layout = cpu_to_le32(mddev->layout);
1692
1693 if (test_bit(WriteMostly, &rdev->flags))
1694 sb->devflags |= WriteMostly1;
1695 else
1696 sb->devflags &= ~WriteMostly1;
1697 sb->data_offset = cpu_to_le64(rdev->data_offset);
1698 sb->data_size = cpu_to_le64(rdev->sectors);
1699
1700 if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
1701 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
1702 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1703 }
1704
1705 if (rdev->raid_disk >= 0 &&
1706 !test_bit(In_sync, &rdev->flags)) {
1707 sb->feature_map |=
1708 cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
1709 sb->recovery_offset =
1710 cpu_to_le64(rdev->recovery_offset);
1711 if (rdev->saved_raid_disk >= 0 && mddev->bitmap)
1712 sb->feature_map |=
1713 cpu_to_le32(MD_FEATURE_RECOVERY_BITMAP);
1714 }
1715 if (test_bit(Replacement, &rdev->flags))
1716 sb->feature_map |=
1717 cpu_to_le32(MD_FEATURE_REPLACEMENT);
1718
1719 if (mddev->reshape_position != MaxSector) {
1720 sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
1721 sb->reshape_position = cpu_to_le64(mddev->reshape_position);
1722 sb->new_layout = cpu_to_le32(mddev->new_layout);
1723 sb->delta_disks = cpu_to_le32(mddev->delta_disks);
1724 sb->new_level = cpu_to_le32(mddev->new_level);
1725 sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
1726 if (mddev->delta_disks == 0 &&
1727 mddev->reshape_backwards)
1728 sb->feature_map
1729 |= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
1730 if (rdev->new_data_offset != rdev->data_offset) {
1731 sb->feature_map
1732 |= cpu_to_le32(MD_FEATURE_NEW_OFFSET);
1733 sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset
1734 - rdev->data_offset));
1735 }
1736 }
1737
1738 if (mddev_is_clustered(mddev))
1739 sb->feature_map |= cpu_to_le32(MD_FEATURE_CLUSTERED);
1740
1741 if (rdev->badblocks.count == 0)
1742 /* Nothing to do for bad blocks*/ ;
1743 else if (sb->bblog_offset == 0)
1744 /* Cannot record bad blocks on this device */
1745 md_error(mddev, rdev);
1746 else {
1747 struct badblocks *bb = &rdev->badblocks;
1748 u64 *bbp = (u64 *)page_address(rdev->bb_page);
1749 u64 *p = bb->page;
1750 sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
1751 if (bb->changed) {
1752 unsigned seq;
1753
1754 retry:
1755 seq = read_seqbegin(&bb->lock);
1756
1757 memset(bbp, 0xff, PAGE_SIZE);
1758
1759 for (i = 0 ; i < bb->count ; i++) {
1760 u64 internal_bb = p[i];
1761 u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
1762 | BB_LEN(internal_bb));
1763 bbp[i] = cpu_to_le64(store_bb);
1764 }
1765 bb->changed = 0;
1766 if (read_seqretry(&bb->lock, seq))
1767 goto retry;
1768
1769 bb->sector = (rdev->sb_start +
1770 (int)le32_to_cpu(sb->bblog_offset));
1771 bb->size = le16_to_cpu(sb->bblog_size);
1772 }
1773 }
1774
1775 max_dev = 0;
1776 rdev_for_each(rdev2, mddev)
1777 if (rdev2->desc_nr+1 > max_dev)
1778 max_dev = rdev2->desc_nr+1;
1779
1780 if (max_dev > le32_to_cpu(sb->max_dev)) {
1781 int bmask;
1782 sb->max_dev = cpu_to_le32(max_dev);
1783 rdev->sb_size = max_dev * 2 + 256;
1784 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1785 if (rdev->sb_size & bmask)
1786 rdev->sb_size = (rdev->sb_size | bmask) + 1;
1787 } else
1788 max_dev = le32_to_cpu(sb->max_dev);
1789
1790 for (i=0; i<max_dev;i++)
1791 sb->dev_roles[i] = cpu_to_le16(0xfffe);
1792
1793 rdev_for_each(rdev2, mddev) {
1794 i = rdev2->desc_nr;
1795 if (test_bit(Faulty, &rdev2->flags))
1796 sb->dev_roles[i] = cpu_to_le16(0xfffe);
1797 else if (test_bit(In_sync, &rdev2->flags))
1798 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1799 else if (rdev2->raid_disk >= 0)
1800 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1801 else
1802 sb->dev_roles[i] = cpu_to_le16(0xffff);
1803 }
1804
1805 sb->sb_csum = calc_sb_1_csum(sb);
1806 }
1807
1808 static unsigned long long
1809 super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1810 {
1811 struct mdp_superblock_1 *sb;
1812 sector_t max_sectors;
1813 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1814 return 0; /* component must fit device */
1815 if (rdev->data_offset != rdev->new_data_offset)
1816 return 0; /* too confusing */
1817 if (rdev->sb_start < rdev->data_offset) {
1818 /* minor versions 1 and 2; superblock before data */
1819 max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9;
1820 max_sectors -= rdev->data_offset;
1821 if (!num_sectors || num_sectors > max_sectors)
1822 num_sectors = max_sectors;
1823 } else if (rdev->mddev->bitmap_info.offset) {
1824 /* minor version 0 with bitmap we can't move */
1825 return 0;
1826 } else {
1827 /* minor version 0; superblock after data */
1828 sector_t sb_start;
1829 sb_start = (i_size_read(rdev->bdev->bd_inode) >> 9) - 8*2;
1830 sb_start &= ~(sector_t)(4*2 - 1);
1831 max_sectors = rdev->sectors + sb_start - rdev->sb_start;
1832 if (!num_sectors || num_sectors > max_sectors)
1833 num_sectors = max_sectors;
1834 rdev->sb_start = sb_start;
1835 }
1836 sb = page_address(rdev->sb_page);
1837 sb->data_size = cpu_to_le64(num_sectors);
1838 sb->super_offset = rdev->sb_start;
1839 sb->sb_csum = calc_sb_1_csum(sb);
1840 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1841 rdev->sb_page);
1842 md_super_wait(rdev->mddev);
1843 return num_sectors;
1844
1845 }
1846
1847 static int
1848 super_1_allow_new_offset(struct md_rdev *rdev,
1849 unsigned long long new_offset)
1850 {
1851 /* All necessary checks on new >= old have been done */
1852 struct bitmap *bitmap;
1853 if (new_offset >= rdev->data_offset)
1854 return 1;
1855
1856 /* with 1.0 metadata, there is no metadata to tread on
1857 * so we can always move back */
1858 if (rdev->mddev->minor_version == 0)
1859 return 1;
1860
1861 /* otherwise we must be sure not to step on
1862 * any metadata, so stay:
1863 * 36K beyond start of superblock
1864 * beyond end of badblocks
1865 * beyond write-intent bitmap
1866 */
1867 if (rdev->sb_start + (32+4)*2 > new_offset)
1868 return 0;
1869 bitmap = rdev->mddev->bitmap;
1870 if (bitmap && !rdev->mddev->bitmap_info.file &&
1871 rdev->sb_start + rdev->mddev->bitmap_info.offset +
1872 bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
1873 return 0;
1874 if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
1875 return 0;
1876
1877 return 1;
1878 }
1879
1880 static struct super_type super_types[] = {
1881 [0] = {
1882 .name = "0.90.0",
1883 .owner = THIS_MODULE,
1884 .load_super = super_90_load,
1885 .validate_super = super_90_validate,
1886 .sync_super = super_90_sync,
1887 .rdev_size_change = super_90_rdev_size_change,
1888 .allow_new_offset = super_90_allow_new_offset,
1889 },
1890 [1] = {
1891 .name = "md-1",
1892 .owner = THIS_MODULE,
1893 .load_super = super_1_load,
1894 .validate_super = super_1_validate,
1895 .sync_super = super_1_sync,
1896 .rdev_size_change = super_1_rdev_size_change,
1897 .allow_new_offset = super_1_allow_new_offset,
1898 },
1899 };
1900
1901 static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
1902 {
1903 if (mddev->sync_super) {
1904 mddev->sync_super(mddev, rdev);
1905 return;
1906 }
1907
1908 BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));
1909
1910 super_types[mddev->major_version].sync_super(mddev, rdev);
1911 }
1912
1913 static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
1914 {
1915 struct md_rdev *rdev, *rdev2;
1916
1917 rcu_read_lock();
1918 rdev_for_each_rcu(rdev, mddev1)
1919 rdev_for_each_rcu(rdev2, mddev2)
1920 if (rdev->bdev->bd_contains ==
1921 rdev2->bdev->bd_contains) {
1922 rcu_read_unlock();
1923 return 1;
1924 }
1925 rcu_read_unlock();
1926 return 0;
1927 }
1928
1929 static LIST_HEAD(pending_raid_disks);
1930
1931 /*
1932 * Try to register data integrity profile for an mddev
1933 *
1934 * This is called when an array is started and after a disk has been kicked
1935 * from the array. It only succeeds if all working and active component devices
1936 * are integrity capable with matching profiles.
1937 */
1938 int md_integrity_register(struct mddev *mddev)
1939 {
1940 struct md_rdev *rdev, *reference = NULL;
1941
1942 if (list_empty(&mddev->disks))
1943 return 0; /* nothing to do */
1944 if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
1945 return 0; /* shouldn't register, or already is */
1946 rdev_for_each(rdev, mddev) {
1947 /* skip spares and non-functional disks */
1948 if (test_bit(Faulty, &rdev->flags))
1949 continue;
1950 if (rdev->raid_disk < 0)
1951 continue;
1952 if (!reference) {
1953 /* Use the first rdev as the reference */
1954 reference = rdev;
1955 continue;
1956 }
1957 /* does this rdev's profile match the reference profile? */
1958 if (blk_integrity_compare(reference->bdev->bd_disk,
1959 rdev->bdev->bd_disk) < 0)
1960 return -EINVAL;
1961 }
1962 if (!reference || !bdev_get_integrity(reference->bdev))
1963 return 0;
1964 /*
1965 * All component devices are integrity capable and have matching
1966 * profiles, register the common profile for the md device.
1967 */
1968 if (blk_integrity_register(mddev->gendisk,
1969 bdev_get_integrity(reference->bdev)) != 0) {
1970 printk(KERN_ERR "md: failed to register integrity for %s\n",
1971 mdname(mddev));
1972 return -EINVAL;
1973 }
1974 printk(KERN_NOTICE "md: data integrity enabled on %s\n", mdname(mddev));
1975 if (bioset_integrity_create(mddev->bio_set, BIO_POOL_SIZE)) {
1976 printk(KERN_ERR "md: failed to create integrity pool for %s\n",
1977 mdname(mddev));
1978 return -EINVAL;
1979 }
1980 return 0;
1981 }
1982 EXPORT_SYMBOL(md_integrity_register);
1983
1984 /* Disable data integrity if non-capable/non-matching disk is being added */
1985 void md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
1986 {
1987 struct blk_integrity *bi_rdev;
1988 struct blk_integrity *bi_mddev;
1989
1990 if (!mddev->gendisk)
1991 return;
1992
1993 bi_rdev = bdev_get_integrity(rdev->bdev);
1994 bi_mddev = blk_get_integrity(mddev->gendisk);
1995
1996 if (!bi_mddev) /* nothing to do */
1997 return;
1998 if (rdev->raid_disk < 0) /* skip spares */
1999 return;
2000 if (bi_rdev && blk_integrity_compare(mddev->gendisk,
2001 rdev->bdev->bd_disk) >= 0)
2002 return;
2003 printk(KERN_NOTICE "disabling data integrity on %s\n", mdname(mddev));
2004 blk_integrity_unregister(mddev->gendisk);
2005 }
2006 EXPORT_SYMBOL(md_integrity_add_rdev);
2007
2008 static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev)
2009 {
2010 char b[BDEVNAME_SIZE];
2011 struct kobject *ko;
2012 int err;
2013
2014 /* prevent duplicates */
2015 if (find_rdev(mddev, rdev->bdev->bd_dev))
2016 return -EEXIST;
2017
2018 /* make sure rdev->sectors exceeds mddev->dev_sectors */
2019 if (rdev->sectors && (mddev->dev_sectors == 0 ||
2020 rdev->sectors < mddev->dev_sectors)) {
2021 if (mddev->pers) {
2022 /* Cannot change size, so fail
2023 * If mddev->level <= 0, then we don't care
2024 * about aligning sizes (e.g. linear)
2025 */
2026 if (mddev->level > 0)
2027 return -ENOSPC;
2028 } else
2029 mddev->dev_sectors = rdev->sectors;
2030 }
2031
2032 /* Verify rdev->desc_nr is unique.
2033 * If it is -1, assign a free number, else
2034 * check number is not in use
2035 */
2036 rcu_read_lock();
2037 if (rdev->desc_nr < 0) {
2038 int choice = 0;
2039 if (mddev->pers)
2040 choice = mddev->raid_disks;
2041 while (md_find_rdev_nr_rcu(mddev, choice))
2042 choice++;
2043 rdev->desc_nr = choice;
2044 } else {
2045 if (md_find_rdev_nr_rcu(mddev, rdev->desc_nr)) {
2046 rcu_read_unlock();
2047 return -EBUSY;
2048 }
2049 }
2050 rcu_read_unlock();
2051 if (mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
2052 printk(KERN_WARNING "md: %s: array is limited to %d devices\n",
2053 mdname(mddev), mddev->max_disks);
2054 return -EBUSY;
2055 }
2056 bdevname(rdev->bdev,b);
2057 strreplace(b, '/', '!');
2058
2059 rdev->mddev = mddev;
2060 printk(KERN_INFO "md: bind<%s>\n", b);
2061
2062 if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
2063 goto fail;
2064
2065 ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
2066 if (sysfs_create_link(&rdev->kobj, ko, "block"))
2067 /* failure here is OK */;
2068 rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
2069
2070 list_add_rcu(&rdev->same_set, &mddev->disks);
2071 bd_link_disk_holder(rdev->bdev, mddev->gendisk);
2072
2073 /* May as well allow recovery to be retried once */
2074 mddev->recovery_disabled++;
2075
2076 return 0;
2077
2078 fail:
2079 printk(KERN_WARNING "md: failed to register dev-%s for %s\n",
2080 b, mdname(mddev));
2081 return err;
2082 }
2083
2084 static void md_delayed_delete(struct work_struct *ws)
2085 {
2086 struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
2087 kobject_del(&rdev->kobj);
2088 kobject_put(&rdev->kobj);
2089 }
2090
2091 static void unbind_rdev_from_array(struct md_rdev *rdev)
2092 {
2093 char b[BDEVNAME_SIZE];
2094
2095 bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
2096 list_del_rcu(&rdev->same_set);
2097 printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
2098 rdev->mddev = NULL;
2099 sysfs_remove_link(&rdev->kobj, "block");
2100 sysfs_put(rdev->sysfs_state);
2101 rdev->sysfs_state = NULL;
2102 rdev->badblocks.count = 0;
2103 /* We need to delay this, otherwise we can deadlock when
2104 * writing to 'remove' to "dev/state". We also need
2105 * to delay it due to rcu usage.
2106 */
2107 synchronize_rcu();
2108 INIT_WORK(&rdev->del_work, md_delayed_delete);
2109 kobject_get(&rdev->kobj);
2110 queue_work(md_misc_wq, &rdev->del_work);
2111 }
2112
2113 /*
2114 * prevent the device from being mounted, repartitioned or
2115 * otherwise reused by a RAID array (or any other kernel
2116 * subsystem), by bd_claiming the device.
2117 */
2118 static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared)
2119 {
2120 int err = 0;
2121 struct block_device *bdev;
2122 char b[BDEVNAME_SIZE];
2123
2124 bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
2125 shared ? (struct md_rdev *)lock_rdev : rdev);
2126 if (IS_ERR(bdev)) {
2127 printk(KERN_ERR "md: could not open %s.\n",
2128 __bdevname(dev, b));
2129 return PTR_ERR(bdev);
2130 }
2131 rdev->bdev = bdev;
2132 return err;
2133 }
2134
2135 static void unlock_rdev(struct md_rdev *rdev)
2136 {
2137 struct block_device *bdev = rdev->bdev;
2138 rdev->bdev = NULL;
2139 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
2140 }
2141
2142 void md_autodetect_dev(dev_t dev);
2143
2144 static void export_rdev(struct md_rdev *rdev)
2145 {
2146 char b[BDEVNAME_SIZE];
2147
2148 printk(KERN_INFO "md: export_rdev(%s)\n",
2149 bdevname(rdev->bdev,b));
2150 md_rdev_clear(rdev);
2151 #ifndef MODULE
2152 if (test_bit(AutoDetected, &rdev->flags))
2153 md_autodetect_dev(rdev->bdev->bd_dev);
2154 #endif
2155 unlock_rdev(rdev);
2156 kobject_put(&rdev->kobj);
2157 }
2158
2159 void md_kick_rdev_from_array(struct md_rdev *rdev)
2160 {
2161 unbind_rdev_from_array(rdev);
2162 export_rdev(rdev);
2163 }
2164 EXPORT_SYMBOL_GPL(md_kick_rdev_from_array);
2165
2166 static void export_array(struct mddev *mddev)
2167 {
2168 struct md_rdev *rdev;
2169
2170 while (!list_empty(&mddev->disks)) {
2171 rdev = list_first_entry(&mddev->disks, struct md_rdev,
2172 same_set);
2173 md_kick_rdev_from_array(rdev);
2174 }
2175 mddev->raid_disks = 0;
2176 mddev->major_version = 0;
2177 }
2178
2179 static void sync_sbs(struct mddev *mddev, int nospares)
2180 {
2181 /* Update each superblock (in-memory image), but
2182 * if we are allowed to, skip spares which already
2183 * have the right event counter, or have one earlier
2184 * (which would mean they aren't being marked as dirty
2185 * with the rest of the array)
2186 */
2187 struct md_rdev *rdev;
2188 rdev_for_each(rdev, mddev) {
2189 if (rdev->sb_events == mddev->events ||
2190 (nospares &&
2191 rdev->raid_disk < 0 &&
2192 rdev->sb_events+1 == mddev->events)) {
2193 /* Don't update this superblock */
2194 rdev->sb_loaded = 2;
2195 } else {
2196 sync_super(mddev, rdev);
2197 rdev->sb_loaded = 1;
2198 }
2199 }
2200 }
2201
2202 static bool does_sb_need_changing(struct mddev *mddev)
2203 {
2204 struct md_rdev *rdev;
2205 struct mdp_superblock_1 *sb;
2206 int role;
2207
2208 /* Find a good rdev */
2209 rdev_for_each(rdev, mddev)
2210 if ((rdev->raid_disk >= 0) && !test_bit(Faulty, &rdev->flags))
2211 break;
2212
2213 /* No good device found. */
2214 if (!rdev)
2215 return false;
2216
2217 sb = page_address(rdev->sb_page);
2218 /* Check if a device has become faulty or a spare become active */
2219 rdev_for_each(rdev, mddev) {
2220 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
2221 /* Device activated? */
2222 if (role == 0xffff && rdev->raid_disk >=0 &&
2223 !test_bit(Faulty, &rdev->flags))
2224 return true;
2225 /* Device turned faulty? */
2226 if (test_bit(Faulty, &rdev->flags) && (role < 0xfffd))
2227 return true;
2228 }
2229
2230 /* Check if any mddev parameters have changed */
2231 if ((mddev->dev_sectors != le64_to_cpu(sb->size)) ||
2232 (mddev->reshape_position != le64_to_cpu(sb->reshape_position)) ||
2233 (mddev->recovery_cp != le64_to_cpu(sb->resync_offset)) ||
2234 (mddev->layout != le64_to_cpu(sb->layout)) ||
2235 (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) ||
2236 (mddev->chunk_sectors != le32_to_cpu(sb->chunksize)))
2237 return true;
2238
2239 return false;
2240 }
2241
2242 void md_update_sb(struct mddev *mddev, int force_change)
2243 {
2244 struct md_rdev *rdev;
2245 int sync_req;
2246 int nospares = 0;
2247 int any_badblocks_changed = 0;
2248
2249 if (mddev->ro) {
2250 if (force_change)
2251 set_bit(MD_CHANGE_DEVS, &mddev->flags);
2252 return;
2253 }
2254
2255 if (mddev_is_clustered(mddev)) {
2256 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
2257 force_change = 1;
2258 md_cluster_ops->metadata_update_start(mddev);
2259 /* Has someone else has updated the sb */
2260 if (!does_sb_need_changing(mddev)) {
2261 md_cluster_ops->metadata_update_cancel(mddev);
2262 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2263 return;
2264 }
2265 }
2266 repeat:
2267 /* First make sure individual recovery_offsets are correct */
2268 rdev_for_each(rdev, mddev) {
2269 if (rdev->raid_disk >= 0 &&
2270 mddev->delta_disks >= 0 &&
2271 !test_bit(In_sync, &rdev->flags) &&
2272 mddev->curr_resync_completed > rdev->recovery_offset)
2273 rdev->recovery_offset = mddev->curr_resync_completed;
2274
2275 }
2276 if (!mddev->persistent) {
2277 clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2278 clear_bit(MD_CHANGE_DEVS, &mddev->flags);
2279 if (!mddev->external) {
2280 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2281 rdev_for_each(rdev, mddev) {
2282 if (rdev->badblocks.changed) {
2283 rdev->badblocks.changed = 0;
2284 md_ack_all_badblocks(&rdev->badblocks);
2285 md_error(mddev, rdev);
2286 }
2287 clear_bit(Blocked, &rdev->flags);
2288 clear_bit(BlockedBadBlocks, &rdev->flags);
2289 wake_up(&rdev->blocked_wait);
2290 }
2291 }
2292 wake_up(&mddev->sb_wait);
2293 return;
2294 }
2295
2296 spin_lock(&mddev->lock);
2297
2298 mddev->utime = get_seconds();
2299
2300 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
2301 force_change = 1;
2302 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
2303 /* just a clean<-> dirty transition, possibly leave spares alone,
2304 * though if events isn't the right even/odd, we will have to do
2305 * spares after all
2306 */
2307 nospares = 1;
2308 if (force_change)
2309 nospares = 0;
2310 if (mddev->degraded)
2311 /* If the array is degraded, then skipping spares is both
2312 * dangerous and fairly pointless.
2313 * Dangerous because a device that was removed from the array
2314 * might have a event_count that still looks up-to-date,
2315 * so it can be re-added without a resync.
2316 * Pointless because if there are any spares to skip,
2317 * then a recovery will happen and soon that array won't
2318 * be degraded any more and the spare can go back to sleep then.
2319 */
2320 nospares = 0;
2321
2322 sync_req = mddev->in_sync;
2323
2324 /* If this is just a dirty<->clean transition, and the array is clean
2325 * and 'events' is odd, we can roll back to the previous clean state */
2326 if (nospares
2327 && (mddev->in_sync && mddev->recovery_cp == MaxSector)
2328 && mddev->can_decrease_events
2329 && mddev->events != 1) {
2330 mddev->events--;
2331 mddev->can_decrease_events = 0;
2332 } else {
2333 /* otherwise we have to go forward and ... */
2334 mddev->events ++;
2335 mddev->can_decrease_events = nospares;
2336 }
2337
2338 /*
2339 * This 64-bit counter should never wrap.
2340 * Either we are in around ~1 trillion A.C., assuming
2341 * 1 reboot per second, or we have a bug...
2342 */
2343 WARN_ON(mddev->events == 0);
2344
2345 rdev_for_each(rdev, mddev) {
2346 if (rdev->badblocks.changed)
2347 any_badblocks_changed++;
2348 if (test_bit(Faulty, &rdev->flags))
2349 set_bit(FaultRecorded, &rdev->flags);
2350 }
2351
2352 sync_sbs(mddev, nospares);
2353 spin_unlock(&mddev->lock);
2354
2355 pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
2356 mdname(mddev), mddev->in_sync);
2357
2358 bitmap_update_sb(mddev->bitmap);
2359 rdev_for_each(rdev, mddev) {
2360 char b[BDEVNAME_SIZE];
2361
2362 if (rdev->sb_loaded != 1)
2363 continue; /* no noise on spare devices */
2364
2365 if (!test_bit(Faulty, &rdev->flags)) {
2366 md_super_write(mddev,rdev,
2367 rdev->sb_start, rdev->sb_size,
2368 rdev->sb_page);
2369 pr_debug("md: (write) %s's sb offset: %llu\n",
2370 bdevname(rdev->bdev, b),
2371 (unsigned long long)rdev->sb_start);
2372 rdev->sb_events = mddev->events;
2373 if (rdev->badblocks.size) {
2374 md_super_write(mddev, rdev,
2375 rdev->badblocks.sector,
2376 rdev->badblocks.size << 9,
2377 rdev->bb_page);
2378 rdev->badblocks.size = 0;
2379 }
2380
2381 } else
2382 pr_debug("md: %s (skipping faulty)\n",
2383 bdevname(rdev->bdev, b));
2384
2385 if (mddev->level == LEVEL_MULTIPATH)
2386 /* only need to write one superblock... */
2387 break;
2388 }
2389 md_super_wait(mddev);
2390 /* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
2391
2392 spin_lock(&mddev->lock);
2393 if (mddev->in_sync != sync_req ||
2394 test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
2395 /* have to write it out again */
2396 spin_unlock(&mddev->lock);
2397 goto repeat;
2398 }
2399 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2400 spin_unlock(&mddev->lock);
2401 wake_up(&mddev->sb_wait);
2402 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2403 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
2404
2405 rdev_for_each(rdev, mddev) {
2406 if (test_and_clear_bit(FaultRecorded, &rdev->flags))
2407 clear_bit(Blocked, &rdev->flags);
2408
2409 if (any_badblocks_changed)
2410 md_ack_all_badblocks(&rdev->badblocks);
2411 clear_bit(BlockedBadBlocks, &rdev->flags);
2412 wake_up(&rdev->blocked_wait);
2413 }
2414
2415 if (mddev_is_clustered(mddev))
2416 md_cluster_ops->metadata_update_finish(mddev);
2417 }
2418 EXPORT_SYMBOL(md_update_sb);
2419
2420 static int add_bound_rdev(struct md_rdev *rdev)
2421 {
2422 struct mddev *mddev = rdev->mddev;
2423 int err = 0;
2424
2425 if (!mddev->pers->hot_remove_disk) {
2426 /* If there is hot_add_disk but no hot_remove_disk
2427 * then added disks for geometry changes,
2428 * and should be added immediately.
2429 */
2430 super_types[mddev->major_version].
2431 validate_super(mddev, rdev);
2432 err = mddev->pers->hot_add_disk(mddev, rdev);
2433 if (err) {
2434 unbind_rdev_from_array(rdev);
2435 export_rdev(rdev);
2436 return err;
2437 }
2438 }
2439 sysfs_notify_dirent_safe(rdev->sysfs_state);
2440
2441 set_bit(MD_CHANGE_DEVS, &mddev->flags);
2442 if (mddev->degraded)
2443 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
2444 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2445 md_new_event(mddev);
2446 md_wakeup_thread(mddev->thread);
2447 return 0;
2448 }
2449
2450 /* words written to sysfs files may, or may not, be \n terminated.
2451 * We want to accept with case. For this we use cmd_match.
2452 */
2453 static int cmd_match(const char *cmd, const char *str)
2454 {
2455 /* See if cmd, written into a sysfs file, matches
2456 * str. They must either be the same, or cmd can
2457 * have a trailing newline
2458 */
2459 while (*cmd && *str && *cmd == *str) {
2460 cmd++;
2461 str++;
2462 }
2463 if (*cmd == '\n')
2464 cmd++;
2465 if (*str || *cmd)
2466 return 0;
2467 return 1;
2468 }
2469
2470 struct rdev_sysfs_entry {
2471 struct attribute attr;
2472 ssize_t (*show)(struct md_rdev *, char *);
2473 ssize_t (*store)(struct md_rdev *, const char *, size_t);
2474 };
2475
2476 static ssize_t
2477 state_show(struct md_rdev *rdev, char *page)
2478 {
2479 char *sep = "";
2480 size_t len = 0;
2481 unsigned long flags = ACCESS_ONCE(rdev->flags);
2482
2483 if (test_bit(Faulty, &flags) ||
2484 rdev->badblocks.unacked_exist) {
2485 len+= sprintf(page+len, "%sfaulty",sep);
2486 sep = ",";
2487 }
2488 if (test_bit(In_sync, &flags)) {
2489 len += sprintf(page+len, "%sin_sync",sep);
2490 sep = ",";
2491 }
2492 if (test_bit(WriteMostly, &flags)) {
2493 len += sprintf(page+len, "%swrite_mostly",sep);
2494 sep = ",";
2495 }
2496 if (test_bit(Blocked, &flags) ||
2497 (rdev->badblocks.unacked_exist
2498 && !test_bit(Faulty, &flags))) {
2499 len += sprintf(page+len, "%sblocked", sep);
2500 sep = ",";
2501 }
2502 if (!test_bit(Faulty, &flags) &&
2503 !test_bit(In_sync, &flags)) {
2504 len += sprintf(page+len, "%sspare", sep);
2505 sep = ",";
2506 }
2507 if (test_bit(WriteErrorSeen, &flags)) {
2508 len += sprintf(page+len, "%swrite_error", sep);
2509 sep = ",";
2510 }
2511 if (test_bit(WantReplacement, &flags)) {
2512 len += sprintf(page+len, "%swant_replacement", sep);
2513 sep = ",";
2514 }
2515 if (test_bit(Replacement, &flags)) {
2516 len += sprintf(page+len, "%sreplacement", sep);
2517 sep = ",";
2518 }
2519
2520 return len+sprintf(page+len, "\n");
2521 }
2522
2523 static ssize_t
2524 state_store(struct md_rdev *rdev, const char *buf, size_t len)
2525 {
2526 /* can write
2527 * faulty - simulates an error
2528 * remove - disconnects the device
2529 * writemostly - sets write_mostly
2530 * -writemostly - clears write_mostly
2531 * blocked - sets the Blocked flags
2532 * -blocked - clears the Blocked and possibly simulates an error
2533 * insync - sets Insync providing device isn't active
2534 * -insync - clear Insync for a device with a slot assigned,
2535 * so that it gets rebuilt based on bitmap
2536 * write_error - sets WriteErrorSeen
2537 * -write_error - clears WriteErrorSeen
2538 */
2539 int err = -EINVAL;
2540 if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2541 md_error(rdev->mddev, rdev);
2542 if (test_bit(Faulty, &rdev->flags))
2543 err = 0;
2544 else
2545 err = -EBUSY;
2546 } else if (cmd_match(buf, "remove")) {
2547 if (rdev->raid_disk >= 0)
2548 err = -EBUSY;
2549 else {
2550 struct mddev *mddev = rdev->mddev;
2551 err = 0;
2552 if (mddev_is_clustered(mddev))
2553 err = md_cluster_ops->remove_disk(mddev, rdev);
2554
2555 if (err == 0) {
2556 md_kick_rdev_from_array(rdev);
2557 if (mddev->pers)
2558 md_update_sb(mddev, 1);
2559 md_new_event(mddev);
2560 }
2561 }
2562 } else if (cmd_match(buf, "writemostly")) {
2563 set_bit(WriteMostly, &rdev->flags);
2564 err = 0;
2565 } else if (cmd_match(buf, "-writemostly")) {
2566 clear_bit(WriteMostly, &rdev->flags);
2567 err = 0;
2568 } else if (cmd_match(buf, "blocked")) {
2569 set_bit(Blocked, &rdev->flags);
2570 err = 0;
2571 } else if (cmd_match(buf, "-blocked")) {
2572 if (!test_bit(Faulty, &rdev->flags) &&
2573 rdev->badblocks.unacked_exist) {
2574 /* metadata handler doesn't understand badblocks,
2575 * so we need to fail the device
2576 */
2577 md_error(rdev->mddev, rdev);
2578 }
2579 clear_bit(Blocked, &rdev->flags);
2580 clear_bit(BlockedBadBlocks, &rdev->flags);
2581 wake_up(&rdev->blocked_wait);
2582 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2583 md_wakeup_thread(rdev->mddev->thread);
2584
2585 err = 0;
2586 } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
2587 set_bit(In_sync, &rdev->flags);
2588 err = 0;
2589 } else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0) {
2590 if (rdev->mddev->pers == NULL) {
2591 clear_bit(In_sync, &rdev->flags);
2592 rdev->saved_raid_disk = rdev->raid_disk;
2593 rdev->raid_disk = -1;
2594 err = 0;
2595 }
2596 } else if (cmd_match(buf, "write_error")) {
2597 set_bit(WriteErrorSeen, &rdev->flags);
2598 err = 0;
2599 } else if (cmd_match(buf, "-write_error")) {
2600 clear_bit(WriteErrorSeen, &rdev->flags);
2601 err = 0;
2602 } else if (cmd_match(buf, "want_replacement")) {
2603 /* Any non-spare device that is not a replacement can
2604 * become want_replacement at any time, but we then need to
2605 * check if recovery is needed.
2606 */
2607 if (rdev->raid_disk >= 0 &&
2608 !test_bit(Replacement, &rdev->flags))
2609 set_bit(WantReplacement, &rdev->flags);
2610 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2611 md_wakeup_thread(rdev->mddev->thread);
2612 err = 0;
2613 } else if (cmd_match(buf, "-want_replacement")) {
2614 /* Clearing 'want_replacement' is always allowed.
2615 * Once replacements starts it is too late though.
2616 */
2617 err = 0;
2618 clear_bit(WantReplacement, &rdev->flags);
2619 } else if (cmd_match(buf, "replacement")) {
2620 /* Can only set a device as a replacement when array has not
2621 * yet been started. Once running, replacement is automatic
2622 * from spares, or by assigning 'slot'.
2623 */
2624 if (rdev->mddev->pers)
2625 err = -EBUSY;
2626 else {
2627 set_bit(Replacement, &rdev->flags);
2628 err = 0;
2629 }
2630 } else if (cmd_match(buf, "-replacement")) {
2631 /* Similarly, can only clear Replacement before start */
2632 if (rdev->mddev->pers)
2633 err = -EBUSY;
2634 else {
2635 clear_bit(Replacement, &rdev->flags);
2636 err = 0;
2637 }
2638 } else if (cmd_match(buf, "re-add")) {
2639 if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1)) {
2640 /* clear_bit is performed _after_ all the devices
2641 * have their local Faulty bit cleared. If any writes
2642 * happen in the meantime in the local node, they
2643 * will land in the local bitmap, which will be synced
2644 * by this node eventually
2645 */
2646 if (!mddev_is_clustered(rdev->mddev) ||
2647 (err = md_cluster_ops->gather_bitmaps(rdev)) == 0) {
2648 clear_bit(Faulty, &rdev->flags);
2649 err = add_bound_rdev(rdev);
2650 }
2651 } else
2652 err = -EBUSY;
2653 }
2654 if (!err)
2655 sysfs_notify_dirent_safe(rdev->sysfs_state);
2656 return err ? err : len;
2657 }
2658 static struct rdev_sysfs_entry rdev_state =
2659 __ATTR_PREALLOC(state, S_IRUGO|S_IWUSR, state_show, state_store);
2660
2661 static ssize_t
2662 errors_show(struct md_rdev *rdev, char *page)
2663 {
2664 return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
2665 }
2666
2667 static ssize_t
2668 errors_store(struct md_rdev *rdev, const char *buf, size_t len)
2669 {
2670 unsigned int n;
2671 int rv;
2672
2673 rv = kstrtouint(buf, 10, &n);
2674 if (rv < 0)
2675 return rv;
2676 atomic_set(&rdev->corrected_errors, n);
2677 return len;
2678 }
2679 static struct rdev_sysfs_entry rdev_errors =
2680 __ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
2681
2682 static ssize_t
2683 slot_show(struct md_rdev *rdev, char *page)
2684 {
2685 if (rdev->raid_disk < 0)
2686 return sprintf(page, "none\n");
2687 else
2688 return sprintf(page, "%d\n", rdev->raid_disk);
2689 }
2690
2691 static ssize_t
2692 slot_store(struct md_rdev *rdev, const char *buf, size_t len)
2693 {
2694 int slot;
2695 int err;
2696
2697 if (strncmp(buf, "none", 4)==0)
2698 slot = -1;
2699 else {
2700 err = kstrtouint(buf, 10, (unsigned int *)&slot);
2701 if (err < 0)
2702 return err;
2703 }
2704 if (rdev->mddev->pers && slot == -1) {
2705 /* Setting 'slot' on an active array requires also
2706 * updating the 'rd%d' link, and communicating
2707 * with the personality with ->hot_*_disk.
2708 * For now we only support removing
2709 * failed/spare devices. This normally happens automatically,
2710 * but not when the metadata is externally managed.
2711 */
2712 if (rdev->raid_disk == -1)
2713 return -EEXIST;
2714 /* personality does all needed checks */
2715 if (rdev->mddev->pers->hot_remove_disk == NULL)
2716 return -EINVAL;
2717 clear_bit(Blocked, &rdev->flags);
2718 remove_and_add_spares(rdev->mddev, rdev);
2719 if (rdev->raid_disk >= 0)
2720 return -EBUSY;
2721 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2722 md_wakeup_thread(rdev->mddev->thread);
2723 } else if (rdev->mddev->pers) {
2724 /* Activating a spare .. or possibly reactivating
2725 * if we ever get bitmaps working here.
2726 */
2727
2728 if (rdev->raid_disk != -1)
2729 return -EBUSY;
2730
2731 if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
2732 return -EBUSY;
2733
2734 if (rdev->mddev->pers->hot_add_disk == NULL)
2735 return -EINVAL;
2736
2737 if (slot >= rdev->mddev->raid_disks &&
2738 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
2739 return -ENOSPC;
2740
2741 rdev->raid_disk = slot;
2742 if (test_bit(In_sync, &rdev->flags))
2743 rdev->saved_raid_disk = slot;
2744 else
2745 rdev->saved_raid_disk = -1;
2746 clear_bit(In_sync, &rdev->flags);
2747 clear_bit(Bitmap_sync, &rdev->flags);
2748 remove_and_add_spares(rdev->mddev, rdev);
2749 if (rdev->raid_disk == -1)
2750 return -EBUSY;
2751 /* don't wakeup anyone, leave that to userspace. */
2752 } else {
2753 if (slot >= rdev->mddev->raid_disks &&
2754 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
2755 return -ENOSPC;
2756 rdev->raid_disk = slot;
2757 /* assume it is working */
2758 clear_bit(Faulty, &rdev->flags);
2759 clear_bit(WriteMostly, &rdev->flags);
2760 set_bit(In_sync, &rdev->flags);
2761 sysfs_notify_dirent_safe(rdev->sysfs_state);
2762 }
2763 return len;
2764 }
2765
2766 static struct rdev_sysfs_entry rdev_slot =
2767 __ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
2768
2769 static ssize_t
2770 offset_show(struct md_rdev *rdev, char *page)
2771 {
2772 return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
2773 }
2774
2775 static ssize_t
2776 offset_store(struct md_rdev *rdev, const char *buf, size_t len)
2777 {
2778 unsigned long long offset;
2779 if (kstrtoull(buf, 10, &offset) < 0)
2780 return -EINVAL;
2781 if (rdev->mddev->pers && rdev->raid_disk >= 0)
2782 return -EBUSY;
2783 if (rdev->sectors && rdev->mddev->external)
2784 /* Must set offset before size, so overlap checks
2785 * can be sane */
2786 return -EBUSY;
2787 rdev->data_offset = offset;
2788 rdev->new_data_offset = offset;
2789 return len;
2790 }
2791
2792 static struct rdev_sysfs_entry rdev_offset =
2793 __ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
2794
2795 static ssize_t new_offset_show(struct md_rdev *rdev, char *page)
2796 {
2797 return sprintf(page, "%llu\n",
2798 (unsigned long long)rdev->new_data_offset);
2799 }
2800
2801 static ssize_t new_offset_store(struct md_rdev *rdev,
2802 const char *buf, size_t len)
2803 {
2804 unsigned long long new_offset;
2805 struct mddev *mddev = rdev->mddev;
2806
2807 if (kstrtoull(buf, 10, &new_offset) < 0)
2808 return -EINVAL;
2809
2810 if (mddev->sync_thread ||
2811 test_bit(MD_RECOVERY_RUNNING,&mddev->recovery))
2812 return -EBUSY;
2813 if (new_offset == rdev->data_offset)
2814 /* reset is always permitted */
2815 ;
2816 else if (new_offset > rdev->data_offset) {
2817 /* must not push array size beyond rdev_sectors */
2818 if (new_offset - rdev->data_offset
2819 + mddev->dev_sectors > rdev->sectors)
2820 return -E2BIG;
2821 }
2822 /* Metadata worries about other space details. */
2823
2824 /* decreasing the offset is inconsistent with a backwards
2825 * reshape.
2826 */
2827 if (new_offset < rdev->data_offset &&
2828 mddev->reshape_backwards)
2829 return -EINVAL;
2830 /* Increasing offset is inconsistent with forwards
2831 * reshape. reshape_direction should be set to
2832 * 'backwards' first.
2833 */
2834 if (new_offset > rdev->data_offset &&
2835 !mddev->reshape_backwards)
2836 return -EINVAL;
2837
2838 if (mddev->pers && mddev->persistent &&
2839 !super_types[mddev->major_version]
2840 .allow_new_offset(rdev, new_offset))
2841 return -E2BIG;
2842 rdev->new_data_offset = new_offset;
2843 if (new_offset > rdev->data_offset)
2844 mddev->reshape_backwards = 1;
2845 else if (new_offset < rdev->data_offset)
2846 mddev->reshape_backwards = 0;
2847
2848 return len;
2849 }
2850 static struct rdev_sysfs_entry rdev_new_offset =
2851 __ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store);
2852
2853 static ssize_t
2854 rdev_size_show(struct md_rdev *rdev, char *page)
2855 {
2856 return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
2857 }
2858
2859 static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
2860 {
2861 /* check if two start/length pairs overlap */
2862 if (s1+l1 <= s2)
2863 return 0;
2864 if (s2+l2 <= s1)
2865 return 0;
2866 return 1;
2867 }
2868
2869 static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
2870 {
2871 unsigned long long blocks;
2872 sector_t new;
2873
2874 if (kstrtoull(buf, 10, &blocks) < 0)
2875 return -EINVAL;
2876
2877 if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
2878 return -EINVAL; /* sector conversion overflow */
2879
2880 new = blocks * 2;
2881 if (new != blocks * 2)
2882 return -EINVAL; /* unsigned long long to sector_t overflow */
2883
2884 *sectors = new;
2885 return 0;
2886 }
2887
2888 static ssize_t
2889 rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
2890 {
2891 struct mddev *my_mddev = rdev->mddev;
2892 sector_t oldsectors = rdev->sectors;
2893 sector_t sectors;
2894
2895 if (strict_blocks_to_sectors(buf, &sectors) < 0)
2896 return -EINVAL;
2897 if (rdev->data_offset != rdev->new_data_offset)
2898 return -EINVAL; /* too confusing */
2899 if (my_mddev->pers && rdev->raid_disk >= 0) {
2900 if (my_mddev->persistent) {
2901 sectors = super_types[my_mddev->major_version].
2902 rdev_size_change(rdev, sectors);
2903 if (!sectors)
2904 return -EBUSY;
2905 } else if (!sectors)
2906 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
2907 rdev->data_offset;
2908 if (!my_mddev->pers->resize)
2909 /* Cannot change size for RAID0 or Linear etc */
2910 return -EINVAL;
2911 }
2912 if (sectors < my_mddev->dev_sectors)
2913 return -EINVAL; /* component must fit device */
2914
2915 rdev->sectors = sectors;
2916 if (sectors > oldsectors && my_mddev->external) {
2917 /* Need to check that all other rdevs with the same
2918 * ->bdev do not overlap. 'rcu' is sufficient to walk
2919 * the rdev lists safely.
2920 * This check does not provide a hard guarantee, it
2921 * just helps avoid dangerous mistakes.
2922 */
2923 struct mddev *mddev;
2924 int overlap = 0;
2925 struct list_head *tmp;
2926
2927 rcu_read_lock();
2928 for_each_mddev(mddev, tmp) {
2929 struct md_rdev *rdev2;
2930
2931 rdev_for_each(rdev2, mddev)
2932 if (rdev->bdev == rdev2->bdev &&
2933 rdev != rdev2 &&
2934 overlaps(rdev->data_offset, rdev->sectors,
2935 rdev2->data_offset,
2936 rdev2->sectors)) {
2937 overlap = 1;
2938 break;
2939 }
2940 if (overlap) {
2941 mddev_put(mddev);
2942 break;
2943 }
2944 }
2945 rcu_read_unlock();
2946 if (overlap) {
2947 /* Someone else could have slipped in a size
2948 * change here, but doing so is just silly.
2949 * We put oldsectors back because we *know* it is
2950 * safe, and trust userspace not to race with
2951 * itself
2952 */
2953 rdev->sectors = oldsectors;
2954 return -EBUSY;
2955 }
2956 }
2957 return len;
2958 }
2959
2960 static struct rdev_sysfs_entry rdev_size =
2961 __ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
2962
2963 static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
2964 {
2965 unsigned long long recovery_start = rdev->recovery_offset;
2966
2967 if (test_bit(In_sync, &rdev->flags) ||
2968 recovery_start == MaxSector)
2969 return sprintf(page, "none\n");
2970
2971 return sprintf(page, "%llu\n", recovery_start);
2972 }
2973
2974 static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
2975 {
2976 unsigned long long recovery_start;
2977
2978 if (cmd_match(buf, "none"))
2979 recovery_start = MaxSector;
2980 else if (kstrtoull(buf, 10, &recovery_start))
2981 return -EINVAL;
2982
2983 if (rdev->mddev->pers &&
2984 rdev->raid_disk >= 0)
2985 return -EBUSY;
2986
2987 rdev->recovery_offset = recovery_start;
2988 if (recovery_start == MaxSector)
2989 set_bit(In_sync, &rdev->flags);
2990 else
2991 clear_bit(In_sync, &rdev->flags);
2992 return len;
2993 }
2994
2995 static struct rdev_sysfs_entry rdev_recovery_start =
2996 __ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);
2997
2998 static ssize_t
2999 badblocks_show(struct badblocks *bb, char *page, int unack);
3000 static ssize_t
3001 badblocks_store(struct badblocks *bb, const char *page, size_t len, int unack);
3002
3003 static ssize_t bb_show(struct md_rdev *rdev, char *page)
3004 {
3005 return badblocks_show(&rdev->badblocks, page, 0);
3006 }
3007 static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
3008 {
3009 int rv = badblocks_store(&rdev->badblocks, page, len, 0);
3010 /* Maybe that ack was all we needed */
3011 if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags))
3012 wake_up(&rdev->blocked_wait);
3013 return rv;
3014 }
3015 static struct rdev_sysfs_entry rdev_bad_blocks =
3016 __ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);
3017
3018 static ssize_t ubb_show(struct md_rdev *rdev, char *page)
3019 {
3020 return badblocks_show(&rdev->badblocks, page, 1);
3021 }
3022 static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
3023 {
3024 return badblocks_store(&rdev->badblocks, page, len, 1);
3025 }
3026 static struct rdev_sysfs_entry rdev_unack_bad_blocks =
3027 __ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store);
3028
3029 static struct attribute *rdev_default_attrs[] = {
3030 &rdev_state.attr,
3031 &rdev_errors.attr,
3032 &rdev_slot.attr,
3033 &rdev_offset.attr,
3034 &rdev_new_offset.attr,
3035 &rdev_size.attr,
3036 &rdev_recovery_start.attr,
3037 &rdev_bad_blocks.attr,
3038 &rdev_unack_bad_blocks.attr,
3039 NULL,
3040 };
3041 static ssize_t
3042 rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
3043 {
3044 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
3045 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
3046
3047 if (!entry->show)
3048 return -EIO;
3049 if (!rdev->mddev)
3050 return -EBUSY;
3051 return entry->show(rdev, page);
3052 }
3053
3054 static ssize_t
3055 rdev_attr_store(struct kobject *kobj, struct attribute *attr,
3056 const char *page, size_t length)
3057 {
3058 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
3059 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
3060 ssize_t rv;
3061 struct mddev *mddev = rdev->mddev;
3062
3063 if (!entry->store)
3064 return -EIO;
3065 if (!capable(CAP_SYS_ADMIN))
3066 return -EACCES;
3067 rv = mddev ? mddev_lock(mddev): -EBUSY;
3068 if (!rv) {
3069 if (rdev->mddev == NULL)
3070 rv = -EBUSY;
3071 else
3072 rv = entry->store(rdev, page, length);
3073 mddev_unlock(mddev);
3074 }
3075 return rv;
3076 }
3077
3078 static void rdev_free(struct kobject *ko)
3079 {
3080 struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
3081 kfree(rdev);
3082 }
3083 static const struct sysfs_ops rdev_sysfs_ops = {
3084 .show = rdev_attr_show,
3085 .store = rdev_attr_store,
3086 };
3087 static struct kobj_type rdev_ktype = {
3088 .release = rdev_free,
3089 .sysfs_ops = &rdev_sysfs_ops,
3090 .default_attrs = rdev_default_attrs,
3091 };
3092
3093 int md_rdev_init(struct md_rdev *rdev)
3094 {
3095 rdev->desc_nr = -1;
3096 rdev->saved_raid_disk = -1;
3097 rdev->raid_disk = -1;
3098 rdev->flags = 0;
3099 rdev->data_offset = 0;
3100 rdev->new_data_offset = 0;
3101 rdev->sb_events = 0;
3102 rdev->last_read_error.tv_sec = 0;
3103 rdev->last_read_error.tv_nsec = 0;
3104 rdev->sb_loaded = 0;
3105 rdev->bb_page = NULL;
3106 atomic_set(&rdev->nr_pending, 0);
3107 atomic_set(&rdev->read_errors, 0);
3108 atomic_set(&rdev->corrected_errors, 0);
3109
3110 INIT_LIST_HEAD(&rdev->same_set);
3111 init_waitqueue_head(&rdev->blocked_wait);
3112
3113 /* Add space to store bad block list.
3114 * This reserves the space even on arrays where it cannot
3115 * be used - I wonder if that matters
3116 */
3117 rdev->badblocks.count = 0;
3118 rdev->badblocks.shift = -1; /* disabled until explicitly enabled */
3119 rdev->badblocks.page = kmalloc(PAGE_SIZE, GFP_KERNEL);
3120 seqlock_init(&rdev->badblocks.lock);
3121 if (rdev->badblocks.page == NULL)
3122 return -ENOMEM;
3123
3124 return 0;
3125 }
3126 EXPORT_SYMBOL_GPL(md_rdev_init);
3127 /*
3128 * Import a device. If 'super_format' >= 0, then sanity check the superblock
3129 *
3130 * mark the device faulty if:
3131 *
3132 * - the device is nonexistent (zero size)
3133 * - the device has no valid superblock
3134 *
3135 * a faulty rdev _never_ has rdev->sb set.
3136 */
3137 static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
3138 {
3139 char b[BDEVNAME_SIZE];
3140 int err;
3141 struct md_rdev *rdev;
3142 sector_t size;
3143
3144 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
3145 if (!rdev) {
3146 printk(KERN_ERR "md: could not alloc mem for new device!\n");
3147 return ERR_PTR(-ENOMEM);
3148 }
3149
3150 err = md_rdev_init(rdev);
3151 if (err)
3152 goto abort_free;
3153 err = alloc_disk_sb(rdev);
3154 if (err)
3155 goto abort_free;
3156
3157 err = lock_rdev(rdev, newdev, super_format == -2);
3158 if (err)
3159 goto abort_free;
3160
3161 kobject_init(&rdev->kobj, &rdev_ktype);
3162
3163 size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
3164 if (!size) {
3165 printk(KERN_WARNING
3166 "md: %s has zero or unknown size, marking faulty!\n",
3167 bdevname(rdev->bdev,b));
3168 err = -EINVAL;
3169 goto abort_free;
3170 }
3171
3172 if (super_format >= 0) {
3173 err = super_types[super_format].
3174 load_super(rdev, NULL, super_minor);
3175 if (err == -EINVAL) {
3176 printk(KERN_WARNING
3177 "md: %s does not have a valid v%d.%d "
3178 "superblock, not importing!\n",
3179 bdevname(rdev->bdev,b),
3180 super_format, super_minor);
3181 goto abort_free;
3182 }
3183 if (err < 0) {
3184 printk(KERN_WARNING
3185 "md: could not read %s's sb, not importing!\n",
3186 bdevname(rdev->bdev,b));
3187 goto abort_free;
3188 }
3189 }
3190
3191 return rdev;
3192
3193 abort_free:
3194 if (rdev->bdev)
3195 unlock_rdev(rdev);
3196 md_rdev_clear(rdev);
3197 kfree(rdev);
3198 return ERR_PTR(err);
3199 }
3200
3201 /*
3202 * Check a full RAID array for plausibility
3203 */
3204
3205 static void analyze_sbs(struct mddev *mddev)
3206 {
3207 int i;
3208 struct md_rdev *rdev, *freshest, *tmp;
3209 char b[BDEVNAME_SIZE];
3210
3211 freshest = NULL;
3212 rdev_for_each_safe(rdev, tmp, mddev)
3213 switch (super_types[mddev->major_version].
3214 load_super(rdev, freshest, mddev->minor_version)) {
3215 case 1:
3216 freshest = rdev;
3217 break;
3218 case 0:
3219 break;
3220 default:
3221 printk( KERN_ERR \
3222 "md: fatal superblock inconsistency in %s"
3223 " -- removing from array\n",
3224 bdevname(rdev->bdev,b));
3225 md_kick_rdev_from_array(rdev);
3226 }
3227
3228 super_types[mddev->major_version].
3229 validate_super(mddev, freshest);
3230
3231 i = 0;
3232 rdev_for_each_safe(rdev, tmp, mddev) {
3233 if (mddev->max_disks &&
3234 (rdev->desc_nr >= mddev->max_disks ||
3235 i > mddev->max_disks)) {
3236 printk(KERN_WARNING
3237 "md: %s: %s: only %d devices permitted\n",
3238 mdname(mddev), bdevname(rdev->bdev, b),
3239 mddev->max_disks);
3240 md_kick_rdev_from_array(rdev);
3241 continue;
3242 }
3243 if (rdev != freshest) {
3244 if (super_types[mddev->major_version].
3245 validate_super(mddev, rdev)) {
3246 printk(KERN_WARNING "md: kicking non-fresh %s"
3247 " from array!\n",
3248 bdevname(rdev->bdev,b));
3249 md_kick_rdev_from_array(rdev);
3250 continue;
3251 }
3252 }
3253 if (mddev->level == LEVEL_MULTIPATH) {
3254 rdev->desc_nr = i++;
3255 rdev->raid_disk = rdev->desc_nr;
3256 set_bit(In_sync, &rdev->flags);
3257 } else if (rdev->raid_disk >= (mddev->raid_disks - min(0, mddev->delta_disks))) {
3258 rdev->raid_disk = -1;
3259 clear_bit(In_sync, &rdev->flags);
3260 }
3261 }
3262 }
3263
3264 /* Read a fixed-point number.
3265 * Numbers in sysfs attributes should be in "standard" units where
3266 * possible, so time should be in seconds.
3267 * However we internally use a a much smaller unit such as
3268 * milliseconds or jiffies.
3269 * This function takes a decimal number with a possible fractional
3270 * component, and produces an integer which is the result of
3271 * multiplying that number by 10^'scale'.
3272 * all without any floating-point arithmetic.
3273 */
3274 int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
3275 {
3276 unsigned long result = 0;
3277 long decimals = -1;
3278 while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
3279 if (*cp == '.')
3280 decimals = 0;
3281 else if (decimals < scale) {
3282 unsigned int value;
3283 value = *cp - '0';
3284 result = result * 10 + value;
3285 if (decimals >= 0)
3286 decimals++;
3287 }
3288 cp++;
3289 }
3290 if (*cp == '\n')
3291 cp++;
3292 if (*cp)
3293 return -EINVAL;
3294 if (decimals < 0)
3295 decimals = 0;
3296 while (decimals < scale) {
3297 result *= 10;
3298 decimals ++;
3299 }
3300 *res = result;
3301 return 0;
3302 }
3303
3304 static ssize_t
3305 safe_delay_show(struct mddev *mddev, char *page)
3306 {
3307 int msec = (mddev->safemode_delay*1000)/HZ;
3308 return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
3309 }
3310 static ssize_t
3311 safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
3312 {
3313 unsigned long msec;
3314
3315 if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
3316 return -EINVAL;
3317 if (msec == 0)
3318 mddev->safemode_delay = 0;
3319 else {
3320 unsigned long old_delay = mddev->safemode_delay;
3321 unsigned long new_delay = (msec*HZ)/1000;
3322
3323 if (new_delay == 0)
3324 new_delay = 1;
3325 mddev->safemode_delay = new_delay;
3326 if (new_delay < old_delay || old_delay == 0)
3327 mod_timer(&mddev->safemode_timer, jiffies+1);
3328 }
3329 return len;
3330 }
3331 static struct md_sysfs_entry md_safe_delay =
3332 __ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
3333
3334 static ssize_t
3335 level_show(struct mddev *mddev, char *page)
3336 {
3337 struct md_personality *p;
3338 int ret;
3339 spin_lock(&mddev->lock);
3340 p = mddev->pers;
3341 if (p)
3342 ret = sprintf(page, "%s\n", p->name);
3343 else if (mddev->clevel[0])
3344 ret = sprintf(page, "%s\n", mddev->clevel);
3345 else if (mddev->level != LEVEL_NONE)
3346 ret = sprintf(page, "%d\n", mddev->level);
3347 else
3348 ret = 0;
3349 spin_unlock(&mddev->lock);
3350 return ret;
3351 }
3352
3353 static ssize_t
3354 level_store(struct mddev *mddev, const char *buf, size_t len)
3355 {
3356 char clevel[16];
3357 ssize_t rv;
3358 size_t slen = len;
3359 struct md_personality *pers, *oldpers;
3360 long level;
3361 void *priv, *oldpriv;
3362 struct md_rdev *rdev;
3363
3364 if (slen == 0 || slen >= sizeof(clevel))
3365 return -EINVAL;
3366
3367 rv = mddev_lock(mddev);
3368 if (rv)
3369 return rv;
3370
3371 if (mddev->pers == NULL) {
3372 strncpy(mddev->clevel, buf, slen);
3373 if (mddev->clevel[slen-1] == '\n')
3374 slen--;
3375 mddev->clevel[slen] = 0;
3376 mddev->level = LEVEL_NONE;
3377 rv = len;
3378 goto out_unlock;
3379 }
3380 rv = -EROFS;
3381 if (mddev->ro)
3382 goto out_unlock;
3383
3384 /* request to change the personality. Need to ensure:
3385 * - array is not engaged in resync/recovery/reshape
3386 * - old personality can be suspended
3387 * - new personality will access other array.
3388 */
3389
3390 rv = -EBUSY;
3391 if (mddev->sync_thread ||
3392 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3393 mddev->reshape_position != MaxSector ||
3394 mddev->sysfs_active)
3395 goto out_unlock;
3396
3397 rv = -EINVAL;
3398 if (!mddev->pers->quiesce) {
3399 printk(KERN_WARNING "md: %s: %s does not support online personality change\n",
3400 mdname(mddev), mddev->pers->name);
3401 goto out_unlock;
3402 }
3403
3404 /* Now find the new personality */
3405 strncpy(clevel, buf, slen);
3406 if (clevel[slen-1] == '\n')
3407 slen--;
3408 clevel[slen] = 0;
3409 if (kstrtol(clevel, 10, &level))
3410 level = LEVEL_NONE;
3411
3412 if (request_module("md-%s", clevel) != 0)
3413 request_module("md-level-%s", clevel);
3414 spin_lock(&pers_lock);
3415 pers = find_pers(level, clevel);
3416 if (!pers || !try_module_get(pers->owner)) {
3417 spin_unlock(&pers_lock);
3418 printk(KERN_WARNING "md: personality %s not loaded\n", clevel);
3419 rv = -EINVAL;
3420 goto out_unlock;
3421 }
3422 spin_unlock(&pers_lock);
3423
3424 if (pers == mddev->pers) {
3425 /* Nothing to do! */
3426 module_put(pers->owner);
3427 rv = len;
3428 goto out_unlock;
3429 }
3430 if (!pers->takeover) {
3431 module_put(pers->owner);
3432 printk(KERN_WARNING "md: %s: %s does not support personality takeover\n",
3433 mdname(mddev), clevel);
3434 rv = -EINVAL;
3435 goto out_unlock;
3436 }
3437
3438 rdev_for_each(rdev, mddev)
3439 rdev->new_raid_disk = rdev->raid_disk;
3440
3441 /* ->takeover must set new_* and/or delta_disks
3442 * if it succeeds, and may set them when it fails.
3443 */
3444 priv = pers->takeover(mddev);
3445 if (IS_ERR(priv)) {
3446 mddev->new_level = mddev->level;
3447 mddev->new_layout = mddev->layout;
3448 mddev->new_chunk_sectors = mddev->chunk_sectors;
3449 mddev->raid_disks -= mddev->delta_disks;
3450 mddev->delta_disks = 0;
3451 mddev->reshape_backwards = 0;
3452 module_put(pers->owner);
3453 printk(KERN_WARNING "md: %s: %s would not accept array\n",
3454 mdname(mddev), clevel);
3455 rv = PTR_ERR(priv);
3456 goto out_unlock;
3457 }
3458
3459 /* Looks like we have a winner */
3460 mddev_suspend(mddev);
3461 mddev_detach(mddev);
3462
3463 spin_lock(&mddev->lock);
3464 oldpers = mddev->pers;
3465 oldpriv = mddev->private;
3466 mddev->pers = pers;
3467 mddev->private = priv;
3468 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3469 mddev->level = mddev->new_level;
3470 mddev->layout = mddev->new_layout;
3471 mddev->chunk_sectors = mddev->new_chunk_sectors;
3472 mddev->delta_disks = 0;
3473 mddev->reshape_backwards = 0;
3474 mddev->degraded = 0;
3475 spin_unlock(&mddev->lock);
3476
3477 if (oldpers->sync_request == NULL &&
3478 mddev->external) {
3479 /* We are converting from a no-redundancy array
3480 * to a redundancy array and metadata is managed
3481 * externally so we need to be sure that writes
3482 * won't block due to a need to transition
3483 * clean->dirty
3484 * until external management is started.
3485 */
3486 mddev->in_sync = 0;
3487 mddev->safemode_delay = 0;
3488 mddev->safemode = 0;
3489 }
3490
3491 oldpers->free(mddev, oldpriv);
3492
3493 if (oldpers->sync_request == NULL &&
3494 pers->sync_request != NULL) {
3495 /* need to add the md_redundancy_group */
3496 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
3497 printk(KERN_WARNING
3498 "md: cannot register extra attributes for %s\n",
3499 mdname(mddev));
3500 mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
3501 }
3502 if (oldpers->sync_request != NULL &&
3503 pers->sync_request == NULL) {
3504 /* need to remove the md_redundancy_group */
3505 if (mddev->to_remove == NULL)
3506 mddev->to_remove = &md_redundancy_group;
3507 }
3508
3509 rdev_for_each(rdev, mddev) {
3510 if (rdev->raid_disk < 0)
3511 continue;
3512 if (rdev->new_raid_disk >= mddev->raid_disks)
3513 rdev->new_raid_disk = -1;
3514 if (rdev->new_raid_disk == rdev->raid_disk)
3515 continue;
3516 sysfs_unlink_rdev(mddev, rdev);
3517 }
3518 rdev_for_each(rdev, mddev) {
3519 if (rdev->raid_disk < 0)
3520 continue;
3521 if (rdev->new_raid_disk == rdev->raid_disk)
3522 continue;
3523 rdev->raid_disk = rdev->new_raid_disk;
3524 if (rdev->raid_disk < 0)
3525 clear_bit(In_sync, &rdev->flags);
3526 else {
3527 if (sysfs_link_rdev(mddev, rdev))
3528 printk(KERN_WARNING "md: cannot register rd%d"
3529 " for %s after level change\n",
3530 rdev->raid_disk, mdname(mddev));
3531 }
3532 }
3533
3534 if (pers->sync_request == NULL) {
3535 /* this is now an array without redundancy, so
3536 * it must always be in_sync
3537 */
3538 mddev->in_sync = 1;
3539 del_timer_sync(&mddev->safemode_timer);
3540 }
3541 blk_set_stacking_limits(&mddev->queue->limits);
3542 pers->run(mddev);
3543 set_bit(MD_CHANGE_DEVS, &mddev->flags);
3544 mddev_resume(mddev);
3545 if (!mddev->thread)
3546 md_update_sb(mddev, 1);
3547 sysfs_notify(&mddev->kobj, NULL, "level");
3548 md_new_event(mddev);
3549 rv = len;
3550 out_unlock:
3551 mddev_unlock(mddev);
3552 return rv;
3553 }
3554
3555 static struct md_sysfs_entry md_level =
3556 __ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
3557
3558 static ssize_t
3559 layout_show(struct mddev *mddev, char *page)
3560 {
3561 /* just a number, not meaningful for all levels */
3562 if (mddev->reshape_position != MaxSector &&
3563 mddev->layout != mddev->new_layout)
3564 return sprintf(page, "%d (%d)\n",
3565 mddev->new_layout, mddev->layout);
3566 return sprintf(page, "%d\n", mddev->layout);
3567 }
3568
3569 static ssize_t
3570 layout_store(struct mddev *mddev, const char *buf, size_t len)
3571 {
3572 unsigned int n;
3573 int err;
3574
3575 err = kstrtouint(buf, 10, &n);
3576 if (err < 0)
3577 return err;
3578 err = mddev_lock(mddev);
3579 if (err)
3580 return err;
3581
3582 if (mddev->pers) {
3583 if (mddev->pers->check_reshape == NULL)
3584 err = -EBUSY;
3585 else if (mddev->ro)
3586 err = -EROFS;
3587 else {
3588 mddev->new_layout = n;
3589 err = mddev->pers->check_reshape(mddev);
3590 if (err)
3591 mddev->new_layout = mddev->layout;
3592 }
3593 } else {
3594 mddev->new_layout = n;
3595 if (mddev->reshape_position == MaxSector)
3596 mddev->layout = n;
3597 }
3598 mddev_unlock(mddev);
3599 return err ?: len;
3600 }
3601 static struct md_sysfs_entry md_layout =
3602 __ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
3603
3604 static ssize_t
3605 raid_disks_show(struct mddev *mddev, char *page)
3606 {
3607 if (mddev->raid_disks == 0)
3608 return 0;
3609 if (mddev->reshape_position != MaxSector &&
3610 mddev->delta_disks != 0)
3611 return sprintf(page, "%d (%d)\n", mddev->raid_disks,
3612 mddev->raid_disks - mddev->delta_disks);
3613 return sprintf(page, "%d\n", mddev->raid_disks);
3614 }
3615
3616 static int update_raid_disks(struct mddev *mddev, int raid_disks);
3617
3618 static ssize_t
3619 raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
3620 {
3621 unsigned int n;
3622 int err;
3623
3624 err = kstrtouint(buf, 10, &n);
3625 if (err < 0)
3626 return err;
3627
3628 err = mddev_lock(mddev);
3629 if (err)
3630 return err;
3631 if (mddev->pers)
3632 err = update_raid_disks(mddev, n);
3633 else if (mddev->reshape_position != MaxSector) {
3634 struct md_rdev *rdev;
3635 int olddisks = mddev->raid_disks - mddev->delta_disks;
3636
3637 err = -EINVAL;
3638 rdev_for_each(rdev, mddev) {
3639 if (olddisks < n &&
3640 rdev->data_offset < rdev->new_data_offset)
3641 goto out_unlock;
3642 if (olddisks > n &&
3643 rdev->data_offset > rdev->new_data_offset)
3644 goto out_unlock;
3645 }
3646 err = 0;
3647 mddev->delta_disks = n - olddisks;
3648 mddev->raid_disks = n;
3649 mddev->reshape_backwards = (mddev->delta_disks < 0);
3650 } else
3651 mddev->raid_disks = n;
3652 out_unlock:
3653 mddev_unlock(mddev);
3654 return err ? err : len;
3655 }
3656 static struct md_sysfs_entry md_raid_disks =
3657 __ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
3658
3659 static ssize_t
3660 chunk_size_show(struct mddev *mddev, char *page)
3661 {
3662 if (mddev->reshape_position != MaxSector &&
3663 mddev->chunk_sectors != mddev->new_chunk_sectors)
3664 return sprintf(page, "%d (%d)\n",
3665 mddev->new_chunk_sectors << 9,
3666 mddev->chunk_sectors << 9);
3667 return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
3668 }
3669
3670 static ssize_t
3671 chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
3672 {
3673 unsigned long n;
3674 int err;
3675
3676 err = kstrtoul(buf, 10, &n);
3677 if (err < 0)
3678 return err;
3679
3680 err = mddev_lock(mddev);
3681 if (err)
3682 return err;
3683 if (mddev->pers) {
3684 if (mddev->pers->check_reshape == NULL)
3685 err = -EBUSY;
3686 else if (mddev->ro)
3687 err = -EROFS;
3688 else {
3689 mddev->new_chunk_sectors = n >> 9;
3690 err = mddev->pers->check_reshape(mddev);
3691 if (err)
3692 mddev->new_chunk_sectors = mddev->chunk_sectors;
3693 }
3694 } else {
3695 mddev->new_chunk_sectors = n >> 9;
3696 if (mddev->reshape_position == MaxSector)
3697 mddev->chunk_sectors = n >> 9;
3698 }
3699 mddev_unlock(mddev);
3700 return err ?: len;
3701 }
3702 static struct md_sysfs_entry md_chunk_size =
3703 __ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
3704
3705 static ssize_t
3706 resync_start_show(struct mddev *mddev, char *page)
3707 {
3708 if (mddev->recovery_cp == MaxSector)
3709 return sprintf(page, "none\n");
3710 return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
3711 }
3712
3713 static ssize_t
3714 resync_start_store(struct mddev *mddev, const char *buf, size_t len)
3715 {
3716 unsigned long long n;
3717 int err;
3718
3719 if (cmd_match(buf, "none"))
3720 n = MaxSector;
3721 else {
3722 err = kstrtoull(buf, 10, &n);
3723 if (err < 0)
3724 return err;
3725 if (n != (sector_t)n)
3726 return -EINVAL;
3727 }
3728
3729 err = mddev_lock(mddev);
3730 if (err)
3731 return err;
3732 if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
3733 err = -EBUSY;
3734
3735 if (!err) {
3736 mddev->recovery_cp = n;
3737 if (mddev->pers)
3738 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3739 }
3740 mddev_unlock(mddev);
3741 return err ?: len;
3742 }
3743 static struct md_sysfs_entry md_resync_start =
3744 __ATTR_PREALLOC(resync_start, S_IRUGO|S_IWUSR,
3745 resync_start_show, resync_start_store);
3746
3747 /*
3748 * The array state can be:
3749 *
3750 * clear
3751 * No devices, no size, no level
3752 * Equivalent to STOP_ARRAY ioctl
3753 * inactive
3754 * May have some settings, but array is not active
3755 * all IO results in error
3756 * When written, doesn't tear down array, but just stops it
3757 * suspended (not supported yet)
3758 * All IO requests will block. The array can be reconfigured.
3759 * Writing this, if accepted, will block until array is quiescent
3760 * readonly
3761 * no resync can happen. no superblocks get written.
3762 * write requests fail
3763 * read-auto
3764 * like readonly, but behaves like 'clean' on a write request.
3765 *
3766 * clean - no pending writes, but otherwise active.
3767 * When written to inactive array, starts without resync
3768 * If a write request arrives then
3769 * if metadata is known, mark 'dirty' and switch to 'active'.
3770 * if not known, block and switch to write-pending
3771 * If written to an active array that has pending writes, then fails.
3772 * active
3773 * fully active: IO and resync can be happening.
3774 * When written to inactive array, starts with resync
3775 *
3776 * write-pending
3777 * clean, but writes are blocked waiting for 'active' to be written.
3778 *
3779 * active-idle
3780 * like active, but no writes have been seen for a while (100msec).
3781 *
3782 */
3783 enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
3784 write_pending, active_idle, bad_word};
3785 static char *array_states[] = {
3786 "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
3787 "write-pending", "active-idle", NULL };
3788
3789 static int match_word(const char *word, char **list)
3790 {
3791 int n;
3792 for (n=0; list[n]; n++)
3793 if (cmd_match(word, list[n]))
3794 break;
3795 return n;
3796 }
3797
3798 static ssize_t
3799 array_state_show(struct mddev *mddev, char *page)
3800 {
3801 enum array_state st = inactive;
3802
3803 if (mddev->pers)
3804 switch(mddev->ro) {
3805 case 1:
3806 st = readonly;
3807 break;
3808 case 2:
3809 st = read_auto;
3810 break;
3811 case 0:
3812 if (mddev->in_sync)
3813 st = clean;
3814 else if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
3815 st = write_pending;
3816 else if (mddev->safemode)
3817 st = active_idle;
3818 else
3819 st = active;
3820 }
3821 else {
3822 if (list_empty(&mddev->disks) &&
3823 mddev->raid_disks == 0 &&
3824 mddev->dev_sectors == 0)
3825 st = clear;
3826 else
3827 st = inactive;
3828 }
3829 return sprintf(page, "%s\n", array_states[st]);
3830 }
3831
3832 static int do_md_stop(struct mddev *mddev, int ro, struct block_device *bdev);
3833 static int md_set_readonly(struct mddev *mddev, struct block_device *bdev);
3834 static int do_md_run(struct mddev *mddev);
3835 static int restart_array(struct mddev *mddev);
3836
3837 static ssize_t
3838 array_state_store(struct mddev *mddev, const char *buf, size_t len)
3839 {
3840 int err;
3841 enum array_state st = match_word(buf, array_states);
3842
3843 if (mddev->pers && (st == active || st == clean) && mddev->ro != 1) {
3844 /* don't take reconfig_mutex when toggling between
3845 * clean and active
3846 */
3847 spin_lock(&mddev->lock);
3848 if (st == active) {
3849 restart_array(mddev);
3850 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
3851 wake_up(&mddev->sb_wait);
3852 err = 0;
3853 } else /* st == clean */ {
3854 restart_array(mddev);
3855 if (atomic_read(&mddev->writes_pending) == 0) {
3856 if (mddev->in_sync == 0) {
3857 mddev->in_sync = 1;
3858 if (mddev->safemode == 1)
3859 mddev->safemode = 0;
3860 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3861 }
3862 err = 0;
3863 } else
3864 err = -EBUSY;
3865 }
3866 spin_unlock(&mddev->lock);
3867 return err ?: len;
3868 }
3869 err = mddev_lock(mddev);
3870 if (err)
3871 return err;
3872 err = -EINVAL;
3873 switch(st) {
3874 case bad_word:
3875 break;
3876 case clear:
3877 /* stopping an active array */
3878 err = do_md_stop(mddev, 0, NULL);
3879 break;
3880 case inactive:
3881 /* stopping an active array */
3882 if (mddev->pers)
3883 err = do_md_stop(mddev, 2, NULL);
3884 else
3885 err = 0; /* already inactive */
3886 break;
3887 case suspended:
3888 break; /* not supported yet */
3889 case readonly:
3890 if (mddev->pers)
3891 err = md_set_readonly(mddev, NULL);
3892 else {
3893 mddev->ro = 1;
3894 set_disk_ro(mddev->gendisk, 1);
3895 err = do_md_run(mddev);
3896 }
3897 break;
3898 case read_auto:
3899 if (mddev->pers) {
3900 if (mddev->ro == 0)
3901 err = md_set_readonly(mddev, NULL);
3902 else if (mddev->ro == 1)
3903 err = restart_array(mddev);
3904 if (err == 0) {
3905 mddev->ro = 2;
3906 set_disk_ro(mddev->gendisk, 0);
3907 }
3908 } else {
3909 mddev->ro = 2;
3910 err = do_md_run(mddev);
3911 }
3912 break;
3913 case clean:
3914 if (mddev->pers) {
3915 restart_array(mddev);
3916 spin_lock(&mddev->lock);
3917 if (atomic_read(&mddev->writes_pending) == 0) {
3918 if (mddev->in_sync == 0) {
3919 mddev->in_sync = 1;
3920 if (mddev->safemode == 1)
3921 mddev->safemode = 0;
3922 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3923 }
3924 err = 0;
3925 } else
3926 err = -EBUSY;
3927 spin_unlock(&mddev->lock);
3928 } else
3929 err = -EINVAL;
3930 break;
3931 case active:
3932 if (mddev->pers) {
3933 restart_array(mddev);
3934 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
3935 wake_up(&mddev->sb_wait);
3936 err = 0;
3937 } else {
3938 mddev->ro = 0;
3939 set_disk_ro(mddev->gendisk, 0);
3940 err = do_md_run(mddev);
3941 }
3942 break;
3943 case write_pending:
3944 case active_idle:
3945 /* these cannot be set */
3946 break;
3947 }
3948
3949 if (!err) {
3950 if (mddev->hold_active == UNTIL_IOCTL)
3951 mddev->hold_active = 0;
3952 sysfs_notify_dirent_safe(mddev->sysfs_state);
3953 }
3954 mddev_unlock(mddev);
3955 return err ?: len;
3956 }
3957 static struct md_sysfs_entry md_array_state =
3958 __ATTR_PREALLOC(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
3959
3960 static ssize_t
3961 max_corrected_read_errors_show(struct mddev *mddev, char *page) {
3962 return sprintf(page, "%d\n",
3963 atomic_read(&mddev->max_corr_read_errors));
3964 }
3965
3966 static ssize_t
3967 max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
3968 {
3969 unsigned int n;
3970 int rv;
3971
3972 rv = kstrtouint(buf, 10, &n);
3973 if (rv < 0)
3974 return rv;
3975 atomic_set(&mddev->max_corr_read_errors, n);
3976 return len;
3977 }
3978
3979 static struct md_sysfs_entry max_corr_read_errors =
3980 __ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
3981 max_corrected_read_errors_store);
3982
3983 static ssize_t
3984 null_show(struct mddev *mddev, char *page)
3985 {
3986 return -EINVAL;
3987 }
3988
3989 static ssize_t
3990 new_dev_store(struct mddev *mddev, const char *buf, size_t len)
3991 {
3992 /* buf must be %d:%d\n? giving major and minor numbers */
3993 /* The new device is added to the array.
3994 * If the array has a persistent superblock, we read the
3995 * superblock to initialise info and check validity.
3996 * Otherwise, only checking done is that in bind_rdev_to_array,
3997 * which mainly checks size.
3998 */
3999 char *e;
4000 int major = simple_strtoul(buf, &e, 10);
4001 int minor;
4002 dev_t dev;
4003 struct md_rdev *rdev;
4004 int err;
4005
4006 if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
4007 return -EINVAL;
4008 minor = simple_strtoul(e+1, &e, 10);
4009 if (*e && *e != '\n')
4010 return -EINVAL;
4011 dev = MKDEV(major, minor);
4012 if (major != MAJOR(dev) ||
4013 minor != MINOR(dev))
4014 return -EOVERFLOW;
4015
4016 flush_workqueue(md_misc_wq);
4017
4018 err = mddev_lock(mddev);
4019 if (err)
4020 return err;
4021 if (mddev->persistent) {
4022 rdev = md_import_device(dev, mddev->major_version,
4023 mddev->minor_version);
4024 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
4025 struct md_rdev *rdev0
4026 = list_entry(mddev->disks.next,
4027 struct md_rdev, same_set);
4028 err = super_types[mddev->major_version]
4029 .load_super(rdev, rdev0, mddev->minor_version);
4030 if (err < 0)
4031 goto out;
4032 }
4033 } else if (mddev->external)
4034 rdev = md_import_device(dev, -2, -1);
4035 else
4036 rdev = md_import_device(dev, -1, -1);
4037
4038 if (IS_ERR(rdev)) {
4039 mddev_unlock(mddev);
4040 return PTR_ERR(rdev);
4041 }
4042 err = bind_rdev_to_array(rdev, mddev);
4043 out:
4044 if (err)
4045 export_rdev(rdev);
4046 mddev_unlock(mddev);
4047 return err ? err : len;
4048 }
4049
4050 static struct md_sysfs_entry md_new_device =
4051 __ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
4052
4053 static ssize_t
4054 bitmap_store(struct mddev *mddev, const char *buf, size_t len)
4055 {
4056 char *end;
4057 unsigned long chunk, end_chunk;
4058 int err;
4059
4060 err = mddev_lock(mddev);
4061 if (err)
4062 return err;
4063 if (!mddev->bitmap)
4064 goto out;
4065 /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
4066 while (*buf) {
4067 chunk = end_chunk = simple_strtoul(buf, &end, 0);
4068 if (buf == end) break;
4069 if (*end == '-') { /* range */
4070 buf = end + 1;
4071 end_chunk = simple_strtoul(buf, &end, 0);
4072 if (buf == end) break;
4073 }
4074 if (*end && !isspace(*end)) break;
4075 bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
4076 buf = skip_spaces(end);
4077 }
4078 bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
4079 out:
4080 mddev_unlock(mddev);
4081 return len;
4082 }
4083
4084 static struct md_sysfs_entry md_bitmap =
4085 __ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
4086
4087 static ssize_t
4088 size_show(struct mddev *mddev, char *page)
4089 {
4090 return sprintf(page, "%llu\n",
4091 (unsigned long long)mddev->dev_sectors / 2);
4092 }
4093
4094 static int update_size(struct mddev *mddev, sector_t num_sectors);
4095
4096 static ssize_t
4097 size_store(struct mddev *mddev, const char *buf, size_t len)
4098 {
4099 /* If array is inactive, we can reduce the component size, but
4100 * not increase it (except from 0).
4101 * If array is active, we can try an on-line resize
4102 */
4103 sector_t sectors;
4104 int err = strict_blocks_to_sectors(buf, &sectors);
4105
4106 if (err < 0)
4107 return err;
4108 err = mddev_lock(mddev);
4109 if (err)
4110 return err;
4111 if (mddev->pers) {
4112 err = update_size(mddev, sectors);
4113 md_update_sb(mddev, 1);
4114 } else {
4115 if (mddev->dev_sectors == 0 ||
4116 mddev->dev_sectors > sectors)
4117 mddev->dev_sectors = sectors;
4118 else
4119 err = -ENOSPC;
4120 }
4121 mddev_unlock(mddev);
4122 return err ? err : len;
4123 }
4124
4125 static struct md_sysfs_entry md_size =
4126 __ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
4127
4128 /* Metadata version.
4129 * This is one of
4130 * 'none' for arrays with no metadata (good luck...)
4131 * 'external' for arrays with externally managed metadata,
4132 * or N.M for internally known formats
4133 */
4134 static ssize_t
4135 metadata_show(struct mddev *mddev, char *page)
4136 {
4137 if (mddev->persistent)
4138 return sprintf(page, "%d.%d\n",
4139 mddev->major_version, mddev->minor_version);
4140 else if (mddev->external)
4141 return sprintf(page, "external:%s\n", mddev->metadata_type);
4142 else
4143 return sprintf(page, "none\n");
4144 }
4145
4146 static ssize_t
4147 metadata_store(struct mddev *mddev, const char *buf, size_t len)
4148 {
4149 int major, minor;
4150 char *e;
4151 int err;
4152 /* Changing the details of 'external' metadata is
4153 * always permitted. Otherwise there must be
4154 * no devices attached to the array.
4155 */
4156
4157 err = mddev_lock(mddev);
4158 if (err)
4159 return err;
4160 err = -EBUSY;
4161 if (mddev->external && strncmp(buf, "external:", 9) == 0)
4162 ;
4163 else if (!list_empty(&mddev->disks))
4164 goto out_unlock;
4165
4166 err = 0;
4167 if (cmd_match(buf, "none")) {
4168 mddev->persistent = 0;
4169 mddev->external = 0;
4170 mddev->major_version = 0;
4171 mddev->minor_version = 90;
4172 goto out_unlock;
4173 }
4174 if (strncmp(buf, "external:", 9) == 0) {
4175 size_t namelen = len-9;
4176 if (namelen >= sizeof(mddev->metadata_type))
4177 namelen = sizeof(mddev->metadata_type)-1;
4178 strncpy(mddev->metadata_type, buf+9, namelen);
4179 mddev->metadata_type[namelen] = 0;
4180 if (namelen && mddev->metadata_type[namelen-1] == '\n')
4181 mddev->metadata_type[--namelen] = 0;
4182 mddev->persistent = 0;
4183 mddev->external = 1;
4184 mddev->major_version = 0;
4185 mddev->minor_version = 90;
4186 goto out_unlock;
4187 }
4188 major = simple_strtoul(buf, &e, 10);
4189 err = -EINVAL;
4190 if (e==buf || *e != '.')
4191 goto out_unlock;
4192 buf = e+1;
4193 minor = simple_strtoul(buf, &e, 10);
4194 if (e==buf || (*e && *e != '\n') )
4195 goto out_unlock;
4196 err = -ENOENT;
4197 if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
4198 goto out_unlock;
4199 mddev->major_version = major;
4200 mddev->minor_version = minor;
4201 mddev->persistent = 1;
4202 mddev->external = 0;
4203 err = 0;
4204 out_unlock:
4205 mddev_unlock(mddev);
4206 return err ?: len;
4207 }
4208
4209 static struct md_sysfs_entry md_metadata =
4210 __ATTR_PREALLOC(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
4211
4212 static ssize_t
4213 action_show(struct mddev *mddev, char *page)
4214 {
4215 char *type = "idle";
4216 unsigned long recovery = mddev->recovery;
4217 if (test_bit(MD_RECOVERY_FROZEN, &recovery))
4218 type = "frozen";
4219 else if (test_bit(MD_RECOVERY_RUNNING, &recovery) ||
4220 (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &recovery))) {
4221 if (test_bit(MD_RECOVERY_RESHAPE, &recovery))
4222 type = "reshape";
4223 else if (test_bit(MD_RECOVERY_SYNC, &recovery)) {
4224 if (!test_bit(MD_RECOVERY_REQUESTED, &recovery))
4225 type = "resync";
4226 else if (test_bit(MD_RECOVERY_CHECK, &recovery))
4227 type = "check";
4228 else
4229 type = "repair";
4230 } else if (test_bit(MD_RECOVERY_RECOVER, &recovery))
4231 type = "recover";
4232 else if (mddev->reshape_position != MaxSector)
4233 type = "reshape";
4234 }
4235 return sprintf(page, "%s\n", type);
4236 }
4237
4238 static ssize_t
4239 action_store(struct mddev *mddev, const char *page, size_t len)
4240 {
4241 if (!mddev->pers || !mddev->pers->sync_request)
4242 return -EINVAL;
4243
4244
4245 if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
4246 if (cmd_match(page, "frozen"))
4247 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4248 else
4249 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4250 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
4251 mddev_lock(mddev) == 0) {
4252 flush_workqueue(md_misc_wq);
4253 if (mddev->sync_thread) {
4254 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4255 md_reap_sync_thread(mddev);
4256 }
4257 mddev_unlock(mddev);
4258 }
4259 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
4260 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
4261 return -EBUSY;
4262 else if (cmd_match(page, "resync"))
4263 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4264 else if (cmd_match(page, "recover")) {
4265 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4266 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
4267 } else if (cmd_match(page, "reshape")) {
4268 int err;
4269 if (mddev->pers->start_reshape == NULL)
4270 return -EINVAL;
4271 err = mddev_lock(mddev);
4272 if (!err) {
4273 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4274 err = mddev->pers->start_reshape(mddev);
4275 mddev_unlock(mddev);
4276 }
4277 if (err)
4278 return err;
4279 sysfs_notify(&mddev->kobj, NULL, "degraded");
4280 } else {
4281 if (cmd_match(page, "check"))
4282 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
4283 else if (!cmd_match(page, "repair"))
4284 return -EINVAL;
4285 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4286 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
4287 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4288 }
4289 if (mddev->ro == 2) {
4290 /* A write to sync_action is enough to justify
4291 * canceling read-auto mode
4292 */
4293 mddev->ro = 0;
4294 md_wakeup_thread(mddev->sync_thread);
4295 }
4296 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4297 md_wakeup_thread(mddev->thread);
4298 sysfs_notify_dirent_safe(mddev->sysfs_action);
4299 return len;
4300 }
4301
4302 static struct md_sysfs_entry md_scan_mode =
4303 __ATTR_PREALLOC(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
4304
4305 static ssize_t
4306 last_sync_action_show(struct mddev *mddev, char *page)
4307 {
4308 return sprintf(page, "%s\n", mddev->last_sync_action);
4309 }
4310
4311 static struct md_sysfs_entry md_last_scan_mode = __ATTR_RO(last_sync_action);
4312
4313 static ssize_t
4314 mismatch_cnt_show(struct mddev *mddev, char *page)
4315 {
4316 return sprintf(page, "%llu\n",
4317 (unsigned long long)
4318 atomic64_read(&mddev->resync_mismatches));
4319 }
4320
4321 static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
4322
4323 static ssize_t
4324 sync_min_show(struct mddev *mddev, char *page)
4325 {
4326 return sprintf(page, "%d (%s)\n", speed_min(mddev),
4327 mddev->sync_speed_min ? "local": "system");
4328 }
4329
4330 static ssize_t
4331 sync_min_store(struct mddev *mddev, const char *buf, size_t len)
4332 {
4333 unsigned int min;
4334 int rv;
4335
4336 if (strncmp(buf, "system", 6)==0) {
4337 min = 0;
4338 } else {
4339 rv = kstrtouint(buf, 10, &min);
4340 if (rv < 0)
4341 return rv;
4342 if (min == 0)
4343 return -EINVAL;
4344 }
4345 mddev->sync_speed_min = min;
4346 return len;
4347 }
4348
4349 static struct md_sysfs_entry md_sync_min =
4350 __ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
4351
4352 static ssize_t
4353 sync_max_show(struct mddev *mddev, char *page)
4354 {
4355 return sprintf(page, "%d (%s)\n", speed_max(mddev),
4356 mddev->sync_speed_max ? "local": "system");
4357 }
4358
4359 static ssize_t
4360 sync_max_store(struct mddev *mddev, const char *buf, size_t len)
4361 {
4362 unsigned int max;
4363 int rv;
4364
4365 if (strncmp(buf, "system", 6)==0) {
4366 max = 0;
4367 } else {
4368 rv = kstrtouint(buf, 10, &max);
4369 if (rv < 0)
4370 return rv;
4371 if (max == 0)
4372 return -EINVAL;
4373 }
4374 mddev->sync_speed_max = max;
4375 return len;
4376 }
4377
4378 static struct md_sysfs_entry md_sync_max =
4379 __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
4380
4381 static ssize_t
4382 degraded_show(struct mddev *mddev, char *page)
4383 {
4384 return sprintf(page, "%d\n", mddev->degraded);
4385 }
4386 static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
4387
4388 static ssize_t
4389 sync_force_parallel_show(struct mddev *mddev, char *page)
4390 {
4391 return sprintf(page, "%d\n", mddev->parallel_resync);
4392 }
4393
4394 static ssize_t
4395 sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
4396 {
4397 long n;
4398
4399 if (kstrtol(buf, 10, &n))
4400 return -EINVAL;
4401
4402 if (n != 0 && n != 1)
4403 return -EINVAL;
4404
4405 mddev->parallel_resync = n;
4406
4407 if (mddev->sync_thread)
4408 wake_up(&resync_wait);
4409
4410 return len;
4411 }
4412
4413 /* force parallel resync, even with shared block devices */
4414 static struct md_sysfs_entry md_sync_force_parallel =
4415 __ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
4416 sync_force_parallel_show, sync_force_parallel_store);
4417
4418 static ssize_t
4419 sync_speed_show(struct mddev *mddev, char *page)
4420 {
4421 unsigned long resync, dt, db;
4422 if (mddev->curr_resync == 0)
4423 return sprintf(page, "none\n");
4424 resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
4425 dt = (jiffies - mddev->resync_mark) / HZ;
4426 if (!dt) dt++;
4427 db = resync - mddev->resync_mark_cnt;
4428 return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
4429 }
4430
4431 static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
4432
4433 static ssize_t
4434 sync_completed_show(struct mddev *mddev, char *page)
4435 {
4436 unsigned long long max_sectors, resync;
4437
4438 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4439 return sprintf(page, "none\n");
4440
4441 if (mddev->curr_resync == 1 ||
4442 mddev->curr_resync == 2)
4443 return sprintf(page, "delayed\n");
4444
4445 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
4446 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
4447 max_sectors = mddev->resync_max_sectors;
4448 else
4449 max_sectors = mddev->dev_sectors;
4450
4451 resync = mddev->curr_resync_completed;
4452 return sprintf(page, "%llu / %llu\n", resync, max_sectors);
4453 }
4454
4455 static struct md_sysfs_entry md_sync_completed =
4456 __ATTR_PREALLOC(sync_completed, S_IRUGO, sync_completed_show, NULL);
4457
4458 static ssize_t
4459 min_sync_show(struct mddev *mddev, char *page)
4460 {
4461 return sprintf(page, "%llu\n",
4462 (unsigned long long)mddev->resync_min);
4463 }
4464 static ssize_t
4465 min_sync_store(struct mddev *mddev, const char *buf, size_t len)
4466 {
4467 unsigned long long min;
4468 int err;
4469
4470 if (kstrtoull(buf, 10, &min))
4471 return -EINVAL;
4472
4473 spin_lock(&mddev->lock);
4474 err = -EINVAL;
4475 if (min > mddev->resync_max)
4476 goto out_unlock;
4477
4478 err = -EBUSY;
4479 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4480 goto out_unlock;
4481
4482 /* Round down to multiple of 4K for safety */
4483 mddev->resync_min = round_down(min, 8);
4484 err = 0;
4485
4486 out_unlock:
4487 spin_unlock(&mddev->lock);
4488 return err ?: len;
4489 }
4490
4491 static struct md_sysfs_entry md_min_sync =
4492 __ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
4493
4494 static ssize_t
4495 max_sync_show(struct mddev *mddev, char *page)
4496 {
4497 if (mddev->resync_max == MaxSector)
4498 return sprintf(page, "max\n");
4499 else
4500 return sprintf(page, "%llu\n",
4501 (unsigned long long)mddev->resync_max);
4502 }
4503 static ssize_t
4504 max_sync_store(struct mddev *mddev, const char *buf, size_t len)
4505 {
4506 int err;
4507 spin_lock(&mddev->lock);
4508 if (strncmp(buf, "max", 3) == 0)
4509 mddev->resync_max = MaxSector;
4510 else {
4511 unsigned long long max;
4512 int chunk;
4513
4514 err = -EINVAL;
4515 if (kstrtoull(buf, 10, &max))
4516 goto out_unlock;
4517 if (max < mddev->resync_min)
4518 goto out_unlock;
4519
4520 err = -EBUSY;
4521 if (max < mddev->resync_max &&
4522 mddev->ro == 0 &&
4523 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4524 goto out_unlock;
4525
4526 /* Must be a multiple of chunk_size */
4527 chunk = mddev->chunk_sectors;
4528 if (chunk) {
4529 sector_t temp = max;
4530
4531 err = -EINVAL;
4532 if (sector_div(temp, chunk))
4533 goto out_unlock;
4534 }
4535 mddev->resync_max = max;
4536 }
4537 wake_up(&mddev->recovery_wait);
4538 err = 0;
4539 out_unlock:
4540 spin_unlock(&mddev->lock);
4541 return err ?: len;
4542 }
4543
4544 static struct md_sysfs_entry md_max_sync =
4545 __ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
4546
4547 static ssize_t
4548 suspend_lo_show(struct mddev *mddev, char *page)
4549 {
4550 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
4551 }
4552
4553 static ssize_t
4554 suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
4555 {
4556 unsigned long long old, new;
4557 int err;
4558
4559 err = kstrtoull(buf, 10, &new);
4560 if (err < 0)
4561 return err;
4562 if (new != (sector_t)new)
4563 return -EINVAL;
4564
4565 err = mddev_lock(mddev);
4566 if (err)
4567 return err;
4568 err = -EINVAL;
4569 if (mddev->pers == NULL ||
4570 mddev->pers->quiesce == NULL)
4571 goto unlock;
4572 old = mddev->suspend_lo;
4573 mddev->suspend_lo = new;
4574 if (new >= old)
4575 /* Shrinking suspended region */
4576 mddev->pers->quiesce(mddev, 2);
4577 else {
4578 /* Expanding suspended region - need to wait */
4579 mddev->pers->quiesce(mddev, 1);
4580 mddev->pers->quiesce(mddev, 0);
4581 }
4582 err = 0;
4583 unlock:
4584 mddev_unlock(mddev);
4585 return err ?: len;
4586 }
4587 static struct md_sysfs_entry md_suspend_lo =
4588 __ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
4589
4590 static ssize_t
4591 suspend_hi_show(struct mddev *mddev, char *page)
4592 {
4593 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
4594 }
4595
4596 static ssize_t
4597 suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
4598 {
4599 unsigned long long old, new;
4600 int err;
4601
4602 err = kstrtoull(buf, 10, &new);
4603 if (err < 0)
4604 return err;
4605 if (new != (sector_t)new)
4606 return -EINVAL;
4607
4608 err = mddev_lock(mddev);
4609 if (err)
4610 return err;
4611 err = -EINVAL;
4612 if (mddev->pers == NULL ||
4613 mddev->pers->quiesce == NULL)
4614 goto unlock;
4615 old = mddev->suspend_hi;
4616 mddev->suspend_hi = new;
4617 if (new <= old)
4618 /* Shrinking suspended region */
4619 mddev->pers->quiesce(mddev, 2);
4620 else {
4621 /* Expanding suspended region - need to wait */
4622 mddev->pers->quiesce(mddev, 1);
4623 mddev->pers->quiesce(mddev, 0);
4624 }
4625 err = 0;
4626 unlock:
4627 mddev_unlock(mddev);
4628 return err ?: len;
4629 }
4630 static struct md_sysfs_entry md_suspend_hi =
4631 __ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
4632
4633 static ssize_t
4634 reshape_position_show(struct mddev *mddev, char *page)
4635 {
4636 if (mddev->reshape_position != MaxSector)
4637 return sprintf(page, "%llu\n",
4638 (unsigned long long)mddev->reshape_position);
4639 strcpy(page, "none\n");
4640 return 5;
4641 }
4642
4643 static ssize_t
4644 reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
4645 {
4646 struct md_rdev *rdev;
4647 unsigned long long new;
4648 int err;
4649
4650 err = kstrtoull(buf, 10, &new);
4651 if (err < 0)
4652 return err;
4653 if (new != (sector_t)new)
4654 return -EINVAL;
4655 err = mddev_lock(mddev);
4656 if (err)
4657 return err;
4658 err = -EBUSY;
4659 if (mddev->pers)
4660 goto unlock;
4661 mddev->reshape_position = new;
4662 mddev->delta_disks = 0;
4663 mddev->reshape_backwards = 0;
4664 mddev->new_level = mddev->level;
4665 mddev->new_layout = mddev->layout;
4666 mddev->new_chunk_sectors = mddev->chunk_sectors;
4667 rdev_for_each(rdev, mddev)
4668 rdev->new_data_offset = rdev->data_offset;
4669 err = 0;
4670 unlock:
4671 mddev_unlock(mddev);
4672 return err ?: len;
4673 }
4674
4675 static struct md_sysfs_entry md_reshape_position =
4676 __ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
4677 reshape_position_store);
4678
4679 static ssize_t
4680 reshape_direction_show(struct mddev *mddev, char *page)
4681 {
4682 return sprintf(page, "%s\n",
4683 mddev->reshape_backwards ? "backwards" : "forwards");
4684 }
4685
4686 static ssize_t
4687 reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
4688 {
4689 int backwards = 0;
4690 int err;
4691
4692 if (cmd_match(buf, "forwards"))
4693 backwards = 0;
4694 else if (cmd_match(buf, "backwards"))
4695 backwards = 1;
4696 else
4697 return -EINVAL;
4698 if (mddev->reshape_backwards == backwards)
4699 return len;
4700
4701 err = mddev_lock(mddev);
4702 if (err)
4703 return err;
4704 /* check if we are allowed to change */
4705 if (mddev->delta_disks)
4706 err = -EBUSY;
4707 else if (mddev->persistent &&
4708 mddev->major_version == 0)
4709 err = -EINVAL;
4710 else
4711 mddev->reshape_backwards = backwards;
4712 mddev_unlock(mddev);
4713 return err ?: len;
4714 }
4715
4716 static struct md_sysfs_entry md_reshape_direction =
4717 __ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
4718 reshape_direction_store);
4719
4720 static ssize_t
4721 array_size_show(struct mddev *mddev, char *page)
4722 {
4723 if (mddev->external_size)
4724 return sprintf(page, "%llu\n",
4725 (unsigned long long)mddev->array_sectors/2);
4726 else
4727 return sprintf(page, "default\n");
4728 }
4729
4730 static ssize_t
4731 array_size_store(struct mddev *mddev, const char *buf, size_t len)
4732 {
4733 sector_t sectors;
4734 int err;
4735
4736 err = mddev_lock(mddev);
4737 if (err)
4738 return err;
4739
4740 if (strncmp(buf, "default", 7) == 0) {
4741 if (mddev->pers)
4742 sectors = mddev->pers->size(mddev, 0, 0);
4743 else
4744 sectors = mddev->array_sectors;
4745
4746 mddev->external_size = 0;
4747 } else {
4748 if (strict_blocks_to_sectors(buf, &sectors) < 0)
4749 err = -EINVAL;
4750 else if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
4751 err = -E2BIG;
4752 else
4753 mddev->external_size = 1;
4754 }
4755
4756 if (!err) {
4757 mddev->array_sectors = sectors;
4758 if (mddev->pers) {
4759 set_capacity(mddev->gendisk, mddev->array_sectors);
4760 revalidate_disk(mddev->gendisk);
4761 }
4762 }
4763 mddev_unlock(mddev);
4764 return err ?: len;
4765 }
4766
4767 static struct md_sysfs_entry md_array_size =
4768 __ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
4769 array_size_store);
4770
4771 static struct attribute *md_default_attrs[] = {
4772 &md_level.attr,
4773 &md_layout.attr,
4774 &md_raid_disks.attr,
4775 &md_chunk_size.attr,
4776 &md_size.attr,
4777 &md_resync_start.attr,
4778 &md_metadata.attr,
4779 &md_new_device.attr,
4780 &md_safe_delay.attr,
4781 &md_array_state.attr,
4782 &md_reshape_position.attr,
4783 &md_reshape_direction.attr,
4784 &md_array_size.attr,
4785 &max_corr_read_errors.attr,
4786 NULL,
4787 };
4788
4789 static struct attribute *md_redundancy_attrs[] = {
4790 &md_scan_mode.attr,
4791 &md_last_scan_mode.attr,
4792 &md_mismatches.attr,
4793 &md_sync_min.attr,
4794 &md_sync_max.attr,
4795 &md_sync_speed.attr,
4796 &md_sync_force_parallel.attr,
4797 &md_sync_completed.attr,
4798 &md_min_sync.attr,
4799 &md_max_sync.attr,
4800 &md_suspend_lo.attr,
4801 &md_suspend_hi.attr,
4802 &md_bitmap.attr,
4803 &md_degraded.attr,
4804 NULL,
4805 };
4806 static struct attribute_group md_redundancy_group = {
4807 .name = NULL,
4808 .attrs = md_redundancy_attrs,
4809 };
4810
4811 static ssize_t
4812 md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
4813 {
4814 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
4815 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
4816 ssize_t rv;
4817
4818 if (!entry->show)
4819 return -EIO;
4820 spin_lock(&all_mddevs_lock);
4821 if (list_empty(&mddev->all_mddevs)) {
4822 spin_unlock(&all_mddevs_lock);
4823 return -EBUSY;
4824 }
4825 mddev_get(mddev);
4826 spin_unlock(&all_mddevs_lock);
4827
4828 rv = entry->show(mddev, page);
4829 mddev_put(mddev);
4830 return rv;
4831 }
4832
4833 static ssize_t
4834 md_attr_store(struct kobject *kobj, struct attribute *attr,
4835 const char *page, size_t length)
4836 {
4837 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
4838 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
4839 ssize_t rv;
4840
4841 if (!entry->store)
4842 return -EIO;
4843 if (!capable(CAP_SYS_ADMIN))
4844 return -EACCES;
4845 spin_lock(&all_mddevs_lock);
4846 if (list_empty(&mddev->all_mddevs)) {
4847 spin_unlock(&all_mddevs_lock);
4848 return -EBUSY;
4849 }
4850 mddev_get(mddev);
4851 spin_unlock(&all_mddevs_lock);
4852 rv = entry->store(mddev, page, length);
4853 mddev_put(mddev);
4854 return rv;
4855 }
4856
4857 static void md_free(struct kobject *ko)
4858 {
4859 struct mddev *mddev = container_of(ko, struct mddev, kobj);
4860
4861 if (mddev->sysfs_state)
4862 sysfs_put(mddev->sysfs_state);
4863
4864 if (mddev->queue)
4865 blk_cleanup_queue(mddev->queue);
4866 if (mddev->gendisk) {
4867 del_gendisk(mddev->gendisk);
4868 put_disk(mddev->gendisk);
4869 }
4870
4871 kfree(mddev);
4872 }
4873
4874 static const struct sysfs_ops md_sysfs_ops = {
4875 .show = md_attr_show,
4876 .store = md_attr_store,
4877 };
4878 static struct kobj_type md_ktype = {
4879 .release = md_free,
4880 .sysfs_ops = &md_sysfs_ops,
4881 .default_attrs = md_default_attrs,
4882 };
4883
4884 int mdp_major = 0;
4885
4886 static void mddev_delayed_delete(struct work_struct *ws)
4887 {
4888 struct mddev *mddev = container_of(ws, struct mddev, del_work);
4889
4890 sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
4891 kobject_del(&mddev->kobj);
4892 kobject_put(&mddev->kobj);
4893 }
4894
4895 static int md_alloc(dev_t dev, char *name)
4896 {
4897 static DEFINE_MUTEX(disks_mutex);
4898 struct mddev *mddev = mddev_find(dev);
4899 struct gendisk *disk;
4900 int partitioned;
4901 int shift;
4902 int unit;
4903 int error;
4904
4905 if (!mddev)
4906 return -ENODEV;
4907
4908 partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
4909 shift = partitioned ? MdpMinorShift : 0;
4910 unit = MINOR(mddev->unit) >> shift;
4911
4912 /* wait for any previous instance of this device to be
4913 * completely removed (mddev_delayed_delete).
4914 */
4915 flush_workqueue(md_misc_wq);
4916
4917 mutex_lock(&disks_mutex);
4918 error = -EEXIST;
4919 if (mddev->gendisk)
4920 goto abort;
4921
4922 if (name) {
4923 /* Need to ensure that 'name' is not a duplicate.
4924 */
4925 struct mddev *mddev2;
4926 spin_lock(&all_mddevs_lock);
4927
4928 list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
4929 if (mddev2->gendisk &&
4930 strcmp(mddev2->gendisk->disk_name, name) == 0) {
4931 spin_unlock(&all_mddevs_lock);
4932 goto abort;
4933 }
4934 spin_unlock(&all_mddevs_lock);
4935 }
4936
4937 error = -ENOMEM;
4938 mddev->queue = blk_alloc_queue(GFP_KERNEL);
4939 if (!mddev->queue)
4940 goto abort;
4941 mddev->queue->queuedata = mddev;
4942
4943 blk_queue_make_request(mddev->queue, md_make_request);
4944 blk_set_stacking_limits(&mddev->queue->limits);
4945
4946 disk = alloc_disk(1 << shift);
4947 if (!disk) {
4948 blk_cleanup_queue(mddev->queue);
4949 mddev->queue = NULL;
4950 goto abort;
4951 }
4952 disk->major = MAJOR(mddev->unit);
4953 disk->first_minor = unit << shift;
4954 if (name)
4955 strcpy(disk->disk_name, name);
4956 else if (partitioned)
4957 sprintf(disk->disk_name, "md_d%d", unit);
4958 else
4959 sprintf(disk->disk_name, "md%d", unit);
4960 disk->fops = &md_fops;
4961 disk->private_data = mddev;
4962 disk->queue = mddev->queue;
4963 blk_queue_flush(mddev->queue, REQ_FLUSH | REQ_FUA);
4964 /* Allow extended partitions. This makes the
4965 * 'mdp' device redundant, but we can't really
4966 * remove it now.
4967 */
4968 disk->flags |= GENHD_FL_EXT_DEVT;
4969 mddev->gendisk = disk;
4970 /* As soon as we call add_disk(), another thread could get
4971 * through to md_open, so make sure it doesn't get too far
4972 */
4973 mutex_lock(&mddev->open_mutex);
4974 add_disk(disk);
4975
4976 error = kobject_init_and_add(&mddev->kobj, &md_ktype,
4977 &disk_to_dev(disk)->kobj, "%s", "md");
4978 if (error) {
4979 /* This isn't possible, but as kobject_init_and_add is marked
4980 * __must_check, we must do something with the result
4981 */
4982 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
4983 disk->disk_name);
4984 error = 0;
4985 }
4986 if (mddev->kobj.sd &&
4987 sysfs_create_group(&mddev->kobj, &md_bitmap_group))
4988 printk(KERN_DEBUG "pointless warning\n");
4989 mutex_unlock(&mddev->open_mutex);
4990 abort:
4991 mutex_unlock(&disks_mutex);
4992 if (!error && mddev->kobj.sd) {
4993 kobject_uevent(&mddev->kobj, KOBJ_ADD);
4994 mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
4995 }
4996 mddev_put(mddev);
4997 return error;
4998 }
4999
5000 static struct kobject *md_probe(dev_t dev, int *part, void *data)
5001 {
5002 md_alloc(dev, NULL);
5003 return NULL;
5004 }
5005
5006 static int add_named_array(const char *val, struct kernel_param *kp)
5007 {
5008 /* val must be "md_*" where * is not all digits.
5009 * We allocate an array with a large free minor number, and
5010 * set the name to val. val must not already be an active name.
5011 */
5012 int len = strlen(val);
5013 char buf[DISK_NAME_LEN];
5014
5015 while (len && val[len-1] == '\n')
5016 len--;
5017 if (len >= DISK_NAME_LEN)
5018 return -E2BIG;
5019 strlcpy(buf, val, len+1);
5020 if (strncmp(buf, "md_", 3) != 0)
5021 return -EINVAL;
5022 return md_alloc(0, buf);
5023 }
5024
5025 static void md_safemode_timeout(unsigned long data)
5026 {
5027 struct mddev *mddev = (struct mddev *) data;
5028
5029 if (!atomic_read(&mddev->writes_pending)) {
5030 mddev->safemode = 1;
5031 if (mddev->external)
5032 sysfs_notify_dirent_safe(mddev->sysfs_state);
5033 }
5034 md_wakeup_thread(mddev->thread);
5035 }
5036
5037 static int start_dirty_degraded;
5038
5039 int md_run(struct mddev *mddev)
5040 {
5041 int err;
5042 struct md_rdev *rdev;
5043 struct md_personality *pers;
5044
5045 if (list_empty(&mddev->disks))
5046 /* cannot run an array with no devices.. */
5047 return -EINVAL;
5048
5049 if (mddev->pers)
5050 return -EBUSY;
5051 /* Cannot run until previous stop completes properly */
5052 if (mddev->sysfs_active)
5053 return -EBUSY;
5054
5055 /*
5056 * Analyze all RAID superblock(s)
5057 */
5058 if (!mddev->raid_disks) {
5059 if (!mddev->persistent)
5060 return -EINVAL;
5061 analyze_sbs(mddev);
5062 }
5063
5064 if (mddev->level != LEVEL_NONE)
5065 request_module("md-level-%d", mddev->level);
5066 else if (mddev->clevel[0])
5067 request_module("md-%s", mddev->clevel);
5068
5069 /*
5070 * Drop all container device buffers, from now on
5071 * the only valid external interface is through the md
5072 * device.
5073 */
5074 rdev_for_each(rdev, mddev) {
5075 if (test_bit(Faulty, &rdev->flags))
5076 continue;
5077 sync_blockdev(rdev->bdev);
5078 invalidate_bdev(rdev->bdev);
5079
5080 /* perform some consistency tests on the device.
5081 * We don't want the data to overlap the metadata,
5082 * Internal Bitmap issues have been handled elsewhere.
5083 */
5084 if (rdev->meta_bdev) {
5085 /* Nothing to check */;
5086 } else if (rdev->data_offset < rdev->sb_start) {
5087 if (mddev->dev_sectors &&
5088 rdev->data_offset + mddev->dev_sectors
5089 > rdev->sb_start) {
5090 printk("md: %s: data overlaps metadata\n",
5091 mdname(mddev));
5092 return -EINVAL;
5093 }
5094 } else {
5095 if (rdev->sb_start + rdev->sb_size/512
5096 > rdev->data_offset) {
5097 printk("md: %s: metadata overlaps data\n",
5098 mdname(mddev));
5099 return -EINVAL;
5100 }
5101 }
5102 sysfs_notify_dirent_safe(rdev->sysfs_state);
5103 }
5104
5105 if (mddev->bio_set == NULL)
5106 mddev->bio_set = bioset_create(BIO_POOL_SIZE, 0);
5107
5108 spin_lock(&pers_lock);
5109 pers = find_pers(mddev->level, mddev->clevel);
5110 if (!pers || !try_module_get(pers->owner)) {
5111 spin_unlock(&pers_lock);
5112 if (mddev->level != LEVEL_NONE)
5113 printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
5114 mddev->level);
5115 else
5116 printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
5117 mddev->clevel);
5118 return -EINVAL;
5119 }
5120 spin_unlock(&pers_lock);
5121 if (mddev->level != pers->level) {
5122 mddev->level = pers->level;
5123 mddev->new_level = pers->level;
5124 }
5125 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
5126
5127 if (mddev->reshape_position != MaxSector &&
5128 pers->start_reshape == NULL) {
5129 /* This personality cannot handle reshaping... */
5130 module_put(pers->owner);
5131 return -EINVAL;
5132 }
5133
5134 if (pers->sync_request) {
5135 /* Warn if this is a potentially silly
5136 * configuration.
5137 */
5138 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
5139 struct md_rdev *rdev2;
5140 int warned = 0;
5141
5142 rdev_for_each(rdev, mddev)
5143 rdev_for_each(rdev2, mddev) {
5144 if (rdev < rdev2 &&
5145 rdev->bdev->bd_contains ==
5146 rdev2->bdev->bd_contains) {
5147 printk(KERN_WARNING
5148 "%s: WARNING: %s appears to be"
5149 " on the same physical disk as"
5150 " %s.\n",
5151 mdname(mddev),
5152 bdevname(rdev->bdev,b),
5153 bdevname(rdev2->bdev,b2));
5154 warned = 1;
5155 }
5156 }
5157
5158 if (warned)
5159 printk(KERN_WARNING
5160 "True protection against single-disk"
5161 " failure might be compromised.\n");
5162 }
5163
5164 mddev->recovery = 0;
5165 /* may be over-ridden by personality */
5166 mddev->resync_max_sectors = mddev->dev_sectors;
5167
5168 mddev->ok_start_degraded = start_dirty_degraded;
5169
5170 if (start_readonly && mddev->ro == 0)
5171 mddev->ro = 2; /* read-only, but switch on first write */
5172
5173 err = pers->run(mddev);
5174 if (err)
5175 printk(KERN_ERR "md: pers->run() failed ...\n");
5176 else if (pers->size(mddev, 0, 0) < mddev->array_sectors) {
5177 WARN_ONCE(!mddev->external_size, "%s: default size too small,"
5178 " but 'external_size' not in effect?\n", __func__);
5179 printk(KERN_ERR
5180 "md: invalid array_size %llu > default size %llu\n",
5181 (unsigned long long)mddev->array_sectors / 2,
5182 (unsigned long long)pers->size(mddev, 0, 0) / 2);
5183 err = -EINVAL;
5184 }
5185 if (err == 0 && pers->sync_request &&
5186 (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
5187 struct bitmap *bitmap;
5188
5189 bitmap = bitmap_create(mddev, -1);
5190 if (IS_ERR(bitmap)) {
5191 err = PTR_ERR(bitmap);
5192 printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
5193 mdname(mddev), err);
5194 } else
5195 mddev->bitmap = bitmap;
5196
5197 }
5198 if (err) {
5199 mddev_detach(mddev);
5200 if (mddev->private)
5201 pers->free(mddev, mddev->private);
5202 mddev->private = NULL;
5203 module_put(pers->owner);
5204 bitmap_destroy(mddev);
5205 return err;
5206 }
5207 if (mddev->queue) {
5208 mddev->queue->backing_dev_info.congested_data = mddev;
5209 mddev->queue->backing_dev_info.congested_fn = md_congested;
5210 }
5211 if (pers->sync_request) {
5212 if (mddev->kobj.sd &&
5213 sysfs_create_group(&mddev->kobj, &md_redundancy_group))
5214 printk(KERN_WARNING
5215 "md: cannot register extra attributes for %s\n",
5216 mdname(mddev));
5217 mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
5218 } else if (mddev->ro == 2) /* auto-readonly not meaningful */
5219 mddev->ro = 0;
5220
5221 atomic_set(&mddev->writes_pending,0);
5222 atomic_set(&mddev->max_corr_read_errors,
5223 MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
5224 mddev->safemode = 0;
5225 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
5226 mddev->in_sync = 1;
5227 smp_wmb();
5228 spin_lock(&mddev->lock);
5229 mddev->pers = pers;
5230 mddev->ready = 1;
5231 spin_unlock(&mddev->lock);
5232 rdev_for_each(rdev, mddev)
5233 if (rdev->raid_disk >= 0)
5234 if (sysfs_link_rdev(mddev, rdev))
5235 /* failure here is OK */;
5236
5237 if (mddev->degraded && !mddev->ro)
5238 /* This ensures that recovering status is reported immediately
5239 * via sysfs - until a lack of spares is confirmed.
5240 */
5241 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
5242 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5243
5244 if (mddev->flags & MD_UPDATE_SB_FLAGS)
5245 md_update_sb(mddev, 0);
5246
5247 md_new_event(mddev);
5248 sysfs_notify_dirent_safe(mddev->sysfs_state);
5249 sysfs_notify_dirent_safe(mddev->sysfs_action);
5250 sysfs_notify(&mddev->kobj, NULL, "degraded");
5251 return 0;
5252 }
5253 EXPORT_SYMBOL_GPL(md_run);
5254
5255 static int do_md_run(struct mddev *mddev)
5256 {
5257 int err;
5258
5259 err = md_run(mddev);
5260 if (err)
5261 goto out;
5262 err = bitmap_load(mddev);
5263 if (err) {
5264 bitmap_destroy(mddev);
5265 goto out;
5266 }
5267
5268 md_wakeup_thread(mddev->thread);
5269 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
5270
5271 set_capacity(mddev->gendisk, mddev->array_sectors);
5272 revalidate_disk(mddev->gendisk);
5273 mddev->changed = 1;
5274 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
5275 out:
5276 return err;
5277 }
5278
5279 static int restart_array(struct mddev *mddev)
5280 {
5281 struct gendisk *disk = mddev->gendisk;
5282
5283 /* Complain if it has no devices */
5284 if (list_empty(&mddev->disks))
5285 return -ENXIO;
5286 if (!mddev->pers)
5287 return -EINVAL;
5288 if (!mddev->ro)
5289 return -EBUSY;
5290 mddev->safemode = 0;
5291 mddev->ro = 0;
5292 set_disk_ro(disk, 0);
5293 printk(KERN_INFO "md: %s switched to read-write mode.\n",
5294 mdname(mddev));
5295 /* Kick recovery or resync if necessary */
5296 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5297 md_wakeup_thread(mddev->thread);
5298 md_wakeup_thread(mddev->sync_thread);
5299 sysfs_notify_dirent_safe(mddev->sysfs_state);
5300 return 0;
5301 }
5302
5303 static void md_clean(struct mddev *mddev)
5304 {
5305 mddev->array_sectors = 0;
5306 mddev->external_size = 0;
5307 mddev->dev_sectors = 0;
5308 mddev->raid_disks = 0;
5309 mddev->recovery_cp = 0;
5310 mddev->resync_min = 0;
5311 mddev->resync_max = MaxSector;
5312 mddev->reshape_position = MaxSector;
5313 mddev->external = 0;
5314 mddev->persistent = 0;
5315 mddev->level = LEVEL_NONE;
5316 mddev->clevel[0] = 0;
5317 mddev->flags = 0;
5318 mddev->ro = 0;
5319 mddev->metadata_type[0] = 0;
5320 mddev->chunk_sectors = 0;
5321 mddev->ctime = mddev->utime = 0;
5322 mddev->layout = 0;
5323 mddev->max_disks = 0;
5324 mddev->events = 0;
5325 mddev->can_decrease_events = 0;
5326 mddev->delta_disks = 0;
5327 mddev->reshape_backwards = 0;
5328 mddev->new_level = LEVEL_NONE;
5329 mddev->new_layout = 0;
5330 mddev->new_chunk_sectors = 0;
5331 mddev->curr_resync = 0;
5332 atomic64_set(&mddev->resync_mismatches, 0);
5333 mddev->suspend_lo = mddev->suspend_hi = 0;
5334 mddev->sync_speed_min = mddev->sync_speed_max = 0;
5335 mddev->recovery = 0;
5336 mddev->in_sync = 0;
5337 mddev->changed = 0;
5338 mddev->degraded = 0;
5339 mddev->safemode = 0;
5340 mddev->private = NULL;
5341 mddev->bitmap_info.offset = 0;
5342 mddev->bitmap_info.default_offset = 0;
5343 mddev->bitmap_info.default_space = 0;
5344 mddev->bitmap_info.chunksize = 0;
5345 mddev->bitmap_info.daemon_sleep = 0;
5346 mddev->bitmap_info.max_write_behind = 0;
5347 }
5348
5349 static void __md_stop_writes(struct mddev *mddev)
5350 {
5351 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5352 flush_workqueue(md_misc_wq);
5353 if (mddev->sync_thread) {
5354 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5355 md_reap_sync_thread(mddev);
5356 }
5357
5358 del_timer_sync(&mddev->safemode_timer);
5359
5360 bitmap_flush(mddev);
5361 md_super_wait(mddev);
5362
5363 if (mddev->ro == 0 &&
5364 (!mddev->in_sync || (mddev->flags & MD_UPDATE_SB_FLAGS))) {
5365 /* mark array as shutdown cleanly */
5366 mddev->in_sync = 1;
5367 md_update_sb(mddev, 1);
5368 }
5369 }
5370
5371 void md_stop_writes(struct mddev *mddev)
5372 {
5373 mddev_lock_nointr(mddev);
5374 __md_stop_writes(mddev);
5375 mddev_unlock(mddev);
5376 }
5377 EXPORT_SYMBOL_GPL(md_stop_writes);
5378
5379 static void mddev_detach(struct mddev *mddev)
5380 {
5381 struct bitmap *bitmap = mddev->bitmap;
5382 /* wait for behind writes to complete */
5383 if (bitmap && atomic_read(&bitmap->behind_writes) > 0) {
5384 printk(KERN_INFO "md:%s: behind writes in progress - waiting to stop.\n",
5385 mdname(mddev));
5386 /* need to kick something here to make sure I/O goes? */
5387 wait_event(bitmap->behind_wait,
5388 atomic_read(&bitmap->behind_writes) == 0);
5389 }
5390 if (mddev->pers && mddev->pers->quiesce) {
5391 mddev->pers->quiesce(mddev, 1);
5392 mddev->pers->quiesce(mddev, 0);
5393 }
5394 md_unregister_thread(&mddev->thread);
5395 if (mddev->queue)
5396 blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
5397 }
5398
5399 static void __md_stop(struct mddev *mddev)
5400 {
5401 struct md_personality *pers = mddev->pers;
5402 mddev_detach(mddev);
5403 /* Ensure ->event_work is done */
5404 flush_workqueue(md_misc_wq);
5405 spin_lock(&mddev->lock);
5406 mddev->ready = 0;
5407 mddev->pers = NULL;
5408 spin_unlock(&mddev->lock);
5409 pers->free(mddev, mddev->private);
5410 mddev->private = NULL;
5411 if (pers->sync_request && mddev->to_remove == NULL)
5412 mddev->to_remove = &md_redundancy_group;
5413 module_put(pers->owner);
5414 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5415 }
5416
5417 void md_stop(struct mddev *mddev)
5418 {
5419 /* stop the array and free an attached data structures.
5420 * This is called from dm-raid
5421 */
5422 __md_stop(mddev);
5423 bitmap_destroy(mddev);
5424 if (mddev->bio_set)
5425 bioset_free(mddev->bio_set);
5426 }
5427
5428 EXPORT_SYMBOL_GPL(md_stop);
5429
5430 static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
5431 {
5432 int err = 0;
5433 int did_freeze = 0;
5434
5435 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
5436 did_freeze = 1;
5437 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5438 md_wakeup_thread(mddev->thread);
5439 }
5440 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5441 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5442 if (mddev->sync_thread)
5443 /* Thread might be blocked waiting for metadata update
5444 * which will now never happen */
5445 wake_up_process(mddev->sync_thread->tsk);
5446
5447 if (mddev->external && test_bit(MD_CHANGE_PENDING, &mddev->flags))
5448 return -EBUSY;
5449 mddev_unlock(mddev);
5450 wait_event(resync_wait, !test_bit(MD_RECOVERY_RUNNING,
5451 &mddev->recovery));
5452 wait_event(mddev->sb_wait,
5453 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
5454 mddev_lock_nointr(mddev);
5455
5456 mutex_lock(&mddev->open_mutex);
5457 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
5458 mddev->sync_thread ||
5459 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
5460 (bdev && !test_bit(MD_STILL_CLOSED, &mddev->flags))) {
5461 printk("md: %s still in use.\n",mdname(mddev));
5462 if (did_freeze) {
5463 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5464 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5465 md_wakeup_thread(mddev->thread);
5466 }
5467 err = -EBUSY;
5468 goto out;
5469 }
5470 if (mddev->pers) {
5471 __md_stop_writes(mddev);
5472
5473 err = -ENXIO;
5474 if (mddev->ro==1)
5475 goto out;
5476 mddev->ro = 1;
5477 set_disk_ro(mddev->gendisk, 1);
5478 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5479 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5480 md_wakeup_thread(mddev->thread);
5481 sysfs_notify_dirent_safe(mddev->sysfs_state);
5482 err = 0;
5483 }
5484 out:
5485 mutex_unlock(&mddev->open_mutex);
5486 return err;
5487 }
5488
5489 /* mode:
5490 * 0 - completely stop and dis-assemble array
5491 * 2 - stop but do not disassemble array
5492 */
5493 static int do_md_stop(struct mddev *mddev, int mode,
5494 struct block_device *bdev)
5495 {
5496 struct gendisk *disk = mddev->gendisk;
5497 struct md_rdev *rdev;
5498 int did_freeze = 0;
5499
5500 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
5501 did_freeze = 1;
5502 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5503 md_wakeup_thread(mddev->thread);
5504 }
5505 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5506 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5507 if (mddev->sync_thread)
5508 /* Thread might be blocked waiting for metadata update
5509 * which will now never happen */
5510 wake_up_process(mddev->sync_thread->tsk);
5511
5512 mddev_unlock(mddev);
5513 wait_event(resync_wait, (mddev->sync_thread == NULL &&
5514 !test_bit(MD_RECOVERY_RUNNING,
5515 &mddev->recovery)));
5516 mddev_lock_nointr(mddev);
5517
5518 mutex_lock(&mddev->open_mutex);
5519 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
5520 mddev->sysfs_active ||
5521 mddev->sync_thread ||
5522 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
5523 (bdev && !test_bit(MD_STILL_CLOSED, &mddev->flags))) {
5524 printk("md: %s still in use.\n",mdname(mddev));
5525 mutex_unlock(&mddev->open_mutex);
5526 if (did_freeze) {
5527 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5528 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5529 md_wakeup_thread(mddev->thread);
5530 }
5531 return -EBUSY;
5532 }
5533 if (mddev->pers) {
5534 if (mddev->ro)
5535 set_disk_ro(disk, 0);
5536
5537 __md_stop_writes(mddev);
5538 __md_stop(mddev);
5539 mddev->queue->backing_dev_info.congested_fn = NULL;
5540
5541 /* tell userspace to handle 'inactive' */
5542 sysfs_notify_dirent_safe(mddev->sysfs_state);
5543
5544 rdev_for_each(rdev, mddev)
5545 if (rdev->raid_disk >= 0)
5546 sysfs_unlink_rdev(mddev, rdev);
5547
5548 set_capacity(disk, 0);
5549 mutex_unlock(&mddev->open_mutex);
5550 mddev->changed = 1;
5551 revalidate_disk(disk);
5552
5553 if (mddev->ro)
5554 mddev->ro = 0;
5555 } else
5556 mutex_unlock(&mddev->open_mutex);
5557 /*
5558 * Free resources if final stop
5559 */
5560 if (mode == 0) {
5561 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
5562
5563 bitmap_destroy(mddev);
5564 if (mddev->bitmap_info.file) {
5565 struct file *f = mddev->bitmap_info.file;
5566 spin_lock(&mddev->lock);
5567 mddev->bitmap_info.file = NULL;
5568 spin_unlock(&mddev->lock);
5569 fput(f);
5570 }
5571 mddev->bitmap_info.offset = 0;
5572
5573 export_array(mddev);
5574
5575 md_clean(mddev);
5576 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
5577 if (mddev->hold_active == UNTIL_STOP)
5578 mddev->hold_active = 0;
5579 }
5580 blk_integrity_unregister(disk);
5581 md_new_event(mddev);
5582 sysfs_notify_dirent_safe(mddev->sysfs_state);
5583 return 0;
5584 }
5585
5586 #ifndef MODULE
5587 static void autorun_array(struct mddev *mddev)
5588 {
5589 struct md_rdev *rdev;
5590 int err;
5591
5592 if (list_empty(&mddev->disks))
5593 return;
5594
5595 printk(KERN_INFO "md: running: ");
5596
5597 rdev_for_each(rdev, mddev) {
5598 char b[BDEVNAME_SIZE];
5599 printk("<%s>", bdevname(rdev->bdev,b));
5600 }
5601 printk("\n");
5602
5603 err = do_md_run(mddev);
5604 if (err) {
5605 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
5606 do_md_stop(mddev, 0, NULL);
5607 }
5608 }
5609
5610 /*
5611 * lets try to run arrays based on all disks that have arrived
5612 * until now. (those are in pending_raid_disks)
5613 *
5614 * the method: pick the first pending disk, collect all disks with
5615 * the same UUID, remove all from the pending list and put them into
5616 * the 'same_array' list. Then order this list based on superblock
5617 * update time (freshest comes first), kick out 'old' disks and
5618 * compare superblocks. If everything's fine then run it.
5619 *
5620 * If "unit" is allocated, then bump its reference count
5621 */
5622 static void autorun_devices(int part)
5623 {
5624 struct md_rdev *rdev0, *rdev, *tmp;
5625 struct mddev *mddev;
5626 char b[BDEVNAME_SIZE];
5627
5628 printk(KERN_INFO "md: autorun ...\n");
5629 while (!list_empty(&pending_raid_disks)) {
5630 int unit;
5631 dev_t dev;
5632 LIST_HEAD(candidates);
5633 rdev0 = list_entry(pending_raid_disks.next,
5634 struct md_rdev, same_set);
5635
5636 printk(KERN_INFO "md: considering %s ...\n",
5637 bdevname(rdev0->bdev,b));
5638 INIT_LIST_HEAD(&candidates);
5639 rdev_for_each_list(rdev, tmp, &pending_raid_disks)
5640 if (super_90_load(rdev, rdev0, 0) >= 0) {
5641 printk(KERN_INFO "md: adding %s ...\n",
5642 bdevname(rdev->bdev,b));
5643 list_move(&rdev->same_set, &candidates);
5644 }
5645 /*
5646 * now we have a set of devices, with all of them having
5647 * mostly sane superblocks. It's time to allocate the
5648 * mddev.
5649 */
5650 if (part) {
5651 dev = MKDEV(mdp_major,
5652 rdev0->preferred_minor << MdpMinorShift);
5653 unit = MINOR(dev) >> MdpMinorShift;
5654 } else {
5655 dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
5656 unit = MINOR(dev);
5657 }
5658 if (rdev0->preferred_minor != unit) {
5659 printk(KERN_INFO "md: unit number in %s is bad: %d\n",
5660 bdevname(rdev0->bdev, b), rdev0->preferred_minor);
5661 break;
5662 }
5663
5664 md_probe(dev, NULL, NULL);
5665 mddev = mddev_find(dev);
5666 if (!mddev || !mddev->gendisk) {
5667 if (mddev)
5668 mddev_put(mddev);
5669 printk(KERN_ERR
5670 "md: cannot allocate memory for md drive.\n");
5671 break;
5672 }
5673 if (mddev_lock(mddev))
5674 printk(KERN_WARNING "md: %s locked, cannot run\n",
5675 mdname(mddev));
5676 else if (mddev->raid_disks || mddev->major_version
5677 || !list_empty(&mddev->disks)) {
5678 printk(KERN_WARNING
5679 "md: %s already running, cannot run %s\n",
5680 mdname(mddev), bdevname(rdev0->bdev,b));
5681 mddev_unlock(mddev);
5682 } else {
5683 printk(KERN_INFO "md: created %s\n", mdname(mddev));
5684 mddev->persistent = 1;
5685 rdev_for_each_list(rdev, tmp, &candidates) {
5686 list_del_init(&rdev->same_set);
5687 if (bind_rdev_to_array(rdev, mddev))
5688 export_rdev(rdev);
5689 }
5690 autorun_array(mddev);
5691 mddev_unlock(mddev);
5692 }
5693 /* on success, candidates will be empty, on error
5694 * it won't...
5695 */
5696 rdev_for_each_list(rdev, tmp, &candidates) {
5697 list_del_init(&rdev->same_set);
5698 export_rdev(rdev);
5699 }
5700 mddev_put(mddev);
5701 }
5702 printk(KERN_INFO "md: ... autorun DONE.\n");
5703 }
5704 #endif /* !MODULE */
5705
5706 static int get_version(void __user *arg)
5707 {
5708 mdu_version_t ver;
5709
5710 ver.major = MD_MAJOR_VERSION;
5711 ver.minor = MD_MINOR_VERSION;
5712 ver.patchlevel = MD_PATCHLEVEL_VERSION;
5713
5714 if (copy_to_user(arg, &ver, sizeof(ver)))
5715 return -EFAULT;
5716
5717 return 0;
5718 }
5719
5720 static int get_array_info(struct mddev *mddev, void __user *arg)
5721 {
5722 mdu_array_info_t info;
5723 int nr,working,insync,failed,spare;
5724 struct md_rdev *rdev;
5725
5726 nr = working = insync = failed = spare = 0;
5727 rcu_read_lock();
5728 rdev_for_each_rcu(rdev, mddev) {
5729 nr++;
5730 if (test_bit(Faulty, &rdev->flags))
5731 failed++;
5732 else {
5733 working++;
5734 if (test_bit(In_sync, &rdev->flags))
5735 insync++;
5736 else
5737 spare++;
5738 }
5739 }
5740 rcu_read_unlock();
5741
5742 info.major_version = mddev->major_version;
5743 info.minor_version = mddev->minor_version;
5744 info.patch_version = MD_PATCHLEVEL_VERSION;
5745 info.ctime = mddev->ctime;
5746 info.level = mddev->level;
5747 info.size = mddev->dev_sectors / 2;
5748 if (info.size != mddev->dev_sectors / 2) /* overflow */
5749 info.size = -1;
5750 info.nr_disks = nr;
5751 info.raid_disks = mddev->raid_disks;
5752 info.md_minor = mddev->md_minor;
5753 info.not_persistent= !mddev->persistent;
5754
5755 info.utime = mddev->utime;
5756 info.state = 0;
5757 if (mddev->in_sync)
5758 info.state = (1<<MD_SB_CLEAN);
5759 if (mddev->bitmap && mddev->bitmap_info.offset)
5760 info.state |= (1<<MD_SB_BITMAP_PRESENT);
5761 if (mddev_is_clustered(mddev))
5762 info.state |= (1<<MD_SB_CLUSTERED);
5763 info.active_disks = insync;
5764 info.working_disks = working;
5765 info.failed_disks = failed;
5766 info.spare_disks = spare;
5767
5768 info.layout = mddev->layout;
5769 info.chunk_size = mddev->chunk_sectors << 9;
5770
5771 if (copy_to_user(arg, &info, sizeof(info)))
5772 return -EFAULT;
5773
5774 return 0;
5775 }
5776
5777 static int get_bitmap_file(struct mddev *mddev, void __user * arg)
5778 {
5779 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
5780 char *ptr;
5781 int err;
5782
5783 file = kzalloc(sizeof(*file), GFP_NOIO);
5784 if (!file)
5785 return -ENOMEM;
5786
5787 err = 0;
5788 spin_lock(&mddev->lock);
5789 /* bitmap enabled */
5790 if (mddev->bitmap_info.file) {
5791 ptr = file_path(mddev->bitmap_info.file, file->pathname,
5792 sizeof(file->pathname));
5793 if (IS_ERR(ptr))
5794 err = PTR_ERR(ptr);
5795 else
5796 memmove(file->pathname, ptr,
5797 sizeof(file->pathname)-(ptr-file->pathname));
5798 }
5799 spin_unlock(&mddev->lock);
5800
5801 if (err == 0 &&
5802 copy_to_user(arg, file, sizeof(*file)))
5803 err = -EFAULT;
5804
5805 kfree(file);
5806 return err;
5807 }
5808
5809 static int get_disk_info(struct mddev *mddev, void __user * arg)
5810 {
5811 mdu_disk_info_t info;
5812 struct md_rdev *rdev;
5813
5814 if (copy_from_user(&info, arg, sizeof(info)))
5815 return -EFAULT;
5816
5817 rcu_read_lock();
5818 rdev = md_find_rdev_nr_rcu(mddev, info.number);
5819 if (rdev) {
5820 info.major = MAJOR(rdev->bdev->bd_dev);
5821 info.minor = MINOR(rdev->bdev->bd_dev);
5822 info.raid_disk = rdev->raid_disk;
5823 info.state = 0;
5824 if (test_bit(Faulty, &rdev->flags))
5825 info.state |= (1<<MD_DISK_FAULTY);
5826 else if (test_bit(In_sync, &rdev->flags)) {
5827 info.state |= (1<<MD_DISK_ACTIVE);
5828 info.state |= (1<<MD_DISK_SYNC);
5829 }
5830 if (test_bit(WriteMostly, &rdev->flags))
5831 info.state |= (1<<MD_DISK_WRITEMOSTLY);
5832 } else {
5833 info.major = info.minor = 0;
5834 info.raid_disk = -1;
5835 info.state = (1<<MD_DISK_REMOVED);
5836 }
5837 rcu_read_unlock();
5838
5839 if (copy_to_user(arg, &info, sizeof(info)))
5840 return -EFAULT;
5841
5842 return 0;
5843 }
5844
5845 static int add_new_disk(struct mddev *mddev, mdu_disk_info_t *info)
5846 {
5847 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
5848 struct md_rdev *rdev;
5849 dev_t dev = MKDEV(info->major,info->minor);
5850
5851 if (mddev_is_clustered(mddev) &&
5852 !(info->state & ((1 << MD_DISK_CLUSTER_ADD) | (1 << MD_DISK_CANDIDATE)))) {
5853 pr_err("%s: Cannot add to clustered mddev.\n",
5854 mdname(mddev));
5855 return -EINVAL;
5856 }
5857
5858 if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
5859 return -EOVERFLOW;
5860
5861 if (!mddev->raid_disks) {
5862 int err;
5863 /* expecting a device which has a superblock */
5864 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
5865 if (IS_ERR(rdev)) {
5866 printk(KERN_WARNING
5867 "md: md_import_device returned %ld\n",
5868 PTR_ERR(rdev));
5869 return PTR_ERR(rdev);
5870 }
5871 if (!list_empty(&mddev->disks)) {
5872 struct md_rdev *rdev0
5873 = list_entry(mddev->disks.next,
5874 struct md_rdev, same_set);
5875 err = super_types[mddev->major_version]
5876 .load_super(rdev, rdev0, mddev->minor_version);
5877 if (err < 0) {
5878 printk(KERN_WARNING
5879 "md: %s has different UUID to %s\n",
5880 bdevname(rdev->bdev,b),
5881 bdevname(rdev0->bdev,b2));
5882 export_rdev(rdev);
5883 return -EINVAL;
5884 }
5885 }
5886 err = bind_rdev_to_array(rdev, mddev);
5887 if (err)
5888 export_rdev(rdev);
5889 return err;
5890 }
5891
5892 /*
5893 * add_new_disk can be used once the array is assembled
5894 * to add "hot spares". They must already have a superblock
5895 * written
5896 */
5897 if (mddev->pers) {
5898 int err;
5899 if (!mddev->pers->hot_add_disk) {
5900 printk(KERN_WARNING
5901 "%s: personality does not support diskops!\n",
5902 mdname(mddev));
5903 return -EINVAL;
5904 }
5905 if (mddev->persistent)
5906 rdev = md_import_device(dev, mddev->major_version,
5907 mddev->minor_version);
5908 else
5909 rdev = md_import_device(dev, -1, -1);
5910 if (IS_ERR(rdev)) {
5911 printk(KERN_WARNING
5912 "md: md_import_device returned %ld\n",
5913 PTR_ERR(rdev));
5914 return PTR_ERR(rdev);
5915 }
5916 /* set saved_raid_disk if appropriate */
5917 if (!mddev->persistent) {
5918 if (info->state & (1<<MD_DISK_SYNC) &&
5919 info->raid_disk < mddev->raid_disks) {
5920 rdev->raid_disk = info->raid_disk;
5921 set_bit(In_sync, &rdev->flags);
5922 clear_bit(Bitmap_sync, &rdev->flags);
5923 } else
5924 rdev->raid_disk = -1;
5925 rdev->saved_raid_disk = rdev->raid_disk;
5926 } else
5927 super_types[mddev->major_version].
5928 validate_super(mddev, rdev);
5929 if ((info->state & (1<<MD_DISK_SYNC)) &&
5930 rdev->raid_disk != info->raid_disk) {
5931 /* This was a hot-add request, but events doesn't
5932 * match, so reject it.
5933 */
5934 export_rdev(rdev);
5935 return -EINVAL;
5936 }
5937
5938 clear_bit(In_sync, &rdev->flags); /* just to be sure */
5939 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
5940 set_bit(WriteMostly, &rdev->flags);
5941 else
5942 clear_bit(WriteMostly, &rdev->flags);
5943
5944 /*
5945 * check whether the device shows up in other nodes
5946 */
5947 if (mddev_is_clustered(mddev)) {
5948 if (info->state & (1 << MD_DISK_CANDIDATE))
5949 set_bit(Candidate, &rdev->flags);
5950 else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) {
5951 /* --add initiated by this node */
5952 err = md_cluster_ops->add_new_disk(mddev, rdev);
5953 if (err) {
5954 export_rdev(rdev);
5955 return err;
5956 }
5957 }
5958 }
5959
5960 rdev->raid_disk = -1;
5961 err = bind_rdev_to_array(rdev, mddev);
5962
5963 if (err)
5964 export_rdev(rdev);
5965
5966 if (mddev_is_clustered(mddev)) {
5967 if (info->state & (1 << MD_DISK_CANDIDATE))
5968 md_cluster_ops->new_disk_ack(mddev, (err == 0));
5969 else {
5970 if (err)
5971 md_cluster_ops->add_new_disk_cancel(mddev);
5972 else
5973 err = add_bound_rdev(rdev);
5974 }
5975
5976 } else if (!err)
5977 err = add_bound_rdev(rdev);
5978
5979 return err;
5980 }
5981
5982 /* otherwise, add_new_disk is only allowed
5983 * for major_version==0 superblocks
5984 */
5985 if (mddev->major_version != 0) {
5986 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
5987 mdname(mddev));
5988 return -EINVAL;
5989 }
5990
5991 if (!(info->state & (1<<MD_DISK_FAULTY))) {
5992 int err;
5993 rdev = md_import_device(dev, -1, 0);
5994 if (IS_ERR(rdev)) {
5995 printk(KERN_WARNING
5996 "md: error, md_import_device() returned %ld\n",
5997 PTR_ERR(rdev));
5998 return PTR_ERR(rdev);
5999 }
6000 rdev->desc_nr = info->number;
6001 if (info->raid_disk < mddev->raid_disks)
6002 rdev->raid_disk = info->raid_disk;
6003 else
6004 rdev->raid_disk = -1;
6005
6006 if (rdev->raid_disk < mddev->raid_disks)
6007 if (info->state & (1<<MD_DISK_SYNC))
6008 set_bit(In_sync, &rdev->flags);
6009
6010 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
6011 set_bit(WriteMostly, &rdev->flags);
6012
6013 if (!mddev->persistent) {
6014 printk(KERN_INFO "md: nonpersistent superblock ...\n");
6015 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
6016 } else
6017 rdev->sb_start = calc_dev_sboffset(rdev);
6018 rdev->sectors = rdev->sb_start;
6019
6020 err = bind_rdev_to_array(rdev, mddev);
6021 if (err) {
6022 export_rdev(rdev);
6023 return err;
6024 }
6025 }
6026
6027 return 0;
6028 }
6029
6030 static int hot_remove_disk(struct mddev *mddev, dev_t dev)
6031 {
6032 char b[BDEVNAME_SIZE];
6033 struct md_rdev *rdev;
6034
6035 rdev = find_rdev(mddev, dev);
6036 if (!rdev)
6037 return -ENXIO;
6038
6039 if (mddev_is_clustered(mddev))
6040 md_cluster_ops->metadata_update_start(mddev);
6041
6042 if (rdev->raid_disk < 0)
6043 goto kick_rdev;
6044
6045 clear_bit(Blocked, &rdev->flags);
6046 remove_and_add_spares(mddev, rdev);
6047
6048 if (rdev->raid_disk >= 0)
6049 goto busy;
6050
6051 kick_rdev:
6052 if (mddev_is_clustered(mddev))
6053 md_cluster_ops->remove_disk(mddev, rdev);
6054
6055 md_kick_rdev_from_array(rdev);
6056 md_update_sb(mddev, 1);
6057 md_new_event(mddev);
6058
6059 return 0;
6060 busy:
6061 if (mddev_is_clustered(mddev))
6062 md_cluster_ops->metadata_update_cancel(mddev);
6063
6064 printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
6065 bdevname(rdev->bdev,b), mdname(mddev));
6066 return -EBUSY;
6067 }
6068
6069 static int hot_add_disk(struct mddev *mddev, dev_t dev)
6070 {
6071 char b[BDEVNAME_SIZE];
6072 int err;
6073 struct md_rdev *rdev;
6074
6075 if (!mddev->pers)
6076 return -ENODEV;
6077
6078 if (mddev->major_version != 0) {
6079 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
6080 " version-0 superblocks.\n",
6081 mdname(mddev));
6082 return -EINVAL;
6083 }
6084 if (!mddev->pers->hot_add_disk) {
6085 printk(KERN_WARNING
6086 "%s: personality does not support diskops!\n",
6087 mdname(mddev));
6088 return -EINVAL;
6089 }
6090
6091 rdev = md_import_device(dev, -1, 0);
6092 if (IS_ERR(rdev)) {
6093 printk(KERN_WARNING
6094 "md: error, md_import_device() returned %ld\n",
6095 PTR_ERR(rdev));
6096 return -EINVAL;
6097 }
6098
6099 if (mddev->persistent)
6100 rdev->sb_start = calc_dev_sboffset(rdev);
6101 else
6102 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
6103
6104 rdev->sectors = rdev->sb_start;
6105
6106 if (test_bit(Faulty, &rdev->flags)) {
6107 printk(KERN_WARNING
6108 "md: can not hot-add faulty %s disk to %s!\n",
6109 bdevname(rdev->bdev,b), mdname(mddev));
6110 err = -EINVAL;
6111 goto abort_export;
6112 }
6113
6114 clear_bit(In_sync, &rdev->flags);
6115 rdev->desc_nr = -1;
6116 rdev->saved_raid_disk = -1;
6117 err = bind_rdev_to_array(rdev, mddev);
6118 if (err)
6119 goto abort_export;
6120
6121 /*
6122 * The rest should better be atomic, we can have disk failures
6123 * noticed in interrupt contexts ...
6124 */
6125
6126 rdev->raid_disk = -1;
6127
6128 md_update_sb(mddev, 1);
6129 /*
6130 * Kick recovery, maybe this spare has to be added to the
6131 * array immediately.
6132 */
6133 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6134 md_wakeup_thread(mddev->thread);
6135 md_new_event(mddev);
6136 return 0;
6137
6138 abort_export:
6139 export_rdev(rdev);
6140 return err;
6141 }
6142
6143 static int set_bitmap_file(struct mddev *mddev, int fd)
6144 {
6145 int err = 0;
6146
6147 if (mddev->pers) {
6148 if (!mddev->pers->quiesce || !mddev->thread)
6149 return -EBUSY;
6150 if (mddev->recovery || mddev->sync_thread)
6151 return -EBUSY;
6152 /* we should be able to change the bitmap.. */
6153 }
6154
6155 if (fd >= 0) {
6156 struct inode *inode;
6157 struct file *f;
6158
6159 if (mddev->bitmap || mddev->bitmap_info.file)
6160 return -EEXIST; /* cannot add when bitmap is present */
6161 f = fget(fd);
6162
6163 if (f == NULL) {
6164 printk(KERN_ERR "%s: error: failed to get bitmap file\n",
6165 mdname(mddev));
6166 return -EBADF;
6167 }
6168
6169 inode = f->f_mapping->host;
6170 if (!S_ISREG(inode->i_mode)) {
6171 printk(KERN_ERR "%s: error: bitmap file must be a regular file\n",
6172 mdname(mddev));
6173 err = -EBADF;
6174 } else if (!(f->f_mode & FMODE_WRITE)) {
6175 printk(KERN_ERR "%s: error: bitmap file must open for write\n",
6176 mdname(mddev));
6177 err = -EBADF;
6178 } else if (atomic_read(&inode->i_writecount) != 1) {
6179 printk(KERN_ERR "%s: error: bitmap file is already in use\n",
6180 mdname(mddev));
6181 err = -EBUSY;
6182 }
6183 if (err) {
6184 fput(f);
6185 return err;
6186 }
6187 mddev->bitmap_info.file = f;
6188 mddev->bitmap_info.offset = 0; /* file overrides offset */
6189 } else if (mddev->bitmap == NULL)
6190 return -ENOENT; /* cannot remove what isn't there */
6191 err = 0;
6192 if (mddev->pers) {
6193 mddev->pers->quiesce(mddev, 1);
6194 if (fd >= 0) {
6195 struct bitmap *bitmap;
6196
6197 bitmap = bitmap_create(mddev, -1);
6198 if (!IS_ERR(bitmap)) {
6199 mddev->bitmap = bitmap;
6200 err = bitmap_load(mddev);
6201 } else
6202 err = PTR_ERR(bitmap);
6203 }
6204 if (fd < 0 || err) {
6205 bitmap_destroy(mddev);
6206 fd = -1; /* make sure to put the file */
6207 }
6208 mddev->pers->quiesce(mddev, 0);
6209 }
6210 if (fd < 0) {
6211 struct file *f = mddev->bitmap_info.file;
6212 if (f) {
6213 spin_lock(&mddev->lock);
6214 mddev->bitmap_info.file = NULL;
6215 spin_unlock(&mddev->lock);
6216 fput(f);
6217 }
6218 }
6219
6220 return err;
6221 }
6222
6223 /*
6224 * set_array_info is used two different ways
6225 * The original usage is when creating a new array.
6226 * In this usage, raid_disks is > 0 and it together with
6227 * level, size, not_persistent,layout,chunksize determine the
6228 * shape of the array.
6229 * This will always create an array with a type-0.90.0 superblock.
6230 * The newer usage is when assembling an array.
6231 * In this case raid_disks will be 0, and the major_version field is
6232 * use to determine which style super-blocks are to be found on the devices.
6233 * The minor and patch _version numbers are also kept incase the
6234 * super_block handler wishes to interpret them.
6235 */
6236 static int set_array_info(struct mddev *mddev, mdu_array_info_t *info)
6237 {
6238
6239 if (info->raid_disks == 0) {
6240 /* just setting version number for superblock loading */
6241 if (info->major_version < 0 ||
6242 info->major_version >= ARRAY_SIZE(super_types) ||
6243 super_types[info->major_version].name == NULL) {
6244 /* maybe try to auto-load a module? */
6245 printk(KERN_INFO
6246 "md: superblock version %d not known\n",
6247 info->major_version);
6248 return -EINVAL;
6249 }
6250 mddev->major_version = info->major_version;
6251 mddev->minor_version = info->minor_version;
6252 mddev->patch_version = info->patch_version;
6253 mddev->persistent = !info->not_persistent;
6254 /* ensure mddev_put doesn't delete this now that there
6255 * is some minimal configuration.
6256 */
6257 mddev->ctime = get_seconds();
6258 return 0;
6259 }
6260 mddev->major_version = MD_MAJOR_VERSION;
6261 mddev->minor_version = MD_MINOR_VERSION;
6262 mddev->patch_version = MD_PATCHLEVEL_VERSION;
6263 mddev->ctime = get_seconds();
6264
6265 mddev->level = info->level;
6266 mddev->clevel[0] = 0;
6267 mddev->dev_sectors = 2 * (sector_t)info->size;
6268 mddev->raid_disks = info->raid_disks;
6269 /* don't set md_minor, it is determined by which /dev/md* was
6270 * openned
6271 */
6272 if (info->state & (1<<MD_SB_CLEAN))
6273 mddev->recovery_cp = MaxSector;
6274 else
6275 mddev->recovery_cp = 0;
6276 mddev->persistent = ! info->not_persistent;
6277 mddev->external = 0;
6278
6279 mddev->layout = info->layout;
6280 mddev->chunk_sectors = info->chunk_size >> 9;
6281
6282 mddev->max_disks = MD_SB_DISKS;
6283
6284 if (mddev->persistent)
6285 mddev->flags = 0;
6286 set_bit(MD_CHANGE_DEVS, &mddev->flags);
6287
6288 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
6289 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
6290 mddev->bitmap_info.offset = 0;
6291
6292 mddev->reshape_position = MaxSector;
6293
6294 /*
6295 * Generate a 128 bit UUID
6296 */
6297 get_random_bytes(mddev->uuid, 16);
6298
6299 mddev->new_level = mddev->level;
6300 mddev->new_chunk_sectors = mddev->chunk_sectors;
6301 mddev->new_layout = mddev->layout;
6302 mddev->delta_disks = 0;
6303 mddev->reshape_backwards = 0;
6304
6305 return 0;
6306 }
6307
6308 void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
6309 {
6310 WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);
6311
6312 if (mddev->external_size)
6313 return;
6314
6315 mddev->array_sectors = array_sectors;
6316 }
6317 EXPORT_SYMBOL(md_set_array_sectors);
6318
6319 static int update_size(struct mddev *mddev, sector_t num_sectors)
6320 {
6321 struct md_rdev *rdev;
6322 int rv;
6323 int fit = (num_sectors == 0);
6324
6325 if (mddev->pers->resize == NULL)
6326 return -EINVAL;
6327 /* The "num_sectors" is the number of sectors of each device that
6328 * is used. This can only make sense for arrays with redundancy.
6329 * linear and raid0 always use whatever space is available. We can only
6330 * consider changing this number if no resync or reconstruction is
6331 * happening, and if the new size is acceptable. It must fit before the
6332 * sb_start or, if that is <data_offset, it must fit before the size
6333 * of each device. If num_sectors is zero, we find the largest size
6334 * that fits.
6335 */
6336 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
6337 mddev->sync_thread)
6338 return -EBUSY;
6339 if (mddev->ro)
6340 return -EROFS;
6341
6342 rdev_for_each(rdev, mddev) {
6343 sector_t avail = rdev->sectors;
6344
6345 if (fit && (num_sectors == 0 || num_sectors > avail))
6346 num_sectors = avail;
6347 if (avail < num_sectors)
6348 return -ENOSPC;
6349 }
6350 rv = mddev->pers->resize(mddev, num_sectors);
6351 if (!rv)
6352 revalidate_disk(mddev->gendisk);
6353 return rv;
6354 }
6355
6356 static int update_raid_disks(struct mddev *mddev, int raid_disks)
6357 {
6358 int rv;
6359 struct md_rdev *rdev;
6360 /* change the number of raid disks */
6361 if (mddev->pers->check_reshape == NULL)
6362 return -EINVAL;
6363 if (mddev->ro)
6364 return -EROFS;
6365 if (raid_disks <= 0 ||
6366 (mddev->max_disks && raid_disks >= mddev->max_disks))
6367 return -EINVAL;
6368 if (mddev->sync_thread ||
6369 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
6370 mddev->reshape_position != MaxSector)
6371 return -EBUSY;
6372
6373 rdev_for_each(rdev, mddev) {
6374 if (mddev->raid_disks < raid_disks &&
6375 rdev->data_offset < rdev->new_data_offset)
6376 return -EINVAL;
6377 if (mddev->raid_disks > raid_disks &&
6378 rdev->data_offset > rdev->new_data_offset)
6379 return -EINVAL;
6380 }
6381
6382 mddev->delta_disks = raid_disks - mddev->raid_disks;
6383 if (mddev->delta_disks < 0)
6384 mddev->reshape_backwards = 1;
6385 else if (mddev->delta_disks > 0)
6386 mddev->reshape_backwards = 0;
6387
6388 rv = mddev->pers->check_reshape(mddev);
6389 if (rv < 0) {
6390 mddev->delta_disks = 0;
6391 mddev->reshape_backwards = 0;
6392 }
6393 return rv;
6394 }
6395
6396 /*
6397 * update_array_info is used to change the configuration of an
6398 * on-line array.
6399 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
6400 * fields in the info are checked against the array.
6401 * Any differences that cannot be handled will cause an error.
6402 * Normally, only one change can be managed at a time.
6403 */
6404 static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
6405 {
6406 int rv = 0;
6407 int cnt = 0;
6408 int state = 0;
6409
6410 /* calculate expected state,ignoring low bits */
6411 if (mddev->bitmap && mddev->bitmap_info.offset)
6412 state |= (1 << MD_SB_BITMAP_PRESENT);
6413
6414 if (mddev->major_version != info->major_version ||
6415 mddev->minor_version != info->minor_version ||
6416 /* mddev->patch_version != info->patch_version || */
6417 mddev->ctime != info->ctime ||
6418 mddev->level != info->level ||
6419 /* mddev->layout != info->layout || */
6420 mddev->persistent != !info->not_persistent ||
6421 mddev->chunk_sectors != info->chunk_size >> 9 ||
6422 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
6423 ((state^info->state) & 0xfffffe00)
6424 )
6425 return -EINVAL;
6426 /* Check there is only one change */
6427 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
6428 cnt++;
6429 if (mddev->raid_disks != info->raid_disks)
6430 cnt++;
6431 if (mddev->layout != info->layout)
6432 cnt++;
6433 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
6434 cnt++;
6435 if (cnt == 0)
6436 return 0;
6437 if (cnt > 1)
6438 return -EINVAL;
6439
6440 if (mddev->layout != info->layout) {
6441 /* Change layout
6442 * we don't need to do anything at the md level, the
6443 * personality will take care of it all.
6444 */
6445 if (mddev->pers->check_reshape == NULL)
6446 return -EINVAL;
6447 else {
6448 mddev->new_layout = info->layout;
6449 rv = mddev->pers->check_reshape(mddev);
6450 if (rv)
6451 mddev->new_layout = mddev->layout;
6452 return rv;
6453 }
6454 }
6455 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
6456 rv = update_size(mddev, (sector_t)info->size * 2);
6457
6458 if (mddev->raid_disks != info->raid_disks)
6459 rv = update_raid_disks(mddev, info->raid_disks);
6460
6461 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
6462 if (mddev->pers->quiesce == NULL || mddev->thread == NULL) {
6463 rv = -EINVAL;
6464 goto err;
6465 }
6466 if (mddev->recovery || mddev->sync_thread) {
6467 rv = -EBUSY;
6468 goto err;
6469 }
6470 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
6471 struct bitmap *bitmap;
6472 /* add the bitmap */
6473 if (mddev->bitmap) {
6474 rv = -EEXIST;
6475 goto err;
6476 }
6477 if (mddev->bitmap_info.default_offset == 0) {
6478 rv = -EINVAL;
6479 goto err;
6480 }
6481 mddev->bitmap_info.offset =
6482 mddev->bitmap_info.default_offset;
6483 mddev->bitmap_info.space =
6484 mddev->bitmap_info.default_space;
6485 mddev->pers->quiesce(mddev, 1);
6486 bitmap = bitmap_create(mddev, -1);
6487 if (!IS_ERR(bitmap)) {
6488 mddev->bitmap = bitmap;
6489 rv = bitmap_load(mddev);
6490 } else
6491 rv = PTR_ERR(bitmap);
6492 if (rv)
6493 bitmap_destroy(mddev);
6494 mddev->pers->quiesce(mddev, 0);
6495 } else {
6496 /* remove the bitmap */
6497 if (!mddev->bitmap) {
6498 rv = -ENOENT;
6499 goto err;
6500 }
6501 if (mddev->bitmap->storage.file) {
6502 rv = -EINVAL;
6503 goto err;
6504 }
6505 mddev->pers->quiesce(mddev, 1);
6506 bitmap_destroy(mddev);
6507 mddev->pers->quiesce(mddev, 0);
6508 mddev->bitmap_info.offset = 0;
6509 }
6510 }
6511 md_update_sb(mddev, 1);
6512 return rv;
6513 err:
6514 return rv;
6515 }
6516
6517 static int set_disk_faulty(struct mddev *mddev, dev_t dev)
6518 {
6519 struct md_rdev *rdev;
6520 int err = 0;
6521
6522 if (mddev->pers == NULL)
6523 return -ENODEV;
6524
6525 rcu_read_lock();
6526 rdev = find_rdev_rcu(mddev, dev);
6527 if (!rdev)
6528 err = -ENODEV;
6529 else {
6530 md_error(mddev, rdev);
6531 if (!test_bit(Faulty, &rdev->flags))
6532 err = -EBUSY;
6533 }
6534 rcu_read_unlock();
6535 return err;
6536 }
6537
6538 /*
6539 * We have a problem here : there is no easy way to give a CHS
6540 * virtual geometry. We currently pretend that we have a 2 heads
6541 * 4 sectors (with a BIG number of cylinders...). This drives
6542 * dosfs just mad... ;-)
6543 */
6544 static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
6545 {
6546 struct mddev *mddev = bdev->bd_disk->private_data;
6547
6548 geo->heads = 2;
6549 geo->sectors = 4;
6550 geo->cylinders = mddev->array_sectors / 8;
6551 return 0;
6552 }
6553
6554 static inline bool md_ioctl_valid(unsigned int cmd)
6555 {
6556 switch (cmd) {
6557 case ADD_NEW_DISK:
6558 case BLKROSET:
6559 case GET_ARRAY_INFO:
6560 case GET_BITMAP_FILE:
6561 case GET_DISK_INFO:
6562 case HOT_ADD_DISK:
6563 case HOT_REMOVE_DISK:
6564 case RAID_AUTORUN:
6565 case RAID_VERSION:
6566 case RESTART_ARRAY_RW:
6567 case RUN_ARRAY:
6568 case SET_ARRAY_INFO:
6569 case SET_BITMAP_FILE:
6570 case SET_DISK_FAULTY:
6571 case STOP_ARRAY:
6572 case STOP_ARRAY_RO:
6573 case CLUSTERED_DISK_NACK:
6574 return true;
6575 default:
6576 return false;
6577 }
6578 }
6579
6580 static int md_ioctl(struct block_device *bdev, fmode_t mode,
6581 unsigned int cmd, unsigned long arg)
6582 {
6583 int err = 0;
6584 void __user *argp = (void __user *)arg;
6585 struct mddev *mddev = NULL;
6586 int ro;
6587
6588 if (!md_ioctl_valid(cmd))
6589 return -ENOTTY;
6590
6591 switch (cmd) {
6592 case RAID_VERSION:
6593 case GET_ARRAY_INFO:
6594 case GET_DISK_INFO:
6595 break;
6596 default:
6597 if (!capable(CAP_SYS_ADMIN))
6598 return -EACCES;
6599 }
6600
6601 /*
6602 * Commands dealing with the RAID driver but not any
6603 * particular array:
6604 */
6605 switch (cmd) {
6606 case RAID_VERSION:
6607 err = get_version(argp);
6608 goto out;
6609
6610 #ifndef MODULE
6611 case RAID_AUTORUN:
6612 err = 0;
6613 autostart_arrays(arg);
6614 goto out;
6615 #endif
6616 default:;
6617 }
6618
6619 /*
6620 * Commands creating/starting a new array:
6621 */
6622
6623 mddev = bdev->bd_disk->private_data;
6624
6625 if (!mddev) {
6626 BUG();
6627 goto out;
6628 }
6629
6630 /* Some actions do not requires the mutex */
6631 switch (cmd) {
6632 case GET_ARRAY_INFO:
6633 if (!mddev->raid_disks && !mddev->external)
6634 err = -ENODEV;
6635 else
6636 err = get_array_info(mddev, argp);
6637 goto out;
6638
6639 case GET_DISK_INFO:
6640 if (!mddev->raid_disks && !mddev->external)
6641 err = -ENODEV;
6642 else
6643 err = get_disk_info(mddev, argp);
6644 goto out;
6645
6646 case SET_DISK_FAULTY:
6647 err = set_disk_faulty(mddev, new_decode_dev(arg));
6648 goto out;
6649
6650 case GET_BITMAP_FILE:
6651 err = get_bitmap_file(mddev, argp);
6652 goto out;
6653
6654 }
6655
6656 if (cmd == ADD_NEW_DISK)
6657 /* need to ensure md_delayed_delete() has completed */
6658 flush_workqueue(md_misc_wq);
6659
6660 if (cmd == HOT_REMOVE_DISK)
6661 /* need to ensure recovery thread has run */
6662 wait_event_interruptible_timeout(mddev->sb_wait,
6663 !test_bit(MD_RECOVERY_NEEDED,
6664 &mddev->flags),
6665 msecs_to_jiffies(5000));
6666 if (cmd == STOP_ARRAY || cmd == STOP_ARRAY_RO) {
6667 /* Need to flush page cache, and ensure no-one else opens
6668 * and writes
6669 */
6670 mutex_lock(&mddev->open_mutex);
6671 if (mddev->pers && atomic_read(&mddev->openers) > 1) {
6672 mutex_unlock(&mddev->open_mutex);
6673 err = -EBUSY;
6674 goto out;
6675 }
6676 set_bit(MD_STILL_CLOSED, &mddev->flags);
6677 mutex_unlock(&mddev->open_mutex);
6678 sync_blockdev(bdev);
6679 }
6680 err = mddev_lock(mddev);
6681 if (err) {
6682 printk(KERN_INFO
6683 "md: ioctl lock interrupted, reason %d, cmd %d\n",
6684 err, cmd);
6685 goto out;
6686 }
6687
6688 if (cmd == SET_ARRAY_INFO) {
6689 mdu_array_info_t info;
6690 if (!arg)
6691 memset(&info, 0, sizeof(info));
6692 else if (copy_from_user(&info, argp, sizeof(info))) {
6693 err = -EFAULT;
6694 goto unlock;
6695 }
6696 if (mddev->pers) {
6697 err = update_array_info(mddev, &info);
6698 if (err) {
6699 printk(KERN_WARNING "md: couldn't update"
6700 " array info. %d\n", err);
6701 goto unlock;
6702 }
6703 goto unlock;
6704 }
6705 if (!list_empty(&mddev->disks)) {
6706 printk(KERN_WARNING
6707 "md: array %s already has disks!\n",
6708 mdname(mddev));
6709 err = -EBUSY;
6710 goto unlock;
6711 }
6712 if (mddev->raid_disks) {
6713 printk(KERN_WARNING
6714 "md: array %s already initialised!\n",
6715 mdname(mddev));
6716 err = -EBUSY;
6717 goto unlock;
6718 }
6719 err = set_array_info(mddev, &info);
6720 if (err) {
6721 printk(KERN_WARNING "md: couldn't set"
6722 " array info. %d\n", err);
6723 goto unlock;
6724 }
6725 goto unlock;
6726 }
6727
6728 /*
6729 * Commands querying/configuring an existing array:
6730 */
6731 /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
6732 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
6733 if ((!mddev->raid_disks && !mddev->external)
6734 && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
6735 && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
6736 && cmd != GET_BITMAP_FILE) {
6737 err = -ENODEV;
6738 goto unlock;
6739 }
6740
6741 /*
6742 * Commands even a read-only array can execute:
6743 */
6744 switch (cmd) {
6745 case RESTART_ARRAY_RW:
6746 err = restart_array(mddev);
6747 goto unlock;
6748
6749 case STOP_ARRAY:
6750 err = do_md_stop(mddev, 0, bdev);
6751 goto unlock;
6752
6753 case STOP_ARRAY_RO:
6754 err = md_set_readonly(mddev, bdev);
6755 goto unlock;
6756
6757 case HOT_REMOVE_DISK:
6758 err = hot_remove_disk(mddev, new_decode_dev(arg));
6759 goto unlock;
6760
6761 case ADD_NEW_DISK:
6762 /* We can support ADD_NEW_DISK on read-only arrays
6763 * on if we are re-adding a preexisting device.
6764 * So require mddev->pers and MD_DISK_SYNC.
6765 */
6766 if (mddev->pers) {
6767 mdu_disk_info_t info;
6768 if (copy_from_user(&info, argp, sizeof(info)))
6769 err = -EFAULT;
6770 else if (!(info.state & (1<<MD_DISK_SYNC)))
6771 /* Need to clear read-only for this */
6772 break;
6773 else
6774 err = add_new_disk(mddev, &info);
6775 goto unlock;
6776 }
6777 break;
6778
6779 case BLKROSET:
6780 if (get_user(ro, (int __user *)(arg))) {
6781 err = -EFAULT;
6782 goto unlock;
6783 }
6784 err = -EINVAL;
6785
6786 /* if the bdev is going readonly the value of mddev->ro
6787 * does not matter, no writes are coming
6788 */
6789 if (ro)
6790 goto unlock;
6791
6792 /* are we are already prepared for writes? */
6793 if (mddev->ro != 1)
6794 goto unlock;
6795
6796 /* transitioning to readauto need only happen for
6797 * arrays that call md_write_start
6798 */
6799 if (mddev->pers) {
6800 err = restart_array(mddev);
6801 if (err == 0) {
6802 mddev->ro = 2;
6803 set_disk_ro(mddev->gendisk, 0);
6804 }
6805 }
6806 goto unlock;
6807 }
6808
6809 /*
6810 * The remaining ioctls are changing the state of the
6811 * superblock, so we do not allow them on read-only arrays.
6812 */
6813 if (mddev->ro && mddev->pers) {
6814 if (mddev->ro == 2) {
6815 mddev->ro = 0;
6816 sysfs_notify_dirent_safe(mddev->sysfs_state);
6817 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6818 /* mddev_unlock will wake thread */
6819 /* If a device failed while we were read-only, we
6820 * need to make sure the metadata is updated now.
6821 */
6822 if (test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
6823 mddev_unlock(mddev);
6824 wait_event(mddev->sb_wait,
6825 !test_bit(MD_CHANGE_DEVS, &mddev->flags) &&
6826 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
6827 mddev_lock_nointr(mddev);
6828 }
6829 } else {
6830 err = -EROFS;
6831 goto unlock;
6832 }
6833 }
6834
6835 switch (cmd) {
6836 case ADD_NEW_DISK:
6837 {
6838 mdu_disk_info_t info;
6839 if (copy_from_user(&info, argp, sizeof(info)))
6840 err = -EFAULT;
6841 else
6842 err = add_new_disk(mddev, &info);
6843 goto unlock;
6844 }
6845
6846 case CLUSTERED_DISK_NACK:
6847 if (mddev_is_clustered(mddev))
6848 md_cluster_ops->new_disk_ack(mddev, false);
6849 else
6850 err = -EINVAL;
6851 goto unlock;
6852
6853 case HOT_ADD_DISK:
6854 err = hot_add_disk(mddev, new_decode_dev(arg));
6855 goto unlock;
6856
6857 case RUN_ARRAY:
6858 err = do_md_run(mddev);
6859 goto unlock;
6860
6861 case SET_BITMAP_FILE:
6862 err = set_bitmap_file(mddev, (int)arg);
6863 goto unlock;
6864
6865 default:
6866 err = -EINVAL;
6867 goto unlock;
6868 }
6869
6870 unlock:
6871 if (mddev->hold_active == UNTIL_IOCTL &&
6872 err != -EINVAL)
6873 mddev->hold_active = 0;
6874 mddev_unlock(mddev);
6875 out:
6876 return err;
6877 }
6878 #ifdef CONFIG_COMPAT
6879 static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
6880 unsigned int cmd, unsigned long arg)
6881 {
6882 switch (cmd) {
6883 case HOT_REMOVE_DISK:
6884 case HOT_ADD_DISK:
6885 case SET_DISK_FAULTY:
6886 case SET_BITMAP_FILE:
6887 /* These take in integer arg, do not convert */
6888 break;
6889 default:
6890 arg = (unsigned long)compat_ptr(arg);
6891 break;
6892 }
6893
6894 return md_ioctl(bdev, mode, cmd, arg);
6895 }
6896 #endif /* CONFIG_COMPAT */
6897
6898 static int md_open(struct block_device *bdev, fmode_t mode)
6899 {
6900 /*
6901 * Succeed if we can lock the mddev, which confirms that
6902 * it isn't being stopped right now.
6903 */
6904 struct mddev *mddev = mddev_find(bdev->bd_dev);
6905 int err;
6906
6907 if (!mddev)
6908 return -ENODEV;
6909
6910 if (mddev->gendisk != bdev->bd_disk) {
6911 /* we are racing with mddev_put which is discarding this
6912 * bd_disk.
6913 */
6914 mddev_put(mddev);
6915 /* Wait until bdev->bd_disk is definitely gone */
6916 flush_workqueue(md_misc_wq);
6917 /* Then retry the open from the top */
6918 return -ERESTARTSYS;
6919 }
6920 BUG_ON(mddev != bdev->bd_disk->private_data);
6921
6922 if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
6923 goto out;
6924
6925 err = 0;
6926 atomic_inc(&mddev->openers);
6927 clear_bit(MD_STILL_CLOSED, &mddev->flags);
6928 mutex_unlock(&mddev->open_mutex);
6929
6930 check_disk_change(bdev);
6931 out:
6932 return err;
6933 }
6934
6935 static void md_release(struct gendisk *disk, fmode_t mode)
6936 {
6937 struct mddev *mddev = disk->private_data;
6938
6939 BUG_ON(!mddev);
6940 atomic_dec(&mddev->openers);
6941 mddev_put(mddev);
6942 }
6943
6944 static int md_media_changed(struct gendisk *disk)
6945 {
6946 struct mddev *mddev = disk->private_data;
6947
6948 return mddev->changed;
6949 }
6950
6951 static int md_revalidate(struct gendisk *disk)
6952 {
6953 struct mddev *mddev = disk->private_data;
6954
6955 mddev->changed = 0;
6956 return 0;
6957 }
6958 static const struct block_device_operations md_fops =
6959 {
6960 .owner = THIS_MODULE,
6961 .open = md_open,
6962 .release = md_release,
6963 .ioctl = md_ioctl,
6964 #ifdef CONFIG_COMPAT
6965 .compat_ioctl = md_compat_ioctl,
6966 #endif
6967 .getgeo = md_getgeo,
6968 .media_changed = md_media_changed,
6969 .revalidate_disk= md_revalidate,
6970 };
6971
6972 static int md_thread(void *arg)
6973 {
6974 struct md_thread *thread = arg;
6975
6976 /*
6977 * md_thread is a 'system-thread', it's priority should be very
6978 * high. We avoid resource deadlocks individually in each
6979 * raid personality. (RAID5 does preallocation) We also use RR and
6980 * the very same RT priority as kswapd, thus we will never get
6981 * into a priority inversion deadlock.
6982 *
6983 * we definitely have to have equal or higher priority than
6984 * bdflush, otherwise bdflush will deadlock if there are too
6985 * many dirty RAID5 blocks.
6986 */
6987
6988 allow_signal(SIGKILL);
6989 while (!kthread_should_stop()) {
6990
6991 /* We need to wait INTERRUPTIBLE so that
6992 * we don't add to the load-average.
6993 * That means we need to be sure no signals are
6994 * pending
6995 */
6996 if (signal_pending(current))
6997 flush_signals(current);
6998
6999 wait_event_interruptible_timeout
7000 (thread->wqueue,
7001 test_bit(THREAD_WAKEUP, &thread->flags)
7002 || kthread_should_stop(),
7003 thread->timeout);
7004
7005 clear_bit(THREAD_WAKEUP, &thread->flags);
7006 if (!kthread_should_stop())
7007 thread->run(thread);
7008 }
7009
7010 return 0;
7011 }
7012
7013 void md_wakeup_thread(struct md_thread *thread)
7014 {
7015 if (thread) {
7016 pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
7017 set_bit(THREAD_WAKEUP, &thread->flags);
7018 wake_up(&thread->wqueue);
7019 }
7020 }
7021 EXPORT_SYMBOL(md_wakeup_thread);
7022
7023 struct md_thread *md_register_thread(void (*run) (struct md_thread *),
7024 struct mddev *mddev, const char *name)
7025 {
7026 struct md_thread *thread;
7027
7028 thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
7029 if (!thread)
7030 return NULL;
7031
7032 init_waitqueue_head(&thread->wqueue);
7033
7034 thread->run = run;
7035 thread->mddev = mddev;
7036 thread->timeout = MAX_SCHEDULE_TIMEOUT;
7037 thread->tsk = kthread_run(md_thread, thread,
7038 "%s_%s",
7039 mdname(thread->mddev),
7040 name);
7041 if (IS_ERR(thread->tsk)) {
7042 kfree(thread);
7043 return NULL;
7044 }
7045 return thread;
7046 }
7047 EXPORT_SYMBOL(md_register_thread);
7048
7049 void md_unregister_thread(struct md_thread **threadp)
7050 {
7051 struct md_thread *thread = *threadp;
7052 if (!thread)
7053 return;
7054 pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
7055 /* Locking ensures that mddev_unlock does not wake_up a
7056 * non-existent thread
7057 */
7058 spin_lock(&pers_lock);
7059 *threadp = NULL;
7060 spin_unlock(&pers_lock);
7061
7062 kthread_stop(thread->tsk);
7063 kfree(thread);
7064 }
7065 EXPORT_SYMBOL(md_unregister_thread);
7066
7067 void md_error(struct mddev *mddev, struct md_rdev *rdev)
7068 {
7069 if (!rdev || test_bit(Faulty, &rdev->flags))
7070 return;
7071
7072 if (!mddev->pers || !mddev->pers->error_handler)
7073 return;
7074 mddev->pers->error_handler(mddev,rdev);
7075 if (mddev->degraded)
7076 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7077 sysfs_notify_dirent_safe(rdev->sysfs_state);
7078 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7079 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7080 md_wakeup_thread(mddev->thread);
7081 if (mddev->event_work.func)
7082 queue_work(md_misc_wq, &mddev->event_work);
7083 md_new_event_inintr(mddev);
7084 }
7085 EXPORT_SYMBOL(md_error);
7086
7087 /* seq_file implementation /proc/mdstat */
7088
7089 static void status_unused(struct seq_file *seq)
7090 {
7091 int i = 0;
7092 struct md_rdev *rdev;
7093
7094 seq_printf(seq, "unused devices: ");
7095
7096 list_for_each_entry(rdev, &pending_raid_disks, same_set) {
7097 char b[BDEVNAME_SIZE];
7098 i++;
7099 seq_printf(seq, "%s ",
7100 bdevname(rdev->bdev,b));
7101 }
7102 if (!i)
7103 seq_printf(seq, "<none>");
7104
7105 seq_printf(seq, "\n");
7106 }
7107
7108 static int status_resync(struct seq_file *seq, struct mddev *mddev)
7109 {
7110 sector_t max_sectors, resync, res;
7111 unsigned long dt, db;
7112 sector_t rt;
7113 int scale;
7114 unsigned int per_milli;
7115
7116 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
7117 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7118 max_sectors = mddev->resync_max_sectors;
7119 else
7120 max_sectors = mddev->dev_sectors;
7121
7122 resync = mddev->curr_resync;
7123 if (resync <= 3) {
7124 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7125 /* Still cleaning up */
7126 resync = max_sectors;
7127 } else
7128 resync -= atomic_read(&mddev->recovery_active);
7129
7130 if (resync == 0) {
7131 if (mddev->recovery_cp < MaxSector) {
7132 seq_printf(seq, "\tresync=PENDING");
7133 return 1;
7134 }
7135 return 0;
7136 }
7137 if (resync < 3) {
7138 seq_printf(seq, "\tresync=DELAYED");
7139 return 1;
7140 }
7141
7142 WARN_ON(max_sectors == 0);
7143 /* Pick 'scale' such that (resync>>scale)*1000 will fit
7144 * in a sector_t, and (max_sectors>>scale) will fit in a
7145 * u32, as those are the requirements for sector_div.
7146 * Thus 'scale' must be at least 10
7147 */
7148 scale = 10;
7149 if (sizeof(sector_t) > sizeof(unsigned long)) {
7150 while ( max_sectors/2 > (1ULL<<(scale+32)))
7151 scale++;
7152 }
7153 res = (resync>>scale)*1000;
7154 sector_div(res, (u32)((max_sectors>>scale)+1));
7155
7156 per_milli = res;
7157 {
7158 int i, x = per_milli/50, y = 20-x;
7159 seq_printf(seq, "[");
7160 for (i = 0; i < x; i++)
7161 seq_printf(seq, "=");
7162 seq_printf(seq, ">");
7163 for (i = 0; i < y; i++)
7164 seq_printf(seq, ".");
7165 seq_printf(seq, "] ");
7166 }
7167 seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
7168 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
7169 "reshape" :
7170 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
7171 "check" :
7172 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
7173 "resync" : "recovery"))),
7174 per_milli/10, per_milli % 10,
7175 (unsigned long long) resync/2,
7176 (unsigned long long) max_sectors/2);
7177
7178 /*
7179 * dt: time from mark until now
7180 * db: blocks written from mark until now
7181 * rt: remaining time
7182 *
7183 * rt is a sector_t, so could be 32bit or 64bit.
7184 * So we divide before multiply in case it is 32bit and close
7185 * to the limit.
7186 * We scale the divisor (db) by 32 to avoid losing precision
7187 * near the end of resync when the number of remaining sectors
7188 * is close to 'db'.
7189 * We then divide rt by 32 after multiplying by db to compensate.
7190 * The '+1' avoids division by zero if db is very small.
7191 */
7192 dt = ((jiffies - mddev->resync_mark) / HZ);
7193 if (!dt) dt++;
7194 db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
7195 - mddev->resync_mark_cnt;
7196
7197 rt = max_sectors - resync; /* number of remaining sectors */
7198 sector_div(rt, db/32+1);
7199 rt *= dt;
7200 rt >>= 5;
7201
7202 seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
7203 ((unsigned long)rt % 60)/6);
7204
7205 seq_printf(seq, " speed=%ldK/sec", db/2/dt);
7206 return 1;
7207 }
7208
7209 static void *md_seq_start(struct seq_file *seq, loff_t *pos)
7210 {
7211 struct list_head *tmp;
7212 loff_t l = *pos;
7213 struct mddev *mddev;
7214
7215 if (l >= 0x10000)
7216 return NULL;
7217 if (!l--)
7218 /* header */
7219 return (void*)1;
7220
7221 spin_lock(&all_mddevs_lock);
7222 list_for_each(tmp,&all_mddevs)
7223 if (!l--) {
7224 mddev = list_entry(tmp, struct mddev, all_mddevs);
7225 mddev_get(mddev);
7226 spin_unlock(&all_mddevs_lock);
7227 return mddev;
7228 }
7229 spin_unlock(&all_mddevs_lock);
7230 if (!l--)
7231 return (void*)2;/* tail */
7232 return NULL;
7233 }
7234
7235 static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
7236 {
7237 struct list_head *tmp;
7238 struct mddev *next_mddev, *mddev = v;
7239
7240 ++*pos;
7241 if (v == (void*)2)
7242 return NULL;
7243
7244 spin_lock(&all_mddevs_lock);
7245 if (v == (void*)1)
7246 tmp = all_mddevs.next;
7247 else
7248 tmp = mddev->all_mddevs.next;
7249 if (tmp != &all_mddevs)
7250 next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
7251 else {
7252 next_mddev = (void*)2;
7253 *pos = 0x10000;
7254 }
7255 spin_unlock(&all_mddevs_lock);
7256
7257 if (v != (void*)1)
7258 mddev_put(mddev);
7259 return next_mddev;
7260
7261 }
7262
7263 static void md_seq_stop(struct seq_file *seq, void *v)
7264 {
7265 struct mddev *mddev = v;
7266
7267 if (mddev && v != (void*)1 && v != (void*)2)
7268 mddev_put(mddev);
7269 }
7270
7271 static int md_seq_show(struct seq_file *seq, void *v)
7272 {
7273 struct mddev *mddev = v;
7274 sector_t sectors;
7275 struct md_rdev *rdev;
7276
7277 if (v == (void*)1) {
7278 struct md_personality *pers;
7279 seq_printf(seq, "Personalities : ");
7280 spin_lock(&pers_lock);
7281 list_for_each_entry(pers, &pers_list, list)
7282 seq_printf(seq, "[%s] ", pers->name);
7283
7284 spin_unlock(&pers_lock);
7285 seq_printf(seq, "\n");
7286 seq->poll_event = atomic_read(&md_event_count);
7287 return 0;
7288 }
7289 if (v == (void*)2) {
7290 status_unused(seq);
7291 return 0;
7292 }
7293
7294 spin_lock(&mddev->lock);
7295 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
7296 seq_printf(seq, "%s : %sactive", mdname(mddev),
7297 mddev->pers ? "" : "in");
7298 if (mddev->pers) {
7299 if (mddev->ro==1)
7300 seq_printf(seq, " (read-only)");
7301 if (mddev->ro==2)
7302 seq_printf(seq, " (auto-read-only)");
7303 seq_printf(seq, " %s", mddev->pers->name);
7304 }
7305
7306 sectors = 0;
7307 rcu_read_lock();
7308 rdev_for_each_rcu(rdev, mddev) {
7309 char b[BDEVNAME_SIZE];
7310 seq_printf(seq, " %s[%d]",
7311 bdevname(rdev->bdev,b), rdev->desc_nr);
7312 if (test_bit(WriteMostly, &rdev->flags))
7313 seq_printf(seq, "(W)");
7314 if (test_bit(Faulty, &rdev->flags)) {
7315 seq_printf(seq, "(F)");
7316 continue;
7317 }
7318 if (rdev->raid_disk < 0)
7319 seq_printf(seq, "(S)"); /* spare */
7320 if (test_bit(Replacement, &rdev->flags))
7321 seq_printf(seq, "(R)");
7322 sectors += rdev->sectors;
7323 }
7324 rcu_read_unlock();
7325
7326 if (!list_empty(&mddev->disks)) {
7327 if (mddev->pers)
7328 seq_printf(seq, "\n %llu blocks",
7329 (unsigned long long)
7330 mddev->array_sectors / 2);
7331 else
7332 seq_printf(seq, "\n %llu blocks",
7333 (unsigned long long)sectors / 2);
7334 }
7335 if (mddev->persistent) {
7336 if (mddev->major_version != 0 ||
7337 mddev->minor_version != 90) {
7338 seq_printf(seq," super %d.%d",
7339 mddev->major_version,
7340 mddev->minor_version);
7341 }
7342 } else if (mddev->external)
7343 seq_printf(seq, " super external:%s",
7344 mddev->metadata_type);
7345 else
7346 seq_printf(seq, " super non-persistent");
7347
7348 if (mddev->pers) {
7349 mddev->pers->status(seq, mddev);
7350 seq_printf(seq, "\n ");
7351 if (mddev->pers->sync_request) {
7352 if (status_resync(seq, mddev))
7353 seq_printf(seq, "\n ");
7354 }
7355 } else
7356 seq_printf(seq, "\n ");
7357
7358 bitmap_status(seq, mddev->bitmap);
7359
7360 seq_printf(seq, "\n");
7361 }
7362 spin_unlock(&mddev->lock);
7363
7364 return 0;
7365 }
7366
7367 static const struct seq_operations md_seq_ops = {
7368 .start = md_seq_start,
7369 .next = md_seq_next,
7370 .stop = md_seq_stop,
7371 .show = md_seq_show,
7372 };
7373
7374 static int md_seq_open(struct inode *inode, struct file *file)
7375 {
7376 struct seq_file *seq;
7377 int error;
7378
7379 error = seq_open(file, &md_seq_ops);
7380 if (error)
7381 return error;
7382
7383 seq = file->private_data;
7384 seq->poll_event = atomic_read(&md_event_count);
7385 return error;
7386 }
7387
7388 static int md_unloading;
7389 static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
7390 {
7391 struct seq_file *seq = filp->private_data;
7392 int mask;
7393
7394 if (md_unloading)
7395 return POLLIN|POLLRDNORM|POLLERR|POLLPRI;
7396 poll_wait(filp, &md_event_waiters, wait);
7397
7398 /* always allow read */
7399 mask = POLLIN | POLLRDNORM;
7400
7401 if (seq->poll_event != atomic_read(&md_event_count))
7402 mask |= POLLERR | POLLPRI;
7403 return mask;
7404 }
7405
7406 static const struct file_operations md_seq_fops = {
7407 .owner = THIS_MODULE,
7408 .open = md_seq_open,
7409 .read = seq_read,
7410 .llseek = seq_lseek,
7411 .release = seq_release_private,
7412 .poll = mdstat_poll,
7413 };
7414
7415 int register_md_personality(struct md_personality *p)
7416 {
7417 printk(KERN_INFO "md: %s personality registered for level %d\n",
7418 p->name, p->level);
7419 spin_lock(&pers_lock);
7420 list_add_tail(&p->list, &pers_list);
7421 spin_unlock(&pers_lock);
7422 return 0;
7423 }
7424 EXPORT_SYMBOL(register_md_personality);
7425
7426 int unregister_md_personality(struct md_personality *p)
7427 {
7428 printk(KERN_INFO "md: %s personality unregistered\n", p->name);
7429 spin_lock(&pers_lock);
7430 list_del_init(&p->list);
7431 spin_unlock(&pers_lock);
7432 return 0;
7433 }
7434 EXPORT_SYMBOL(unregister_md_personality);
7435
7436 int register_md_cluster_operations(struct md_cluster_operations *ops,
7437 struct module *module)
7438 {
7439 int ret = 0;
7440 spin_lock(&pers_lock);
7441 if (md_cluster_ops != NULL)
7442 ret = -EALREADY;
7443 else {
7444 md_cluster_ops = ops;
7445 md_cluster_mod = module;
7446 }
7447 spin_unlock(&pers_lock);
7448 return ret;
7449 }
7450 EXPORT_SYMBOL(register_md_cluster_operations);
7451
7452 int unregister_md_cluster_operations(void)
7453 {
7454 spin_lock(&pers_lock);
7455 md_cluster_ops = NULL;
7456 spin_unlock(&pers_lock);
7457 return 0;
7458 }
7459 EXPORT_SYMBOL(unregister_md_cluster_operations);
7460
7461 int md_setup_cluster(struct mddev *mddev, int nodes)
7462 {
7463 int err;
7464
7465 err = request_module("md-cluster");
7466 if (err) {
7467 pr_err("md-cluster module not found.\n");
7468 return -ENOENT;
7469 }
7470
7471 spin_lock(&pers_lock);
7472 if (!md_cluster_ops || !try_module_get(md_cluster_mod)) {
7473 spin_unlock(&pers_lock);
7474 return -ENOENT;
7475 }
7476 spin_unlock(&pers_lock);
7477
7478 return md_cluster_ops->join(mddev, nodes);
7479 }
7480
7481 void md_cluster_stop(struct mddev *mddev)
7482 {
7483 if (!md_cluster_ops)
7484 return;
7485 md_cluster_ops->leave(mddev);
7486 module_put(md_cluster_mod);
7487 }
7488
7489 static int is_mddev_idle(struct mddev *mddev, int init)
7490 {
7491 struct md_rdev *rdev;
7492 int idle;
7493 int curr_events;
7494
7495 idle = 1;
7496 rcu_read_lock();
7497 rdev_for_each_rcu(rdev, mddev) {
7498 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
7499 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
7500 (int)part_stat_read(&disk->part0, sectors[1]) -
7501 atomic_read(&disk->sync_io);
7502 /* sync IO will cause sync_io to increase before the disk_stats
7503 * as sync_io is counted when a request starts, and
7504 * disk_stats is counted when it completes.
7505 * So resync activity will cause curr_events to be smaller than
7506 * when there was no such activity.
7507 * non-sync IO will cause disk_stat to increase without
7508 * increasing sync_io so curr_events will (eventually)
7509 * be larger than it was before. Once it becomes
7510 * substantially larger, the test below will cause
7511 * the array to appear non-idle, and resync will slow
7512 * down.
7513 * If there is a lot of outstanding resync activity when
7514 * we set last_event to curr_events, then all that activity
7515 * completing might cause the array to appear non-idle
7516 * and resync will be slowed down even though there might
7517 * not have been non-resync activity. This will only
7518 * happen once though. 'last_events' will soon reflect
7519 * the state where there is little or no outstanding
7520 * resync requests, and further resync activity will
7521 * always make curr_events less than last_events.
7522 *
7523 */
7524 if (init || curr_events - rdev->last_events > 64) {
7525 rdev->last_events = curr_events;
7526 idle = 0;
7527 }
7528 }
7529 rcu_read_unlock();
7530 return idle;
7531 }
7532
7533 void md_done_sync(struct mddev *mddev, int blocks, int ok)
7534 {
7535 /* another "blocks" (512byte) blocks have been synced */
7536 atomic_sub(blocks, &mddev->recovery_active);
7537 wake_up(&mddev->recovery_wait);
7538 if (!ok) {
7539 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7540 set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
7541 md_wakeup_thread(mddev->thread);
7542 // stop recovery, signal do_sync ....
7543 }
7544 }
7545 EXPORT_SYMBOL(md_done_sync);
7546
7547 /* md_write_start(mddev, bi)
7548 * If we need to update some array metadata (e.g. 'active' flag
7549 * in superblock) before writing, schedule a superblock update
7550 * and wait for it to complete.
7551 */
7552 void md_write_start(struct mddev *mddev, struct bio *bi)
7553 {
7554 int did_change = 0;
7555 if (bio_data_dir(bi) != WRITE)
7556 return;
7557
7558 BUG_ON(mddev->ro == 1);
7559 if (mddev->ro == 2) {
7560 /* need to switch to read/write */
7561 mddev->ro = 0;
7562 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7563 md_wakeup_thread(mddev->thread);
7564 md_wakeup_thread(mddev->sync_thread);
7565 did_change = 1;
7566 }
7567 atomic_inc(&mddev->writes_pending);
7568 if (mddev->safemode == 1)
7569 mddev->safemode = 0;
7570 if (mddev->in_sync) {
7571 spin_lock(&mddev->lock);
7572 if (mddev->in_sync) {
7573 mddev->in_sync = 0;
7574 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7575 set_bit(MD_CHANGE_PENDING, &mddev->flags);
7576 md_wakeup_thread(mddev->thread);
7577 did_change = 1;
7578 }
7579 spin_unlock(&mddev->lock);
7580 }
7581 if (did_change)
7582 sysfs_notify_dirent_safe(mddev->sysfs_state);
7583 wait_event(mddev->sb_wait,
7584 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
7585 }
7586 EXPORT_SYMBOL(md_write_start);
7587
7588 void md_write_end(struct mddev *mddev)
7589 {
7590 if (atomic_dec_and_test(&mddev->writes_pending)) {
7591 if (mddev->safemode == 2)
7592 md_wakeup_thread(mddev->thread);
7593 else if (mddev->safemode_delay)
7594 mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
7595 }
7596 }
7597 EXPORT_SYMBOL(md_write_end);
7598
7599 /* md_allow_write(mddev)
7600 * Calling this ensures that the array is marked 'active' so that writes
7601 * may proceed without blocking. It is important to call this before
7602 * attempting a GFP_KERNEL allocation while holding the mddev lock.
7603 * Must be called with mddev_lock held.
7604 *
7605 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
7606 * is dropped, so return -EAGAIN after notifying userspace.
7607 */
7608 int md_allow_write(struct mddev *mddev)
7609 {
7610 if (!mddev->pers)
7611 return 0;
7612 if (mddev->ro)
7613 return 0;
7614 if (!mddev->pers->sync_request)
7615 return 0;
7616
7617 spin_lock(&mddev->lock);
7618 if (mddev->in_sync) {
7619 mddev->in_sync = 0;
7620 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7621 set_bit(MD_CHANGE_PENDING, &mddev->flags);
7622 if (mddev->safemode_delay &&
7623 mddev->safemode == 0)
7624 mddev->safemode = 1;
7625 spin_unlock(&mddev->lock);
7626 md_update_sb(mddev, 0);
7627 sysfs_notify_dirent_safe(mddev->sysfs_state);
7628 } else
7629 spin_unlock(&mddev->lock);
7630
7631 if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
7632 return -EAGAIN;
7633 else
7634 return 0;
7635 }
7636 EXPORT_SYMBOL_GPL(md_allow_write);
7637
7638 #define SYNC_MARKS 10
7639 #define SYNC_MARK_STEP (3*HZ)
7640 #define UPDATE_FREQUENCY (5*60*HZ)
7641 void md_do_sync(struct md_thread *thread)
7642 {
7643 struct mddev *mddev = thread->mddev;
7644 struct mddev *mddev2;
7645 unsigned int currspeed = 0,
7646 window;
7647 sector_t max_sectors,j, io_sectors, recovery_done;
7648 unsigned long mark[SYNC_MARKS];
7649 unsigned long update_time;
7650 sector_t mark_cnt[SYNC_MARKS];
7651 int last_mark,m;
7652 struct list_head *tmp;
7653 sector_t last_check;
7654 int skipped = 0;
7655 struct md_rdev *rdev;
7656 char *desc, *action = NULL;
7657 struct blk_plug plug;
7658 bool cluster_resync_finished = false;
7659
7660 /* just incase thread restarts... */
7661 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7662 return;
7663 if (mddev->ro) {/* never try to sync a read-only array */
7664 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7665 return;
7666 }
7667
7668 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7669 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
7670 desc = "data-check";
7671 action = "check";
7672 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
7673 desc = "requested-resync";
7674 action = "repair";
7675 } else
7676 desc = "resync";
7677 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7678 desc = "reshape";
7679 else
7680 desc = "recovery";
7681
7682 mddev->last_sync_action = action ?: desc;
7683
7684 /* we overload curr_resync somewhat here.
7685 * 0 == not engaged in resync at all
7686 * 2 == checking that there is no conflict with another sync
7687 * 1 == like 2, but have yielded to allow conflicting resync to
7688 * commense
7689 * other == active in resync - this many blocks
7690 *
7691 * Before starting a resync we must have set curr_resync to
7692 * 2, and then checked that every "conflicting" array has curr_resync
7693 * less than ours. When we find one that is the same or higher
7694 * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
7695 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
7696 * This will mean we have to start checking from the beginning again.
7697 *
7698 */
7699
7700 do {
7701 mddev->curr_resync = 2;
7702
7703 try_again:
7704 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7705 goto skip;
7706 for_each_mddev(mddev2, tmp) {
7707 if (mddev2 == mddev)
7708 continue;
7709 if (!mddev->parallel_resync
7710 && mddev2->curr_resync
7711 && match_mddev_units(mddev, mddev2)) {
7712 DEFINE_WAIT(wq);
7713 if (mddev < mddev2 && mddev->curr_resync == 2) {
7714 /* arbitrarily yield */
7715 mddev->curr_resync = 1;
7716 wake_up(&resync_wait);
7717 }
7718 if (mddev > mddev2 && mddev->curr_resync == 1)
7719 /* no need to wait here, we can wait the next
7720 * time 'round when curr_resync == 2
7721 */
7722 continue;
7723 /* We need to wait 'interruptible' so as not to
7724 * contribute to the load average, and not to
7725 * be caught by 'softlockup'
7726 */
7727 prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
7728 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
7729 mddev2->curr_resync >= mddev->curr_resync) {
7730 printk(KERN_INFO "md: delaying %s of %s"
7731 " until %s has finished (they"
7732 " share one or more physical units)\n",
7733 desc, mdname(mddev), mdname(mddev2));
7734 mddev_put(mddev2);
7735 if (signal_pending(current))
7736 flush_signals(current);
7737 schedule();
7738 finish_wait(&resync_wait, &wq);
7739 goto try_again;
7740 }
7741 finish_wait(&resync_wait, &wq);
7742 }
7743 }
7744 } while (mddev->curr_resync < 2);
7745
7746 j = 0;
7747 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7748 /* resync follows the size requested by the personality,
7749 * which defaults to physical size, but can be virtual size
7750 */
7751 max_sectors = mddev->resync_max_sectors;
7752 atomic64_set(&mddev->resync_mismatches, 0);
7753 /* we don't use the checkpoint if there's a bitmap */
7754 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7755 j = mddev->resync_min;
7756 else if (!mddev->bitmap)
7757 j = mddev->recovery_cp;
7758
7759 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7760 max_sectors = mddev->resync_max_sectors;
7761 else {
7762 /* recovery follows the physical size of devices */
7763 max_sectors = mddev->dev_sectors;
7764 j = MaxSector;
7765 rcu_read_lock();
7766 rdev_for_each_rcu(rdev, mddev)
7767 if (rdev->raid_disk >= 0 &&
7768 !test_bit(Faulty, &rdev->flags) &&
7769 !test_bit(In_sync, &rdev->flags) &&
7770 rdev->recovery_offset < j)
7771 j = rdev->recovery_offset;
7772 rcu_read_unlock();
7773
7774 /* If there is a bitmap, we need to make sure all
7775 * writes that started before we added a spare
7776 * complete before we start doing a recovery.
7777 * Otherwise the write might complete and (via
7778 * bitmap_endwrite) set a bit in the bitmap after the
7779 * recovery has checked that bit and skipped that
7780 * region.
7781 */
7782 if (mddev->bitmap) {
7783 mddev->pers->quiesce(mddev, 1);
7784 mddev->pers->quiesce(mddev, 0);
7785 }
7786 }
7787
7788 printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
7789 printk(KERN_INFO "md: minimum _guaranteed_ speed:"
7790 " %d KB/sec/disk.\n", speed_min(mddev));
7791 printk(KERN_INFO "md: using maximum available idle IO bandwidth "
7792 "(but not more than %d KB/sec) for %s.\n",
7793 speed_max(mddev), desc);
7794
7795 is_mddev_idle(mddev, 1); /* this initializes IO event counters */
7796
7797 io_sectors = 0;
7798 for (m = 0; m < SYNC_MARKS; m++) {
7799 mark[m] = jiffies;
7800 mark_cnt[m] = io_sectors;
7801 }
7802 last_mark = 0;
7803 mddev->resync_mark = mark[last_mark];
7804 mddev->resync_mark_cnt = mark_cnt[last_mark];
7805
7806 /*
7807 * Tune reconstruction:
7808 */
7809 window = 32*(PAGE_SIZE/512);
7810 printk(KERN_INFO "md: using %dk window, over a total of %lluk.\n",
7811 window/2, (unsigned long long)max_sectors/2);
7812
7813 atomic_set(&mddev->recovery_active, 0);
7814 last_check = 0;
7815
7816 if (j>2) {
7817 printk(KERN_INFO
7818 "md: resuming %s of %s from checkpoint.\n",
7819 desc, mdname(mddev));
7820 mddev->curr_resync = j;
7821 } else
7822 mddev->curr_resync = 3; /* no longer delayed */
7823 mddev->curr_resync_completed = j;
7824 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
7825 md_new_event(mddev);
7826 update_time = jiffies;
7827
7828 blk_start_plug(&plug);
7829 while (j < max_sectors) {
7830 sector_t sectors;
7831
7832 skipped = 0;
7833
7834 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7835 ((mddev->curr_resync > mddev->curr_resync_completed &&
7836 (mddev->curr_resync - mddev->curr_resync_completed)
7837 > (max_sectors >> 4)) ||
7838 time_after_eq(jiffies, update_time + UPDATE_FREQUENCY) ||
7839 (j - mddev->curr_resync_completed)*2
7840 >= mddev->resync_max - mddev->curr_resync_completed ||
7841 mddev->curr_resync_completed > mddev->resync_max
7842 )) {
7843 /* time to update curr_resync_completed */
7844 wait_event(mddev->recovery_wait,
7845 atomic_read(&mddev->recovery_active) == 0);
7846 mddev->curr_resync_completed = j;
7847 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
7848 j > mddev->recovery_cp)
7849 mddev->recovery_cp = j;
7850 update_time = jiffies;
7851 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7852 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
7853 }
7854
7855 while (j >= mddev->resync_max &&
7856 !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
7857 /* As this condition is controlled by user-space,
7858 * we can block indefinitely, so use '_interruptible'
7859 * to avoid triggering warnings.
7860 */
7861 flush_signals(current); /* just in case */
7862 wait_event_interruptible(mddev->recovery_wait,
7863 mddev->resync_max > j
7864 || test_bit(MD_RECOVERY_INTR,
7865 &mddev->recovery));
7866 }
7867
7868 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7869 break;
7870
7871 sectors = mddev->pers->sync_request(mddev, j, &skipped);
7872 if (sectors == 0) {
7873 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7874 break;
7875 }
7876
7877 if (!skipped) { /* actual IO requested */
7878 io_sectors += sectors;
7879 atomic_add(sectors, &mddev->recovery_active);
7880 }
7881
7882 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7883 break;
7884
7885 j += sectors;
7886 if (j > max_sectors)
7887 /* when skipping, extra large numbers can be returned. */
7888 j = max_sectors;
7889 if (j > 2)
7890 mddev->curr_resync = j;
7891 mddev->curr_mark_cnt = io_sectors;
7892 if (last_check == 0)
7893 /* this is the earliest that rebuild will be
7894 * visible in /proc/mdstat
7895 */
7896 md_new_event(mddev);
7897
7898 if (last_check + window > io_sectors || j == max_sectors)
7899 continue;
7900
7901 last_check = io_sectors;
7902 repeat:
7903 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
7904 /* step marks */
7905 int next = (last_mark+1) % SYNC_MARKS;
7906
7907 mddev->resync_mark = mark[next];
7908 mddev->resync_mark_cnt = mark_cnt[next];
7909 mark[next] = jiffies;
7910 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
7911 last_mark = next;
7912 }
7913
7914 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7915 break;
7916
7917 /*
7918 * this loop exits only if either when we are slower than
7919 * the 'hard' speed limit, or the system was IO-idle for
7920 * a jiffy.
7921 * the system might be non-idle CPU-wise, but we only care
7922 * about not overloading the IO subsystem. (things like an
7923 * e2fsck being done on the RAID array should execute fast)
7924 */
7925 cond_resched();
7926
7927 recovery_done = io_sectors - atomic_read(&mddev->recovery_active);
7928 currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2
7929 /((jiffies-mddev->resync_mark)/HZ +1) +1;
7930
7931 if (currspeed > speed_min(mddev)) {
7932 if (currspeed > speed_max(mddev)) {
7933 msleep(500);
7934 goto repeat;
7935 }
7936 if (!is_mddev_idle(mddev, 0)) {
7937 /*
7938 * Give other IO more of a chance.
7939 * The faster the devices, the less we wait.
7940 */
7941 wait_event(mddev->recovery_wait,
7942 !atomic_read(&mddev->recovery_active));
7943 }
7944 }
7945 }
7946 printk(KERN_INFO "md: %s: %s %s.\n",mdname(mddev), desc,
7947 test_bit(MD_RECOVERY_INTR, &mddev->recovery)
7948 ? "interrupted" : "done");
7949 /*
7950 * this also signals 'finished resyncing' to md_stop
7951 */
7952 blk_finish_plug(&plug);
7953 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
7954
7955 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7956 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
7957 mddev->curr_resync > 2) {
7958 mddev->curr_resync_completed = mddev->curr_resync;
7959 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
7960 }
7961 /* tell personality and other nodes that we are finished */
7962 if (mddev_is_clustered(mddev)) {
7963 md_cluster_ops->resync_finish(mddev);
7964 cluster_resync_finished = true;
7965 }
7966 mddev->pers->sync_request(mddev, max_sectors, &skipped);
7967
7968 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
7969 mddev->curr_resync > 2) {
7970 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7971 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
7972 if (mddev->curr_resync >= mddev->recovery_cp) {
7973 printk(KERN_INFO
7974 "md: checkpointing %s of %s.\n",
7975 desc, mdname(mddev));
7976 if (test_bit(MD_RECOVERY_ERROR,
7977 &mddev->recovery))
7978 mddev->recovery_cp =
7979 mddev->curr_resync_completed;
7980 else
7981 mddev->recovery_cp =
7982 mddev->curr_resync;
7983 }
7984 } else
7985 mddev->recovery_cp = MaxSector;
7986 } else {
7987 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7988 mddev->curr_resync = MaxSector;
7989 rcu_read_lock();
7990 rdev_for_each_rcu(rdev, mddev)
7991 if (rdev->raid_disk >= 0 &&
7992 mddev->delta_disks >= 0 &&
7993 !test_bit(Faulty, &rdev->flags) &&
7994 !test_bit(In_sync, &rdev->flags) &&
7995 rdev->recovery_offset < mddev->curr_resync)
7996 rdev->recovery_offset = mddev->curr_resync;
7997 rcu_read_unlock();
7998 }
7999 }
8000 skip:
8001 set_bit(MD_CHANGE_DEVS, &mddev->flags);
8002
8003 if (mddev_is_clustered(mddev) &&
8004 test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8005 !cluster_resync_finished)
8006 md_cluster_ops->resync_finish(mddev);
8007
8008 spin_lock(&mddev->lock);
8009 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8010 /* We completed so min/max setting can be forgotten if used. */
8011 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8012 mddev->resync_min = 0;
8013 mddev->resync_max = MaxSector;
8014 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8015 mddev->resync_min = mddev->curr_resync_completed;
8016 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
8017 mddev->curr_resync = 0;
8018 spin_unlock(&mddev->lock);
8019
8020 wake_up(&resync_wait);
8021 md_wakeup_thread(mddev->thread);
8022 return;
8023 }
8024 EXPORT_SYMBOL_GPL(md_do_sync);
8025
8026 static int remove_and_add_spares(struct mddev *mddev,
8027 struct md_rdev *this)
8028 {
8029 struct md_rdev *rdev;
8030 int spares = 0;
8031 int removed = 0;
8032
8033 rdev_for_each(rdev, mddev)
8034 if ((this == NULL || rdev == this) &&
8035 rdev->raid_disk >= 0 &&
8036 !test_bit(Blocked, &rdev->flags) &&
8037 (test_bit(Faulty, &rdev->flags) ||
8038 ! test_bit(In_sync, &rdev->flags)) &&
8039 atomic_read(&rdev->nr_pending)==0) {
8040 if (mddev->pers->hot_remove_disk(
8041 mddev, rdev) == 0) {
8042 sysfs_unlink_rdev(mddev, rdev);
8043 rdev->raid_disk = -1;
8044 removed++;
8045 }
8046 }
8047 if (removed && mddev->kobj.sd)
8048 sysfs_notify(&mddev->kobj, NULL, "degraded");
8049
8050 if (this && removed)
8051 goto no_add;
8052
8053 rdev_for_each(rdev, mddev) {
8054 if (this && this != rdev)
8055 continue;
8056 if (test_bit(Candidate, &rdev->flags))
8057 continue;
8058 if (rdev->raid_disk >= 0 &&
8059 !test_bit(In_sync, &rdev->flags) &&
8060 !test_bit(Faulty, &rdev->flags))
8061 spares++;
8062 if (rdev->raid_disk >= 0)
8063 continue;
8064 if (test_bit(Faulty, &rdev->flags))
8065 continue;
8066 if (mddev->ro &&
8067 ! (rdev->saved_raid_disk >= 0 &&
8068 !test_bit(Bitmap_sync, &rdev->flags)))
8069 continue;
8070
8071 if (rdev->saved_raid_disk < 0)
8072 rdev->recovery_offset = 0;
8073 if (mddev->pers->
8074 hot_add_disk(mddev, rdev) == 0) {
8075 if (sysfs_link_rdev(mddev, rdev))
8076 /* failure here is OK */;
8077 spares++;
8078 md_new_event(mddev);
8079 set_bit(MD_CHANGE_DEVS, &mddev->flags);
8080 }
8081 }
8082 no_add:
8083 if (removed)
8084 set_bit(MD_CHANGE_DEVS, &mddev->flags);
8085 return spares;
8086 }
8087
8088 static void md_start_sync(struct work_struct *ws)
8089 {
8090 struct mddev *mddev = container_of(ws, struct mddev, del_work);
8091 int ret = 0;
8092
8093 if (mddev_is_clustered(mddev)) {
8094 ret = md_cluster_ops->resync_start(mddev);
8095 if (ret) {
8096 mddev->sync_thread = NULL;
8097 goto out;
8098 }
8099 }
8100
8101 mddev->sync_thread = md_register_thread(md_do_sync,
8102 mddev,
8103 "resync");
8104 out:
8105 if (!mddev->sync_thread) {
8106 if (!(mddev_is_clustered(mddev) && ret == -EAGAIN))
8107 printk(KERN_ERR "%s: could not start resync"
8108 " thread...\n",
8109 mdname(mddev));
8110 /* leave the spares where they are, it shouldn't hurt */
8111 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8112 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8113 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
8114 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8115 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8116 wake_up(&resync_wait);
8117 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
8118 &mddev->recovery))
8119 if (mddev->sysfs_action)
8120 sysfs_notify_dirent_safe(mddev->sysfs_action);
8121 } else
8122 md_wakeup_thread(mddev->sync_thread);
8123 sysfs_notify_dirent_safe(mddev->sysfs_action);
8124 md_new_event(mddev);
8125 }
8126
8127 /*
8128 * This routine is regularly called by all per-raid-array threads to
8129 * deal with generic issues like resync and super-block update.
8130 * Raid personalities that don't have a thread (linear/raid0) do not
8131 * need this as they never do any recovery or update the superblock.
8132 *
8133 * It does not do any resync itself, but rather "forks" off other threads
8134 * to do that as needed.
8135 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
8136 * "->recovery" and create a thread at ->sync_thread.
8137 * When the thread finishes it sets MD_RECOVERY_DONE
8138 * and wakeups up this thread which will reap the thread and finish up.
8139 * This thread also removes any faulty devices (with nr_pending == 0).
8140 *
8141 * The overall approach is:
8142 * 1/ if the superblock needs updating, update it.
8143 * 2/ If a recovery thread is running, don't do anything else.
8144 * 3/ If recovery has finished, clean up, possibly marking spares active.
8145 * 4/ If there are any faulty devices, remove them.
8146 * 5/ If array is degraded, try to add spares devices
8147 * 6/ If array has spares or is not in-sync, start a resync thread.
8148 */
8149 void md_check_recovery(struct mddev *mddev)
8150 {
8151 if (mddev->suspended)
8152 return;
8153
8154 if (mddev->bitmap)
8155 bitmap_daemon_work(mddev);
8156
8157 if (signal_pending(current)) {
8158 if (mddev->pers->sync_request && !mddev->external) {
8159 printk(KERN_INFO "md: %s in immediate safe mode\n",
8160 mdname(mddev));
8161 mddev->safemode = 2;
8162 }
8163 flush_signals(current);
8164 }
8165
8166 if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
8167 return;
8168 if ( ! (
8169 (mddev->flags & MD_UPDATE_SB_FLAGS & ~ (1<<MD_CHANGE_PENDING)) ||
8170 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
8171 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
8172 (mddev->external == 0 && mddev->safemode == 1) ||
8173 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
8174 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
8175 ))
8176 return;
8177
8178 if (mddev_trylock(mddev)) {
8179 int spares = 0;
8180
8181 if (mddev->ro) {
8182 struct md_rdev *rdev;
8183 if (!mddev->external && mddev->in_sync)
8184 /* 'Blocked' flag not needed as failed devices
8185 * will be recorded if array switched to read/write.
8186 * Leaving it set will prevent the device
8187 * from being removed.
8188 */
8189 rdev_for_each(rdev, mddev)
8190 clear_bit(Blocked, &rdev->flags);
8191 /* On a read-only array we can:
8192 * - remove failed devices
8193 * - add already-in_sync devices if the array itself
8194 * is in-sync.
8195 * As we only add devices that are already in-sync,
8196 * we can activate the spares immediately.
8197 */
8198 remove_and_add_spares(mddev, NULL);
8199 /* There is no thread, but we need to call
8200 * ->spare_active and clear saved_raid_disk
8201 */
8202 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8203 md_reap_sync_thread(mddev);
8204 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8205 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8206 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
8207 goto unlock;
8208 }
8209
8210 if (!mddev->external) {
8211 int did_change = 0;
8212 spin_lock(&mddev->lock);
8213 if (mddev->safemode &&
8214 !atomic_read(&mddev->writes_pending) &&
8215 !mddev->in_sync &&
8216 mddev->recovery_cp == MaxSector) {
8217 mddev->in_sync = 1;
8218 did_change = 1;
8219 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
8220 }
8221 if (mddev->safemode == 1)
8222 mddev->safemode = 0;
8223 spin_unlock(&mddev->lock);
8224 if (did_change)
8225 sysfs_notify_dirent_safe(mddev->sysfs_state);
8226 }
8227
8228 if (mddev->flags & MD_UPDATE_SB_FLAGS)
8229 md_update_sb(mddev, 0);
8230
8231 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
8232 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
8233 /* resync/recovery still happening */
8234 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8235 goto unlock;
8236 }
8237 if (mddev->sync_thread) {
8238 md_reap_sync_thread(mddev);
8239 goto unlock;
8240 }
8241 /* Set RUNNING before clearing NEEDED to avoid
8242 * any transients in the value of "sync_action".
8243 */
8244 mddev->curr_resync_completed = 0;
8245 spin_lock(&mddev->lock);
8246 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8247 spin_unlock(&mddev->lock);
8248 /* Clear some bits that don't mean anything, but
8249 * might be left set
8250 */
8251 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
8252 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
8253
8254 if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
8255 test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
8256 goto not_running;
8257 /* no recovery is running.
8258 * remove any failed drives, then
8259 * add spares if possible.
8260 * Spares are also removed and re-added, to allow
8261 * the personality to fail the re-add.
8262 */
8263
8264 if (mddev->reshape_position != MaxSector) {
8265 if (mddev->pers->check_reshape == NULL ||
8266 mddev->pers->check_reshape(mddev) != 0)
8267 /* Cannot proceed */
8268 goto not_running;
8269 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8270 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8271 } else if ((spares = remove_and_add_spares(mddev, NULL))) {
8272 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8273 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8274 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
8275 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8276 } else if (mddev->recovery_cp < MaxSector) {
8277 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8278 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8279 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
8280 /* nothing to be done ... */
8281 goto not_running;
8282
8283 if (mddev->pers->sync_request) {
8284 if (spares) {
8285 /* We are adding a device or devices to an array
8286 * which has the bitmap stored on all devices.
8287 * So make sure all bitmap pages get written
8288 */
8289 bitmap_write_all(mddev->bitmap);
8290 }
8291 INIT_WORK(&mddev->del_work, md_start_sync);
8292 queue_work(md_misc_wq, &mddev->del_work);
8293 goto unlock;
8294 }
8295 not_running:
8296 if (!mddev->sync_thread) {
8297 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8298 wake_up(&resync_wait);
8299 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
8300 &mddev->recovery))
8301 if (mddev->sysfs_action)
8302 sysfs_notify_dirent_safe(mddev->sysfs_action);
8303 }
8304 unlock:
8305 wake_up(&mddev->sb_wait);
8306 mddev_unlock(mddev);
8307 }
8308 }
8309 EXPORT_SYMBOL(md_check_recovery);
8310
8311 void md_reap_sync_thread(struct mddev *mddev)
8312 {
8313 struct md_rdev *rdev;
8314
8315 /* resync has finished, collect result */
8316 md_unregister_thread(&mddev->sync_thread);
8317 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8318 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
8319 /* success...*/
8320 /* activate any spares */
8321 if (mddev->pers->spare_active(mddev)) {
8322 sysfs_notify(&mddev->kobj, NULL,
8323 "degraded");
8324 set_bit(MD_CHANGE_DEVS, &mddev->flags);
8325 }
8326 }
8327 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8328 mddev->pers->finish_reshape)
8329 mddev->pers->finish_reshape(mddev);
8330
8331 /* If array is no-longer degraded, then any saved_raid_disk
8332 * information must be scrapped.
8333 */
8334 if (!mddev->degraded)
8335 rdev_for_each(rdev, mddev)
8336 rdev->saved_raid_disk = -1;
8337
8338 md_update_sb(mddev, 1);
8339 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8340 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
8341 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8342 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8343 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
8344 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8345 wake_up(&resync_wait);
8346 /* flag recovery needed just to double check */
8347 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8348 sysfs_notify_dirent_safe(mddev->sysfs_action);
8349 md_new_event(mddev);
8350 if (mddev->event_work.func)
8351 queue_work(md_misc_wq, &mddev->event_work);
8352 }
8353 EXPORT_SYMBOL(md_reap_sync_thread);
8354
8355 void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
8356 {
8357 sysfs_notify_dirent_safe(rdev->sysfs_state);
8358 wait_event_timeout(rdev->blocked_wait,
8359 !test_bit(Blocked, &rdev->flags) &&
8360 !test_bit(BlockedBadBlocks, &rdev->flags),
8361 msecs_to_jiffies(5000));
8362 rdev_dec_pending(rdev, mddev);
8363 }
8364 EXPORT_SYMBOL(md_wait_for_blocked_rdev);
8365
8366 void md_finish_reshape(struct mddev *mddev)
8367 {
8368 /* called be personality module when reshape completes. */
8369 struct md_rdev *rdev;
8370
8371 rdev_for_each(rdev, mddev) {
8372 if (rdev->data_offset > rdev->new_data_offset)
8373 rdev->sectors += rdev->data_offset - rdev->new_data_offset;
8374 else
8375 rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
8376 rdev->data_offset = rdev->new_data_offset;
8377 }
8378 }
8379 EXPORT_SYMBOL(md_finish_reshape);
8380
8381 /* Bad block management.
8382 * We can record which blocks on each device are 'bad' and so just
8383 * fail those blocks, or that stripe, rather than the whole device.
8384 * Entries in the bad-block table are 64bits wide. This comprises:
8385 * Length of bad-range, in sectors: 0-511 for lengths 1-512
8386 * Start of bad-range, sector offset, 54 bits (allows 8 exbibytes)
8387 * A 'shift' can be set so that larger blocks are tracked and
8388 * consequently larger devices can be covered.
8389 * 'Acknowledged' flag - 1 bit. - the most significant bit.
8390 *
8391 * Locking of the bad-block table uses a seqlock so md_is_badblock
8392 * might need to retry if it is very unlucky.
8393 * We will sometimes want to check for bad blocks in a bi_end_io function,
8394 * so we use the write_seqlock_irq variant.
8395 *
8396 * When looking for a bad block we specify a range and want to
8397 * know if any block in the range is bad. So we binary-search
8398 * to the last range that starts at-or-before the given endpoint,
8399 * (or "before the sector after the target range")
8400 * then see if it ends after the given start.
8401 * We return
8402 * 0 if there are no known bad blocks in the range
8403 * 1 if there are known bad block which are all acknowledged
8404 * -1 if there are bad blocks which have not yet been acknowledged in metadata.
8405 * plus the start/length of the first bad section we overlap.
8406 */
8407 int md_is_badblock(struct badblocks *bb, sector_t s, int sectors,
8408 sector_t *first_bad, int *bad_sectors)
8409 {
8410 int hi;
8411 int lo;
8412 u64 *p = bb->page;
8413 int rv;
8414 sector_t target = s + sectors;
8415 unsigned seq;
8416
8417 if (bb->shift > 0) {
8418 /* round the start down, and the end up */
8419 s >>= bb->shift;
8420 target += (1<<bb->shift) - 1;
8421 target >>= bb->shift;
8422 sectors = target - s;
8423 }
8424 /* 'target' is now the first block after the bad range */
8425
8426 retry:
8427 seq = read_seqbegin(&bb->lock);
8428 lo = 0;
8429 rv = 0;
8430 hi = bb->count;
8431
8432 /* Binary search between lo and hi for 'target'
8433 * i.e. for the last range that starts before 'target'
8434 */
8435 /* INVARIANT: ranges before 'lo' and at-or-after 'hi'
8436 * are known not to be the last range before target.
8437 * VARIANT: hi-lo is the number of possible
8438 * ranges, and decreases until it reaches 1
8439 */
8440 while (hi - lo > 1) {
8441 int mid = (lo + hi) / 2;
8442 sector_t a = BB_OFFSET(p[mid]);
8443 if (a < target)
8444 /* This could still be the one, earlier ranges
8445 * could not. */
8446 lo = mid;
8447 else
8448 /* This and later ranges are definitely out. */
8449 hi = mid;
8450 }
8451 /* 'lo' might be the last that started before target, but 'hi' isn't */
8452 if (hi > lo) {
8453 /* need to check all range that end after 's' to see if
8454 * any are unacknowledged.
8455 */
8456 while (lo >= 0 &&
8457 BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > s) {
8458 if (BB_OFFSET(p[lo]) < target) {
8459 /* starts before the end, and finishes after
8460 * the start, so they must overlap
8461 */
8462 if (rv != -1 && BB_ACK(p[lo]))
8463 rv = 1;
8464 else
8465 rv = -1;
8466 *first_bad = BB_OFFSET(p[lo]);
8467 *bad_sectors = BB_LEN(p[lo]);
8468 }
8469 lo--;
8470 }
8471 }
8472
8473 if (read_seqretry(&bb->lock, seq))
8474 goto retry;
8475
8476 return rv;
8477 }
8478 EXPORT_SYMBOL_GPL(md_is_badblock);
8479
8480 /*
8481 * Add a range of bad blocks to the table.
8482 * This might extend the table, or might contract it
8483 * if two adjacent ranges can be merged.
8484 * We binary-search to find the 'insertion' point, then
8485 * decide how best to handle it.
8486 */
8487 static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
8488 int acknowledged)
8489 {
8490 u64 *p;
8491 int lo, hi;
8492 int rv = 1;
8493 unsigned long flags;
8494
8495 if (bb->shift < 0)
8496 /* badblocks are disabled */
8497 return 0;
8498
8499 if (bb->shift) {
8500 /* round the start down, and the end up */
8501 sector_t next = s + sectors;
8502 s >>= bb->shift;
8503 next += (1<<bb->shift) - 1;
8504 next >>= bb->shift;
8505 sectors = next - s;
8506 }
8507
8508 write_seqlock_irqsave(&bb->lock, flags);
8509
8510 p = bb->page;
8511 lo = 0;
8512 hi = bb->count;
8513 /* Find the last range that starts at-or-before 's' */
8514 while (hi - lo > 1) {
8515 int mid = (lo + hi) / 2;
8516 sector_t a = BB_OFFSET(p[mid]);
8517 if (a <= s)
8518 lo = mid;
8519 else
8520 hi = mid;
8521 }
8522 if (hi > lo && BB_OFFSET(p[lo]) > s)
8523 hi = lo;
8524
8525 if (hi > lo) {
8526 /* we found a range that might merge with the start
8527 * of our new range
8528 */
8529 sector_t a = BB_OFFSET(p[lo]);
8530 sector_t e = a + BB_LEN(p[lo]);
8531 int ack = BB_ACK(p[lo]);
8532 if (e >= s) {
8533 /* Yes, we can merge with a previous range */
8534 if (s == a && s + sectors >= e)
8535 /* new range covers old */
8536 ack = acknowledged;
8537 else
8538 ack = ack && acknowledged;
8539
8540 if (e < s + sectors)
8541 e = s + sectors;
8542 if (e - a <= BB_MAX_LEN) {
8543 p[lo] = BB_MAKE(a, e-a, ack);
8544 s = e;
8545 } else {
8546 /* does not all fit in one range,
8547 * make p[lo] maximal
8548 */
8549 if (BB_LEN(p[lo]) != BB_MAX_LEN)
8550 p[lo] = BB_MAKE(a, BB_MAX_LEN, ack);
8551 s = a + BB_MAX_LEN;
8552 }
8553 sectors = e - s;
8554 }
8555 }
8556 if (sectors && hi < bb->count) {
8557 /* 'hi' points to the first range that starts after 's'.
8558 * Maybe we can merge with the start of that range */
8559 sector_t a = BB_OFFSET(p[hi]);
8560 sector_t e = a + BB_LEN(p[hi]);
8561 int ack = BB_ACK(p[hi]);
8562 if (a <= s + sectors) {
8563 /* merging is possible */
8564 if (e <= s + sectors) {
8565 /* full overlap */
8566 e = s + sectors;
8567 ack = acknowledged;
8568 } else
8569 ack = ack && acknowledged;
8570
8571 a = s;
8572 if (e - a <= BB_MAX_LEN) {
8573 p[hi] = BB_MAKE(a, e-a, ack);
8574 s = e;
8575 } else {
8576 p[hi] = BB_MAKE(a, BB_MAX_LEN, ack);
8577 s = a + BB_MAX_LEN;
8578 }
8579 sectors = e - s;
8580 lo = hi;
8581 hi++;
8582 }
8583 }
8584 if (sectors == 0 && hi < bb->count) {
8585 /* we might be able to combine lo and hi */
8586 /* Note: 's' is at the end of 'lo' */
8587 sector_t a = BB_OFFSET(p[hi]);
8588 int lolen = BB_LEN(p[lo]);
8589 int hilen = BB_LEN(p[hi]);
8590 int newlen = lolen + hilen - (s - a);
8591 if (s >= a && newlen < BB_MAX_LEN) {
8592 /* yes, we can combine them */
8593 int ack = BB_ACK(p[lo]) && BB_ACK(p[hi]);
8594 p[lo] = BB_MAKE(BB_OFFSET(p[lo]), newlen, ack);
8595 memmove(p + hi, p + hi + 1,
8596 (bb->count - hi - 1) * 8);
8597 bb->count--;
8598 }
8599 }
8600 while (sectors) {
8601 /* didn't merge (it all).
8602 * Need to add a range just before 'hi' */
8603 if (bb->count >= MD_MAX_BADBLOCKS) {
8604 /* No room for more */
8605 rv = 0;
8606 break;
8607 } else {
8608 int this_sectors = sectors;
8609 memmove(p + hi + 1, p + hi,
8610 (bb->count - hi) * 8);
8611 bb->count++;
8612
8613 if (this_sectors > BB_MAX_LEN)
8614 this_sectors = BB_MAX_LEN;
8615 p[hi] = BB_MAKE(s, this_sectors, acknowledged);
8616 sectors -= this_sectors;
8617 s += this_sectors;
8618 }
8619 }
8620
8621 bb->changed = 1;
8622 if (!acknowledged)
8623 bb->unacked_exist = 1;
8624 write_sequnlock_irqrestore(&bb->lock, flags);
8625
8626 return rv;
8627 }
8628
8629 int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
8630 int is_new)
8631 {
8632 int rv;
8633 if (is_new)
8634 s += rdev->new_data_offset;
8635 else
8636 s += rdev->data_offset;
8637 rv = md_set_badblocks(&rdev->badblocks,
8638 s, sectors, 0);
8639 if (rv) {
8640 /* Make sure they get written out promptly */
8641 sysfs_notify_dirent_safe(rdev->sysfs_state);
8642 set_bit(MD_CHANGE_CLEAN, &rdev->mddev->flags);
8643 set_bit(MD_CHANGE_PENDING, &rdev->mddev->flags);
8644 md_wakeup_thread(rdev->mddev->thread);
8645 }
8646 return rv;
8647 }
8648 EXPORT_SYMBOL_GPL(rdev_set_badblocks);
8649
8650 /*
8651 * Remove a range of bad blocks from the table.
8652 * This may involve extending the table if we spilt a region,
8653 * but it must not fail. So if the table becomes full, we just
8654 * drop the remove request.
8655 */
8656 static int md_clear_badblocks(struct badblocks *bb, sector_t s, int sectors)
8657 {
8658 u64 *p;
8659 int lo, hi;
8660 sector_t target = s + sectors;
8661 int rv = 0;
8662
8663 if (bb->shift > 0) {
8664 /* When clearing we round the start up and the end down.
8665 * This should not matter as the shift should align with
8666 * the block size and no rounding should ever be needed.
8667 * However it is better the think a block is bad when it
8668 * isn't than to think a block is not bad when it is.
8669 */
8670 s += (1<<bb->shift) - 1;
8671 s >>= bb->shift;
8672 target >>= bb->shift;
8673 sectors = target - s;
8674 }
8675
8676 write_seqlock_irq(&bb->lock);
8677
8678 p = bb->page;
8679 lo = 0;
8680 hi = bb->count;
8681 /* Find the last range that starts before 'target' */
8682 while (hi - lo > 1) {
8683 int mid = (lo + hi) / 2;
8684 sector_t a = BB_OFFSET(p[mid]);
8685 if (a < target)
8686 lo = mid;
8687 else
8688 hi = mid;
8689 }
8690 if (hi > lo) {
8691 /* p[lo] is the last range that could overlap the
8692 * current range. Earlier ranges could also overlap,
8693 * but only this one can overlap the end of the range.
8694 */
8695 if (BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > target) {
8696 /* Partial overlap, leave the tail of this range */
8697 int ack = BB_ACK(p[lo]);
8698 sector_t a = BB_OFFSET(p[lo]);
8699 sector_t end = a + BB_LEN(p[lo]);
8700
8701 if (a < s) {
8702 /* we need to split this range */
8703 if (bb->count >= MD_MAX_BADBLOCKS) {
8704 rv = -ENOSPC;
8705 goto out;
8706 }
8707 memmove(p+lo+1, p+lo, (bb->count - lo) * 8);
8708 bb->count++;
8709 p[lo] = BB_MAKE(a, s-a, ack);
8710 lo++;
8711 }
8712 p[lo] = BB_MAKE(target, end - target, ack);
8713 /* there is no longer an overlap */
8714 hi = lo;
8715 lo--;
8716 }
8717 while (lo >= 0 &&
8718 BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > s) {
8719 /* This range does overlap */
8720 if (BB_OFFSET(p[lo]) < s) {
8721 /* Keep the early parts of this range. */
8722 int ack = BB_ACK(p[lo]);
8723 sector_t start = BB_OFFSET(p[lo]);
8724 p[lo] = BB_MAKE(start, s - start, ack);
8725 /* now low doesn't overlap, so.. */
8726 break;
8727 }
8728 lo--;
8729 }
8730 /* 'lo' is strictly before, 'hi' is strictly after,
8731 * anything between needs to be discarded
8732 */
8733 if (hi - lo > 1) {
8734 memmove(p+lo+1, p+hi, (bb->count - hi) * 8);
8735 bb->count -= (hi - lo - 1);
8736 }
8737 }
8738
8739 bb->changed = 1;
8740 out:
8741 write_sequnlock_irq(&bb->lock);
8742 return rv;
8743 }
8744
8745 int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
8746 int is_new)
8747 {
8748 if (is_new)
8749 s += rdev->new_data_offset;
8750 else
8751 s += rdev->data_offset;
8752 return md_clear_badblocks(&rdev->badblocks,
8753 s, sectors);
8754 }
8755 EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
8756
8757 /*
8758 * Acknowledge all bad blocks in a list.
8759 * This only succeeds if ->changed is clear. It is used by
8760 * in-kernel metadata updates
8761 */
8762 void md_ack_all_badblocks(struct badblocks *bb)
8763 {
8764 if (bb->page == NULL || bb->changed)
8765 /* no point even trying */
8766 return;
8767 write_seqlock_irq(&bb->lock);
8768
8769 if (bb->changed == 0 && bb->unacked_exist) {
8770 u64 *p = bb->page;
8771 int i;
8772 for (i = 0; i < bb->count ; i++) {
8773 if (!BB_ACK(p[i])) {
8774 sector_t start = BB_OFFSET(p[i]);
8775 int len = BB_LEN(p[i]);
8776 p[i] = BB_MAKE(start, len, 1);
8777 }
8778 }
8779 bb->unacked_exist = 0;
8780 }
8781 write_sequnlock_irq(&bb->lock);
8782 }
8783 EXPORT_SYMBOL_GPL(md_ack_all_badblocks);
8784
8785 /* sysfs access to bad-blocks list.
8786 * We present two files.
8787 * 'bad-blocks' lists sector numbers and lengths of ranges that
8788 * are recorded as bad. The list is truncated to fit within
8789 * the one-page limit of sysfs.
8790 * Writing "sector length" to this file adds an acknowledged
8791 * bad block list.
8792 * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
8793 * been acknowledged. Writing to this file adds bad blocks
8794 * without acknowledging them. This is largely for testing.
8795 */
8796
8797 static ssize_t
8798 badblocks_show(struct badblocks *bb, char *page, int unack)
8799 {
8800 size_t len;
8801 int i;
8802 u64 *p = bb->page;
8803 unsigned seq;
8804
8805 if (bb->shift < 0)
8806 return 0;
8807
8808 retry:
8809 seq = read_seqbegin(&bb->lock);
8810
8811 len = 0;
8812 i = 0;
8813
8814 while (len < PAGE_SIZE && i < bb->count) {
8815 sector_t s = BB_OFFSET(p[i]);
8816 unsigned int length = BB_LEN(p[i]);
8817 int ack = BB_ACK(p[i]);
8818 i++;
8819
8820 if (unack && ack)
8821 continue;
8822
8823 len += snprintf(page+len, PAGE_SIZE-len, "%llu %u\n",
8824 (unsigned long long)s << bb->shift,
8825 length << bb->shift);
8826 }
8827 if (unack && len == 0)
8828 bb->unacked_exist = 0;
8829
8830 if (read_seqretry(&bb->lock, seq))
8831 goto retry;
8832
8833 return len;
8834 }
8835
8836 #define DO_DEBUG 1
8837
8838 static ssize_t
8839 badblocks_store(struct badblocks *bb, const char *page, size_t len, int unack)
8840 {
8841 unsigned long long sector;
8842 int length;
8843 char newline;
8844 #ifdef DO_DEBUG
8845 /* Allow clearing via sysfs *only* for testing/debugging.
8846 * Normally only a successful write may clear a badblock
8847 */
8848 int clear = 0;
8849 if (page[0] == '-') {
8850 clear = 1;
8851 page++;
8852 }
8853 #endif /* DO_DEBUG */
8854
8855 switch (sscanf(page, "%llu %d%c", &sector, &length, &newline)) {
8856 case 3:
8857 if (newline != '\n')
8858 return -EINVAL;
8859 case 2:
8860 if (length <= 0)
8861 return -EINVAL;
8862 break;
8863 default:
8864 return -EINVAL;
8865 }
8866
8867 #ifdef DO_DEBUG
8868 if (clear) {
8869 md_clear_badblocks(bb, sector, length);
8870 return len;
8871 }
8872 #endif /* DO_DEBUG */
8873 if (md_set_badblocks(bb, sector, length, !unack))
8874 return len;
8875 else
8876 return -ENOSPC;
8877 }
8878
8879 static int md_notify_reboot(struct notifier_block *this,
8880 unsigned long code, void *x)
8881 {
8882 struct list_head *tmp;
8883 struct mddev *mddev;
8884 int need_delay = 0;
8885
8886 for_each_mddev(mddev, tmp) {
8887 if (mddev_trylock(mddev)) {
8888 if (mddev->pers)
8889 __md_stop_writes(mddev);
8890 if (mddev->persistent)
8891 mddev->safemode = 2;
8892 mddev_unlock(mddev);
8893 }
8894 need_delay = 1;
8895 }
8896 /*
8897 * certain more exotic SCSI devices are known to be
8898 * volatile wrt too early system reboots. While the
8899 * right place to handle this issue is the given
8900 * driver, we do want to have a safe RAID driver ...
8901 */
8902 if (need_delay)
8903 mdelay(1000*1);
8904
8905 return NOTIFY_DONE;
8906 }
8907
8908 static struct notifier_block md_notifier = {
8909 .notifier_call = md_notify_reboot,
8910 .next = NULL,
8911 .priority = INT_MAX, /* before any real devices */
8912 };
8913
8914 static void md_geninit(void)
8915 {
8916 pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
8917
8918 proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
8919 }
8920
8921 static int __init md_init(void)
8922 {
8923 int ret = -ENOMEM;
8924
8925 md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
8926 if (!md_wq)
8927 goto err_wq;
8928
8929 md_misc_wq = alloc_workqueue("md_misc", 0, 0);
8930 if (!md_misc_wq)
8931 goto err_misc_wq;
8932
8933 if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
8934 goto err_md;
8935
8936 if ((ret = register_blkdev(0, "mdp")) < 0)
8937 goto err_mdp;
8938 mdp_major = ret;
8939
8940 blk_register_region(MKDEV(MD_MAJOR, 0), 512, THIS_MODULE,
8941 md_probe, NULL, NULL);
8942 blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
8943 md_probe, NULL, NULL);
8944
8945 register_reboot_notifier(&md_notifier);
8946 raid_table_header = register_sysctl_table(raid_root_table);
8947
8948 md_geninit();
8949 return 0;
8950
8951 err_mdp:
8952 unregister_blkdev(MD_MAJOR, "md");
8953 err_md:
8954 destroy_workqueue(md_misc_wq);
8955 err_misc_wq:
8956 destroy_workqueue(md_wq);
8957 err_wq:
8958 return ret;
8959 }
8960
8961 static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev)
8962 {
8963 struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
8964 struct md_rdev *rdev2;
8965 int role, ret;
8966 char b[BDEVNAME_SIZE];
8967
8968 /* Check for change of roles in the active devices */
8969 rdev_for_each(rdev2, mddev) {
8970 if (test_bit(Faulty, &rdev2->flags))
8971 continue;
8972
8973 /* Check if the roles changed */
8974 role = le16_to_cpu(sb->dev_roles[rdev2->desc_nr]);
8975
8976 if (test_bit(Candidate, &rdev2->flags)) {
8977 if (role == 0xfffe) {
8978 pr_info("md: Removing Candidate device %s because add failed\n", bdevname(rdev2->bdev,b));
8979 md_kick_rdev_from_array(rdev2);
8980 continue;
8981 }
8982 else
8983 clear_bit(Candidate, &rdev2->flags);
8984 }
8985
8986 if (role != rdev2->raid_disk) {
8987 /* got activated */
8988 if (rdev2->raid_disk == -1 && role != 0xffff) {
8989 rdev2->saved_raid_disk = role;
8990 ret = remove_and_add_spares(mddev, rdev2);
8991 pr_info("Activated spare: %s\n",
8992 bdevname(rdev2->bdev,b));
8993 continue;
8994 }
8995 /* device faulty
8996 * We just want to do the minimum to mark the disk
8997 * as faulty. The recovery is performed by the
8998 * one who initiated the error.
8999 */
9000 if ((role == 0xfffe) || (role == 0xfffd)) {
9001 md_error(mddev, rdev2);
9002 clear_bit(Blocked, &rdev2->flags);
9003 }
9004 }
9005 }
9006
9007 /* recovery_cp changed */
9008 if (le64_to_cpu(sb->resync_offset) != mddev->recovery_cp)
9009 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
9010
9011 /* Finally set the event to be up to date */
9012 mddev->events = le64_to_cpu(sb->events);
9013 }
9014
9015 static int read_rdev(struct mddev *mddev, struct md_rdev *rdev)
9016 {
9017 int err;
9018 struct page *swapout = rdev->sb_page;
9019 struct mdp_superblock_1 *sb;
9020
9021 /* Store the sb page of the rdev in the swapout temporary
9022 * variable in case we err in the future
9023 */
9024 rdev->sb_page = NULL;
9025 alloc_disk_sb(rdev);
9026 ClearPageUptodate(rdev->sb_page);
9027 rdev->sb_loaded = 0;
9028 err = super_types[mddev->major_version].load_super(rdev, NULL, mddev->minor_version);
9029
9030 if (err < 0) {
9031 pr_warn("%s: %d Could not reload rdev(%d) err: %d. Restoring old values\n",
9032 __func__, __LINE__, rdev->desc_nr, err);
9033 put_page(rdev->sb_page);
9034 rdev->sb_page = swapout;
9035 rdev->sb_loaded = 1;
9036 return err;
9037 }
9038
9039 sb = page_address(rdev->sb_page);
9040 /* Read the offset unconditionally, even if MD_FEATURE_RECOVERY_OFFSET
9041 * is not set
9042 */
9043
9044 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET))
9045 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
9046
9047 /* The other node finished recovery, call spare_active to set
9048 * device In_sync and mddev->degraded
9049 */
9050 if (rdev->recovery_offset == MaxSector &&
9051 !test_bit(In_sync, &rdev->flags) &&
9052 mddev->pers->spare_active(mddev))
9053 sysfs_notify(&mddev->kobj, NULL, "degraded");
9054
9055 put_page(swapout);
9056 return 0;
9057 }
9058
9059 void md_reload_sb(struct mddev *mddev, int nr)
9060 {
9061 struct md_rdev *rdev;
9062 int err;
9063
9064 /* Find the rdev */
9065 rdev_for_each_rcu(rdev, mddev) {
9066 if (rdev->desc_nr == nr)
9067 break;
9068 }
9069
9070 if (!rdev || rdev->desc_nr != nr) {
9071 pr_warn("%s: %d Could not find rdev with nr %d\n", __func__, __LINE__, nr);
9072 return;
9073 }
9074
9075 err = read_rdev(mddev, rdev);
9076 if (err < 0)
9077 return;
9078
9079 check_sb_changes(mddev, rdev);
9080
9081 /* Read all rdev's to update recovery_offset */
9082 rdev_for_each_rcu(rdev, mddev)
9083 read_rdev(mddev, rdev);
9084 }
9085 EXPORT_SYMBOL(md_reload_sb);
9086
9087 #ifndef MODULE
9088
9089 /*
9090 * Searches all registered partitions for autorun RAID arrays
9091 * at boot time.
9092 */
9093
9094 static LIST_HEAD(all_detected_devices);
9095 struct detected_devices_node {
9096 struct list_head list;
9097 dev_t dev;
9098 };
9099
9100 void md_autodetect_dev(dev_t dev)
9101 {
9102 struct detected_devices_node *node_detected_dev;
9103
9104 node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
9105 if (node_detected_dev) {
9106 node_detected_dev->dev = dev;
9107 list_add_tail(&node_detected_dev->list, &all_detected_devices);
9108 } else {
9109 printk(KERN_CRIT "md: md_autodetect_dev: kzalloc failed"
9110 ", skipping dev(%d,%d)\n", MAJOR(dev), MINOR(dev));
9111 }
9112 }
9113
9114 static void autostart_arrays(int part)
9115 {
9116 struct md_rdev *rdev;
9117 struct detected_devices_node *node_detected_dev;
9118 dev_t dev;
9119 int i_scanned, i_passed;
9120
9121 i_scanned = 0;
9122 i_passed = 0;
9123
9124 printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
9125
9126 while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
9127 i_scanned++;
9128 node_detected_dev = list_entry(all_detected_devices.next,
9129 struct detected_devices_node, list);
9130 list_del(&node_detected_dev->list);
9131 dev = node_detected_dev->dev;
9132 kfree(node_detected_dev);
9133 rdev = md_import_device(dev,0, 90);
9134 if (IS_ERR(rdev))
9135 continue;
9136
9137 if (test_bit(Faulty, &rdev->flags))
9138 continue;
9139
9140 set_bit(AutoDetected, &rdev->flags);
9141 list_add(&rdev->same_set, &pending_raid_disks);
9142 i_passed++;
9143 }
9144
9145 printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
9146 i_scanned, i_passed);
9147
9148 autorun_devices(part);
9149 }
9150
9151 #endif /* !MODULE */
9152
9153 static __exit void md_exit(void)
9154 {
9155 struct mddev *mddev;
9156 struct list_head *tmp;
9157 int delay = 1;
9158
9159 blk_unregister_region(MKDEV(MD_MAJOR,0), 512);
9160 blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
9161
9162 unregister_blkdev(MD_MAJOR,"md");
9163 unregister_blkdev(mdp_major, "mdp");
9164 unregister_reboot_notifier(&md_notifier);
9165 unregister_sysctl_table(raid_table_header);
9166
9167 /* We cannot unload the modules while some process is
9168 * waiting for us in select() or poll() - wake them up
9169 */
9170 md_unloading = 1;
9171 while (waitqueue_active(&md_event_waiters)) {
9172 /* not safe to leave yet */
9173 wake_up(&md_event_waiters);
9174 msleep(delay);
9175 delay += delay;
9176 }
9177 remove_proc_entry("mdstat", NULL);
9178
9179 for_each_mddev(mddev, tmp) {
9180 export_array(mddev);
9181 mddev->hold_active = 0;
9182 }
9183 destroy_workqueue(md_misc_wq);
9184 destroy_workqueue(md_wq);
9185 }
9186
9187 subsys_initcall(md_init);
9188 module_exit(md_exit)
9189
9190 static int get_ro(char *buffer, struct kernel_param *kp)
9191 {
9192 return sprintf(buffer, "%d", start_readonly);
9193 }
9194 static int set_ro(const char *val, struct kernel_param *kp)
9195 {
9196 return kstrtouint(val, 10, (unsigned int *)&start_readonly);
9197 }
9198
9199 module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
9200 module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
9201 module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
9202
9203 MODULE_LICENSE("GPL");
9204 MODULE_DESCRIPTION("MD RAID framework");
9205 MODULE_ALIAS("md");
9206 MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);
Ubuntu Artful kernel mirror