Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 md.c : Multiple Devices driver for Linux
4 Copyright (C) 1998, 1999, 2000 Ingo Molnar
5
6 completely rewritten, based on the MD driver code from Marc Zyngier
7
8 Changes:
9
10 - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
11 - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
12 - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
13 - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
14 - kmod support by: Cyrus Durgin
15 - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
16 - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
17
18 - lots of fixes and improvements to the RAID1/RAID5 and generic
19 RAID code (such as request based resynchronization):
20
21 Neil Brown <neilb@cse.unsw.edu.au>.
22
23 - persistent bitmap code
24 Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
25
26
27 Errors, Warnings, etc.
28 Please use:
29 pr_crit() for error conditions that risk data loss
30 pr_err() for error conditions that are unexpected, like an IO error
31 or internal inconsistency
32 pr_warn() for error conditions that could have been predicated, like
33 adding a device to an array when it has incompatible metadata
34 pr_info() for every interesting, very rare events, like an array starting
35 or stopping, or resync starting or stopping
36 pr_debug() for everything else.
37
38*/
39
40#include <linux/sched/mm.h>
41#include <linux/sched/signal.h>
42#include <linux/kthread.h>
43#include <linux/blkdev.h>
44#include <linux/blk-integrity.h>
45#include <linux/badblocks.h>
46#include <linux/sysctl.h>
47#include <linux/seq_file.h>
48#include <linux/fs.h>
49#include <linux/poll.h>
50#include <linux/ctype.h>
51#include <linux/string.h>
52#include <linux/hdreg.h>
53#include <linux/proc_fs.h>
54#include <linux/random.h>
55#include <linux/major.h>
56#include <linux/module.h>
57#include <linux/reboot.h>
58#include <linux/file.h>
59#include <linux/compat.h>
60#include <linux/delay.h>
61#include <linux/raid/md_p.h>
62#include <linux/raid/md_u.h>
63#include <linux/raid/detect.h>
64#include <linux/slab.h>
65#include <linux/percpu-refcount.h>
66#include <linux/part_stat.h>
67
68#include <trace/events/block.h>
69#include "md.h"
70#include "md-bitmap.h"
71#include "md-cluster.h"
72
73/* pers_list is a list of registered personalities protected
74 * by pers_lock.
75 * pers_lock does extra service to protect accesses to
76 * mddev->thread when the mutex cannot be held.
77 */
78static LIST_HEAD(pers_list);
79static DEFINE_SPINLOCK(pers_lock);
80
81static struct kobj_type md_ktype;
82
83struct md_cluster_operations *md_cluster_ops;
84EXPORT_SYMBOL(md_cluster_ops);
85static struct module *md_cluster_mod;
86
87static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
88static struct workqueue_struct *md_wq;
89static struct workqueue_struct *md_misc_wq;
90static struct workqueue_struct *md_rdev_misc_wq;
91
92static int remove_and_add_spares(struct mddev *mddev,
93 struct md_rdev *this);
94static void mddev_detach(struct mddev *mddev);
95
96enum md_ro_state {
97 MD_RDWR,
98 MD_RDONLY,
99 MD_AUTO_READ,
100 MD_MAX_STATE
101};
102
103static bool md_is_rdwr(struct mddev *mddev)
104{
105 return (mddev->ro == MD_RDWR);
106}
107
108/*
109 * Default number of read corrections we'll attempt on an rdev
110 * before ejecting it from the array. We divide the read error
111 * count by 2 for every hour elapsed between read errors.
112 */
113#define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
114/* Default safemode delay: 200 msec */
115#define DEFAULT_SAFEMODE_DELAY ((200 * HZ)/1000 +1)
116/*
117 * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
118 * is 1000 KB/sec, so the extra system load does not show up that much.
119 * Increase it if you want to have more _guaranteed_ speed. Note that
120 * the RAID driver will use the maximum available bandwidth if the IO
121 * subsystem is idle. There is also an 'absolute maximum' reconstruction
122 * speed limit - in case reconstruction slows down your system despite
123 * idle IO detection.
124 *
125 * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
126 * or /sys/block/mdX/md/sync_speed_{min,max}
127 */
128
129static int sysctl_speed_limit_min = 1000;
130static int sysctl_speed_limit_max = 200000;
131static inline int speed_min(struct mddev *mddev)
132{
133 return mddev->sync_speed_min ?
134 mddev->sync_speed_min : sysctl_speed_limit_min;
135}
136
137static inline int speed_max(struct mddev *mddev)
138{
139 return mddev->sync_speed_max ?
140 mddev->sync_speed_max : sysctl_speed_limit_max;
141}
142
143static void rdev_uninit_serial(struct md_rdev *rdev)
144{
145 if (!test_and_clear_bit(CollisionCheck, &rdev->flags))
146 return;
147
148 kvfree(rdev->serial);
149 rdev->serial = NULL;
150}
151
152static void rdevs_uninit_serial(struct mddev *mddev)
153{
154 struct md_rdev *rdev;
155
156 rdev_for_each(rdev, mddev)
157 rdev_uninit_serial(rdev);
158}
159
160static int rdev_init_serial(struct md_rdev *rdev)
161{
162 /* serial_nums equals with BARRIER_BUCKETS_NR */
163 int i, serial_nums = 1 << ((PAGE_SHIFT - ilog2(sizeof(atomic_t))));
164 struct serial_in_rdev *serial = NULL;
165
166 if (test_bit(CollisionCheck, &rdev->flags))
167 return 0;
168
169 serial = kvmalloc(sizeof(struct serial_in_rdev) * serial_nums,
170 GFP_KERNEL);
171 if (!serial)
172 return -ENOMEM;
173
174 for (i = 0; i < serial_nums; i++) {
175 struct serial_in_rdev *serial_tmp = &serial[i];
176
177 spin_lock_init(&serial_tmp->serial_lock);
178 serial_tmp->serial_rb = RB_ROOT_CACHED;
179 init_waitqueue_head(&serial_tmp->serial_io_wait);
180 }
181
182 rdev->serial = serial;
183 set_bit(CollisionCheck, &rdev->flags);
184
185 return 0;
186}
187
188static int rdevs_init_serial(struct mddev *mddev)
189{
190 struct md_rdev *rdev;
191 int ret = 0;
192
193 rdev_for_each(rdev, mddev) {
194 ret = rdev_init_serial(rdev);
195 if (ret)
196 break;
197 }
198
199 /* Free all resources if pool is not existed */
200 if (ret && !mddev->serial_info_pool)
201 rdevs_uninit_serial(mddev);
202
203 return ret;
204}
205
206/*
207 * rdev needs to enable serial stuffs if it meets the conditions:
208 * 1. it is multi-queue device flaged with writemostly.
209 * 2. the write-behind mode is enabled.
210 */
211static int rdev_need_serial(struct md_rdev *rdev)
212{
213 return (rdev && rdev->mddev->bitmap_info.max_write_behind > 0 &&
214 rdev->bdev->bd_disk->queue->nr_hw_queues != 1 &&
215 test_bit(WriteMostly, &rdev->flags));
216}
217
218/*
219 * Init resource for rdev(s), then create serial_info_pool if:
220 * 1. rdev is the first device which return true from rdev_enable_serial.
221 * 2. rdev is NULL, means we want to enable serialization for all rdevs.
222 */
223void mddev_create_serial_pool(struct mddev *mddev, struct md_rdev *rdev,
224 bool is_suspend)
225{
226 int ret = 0;
227
228 if (rdev && !rdev_need_serial(rdev) &&
229 !test_bit(CollisionCheck, &rdev->flags))
230 return;
231
232 if (!is_suspend)
233 mddev_suspend(mddev);
234
235 if (!rdev)
236 ret = rdevs_init_serial(mddev);
237 else
238 ret = rdev_init_serial(rdev);
239 if (ret)
240 goto abort;
241
242 if (mddev->serial_info_pool == NULL) {
243 /*
244 * already in memalloc noio context by
245 * mddev_suspend()
246 */
247 mddev->serial_info_pool =
248 mempool_create_kmalloc_pool(NR_SERIAL_INFOS,
249 sizeof(struct serial_info));
250 if (!mddev->serial_info_pool) {
251 rdevs_uninit_serial(mddev);
252 pr_err("can't alloc memory pool for serialization\n");
253 }
254 }
255
256abort:
257 if (!is_suspend)
258 mddev_resume(mddev);
259}
260
261/*
262 * Free resource from rdev(s), and destroy serial_info_pool under conditions:
263 * 1. rdev is the last device flaged with CollisionCheck.
264 * 2. when bitmap is destroyed while policy is not enabled.
265 * 3. for disable policy, the pool is destroyed only when no rdev needs it.
266 */
267void mddev_destroy_serial_pool(struct mddev *mddev, struct md_rdev *rdev,
268 bool is_suspend)
269{
270 if (rdev && !test_bit(CollisionCheck, &rdev->flags))
271 return;
272
273 if (mddev->serial_info_pool) {
274 struct md_rdev *temp;
275 int num = 0; /* used to track if other rdevs need the pool */
276
277 if (!is_suspend)
278 mddev_suspend(mddev);
279 rdev_for_each(temp, mddev) {
280 if (!rdev) {
281 if (!mddev->serialize_policy ||
282 !rdev_need_serial(temp))
283 rdev_uninit_serial(temp);
284 else
285 num++;
286 } else if (temp != rdev &&
287 test_bit(CollisionCheck, &temp->flags))
288 num++;
289 }
290
291 if (rdev)
292 rdev_uninit_serial(rdev);
293
294 if (num)
295 pr_info("The mempool could be used by other devices\n");
296 else {
297 mempool_destroy(mddev->serial_info_pool);
298 mddev->serial_info_pool = NULL;
299 }
300 if (!is_suspend)
301 mddev_resume(mddev);
302 }
303}
304
305static struct ctl_table_header *raid_table_header;
306
307static struct ctl_table raid_table[] = {
308 {
309 .procname = "speed_limit_min",
310 .data = &sysctl_speed_limit_min,
311 .maxlen = sizeof(int),
312 .mode = S_IRUGO|S_IWUSR,
313 .proc_handler = proc_dointvec,
314 },
315 {
316 .procname = "speed_limit_max",
317 .data = &sysctl_speed_limit_max,
318 .maxlen = sizeof(int),
319 .mode = S_IRUGO|S_IWUSR,
320 .proc_handler = proc_dointvec,
321 },
322 { }
323};
324
325static struct ctl_table raid_dir_table[] = {
326 {
327 .procname = "raid",
328 .maxlen = 0,
329 .mode = S_IRUGO|S_IXUGO,
330 .child = raid_table,
331 },
332 { }
333};
334
335static struct ctl_table raid_root_table[] = {
336 {
337 .procname = "dev",
338 .maxlen = 0,
339 .mode = 0555,
340 .child = raid_dir_table,
341 },
342 { }
343};
344
345static int start_readonly;
346
347/*
348 * The original mechanism for creating an md device is to create
349 * a device node in /dev and to open it. This causes races with device-close.
350 * The preferred method is to write to the "new_array" module parameter.
351 * This can avoid races.
352 * Setting create_on_open to false disables the original mechanism
353 * so all the races disappear.
354 */
355static bool create_on_open = true;
356
357/*
358 * We have a system wide 'event count' that is incremented
359 * on any 'interesting' event, and readers of /proc/mdstat
360 * can use 'poll' or 'select' to find out when the event
361 * count increases.
362 *
363 * Events are:
364 * start array, stop array, error, add device, remove device,
365 * start build, activate spare
366 */
367static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
368static atomic_t md_event_count;
369void md_new_event(void)
370{
371 atomic_inc(&md_event_count);
372 wake_up(&md_event_waiters);
373}
374EXPORT_SYMBOL_GPL(md_new_event);
375
376/*
377 * Enables to iterate over all existing md arrays
378 * all_mddevs_lock protects this list.
379 */
380static LIST_HEAD(all_mddevs);
381static DEFINE_SPINLOCK(all_mddevs_lock);
382
383/* Rather than calling directly into the personality make_request function,
384 * IO requests come here first so that we can check if the device is
385 * being suspended pending a reconfiguration.
386 * We hold a refcount over the call to ->make_request. By the time that
387 * call has finished, the bio has been linked into some internal structure
388 * and so is visible to ->quiesce(), so we don't need the refcount any more.
389 */
390static bool is_suspended(struct mddev *mddev, struct bio *bio)
391{
392 if (mddev->suspended)
393 return true;
394 if (bio_data_dir(bio) != WRITE)
395 return false;
396 if (mddev->suspend_lo >= mddev->suspend_hi)
397 return false;
398 if (bio->bi_iter.bi_sector >= mddev->suspend_hi)
399 return false;
400 if (bio_end_sector(bio) < mddev->suspend_lo)
401 return false;
402 return true;
403}
404
405void md_handle_request(struct mddev *mddev, struct bio *bio)
406{
407check_suspended:
408 rcu_read_lock();
409 if (is_suspended(mddev, bio)) {
410 DEFINE_WAIT(__wait);
411 /* Bail out if REQ_NOWAIT is set for the bio */
412 if (bio->bi_opf & REQ_NOWAIT) {
413 rcu_read_unlock();
414 bio_wouldblock_error(bio);
415 return;
416 }
417 for (;;) {
418 prepare_to_wait(&mddev->sb_wait, &__wait,
419 TASK_UNINTERRUPTIBLE);
420 if (!is_suspended(mddev, bio))
421 break;
422 rcu_read_unlock();
423 schedule();
424 rcu_read_lock();
425 }
426 finish_wait(&mddev->sb_wait, &__wait);
427 }
428 atomic_inc(&mddev->active_io);
429 rcu_read_unlock();
430
431 if (!mddev->pers->make_request(mddev, bio)) {
432 atomic_dec(&mddev->active_io);
433 wake_up(&mddev->sb_wait);
434 goto check_suspended;
435 }
436
437 if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
438 wake_up(&mddev->sb_wait);
439}
440EXPORT_SYMBOL(md_handle_request);
441
442static void md_submit_bio(struct bio *bio)
443{
444 const int rw = bio_data_dir(bio);
445 struct mddev *mddev = bio->bi_bdev->bd_disk->private_data;
446
447 if (mddev == NULL || mddev->pers == NULL) {
448 bio_io_error(bio);
449 return;
450 }
451
452 if (unlikely(test_bit(MD_BROKEN, &mddev->flags)) && (rw == WRITE)) {
453 bio_io_error(bio);
454 return;
455 }
456
457 bio = bio_split_to_limits(bio);
458 if (!bio)
459 return;
460
461 if (mddev->ro == MD_RDONLY && unlikely(rw == WRITE)) {
462 if (bio_sectors(bio) != 0)
463 bio->bi_status = BLK_STS_IOERR;
464 bio_endio(bio);
465 return;
466 }
467
468 /* bio could be mergeable after passing to underlayer */
469 bio->bi_opf &= ~REQ_NOMERGE;
470
471 md_handle_request(mddev, bio);
472}
473
474/* mddev_suspend makes sure no new requests are submitted
475 * to the device, and that any requests that have been submitted
476 * are completely handled.
477 * Once mddev_detach() is called and completes, the module will be
478 * completely unused.
479 */
480void mddev_suspend(struct mddev *mddev)
481{
482 WARN_ON_ONCE(mddev->thread && current == mddev->thread->tsk);
483 lockdep_assert_held(&mddev->reconfig_mutex);
484 if (mddev->suspended++)
485 return;
486 synchronize_rcu();
487 wake_up(&mddev->sb_wait);
488 set_bit(MD_ALLOW_SB_UPDATE, &mddev->flags);
489 smp_mb__after_atomic();
490 wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
491 mddev->pers->quiesce(mddev, 1);
492 clear_bit_unlock(MD_ALLOW_SB_UPDATE, &mddev->flags);
493 wait_event(mddev->sb_wait, !test_bit(MD_UPDATING_SB, &mddev->flags));
494
495 del_timer_sync(&mddev->safemode_timer);
496 /* restrict memory reclaim I/O during raid array is suspend */
497 mddev->noio_flag = memalloc_noio_save();
498}
499EXPORT_SYMBOL_GPL(mddev_suspend);
500
501void mddev_resume(struct mddev *mddev)
502{
503 /* entred the memalloc scope from mddev_suspend() */
504 memalloc_noio_restore(mddev->noio_flag);
505 lockdep_assert_held(&mddev->reconfig_mutex);
506 if (--mddev->suspended)
507 return;
508 wake_up(&mddev->sb_wait);
509 mddev->pers->quiesce(mddev, 0);
510
511 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
512 md_wakeup_thread(mddev->thread);
513 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
514}
515EXPORT_SYMBOL_GPL(mddev_resume);
516
517/*
518 * Generic flush handling for md
519 */
520
521static void md_end_flush(struct bio *bio)
522{
523 struct md_rdev *rdev = bio->bi_private;
524 struct mddev *mddev = rdev->mddev;
525
526 bio_put(bio);
527
528 rdev_dec_pending(rdev, mddev);
529
530 if (atomic_dec_and_test(&mddev->flush_pending)) {
531 /* The pre-request flush has finished */
532 queue_work(md_wq, &mddev->flush_work);
533 }
534}
535
536static void md_submit_flush_data(struct work_struct *ws);
537
538static void submit_flushes(struct work_struct *ws)
539{
540 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
541 struct md_rdev *rdev;
542
543 mddev->start_flush = ktime_get_boottime();
544 INIT_WORK(&mddev->flush_work, md_submit_flush_data);
545 atomic_set(&mddev->flush_pending, 1);
546 rcu_read_lock();
547 rdev_for_each_rcu(rdev, mddev)
548 if (rdev->raid_disk >= 0 &&
549 !test_bit(Faulty, &rdev->flags)) {
550 /* Take two references, one is dropped
551 * when request finishes, one after
552 * we reclaim rcu_read_lock
553 */
554 struct bio *bi;
555 atomic_inc(&rdev->nr_pending);
556 atomic_inc(&rdev->nr_pending);
557 rcu_read_unlock();
558 bi = bio_alloc_bioset(rdev->bdev, 0,
559 REQ_OP_WRITE | REQ_PREFLUSH,
560 GFP_NOIO, &mddev->bio_set);
561 bi->bi_end_io = md_end_flush;
562 bi->bi_private = rdev;
563 atomic_inc(&mddev->flush_pending);
564 submit_bio(bi);
565 rcu_read_lock();
566 rdev_dec_pending(rdev, mddev);
567 }
568 rcu_read_unlock();
569 if (atomic_dec_and_test(&mddev->flush_pending))
570 queue_work(md_wq, &mddev->flush_work);
571}
572
573static void md_submit_flush_data(struct work_struct *ws)
574{
575 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
576 struct bio *bio = mddev->flush_bio;
577
578 /*
579 * must reset flush_bio before calling into md_handle_request to avoid a
580 * deadlock, because other bios passed md_handle_request suspend check
581 * could wait for this and below md_handle_request could wait for those
582 * bios because of suspend check
583 */
584 spin_lock_irq(&mddev->lock);
585 mddev->prev_flush_start = mddev->start_flush;
586 mddev->flush_bio = NULL;
587 spin_unlock_irq(&mddev->lock);
588 wake_up(&mddev->sb_wait);
589
590 if (bio->bi_iter.bi_size == 0) {
591 /* an empty barrier - all done */
592 bio_endio(bio);
593 } else {
594 bio->bi_opf &= ~REQ_PREFLUSH;
595 md_handle_request(mddev, bio);
596 }
597}
598
599/*
600 * Manages consolidation of flushes and submitting any flushes needed for
601 * a bio with REQ_PREFLUSH. Returns true if the bio is finished or is
602 * being finished in another context. Returns false if the flushing is
603 * complete but still needs the I/O portion of the bio to be processed.
604 */
605bool md_flush_request(struct mddev *mddev, struct bio *bio)
606{
607 ktime_t req_start = ktime_get_boottime();
608 spin_lock_irq(&mddev->lock);
609 /* flush requests wait until ongoing flush completes,
610 * hence coalescing all the pending requests.
611 */
612 wait_event_lock_irq(mddev->sb_wait,
613 !mddev->flush_bio ||
614 ktime_before(req_start, mddev->prev_flush_start),
615 mddev->lock);
616 /* new request after previous flush is completed */
617 if (ktime_after(req_start, mddev->prev_flush_start)) {
618 WARN_ON(mddev->flush_bio);
619 mddev->flush_bio = bio;
620 bio = NULL;
621 }
622 spin_unlock_irq(&mddev->lock);
623
624 if (!bio) {
625 INIT_WORK(&mddev->flush_work, submit_flushes);
626 queue_work(md_wq, &mddev->flush_work);
627 } else {
628 /* flush was performed for some other bio while we waited. */
629 if (bio->bi_iter.bi_size == 0)
630 /* an empty barrier - all done */
631 bio_endio(bio);
632 else {
633 bio->bi_opf &= ~REQ_PREFLUSH;
634 return false;
635 }
636 }
637 return true;
638}
639EXPORT_SYMBOL(md_flush_request);
640
641static inline struct mddev *mddev_get(struct mddev *mddev)
642{
643 lockdep_assert_held(&all_mddevs_lock);
644
645 if (test_bit(MD_DELETED, &mddev->flags))
646 return NULL;
647 atomic_inc(&mddev->active);
648 return mddev;
649}
650
651static void mddev_delayed_delete(struct work_struct *ws);
652
653void mddev_put(struct mddev *mddev)
654{
655 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
656 return;
657 if (!mddev->raid_disks && list_empty(&mddev->disks) &&
658 mddev->ctime == 0 && !mddev->hold_active) {
659 /* Array is not configured at all, and not held active,
660 * so destroy it */
661 set_bit(MD_DELETED, &mddev->flags);
662
663 /*
664 * Call queue_work inside the spinlock so that
665 * flush_workqueue() after mddev_find will succeed in waiting
666 * for the work to be done.
667 */
668 INIT_WORK(&mddev->del_work, mddev_delayed_delete);
669 queue_work(md_misc_wq, &mddev->del_work);
670 }
671 spin_unlock(&all_mddevs_lock);
672}
673
674static void md_safemode_timeout(struct timer_list *t);
675
676void mddev_init(struct mddev *mddev)
677{
678 mutex_init(&mddev->open_mutex);
679 mutex_init(&mddev->reconfig_mutex);
680 mutex_init(&mddev->bitmap_info.mutex);
681 INIT_LIST_HEAD(&mddev->disks);
682 INIT_LIST_HEAD(&mddev->all_mddevs);
683 timer_setup(&mddev->safemode_timer, md_safemode_timeout, 0);
684 atomic_set(&mddev->active, 1);
685 atomic_set(&mddev->openers, 0);
686 atomic_set(&mddev->active_io, 0);
687 spin_lock_init(&mddev->lock);
688 atomic_set(&mddev->flush_pending, 0);
689 init_waitqueue_head(&mddev->sb_wait);
690 init_waitqueue_head(&mddev->recovery_wait);
691 mddev->reshape_position = MaxSector;
692 mddev->reshape_backwards = 0;
693 mddev->last_sync_action = "none";
694 mddev->resync_min = 0;
695 mddev->resync_max = MaxSector;
696 mddev->level = LEVEL_NONE;
697}
698EXPORT_SYMBOL_GPL(mddev_init);
699
700static struct mddev *mddev_find_locked(dev_t unit)
701{
702 struct mddev *mddev;
703
704 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
705 if (mddev->unit == unit)
706 return mddev;
707
708 return NULL;
709}
710
711/* find an unused unit number */
712static dev_t mddev_alloc_unit(void)
713{
714 static int next_minor = 512;
715 int start = next_minor;
716 bool is_free = 0;
717 dev_t dev = 0;
718
719 while (!is_free) {
720 dev = MKDEV(MD_MAJOR, next_minor);
721 next_minor++;
722 if (next_minor > MINORMASK)
723 next_minor = 0;
724 if (next_minor == start)
725 return 0; /* Oh dear, all in use. */
726 is_free = !mddev_find_locked(dev);
727 }
728
729 return dev;
730}
731
732static struct mddev *mddev_alloc(dev_t unit)
733{
734 struct mddev *new;
735 int error;
736
737 if (unit && MAJOR(unit) != MD_MAJOR)
738 unit &= ~((1 << MdpMinorShift) - 1);
739
740 new = kzalloc(sizeof(*new), GFP_KERNEL);
741 if (!new)
742 return ERR_PTR(-ENOMEM);
743 mddev_init(new);
744
745 spin_lock(&all_mddevs_lock);
746 if (unit) {
747 error = -EEXIST;
748 if (mddev_find_locked(unit))
749 goto out_free_new;
750 new->unit = unit;
751 if (MAJOR(unit) == MD_MAJOR)
752 new->md_minor = MINOR(unit);
753 else
754 new->md_minor = MINOR(unit) >> MdpMinorShift;
755 new->hold_active = UNTIL_IOCTL;
756 } else {
757 error = -ENODEV;
758 new->unit = mddev_alloc_unit();
759 if (!new->unit)
760 goto out_free_new;
761 new->md_minor = MINOR(new->unit);
762 new->hold_active = UNTIL_STOP;
763 }
764
765 list_add(&new->all_mddevs, &all_mddevs);
766 spin_unlock(&all_mddevs_lock);
767 return new;
768out_free_new:
769 spin_unlock(&all_mddevs_lock);
770 kfree(new);
771 return ERR_PTR(error);
772}
773
774static void mddev_free(struct mddev *mddev)
775{
776 spin_lock(&all_mddevs_lock);
777 list_del(&mddev->all_mddevs);
778 spin_unlock(&all_mddevs_lock);
779
780 kfree(mddev);
781}
782
783static const struct attribute_group md_redundancy_group;
784
785void mddev_unlock(struct mddev *mddev)
786{
787 if (mddev->to_remove) {
788 /* These cannot be removed under reconfig_mutex as
789 * an access to the files will try to take reconfig_mutex
790 * while holding the file unremovable, which leads to
791 * a deadlock.
792 * So hold set sysfs_active while the remove in happeing,
793 * and anything else which might set ->to_remove or my
794 * otherwise change the sysfs namespace will fail with
795 * -EBUSY if sysfs_active is still set.
796 * We set sysfs_active under reconfig_mutex and elsewhere
797 * test it under the same mutex to ensure its correct value
798 * is seen.
799 */
800 const struct attribute_group *to_remove = mddev->to_remove;
801 mddev->to_remove = NULL;
802 mddev->sysfs_active = 1;
803 mutex_unlock(&mddev->reconfig_mutex);
804
805 if (mddev->kobj.sd) {
806 if (to_remove != &md_redundancy_group)
807 sysfs_remove_group(&mddev->kobj, to_remove);
808 if (mddev->pers == NULL ||
809 mddev->pers->sync_request == NULL) {
810 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
811 if (mddev->sysfs_action)
812 sysfs_put(mddev->sysfs_action);
813 if (mddev->sysfs_completed)
814 sysfs_put(mddev->sysfs_completed);
815 if (mddev->sysfs_degraded)
816 sysfs_put(mddev->sysfs_degraded);
817 mddev->sysfs_action = NULL;
818 mddev->sysfs_completed = NULL;
819 mddev->sysfs_degraded = NULL;
820 }
821 }
822 mddev->sysfs_active = 0;
823 } else
824 mutex_unlock(&mddev->reconfig_mutex);
825
826 /* As we've dropped the mutex we need a spinlock to
827 * make sure the thread doesn't disappear
828 */
829 spin_lock(&pers_lock);
830 md_wakeup_thread(mddev->thread);
831 wake_up(&mddev->sb_wait);
832 spin_unlock(&pers_lock);
833}
834EXPORT_SYMBOL_GPL(mddev_unlock);
835
836struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr)
837{
838 struct md_rdev *rdev;
839
840 rdev_for_each_rcu(rdev, mddev)
841 if (rdev->desc_nr == nr)
842 return rdev;
843
844 return NULL;
845}
846EXPORT_SYMBOL_GPL(md_find_rdev_nr_rcu);
847
848static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)
849{
850 struct md_rdev *rdev;
851
852 rdev_for_each(rdev, mddev)
853 if (rdev->bdev->bd_dev == dev)
854 return rdev;
855
856 return NULL;
857}
858
859struct md_rdev *md_find_rdev_rcu(struct mddev *mddev, dev_t dev)
860{
861 struct md_rdev *rdev;
862
863 rdev_for_each_rcu(rdev, mddev)
864 if (rdev->bdev->bd_dev == dev)
865 return rdev;
866
867 return NULL;
868}
869EXPORT_SYMBOL_GPL(md_find_rdev_rcu);
870
871static struct md_personality *find_pers(int level, char *clevel)
872{
873 struct md_personality *pers;
874 list_for_each_entry(pers, &pers_list, list) {
875 if (level != LEVEL_NONE && pers->level == level)
876 return pers;
877 if (strcmp(pers->name, clevel)==0)
878 return pers;
879 }
880 return NULL;
881}
882
883/* return the offset of the super block in 512byte sectors */
884static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
885{
886 return MD_NEW_SIZE_SECTORS(bdev_nr_sectors(rdev->bdev));
887}
888
889static int alloc_disk_sb(struct md_rdev *rdev)
890{
891 rdev->sb_page = alloc_page(GFP_KERNEL);
892 if (!rdev->sb_page)
893 return -ENOMEM;
894 return 0;
895}
896
897void md_rdev_clear(struct md_rdev *rdev)
898{
899 if (rdev->sb_page) {
900 put_page(rdev->sb_page);
901 rdev->sb_loaded = 0;
902 rdev->sb_page = NULL;
903 rdev->sb_start = 0;
904 rdev->sectors = 0;
905 }
906 if (rdev->bb_page) {
907 put_page(rdev->bb_page);
908 rdev->bb_page = NULL;
909 }
910 badblocks_exit(&rdev->badblocks);
911}
912EXPORT_SYMBOL_GPL(md_rdev_clear);
913
914static void super_written(struct bio *bio)
915{
916 struct md_rdev *rdev = bio->bi_private;
917 struct mddev *mddev = rdev->mddev;
918
919 if (bio->bi_status) {
920 pr_err("md: %s gets error=%d\n", __func__,
921 blk_status_to_errno(bio->bi_status));
922 md_error(mddev, rdev);
923 if (!test_bit(Faulty, &rdev->flags)
924 && (bio->bi_opf & MD_FAILFAST)) {
925 set_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags);
926 set_bit(LastDev, &rdev->flags);
927 }
928 } else
929 clear_bit(LastDev, &rdev->flags);
930
931 bio_put(bio);
932
933 rdev_dec_pending(rdev, mddev);
934
935 if (atomic_dec_and_test(&mddev->pending_writes))
936 wake_up(&mddev->sb_wait);
937}
938
939void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
940 sector_t sector, int size, struct page *page)
941{
942 /* write first size bytes of page to sector of rdev
943 * Increment mddev->pending_writes before returning
944 * and decrement it on completion, waking up sb_wait
945 * if zero is reached.
946 * If an error occurred, call md_error
947 */
948 struct bio *bio;
949
950 if (!page)
951 return;
952
953 if (test_bit(Faulty, &rdev->flags))
954 return;
955
956 bio = bio_alloc_bioset(rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev,
957 1,
958 REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH | REQ_FUA,
959 GFP_NOIO, &mddev->sync_set);
960
961 atomic_inc(&rdev->nr_pending);
962
963 bio->bi_iter.bi_sector = sector;
964 bio_add_page(bio, page, size, 0);
965 bio->bi_private = rdev;
966 bio->bi_end_io = super_written;
967
968 if (test_bit(MD_FAILFAST_SUPPORTED, &mddev->flags) &&
969 test_bit(FailFast, &rdev->flags) &&
970 !test_bit(LastDev, &rdev->flags))
971 bio->bi_opf |= MD_FAILFAST;
972
973 atomic_inc(&mddev->pending_writes);
974 submit_bio(bio);
975}
976
977int md_super_wait(struct mddev *mddev)
978{
979 /* wait for all superblock writes that were scheduled to complete */
980 wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
981 if (test_and_clear_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags))
982 return -EAGAIN;
983 return 0;
984}
985
986int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
987 struct page *page, blk_opf_t opf, bool metadata_op)
988{
989 struct bio bio;
990 struct bio_vec bvec;
991
992 if (metadata_op && rdev->meta_bdev)
993 bio_init(&bio, rdev->meta_bdev, &bvec, 1, opf);
994 else
995 bio_init(&bio, rdev->bdev, &bvec, 1, opf);
996
997 if (metadata_op)
998 bio.bi_iter.bi_sector = sector + rdev->sb_start;
999 else if (rdev->mddev->reshape_position != MaxSector &&
1000 (rdev->mddev->reshape_backwards ==
1001 (sector >= rdev->mddev->reshape_position)))
1002 bio.bi_iter.bi_sector = sector + rdev->new_data_offset;
1003 else
1004 bio.bi_iter.bi_sector = sector + rdev->data_offset;
1005 bio_add_page(&bio, page, size, 0);
1006
1007 submit_bio_wait(&bio);
1008
1009 return !bio.bi_status;
1010}
1011EXPORT_SYMBOL_GPL(sync_page_io);
1012
1013static int read_disk_sb(struct md_rdev *rdev, int size)
1014{
1015 if (rdev->sb_loaded)
1016 return 0;
1017
1018 if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, true))
1019 goto fail;
1020 rdev->sb_loaded = 1;
1021 return 0;
1022
1023fail:
1024 pr_err("md: disabled device %pg, could not read superblock.\n",
1025 rdev->bdev);
1026 return -EINVAL;
1027}
1028
1029static int md_uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
1030{
1031 return sb1->set_uuid0 == sb2->set_uuid0 &&
1032 sb1->set_uuid1 == sb2->set_uuid1 &&
1033 sb1->set_uuid2 == sb2->set_uuid2 &&
1034 sb1->set_uuid3 == sb2->set_uuid3;
1035}
1036
1037static int md_sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
1038{
1039 int ret;
1040 mdp_super_t *tmp1, *tmp2;
1041
1042 tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
1043 tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
1044
1045 if (!tmp1 || !tmp2) {
1046 ret = 0;
1047 goto abort;
1048 }
1049
1050 *tmp1 = *sb1;
1051 *tmp2 = *sb2;
1052
1053 /*
1054 * nr_disks is not constant
1055 */
1056 tmp1->nr_disks = 0;
1057 tmp2->nr_disks = 0;
1058
1059 ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
1060abort:
1061 kfree(tmp1);
1062 kfree(tmp2);
1063 return ret;
1064}
1065
1066static u32 md_csum_fold(u32 csum)
1067{
1068 csum = (csum & 0xffff) + (csum >> 16);
1069 return (csum & 0xffff) + (csum >> 16);
1070}
1071
1072static unsigned int calc_sb_csum(mdp_super_t *sb)
1073{
1074 u64 newcsum = 0;
1075 u32 *sb32 = (u32*)sb;
1076 int i;
1077 unsigned int disk_csum, csum;
1078
1079 disk_csum = sb->sb_csum;
1080 sb->sb_csum = 0;
1081
1082 for (i = 0; i < MD_SB_BYTES/4 ; i++)
1083 newcsum += sb32[i];
1084 csum = (newcsum & 0xffffffff) + (newcsum>>32);
1085
1086#ifdef CONFIG_ALPHA
1087 /* This used to use csum_partial, which was wrong for several
1088 * reasons including that different results are returned on
1089 * different architectures. It isn't critical that we get exactly
1090 * the same return value as before (we always csum_fold before
1091 * testing, and that removes any differences). However as we
1092 * know that csum_partial always returned a 16bit value on
1093 * alphas, do a fold to maximise conformity to previous behaviour.
1094 */
1095 sb->sb_csum = md_csum_fold(disk_csum);
1096#else
1097 sb->sb_csum = disk_csum;
1098#endif
1099 return csum;
1100}
1101
1102/*
1103 * Handle superblock details.
1104 * We want to be able to handle multiple superblock formats
1105 * so we have a common interface to them all, and an array of
1106 * different handlers.
1107 * We rely on user-space to write the initial superblock, and support
1108 * reading and updating of superblocks.
1109 * Interface methods are:
1110 * int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
1111 * loads and validates a superblock on dev.
1112 * if refdev != NULL, compare superblocks on both devices
1113 * Return:
1114 * 0 - dev has a superblock that is compatible with refdev
1115 * 1 - dev has a superblock that is compatible and newer than refdev
1116 * so dev should be used as the refdev in future
1117 * -EINVAL superblock incompatible or invalid
1118 * -othererror e.g. -EIO
1119 *
1120 * int validate_super(struct mddev *mddev, struct md_rdev *dev)
1121 * Verify that dev is acceptable into mddev.
1122 * The first time, mddev->raid_disks will be 0, and data from
1123 * dev should be merged in. Subsequent calls check that dev
1124 * is new enough. Return 0 or -EINVAL
1125 *
1126 * void sync_super(struct mddev *mddev, struct md_rdev *dev)
1127 * Update the superblock for rdev with data in mddev
1128 * This does not write to disc.
1129 *
1130 */
1131
1132struct super_type {
1133 char *name;
1134 struct module *owner;
1135 int (*load_super)(struct md_rdev *rdev,
1136 struct md_rdev *refdev,
1137 int minor_version);
1138 int (*validate_super)(struct mddev *mddev,
1139 struct md_rdev *rdev);
1140 void (*sync_super)(struct mddev *mddev,
1141 struct md_rdev *rdev);
1142 unsigned long long (*rdev_size_change)(struct md_rdev *rdev,
1143 sector_t num_sectors);
1144 int (*allow_new_offset)(struct md_rdev *rdev,
1145 unsigned long long new_offset);
1146};
1147
1148/*
1149 * Check that the given mddev has no bitmap.
1150 *
1151 * This function is called from the run method of all personalities that do not
1152 * support bitmaps. It prints an error message and returns non-zero if mddev
1153 * has a bitmap. Otherwise, it returns 0.
1154 *
1155 */
1156int md_check_no_bitmap(struct mddev *mddev)
1157{
1158 if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
1159 return 0;
1160 pr_warn("%s: bitmaps are not supported for %s\n",
1161 mdname(mddev), mddev->pers->name);
1162 return 1;
1163}
1164EXPORT_SYMBOL(md_check_no_bitmap);
1165
1166/*
1167 * load_super for 0.90.0
1168 */
1169static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
1170{
1171 mdp_super_t *sb;
1172 int ret;
1173 bool spare_disk = true;
1174
1175 /*
1176 * Calculate the position of the superblock (512byte sectors),
1177 * it's at the end of the disk.
1178 *
1179 * It also happens to be a multiple of 4Kb.
1180 */
1181 rdev->sb_start = calc_dev_sboffset(rdev);
1182
1183 ret = read_disk_sb(rdev, MD_SB_BYTES);
1184 if (ret)
1185 return ret;
1186
1187 ret = -EINVAL;
1188
1189 sb = page_address(rdev->sb_page);
1190
1191 if (sb->md_magic != MD_SB_MAGIC) {
1192 pr_warn("md: invalid raid superblock magic on %pg\n",
1193 rdev->bdev);
1194 goto abort;
1195 }
1196
1197 if (sb->major_version != 0 ||
1198 sb->minor_version < 90 ||
1199 sb->minor_version > 91) {
1200 pr_warn("Bad version number %d.%d on %pg\n",
1201 sb->major_version, sb->minor_version, rdev->bdev);
1202 goto abort;
1203 }
1204
1205 if (sb->raid_disks <= 0)
1206 goto abort;
1207
1208 if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
1209 pr_warn("md: invalid superblock checksum on %pg\n", rdev->bdev);
1210 goto abort;
1211 }
1212
1213 rdev->preferred_minor = sb->md_minor;
1214 rdev->data_offset = 0;
1215 rdev->new_data_offset = 0;
1216 rdev->sb_size = MD_SB_BYTES;
1217 rdev->badblocks.shift = -1;
1218
1219 if (sb->level == LEVEL_MULTIPATH)
1220 rdev->desc_nr = -1;
1221 else
1222 rdev->desc_nr = sb->this_disk.number;
1223
1224 /* not spare disk, or LEVEL_MULTIPATH */
1225 if (sb->level == LEVEL_MULTIPATH ||
1226 (rdev->desc_nr >= 0 &&
1227 rdev->desc_nr < MD_SB_DISKS &&
1228 sb->disks[rdev->desc_nr].state &
1229 ((1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE))))
1230 spare_disk = false;
1231
1232 if (!refdev) {
1233 if (!spare_disk)
1234 ret = 1;
1235 else
1236 ret = 0;
1237 } else {
1238 __u64 ev1, ev2;
1239 mdp_super_t *refsb = page_address(refdev->sb_page);
1240 if (!md_uuid_equal(refsb, sb)) {
1241 pr_warn("md: %pg has different UUID to %pg\n",
1242 rdev->bdev, refdev->bdev);
1243 goto abort;
1244 }
1245 if (!md_sb_equal(refsb, sb)) {
1246 pr_warn("md: %pg has same UUID but different superblock to %pg\n",
1247 rdev->bdev, refdev->bdev);
1248 goto abort;
1249 }
1250 ev1 = md_event(sb);
1251 ev2 = md_event(refsb);
1252
1253 if (!spare_disk && ev1 > ev2)
1254 ret = 1;
1255 else
1256 ret = 0;
1257 }
1258 rdev->sectors = rdev->sb_start;
1259 /* Limit to 4TB as metadata cannot record more than that.
1260 * (not needed for Linear and RAID0 as metadata doesn't
1261 * record this size)
1262 */
1263 if ((u64)rdev->sectors >= (2ULL << 32) && sb->level >= 1)
1264 rdev->sectors = (sector_t)(2ULL << 32) - 2;
1265
1266 if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
1267 /* "this cannot possibly happen" ... */
1268 ret = -EINVAL;
1269
1270 abort:
1271 return ret;
1272}
1273
1274/*
1275 * validate_super for 0.90.0
1276 */
1277static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
1278{
1279 mdp_disk_t *desc;
1280 mdp_super_t *sb = page_address(rdev->sb_page);
1281 __u64 ev1 = md_event(sb);
1282
1283 rdev->raid_disk = -1;
1284 clear_bit(Faulty, &rdev->flags);
1285 clear_bit(In_sync, &rdev->flags);
1286 clear_bit(Bitmap_sync, &rdev->flags);
1287 clear_bit(WriteMostly, &rdev->flags);
1288
1289 if (mddev->raid_disks == 0) {
1290 mddev->major_version = 0;
1291 mddev->minor_version = sb->minor_version;
1292 mddev->patch_version = sb->patch_version;
1293 mddev->external = 0;
1294 mddev->chunk_sectors = sb->chunk_size >> 9;
1295 mddev->ctime = sb->ctime;
1296 mddev->utime = sb->utime;
1297 mddev->level = sb->level;
1298 mddev->clevel[0] = 0;
1299 mddev->layout = sb->layout;
1300 mddev->raid_disks = sb->raid_disks;
1301 mddev->dev_sectors = ((sector_t)sb->size) * 2;
1302 mddev->events = ev1;
1303 mddev->bitmap_info.offset = 0;
1304 mddev->bitmap_info.space = 0;
1305 /* bitmap can use 60 K after the 4K superblocks */
1306 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
1307 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
1308 mddev->reshape_backwards = 0;
1309
1310 if (mddev->minor_version >= 91) {
1311 mddev->reshape_position = sb->reshape_position;
1312 mddev->delta_disks = sb->delta_disks;
1313 mddev->new_level = sb->new_level;
1314 mddev->new_layout = sb->new_layout;
1315 mddev->new_chunk_sectors = sb->new_chunk >> 9;
1316 if (mddev->delta_disks < 0)
1317 mddev->reshape_backwards = 1;
1318 } else {
1319 mddev->reshape_position = MaxSector;
1320 mddev->delta_disks = 0;
1321 mddev->new_level = mddev->level;
1322 mddev->new_layout = mddev->layout;
1323 mddev->new_chunk_sectors = mddev->chunk_sectors;
1324 }
1325 if (mddev->level == 0)
1326 mddev->layout = -1;
1327
1328 if (sb->state & (1<<MD_SB_CLEAN))
1329 mddev->recovery_cp = MaxSector;
1330 else {
1331 if (sb->events_hi == sb->cp_events_hi &&
1332 sb->events_lo == sb->cp_events_lo) {
1333 mddev->recovery_cp = sb->recovery_cp;
1334 } else
1335 mddev->recovery_cp = 0;
1336 }
1337
1338 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
1339 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
1340 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
1341 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
1342
1343 mddev->max_disks = MD_SB_DISKS;
1344
1345 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
1346 mddev->bitmap_info.file == NULL) {
1347 mddev->bitmap_info.offset =
1348 mddev->bitmap_info.default_offset;
1349 mddev->bitmap_info.space =
1350 mddev->bitmap_info.default_space;
1351 }
1352
1353 } else if (mddev->pers == NULL) {
1354 /* Insist on good event counter while assembling, except
1355 * for spares (which don't need an event count) */
1356 ++ev1;
1357 if (sb->disks[rdev->desc_nr].state & (
1358 (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
1359 if (ev1 < mddev->events)
1360 return -EINVAL;
1361 } else if (mddev->bitmap) {
1362 /* if adding to array with a bitmap, then we can accept an
1363 * older device ... but not too old.
1364 */
1365 if (ev1 < mddev->bitmap->events_cleared)
1366 return 0;
1367 if (ev1 < mddev->events)
1368 set_bit(Bitmap_sync, &rdev->flags);
1369 } else {
1370 if (ev1 < mddev->events)
1371 /* just a hot-add of a new device, leave raid_disk at -1 */
1372 return 0;
1373 }
1374
1375 if (mddev->level != LEVEL_MULTIPATH) {
1376 desc = sb->disks + rdev->desc_nr;
1377
1378 if (desc->state & (1<<MD_DISK_FAULTY))
1379 set_bit(Faulty, &rdev->flags);
1380 else if (desc->state & (1<<MD_DISK_SYNC) /* &&
1381 desc->raid_disk < mddev->raid_disks */) {
1382 set_bit(In_sync, &rdev->flags);
1383 rdev->raid_disk = desc->raid_disk;
1384 rdev->saved_raid_disk = desc->raid_disk;
1385 } else if (desc->state & (1<<MD_DISK_ACTIVE)) {
1386 /* active but not in sync implies recovery up to
1387 * reshape position. We don't know exactly where
1388 * that is, so set to zero for now */
1389 if (mddev->minor_version >= 91) {
1390 rdev->recovery_offset = 0;
1391 rdev->raid_disk = desc->raid_disk;
1392 }
1393 }
1394 if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
1395 set_bit(WriteMostly, &rdev->flags);
1396 if (desc->state & (1<<MD_DISK_FAILFAST))
1397 set_bit(FailFast, &rdev->flags);
1398 } else /* MULTIPATH are always insync */
1399 set_bit(In_sync, &rdev->flags);
1400 return 0;
1401}
1402
1403/*
1404 * sync_super for 0.90.0
1405 */
1406static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
1407{
1408 mdp_super_t *sb;
1409 struct md_rdev *rdev2;
1410 int next_spare = mddev->raid_disks;
1411
1412 /* make rdev->sb match mddev data..
1413 *
1414 * 1/ zero out disks
1415 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
1416 * 3/ any empty disks < next_spare become removed
1417 *
1418 * disks[0] gets initialised to REMOVED because
1419 * we cannot be sure from other fields if it has
1420 * been initialised or not.
1421 */
1422 int i;
1423 int active=0, working=0,failed=0,spare=0,nr_disks=0;
1424
1425 rdev->sb_size = MD_SB_BYTES;
1426
1427 sb = page_address(rdev->sb_page);
1428
1429 memset(sb, 0, sizeof(*sb));
1430
1431 sb->md_magic = MD_SB_MAGIC;
1432 sb->major_version = mddev->major_version;
1433 sb->patch_version = mddev->patch_version;
1434 sb->gvalid_words = 0; /* ignored */
1435 memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
1436 memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
1437 memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
1438 memcpy(&sb->set_uuid3, mddev->uuid+12,4);
1439
1440 sb->ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
1441 sb->level = mddev->level;
1442 sb->size = mddev->dev_sectors / 2;
1443 sb->raid_disks = mddev->raid_disks;
1444 sb->md_minor = mddev->md_minor;
1445 sb->not_persistent = 0;
1446 sb->utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
1447 sb->state = 0;
1448 sb->events_hi = (mddev->events>>32);
1449 sb->events_lo = (u32)mddev->events;
1450
1451 if (mddev->reshape_position == MaxSector)
1452 sb->minor_version = 90;
1453 else {
1454 sb->minor_version = 91;
1455 sb->reshape_position = mddev->reshape_position;
1456 sb->new_level = mddev->new_level;
1457 sb->delta_disks = mddev->delta_disks;
1458 sb->new_layout = mddev->new_layout;
1459 sb->new_chunk = mddev->new_chunk_sectors << 9;
1460 }
1461 mddev->minor_version = sb->minor_version;
1462 if (mddev->in_sync)
1463 {
1464 sb->recovery_cp = mddev->recovery_cp;
1465 sb->cp_events_hi = (mddev->events>>32);
1466 sb->cp_events_lo = (u32)mddev->events;
1467 if (mddev->recovery_cp == MaxSector)
1468 sb->state = (1<< MD_SB_CLEAN);
1469 } else
1470 sb->recovery_cp = 0;
1471
1472 sb->layout = mddev->layout;
1473 sb->chunk_size = mddev->chunk_sectors << 9;
1474
1475 if (mddev->bitmap && mddev->bitmap_info.file == NULL)
1476 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
1477
1478 sb->disks[0].state = (1<<MD_DISK_REMOVED);
1479 rdev_for_each(rdev2, mddev) {
1480 mdp_disk_t *d;
1481 int desc_nr;
1482 int is_active = test_bit(In_sync, &rdev2->flags);
1483
1484 if (rdev2->raid_disk >= 0 &&
1485 sb->minor_version >= 91)
1486 /* we have nowhere to store the recovery_offset,
1487 * but if it is not below the reshape_position,
1488 * we can piggy-back on that.
1489 */
1490 is_active = 1;
1491 if (rdev2->raid_disk < 0 ||
1492 test_bit(Faulty, &rdev2->flags))
1493 is_active = 0;
1494 if (is_active)
1495 desc_nr = rdev2->raid_disk;
1496 else
1497 desc_nr = next_spare++;
1498 rdev2->desc_nr = desc_nr;
1499 d = &sb->disks[rdev2->desc_nr];
1500 nr_disks++;
1501 d->number = rdev2->desc_nr;
1502 d->major = MAJOR(rdev2->bdev->bd_dev);
1503 d->minor = MINOR(rdev2->bdev->bd_dev);
1504 if (is_active)
1505 d->raid_disk = rdev2->raid_disk;
1506 else
1507 d->raid_disk = rdev2->desc_nr; /* compatibility */
1508 if (test_bit(Faulty, &rdev2->flags))
1509 d->state = (1<<MD_DISK_FAULTY);
1510 else if (is_active) {
1511 d->state = (1<<MD_DISK_ACTIVE);
1512 if (test_bit(In_sync, &rdev2->flags))
1513 d->state |= (1<<MD_DISK_SYNC);
1514 active++;
1515 working++;
1516 } else {
1517 d->state = 0;
1518 spare++;
1519 working++;
1520 }
1521 if (test_bit(WriteMostly, &rdev2->flags))
1522 d->state |= (1<<MD_DISK_WRITEMOSTLY);
1523 if (test_bit(FailFast, &rdev2->flags))
1524 d->state |= (1<<MD_DISK_FAILFAST);
1525 }
1526 /* now set the "removed" and "faulty" bits on any missing devices */
1527 for (i=0 ; i < mddev->raid_disks ; i++) {
1528 mdp_disk_t *d = &sb->disks[i];
1529 if (d->state == 0 && d->number == 0) {
1530 d->number = i;
1531 d->raid_disk = i;
1532 d->state = (1<<MD_DISK_REMOVED);
1533 d->state |= (1<<MD_DISK_FAULTY);
1534 failed++;
1535 }
1536 }
1537 sb->nr_disks = nr_disks;
1538 sb->active_disks = active;
1539 sb->working_disks = working;
1540 sb->failed_disks = failed;
1541 sb->spare_disks = spare;
1542
1543 sb->this_disk = sb->disks[rdev->desc_nr];
1544 sb->sb_csum = calc_sb_csum(sb);
1545}
1546
1547/*
1548 * rdev_size_change for 0.90.0
1549 */
1550static unsigned long long
1551super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1552{
1553 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1554 return 0; /* component must fit device */
1555 if (rdev->mddev->bitmap_info.offset)
1556 return 0; /* can't move bitmap */
1557 rdev->sb_start = calc_dev_sboffset(rdev);
1558 if (!num_sectors || num_sectors > rdev->sb_start)
1559 num_sectors = rdev->sb_start;
1560 /* Limit to 4TB as metadata cannot record more than that.
1561 * 4TB == 2^32 KB, or 2*2^32 sectors.
1562 */
1563 if ((u64)num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1)
1564 num_sectors = (sector_t)(2ULL << 32) - 2;
1565 do {
1566 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1567 rdev->sb_page);
1568 } while (md_super_wait(rdev->mddev) < 0);
1569 return num_sectors;
1570}
1571
1572static int
1573super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset)
1574{
1575 /* non-zero offset changes not possible with v0.90 */
1576 return new_offset == 0;
1577}
1578
1579/*
1580 * version 1 superblock
1581 */
1582
1583static __le32 calc_sb_1_csum(struct mdp_superblock_1 *sb)
1584{
1585 __le32 disk_csum;
1586 u32 csum;
1587 unsigned long long newcsum;
1588 int size = 256 + le32_to_cpu(sb->max_dev)*2;
1589 __le32 *isuper = (__le32*)sb;
1590
1591 disk_csum = sb->sb_csum;
1592 sb->sb_csum = 0;
1593 newcsum = 0;
1594 for (; size >= 4; size -= 4)
1595 newcsum += le32_to_cpu(*isuper++);
1596
1597 if (size == 2)
1598 newcsum += le16_to_cpu(*(__le16*) isuper);
1599
1600 csum = (newcsum & 0xffffffff) + (newcsum >> 32);
1601 sb->sb_csum = disk_csum;
1602 return cpu_to_le32(csum);
1603}
1604
1605static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
1606{
1607 struct mdp_superblock_1 *sb;
1608 int ret;
1609 sector_t sb_start;
1610 sector_t sectors;
1611 int bmask;
1612 bool spare_disk = true;
1613
1614 /*
1615 * Calculate the position of the superblock in 512byte sectors.
1616 * It is always aligned to a 4K boundary and
1617 * depeding on minor_version, it can be:
1618 * 0: At least 8K, but less than 12K, from end of device
1619 * 1: At start of device
1620 * 2: 4K from start of device.
1621 */
1622 switch(minor_version) {
1623 case 0:
1624 sb_start = bdev_nr_sectors(rdev->bdev) - 8 * 2;
1625 sb_start &= ~(sector_t)(4*2-1);
1626 break;
1627 case 1:
1628 sb_start = 0;
1629 break;
1630 case 2:
1631 sb_start = 8;
1632 break;
1633 default:
1634 return -EINVAL;
1635 }
1636 rdev->sb_start = sb_start;
1637
1638 /* superblock is rarely larger than 1K, but it can be larger,
1639 * and it is safe to read 4k, so we do that
1640 */
1641 ret = read_disk_sb(rdev, 4096);
1642 if (ret) return ret;
1643
1644 sb = page_address(rdev->sb_page);
1645
1646 if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
1647 sb->major_version != cpu_to_le32(1) ||
1648 le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
1649 le64_to_cpu(sb->super_offset) != rdev->sb_start ||
1650 (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
1651 return -EINVAL;
1652
1653 if (calc_sb_1_csum(sb) != sb->sb_csum) {
1654 pr_warn("md: invalid superblock checksum on %pg\n",
1655 rdev->bdev);
1656 return -EINVAL;
1657 }
1658 if (le64_to_cpu(sb->data_size) < 10) {
1659 pr_warn("md: data_size too small on %pg\n",
1660 rdev->bdev);
1661 return -EINVAL;
1662 }
1663 if (sb->pad0 ||
1664 sb->pad3[0] ||
1665 memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1])))
1666 /* Some padding is non-zero, might be a new feature */
1667 return -EINVAL;
1668
1669 rdev->preferred_minor = 0xffff;
1670 rdev->data_offset = le64_to_cpu(sb->data_offset);
1671 rdev->new_data_offset = rdev->data_offset;
1672 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) &&
1673 (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
1674 rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset);
1675 atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
1676
1677 rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
1678 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1679 if (rdev->sb_size & bmask)
1680 rdev->sb_size = (rdev->sb_size | bmask) + 1;
1681
1682 if (minor_version
1683 && rdev->data_offset < sb_start + (rdev->sb_size/512))
1684 return -EINVAL;
1685 if (minor_version
1686 && rdev->new_data_offset < sb_start + (rdev->sb_size/512))
1687 return -EINVAL;
1688
1689 if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
1690 rdev->desc_nr = -1;
1691 else
1692 rdev->desc_nr = le32_to_cpu(sb->dev_number);
1693
1694 if (!rdev->bb_page) {
1695 rdev->bb_page = alloc_page(GFP_KERNEL);
1696 if (!rdev->bb_page)
1697 return -ENOMEM;
1698 }
1699 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
1700 rdev->badblocks.count == 0) {
1701 /* need to load the bad block list.
1702 * Currently we limit it to one page.
1703 */
1704 s32 offset;
1705 sector_t bb_sector;
1706 __le64 *bbp;
1707 int i;
1708 int sectors = le16_to_cpu(sb->bblog_size);
1709 if (sectors > (PAGE_SIZE / 512))
1710 return -EINVAL;
1711 offset = le32_to_cpu(sb->bblog_offset);
1712 if (offset == 0)
1713 return -EINVAL;
1714 bb_sector = (long long)offset;
1715 if (!sync_page_io(rdev, bb_sector, sectors << 9,
1716 rdev->bb_page, REQ_OP_READ, true))
1717 return -EIO;
1718 bbp = (__le64 *)page_address(rdev->bb_page);
1719 rdev->badblocks.shift = sb->bblog_shift;
1720 for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
1721 u64 bb = le64_to_cpu(*bbp);
1722 int count = bb & (0x3ff);
1723 u64 sector = bb >> 10;
1724 sector <<= sb->bblog_shift;
1725 count <<= sb->bblog_shift;
1726 if (bb + 1 == 0)
1727 break;
1728 if (badblocks_set(&rdev->badblocks, sector, count, 1))
1729 return -EINVAL;
1730 }
1731 } else if (sb->bblog_offset != 0)
1732 rdev->badblocks.shift = 0;
1733
1734 if ((le32_to_cpu(sb->feature_map) &
1735 (MD_FEATURE_PPL | MD_FEATURE_MULTIPLE_PPLS))) {
1736 rdev->ppl.offset = (__s16)le16_to_cpu(sb->ppl.offset);
1737 rdev->ppl.size = le16_to_cpu(sb->ppl.size);
1738 rdev->ppl.sector = rdev->sb_start + rdev->ppl.offset;
1739 }
1740
1741 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RAID0_LAYOUT) &&
1742 sb->level != 0)
1743 return -EINVAL;
1744
1745 /* not spare disk, or LEVEL_MULTIPATH */
1746 if (sb->level == cpu_to_le32(LEVEL_MULTIPATH) ||
1747 (rdev->desc_nr >= 0 &&
1748 rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
1749 (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX ||
1750 le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL)))
1751 spare_disk = false;
1752
1753 if (!refdev) {
1754 if (!spare_disk)
1755 ret = 1;
1756 else
1757 ret = 0;
1758 } else {
1759 __u64 ev1, ev2;
1760 struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
1761
1762 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1763 sb->level != refsb->level ||
1764 sb->layout != refsb->layout ||
1765 sb->chunksize != refsb->chunksize) {
1766 pr_warn("md: %pg has strangely different superblock to %pg\n",
1767 rdev->bdev,
1768 refdev->bdev);
1769 return -EINVAL;
1770 }
1771 ev1 = le64_to_cpu(sb->events);
1772 ev2 = le64_to_cpu(refsb->events);
1773
1774 if (!spare_disk && ev1 > ev2)
1775 ret = 1;
1776 else
1777 ret = 0;
1778 }
1779 if (minor_version)
1780 sectors = bdev_nr_sectors(rdev->bdev) - rdev->data_offset;
1781 else
1782 sectors = rdev->sb_start;
1783 if (sectors < le64_to_cpu(sb->data_size))
1784 return -EINVAL;
1785 rdev->sectors = le64_to_cpu(sb->data_size);
1786 return ret;
1787}
1788
1789static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
1790{
1791 struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
1792 __u64 ev1 = le64_to_cpu(sb->events);
1793
1794 rdev->raid_disk = -1;
1795 clear_bit(Faulty, &rdev->flags);
1796 clear_bit(In_sync, &rdev->flags);
1797 clear_bit(Bitmap_sync, &rdev->flags);
1798 clear_bit(WriteMostly, &rdev->flags);
1799
1800 if (mddev->raid_disks == 0) {
1801 mddev->major_version = 1;
1802 mddev->patch_version = 0;
1803 mddev->external = 0;
1804 mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
1805 mddev->ctime = le64_to_cpu(sb->ctime);
1806 mddev->utime = le64_to_cpu(sb->utime);
1807 mddev->level = le32_to_cpu(sb->level);
1808 mddev->clevel[0] = 0;
1809 mddev->layout = le32_to_cpu(sb->layout);
1810 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
1811 mddev->dev_sectors = le64_to_cpu(sb->size);
1812 mddev->events = ev1;
1813 mddev->bitmap_info.offset = 0;
1814 mddev->bitmap_info.space = 0;
1815 /* Default location for bitmap is 1K after superblock
1816 * using 3K - total of 4K
1817 */
1818 mddev->bitmap_info.default_offset = 1024 >> 9;
1819 mddev->bitmap_info.default_space = (4096-1024) >> 9;
1820 mddev->reshape_backwards = 0;
1821
1822 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1823 memcpy(mddev->uuid, sb->set_uuid, 16);
1824
1825 mddev->max_disks = (4096-256)/2;
1826
1827 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1828 mddev->bitmap_info.file == NULL) {
1829 mddev->bitmap_info.offset =
1830 (__s32)le32_to_cpu(sb->bitmap_offset);
1831 /* Metadata doesn't record how much space is available.
1832 * For 1.0, we assume we can use up to the superblock
1833 * if before, else to 4K beyond superblock.
1834 * For others, assume no change is possible.
1835 */
1836 if (mddev->minor_version > 0)
1837 mddev->bitmap_info.space = 0;
1838 else if (mddev->bitmap_info.offset > 0)
1839 mddev->bitmap_info.space =
1840 8 - mddev->bitmap_info.offset;
1841 else
1842 mddev->bitmap_info.space =
1843 -mddev->bitmap_info.offset;
1844 }
1845
1846 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
1847 mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1848 mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1849 mddev->new_level = le32_to_cpu(sb->new_level);
1850 mddev->new_layout = le32_to_cpu(sb->new_layout);
1851 mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
1852 if (mddev->delta_disks < 0 ||
1853 (mddev->delta_disks == 0 &&
1854 (le32_to_cpu(sb->feature_map)
1855 & MD_FEATURE_RESHAPE_BACKWARDS)))
1856 mddev->reshape_backwards = 1;
1857 } else {
1858 mddev->reshape_position = MaxSector;
1859 mddev->delta_disks = 0;
1860 mddev->new_level = mddev->level;
1861 mddev->new_layout = mddev->layout;
1862 mddev->new_chunk_sectors = mddev->chunk_sectors;
1863 }
1864
1865 if (mddev->level == 0 &&
1866 !(le32_to_cpu(sb->feature_map) & MD_FEATURE_RAID0_LAYOUT))
1867 mddev->layout = -1;
1868
1869 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)
1870 set_bit(MD_HAS_JOURNAL, &mddev->flags);
1871
1872 if (le32_to_cpu(sb->feature_map) &
1873 (MD_FEATURE_PPL | MD_FEATURE_MULTIPLE_PPLS)) {
1874 if (le32_to_cpu(sb->feature_map) &
1875 (MD_FEATURE_BITMAP_OFFSET | MD_FEATURE_JOURNAL))
1876 return -EINVAL;
1877 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_PPL) &&
1878 (le32_to_cpu(sb->feature_map) &
1879 MD_FEATURE_MULTIPLE_PPLS))
1880 return -EINVAL;
1881 set_bit(MD_HAS_PPL, &mddev->flags);
1882 }
1883 } else if (mddev->pers == NULL) {
1884 /* Insist of good event counter while assembling, except for
1885 * spares (which don't need an event count) */
1886 ++ev1;
1887 if (rdev->desc_nr >= 0 &&
1888 rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
1889 (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX ||
1890 le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL))
1891 if (ev1 < mddev->events)
1892 return -EINVAL;
1893 } else if (mddev->bitmap) {
1894 /* If adding to array with a bitmap, then we can accept an
1895 * older device, but not too old.
1896 */
1897 if (ev1 < mddev->bitmap->events_cleared)
1898 return 0;
1899 if (ev1 < mddev->events)
1900 set_bit(Bitmap_sync, &rdev->flags);
1901 } else {
1902 if (ev1 < mddev->events)
1903 /* just a hot-add of a new device, leave raid_disk at -1 */
1904 return 0;
1905 }
1906 if (mddev->level != LEVEL_MULTIPATH) {
1907 int role;
1908 if (rdev->desc_nr < 0 ||
1909 rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
1910 role = MD_DISK_ROLE_SPARE;
1911 rdev->desc_nr = -1;
1912 } else
1913 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
1914 switch(role) {
1915 case MD_DISK_ROLE_SPARE: /* spare */
1916 break;
1917 case MD_DISK_ROLE_FAULTY: /* faulty */
1918 set_bit(Faulty, &rdev->flags);
1919 break;
1920 case MD_DISK_ROLE_JOURNAL: /* journal device */
1921 if (!(le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)) {
1922 /* journal device without journal feature */
1923 pr_warn("md: journal device provided without journal feature, ignoring the device\n");
1924 return -EINVAL;
1925 }
1926 set_bit(Journal, &rdev->flags);
1927 rdev->journal_tail = le64_to_cpu(sb->journal_tail);
1928 rdev->raid_disk = 0;
1929 break;
1930 default:
1931 rdev->saved_raid_disk = role;
1932 if ((le32_to_cpu(sb->feature_map) &
1933 MD_FEATURE_RECOVERY_OFFSET)) {
1934 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
1935 if (!(le32_to_cpu(sb->feature_map) &
1936 MD_FEATURE_RECOVERY_BITMAP))
1937 rdev->saved_raid_disk = -1;
1938 } else {
1939 /*
1940 * If the array is FROZEN, then the device can't
1941 * be in_sync with rest of array.
1942 */
1943 if (!test_bit(MD_RECOVERY_FROZEN,
1944 &mddev->recovery))
1945 set_bit(In_sync, &rdev->flags);
1946 }
1947 rdev->raid_disk = role;
1948 break;
1949 }
1950 if (sb->devflags & WriteMostly1)
1951 set_bit(WriteMostly, &rdev->flags);
1952 if (sb->devflags & FailFast1)
1953 set_bit(FailFast, &rdev->flags);
1954 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT)
1955 set_bit(Replacement, &rdev->flags);
1956 } else /* MULTIPATH are always insync */
1957 set_bit(In_sync, &rdev->flags);
1958
1959 return 0;
1960}
1961
1962static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
1963{
1964 struct mdp_superblock_1 *sb;
1965 struct md_rdev *rdev2;
1966 int max_dev, i;
1967 /* make rdev->sb match mddev and rdev data. */
1968
1969 sb = page_address(rdev->sb_page);
1970
1971 sb->feature_map = 0;
1972 sb->pad0 = 0;
1973 sb->recovery_offset = cpu_to_le64(0);
1974 memset(sb->pad3, 0, sizeof(sb->pad3));
1975
1976 sb->utime = cpu_to_le64((__u64)mddev->utime);
1977 sb->events = cpu_to_le64(mddev->events);
1978 if (mddev->in_sync)
1979 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
1980 else if (test_bit(MD_JOURNAL_CLEAN, &mddev->flags))
1981 sb->resync_offset = cpu_to_le64(MaxSector);
1982 else
1983 sb->resync_offset = cpu_to_le64(0);
1984
1985 sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
1986
1987 sb->raid_disks = cpu_to_le32(mddev->raid_disks);
1988 sb->size = cpu_to_le64(mddev->dev_sectors);
1989 sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
1990 sb->level = cpu_to_le32(mddev->level);
1991 sb->layout = cpu_to_le32(mddev->layout);
1992 if (test_bit(FailFast, &rdev->flags))
1993 sb->devflags |= FailFast1;
1994 else
1995 sb->devflags &= ~FailFast1;
1996
1997 if (test_bit(WriteMostly, &rdev->flags))
1998 sb->devflags |= WriteMostly1;
1999 else
2000 sb->devflags &= ~WriteMostly1;
2001 sb->data_offset = cpu_to_le64(rdev->data_offset);
2002 sb->data_size = cpu_to_le64(rdev->sectors);
2003
2004 if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
2005 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
2006 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
2007 }
2008
2009 if (rdev->raid_disk >= 0 && !test_bit(Journal, &rdev->flags) &&
2010 !test_bit(In_sync, &rdev->flags)) {
2011 sb->feature_map |=
2012 cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
2013 sb->recovery_offset =
2014 cpu_to_le64(rdev->recovery_offset);
2015 if (rdev->saved_raid_disk >= 0 && mddev->bitmap)
2016 sb->feature_map |=
2017 cpu_to_le32(MD_FEATURE_RECOVERY_BITMAP);
2018 }
2019 /* Note: recovery_offset and journal_tail share space */
2020 if (test_bit(Journal, &rdev->flags))
2021 sb->journal_tail = cpu_to_le64(rdev->journal_tail);
2022 if (test_bit(Replacement, &rdev->flags))
2023 sb->feature_map |=
2024 cpu_to_le32(MD_FEATURE_REPLACEMENT);
2025
2026 if (mddev->reshape_position != MaxSector) {
2027 sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
2028 sb->reshape_position = cpu_to_le64(mddev->reshape_position);
2029 sb->new_layout = cpu_to_le32(mddev->new_layout);
2030 sb->delta_disks = cpu_to_le32(mddev->delta_disks);
2031 sb->new_level = cpu_to_le32(mddev->new_level);
2032 sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
2033 if (mddev->delta_disks == 0 &&
2034 mddev->reshape_backwards)
2035 sb->feature_map
2036 |= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
2037 if (rdev->new_data_offset != rdev->data_offset) {
2038 sb->feature_map
2039 |= cpu_to_le32(MD_FEATURE_NEW_OFFSET);
2040 sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset
2041 - rdev->data_offset));
2042 }
2043 }
2044
2045 if (mddev_is_clustered(mddev))
2046 sb->feature_map |= cpu_to_le32(MD_FEATURE_CLUSTERED);
2047
2048 if (rdev->badblocks.count == 0)
2049 /* Nothing to do for bad blocks*/ ;
2050 else if (sb->bblog_offset == 0)
2051 /* Cannot record bad blocks on this device */
2052 md_error(mddev, rdev);
2053 else {
2054 struct badblocks *bb = &rdev->badblocks;
2055 __le64 *bbp = (__le64 *)page_address(rdev->bb_page);
2056 u64 *p = bb->page;
2057 sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
2058 if (bb->changed) {
2059 unsigned seq;
2060
2061retry:
2062 seq = read_seqbegin(&bb->lock);
2063
2064 memset(bbp, 0xff, PAGE_SIZE);
2065
2066 for (i = 0 ; i < bb->count ; i++) {
2067 u64 internal_bb = p[i];
2068 u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
2069 | BB_LEN(internal_bb));
2070 bbp[i] = cpu_to_le64(store_bb);
2071 }
2072 bb->changed = 0;
2073 if (read_seqretry(&bb->lock, seq))
2074 goto retry;
2075
2076 bb->sector = (rdev->sb_start +
2077 (int)le32_to_cpu(sb->bblog_offset));
2078 bb->size = le16_to_cpu(sb->bblog_size);
2079 }
2080 }
2081
2082 max_dev = 0;
2083 rdev_for_each(rdev2, mddev)
2084 if (rdev2->desc_nr+1 > max_dev)
2085 max_dev = rdev2->desc_nr+1;
2086
2087 if (max_dev > le32_to_cpu(sb->max_dev)) {
2088 int bmask;
2089 sb->max_dev = cpu_to_le32(max_dev);
2090 rdev->sb_size = max_dev * 2 + 256;
2091 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
2092 if (rdev->sb_size & bmask)
2093 rdev->sb_size = (rdev->sb_size | bmask) + 1;
2094 } else
2095 max_dev = le32_to_cpu(sb->max_dev);
2096
2097 for (i=0; i<max_dev;i++)
2098 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE);
2099
2100 if (test_bit(MD_HAS_JOURNAL, &mddev->flags))
2101 sb->feature_map |= cpu_to_le32(MD_FEATURE_JOURNAL);
2102
2103 if (test_bit(MD_HAS_PPL, &mddev->flags)) {
2104 if (test_bit(MD_HAS_MULTIPLE_PPLS, &mddev->flags))
2105 sb->feature_map |=
2106 cpu_to_le32(MD_FEATURE_MULTIPLE_PPLS);
2107 else
2108 sb->feature_map |= cpu_to_le32(MD_FEATURE_PPL);
2109 sb->ppl.offset = cpu_to_le16(rdev->ppl.offset);
2110 sb->ppl.size = cpu_to_le16(rdev->ppl.size);
2111 }
2112
2113 rdev_for_each(rdev2, mddev) {
2114 i = rdev2->desc_nr;
2115 if (test_bit(Faulty, &rdev2->flags))
2116 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_FAULTY);
2117 else if (test_bit(In_sync, &rdev2->flags))
2118 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
2119 else if (test_bit(Journal, &rdev2->flags))
2120 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_JOURNAL);
2121 else if (rdev2->raid_disk >= 0)
2122 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
2123 else
2124 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE);
2125 }
2126
2127 sb->sb_csum = calc_sb_1_csum(sb);
2128}
2129
2130static sector_t super_1_choose_bm_space(sector_t dev_size)
2131{
2132 sector_t bm_space;
2133
2134 /* if the device is bigger than 8Gig, save 64k for bitmap
2135 * usage, if bigger than 200Gig, save 128k
2136 */
2137 if (dev_size < 64*2)
2138 bm_space = 0;
2139 else if (dev_size - 64*2 >= 200*1024*1024*2)
2140 bm_space = 128*2;
2141 else if (dev_size - 4*2 > 8*1024*1024*2)
2142 bm_space = 64*2;
2143 else
2144 bm_space = 4*2;
2145 return bm_space;
2146}
2147
2148static unsigned long long
2149super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
2150{
2151 struct mdp_superblock_1 *sb;
2152 sector_t max_sectors;
2153 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
2154 return 0; /* component must fit device */
2155 if (rdev->data_offset != rdev->new_data_offset)
2156 return 0; /* too confusing */
2157 if (rdev->sb_start < rdev->data_offset) {
2158 /* minor versions 1 and 2; superblock before data */
2159 max_sectors = bdev_nr_sectors(rdev->bdev) - rdev->data_offset;
2160 if (!num_sectors || num_sectors > max_sectors)
2161 num_sectors = max_sectors;
2162 } else if (rdev->mddev->bitmap_info.offset) {
2163 /* minor version 0 with bitmap we can't move */
2164 return 0;
2165 } else {
2166 /* minor version 0; superblock after data */
2167 sector_t sb_start, bm_space;
2168 sector_t dev_size = bdev_nr_sectors(rdev->bdev);
2169
2170 /* 8K is for superblock */
2171 sb_start = dev_size - 8*2;
2172 sb_start &= ~(sector_t)(4*2 - 1);
2173
2174 bm_space = super_1_choose_bm_space(dev_size);
2175
2176 /* Space that can be used to store date needs to decrease
2177 * superblock bitmap space and bad block space(4K)
2178 */
2179 max_sectors = sb_start - bm_space - 4*2;
2180
2181 if (!num_sectors || num_sectors > max_sectors)
2182 num_sectors = max_sectors;
2183 rdev->sb_start = sb_start;
2184 }
2185 sb = page_address(rdev->sb_page);
2186 sb->data_size = cpu_to_le64(num_sectors);
2187 sb->super_offset = cpu_to_le64(rdev->sb_start);
2188 sb->sb_csum = calc_sb_1_csum(sb);
2189 do {
2190 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
2191 rdev->sb_page);
2192 } while (md_super_wait(rdev->mddev) < 0);
2193 return num_sectors;
2194
2195}
2196
2197static int
2198super_1_allow_new_offset(struct md_rdev *rdev,
2199 unsigned long long new_offset)
2200{
2201 /* All necessary checks on new >= old have been done */
2202 struct bitmap *bitmap;
2203 if (new_offset >= rdev->data_offset)
2204 return 1;
2205
2206 /* with 1.0 metadata, there is no metadata to tread on
2207 * so we can always move back */
2208 if (rdev->mddev->minor_version == 0)
2209 return 1;
2210
2211 /* otherwise we must be sure not to step on
2212 * any metadata, so stay:
2213 * 36K beyond start of superblock
2214 * beyond end of badblocks
2215 * beyond write-intent bitmap
2216 */
2217 if (rdev->sb_start + (32+4)*2 > new_offset)
2218 return 0;
2219 bitmap = rdev->mddev->bitmap;
2220 if (bitmap && !rdev->mddev->bitmap_info.file &&
2221 rdev->sb_start + rdev->mddev->bitmap_info.offset +
2222 bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
2223 return 0;
2224 if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
2225 return 0;
2226
2227 return 1;
2228}
2229
2230static struct super_type super_types[] = {
2231 [0] = {
2232 .name = "0.90.0",
2233 .owner = THIS_MODULE,
2234 .load_super = super_90_load,
2235 .validate_super = super_90_validate,
2236 .sync_super = super_90_sync,
2237 .rdev_size_change = super_90_rdev_size_change,
2238 .allow_new_offset = super_90_allow_new_offset,
2239 },
2240 [1] = {
2241 .name = "md-1",
2242 .owner = THIS_MODULE,
2243 .load_super = super_1_load,
2244 .validate_super = super_1_validate,
2245 .sync_super = super_1_sync,
2246 .rdev_size_change = super_1_rdev_size_change,
2247 .allow_new_offset = super_1_allow_new_offset,
2248 },
2249};
2250
2251static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
2252{
2253 if (mddev->sync_super) {
2254 mddev->sync_super(mddev, rdev);
2255 return;
2256 }
2257
2258 BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));
2259
2260 super_types[mddev->major_version].sync_super(mddev, rdev);
2261}
2262
2263static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
2264{
2265 struct md_rdev *rdev, *rdev2;
2266
2267 rcu_read_lock();
2268 rdev_for_each_rcu(rdev, mddev1) {
2269 if (test_bit(Faulty, &rdev->flags) ||
2270 test_bit(Journal, &rdev->flags) ||
2271 rdev->raid_disk == -1)
2272 continue;
2273 rdev_for_each_rcu(rdev2, mddev2) {
2274 if (test_bit(Faulty, &rdev2->flags) ||
2275 test_bit(Journal, &rdev2->flags) ||
2276 rdev2->raid_disk == -1)
2277 continue;
2278 if (rdev->bdev->bd_disk == rdev2->bdev->bd_disk) {
2279 rcu_read_unlock();
2280 return 1;
2281 }
2282 }
2283 }
2284 rcu_read_unlock();
2285 return 0;
2286}
2287
2288static LIST_HEAD(pending_raid_disks);
2289
2290/*
2291 * Try to register data integrity profile for an mddev
2292 *
2293 * This is called when an array is started and after a disk has been kicked
2294 * from the array. It only succeeds if all working and active component devices
2295 * are integrity capable with matching profiles.
2296 */
2297int md_integrity_register(struct mddev *mddev)
2298{
2299 struct md_rdev *rdev, *reference = NULL;
2300
2301 if (list_empty(&mddev->disks))
2302 return 0; /* nothing to do */
2303 if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
2304 return 0; /* shouldn't register, or already is */
2305 rdev_for_each(rdev, mddev) {
2306 /* skip spares and non-functional disks */
2307 if (test_bit(Faulty, &rdev->flags))
2308 continue;
2309 if (rdev->raid_disk < 0)
2310 continue;
2311 if (!reference) {
2312 /* Use the first rdev as the reference */
2313 reference = rdev;
2314 continue;
2315 }
2316 /* does this rdev's profile match the reference profile? */
2317 if (blk_integrity_compare(reference->bdev->bd_disk,
2318 rdev->bdev->bd_disk) < 0)
2319 return -EINVAL;
2320 }
2321 if (!reference || !bdev_get_integrity(reference->bdev))
2322 return 0;
2323 /*
2324 * All component devices are integrity capable and have matching
2325 * profiles, register the common profile for the md device.
2326 */
2327 blk_integrity_register(mddev->gendisk,
2328 bdev_get_integrity(reference->bdev));
2329
2330 pr_debug("md: data integrity enabled on %s\n", mdname(mddev));
2331 if (bioset_integrity_create(&mddev->bio_set, BIO_POOL_SIZE) ||
2332 (mddev->level != 1 && mddev->level != 10 &&
2333 bioset_integrity_create(&mddev->io_acct_set, BIO_POOL_SIZE))) {
2334 /*
2335 * No need to handle the failure of bioset_integrity_create,
2336 * because the function is called by md_run() -> pers->run(),
2337 * md_run calls bioset_exit -> bioset_integrity_free in case
2338 * of failure case.
2339 */
2340 pr_err("md: failed to create integrity pool for %s\n",
2341 mdname(mddev));
2342 return -EINVAL;
2343 }
2344 return 0;
2345}
2346EXPORT_SYMBOL(md_integrity_register);
2347
2348/*
2349 * Attempt to add an rdev, but only if it is consistent with the current
2350 * integrity profile
2351 */
2352int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
2353{
2354 struct blk_integrity *bi_mddev;
2355
2356 if (!mddev->gendisk)
2357 return 0;
2358
2359 bi_mddev = blk_get_integrity(mddev->gendisk);
2360
2361 if (!bi_mddev) /* nothing to do */
2362 return 0;
2363
2364 if (blk_integrity_compare(mddev->gendisk, rdev->bdev->bd_disk) != 0) {
2365 pr_err("%s: incompatible integrity profile for %pg\n",
2366 mdname(mddev), rdev->bdev);
2367 return -ENXIO;
2368 }
2369
2370 return 0;
2371}
2372EXPORT_SYMBOL(md_integrity_add_rdev);
2373
2374static bool rdev_read_only(struct md_rdev *rdev)
2375{
2376 return bdev_read_only(rdev->bdev) ||
2377 (rdev->meta_bdev && bdev_read_only(rdev->meta_bdev));
2378}
2379
2380static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev)
2381{
2382 char b[BDEVNAME_SIZE];
2383 int err;
2384
2385 /* prevent duplicates */
2386 if (find_rdev(mddev, rdev->bdev->bd_dev))
2387 return -EEXIST;
2388
2389 if (rdev_read_only(rdev) && mddev->pers)
2390 return -EROFS;
2391
2392 /* make sure rdev->sectors exceeds mddev->dev_sectors */
2393 if (!test_bit(Journal, &rdev->flags) &&
2394 rdev->sectors &&
2395 (mddev->dev_sectors == 0 || rdev->sectors < mddev->dev_sectors)) {
2396 if (mddev->pers) {
2397 /* Cannot change size, so fail
2398 * If mddev->level <= 0, then we don't care
2399 * about aligning sizes (e.g. linear)
2400 */
2401 if (mddev->level > 0)
2402 return -ENOSPC;
2403 } else
2404 mddev->dev_sectors = rdev->sectors;
2405 }
2406
2407 /* Verify rdev->desc_nr is unique.
2408 * If it is -1, assign a free number, else
2409 * check number is not in use
2410 */
2411 rcu_read_lock();
2412 if (rdev->desc_nr < 0) {
2413 int choice = 0;
2414 if (mddev->pers)
2415 choice = mddev->raid_disks;
2416 while (md_find_rdev_nr_rcu(mddev, choice))
2417 choice++;
2418 rdev->desc_nr = choice;
2419 } else {
2420 if (md_find_rdev_nr_rcu(mddev, rdev->desc_nr)) {
2421 rcu_read_unlock();
2422 return -EBUSY;
2423 }
2424 }
2425 rcu_read_unlock();
2426 if (!test_bit(Journal, &rdev->flags) &&
2427 mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
2428 pr_warn("md: %s: array is limited to %d devices\n",
2429 mdname(mddev), mddev->max_disks);
2430 return -EBUSY;
2431 }
2432 snprintf(b, sizeof(b), "%pg", rdev->bdev);
2433 strreplace(b, '/', '!');
2434
2435 rdev->mddev = mddev;
2436 pr_debug("md: bind<%s>\n", b);
2437
2438 if (mddev->raid_disks)
2439 mddev_create_serial_pool(mddev, rdev, false);
2440
2441 if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
2442 goto fail;
2443
2444 /* failure here is OK */
2445 err = sysfs_create_link(&rdev->kobj, bdev_kobj(rdev->bdev), "block");
2446 rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
2447 rdev->sysfs_unack_badblocks =
2448 sysfs_get_dirent_safe(rdev->kobj.sd, "unacknowledged_bad_blocks");
2449 rdev->sysfs_badblocks =
2450 sysfs_get_dirent_safe(rdev->kobj.sd, "bad_blocks");
2451
2452 list_add_rcu(&rdev->same_set, &mddev->disks);
2453 bd_link_disk_holder(rdev->bdev, mddev->gendisk);
2454
2455 /* May as well allow recovery to be retried once */
2456 mddev->recovery_disabled++;
2457
2458 return 0;
2459
2460 fail:
2461 pr_warn("md: failed to register dev-%s for %s\n",
2462 b, mdname(mddev));
2463 return err;
2464}
2465
2466static void rdev_delayed_delete(struct work_struct *ws)
2467{
2468 struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
2469 kobject_del(&rdev->kobj);
2470 kobject_put(&rdev->kobj);
2471}
2472
2473void md_autodetect_dev(dev_t dev);
2474
2475static void export_rdev(struct md_rdev *rdev)
2476{
2477 pr_debug("md: export_rdev(%pg)\n", rdev->bdev);
2478 md_rdev_clear(rdev);
2479#ifndef MODULE
2480 if (test_bit(AutoDetected, &rdev->flags))
2481 md_autodetect_dev(rdev->bdev->bd_dev);
2482#endif
2483 blkdev_put(rdev->bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
2484 rdev->bdev = NULL;
2485 kobject_put(&rdev->kobj);
2486}
2487
2488static void md_kick_rdev_from_array(struct md_rdev *rdev)
2489{
2490 bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
2491 list_del_rcu(&rdev->same_set);
2492 pr_debug("md: unbind<%pg>\n", rdev->bdev);
2493 mddev_destroy_serial_pool(rdev->mddev, rdev, false);
2494 rdev->mddev = NULL;
2495 sysfs_remove_link(&rdev->kobj, "block");
2496 sysfs_put(rdev->sysfs_state);
2497 sysfs_put(rdev->sysfs_unack_badblocks);
2498 sysfs_put(rdev->sysfs_badblocks);
2499 rdev->sysfs_state = NULL;
2500 rdev->sysfs_unack_badblocks = NULL;
2501 rdev->sysfs_badblocks = NULL;
2502 rdev->badblocks.count = 0;
2503 /* We need to delay this, otherwise we can deadlock when
2504 * writing to 'remove' to "dev/state". We also need
2505 * to delay it due to rcu usage.
2506 */
2507 synchronize_rcu();
2508 INIT_WORK(&rdev->del_work, rdev_delayed_delete);
2509 kobject_get(&rdev->kobj);
2510 queue_work(md_rdev_misc_wq, &rdev->del_work);
2511 export_rdev(rdev);
2512}
2513
2514static void export_array(struct mddev *mddev)
2515{
2516 struct md_rdev *rdev;
2517
2518 while (!list_empty(&mddev->disks)) {
2519 rdev = list_first_entry(&mddev->disks, struct md_rdev,
2520 same_set);
2521 md_kick_rdev_from_array(rdev);
2522 }
2523 mddev->raid_disks = 0;
2524 mddev->major_version = 0;
2525}
2526
2527static bool set_in_sync(struct mddev *mddev)
2528{
2529 lockdep_assert_held(&mddev->lock);
2530 if (!mddev->in_sync) {
2531 mddev->sync_checkers++;
2532 spin_unlock(&mddev->lock);
2533 percpu_ref_switch_to_atomic_sync(&mddev->writes_pending);
2534 spin_lock(&mddev->lock);
2535 if (!mddev->in_sync &&
2536 percpu_ref_is_zero(&mddev->writes_pending)) {
2537 mddev->in_sync = 1;
2538 /*
2539 * Ensure ->in_sync is visible before we clear
2540 * ->sync_checkers.
2541 */
2542 smp_mb();
2543 set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
2544 sysfs_notify_dirent_safe(mddev->sysfs_state);
2545 }
2546 if (--mddev->sync_checkers == 0)
2547 percpu_ref_switch_to_percpu(&mddev->writes_pending);
2548 }
2549 if (mddev->safemode == 1)
2550 mddev->safemode = 0;
2551 return mddev->in_sync;
2552}
2553
2554static void sync_sbs(struct mddev *mddev, int nospares)
2555{
2556 /* Update each superblock (in-memory image), but
2557 * if we are allowed to, skip spares which already
2558 * have the right event counter, or have one earlier
2559 * (which would mean they aren't being marked as dirty
2560 * with the rest of the array)
2561 */
2562 struct md_rdev *rdev;
2563 rdev_for_each(rdev, mddev) {
2564 if (rdev->sb_events == mddev->events ||
2565 (nospares &&
2566 rdev->raid_disk < 0 &&
2567 rdev->sb_events+1 == mddev->events)) {
2568 /* Don't update this superblock */
2569 rdev->sb_loaded = 2;
2570 } else {
2571 sync_super(mddev, rdev);
2572 rdev->sb_loaded = 1;
2573 }
2574 }
2575}
2576
2577static bool does_sb_need_changing(struct mddev *mddev)
2578{
2579 struct md_rdev *rdev = NULL, *iter;
2580 struct mdp_superblock_1 *sb;
2581 int role;
2582
2583 /* Find a good rdev */
2584 rdev_for_each(iter, mddev)
2585 if ((iter->raid_disk >= 0) && !test_bit(Faulty, &iter->flags)) {
2586 rdev = iter;
2587 break;
2588 }
2589
2590 /* No good device found. */
2591 if (!rdev)
2592 return false;
2593
2594 sb = page_address(rdev->sb_page);
2595 /* Check if a device has become faulty or a spare become active */
2596 rdev_for_each(rdev, mddev) {
2597 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
2598 /* Device activated? */
2599 if (role == MD_DISK_ROLE_SPARE && rdev->raid_disk >= 0 &&
2600 !test_bit(Faulty, &rdev->flags))
2601 return true;
2602 /* Device turned faulty? */
2603 if (test_bit(Faulty, &rdev->flags) && (role < MD_DISK_ROLE_MAX))
2604 return true;
2605 }
2606
2607 /* Check if any mddev parameters have changed */
2608 if ((mddev->dev_sectors != le64_to_cpu(sb->size)) ||
2609 (mddev->reshape_position != le64_to_cpu(sb->reshape_position)) ||
2610 (mddev->layout != le32_to_cpu(sb->layout)) ||
2611 (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) ||
2612 (mddev->chunk_sectors != le32_to_cpu(sb->chunksize)))
2613 return true;
2614
2615 return false;
2616}
2617
2618void md_update_sb(struct mddev *mddev, int force_change)
2619{
2620 struct md_rdev *rdev;
2621 int sync_req;
2622 int nospares = 0;
2623 int any_badblocks_changed = 0;
2624 int ret = -1;
2625
2626 if (!md_is_rdwr(mddev)) {
2627 if (force_change)
2628 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
2629 return;
2630 }
2631
2632repeat:
2633 if (mddev_is_clustered(mddev)) {
2634 if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags))
2635 force_change = 1;
2636 if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags))
2637 nospares = 1;
2638 ret = md_cluster_ops->metadata_update_start(mddev);
2639 /* Has someone else has updated the sb */
2640 if (!does_sb_need_changing(mddev)) {
2641 if (ret == 0)
2642 md_cluster_ops->metadata_update_cancel(mddev);
2643 bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING),
2644 BIT(MD_SB_CHANGE_DEVS) |
2645 BIT(MD_SB_CHANGE_CLEAN));
2646 return;
2647 }
2648 }
2649
2650 /*
2651 * First make sure individual recovery_offsets are correct
2652 * curr_resync_completed can only be used during recovery.
2653 * During reshape/resync it might use array-addresses rather
2654 * that device addresses.
2655 */
2656 rdev_for_each(rdev, mddev) {
2657 if (rdev->raid_disk >= 0 &&
2658 mddev->delta_disks >= 0 &&
2659 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
2660 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery) &&
2661 !test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
2662 !test_bit(Journal, &rdev->flags) &&
2663 !test_bit(In_sync, &rdev->flags) &&
2664 mddev->curr_resync_completed > rdev->recovery_offset)
2665 rdev->recovery_offset = mddev->curr_resync_completed;
2666
2667 }
2668 if (!mddev->persistent) {
2669 clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
2670 clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
2671 if (!mddev->external) {
2672 clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
2673 rdev_for_each(rdev, mddev) {
2674 if (rdev->badblocks.changed) {
2675 rdev->badblocks.changed = 0;
2676 ack_all_badblocks(&rdev->badblocks);
2677 md_error(mddev, rdev);
2678 }
2679 clear_bit(Blocked, &rdev->flags);
2680 clear_bit(BlockedBadBlocks, &rdev->flags);
2681 wake_up(&rdev->blocked_wait);
2682 }
2683 }
2684 wake_up(&mddev->sb_wait);
2685 return;
2686 }
2687
2688 spin_lock(&mddev->lock);
2689
2690 mddev->utime = ktime_get_real_seconds();
2691
2692 if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags))
2693 force_change = 1;
2694 if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags))
2695 /* just a clean<-> dirty transition, possibly leave spares alone,
2696 * though if events isn't the right even/odd, we will have to do
2697 * spares after all
2698 */
2699 nospares = 1;
2700 if (force_change)
2701 nospares = 0;
2702 if (mddev->degraded)
2703 /* If the array is degraded, then skipping spares is both
2704 * dangerous and fairly pointless.
2705 * Dangerous because a device that was removed from the array
2706 * might have a event_count that still looks up-to-date,
2707 * so it can be re-added without a resync.
2708 * Pointless because if there are any spares to skip,
2709 * then a recovery will happen and soon that array won't
2710 * be degraded any more and the spare can go back to sleep then.
2711 */
2712 nospares = 0;
2713
2714 sync_req = mddev->in_sync;
2715
2716 /* If this is just a dirty<->clean transition, and the array is clean
2717 * and 'events' is odd, we can roll back to the previous clean state */
2718 if (nospares
2719 && (mddev->in_sync && mddev->recovery_cp == MaxSector)
2720 && mddev->can_decrease_events
2721 && mddev->events != 1) {
2722 mddev->events--;
2723 mddev->can_decrease_events = 0;
2724 } else {
2725 /* otherwise we have to go forward and ... */
2726 mddev->events ++;
2727 mddev->can_decrease_events = nospares;
2728 }
2729
2730 /*
2731 * This 64-bit counter should never wrap.
2732 * Either we are in around ~1 trillion A.C., assuming
2733 * 1 reboot per second, or we have a bug...
2734 */
2735 WARN_ON(mddev->events == 0);
2736
2737 rdev_for_each(rdev, mddev) {
2738 if (rdev->badblocks.changed)
2739 any_badblocks_changed++;
2740 if (test_bit(Faulty, &rdev->flags))
2741 set_bit(FaultRecorded, &rdev->flags);
2742 }
2743
2744 sync_sbs(mddev, nospares);
2745 spin_unlock(&mddev->lock);
2746
2747 pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
2748 mdname(mddev), mddev->in_sync);
2749
2750 if (mddev->queue)
2751 blk_add_trace_msg(mddev->queue, "md md_update_sb");
2752rewrite:
2753 md_bitmap_update_sb(mddev->bitmap);
2754 rdev_for_each(rdev, mddev) {
2755 if (rdev->sb_loaded != 1)
2756 continue; /* no noise on spare devices */
2757
2758 if (!test_bit(Faulty, &rdev->flags)) {
2759 md_super_write(mddev,rdev,
2760 rdev->sb_start, rdev->sb_size,
2761 rdev->sb_page);
2762 pr_debug("md: (write) %pg's sb offset: %llu\n",
2763 rdev->bdev,
2764 (unsigned long long)rdev->sb_start);
2765 rdev->sb_events = mddev->events;
2766 if (rdev->badblocks.size) {
2767 md_super_write(mddev, rdev,
2768 rdev->badblocks.sector,
2769 rdev->badblocks.size << 9,
2770 rdev->bb_page);
2771 rdev->badblocks.size = 0;
2772 }
2773
2774 } else
2775 pr_debug("md: %pg (skipping faulty)\n",
2776 rdev->bdev);
2777
2778 if (mddev->level == LEVEL_MULTIPATH)
2779 /* only need to write one superblock... */
2780 break;
2781 }
2782 if (md_super_wait(mddev) < 0)
2783 goto rewrite;
2784 /* if there was a failure, MD_SB_CHANGE_DEVS was set, and we re-write super */
2785
2786 if (mddev_is_clustered(mddev) && ret == 0)
2787 md_cluster_ops->metadata_update_finish(mddev);
2788
2789 if (mddev->in_sync != sync_req ||
2790 !bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING),
2791 BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_CLEAN)))
2792 /* have to write it out again */
2793 goto repeat;
2794 wake_up(&mddev->sb_wait);
2795 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2796 sysfs_notify_dirent_safe(mddev->sysfs_completed);
2797
2798 rdev_for_each(rdev, mddev) {
2799 if (test_and_clear_bit(FaultRecorded, &rdev->flags))
2800 clear_bit(Blocked, &rdev->flags);
2801
2802 if (any_badblocks_changed)
2803 ack_all_badblocks(&rdev->badblocks);
2804 clear_bit(BlockedBadBlocks, &rdev->flags);
2805 wake_up(&rdev->blocked_wait);
2806 }
2807}
2808EXPORT_SYMBOL(md_update_sb);
2809
2810static int add_bound_rdev(struct md_rdev *rdev)
2811{
2812 struct mddev *mddev = rdev->mddev;
2813 int err = 0;
2814 bool add_journal = test_bit(Journal, &rdev->flags);
2815
2816 if (!mddev->pers->hot_remove_disk || add_journal) {
2817 /* If there is hot_add_disk but no hot_remove_disk
2818 * then added disks for geometry changes,
2819 * and should be added immediately.
2820 */
2821 super_types[mddev->major_version].
2822 validate_super(mddev, rdev);
2823 if (add_journal)
2824 mddev_suspend(mddev);
2825 err = mddev->pers->hot_add_disk(mddev, rdev);
2826 if (add_journal)
2827 mddev_resume(mddev);
2828 if (err) {
2829 md_kick_rdev_from_array(rdev);
2830 return err;
2831 }
2832 }
2833 sysfs_notify_dirent_safe(rdev->sysfs_state);
2834
2835 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
2836 if (mddev->degraded)
2837 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
2838 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2839 md_new_event();
2840 md_wakeup_thread(mddev->thread);
2841 return 0;
2842}
2843
2844/* words written to sysfs files may, or may not, be \n terminated.
2845 * We want to accept with case. For this we use cmd_match.
2846 */
2847static int cmd_match(const char *cmd, const char *str)
2848{
2849 /* See if cmd, written into a sysfs file, matches
2850 * str. They must either be the same, or cmd can
2851 * have a trailing newline
2852 */
2853 while (*cmd && *str && *cmd == *str) {
2854 cmd++;
2855 str++;
2856 }
2857 if (*cmd == '\n')
2858 cmd++;
2859 if (*str || *cmd)
2860 return 0;
2861 return 1;
2862}
2863
2864struct rdev_sysfs_entry {
2865 struct attribute attr;
2866 ssize_t (*show)(struct md_rdev *, char *);
2867 ssize_t (*store)(struct md_rdev *, const char *, size_t);
2868};
2869
2870static ssize_t
2871state_show(struct md_rdev *rdev, char *page)
2872{
2873 char *sep = ",";
2874 size_t len = 0;
2875 unsigned long flags = READ_ONCE(rdev->flags);
2876
2877 if (test_bit(Faulty, &flags) ||
2878 (!test_bit(ExternalBbl, &flags) &&
2879 rdev->badblocks.unacked_exist))
2880 len += sprintf(page+len, "faulty%s", sep);
2881 if (test_bit(In_sync, &flags))
2882 len += sprintf(page+len, "in_sync%s", sep);
2883 if (test_bit(Journal, &flags))
2884 len += sprintf(page+len, "journal%s", sep);
2885 if (test_bit(WriteMostly, &flags))
2886 len += sprintf(page+len, "write_mostly%s", sep);
2887 if (test_bit(Blocked, &flags) ||
2888 (rdev->badblocks.unacked_exist
2889 && !test_bit(Faulty, &flags)))
2890 len += sprintf(page+len, "blocked%s", sep);
2891 if (!test_bit(Faulty, &flags) &&
2892 !test_bit(Journal, &flags) &&
2893 !test_bit(In_sync, &flags))
2894 len += sprintf(page+len, "spare%s", sep);
2895 if (test_bit(WriteErrorSeen, &flags))
2896 len += sprintf(page+len, "write_error%s", sep);
2897 if (test_bit(WantReplacement, &flags))
2898 len += sprintf(page+len, "want_replacement%s", sep);
2899 if (test_bit(Replacement, &flags))
2900 len += sprintf(page+len, "replacement%s", sep);
2901 if (test_bit(ExternalBbl, &flags))
2902 len += sprintf(page+len, "external_bbl%s", sep);
2903 if (test_bit(FailFast, &flags))
2904 len += sprintf(page+len, "failfast%s", sep);
2905
2906 if (len)
2907 len -= strlen(sep);
2908
2909 return len+sprintf(page+len, "\n");
2910}
2911
2912static ssize_t
2913state_store(struct md_rdev *rdev, const char *buf, size_t len)
2914{
2915 /* can write
2916 * faulty - simulates an error
2917 * remove - disconnects the device
2918 * writemostly - sets write_mostly
2919 * -writemostly - clears write_mostly
2920 * blocked - sets the Blocked flags
2921 * -blocked - clears the Blocked and possibly simulates an error
2922 * insync - sets Insync providing device isn't active
2923 * -insync - clear Insync for a device with a slot assigned,
2924 * so that it gets rebuilt based on bitmap
2925 * write_error - sets WriteErrorSeen
2926 * -write_error - clears WriteErrorSeen
2927 * {,-}failfast - set/clear FailFast
2928 */
2929
2930 struct mddev *mddev = rdev->mddev;
2931 int err = -EINVAL;
2932 bool need_update_sb = false;
2933
2934 if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2935 md_error(rdev->mddev, rdev);
2936
2937 if (test_bit(MD_BROKEN, &rdev->mddev->flags))
2938 err = -EBUSY;
2939 else
2940 err = 0;
2941 } else if (cmd_match(buf, "remove")) {
2942 if (rdev->mddev->pers) {
2943 clear_bit(Blocked, &rdev->flags);
2944 remove_and_add_spares(rdev->mddev, rdev);
2945 }
2946 if (rdev->raid_disk >= 0)
2947 err = -EBUSY;
2948 else {
2949 err = 0;
2950 if (mddev_is_clustered(mddev))
2951 err = md_cluster_ops->remove_disk(mddev, rdev);
2952
2953 if (err == 0) {
2954 md_kick_rdev_from_array(rdev);
2955 if (mddev->pers) {
2956 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
2957 md_wakeup_thread(mddev->thread);
2958 }
2959 md_new_event();
2960 }
2961 }
2962 } else if (cmd_match(buf, "writemostly")) {
2963 set_bit(WriteMostly, &rdev->flags);
2964 mddev_create_serial_pool(rdev->mddev, rdev, false);
2965 need_update_sb = true;
2966 err = 0;
2967 } else if (cmd_match(buf, "-writemostly")) {
2968 mddev_destroy_serial_pool(rdev->mddev, rdev, false);
2969 clear_bit(WriteMostly, &rdev->flags);
2970 need_update_sb = true;
2971 err = 0;
2972 } else if (cmd_match(buf, "blocked")) {
2973 set_bit(Blocked, &rdev->flags);
2974 err = 0;
2975 } else if (cmd_match(buf, "-blocked")) {
2976 if (!test_bit(Faulty, &rdev->flags) &&
2977 !test_bit(ExternalBbl, &rdev->flags) &&
2978 rdev->badblocks.unacked_exist) {
2979 /* metadata handler doesn't understand badblocks,
2980 * so we need to fail the device
2981 */
2982 md_error(rdev->mddev, rdev);
2983 }
2984 clear_bit(Blocked, &rdev->flags);
2985 clear_bit(BlockedBadBlocks, &rdev->flags);
2986 wake_up(&rdev->blocked_wait);
2987 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2988 md_wakeup_thread(rdev->mddev->thread);
2989
2990 err = 0;
2991 } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
2992 set_bit(In_sync, &rdev->flags);
2993 err = 0;
2994 } else if (cmd_match(buf, "failfast")) {
2995 set_bit(FailFast, &rdev->flags);
2996 need_update_sb = true;
2997 err = 0;
2998 } else if (cmd_match(buf, "-failfast")) {
2999 clear_bit(FailFast, &rdev->flags);
3000 need_update_sb = true;
3001 err = 0;
3002 } else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0 &&
3003 !test_bit(Journal, &rdev->flags)) {
3004 if (rdev->mddev->pers == NULL) {
3005 clear_bit(In_sync, &rdev->flags);
3006 rdev->saved_raid_disk = rdev->raid_disk;
3007 rdev->raid_disk = -1;
3008 err = 0;
3009 }
3010 } else if (cmd_match(buf, "write_error")) {
3011 set_bit(WriteErrorSeen, &rdev->flags);
3012 err = 0;
3013 } else if (cmd_match(buf, "-write_error")) {
3014 clear_bit(WriteErrorSeen, &rdev->flags);
3015 err = 0;
3016 } else if (cmd_match(buf, "want_replacement")) {
3017 /* Any non-spare device that is not a replacement can
3018 * become want_replacement at any time, but we then need to
3019 * check if recovery is needed.
3020 */
3021 if (rdev->raid_disk >= 0 &&
3022 !test_bit(Journal, &rdev->flags) &&
3023 !test_bit(Replacement, &rdev->flags))
3024 set_bit(WantReplacement, &rdev->flags);
3025 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
3026 md_wakeup_thread(rdev->mddev->thread);
3027 err = 0;
3028 } else if (cmd_match(buf, "-want_replacement")) {
3029 /* Clearing 'want_replacement' is always allowed.
3030 * Once replacements starts it is too late though.
3031 */
3032 err = 0;
3033 clear_bit(WantReplacement, &rdev->flags);
3034 } else if (cmd_match(buf, "replacement")) {
3035 /* Can only set a device as a replacement when array has not
3036 * yet been started. Once running, replacement is automatic
3037 * from spares, or by assigning 'slot'.
3038 */
3039 if (rdev->mddev->pers)
3040 err = -EBUSY;
3041 else {
3042 set_bit(Replacement, &rdev->flags);
3043 err = 0;
3044 }
3045 } else if (cmd_match(buf, "-replacement")) {
3046 /* Similarly, can only clear Replacement before start */
3047 if (rdev->mddev->pers)
3048 err = -EBUSY;
3049 else {
3050 clear_bit(Replacement, &rdev->flags);
3051 err = 0;
3052 }
3053 } else if (cmd_match(buf, "re-add")) {
3054 if (!rdev->mddev->pers)
3055 err = -EINVAL;
3056 else if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1) &&
3057 rdev->saved_raid_disk >= 0) {
3058 /* clear_bit is performed _after_ all the devices
3059 * have their local Faulty bit cleared. If any writes
3060 * happen in the meantime in the local node, they
3061 * will land in the local bitmap, which will be synced
3062 * by this node eventually
3063 */
3064 if (!mddev_is_clustered(rdev->mddev) ||
3065 (err = md_cluster_ops->gather_bitmaps(rdev)) == 0) {
3066 clear_bit(Faulty, &rdev->flags);
3067 err = add_bound_rdev(rdev);
3068 }
3069 } else
3070 err = -EBUSY;
3071 } else if (cmd_match(buf, "external_bbl") && (rdev->mddev->external)) {
3072 set_bit(ExternalBbl, &rdev->flags);
3073 rdev->badblocks.shift = 0;
3074 err = 0;
3075 } else if (cmd_match(buf, "-external_bbl") && (rdev->mddev->external)) {
3076 clear_bit(ExternalBbl, &rdev->flags);
3077 err = 0;
3078 }
3079 if (need_update_sb)
3080 md_update_sb(mddev, 1);
3081 if (!err)
3082 sysfs_notify_dirent_safe(rdev->sysfs_state);
3083 return err ? err : len;
3084}
3085static struct rdev_sysfs_entry rdev_state =
3086__ATTR_PREALLOC(state, S_IRUGO|S_IWUSR, state_show, state_store);
3087
3088static ssize_t
3089errors_show(struct md_rdev *rdev, char *page)
3090{
3091 return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
3092}
3093
3094static ssize_t
3095errors_store(struct md_rdev *rdev, const char *buf, size_t len)
3096{
3097 unsigned int n;
3098 int rv;
3099
3100 rv = kstrtouint(buf, 10, &n);
3101 if (rv < 0)
3102 return rv;
3103 atomic_set(&rdev->corrected_errors, n);
3104 return len;
3105}
3106static struct rdev_sysfs_entry rdev_errors =
3107__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
3108
3109static ssize_t
3110slot_show(struct md_rdev *rdev, char *page)
3111{
3112 if (test_bit(Journal, &rdev->flags))
3113 return sprintf(page, "journal\n");
3114 else if (rdev->raid_disk < 0)
3115 return sprintf(page, "none\n");
3116 else
3117 return sprintf(page, "%d\n", rdev->raid_disk);
3118}
3119
3120static ssize_t
3121slot_store(struct md_rdev *rdev, const char *buf, size_t len)
3122{
3123 int slot;
3124 int err;
3125
3126 if (test_bit(Journal, &rdev->flags))
3127 return -EBUSY;
3128 if (strncmp(buf, "none", 4)==0)
3129 slot = -1;
3130 else {
3131 err = kstrtouint(buf, 10, (unsigned int *)&slot);
3132 if (err < 0)
3133 return err;
3134 }
3135 if (rdev->mddev->pers && slot == -1) {
3136 /* Setting 'slot' on an active array requires also
3137 * updating the 'rd%d' link, and communicating
3138 * with the personality with ->hot_*_disk.
3139 * For now we only support removing
3140 * failed/spare devices. This normally happens automatically,
3141 * but not when the metadata is externally managed.
3142 */
3143 if (rdev->raid_disk == -1)
3144 return -EEXIST;
3145 /* personality does all needed checks */
3146 if (rdev->mddev->pers->hot_remove_disk == NULL)
3147 return -EINVAL;
3148 clear_bit(Blocked, &rdev->flags);
3149 remove_and_add_spares(rdev->mddev, rdev);
3150 if (rdev->raid_disk >= 0)
3151 return -EBUSY;
3152 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
3153 md_wakeup_thread(rdev->mddev->thread);
3154 } else if (rdev->mddev->pers) {
3155 /* Activating a spare .. or possibly reactivating
3156 * if we ever get bitmaps working here.
3157 */
3158 int err;
3159
3160 if (rdev->raid_disk != -1)
3161 return -EBUSY;
3162
3163 if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
3164 return -EBUSY;
3165
3166 if (rdev->mddev->pers->hot_add_disk == NULL)
3167 return -EINVAL;
3168
3169 if (slot >= rdev->mddev->raid_disks &&
3170 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
3171 return -ENOSPC;
3172
3173 rdev->raid_disk = slot;
3174 if (test_bit(In_sync, &rdev->flags))
3175 rdev->saved_raid_disk = slot;
3176 else
3177 rdev->saved_raid_disk = -1;
3178 clear_bit(In_sync, &rdev->flags);
3179 clear_bit(Bitmap_sync, &rdev->flags);
3180 err = rdev->mddev->pers->hot_add_disk(rdev->mddev, rdev);
3181 if (err) {
3182 rdev->raid_disk = -1;
3183 return err;
3184 } else
3185 sysfs_notify_dirent_safe(rdev->sysfs_state);
3186 /* failure here is OK */;
3187 sysfs_link_rdev(rdev->mddev, rdev);
3188 /* don't wakeup anyone, leave that to userspace. */
3189 } else {
3190 if (slot >= rdev->mddev->raid_disks &&
3191 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
3192 return -ENOSPC;
3193 rdev->raid_disk = slot;
3194 /* assume it is working */
3195 clear_bit(Faulty, &rdev->flags);
3196 clear_bit(WriteMostly, &rdev->flags);
3197 set_bit(In_sync, &rdev->flags);
3198 sysfs_notify_dirent_safe(rdev->sysfs_state);
3199 }
3200 return len;
3201}
3202
3203static struct rdev_sysfs_entry rdev_slot =
3204__ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
3205
3206static ssize_t
3207offset_show(struct md_rdev *rdev, char *page)
3208{
3209 return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
3210}
3211
3212static ssize_t
3213offset_store(struct md_rdev *rdev, const char *buf, size_t len)
3214{
3215 unsigned long long offset;
3216 if (kstrtoull(buf, 10, &offset) < 0)
3217 return -EINVAL;
3218 if (rdev->mddev->pers && rdev->raid_disk >= 0)
3219 return -EBUSY;
3220 if (rdev->sectors && rdev->mddev->external)
3221 /* Must set offset before size, so overlap checks
3222 * can be sane */
3223 return -EBUSY;
3224 rdev->data_offset = offset;
3225 rdev->new_data_offset = offset;
3226 return len;
3227}
3228
3229static struct rdev_sysfs_entry rdev_offset =
3230__ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
3231
3232static ssize_t new_offset_show(struct md_rdev *rdev, char *page)
3233{
3234 return sprintf(page, "%llu\n",
3235 (unsigned long long)rdev->new_data_offset);
3236}
3237
3238static ssize_t new_offset_store(struct md_rdev *rdev,
3239 const char *buf, size_t len)
3240{
3241 unsigned long long new_offset;
3242 struct mddev *mddev = rdev->mddev;
3243
3244 if (kstrtoull(buf, 10, &new_offset) < 0)
3245 return -EINVAL;
3246
3247 if (mddev->sync_thread ||
3248 test_bit(MD_RECOVERY_RUNNING,&mddev->recovery))
3249 return -EBUSY;
3250 if (new_offset == rdev->data_offset)
3251 /* reset is always permitted */
3252 ;
3253 else if (new_offset > rdev->data_offset) {
3254 /* must not push array size beyond rdev_sectors */
3255 if (new_offset - rdev->data_offset
3256 + mddev->dev_sectors > rdev->sectors)
3257 return -E2BIG;
3258 }
3259 /* Metadata worries about other space details. */
3260
3261 /* decreasing the offset is inconsistent with a backwards
3262 * reshape.
3263 */
3264 if (new_offset < rdev->data_offset &&
3265 mddev->reshape_backwards)
3266 return -EINVAL;
3267 /* Increasing offset is inconsistent with forwards
3268 * reshape. reshape_direction should be set to
3269 * 'backwards' first.
3270 */
3271 if (new_offset > rdev->data_offset &&
3272 !mddev->reshape_backwards)
3273 return -EINVAL;
3274
3275 if (mddev->pers && mddev->persistent &&
3276 !super_types[mddev->major_version]
3277 .allow_new_offset(rdev, new_offset))
3278 return -E2BIG;
3279 rdev->new_data_offset = new_offset;
3280 if (new_offset > rdev->data_offset)
3281 mddev->reshape_backwards = 1;
3282 else if (new_offset < rdev->data_offset)
3283 mddev->reshape_backwards = 0;
3284
3285 return len;
3286}
3287static struct rdev_sysfs_entry rdev_new_offset =
3288__ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store);
3289
3290static ssize_t
3291rdev_size_show(struct md_rdev *rdev, char *page)
3292{
3293 return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
3294}
3295
3296static int md_rdevs_overlap(struct md_rdev *a, struct md_rdev *b)
3297{
3298 /* check if two start/length pairs overlap */
3299 if (a->data_offset + a->sectors <= b->data_offset)
3300 return false;
3301 if (b->data_offset + b->sectors <= a->data_offset)
3302 return false;
3303 return true;
3304}
3305
3306static bool md_rdev_overlaps(struct md_rdev *rdev)
3307{
3308 struct mddev *mddev;
3309 struct md_rdev *rdev2;
3310
3311 spin_lock(&all_mddevs_lock);
3312 list_for_each_entry(mddev, &all_mddevs, all_mddevs) {
3313 if (test_bit(MD_DELETED, &mddev->flags))
3314 continue;
3315 rdev_for_each(rdev2, mddev) {
3316 if (rdev != rdev2 && rdev->bdev == rdev2->bdev &&
3317 md_rdevs_overlap(rdev, rdev2)) {
3318 spin_unlock(&all_mddevs_lock);
3319 return true;
3320 }
3321 }
3322 }
3323 spin_unlock(&all_mddevs_lock);
3324 return false;
3325}
3326
3327static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
3328{
3329 unsigned long long blocks;
3330 sector_t new;
3331
3332 if (kstrtoull(buf, 10, &blocks) < 0)
3333 return -EINVAL;
3334
3335 if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
3336 return -EINVAL; /* sector conversion overflow */
3337
3338 new = blocks * 2;
3339 if (new != blocks * 2)
3340 return -EINVAL; /* unsigned long long to sector_t overflow */
3341
3342 *sectors = new;
3343 return 0;
3344}
3345
3346static ssize_t
3347rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
3348{
3349 struct mddev *my_mddev = rdev->mddev;
3350 sector_t oldsectors = rdev->sectors;
3351 sector_t sectors;
3352
3353 if (test_bit(Journal, &rdev->flags))
3354 return -EBUSY;
3355 if (strict_blocks_to_sectors(buf, §ors) < 0)
3356 return -EINVAL;
3357 if (rdev->data_offset != rdev->new_data_offset)
3358 return -EINVAL; /* too confusing */
3359 if (my_mddev->pers && rdev->raid_disk >= 0) {
3360 if (my_mddev->persistent) {
3361 sectors = super_types[my_mddev->major_version].
3362 rdev_size_change(rdev, sectors);
3363 if (!sectors)
3364 return -EBUSY;
3365 } else if (!sectors)
3366 sectors = bdev_nr_sectors(rdev->bdev) -
3367 rdev->data_offset;
3368 if (!my_mddev->pers->resize)
3369 /* Cannot change size for RAID0 or Linear etc */
3370 return -EINVAL;
3371 }
3372 if (sectors < my_mddev->dev_sectors)
3373 return -EINVAL; /* component must fit device */
3374
3375 rdev->sectors = sectors;
3376
3377 /*
3378 * Check that all other rdevs with the same bdev do not overlap. This
3379 * check does not provide a hard guarantee, it just helps avoid
3380 * dangerous mistakes.
3381 */
3382 if (sectors > oldsectors && my_mddev->external &&
3383 md_rdev_overlaps(rdev)) {
3384 /*
3385 * Someone else could have slipped in a size change here, but
3386 * doing so is just silly. We put oldsectors back because we
3387 * know it is safe, and trust userspace not to race with itself.
3388 */
3389 rdev->sectors = oldsectors;
3390 return -EBUSY;
3391 }
3392 return len;
3393}
3394
3395static struct rdev_sysfs_entry rdev_size =
3396__ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
3397
3398static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
3399{
3400 unsigned long long recovery_start = rdev->recovery_offset;
3401
3402 if (test_bit(In_sync, &rdev->flags) ||
3403 recovery_start == MaxSector)
3404 return sprintf(page, "none\n");
3405
3406 return sprintf(page, "%llu\n", recovery_start);
3407}
3408
3409static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
3410{
3411 unsigned long long recovery_start;
3412
3413 if (cmd_match(buf, "none"))
3414 recovery_start = MaxSector;
3415 else if (kstrtoull(buf, 10, &recovery_start))
3416 return -EINVAL;
3417
3418 if (rdev->mddev->pers &&
3419 rdev->raid_disk >= 0)
3420 return -EBUSY;
3421
3422 rdev->recovery_offset = recovery_start;
3423 if (recovery_start == MaxSector)
3424 set_bit(In_sync, &rdev->flags);
3425 else
3426 clear_bit(In_sync, &rdev->flags);
3427 return len;
3428}
3429
3430static struct rdev_sysfs_entry rdev_recovery_start =
3431__ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);
3432
3433/* sysfs access to bad-blocks list.
3434 * We present two files.
3435 * 'bad-blocks' lists sector numbers and lengths of ranges that
3436 * are recorded as bad. The list is truncated to fit within
3437 * the one-page limit of sysfs.
3438 * Writing "sector length" to this file adds an acknowledged
3439 * bad block list.
3440 * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
3441 * been acknowledged. Writing to this file adds bad blocks
3442 * without acknowledging them. This is largely for testing.
3443 */
3444static ssize_t bb_show(struct md_rdev *rdev, char *page)
3445{
3446 return badblocks_show(&rdev->badblocks, page, 0);
3447}
3448static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
3449{
3450 int rv = badblocks_store(&rdev->badblocks, page, len, 0);
3451 /* Maybe that ack was all we needed */
3452 if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags))
3453 wake_up(&rdev->blocked_wait);
3454 return rv;
3455}
3456static struct rdev_sysfs_entry rdev_bad_blocks =
3457__ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);
3458
3459static ssize_t ubb_show(struct md_rdev *rdev, char *page)
3460{
3461 return badblocks_show(&rdev->badblocks, page, 1);
3462}
3463static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
3464{
3465 return badblocks_store(&rdev->badblocks, page, len, 1);
3466}
3467static struct rdev_sysfs_entry rdev_unack_bad_blocks =
3468__ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store);
3469
3470static ssize_t
3471ppl_sector_show(struct md_rdev *rdev, char *page)
3472{
3473 return sprintf(page, "%llu\n", (unsigned long long)rdev->ppl.sector);
3474}
3475
3476static ssize_t
3477ppl_sector_store(struct md_rdev *rdev, const char *buf, size_t len)
3478{
3479 unsigned long long sector;
3480
3481 if (kstrtoull(buf, 10, §or) < 0)
3482 return -EINVAL;
3483 if (sector != (sector_t)sector)
3484 return -EINVAL;
3485
3486 if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) &&
3487 rdev->raid_disk >= 0)
3488 return -EBUSY;
3489
3490 if (rdev->mddev->persistent) {
3491 if (rdev->mddev->major_version == 0)
3492 return -EINVAL;
3493 if ((sector > rdev->sb_start &&
3494 sector - rdev->sb_start > S16_MAX) ||
3495 (sector < rdev->sb_start &&
3496 rdev->sb_start - sector > -S16_MIN))
3497 return -EINVAL;
3498 rdev->ppl.offset = sector - rdev->sb_start;
3499 } else if (!rdev->mddev->external) {
3500 return -EBUSY;
3501 }
3502 rdev->ppl.sector = sector;
3503 return len;
3504}
3505
3506static struct rdev_sysfs_entry rdev_ppl_sector =
3507__ATTR(ppl_sector, S_IRUGO|S_IWUSR, ppl_sector_show, ppl_sector_store);
3508
3509static ssize_t
3510ppl_size_show(struct md_rdev *rdev, char *page)
3511{
3512 return sprintf(page, "%u\n", rdev->ppl.size);
3513}
3514
3515static ssize_t
3516ppl_size_store(struct md_rdev *rdev, const char *buf, size_t len)
3517{
3518 unsigned int size;
3519
3520 if (kstrtouint(buf, 10, &size) < 0)
3521 return -EINVAL;
3522
3523 if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) &&
3524 rdev->raid_disk >= 0)
3525 return -EBUSY;
3526
3527 if (rdev->mddev->persistent) {
3528 if (rdev->mddev->major_version == 0)
3529 return -EINVAL;
3530 if (size > U16_MAX)
3531 return -EINVAL;
3532 } else if (!rdev->mddev->external) {
3533 return -EBUSY;
3534 }
3535 rdev->ppl.size = size;
3536 return len;
3537}
3538
3539static struct rdev_sysfs_entry rdev_ppl_size =
3540__ATTR(ppl_size, S_IRUGO|S_IWUSR, ppl_size_show, ppl_size_store);
3541
3542static struct attribute *rdev_default_attrs[] = {
3543 &rdev_state.attr,
3544 &rdev_errors.attr,
3545 &rdev_slot.attr,
3546 &rdev_offset.attr,
3547 &rdev_new_offset.attr,
3548 &rdev_size.attr,
3549 &rdev_recovery_start.attr,
3550 &rdev_bad_blocks.attr,
3551 &rdev_unack_bad_blocks.attr,
3552 &rdev_ppl_sector.attr,
3553 &rdev_ppl_size.attr,
3554 NULL,
3555};
3556ATTRIBUTE_GROUPS(rdev_default);
3557static ssize_t
3558rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
3559{
3560 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
3561 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
3562
3563 if (!entry->show)
3564 return -EIO;
3565 if (!rdev->mddev)
3566 return -ENODEV;
3567 return entry->show(rdev, page);
3568}
3569
3570static ssize_t
3571rdev_attr_store(struct kobject *kobj, struct attribute *attr,
3572 const char *page, size_t length)
3573{
3574 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
3575 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
3576 ssize_t rv;
3577 struct mddev *mddev = rdev->mddev;
3578
3579 if (!entry->store)
3580 return -EIO;
3581 if (!capable(CAP_SYS_ADMIN))
3582 return -EACCES;
3583 rv = mddev ? mddev_lock(mddev) : -ENODEV;
3584 if (!rv) {
3585 if (rdev->mddev == NULL)
3586 rv = -ENODEV;
3587 else
3588 rv = entry->store(rdev, page, length);
3589 mddev_unlock(mddev);
3590 }
3591 return rv;
3592}
3593
3594static void rdev_free(struct kobject *ko)
3595{
3596 struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
3597 kfree(rdev);
3598}
3599static const struct sysfs_ops rdev_sysfs_ops = {
3600 .show = rdev_attr_show,
3601 .store = rdev_attr_store,
3602};
3603static struct kobj_type rdev_ktype = {
3604 .release = rdev_free,
3605 .sysfs_ops = &rdev_sysfs_ops,
3606 .default_groups = rdev_default_groups,
3607};
3608
3609int md_rdev_init(struct md_rdev *rdev)
3610{
3611 rdev->desc_nr = -1;
3612 rdev->saved_raid_disk = -1;
3613 rdev->raid_disk = -1;
3614 rdev->flags = 0;
3615 rdev->data_offset = 0;
3616 rdev->new_data_offset = 0;
3617 rdev->sb_events = 0;
3618 rdev->last_read_error = 0;
3619 rdev->sb_loaded = 0;
3620 rdev->bb_page = NULL;
3621 atomic_set(&rdev->nr_pending, 0);
3622 atomic_set(&rdev->read_errors, 0);
3623 atomic_set(&rdev->corrected_errors, 0);
3624
3625 INIT_LIST_HEAD(&rdev->same_set);
3626 init_waitqueue_head(&rdev->blocked_wait);
3627
3628 /* Add space to store bad block list.
3629 * This reserves the space even on arrays where it cannot
3630 * be used - I wonder if that matters
3631 */
3632 return badblocks_init(&rdev->badblocks, 0);
3633}
3634EXPORT_SYMBOL_GPL(md_rdev_init);
3635/*
3636 * Import a device. If 'super_format' >= 0, then sanity check the superblock
3637 *
3638 * mark the device faulty if:
3639 *
3640 * - the device is nonexistent (zero size)
3641 * - the device has no valid superblock
3642 *
3643 * a faulty rdev _never_ has rdev->sb set.
3644 */
3645static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
3646{
3647 static struct md_rdev claim_rdev; /* just for claiming the bdev */
3648 struct md_rdev *rdev;
3649 sector_t size;
3650 int err;
3651
3652 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
3653 if (!rdev)
3654 return ERR_PTR(-ENOMEM);
3655
3656 err = md_rdev_init(rdev);
3657 if (err)
3658 goto out_free_rdev;
3659 err = alloc_disk_sb(rdev);
3660 if (err)
3661 goto out_clear_rdev;
3662
3663 rdev->bdev = blkdev_get_by_dev(newdev,
3664 FMODE_READ | FMODE_WRITE | FMODE_EXCL,
3665 super_format == -2 ? &claim_rdev : rdev);
3666 if (IS_ERR(rdev->bdev)) {
3667 pr_warn("md: could not open device unknown-block(%u,%u).\n",
3668 MAJOR(newdev), MINOR(newdev));
3669 err = PTR_ERR(rdev->bdev);
3670 goto out_clear_rdev;
3671 }
3672
3673 kobject_init(&rdev->kobj, &rdev_ktype);
3674
3675 size = bdev_nr_bytes(rdev->bdev) >> BLOCK_SIZE_BITS;
3676 if (!size) {
3677 pr_warn("md: %pg has zero or unknown size, marking faulty!\n",
3678 rdev->bdev);
3679 err = -EINVAL;
3680 goto out_blkdev_put;
3681 }
3682
3683 if (super_format >= 0) {
3684 err = super_types[super_format].
3685 load_super(rdev, NULL, super_minor);
3686 if (err == -EINVAL) {
3687 pr_warn("md: %pg does not have a valid v%d.%d superblock, not importing!\n",
3688 rdev->bdev,
3689 super_format, super_minor);
3690 goto out_blkdev_put;
3691 }
3692 if (err < 0) {
3693 pr_warn("md: could not read %pg's sb, not importing!\n",
3694 rdev->bdev);
3695 goto out_blkdev_put;
3696 }
3697 }
3698
3699 return rdev;
3700
3701out_blkdev_put:
3702 blkdev_put(rdev->bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
3703out_clear_rdev:
3704 md_rdev_clear(rdev);
3705out_free_rdev:
3706 kfree(rdev);
3707 return ERR_PTR(err);
3708}
3709
3710/*
3711 * Check a full RAID array for plausibility
3712 */
3713
3714static int analyze_sbs(struct mddev *mddev)
3715{
3716 int i;
3717 struct md_rdev *rdev, *freshest, *tmp;
3718
3719 freshest = NULL;
3720 rdev_for_each_safe(rdev, tmp, mddev)
3721 switch (super_types[mddev->major_version].
3722 load_super(rdev, freshest, mddev->minor_version)) {
3723 case 1:
3724 freshest = rdev;
3725 break;
3726 case 0:
3727 break;
3728 default:
3729 pr_warn("md: fatal superblock inconsistency in %pg -- removing from array\n",
3730 rdev->bdev);
3731 md_kick_rdev_from_array(rdev);
3732 }
3733
3734 /* Cannot find a valid fresh disk */
3735 if (!freshest) {
3736 pr_warn("md: cannot find a valid disk\n");
3737 return -EINVAL;
3738 }
3739
3740 super_types[mddev->major_version].
3741 validate_super(mddev, freshest);
3742
3743 i = 0;
3744 rdev_for_each_safe(rdev, tmp, mddev) {
3745 if (mddev->max_disks &&
3746 (rdev->desc_nr >= mddev->max_disks ||
3747 i > mddev->max_disks)) {
3748 pr_warn("md: %s: %pg: only %d devices permitted\n",
3749 mdname(mddev), rdev->bdev,
3750 mddev->max_disks);
3751 md_kick_rdev_from_array(rdev);
3752 continue;
3753 }
3754 if (rdev != freshest) {
3755 if (super_types[mddev->major_version].
3756 validate_super(mddev, rdev)) {
3757 pr_warn("md: kicking non-fresh %pg from array!\n",
3758 rdev->bdev);
3759 md_kick_rdev_from_array(rdev);
3760 continue;
3761 }
3762 }
3763 if (mddev->level == LEVEL_MULTIPATH) {
3764 rdev->desc_nr = i++;
3765 rdev->raid_disk = rdev->desc_nr;
3766 set_bit(In_sync, &rdev->flags);
3767 } else if (rdev->raid_disk >=
3768 (mddev->raid_disks - min(0, mddev->delta_disks)) &&
3769 !test_bit(Journal, &rdev->flags)) {
3770 rdev->raid_disk = -1;
3771 clear_bit(In_sync, &rdev->flags);
3772 }
3773 }
3774
3775 return 0;
3776}
3777
3778/* Read a fixed-point number.
3779 * Numbers in sysfs attributes should be in "standard" units where
3780 * possible, so time should be in seconds.
3781 * However we internally use a a much smaller unit such as
3782 * milliseconds or jiffies.
3783 * This function takes a decimal number with a possible fractional
3784 * component, and produces an integer which is the result of
3785 * multiplying that number by 10^'scale'.
3786 * all without any floating-point arithmetic.
3787 */
3788int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
3789{
3790 unsigned long result = 0;
3791 long decimals = -1;
3792 while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
3793 if (*cp == '.')
3794 decimals = 0;
3795 else if (decimals < scale) {
3796 unsigned int value;
3797 value = *cp - '0';
3798 result = result * 10 + value;
3799 if (decimals >= 0)
3800 decimals++;
3801 }
3802 cp++;
3803 }
3804 if (*cp == '\n')
3805 cp++;
3806 if (*cp)
3807 return -EINVAL;
3808 if (decimals < 0)
3809 decimals = 0;
3810 *res = result * int_pow(10, scale - decimals);
3811 return 0;
3812}
3813
3814static ssize_t
3815safe_delay_show(struct mddev *mddev, char *page)
3816{
3817 int msec = (mddev->safemode_delay*1000)/HZ;
3818 return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
3819}
3820static ssize_t
3821safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
3822{
3823 unsigned long msec;
3824
3825 if (mddev_is_clustered(mddev)) {
3826 pr_warn("md: Safemode is disabled for clustered mode\n");
3827 return -EINVAL;
3828 }
3829
3830 if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
3831 return -EINVAL;
3832 if (msec == 0)
3833 mddev->safemode_delay = 0;
3834 else {
3835 unsigned long old_delay = mddev->safemode_delay;
3836 unsigned long new_delay = (msec*HZ)/1000;
3837
3838 if (new_delay == 0)
3839 new_delay = 1;
3840 mddev->safemode_delay = new_delay;
3841 if (new_delay < old_delay || old_delay == 0)
3842 mod_timer(&mddev->safemode_timer, jiffies+1);
3843 }
3844 return len;
3845}
3846static struct md_sysfs_entry md_safe_delay =
3847__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
3848
3849static ssize_t
3850level_show(struct mddev *mddev, char *page)
3851{
3852 struct md_personality *p;
3853 int ret;
3854 spin_lock(&mddev->lock);
3855 p = mddev->pers;
3856 if (p)
3857 ret = sprintf(page, "%s\n", p->name);
3858 else if (mddev->clevel[0])
3859 ret = sprintf(page, "%s\n", mddev->clevel);
3860 else if (mddev->level != LEVEL_NONE)
3861 ret = sprintf(page, "%d\n", mddev->level);
3862 else
3863 ret = 0;
3864 spin_unlock(&mddev->lock);
3865 return ret;
3866}
3867
3868static ssize_t
3869level_store(struct mddev *mddev, const char *buf, size_t len)
3870{
3871 char clevel[16];
3872 ssize_t rv;
3873 size_t slen = len;
3874 struct md_personality *pers, *oldpers;
3875 long level;
3876 void *priv, *oldpriv;
3877 struct md_rdev *rdev;
3878
3879 if (slen == 0 || slen >= sizeof(clevel))
3880 return -EINVAL;
3881
3882 rv = mddev_lock(mddev);
3883 if (rv)
3884 return rv;
3885
3886 if (mddev->pers == NULL) {
3887 strncpy(mddev->clevel, buf, slen);
3888 if (mddev->clevel[slen-1] == '\n')
3889 slen--;
3890 mddev->clevel[slen] = 0;
3891 mddev->level = LEVEL_NONE;
3892 rv = len;
3893 goto out_unlock;
3894 }
3895 rv = -EROFS;
3896 if (!md_is_rdwr(mddev))
3897 goto out_unlock;
3898
3899 /* request to change the personality. Need to ensure:
3900 * - array is not engaged in resync/recovery/reshape
3901 * - old personality can be suspended
3902 * - new personality will access other array.
3903 */
3904
3905 rv = -EBUSY;
3906 if (mddev->sync_thread ||
3907 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3908 mddev->reshape_position != MaxSector ||
3909 mddev->sysfs_active)
3910 goto out_unlock;
3911
3912 rv = -EINVAL;
3913 if (!mddev->pers->quiesce) {
3914 pr_warn("md: %s: %s does not support online personality change\n",
3915 mdname(mddev), mddev->pers->name);
3916 goto out_unlock;
3917 }
3918
3919 /* Now find the new personality */
3920 strncpy(clevel, buf, slen);
3921 if (clevel[slen-1] == '\n')
3922 slen--;
3923 clevel[slen] = 0;
3924 if (kstrtol(clevel, 10, &level))
3925 level = LEVEL_NONE;
3926
3927 if (request_module("md-%s", clevel) != 0)
3928 request_module("md-level-%s", clevel);
3929 spin_lock(&pers_lock);
3930 pers = find_pers(level, clevel);
3931 if (!pers || !try_module_get(pers->owner)) {
3932 spin_unlock(&pers_lock);
3933 pr_warn("md: personality %s not loaded\n", clevel);
3934 rv = -EINVAL;
3935 goto out_unlock;
3936 }
3937 spin_unlock(&pers_lock);
3938
3939 if (pers == mddev->pers) {
3940 /* Nothing to do! */
3941 module_put(pers->owner);
3942 rv = len;
3943 goto out_unlock;
3944 }
3945 if (!pers->takeover) {
3946 module_put(pers->owner);
3947 pr_warn("md: %s: %s does not support personality takeover\n",
3948 mdname(mddev), clevel);
3949 rv = -EINVAL;
3950 goto out_unlock;
3951 }
3952
3953 rdev_for_each(rdev, mddev)
3954 rdev->new_raid_disk = rdev->raid_disk;
3955
3956 /* ->takeover must set new_* and/or delta_disks
3957 * if it succeeds, and may set them when it fails.
3958 */
3959 priv = pers->takeover(mddev);
3960 if (IS_ERR(priv)) {
3961 mddev->new_level = mddev->level;
3962 mddev->new_layout = mddev->layout;
3963 mddev->new_chunk_sectors = mddev->chunk_sectors;
3964 mddev->raid_disks -= mddev->delta_disks;
3965 mddev->delta_disks = 0;
3966 mddev->reshape_backwards = 0;
3967 module_put(pers->owner);
3968 pr_warn("md: %s: %s would not accept array\n",
3969 mdname(mddev), clevel);
3970 rv = PTR_ERR(priv);
3971 goto out_unlock;
3972 }
3973
3974 /* Looks like we have a winner */
3975 mddev_suspend(mddev);
3976 mddev_detach(mddev);
3977
3978 spin_lock(&mddev->lock);
3979 oldpers = mddev->pers;
3980 oldpriv = mddev->private;
3981 mddev->pers = pers;
3982 mddev->private = priv;
3983 strscpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3984 mddev->level = mddev->new_level;
3985 mddev->layout = mddev->new_layout;
3986 mddev->chunk_sectors = mddev->new_chunk_sectors;
3987 mddev->delta_disks = 0;
3988 mddev->reshape_backwards = 0;
3989 mddev->degraded = 0;
3990 spin_unlock(&mddev->lock);
3991
3992 if (oldpers->sync_request == NULL &&
3993 mddev->external) {
3994 /* We are converting from a no-redundancy array
3995 * to a redundancy array and metadata is managed
3996 * externally so we need to be sure that writes
3997 * won't block due to a need to transition
3998 * clean->dirty
3999 * until external management is started.
4000 */
4001 mddev->in_sync = 0;
4002 mddev->safemode_delay = 0;
4003 mddev->safemode = 0;
4004 }
4005
4006 oldpers->free(mddev, oldpriv);
4007
4008 if (oldpers->sync_request == NULL &&
4009 pers->sync_request != NULL) {
4010 /* need to add the md_redundancy_group */
4011 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
4012 pr_warn("md: cannot register extra attributes for %s\n",
4013 mdname(mddev));
4014 mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
4015 mddev->sysfs_completed = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_completed");
4016 mddev->sysfs_degraded = sysfs_get_dirent_safe(mddev->kobj.sd, "degraded");
4017 }
4018 if (oldpers->sync_request != NULL &&
4019 pers->sync_request == NULL) {
4020 /* need to remove the md_redundancy_group */
4021 if (mddev->to_remove == NULL)
4022 mddev->to_remove = &md_redundancy_group;
4023 }
4024
4025 module_put(oldpers->owner);
4026
4027 rdev_for_each(rdev, mddev) {
4028 if (rdev->raid_disk < 0)
4029 continue;
4030 if (rdev->new_raid_disk >= mddev->raid_disks)
4031 rdev->new_raid_disk = -1;
4032 if (rdev->new_raid_disk == rdev->raid_disk)
4033 continue;
4034 sysfs_unlink_rdev(mddev, rdev);
4035 }
4036 rdev_for_each(rdev, mddev) {
4037 if (rdev->raid_disk < 0)
4038 continue;
4039 if (rdev->new_raid_disk == rdev->raid_disk)
4040 continue;
4041 rdev->raid_disk = rdev->new_raid_disk;
4042 if (rdev->raid_disk < 0)
4043 clear_bit(In_sync, &rdev->flags);
4044 else {
4045 if (sysfs_link_rdev(mddev, rdev))
4046 pr_warn("md: cannot register rd%d for %s after level change\n",
4047 rdev->raid_disk, mdname(mddev));
4048 }
4049 }
4050
4051 if (pers->sync_request == NULL) {
4052 /* this is now an array without redundancy, so
4053 * it must always be in_sync
4054 */
4055 mddev->in_sync = 1;
4056 del_timer_sync(&mddev->safemode_timer);
4057 }
4058 blk_set_stacking_limits(&mddev->queue->limits);
4059 pers->run(mddev);
4060 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
4061 mddev_resume(mddev);
4062 if (!mddev->thread)
4063 md_update_sb(mddev, 1);
4064 sysfs_notify_dirent_safe(mddev->sysfs_level);
4065 md_new_event();
4066 rv = len;
4067out_unlock:
4068 mddev_unlock(mddev);
4069 return rv;
4070}
4071
4072static struct md_sysfs_entry md_level =
4073__ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
4074
4075static ssize_t
4076layout_show(struct mddev *mddev, char *page)
4077{
4078 /* just a number, not meaningful for all levels */
4079 if (mddev->reshape_position != MaxSector &&
4080 mddev->layout != mddev->new_layout)
4081 return sprintf(page, "%d (%d)\n",
4082 mddev->new_layout, mddev->layout);
4083 return sprintf(page, "%d\n", mddev->layout);
4084}
4085
4086static ssize_t
4087layout_store(struct mddev *mddev, const char *buf, size_t len)
4088{
4089 unsigned int n;
4090 int err;
4091
4092 err = kstrtouint(buf, 10, &n);
4093 if (err < 0)
4094 return err;
4095 err = mddev_lock(mddev);
4096 if (err)
4097 return err;
4098
4099 if (mddev->pers) {
4100 if (mddev->pers->check_reshape == NULL)
4101 err = -EBUSY;
4102 else if (!md_is_rdwr(mddev))
4103 err = -EROFS;
4104 else {
4105 mddev->new_layout = n;
4106 err = mddev->pers->check_reshape(mddev);
4107 if (err)
4108 mddev->new_layout = mddev->layout;
4109 }
4110 } else {
4111 mddev->new_layout = n;
4112 if (mddev->reshape_position == MaxSector)
4113 mddev->layout = n;
4114 }
4115 mddev_unlock(mddev);
4116 return err ?: len;
4117}
4118static struct md_sysfs_entry md_layout =
4119__ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
4120
4121static ssize_t
4122raid_disks_show(struct mddev *mddev, char *page)
4123{
4124 if (mddev->raid_disks == 0)
4125 return 0;
4126 if (mddev->reshape_position != MaxSector &&
4127 mddev->delta_disks != 0)
4128 return sprintf(page, "%d (%d)\n", mddev->raid_disks,
4129 mddev->raid_disks - mddev->delta_disks);
4130 return sprintf(page, "%d\n", mddev->raid_disks);
4131}
4132
4133static int update_raid_disks(struct mddev *mddev, int raid_disks);
4134
4135static ssize_t
4136raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
4137{
4138 unsigned int n;
4139 int err;
4140
4141 err = kstrtouint(buf, 10, &n);
4142 if (err < 0)
4143 return err;
4144
4145 err = mddev_lock(mddev);
4146 if (err)
4147 return err;
4148 if (mddev->pers)
4149 err = update_raid_disks(mddev, n);
4150 else if (mddev->reshape_position != MaxSector) {
4151 struct md_rdev *rdev;
4152 int olddisks = mddev->raid_disks - mddev->delta_disks;
4153
4154 err = -EINVAL;
4155 rdev_for_each(rdev, mddev) {
4156 if (olddisks < n &&
4157 rdev->data_offset < rdev->new_data_offset)
4158 goto out_unlock;
4159 if (olddisks > n &&
4160 rdev->data_offset > rdev->new_data_offset)
4161 goto out_unlock;
4162 }
4163 err = 0;
4164 mddev->delta_disks = n - olddisks;
4165 mddev->raid_disks = n;
4166 mddev->reshape_backwards = (mddev->delta_disks < 0);
4167 } else
4168 mddev->raid_disks = n;
4169out_unlock:
4170 mddev_unlock(mddev);
4171 return err ? err : len;
4172}
4173static struct md_sysfs_entry md_raid_disks =
4174__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
4175
4176static ssize_t
4177uuid_show(struct mddev *mddev, char *page)
4178{
4179 return sprintf(page, "%pU\n", mddev->uuid);
4180}
4181static struct md_sysfs_entry md_uuid =
4182__ATTR(uuid, S_IRUGO, uuid_show, NULL);
4183
4184static ssize_t
4185chunk_size_show(struct mddev *mddev, char *page)
4186{
4187 if (mddev->reshape_position != MaxSector &&
4188 mddev->chunk_sectors != mddev->new_chunk_sectors)
4189 return sprintf(page, "%d (%d)\n",
4190 mddev->new_chunk_sectors << 9,
4191 mddev->chunk_sectors << 9);
4192 return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
4193}
4194
4195static ssize_t
4196chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
4197{
4198 unsigned long n;
4199 int err;
4200
4201 err = kstrtoul(buf, 10, &n);
4202 if (err < 0)
4203 return err;
4204
4205 err = mddev_lock(mddev);
4206 if (err)
4207 return err;
4208 if (mddev->pers) {
4209 if (mddev->pers->check_reshape == NULL)
4210 err = -EBUSY;
4211 else if (!md_is_rdwr(mddev))
4212 err = -EROFS;
4213 else {
4214 mddev->new_chunk_sectors = n >> 9;
4215 err = mddev->pers->check_reshape(mddev);
4216 if (err)
4217 mddev->new_chunk_sectors = mddev->chunk_sectors;
4218 }
4219 } else {
4220 mddev->new_chunk_sectors = n >> 9;
4221 if (mddev->reshape_position == MaxSector)
4222 mddev->chunk_sectors = n >> 9;
4223 }
4224 mddev_unlock(mddev);
4225 return err ?: len;
4226}
4227static struct md_sysfs_entry md_chunk_size =
4228__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
4229
4230static ssize_t
4231resync_start_show(struct mddev *mddev, char *page)
4232{
4233 if (mddev->recovery_cp == MaxSector)
4234 return sprintf(page, "none\n");
4235 return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
4236}
4237
4238static ssize_t
4239resync_start_store(struct mddev *mddev, const char *buf, size_t len)
4240{
4241 unsigned long long n;
4242 int err;
4243
4244 if (cmd_match(buf, "none"))
4245 n = MaxSector;
4246 else {
4247 err = kstrtoull(buf, 10, &n);
4248 if (err < 0)
4249 return err;
4250 if (n != (sector_t)n)
4251 return -EINVAL;
4252 }
4253
4254 err = mddev_lock(mddev);
4255 if (err)
4256 return err;
4257 if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
4258 err = -EBUSY;
4259
4260 if (!err) {
4261 mddev->recovery_cp = n;
4262 if (mddev->pers)
4263 set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
4264 }
4265 mddev_unlock(mddev);
4266 return err ?: len;
4267}
4268static struct md_sysfs_entry md_resync_start =
4269__ATTR_PREALLOC(resync_start, S_IRUGO|S_IWUSR,
4270 resync_start_show, resync_start_store);
4271
4272/*
4273 * The array state can be:
4274 *
4275 * clear
4276 * No devices, no size, no level
4277 * Equivalent to STOP_ARRAY ioctl
4278 * inactive
4279 * May have some settings, but array is not active
4280 * all IO results in error
4281 * When written, doesn't tear down array, but just stops it
4282 * suspended (not supported yet)
4283 * All IO requests will block. The array can be reconfigured.
4284 * Writing this, if accepted, will block until array is quiescent
4285 * readonly
4286 * no resync can happen. no superblocks get written.
4287 * write requests fail
4288 * read-auto
4289 * like readonly, but behaves like 'clean' on a write request.
4290 *
4291 * clean - no pending writes, but otherwise active.
4292 * When written to inactive array, starts without resync
4293 * If a write request arrives then
4294 * if metadata is known, mark 'dirty' and switch to 'active'.
4295 * if not known, block and switch to write-pending
4296 * If written to an active array that has pending writes, then fails.
4297 * active
4298 * fully active: IO and resync can be happening.
4299 * When written to inactive array, starts with resync
4300 *
4301 * write-pending
4302 * clean, but writes are blocked waiting for 'active' to be written.
4303 *
4304 * active-idle
4305 * like active, but no writes have been seen for a while (100msec).
4306 *
4307 * broken
4308* Array is failed. It's useful because mounted-arrays aren't stopped
4309* when array is failed, so this state will at least alert the user that
4310* something is wrong.
4311 */
4312enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
4313 write_pending, active_idle, broken, bad_word};
4314static char *array_states[] = {
4315 "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
4316 "write-pending", "active-idle", "broken", NULL };
4317
4318static int match_word(const char *word, char **list)
4319{
4320 int n;
4321 for (n=0; list[n]; n++)
4322 if (cmd_match(word, list[n]))
4323 break;
4324 return n;
4325}
4326
4327static ssize_t
4328array_state_show(struct mddev *mddev, char *page)
4329{
4330 enum array_state st = inactive;
4331
4332 if (mddev->pers && !test_bit(MD_NOT_READY, &mddev->flags)) {
4333 switch(mddev->ro) {
4334 case MD_RDONLY:
4335 st = readonly;
4336 break;
4337 case MD_AUTO_READ:
4338 st = read_auto;
4339 break;
4340 case MD_RDWR:
4341 spin_lock(&mddev->lock);
4342 if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))
4343 st = write_pending;
4344 else if (mddev->in_sync)
4345 st = clean;
4346 else if (mddev->safemode)
4347 st = active_idle;
4348 else
4349 st = active;
4350 spin_unlock(&mddev->lock);
4351 }
4352
4353 if (test_bit(MD_BROKEN, &mddev->flags) && st == clean)
4354 st = broken;
4355 } else {
4356 if (list_empty(&mddev->disks) &&
4357 mddev->raid_disks == 0 &&
4358 mddev->dev_sectors == 0)
4359 st = clear;
4360 else
4361 st = inactive;
4362 }
4363 return sprintf(page, "%s\n", array_states[st]);
4364}
4365
4366static int do_md_stop(struct mddev *mddev, int ro, struct block_device *bdev);
4367static int md_set_readonly(struct mddev *mddev, struct block_device *bdev);
4368static int restart_array(struct mddev *mddev);
4369
4370static ssize_t
4371array_state_store(struct mddev *mddev, const char *buf, size_t len)
4372{
4373 int err = 0;
4374 enum array_state st = match_word(buf, array_states);
4375
4376 if (mddev->pers && (st == active || st == clean) &&
4377 mddev->ro != MD_RDONLY) {
4378 /* don't take reconfig_mutex when toggling between
4379 * clean and active
4380 */
4381 spin_lock(&mddev->lock);
4382 if (st == active) {
4383 restart_array(mddev);
4384 clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
4385 md_wakeup_thread(mddev->thread);
4386 wake_up(&mddev->sb_wait);
4387 } else /* st == clean */ {
4388 restart_array(mddev);
4389 if (!set_in_sync(mddev))
4390 err = -EBUSY;
4391 }
4392 if (!err)
4393 sysfs_notify_dirent_safe(mddev->sysfs_state);
4394 spin_unlock(&mddev->lock);
4395 return err ?: len;
4396 }
4397 err = mddev_lock(mddev);
4398 if (err)
4399 return err;
4400 err = -EINVAL;
4401 switch(st) {
4402 case bad_word:
4403 break;
4404 case clear:
4405 /* stopping an active array */
4406 err = do_md_stop(mddev, 0, NULL);
4407 break;
4408 case inactive:
4409 /* stopping an active array */
4410 if (mddev->pers)
4411 err = do_md_stop(mddev, 2, NULL);
4412 else
4413 err = 0; /* already inactive */
4414 break;
4415 case suspended:
4416 break; /* not supported yet */
4417 case readonly:
4418 if (mddev->pers)
4419 err = md_set_readonly(mddev, NULL);
4420 else {
4421 mddev->ro = MD_RDONLY;
4422 set_disk_ro(mddev->gendisk, 1);
4423 err = do_md_run(mddev);
4424 }
4425 break;
4426 case read_auto:
4427 if (mddev->pers) {
4428 if (md_is_rdwr(mddev))
4429 err = md_set_readonly(mddev, NULL);
4430 else if (mddev->ro == MD_RDONLY)
4431 err = restart_array(mddev);
4432 if (err == 0) {
4433 mddev->ro = MD_AUTO_READ;
4434 set_disk_ro(mddev->gendisk, 0);
4435 }
4436 } else {
4437 mddev->ro = MD_AUTO_READ;
4438 err = do_md_run(mddev);
4439 }
4440 break;
4441 case clean:
4442 if (mddev->pers) {
4443 err = restart_array(mddev);
4444 if (err)
4445 break;
4446 spin_lock(&mddev->lock);
4447 if (!set_in_sync(mddev))
4448 err = -EBUSY;
4449 spin_unlock(&mddev->lock);
4450 } else
4451 err = -EINVAL;
4452 break;
4453 case active:
4454 if (mddev->pers) {
4455 err = restart_array(mddev);
4456 if (err)
4457 break;
4458 clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
4459 wake_up(&mddev->sb_wait);
4460 err = 0;
4461 } else {
4462 mddev->ro = MD_RDWR;
4463 set_disk_ro(mddev->gendisk, 0);
4464 err = do_md_run(mddev);
4465 }
4466 break;
4467 case write_pending:
4468 case active_idle:
4469 case broken:
4470 /* these cannot be set */
4471 break;
4472 }
4473
4474 if (!err) {
4475 if (mddev->hold_active == UNTIL_IOCTL)
4476 mddev->hold_active = 0;
4477 sysfs_notify_dirent_safe(mddev->sysfs_state);
4478 }
4479 mddev_unlock(mddev);
4480 return err ?: len;
4481}
4482static struct md_sysfs_entry md_array_state =
4483__ATTR_PREALLOC(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
4484
4485static ssize_t
4486max_corrected_read_errors_show(struct mddev *mddev, char *page) {
4487 return sprintf(page, "%d\n",
4488 atomic_read(&mddev->max_corr_read_errors));
4489}
4490
4491static ssize_t
4492max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
4493{
4494 unsigned int n;
4495 int rv;
4496
4497 rv = kstrtouint(buf, 10, &n);
4498 if (rv < 0)
4499 return rv;
4500 atomic_set(&mddev->max_corr_read_errors, n);
4501 return len;
4502}
4503
4504static struct md_sysfs_entry max_corr_read_errors =
4505__ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
4506 max_corrected_read_errors_store);
4507
4508static ssize_t
4509null_show(struct mddev *mddev, char *page)
4510{
4511 return -EINVAL;
4512}
4513
4514/* need to ensure rdev_delayed_delete() has completed */
4515static void flush_rdev_wq(struct mddev *mddev)
4516{
4517 struct md_rdev *rdev;
4518
4519 rcu_read_lock();
4520 rdev_for_each_rcu(rdev, mddev)
4521 if (work_pending(&rdev->del_work)) {
4522 flush_workqueue(md_rdev_misc_wq);
4523 break;
4524 }
4525 rcu_read_unlock();
4526}
4527
4528static ssize_t
4529new_dev_store(struct mddev *mddev, const char *buf, size_t len)
4530{
4531 /* buf must be %d:%d\n? giving major and minor numbers */
4532 /* The new device is added to the array.
4533 * If the array has a persistent superblock, we read the
4534 * superblock to initialise info and check validity.
4535 * Otherwise, only checking done is that in bind_rdev_to_array,
4536 * which mainly checks size.
4537 */
4538 char *e;
4539 int major = simple_strtoul(buf, &e, 10);
4540 int minor;
4541 dev_t dev;
4542 struct md_rdev *rdev;
4543 int err;
4544
4545 if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
4546 return -EINVAL;
4547 minor = simple_strtoul(e+1, &e, 10);
4548 if (*e && *e != '\n')
4549 return -EINVAL;
4550 dev = MKDEV(major, minor);
4551 if (major != MAJOR(dev) ||
4552 minor != MINOR(dev))
4553 return -EOVERFLOW;
4554
4555 flush_rdev_wq(mddev);
4556 err = mddev_lock(mddev);
4557 if (err)
4558 return err;
4559 if (mddev->persistent) {
4560 rdev = md_import_device(dev, mddev->major_version,
4561 mddev->minor_version);
4562 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
4563 struct md_rdev *rdev0
4564 = list_entry(mddev->disks.next,
4565 struct md_rdev, same_set);
4566 err = super_types[mddev->major_version]
4567 .load_super(rdev, rdev0, mddev->minor_version);
4568 if (err < 0)
4569 goto out;
4570 }
4571 } else if (mddev->external)
4572 rdev = md_import_device(dev, -2, -1);
4573 else
4574 rdev = md_import_device(dev, -1, -1);
4575
4576 if (IS_ERR(rdev)) {
4577 mddev_unlock(mddev);
4578 return PTR_ERR(rdev);
4579 }
4580 err = bind_rdev_to_array(rdev, mddev);
4581 out:
4582 if (err)
4583 export_rdev(rdev);
4584 mddev_unlock(mddev);
4585 if (!err)
4586 md_new_event();
4587 return err ? err : len;
4588}
4589
4590static struct md_sysfs_entry md_new_device =
4591__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
4592
4593static ssize_t
4594bitmap_store(struct mddev *mddev, const char *buf, size_t len)
4595{
4596 char *end;
4597 unsigned long chunk, end_chunk;
4598 int err;
4599
4600 err = mddev_lock(mddev);
4601 if (err)
4602 return err;
4603 if (!mddev->bitmap)
4604 goto out;
4605 /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
4606 while (*buf) {
4607 chunk = end_chunk = simple_strtoul(buf, &end, 0);
4608 if (buf == end) break;
4609 if (*end == '-') { /* range */
4610 buf = end + 1;
4611 end_chunk = simple_strtoul(buf, &end, 0);
4612 if (buf == end) break;
4613 }
4614 if (*end && !isspace(*end)) break;
4615 md_bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
4616 buf = skip_spaces(end);
4617 }
4618 md_bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
4619out:
4620 mddev_unlock(mddev);
4621 return len;
4622}
4623
4624static struct md_sysfs_entry md_bitmap =
4625__ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
4626
4627static ssize_t
4628size_show(struct mddev *mddev, char *page)
4629{
4630 return sprintf(page, "%llu\n",
4631 (unsigned long long)mddev->dev_sectors / 2);
4632}
4633
4634static int update_size(struct mddev *mddev, sector_t num_sectors);
4635
4636static ssize_t
4637size_store(struct mddev *mddev, const char *buf, size_t len)
4638{
4639 /* If array is inactive, we can reduce the component size, but
4640 * not increase it (except from 0).
4641 * If array is active, we can try an on-line resize
4642 */
4643 sector_t sectors;
4644 int err = strict_blocks_to_sectors(buf, §ors);
4645
4646 if (err < 0)
4647 return err;
4648 err = mddev_lock(mddev);
4649 if (err)
4650 return err;
4651 if (mddev->pers) {
4652 err = update_size(mddev, sectors);
4653 if (err == 0)
4654 md_update_sb(mddev, 1);
4655 } else {
4656 if (mddev->dev_sectors == 0 ||
4657 mddev->dev_sectors > sectors)
4658 mddev->dev_sectors = sectors;
4659 else
4660 err = -ENOSPC;
4661 }
4662 mddev_unlock(mddev);
4663 return err ? err : len;
4664}
4665
4666static struct md_sysfs_entry md_size =
4667__ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
4668
4669/* Metadata version.
4670 * This is one of
4671 * 'none' for arrays with no metadata (good luck...)
4672 * 'external' for arrays with externally managed metadata,
4673 * or N.M for internally known formats
4674 */
4675static ssize_t
4676metadata_show(struct mddev *mddev, char *page)
4677{
4678 if (mddev->persistent)
4679 return sprintf(page, "%d.%d\n",
4680 mddev->major_version, mddev->minor_version);
4681 else if (mddev->external)
4682 return sprintf(page, "external:%s\n", mddev->metadata_type);
4683 else
4684 return sprintf(page, "none\n");
4685}
4686
4687static ssize_t
4688metadata_store(struct mddev *mddev, const char *buf, size_t len)
4689{
4690 int major, minor;
4691 char *e;
4692 int err;
4693 /* Changing the details of 'external' metadata is
4694 * always permitted. Otherwise there must be
4695 * no devices attached to the array.
4696 */
4697
4698 err = mddev_lock(mddev);
4699 if (err)
4700 return err;
4701 err = -EBUSY;
4702 if (mddev->external && strncmp(buf, "external:", 9) == 0)
4703 ;
4704 else if (!list_empty(&mddev->disks))
4705 goto out_unlock;
4706
4707 err = 0;
4708 if (cmd_match(buf, "none")) {
4709 mddev->persistent = 0;
4710 mddev->external = 0;
4711 mddev->major_version = 0;
4712 mddev->minor_version = 90;
4713 goto out_unlock;
4714 }
4715 if (strncmp(buf, "external:", 9) == 0) {
4716 size_t namelen = len-9;
4717 if (namelen >= sizeof(mddev->metadata_type))
4718 namelen = sizeof(mddev->metadata_type)-1;
4719 strncpy(mddev->metadata_type, buf+9, namelen);
4720 mddev->metadata_type[namelen] = 0;
4721 if (namelen && mddev->metadata_type[namelen-1] == '\n')
4722 mddev->metadata_type[--namelen] = 0;
4723 mddev->persistent = 0;
4724 mddev->external = 1;
4725 mddev->major_version = 0;
4726 mddev->minor_version = 90;
4727 goto out_unlock;
4728 }
4729 major = simple_strtoul(buf, &e, 10);
4730 err = -EINVAL;
4731 if (e==buf || *e != '.')
4732 goto out_unlock;
4733 buf = e+1;
4734 minor = simple_strtoul(buf, &e, 10);
4735 if (e==buf || (*e && *e != '\n') )
4736 goto out_unlock;
4737 err = -ENOENT;
4738 if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
4739 goto out_unlock;
4740 mddev->major_version = major;
4741 mddev->minor_version = minor;
4742 mddev->persistent = 1;
4743 mddev->external = 0;
4744 err = 0;
4745out_unlock:
4746 mddev_unlock(mddev);
4747 return err ?: len;
4748}
4749
4750static struct md_sysfs_entry md_metadata =
4751__ATTR_PREALLOC(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
4752
4753static ssize_t
4754action_show(struct mddev *mddev, char *page)
4755{
4756 char *type = "idle";
4757 unsigned long recovery = mddev->recovery;
4758 if (test_bit(MD_RECOVERY_FROZEN, &recovery))
4759 type = "frozen";
4760 else if (test_bit(MD_RECOVERY_RUNNING, &recovery) ||
4761 (md_is_rdwr(mddev) && test_bit(MD_RECOVERY_NEEDED, &recovery))) {
4762 if (test_bit(MD_RECOVERY_RESHAPE, &recovery))
4763 type = "reshape";
4764 else if (test_bit(MD_RECOVERY_SYNC, &recovery)) {
4765 if (!test_bit(MD_RECOVERY_REQUESTED, &recovery))
4766 type = "resync";
4767 else if (test_bit(MD_RECOVERY_CHECK, &recovery))
4768 type = "check";
4769 else
4770 type = "repair";
4771 } else if (test_bit(MD_RECOVERY_RECOVER, &recovery))
4772 type = "recover";
4773 else if (mddev->reshape_position != MaxSector)
4774 type = "reshape";
4775 }
4776 return sprintf(page, "%s\n", type);
4777}
4778
4779static ssize_t
4780action_store(struct mddev *mddev, const char *page, size_t len)
4781{
4782 if (!mddev->pers || !mddev->pers->sync_request)
4783 return -EINVAL;
4784
4785
4786 if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
4787 if (cmd_match(page, "frozen"))
4788 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4789 else
4790 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4791 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
4792 mddev_lock(mddev) == 0) {
4793 if (work_pending(&mddev->del_work))
4794 flush_workqueue(md_misc_wq);
4795 if (mddev->sync_thread) {
4796 sector_t save_rp = mddev->reshape_position;
4797
4798 mddev_unlock(mddev);
4799 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4800 md_unregister_thread(&mddev->sync_thread);
4801 mddev_lock_nointr(mddev);
4802 /*
4803 * set RECOVERY_INTR again and restore reshape
4804 * position in case others changed them after
4805 * got lock, eg, reshape_position_store and
4806 * md_check_recovery.
4807 */
4808 mddev->reshape_position = save_rp;
4809 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4810 md_reap_sync_thread(mddev);
4811 }
4812 mddev_unlock(mddev);
4813 }
4814 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4815 return -EBUSY;
4816 else if (cmd_match(page, "resync"))
4817 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4818 else if (cmd_match(page, "recover")) {
4819 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4820 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
4821 } else if (cmd_match(page, "reshape")) {
4822 int err;
4823 if (mddev->pers->start_reshape == NULL)
4824 return -EINVAL;
4825 err = mddev_lock(mddev);
4826 if (!err) {
4827 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4828 err = -EBUSY;
4829 else {
4830 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4831 err = mddev->pers->start_reshape(mddev);
4832 }
4833 mddev_unlock(mddev);
4834 }
4835 if (err)
4836 return err;
4837 sysfs_notify_dirent_safe(mddev->sysfs_degraded);
4838 } else {
4839 if (cmd_match(page, "check"))
4840 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
4841 else if (!cmd_match(page, "repair"))
4842 return -EINVAL;
4843 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4844 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
4845 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4846 }
4847 if (mddev->ro == MD_AUTO_READ) {
4848 /* A write to sync_action is enough to justify
4849 * canceling read-auto mode
4850 */
4851 mddev->ro = MD_RDWR;
4852 md_wakeup_thread(mddev->sync_thread);
4853 }
4854 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4855 md_wakeup_thread(mddev->thread);
4856 sysfs_notify_dirent_safe(mddev->sysfs_action);
4857 return len;
4858}
4859
4860static struct md_sysfs_entry md_scan_mode =
4861__ATTR_PREALLOC(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
4862
4863static ssize_t
4864last_sync_action_show(struct mddev *mddev, char *page)
4865{
4866 return sprintf(page, "%s\n", mddev->last_sync_action);
4867}
4868
4869static struct md_sysfs_entry md_last_scan_mode = __ATTR_RO(last_sync_action);
4870
4871static ssize_t
4872mismatch_cnt_show(struct mddev *mddev, char *page)
4873{
4874 return sprintf(page, "%llu\n",
4875 (unsigned long long)
4876 atomic64_read(&mddev->resync_mismatches));
4877}
4878
4879static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
4880
4881static ssize_t
4882sync_min_show(struct mddev *mddev, char *page)
4883{
4884 return sprintf(page, "%d (%s)\n", speed_min(mddev),
4885 mddev->sync_speed_min ? "local": "system");
4886}
4887
4888static ssize_t
4889sync_min_store(struct mddev *mddev, const char *buf, size_t len)
4890{
4891 unsigned int min;
4892 int rv;
4893
4894 if (strncmp(buf, "system", 6)==0) {
4895 min = 0;
4896 } else {
4897 rv = kstrtouint(buf, 10, &min);
4898 if (rv < 0)
4899 return rv;
4900 if (min == 0)
4901 return -EINVAL;
4902 }
4903 mddev->sync_speed_min = min;
4904 return len;
4905}
4906
4907static struct md_sysfs_entry md_sync_min =
4908__ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
4909
4910static ssize_t
4911sync_max_show(struct mddev *mddev, char *page)
4912{
4913 return sprintf(page, "%d (%s)\n", speed_max(mddev),
4914 mddev->sync_speed_max ? "local": "system");
4915}
4916
4917static ssize_t
4918sync_max_store(struct mddev *mddev, const char *buf, size_t len)
4919{
4920 unsigned int max;
4921 int rv;
4922
4923 if (strncmp(buf, "system", 6)==0) {
4924 max = 0;
4925 } else {
4926 rv = kstrtouint(buf, 10, &max);
4927 if (rv < 0)
4928 return rv;
4929 if (max == 0)
4930 return -EINVAL;
4931 }
4932 mddev->sync_speed_max = max;
4933 return len;
4934}
4935
4936static struct md_sysfs_entry md_sync_max =
4937__ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
4938
4939static ssize_t
4940degraded_show(struct mddev *mddev, char *page)
4941{
4942 return sprintf(page, "%d\n", mddev->degraded);
4943}
4944static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
4945
4946static ssize_t
4947sync_force_parallel_show(struct mddev *mddev, char *page)
4948{
4949 return sprintf(page, "%d\n", mddev->parallel_resync);
4950}
4951
4952static ssize_t
4953sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
4954{
4955 long n;
4956
4957 if (kstrtol(buf, 10, &n))
4958 return -EINVAL;
4959
4960 if (n != 0 && n != 1)
4961 return -EINVAL;
4962
4963 mddev->parallel_resync = n;
4964
4965 if (mddev->sync_thread)
4966 wake_up(&resync_wait);
4967
4968 return len;
4969}
4970
4971/* force parallel resync, even with shared block devices */
4972static struct md_sysfs_entry md_sync_force_parallel =
4973__ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
4974 sync_force_parallel_show, sync_force_parallel_store);
4975
4976static ssize_t
4977sync_speed_show(struct mddev *mddev, char *page)
4978{
4979 unsigned long resync, dt, db;
4980 if (mddev->curr_resync == MD_RESYNC_NONE)
4981 return sprintf(page, "none\n");
4982 resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
4983 dt = (jiffies - mddev->resync_mark) / HZ;
4984 if (!dt) dt++;
4985 db = resync - mddev->resync_mark_cnt;
4986 return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
4987}
4988
4989static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
4990
4991static ssize_t
4992sync_completed_show(struct mddev *mddev, char *page)
4993{
4994 unsigned long long max_sectors, resync;
4995
4996 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4997 return sprintf(page, "none\n");
4998
4999 if (mddev->curr_resync == MD_RESYNC_YIELDED ||
5000 mddev->curr_resync == MD_RESYNC_DELAYED)
5001 return sprintf(page, "delayed\n");
5002
5003 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
5004 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
5005 max_sectors = mddev->resync_max_sectors;
5006 else
5007 max_sectors = mddev->dev_sectors;
5008
5009 resync = mddev->curr_resync_completed;
5010 return sprintf(page, "%llu / %llu\n", resync, max_sectors);
5011}
5012
5013static struct md_sysfs_entry md_sync_completed =
5014 __ATTR_PREALLOC(sync_completed, S_IRUGO, sync_completed_show, NULL);
5015
5016static ssize_t
5017min_sync_show(struct mddev *mddev, char *page)
5018{
5019 return sprintf(page, "%llu\n",
5020 (unsigned long long)mddev->resync_min);
5021}
5022static ssize_t
5023min_sync_store(struct mddev *mddev, const char *buf, size_t len)
5024{
5025 unsigned long long min;
5026 int err;
5027
5028 if (kstrtoull(buf, 10, &min))
5029 return -EINVAL;
5030
5031 spin_lock(&mddev->lock);
5032 err = -EINVAL;
5033 if (min > mddev->resync_max)
5034 goto out_unlock;
5035
5036 err = -EBUSY;
5037 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5038 goto out_unlock;
5039
5040 /* Round down to multiple of 4K for safety */
5041 mddev->resync_min = round_down(min, 8);
5042 err = 0;
5043
5044out_unlock:
5045 spin_unlock(&mddev->lock);
5046 return err ?: len;
5047}
5048
5049static struct md_sysfs_entry md_min_sync =
5050__ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
5051
5052static ssize_t
5053max_sync_show(struct mddev *mddev, char *page)
5054{
5055 if (mddev->resync_max == MaxSector)
5056 return sprintf(page, "max\n");
5057 else
5058 return sprintf(page, "%llu\n",
5059 (unsigned long long)mddev->resync_max);
5060}
5061static ssize_t
5062max_sync_store(struct mddev *mddev, const char *buf, size_t len)
5063{
5064 int err;
5065 spin_lock(&mddev->lock);
5066 if (strncmp(buf, "max", 3) == 0)
5067 mddev->resync_max = MaxSector;
5068 else {
5069 unsigned long long max;
5070 int chunk;
5071
5072 err = -EINVAL;
5073 if (kstrtoull(buf, 10, &max))
5074 goto out_unlock;
5075 if (max < mddev->resync_min)
5076 goto out_unlock;
5077
5078 err = -EBUSY;
5079 if (max < mddev->resync_max && md_is_rdwr(mddev) &&
5080 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5081 goto out_unlock;
5082
5083 /* Must be a multiple of chunk_size */
5084 chunk = mddev->chunk_sectors;
5085 if (chunk) {
5086 sector_t temp = max;
5087
5088 err = -EINVAL;
5089 if (sector_div(temp, chunk))
5090 goto out_unlock;
5091 }
5092 mddev->resync_max = max;
5093 }
5094 wake_up(&mddev->recovery_wait);
5095 err = 0;
5096out_unlock:
5097 spin_unlock(&mddev->lock);
5098 return err ?: len;
5099}
5100
5101static struct md_sysfs_entry md_max_sync =
5102__ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
5103
5104static ssize_t
5105suspend_lo_show(struct mddev *mddev, char *page)
5106{
5107 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
5108}
5109
5110static ssize_t
5111suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
5112{
5113 unsigned long long new;
5114 int err;
5115
5116 err = kstrtoull(buf, 10, &new);
5117 if (err < 0)
5118 return err;
5119 if (new != (sector_t)new)
5120 return -EINVAL;
5121
5122 err = mddev_lock(mddev);
5123 if (err)
5124 return err;
5125 err = -EINVAL;
5126 if (mddev->pers == NULL ||
5127 mddev->pers->quiesce == NULL)
5128 goto unlock;
5129 mddev_suspend(mddev);
5130 mddev->suspend_lo = new;
5131 mddev_resume(mddev);
5132
5133 err = 0;
5134unlock:
5135 mddev_unlock(mddev);
5136 return err ?: len;
5137}
5138static struct md_sysfs_entry md_suspend_lo =
5139__ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
5140
5141static ssize_t
5142suspend_hi_show(struct mddev *mddev, char *page)
5143{
5144 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
5145}
5146
5147static ssize_t
5148suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
5149{
5150 unsigned long long new;
5151 int err;
5152
5153 err = kstrtoull(buf, 10, &new);
5154 if (err < 0)
5155 return err;
5156 if (new != (sector_t)new)
5157 return -EINVAL;
5158
5159 err = mddev_lock(mddev);
5160 if (err)
5161 return err;
5162 err = -EINVAL;
5163 if (mddev->pers == NULL)
5164 goto unlock;
5165
5166 mddev_suspend(mddev);
5167 mddev->suspend_hi = new;
5168 mddev_resume(mddev);
5169
5170 err = 0;
5171unlock:
5172 mddev_unlock(mddev);
5173 return err ?: len;
5174}
5175static struct md_sysfs_entry md_suspend_hi =
5176__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
5177
5178static ssize_t
5179reshape_position_show(struct mddev *mddev, char *page)
5180{
5181 if (mddev->reshape_position != MaxSector)
5182 return sprintf(page, "%llu\n",
5183 (unsigned long long)mddev->reshape_position);
5184 strcpy(page, "none\n");
5185 return 5;
5186}
5187
5188static ssize_t
5189reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
5190{
5191 struct md_rdev *rdev;
5192 unsigned long long new;
5193 int err;
5194
5195 err = kstrtoull(buf, 10, &new);
5196 if (err < 0)
5197 return err;
5198 if (new != (sector_t)new)
5199 return -EINVAL;
5200 err = mddev_lock(mddev);
5201 if (err)
5202 return err;
5203 err = -EBUSY;
5204 if (mddev->pers)
5205 goto unlock;
5206 mddev->reshape_position = new;
5207 mddev->delta_disks = 0;
5208 mddev->reshape_backwards = 0;
5209 mddev->new_level = mddev->level;
5210 mddev->new_layout = mddev->layout;
5211 mddev->new_chunk_sectors = mddev->chunk_sectors;
5212 rdev_for_each(rdev, mddev)
5213 rdev->new_data_offset = rdev->data_offset;
5214 err = 0;
5215unlock:
5216 mddev_unlock(mddev);
5217 return err ?: len;
5218}
5219
5220static struct md_sysfs_entry md_reshape_position =
5221__ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
5222 reshape_position_store);
5223
5224static ssize_t
5225reshape_direction_show(struct mddev *mddev, char *page)
5226{
5227 return sprintf(page, "%s\n",
5228 mddev->reshape_backwards ? "backwards" : "forwards");
5229}
5230
5231static ssize_t
5232reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
5233{
5234 int backwards = 0;
5235 int err;
5236
5237 if (cmd_match(buf, "forwards"))
5238 backwards = 0;
5239 else if (cmd_match(buf, "backwards"))
5240 backwards = 1;
5241 else
5242 return -EINVAL;
5243 if (mddev->reshape_backwards == backwards)
5244 return len;
5245
5246 err = mddev_lock(mddev);
5247 if (err)
5248 return err;
5249 /* check if we are allowed to change */
5250 if (mddev->delta_disks)
5251 err = -EBUSY;
5252 else if (mddev->persistent &&
5253 mddev->major_version == 0)
5254 err = -EINVAL;
5255 else
5256 mddev->reshape_backwards = backwards;
5257 mddev_unlock(mddev);
5258 return err ?: len;
5259}
5260
5261static struct md_sysfs_entry md_reshape_direction =
5262__ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
5263 reshape_direction_store);
5264
5265static ssize_t
5266array_size_show(struct mddev *mddev, char *page)
5267{
5268 if (mddev->external_size)
5269 return sprintf(page, "%llu\n",
5270 (unsigned long long)mddev->array_sectors/2);
5271 else
5272 return sprintf(page, "default\n");
5273}
5274
5275static ssize_t
5276array_size_store(struct mddev *mddev, const char *buf, size_t len)
5277{
5278 sector_t sectors;
5279 int err;
5280
5281 err = mddev_lock(mddev);
5282 if (err)
5283 return err;
5284
5285 /* cluster raid doesn't support change array_sectors */
5286 if (mddev_is_clustered(mddev)) {
5287 mddev_unlock(mddev);
5288 return -EINVAL;
5289 }
5290
5291 if (strncmp(buf, "default", 7) == 0) {
5292 if (mddev->pers)
5293 sectors = mddev->pers->size(mddev, 0, 0);
5294 else
5295 sectors = mddev->array_sectors;
5296
5297 mddev->external_size = 0;
5298 } else {
5299 if (strict_blocks_to_sectors(buf, §ors) < 0)
5300 err = -EINVAL;
5301 else if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
5302 err = -E2BIG;
5303 else
5304 mddev->external_size = 1;
5305 }
5306
5307 if (!err) {
5308 mddev->array_sectors = sectors;
5309 if (mddev->pers)
5310 set_capacity_and_notify(mddev->gendisk,
5311 mddev->array_sectors);
5312 }
5313 mddev_unlock(mddev);
5314 return err ?: len;
5315}
5316
5317static struct md_sysfs_entry md_array_size =
5318__ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
5319 array_size_store);
5320
5321static ssize_t
5322consistency_policy_show(struct mddev *mddev, char *page)
5323{
5324 int ret;
5325
5326 if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {
5327 ret = sprintf(page, "journal\n");
5328 } else if (test_bit(MD_HAS_PPL, &mddev->flags)) {
5329 ret = sprintf(page, "ppl\n");
5330 } else if (mddev->bitmap) {
5331 ret = sprintf(page, "bitmap\n");
5332 } else if (mddev->pers) {
5333 if (mddev->pers->sync_request)
5334 ret = sprintf(page, "resync\n");
5335 else
5336 ret = sprintf(page, "none\n");
5337 } else {
5338 ret = sprintf(page, "unknown\n");
5339 }
5340
5341 return ret;
5342}
5343
5344static ssize_t
5345consistency_policy_store(struct mddev *mddev, const char *buf, size_t len)
5346{
5347 int err = 0;
5348
5349 if (mddev->pers) {
5350 if (mddev->pers->change_consistency_policy)
5351 err = mddev->pers->change_consistency_policy(mddev, buf);
5352 else
5353 err = -EBUSY;
5354 } else if (mddev->external && strncmp(buf, "ppl", 3) == 0) {
5355 set_bit(MD_HAS_PPL, &mddev->flags);
5356 } else {
5357 err = -EINVAL;
5358 }
5359
5360 return err ? err : len;
5361}
5362
5363static struct md_sysfs_entry md_consistency_policy =
5364__ATTR(consistency_policy, S_IRUGO | S_IWUSR, consistency_policy_show,
5365 consistency_policy_store);
5366
5367static ssize_t fail_last_dev_show(struct mddev *mddev, char *page)
5368{
5369 return sprintf(page, "%d\n", mddev->fail_last_dev);
5370}
5371
5372/*
5373 * Setting fail_last_dev to true to allow last device to be forcibly removed
5374 * from RAID1/RAID10.
5375 */
5376static ssize_t
5377fail_last_dev_store(struct mddev *mddev, const char *buf, size_t len)
5378{
5379 int ret;
5380 bool value;
5381
5382 ret = kstrtobool(buf, &value);
5383 if (ret)
5384 return ret;
5385
5386 if (value != mddev->fail_last_dev)
5387 mddev->fail_last_dev = value;
5388
5389 return len;
5390}
5391static struct md_sysfs_entry md_fail_last_dev =
5392__ATTR(fail_last_dev, S_IRUGO | S_IWUSR, fail_last_dev_show,
5393 fail_last_dev_store);
5394
5395static ssize_t serialize_policy_show(struct mddev *mddev, char *page)
5396{
5397 if (mddev->pers == NULL || (mddev->pers->level != 1))
5398 return sprintf(page, "n/a\n");
5399 else
5400 return sprintf(page, "%d\n", mddev->serialize_policy);
5401}
5402
5403/*
5404 * Setting serialize_policy to true to enforce write IO is not reordered
5405 * for raid1.
5406 */
5407static ssize_t
5408serialize_policy_store(struct mddev *mddev, const char *buf, size_t len)
5409{
5410 int err;
5411 bool value;
5412
5413 err = kstrtobool(buf, &value);
5414 if (err)
5415 return err;
5416
5417 if (value == mddev->serialize_policy)
5418 return len;
5419
5420 err = mddev_lock(mddev);
5421 if (err)
5422 return err;
5423 if (mddev->pers == NULL || (mddev->pers->level != 1)) {
5424 pr_err("md: serialize_policy is only effective for raid1\n");
5425 err = -EINVAL;
5426 goto unlock;
5427 }
5428
5429 mddev_suspend(mddev);
5430 if (value)
5431 mddev_create_serial_pool(mddev, NULL, true);
5432 else
5433 mddev_destroy_serial_pool(mddev, NULL, true);
5434 mddev->serialize_policy = value;
5435 mddev_resume(mddev);
5436unlock:
5437 mddev_unlock(mddev);
5438 return err ?: len;
5439}
5440
5441static struct md_sysfs_entry md_serialize_policy =
5442__ATTR(serialize_policy, S_IRUGO | S_IWUSR, serialize_policy_show,
5443 serialize_policy_store);
5444
5445
5446static struct attribute *md_default_attrs[] = {
5447 &md_level.attr,
5448 &md_layout.attr,
5449 &md_raid_disks.attr,
5450 &md_uuid.attr,
5451 &md_chunk_size.attr,
5452 &md_size.attr,
5453 &md_resync_start.attr,
5454 &md_metadata.attr,
5455 &md_new_device.attr,
5456 &md_safe_delay.attr,
5457 &md_array_state.attr,
5458 &md_reshape_position.attr,
5459 &md_reshape_direction.attr,
5460 &md_array_size.attr,
5461 &max_corr_read_errors.attr,
5462 &md_consistency_policy.attr,
5463 &md_fail_last_dev.attr,
5464 &md_serialize_policy.attr,
5465 NULL,
5466};
5467
5468static const struct attribute_group md_default_group = {
5469 .attrs = md_default_attrs,
5470};
5471
5472static struct attribute *md_redundancy_attrs[] = {
5473 &md_scan_mode.attr,
5474 &md_last_scan_mode.attr,
5475 &md_mismatches.attr,
5476 &md_sync_min.attr,
5477 &md_sync_max.attr,
5478 &md_sync_speed.attr,
5479 &md_sync_force_parallel.attr,
5480 &md_sync_completed.attr,
5481 &md_min_sync.attr,
5482 &md_max_sync.attr,
5483 &md_suspend_lo.attr,
5484 &md_suspend_hi.attr,
5485 &md_bitmap.attr,
5486 &md_degraded.attr,
5487 NULL,
5488};
5489static const struct attribute_group md_redundancy_group = {
5490 .name = NULL,
5491 .attrs = md_redundancy_attrs,
5492};
5493
5494static const struct attribute_group *md_attr_groups[] = {
5495 &md_default_group,
5496 &md_bitmap_group,
5497 NULL,
5498};
5499
5500static ssize_t
5501md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
5502{
5503 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
5504 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
5505 ssize_t rv;
5506
5507 if (!entry->show)
5508 return -EIO;
5509 spin_lock(&all_mddevs_lock);
5510 if (!mddev_get(mddev)) {
5511 spin_unlock(&all_mddevs_lock);
5512 return -EBUSY;
5513 }
5514 spin_unlock(&all_mddevs_lock);
5515
5516 rv = entry->show(mddev, page);
5517 mddev_put(mddev);
5518 return rv;
5519}
5520
5521static ssize_t
5522md_attr_store(struct kobject *kobj, struct attribute *attr,
5523 const char *page, size_t length)
5524{
5525 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
5526 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
5527 ssize_t rv;
5528
5529 if (!entry->store)
5530 return -EIO;
5531 if (!capable(CAP_SYS_ADMIN))
5532 return -EACCES;
5533 spin_lock(&all_mddevs_lock);
5534 if (!mddev_get(mddev)) {
5535 spin_unlock(&all_mddevs_lock);
5536 return -EBUSY;
5537 }
5538 spin_unlock(&all_mddevs_lock);
5539 rv = entry->store(mddev, page, length);
5540 mddev_put(mddev);
5541 return rv;
5542}
5543
5544static void md_kobj_release(struct kobject *ko)
5545{
5546 struct mddev *mddev = container_of(ko, struct mddev, kobj);
5547
5548 if (mddev->sysfs_state)
5549 sysfs_put(mddev->sysfs_state);
5550 if (mddev->sysfs_level)
5551 sysfs_put(mddev->sysfs_level);
5552
5553 del_gendisk(mddev->gendisk);
5554 put_disk(mddev->gendisk);
5555}
5556
5557static const struct sysfs_ops md_sysfs_ops = {
5558 .show = md_attr_show,
5559 .store = md_attr_store,
5560};
5561static struct kobj_type md_ktype = {
5562 .release = md_kobj_release,
5563 .sysfs_ops = &md_sysfs_ops,
5564 .default_groups = md_attr_groups,
5565};
5566
5567int mdp_major = 0;
5568
5569static void mddev_delayed_delete(struct work_struct *ws)
5570{
5571 struct mddev *mddev = container_of(ws, struct mddev, del_work);
5572
5573 kobject_put(&mddev->kobj);
5574}
5575
5576static void no_op(struct percpu_ref *r) {}
5577
5578int mddev_init_writes_pending(struct mddev *mddev)
5579{
5580 if (mddev->writes_pending.percpu_count_ptr)
5581 return 0;
5582 if (percpu_ref_init(&mddev->writes_pending, no_op,
5583 PERCPU_REF_ALLOW_REINIT, GFP_KERNEL) < 0)
5584 return -ENOMEM;
5585 /* We want to start with the refcount at zero */
5586 percpu_ref_put(&mddev->writes_pending);
5587 return 0;
5588}
5589EXPORT_SYMBOL_GPL(mddev_init_writes_pending);
5590
5591struct mddev *md_alloc(dev_t dev, char *name)
5592{
5593 /*
5594 * If dev is zero, name is the name of a device to allocate with
5595 * an arbitrary minor number. It will be "md_???"
5596 * If dev is non-zero it must be a device number with a MAJOR of
5597 * MD_MAJOR or mdp_major. In this case, if "name" is NULL, then
5598 * the device is being created by opening a node in /dev.
5599 * If "name" is not NULL, the device is being created by
5600 * writing to /sys/module/md_mod/parameters/new_array.
5601 */
5602 static DEFINE_MUTEX(disks_mutex);
5603 struct mddev *mddev;
5604 struct gendisk *disk;
5605 int partitioned;
5606 int shift;
5607 int unit;
5608 int error ;
5609
5610 /*
5611 * Wait for any previous instance of this device to be completely
5612 * removed (mddev_delayed_delete).
5613 */
5614 flush_workqueue(md_misc_wq);
5615 flush_workqueue(md_rdev_misc_wq);
5616
5617 mutex_lock(&disks_mutex);
5618 mddev = mddev_alloc(dev);
5619 if (IS_ERR(mddev)) {
5620 error = PTR_ERR(mddev);
5621 goto out_unlock;
5622 }
5623
5624 partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
5625 shift = partitioned ? MdpMinorShift : 0;
5626 unit = MINOR(mddev->unit) >> shift;
5627
5628 if (name && !dev) {
5629 /* Need to ensure that 'name' is not a duplicate.
5630 */
5631 struct mddev *mddev2;
5632 spin_lock(&all_mddevs_lock);
5633
5634 list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
5635 if (mddev2->gendisk &&
5636 strcmp(mddev2->gendisk->disk_name, name) == 0) {
5637 spin_unlock(&all_mddevs_lock);
5638 error = -EEXIST;
5639 goto out_free_mddev;
5640 }
5641 spin_unlock(&all_mddevs_lock);
5642 }
5643 if (name && dev)
5644 /*
5645 * Creating /dev/mdNNN via "newarray", so adjust hold_active.
5646 */
5647 mddev->hold_active = UNTIL_STOP;
5648
5649 error = -ENOMEM;
5650 disk = blk_alloc_disk(NUMA_NO_NODE);
5651 if (!disk)
5652 goto out_free_mddev;
5653
5654 disk->major = MAJOR(mddev->unit);
5655 disk->first_minor = unit << shift;
5656 disk->minors = 1 << shift;
5657 if (name)
5658 strcpy(disk->disk_name, name);
5659 else if (partitioned)
5660 sprintf(disk->disk_name, "md_d%d", unit);
5661 else
5662 sprintf(disk->disk_name, "md%d", unit);
5663 disk->fops = &md_fops;
5664 disk->private_data = mddev;
5665
5666 mddev->queue = disk->queue;
5667 blk_set_stacking_limits(&mddev->queue->limits);
5668 blk_queue_write_cache(mddev->queue, true, true);
5669 disk->events |= DISK_EVENT_MEDIA_CHANGE;
5670 mddev->gendisk = disk;
5671 error = add_disk(disk);
5672 if (error)
5673 goto out_put_disk;
5674
5675 kobject_init(&mddev->kobj, &md_ktype);
5676 error = kobject_add(&mddev->kobj, &disk_to_dev(disk)->kobj, "%s", "md");
5677 if (error) {
5678 /*
5679 * The disk is already live at this point. Clear the hold flag
5680 * and let mddev_put take care of the deletion, as it isn't any
5681 * different from a normal close on last release now.
5682 */
5683 mddev->hold_active = 0;
5684 mutex_unlock(&disks_mutex);
5685 mddev_put(mddev);
5686 return ERR_PTR(error);
5687 }
5688
5689 kobject_uevent(&mddev->kobj, KOBJ_ADD);
5690 mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
5691 mddev->sysfs_level = sysfs_get_dirent_safe(mddev->kobj.sd, "level");
5692 mutex_unlock(&disks_mutex);
5693 return mddev;
5694
5695out_put_disk:
5696 put_disk(disk);
5697out_free_mddev:
5698 mddev_free(mddev);
5699out_unlock:
5700 mutex_unlock(&disks_mutex);
5701 return ERR_PTR(error);
5702}
5703
5704static int md_alloc_and_put(dev_t dev, char *name)
5705{
5706 struct mddev *mddev = md_alloc(dev, name);
5707
5708 if (IS_ERR(mddev))
5709 return PTR_ERR(mddev);
5710 mddev_put(mddev);
5711 return 0;
5712}
5713
5714static void md_probe(dev_t dev)
5715{
5716 if (MAJOR(dev) == MD_MAJOR && MINOR(dev) >= 512)
5717 return;
5718 if (create_on_open)
5719 md_alloc_and_put(dev, NULL);
5720}
5721
5722static int add_named_array(const char *val, const struct kernel_param *kp)
5723{
5724 /*
5725 * val must be "md_*" or "mdNNN".
5726 * For "md_*" we allocate an array with a large free minor number, and
5727 * set the name to val. val must not already be an active name.
5728 * For "mdNNN" we allocate an array with the minor number NNN
5729 * which must not already be in use.
5730 */
5731 int len = strlen(val);
5732 char buf[DISK_NAME_LEN];
5733 unsigned long devnum;
5734
5735 while (len && val[len-1] == '\n')
5736 len--;
5737 if (len >= DISK_NAME_LEN)
5738 return -E2BIG;
5739 strscpy(buf, val, len+1);
5740 if (strncmp(buf, "md_", 3) == 0)
5741 return md_alloc_and_put(0, buf);
5742 if (strncmp(buf, "md", 2) == 0 &&
5743 isdigit(buf[2]) &&
5744 kstrtoul(buf+2, 10, &devnum) == 0 &&
5745 devnum <= MINORMASK)
5746 return md_alloc_and_put(MKDEV(MD_MAJOR, devnum), NULL);
5747
5748 return -EINVAL;
5749}
5750
5751static void md_safemode_timeout(struct timer_list *t)
5752{
5753 struct mddev *mddev = from_timer(mddev, t, safemode_timer);
5754
5755 mddev->safemode = 1;
5756 if (mddev->external)
5757 sysfs_notify_dirent_safe(mddev->sysfs_state);
5758
5759 md_wakeup_thread(mddev->thread);
5760}
5761
5762static int start_dirty_degraded;
5763
5764int md_run(struct mddev *mddev)
5765{
5766 int err;
5767 struct md_rdev *rdev;
5768 struct md_personality *pers;
5769 bool nowait = true;
5770
5771 if (list_empty(&mddev->disks))
5772 /* cannot run an array with no devices.. */
5773 return -EINVAL;
5774
5775 if (mddev->pers)
5776 return -EBUSY;
5777 /* Cannot run until previous stop completes properly */
5778 if (mddev->sysfs_active)
5779 return -EBUSY;
5780
5781 /*
5782 * Analyze all RAID superblock(s)
5783 */
5784 if (!mddev->raid_disks) {
5785 if (!mddev->persistent)
5786 return -EINVAL;
5787 err = analyze_sbs(mddev);
5788 if (err)
5789 return -EINVAL;
5790 }
5791
5792 if (mddev->level != LEVEL_NONE)
5793 request_module("md-level-%d", mddev->level);
5794 else if (mddev->clevel[0])
5795 request_module("md-%s", mddev->clevel);
5796
5797 /*
5798 * Drop all container device buffers, from now on
5799 * the only valid external interface is through the md
5800 * device.
5801 */
5802 mddev->has_superblocks = false;
5803 rdev_for_each(rdev, mddev) {
5804 if (test_bit(Faulty, &rdev->flags))
5805 continue;
5806 sync_blockdev(rdev->bdev);
5807 invalidate_bdev(rdev->bdev);
5808 if (mddev->ro != MD_RDONLY && rdev_read_only(rdev)) {
5809 mddev->ro = MD_RDONLY;
5810 if (mddev->gendisk)
5811 set_disk_ro(mddev->gendisk, 1);
5812 }
5813
5814 if (rdev->sb_page)
5815 mddev->has_superblocks = true;
5816
5817 /* perform some consistency tests on the device.
5818 * We don't want the data to overlap the metadata,
5819 * Internal Bitmap issues have been handled elsewhere.
5820 */
5821 if (rdev->meta_bdev) {
5822 /* Nothing to check */;
5823 } else if (rdev->data_offset < rdev->sb_start) {
5824 if (mddev->dev_sectors &&
5825 rdev->data_offset + mddev->dev_sectors
5826 > rdev->sb_start) {
5827 pr_warn("md: %s: data overlaps metadata\n",
5828 mdname(mddev));
5829 return -EINVAL;
5830 }
5831 } else {
5832 if (rdev->sb_start + rdev->sb_size/512
5833 > rdev->data_offset) {
5834 pr_warn("md: %s: metadata overlaps data\n",
5835 mdname(mddev));
5836 return -EINVAL;
5837 }
5838 }
5839 sysfs_notify_dirent_safe(rdev->sysfs_state);
5840 nowait = nowait && bdev_nowait(rdev->bdev);
5841 }
5842
5843 if (!bioset_initialized(&mddev->bio_set)) {
5844 err = bioset_init(&mddev->bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
5845 if (err)
5846 return err;
5847 }
5848 if (!bioset_initialized(&mddev->sync_set)) {
5849 err = bioset_init(&mddev->sync_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
5850 if (err)
5851 goto exit_bio_set;
5852 }
5853
5854 spin_lock(&pers_lock);
5855 pers = find_pers(mddev->level, mddev->clevel);
5856 if (!pers || !try_module_get(pers->owner)) {
5857 spin_unlock(&pers_lock);
5858 if (mddev->level != LEVEL_NONE)
5859 pr_warn("md: personality for level %d is not loaded!\n",
5860 mddev->level);
5861 else
5862 pr_warn("md: personality for level %s is not loaded!\n",
5863 mddev->clevel);
5864 err = -EINVAL;
5865 goto abort;
5866 }
5867 spin_unlock(&pers_lock);
5868 if (mddev->level != pers->level) {
5869 mddev->level = pers->level;
5870 mddev->new_level = pers->level;
5871 }
5872 strscpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
5873
5874 if (mddev->reshape_position != MaxSector &&
5875 pers->start_reshape == NULL) {
5876 /* This personality cannot handle reshaping... */
5877 module_put(pers->owner);
5878 err = -EINVAL;
5879 goto abort;
5880 }
5881
5882 if (pers->sync_request) {
5883 /* Warn if this is a potentially silly
5884 * configuration.
5885 */
5886 struct md_rdev *rdev2;
5887 int warned = 0;
5888
5889 rdev_for_each(rdev, mddev)
5890 rdev_for_each(rdev2, mddev) {
5891 if (rdev < rdev2 &&
5892 rdev->bdev->bd_disk ==
5893 rdev2->bdev->bd_disk) {
5894 pr_warn("%s: WARNING: %pg appears to be on the same physical disk as %pg.\n",
5895 mdname(mddev),
5896 rdev->bdev,
5897 rdev2->bdev);
5898 warned = 1;
5899 }
5900 }
5901
5902 if (warned)
5903 pr_warn("True protection against single-disk failure might be compromised.\n");
5904 }
5905
5906 mddev->recovery = 0;
5907 /* may be over-ridden by personality */
5908 mddev->resync_max_sectors = mddev->dev_sectors;
5909
5910 mddev->ok_start_degraded = start_dirty_degraded;
5911
5912 if (start_readonly && md_is_rdwr(mddev))
5913 mddev->ro = MD_AUTO_READ; /* read-only, but switch on first write */
5914
5915 err = pers->run(mddev);
5916 if (err)
5917 pr_warn("md: pers->run() failed ...\n");
5918 else if (pers->size(mddev, 0, 0) < mddev->array_sectors) {
5919 WARN_ONCE(!mddev->external_size,
5920 "%s: default size too small, but 'external_size' not in effect?\n",
5921 __func__);
5922 pr_warn("md: invalid array_size %llu > default size %llu\n",
5923 (unsigned long long)mddev->array_sectors / 2,
5924 (unsigned long long)pers->size(mddev, 0, 0) / 2);
5925 err = -EINVAL;
5926 }
5927 if (err == 0 && pers->sync_request &&
5928 (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
5929 struct bitmap *bitmap;
5930
5931 bitmap = md_bitmap_create(mddev, -1);
5932 if (IS_ERR(bitmap)) {
5933 err = PTR_ERR(bitmap);
5934 pr_warn("%s: failed to create bitmap (%d)\n",
5935 mdname(mddev), err);
5936 } else
5937 mddev->bitmap = bitmap;
5938
5939 }
5940 if (err)
5941 goto bitmap_abort;
5942
5943 if (mddev->bitmap_info.max_write_behind > 0) {
5944 bool create_pool = false;
5945
5946 rdev_for_each(rdev, mddev) {
5947 if (test_bit(WriteMostly, &rdev->flags) &&
5948 rdev_init_serial(rdev))
5949 create_pool = true;
5950 }
5951 if (create_pool && mddev->serial_info_pool == NULL) {
5952 mddev->serial_info_pool =
5953 mempool_create_kmalloc_pool(NR_SERIAL_INFOS,
5954 sizeof(struct serial_info));
5955 if (!mddev->serial_info_pool) {
5956 err = -ENOMEM;
5957 goto bitmap_abort;
5958 }
5959 }
5960 }
5961
5962 if (mddev->queue) {
5963 bool nonrot = true;
5964
5965 rdev_for_each(rdev, mddev) {
5966 if (rdev->raid_disk >= 0 && !bdev_nonrot(rdev->bdev)) {
5967 nonrot = false;
5968 break;
5969 }
5970 }
5971 if (mddev->degraded)
5972 nonrot = false;
5973 if (nonrot)
5974 blk_queue_flag_set(QUEUE_FLAG_NONROT, mddev->queue);
5975 else
5976 blk_queue_flag_clear(QUEUE_FLAG_NONROT, mddev->queue);
5977 blk_queue_flag_set(QUEUE_FLAG_IO_STAT, mddev->queue);
5978
5979 /* Set the NOWAIT flags if all underlying devices support it */
5980 if (nowait)
5981 blk_queue_flag_set(QUEUE_FLAG_NOWAIT, mddev->queue);
5982 }
5983 if (pers->sync_request) {
5984 if (mddev->kobj.sd &&
5985 sysfs_create_group(&mddev->kobj, &md_redundancy_group))
5986 pr_warn("md: cannot register extra attributes for %s\n",
5987 mdname(mddev));
5988 mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
5989 mddev->sysfs_completed = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_completed");
5990 mddev->sysfs_degraded = sysfs_get_dirent_safe(mddev->kobj.sd, "degraded");
5991 } else if (mddev->ro == MD_AUTO_READ)
5992 mddev->ro = MD_RDWR;
5993
5994 atomic_set(&mddev->max_corr_read_errors,
5995 MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
5996 mddev->safemode = 0;
5997 if (mddev_is_clustered(mddev))
5998 mddev->safemode_delay = 0;
5999 else
6000 mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;
6001 mddev->in_sync = 1;
6002 smp_wmb();
6003 spin_lock(&mddev->lock);
6004 mddev->pers = pers;
6005 spin_unlock(&mddev->lock);
6006 rdev_for_each(rdev, mddev)
6007 if (rdev->raid_disk >= 0)
6008 sysfs_link_rdev(mddev, rdev); /* failure here is OK */
6009
6010 if (mddev->degraded && md_is_rdwr(mddev))
6011 /* This ensures that recovering status is reported immediately
6012 * via sysfs - until a lack of spares is confirmed.
6013 */
6014 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
6015 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6016
6017 if (mddev->sb_flags)
6018 md_update_sb(mddev, 0);
6019
6020 md_new_event();
6021 return 0;
6022
6023bitmap_abort:
6024 mddev_detach(mddev);
6025 if (mddev->private)
6026 pers->free(mddev, mddev->private);
6027 mddev->private = NULL;
6028 module_put(pers->owner);
6029 md_bitmap_destroy(mddev);
6030abort:
6031 bioset_exit(&mddev->sync_set);
6032exit_bio_set:
6033 bioset_exit(&mddev->bio_set);
6034 return err;
6035}
6036EXPORT_SYMBOL_GPL(md_run);
6037
6038int do_md_run(struct mddev *mddev)
6039{
6040 int err;
6041
6042 set_bit(MD_NOT_READY, &mddev->flags);
6043 err = md_run(mddev);
6044 if (err)
6045 goto out;
6046 err = md_bitmap_load(mddev);
6047 if (err) {
6048 md_bitmap_destroy(mddev);
6049 goto out;
6050 }
6051
6052 if (mddev_is_clustered(mddev))
6053 md_allow_write(mddev);
6054
6055 /* run start up tasks that require md_thread */
6056 md_start(mddev);
6057
6058 md_wakeup_thread(mddev->thread);
6059 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
6060
6061 set_capacity_and_notify(mddev->gendisk, mddev->array_sectors);
6062 clear_bit(MD_NOT_READY, &mddev->flags);
6063 mddev->changed = 1;
6064 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
6065 sysfs_notify_dirent_safe(mddev->sysfs_state);
6066 sysfs_notify_dirent_safe(mddev->sysfs_action);
6067 sysfs_notify_dirent_safe(mddev->sysfs_degraded);
6068out:
6069 clear_bit(MD_NOT_READY, &mddev->flags);
6070 return err;
6071}
6072
6073int md_start(struct mddev *mddev)
6074{
6075 int ret = 0;
6076
6077 if (mddev->pers->start) {
6078 set_bit(MD_RECOVERY_WAIT, &mddev->recovery);
6079 md_wakeup_thread(mddev->thread);
6080 ret = mddev->pers->start(mddev);
6081 clear_bit(MD_RECOVERY_WAIT, &mddev->recovery);
6082 md_wakeup_thread(mddev->sync_thread);
6083 }
6084 return ret;
6085}
6086EXPORT_SYMBOL_GPL(md_start);
6087
6088static int restart_array(struct mddev *mddev)
6089{
6090 struct gendisk *disk = mddev->gendisk;
6091 struct md_rdev *rdev;
6092 bool has_journal = false;
6093 bool has_readonly = false;
6094
6095 /* Complain if it has no devices */
6096 if (list_empty(&mddev->disks))
6097 return -ENXIO;
6098 if (!mddev->pers)
6099 return -EINVAL;
6100 if (md_is_rdwr(mddev))
6101 return -EBUSY;
6102
6103 rcu_read_lock();
6104 rdev_for_each_rcu(rdev, mddev) {
6105 if (test_bit(Journal, &rdev->flags) &&
6106 !test_bit(Faulty, &rdev->flags))
6107 has_journal = true;
6108 if (rdev_read_only(rdev))
6109 has_readonly = true;
6110 }
6111 rcu_read_unlock();
6112 if (test_bit(MD_HAS_JOURNAL, &mddev->flags) && !has_journal)
6113 /* Don't restart rw with journal missing/faulty */
6114 return -EINVAL;
6115 if (has_readonly)
6116 return -EROFS;
6117
6118 mddev->safemode = 0;
6119 mddev->ro = MD_RDWR;
6120 set_disk_ro(disk, 0);
6121 pr_debug("md: %s switched to read-write mode.\n", mdname(mddev));
6122 /* Kick recovery or resync if necessary */
6123 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6124 md_wakeup_thread(mddev->thread);
6125 md_wakeup_thread(mddev->sync_thread);
6126 sysfs_notify_dirent_safe(mddev->sysfs_state);
6127 return 0;
6128}
6129
6130static void md_clean(struct mddev *mddev)
6131{
6132 mddev->array_sectors = 0;
6133 mddev->external_size = 0;
6134 mddev->dev_sectors = 0;
6135 mddev->raid_disks = 0;
6136 mddev->recovery_cp = 0;
6137 mddev->resync_min = 0;
6138 mddev->resync_max = MaxSector;
6139 mddev->reshape_position = MaxSector;
6140 mddev->external = 0;
6141 mddev->persistent = 0;
6142 mddev->level = LEVEL_NONE;
6143 mddev->clevel[0] = 0;
6144 mddev->flags = 0;
6145 mddev->sb_flags = 0;
6146 mddev->ro = MD_RDWR;
6147 mddev->metadata_type[0] = 0;
6148 mddev->chunk_sectors = 0;
6149 mddev->ctime = mddev->utime = 0;
6150 mddev->layout = 0;
6151 mddev->max_disks = 0;
6152 mddev->events = 0;
6153 mddev->can_decrease_events = 0;
6154 mddev->delta_disks = 0;
6155 mddev->reshape_backwards = 0;
6156 mddev->new_level = LEVEL_NONE;
6157 mddev->new_layout = 0;
6158 mddev->new_chunk_sectors = 0;
6159 mddev->curr_resync = 0;
6160 atomic64_set(&mddev->resync_mismatches, 0);
6161 mddev->suspend_lo = mddev->suspend_hi = 0;
6162 mddev->sync_speed_min = mddev->sync_speed_max = 0;
6163 mddev->recovery = 0;
6164 mddev->in_sync = 0;
6165 mddev->changed = 0;
6166 mddev->degraded = 0;
6167 mddev->safemode = 0;
6168 mddev->private = NULL;
6169 mddev->cluster_info = NULL;
6170 mddev->bitmap_info.offset = 0;
6171 mddev->bitmap_info.default_offset = 0;
6172 mddev->bitmap_info.default_space = 0;
6173 mddev->bitmap_info.chunksize = 0;
6174 mddev->bitmap_info.daemon_sleep = 0;
6175 mddev->bitmap_info.max_write_behind = 0;
6176 mddev->bitmap_info.nodes = 0;
6177}
6178
6179static void __md_stop_writes(struct mddev *mddev)
6180{
6181 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6182 if (work_pending(&mddev->del_work))
6183 flush_workqueue(md_misc_wq);
6184 if (mddev->sync_thread) {
6185 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6186 md_unregister_thread(&mddev->sync_thread);
6187 md_reap_sync_thread(mddev);
6188 }
6189
6190 del_timer_sync(&mddev->safemode_timer);
6191
6192 if (mddev->pers && mddev->pers->quiesce) {
6193 mddev->pers->quiesce(mddev, 1);
6194 mddev->pers->quiesce(mddev, 0);
6195 }
6196 md_bitmap_flush(mddev);
6197
6198 if (md_is_rdwr(mddev) &&
6199 ((!mddev->in_sync && !mddev_is_clustered(mddev)) ||
6200 mddev->sb_flags)) {
6201 /* mark array as shutdown cleanly */
6202 if (!mddev_is_clustered(mddev))
6203 mddev->in_sync = 1;
6204 md_update_sb(mddev, 1);
6205 }
6206 /* disable policy to guarantee rdevs free resources for serialization */
6207 mddev->serialize_policy = 0;
6208 mddev_destroy_serial_pool(mddev, NULL, true);
6209}
6210
6211void md_stop_writes(struct mddev *mddev)
6212{
6213 mddev_lock_nointr(mddev);
6214 __md_stop_writes(mddev);
6215 mddev_unlock(mddev);
6216}
6217EXPORT_SYMBOL_GPL(md_stop_writes);
6218
6219static void mddev_detach(struct mddev *mddev)
6220{
6221 md_bitmap_wait_behind_writes(mddev);
6222 if (mddev->pers && mddev->pers->quiesce && !mddev->suspended) {
6223 mddev->pers->quiesce(mddev, 1);
6224 mddev->pers->quiesce(mddev, 0);
6225 }
6226 md_unregister_thread(&mddev->thread);
6227 if (mddev->queue)
6228 blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
6229}
6230
6231static void __md_stop(struct mddev *mddev)
6232{
6233 struct md_personality *pers = mddev->pers;
6234 md_bitmap_destroy(mddev);
6235 mddev_detach(mddev);
6236 /* Ensure ->event_work is done */
6237 if (mddev->event_work.func)
6238 flush_workqueue(md_misc_wq);
6239 spin_lock(&mddev->lock);
6240 mddev->pers = NULL;
6241 spin_unlock(&mddev->lock);
6242 if (mddev->private)
6243 pers->free(mddev, mddev->private);
6244 mddev->private = NULL;
6245 if (pers->sync_request && mddev->to_remove == NULL)
6246 mddev->to_remove = &md_redundancy_group;
6247 module_put(pers->owner);
6248 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6249}
6250
6251void md_stop(struct mddev *mddev)
6252{
6253 /* stop the array and free an attached data structures.
6254 * This is called from dm-raid
6255 */
6256 __md_stop_writes(mddev);
6257 __md_stop(mddev);
6258 bioset_exit(&mddev->bio_set);
6259 bioset_exit(&mddev->sync_set);
6260}
6261
6262EXPORT_SYMBOL_GPL(md_stop);
6263
6264static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
6265{
6266 int err = 0;
6267 int did_freeze = 0;
6268
6269 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
6270 did_freeze = 1;
6271 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6272 md_wakeup_thread(mddev->thread);
6273 }
6274 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
6275 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6276 if (mddev->sync_thread)
6277 /* Thread might be blocked waiting for metadata update
6278 * which will now never happen */
6279 wake_up_process(mddev->sync_thread->tsk);
6280
6281 if (mddev->external && test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))
6282 return -EBUSY;
6283 mddev_unlock(mddev);
6284 wait_event(resync_wait, !test_bit(MD_RECOVERY_RUNNING,
6285 &mddev->recovery));
6286 wait_event(mddev->sb_wait,
6287 !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
6288 mddev_lock_nointr(mddev);
6289
6290 mutex_lock(&mddev->open_mutex);
6291 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
6292 mddev->sync_thread ||
6293 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
6294 pr_warn("md: %s still in use.\n",mdname(mddev));
6295 if (did_freeze) {
6296 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6297 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6298 md_wakeup_thread(mddev->thread);
6299 }
6300 err = -EBUSY;
6301 goto out;
6302 }
6303 if (mddev->pers) {
6304 __md_stop_writes(mddev);
6305
6306 err = -ENXIO;
6307 if (mddev->ro == MD_RDONLY)
6308 goto out;
6309 mddev->ro = MD_RDONLY;
6310 set_disk_ro(mddev->gendisk, 1);
6311 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6312 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6313 md_wakeup_thread(mddev->thread);
6314 sysfs_notify_dirent_safe(mddev->sysfs_state);
6315 err = 0;
6316 }
6317out:
6318 mutex_unlock(&mddev->open_mutex);
6319 return err;
6320}
6321
6322/* mode:
6323 * 0 - completely stop and dis-assemble array
6324 * 2 - stop but do not disassemble array
6325 */
6326static int do_md_stop(struct mddev *mddev, int mode,
6327 struct block_device *bdev)
6328{
6329 struct gendisk *disk = mddev->gendisk;
6330 struct md_rdev *rdev;
6331 int did_freeze = 0;
6332
6333 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
6334 did_freeze = 1;
6335 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6336 md_wakeup_thread(mddev->thread);
6337 }
6338 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
6339 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6340 if (mddev->sync_thread)
6341 /* Thread might be blocked waiting for metadata update
6342 * which will now never happen */
6343 wake_up_process(mddev->sync_thread->tsk);
6344
6345 mddev_unlock(mddev);
6346 wait_event(resync_wait, (mddev->sync_thread == NULL &&
6347 !test_bit(MD_RECOVERY_RUNNING,
6348 &mddev->recovery)));
6349 mddev_lock_nointr(mddev);
6350
6351 mutex_lock(&mddev->open_mutex);
6352 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
6353 mddev->sysfs_active ||
6354 mddev->sync_thread ||
6355 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
6356 pr_warn("md: %s still in use.\n",mdname(mddev));
6357 mutex_unlock(&mddev->open_mutex);
6358 if (did_freeze) {
6359 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6360 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6361 md_wakeup_thread(mddev->thread);
6362 }
6363 return -EBUSY;
6364 }
6365 if (mddev->pers) {
6366 if (!md_is_rdwr(mddev))
6367 set_disk_ro(disk, 0);
6368
6369 __md_stop_writes(mddev);
6370 __md_stop(mddev);
6371
6372 /* tell userspace to handle 'inactive' */
6373 sysfs_notify_dirent_safe(mddev->sysfs_state);
6374
6375 rdev_for_each(rdev, mddev)
6376 if (rdev->raid_disk >= 0)
6377 sysfs_unlink_rdev(mddev, rdev);
6378
6379 set_capacity_and_notify(disk, 0);
6380 mutex_unlock(&mddev->open_mutex);
6381 mddev->changed = 1;
6382
6383 if (!md_is_rdwr(mddev))
6384 mddev->ro = MD_RDWR;
6385 } else
6386 mutex_unlock(&mddev->open_mutex);
6387 /*
6388 * Free resources if final stop
6389 */
6390 if (mode == 0) {
6391 pr_info("md: %s stopped.\n", mdname(mddev));
6392
6393 if (mddev->bitmap_info.file) {
6394 struct file *f = mddev->bitmap_info.file;
6395 spin_lock(&mddev->lock);
6396 mddev->bitmap_info.file = NULL;
6397 spin_unlock(&mddev->lock);
6398 fput(f);
6399 }
6400 mddev->bitmap_info.offset = 0;
6401
6402 export_array(mddev);
6403
6404 md_clean(mddev);
6405 if (mddev->hold_active == UNTIL_STOP)
6406 mddev->hold_active = 0;
6407 }
6408 md_new_event();
6409 sysfs_notify_dirent_safe(mddev->sysfs_state);
6410 return 0;
6411}
6412
6413#ifndef MODULE
6414static void autorun_array(struct mddev *mddev)
6415{
6416 struct md_rdev *rdev;
6417 int err;
6418
6419 if (list_empty(&mddev->disks))
6420 return;
6421
6422 pr_info("md: running: ");
6423
6424 rdev_for_each(rdev, mddev) {
6425 pr_cont("<%pg>", rdev->bdev);
6426 }
6427 pr_cont("\n");
6428
6429 err = do_md_run(mddev);
6430 if (err) {
6431 pr_warn("md: do_md_run() returned %d\n", err);
6432 do_md_stop(mddev, 0, NULL);
6433 }
6434}
6435
6436/*
6437 * lets try to run arrays based on all disks that have arrived
6438 * until now. (those are in pending_raid_disks)
6439 *
6440 * the method: pick the first pending disk, collect all disks with
6441 * the same UUID, remove all from the pending list and put them into
6442 * the 'same_array' list. Then order this list based on superblock
6443 * update time (freshest comes first), kick out 'old' disks and
6444 * compare superblocks. If everything's fine then run it.
6445 *
6446 * If "unit" is allocated, then bump its reference count
6447 */
6448static void autorun_devices(int part)
6449{
6450 struct md_rdev *rdev0, *rdev, *tmp;
6451 struct mddev *mddev;
6452
6453 pr_info("md: autorun ...\n");
6454 while (!list_empty(&pending_raid_disks)) {
6455 int unit;
6456 dev_t dev;
6457 LIST_HEAD(candidates);
6458 rdev0 = list_entry(pending_raid_disks.next,
6459 struct md_rdev, same_set);
6460
6461 pr_debug("md: considering %pg ...\n", rdev0->bdev);
6462 INIT_LIST_HEAD(&candidates);
6463 rdev_for_each_list(rdev, tmp, &pending_raid_disks)
6464 if (super_90_load(rdev, rdev0, 0) >= 0) {
6465 pr_debug("md: adding %pg ...\n",
6466 rdev->bdev);
6467 list_move(&rdev->same_set, &candidates);
6468 }
6469 /*
6470 * now we have a set of devices, with all of them having
6471 * mostly sane superblocks. It's time to allocate the
6472 * mddev.
6473 */
6474 if (part) {
6475 dev = MKDEV(mdp_major,
6476 rdev0->preferred_minor << MdpMinorShift);
6477 unit = MINOR(dev) >> MdpMinorShift;
6478 } else {
6479 dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
6480 unit = MINOR(dev);
6481 }
6482 if (rdev0->preferred_minor != unit) {
6483 pr_warn("md: unit number in %pg is bad: %d\n",
6484 rdev0->bdev, rdev0->preferred_minor);
6485 break;
6486 }
6487
6488 mddev = md_alloc(dev, NULL);
6489 if (IS_ERR(mddev))
6490 break;
6491
6492 if (mddev_lock(mddev))
6493 pr_warn("md: %s locked, cannot run\n", mdname(mddev));
6494 else if (mddev->raid_disks || mddev->major_version
6495 || !list_empty(&mddev->disks)) {
6496 pr_warn("md: %s already running, cannot run %pg\n",
6497 mdname(mddev), rdev0->bdev);
6498 mddev_unlock(mddev);
6499 } else {
6500 pr_debug("md: created %s\n", mdname(mddev));
6501 mddev->persistent = 1;
6502 rdev_for_each_list(rdev, tmp, &candidates) {
6503 list_del_init(&rdev->same_set);
6504 if (bind_rdev_to_array(rdev, mddev))
6505 export_rdev(rdev);
6506 }
6507 autorun_array(mddev);
6508 mddev_unlock(mddev);
6509 }
6510 /* on success, candidates will be empty, on error
6511 * it won't...
6512 */
6513 rdev_for_each_list(rdev, tmp, &candidates) {
6514 list_del_init(&rdev->same_set);
6515 export_rdev(rdev);
6516 }
6517 mddev_put(mddev);
6518 }
6519 pr_info("md: ... autorun DONE.\n");
6520}
6521#endif /* !MODULE */
6522
6523static int get_version(void __user *arg)
6524{
6525 mdu_version_t ver;
6526
6527 ver.major = MD_MAJOR_VERSION;
6528 ver.minor = MD_MINOR_VERSION;
6529 ver.patchlevel = MD_PATCHLEVEL_VERSION;
6530
6531 if (copy_to_user(arg, &ver, sizeof(ver)))
6532 return -EFAULT;
6533
6534 return 0;
6535}
6536
6537static int get_array_info(struct mddev *mddev, void __user *arg)
6538{
6539 mdu_array_info_t info;
6540 int nr,working,insync,failed,spare;
6541 struct md_rdev *rdev;
6542
6543 nr = working = insync = failed = spare = 0;
6544 rcu_read_lock();
6545 rdev_for_each_rcu(rdev, mddev) {
6546 nr++;
6547 if (test_bit(Faulty, &rdev->flags))
6548 failed++;
6549 else {
6550 working++;
6551 if (test_bit(In_sync, &rdev->flags))
6552 insync++;
6553 else if (test_bit(Journal, &rdev->flags))
6554 /* TODO: add journal count to md_u.h */
6555 ;
6556 else
6557 spare++;
6558 }
6559 }
6560 rcu_read_unlock();
6561
6562 info.major_version = mddev->major_version;
6563 info.minor_version = mddev->minor_version;
6564 info.patch_version = MD_PATCHLEVEL_VERSION;
6565 info.ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
6566 info.level = mddev->level;
6567 info.size = mddev->dev_sectors / 2;
6568 if (info.size != mddev->dev_sectors / 2) /* overflow */
6569 info.size = -1;
6570 info.nr_disks = nr;
6571 info.raid_disks = mddev->raid_disks;
6572 info.md_minor = mddev->md_minor;
6573 info.not_persistent= !mddev->persistent;
6574
6575 info.utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
6576 info.state = 0;
6577 if (mddev->in_sync)
6578 info.state = (1<<MD_SB_CLEAN);
6579 if (mddev->bitmap && mddev->bitmap_info.offset)
6580 info.state |= (1<<MD_SB_BITMAP_PRESENT);
6581 if (mddev_is_clustered(mddev))
6582 info.state |= (1<<MD_SB_CLUSTERED);
6583 info.active_disks = insync;
6584 info.working_disks = working;
6585 info.failed_disks = failed;
6586 info.spare_disks = spare;
6587
6588 info.layout = mddev->layout;
6589 info.chunk_size = mddev->chunk_sectors << 9;
6590
6591 if (copy_to_user(arg, &info, sizeof(info)))
6592 return -EFAULT;
6593
6594 return 0;
6595}
6596
6597static int get_bitmap_file(struct mddev *mddev, void __user * arg)
6598{
6599 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
6600 char *ptr;
6601 int err;
6602
6603 file = kzalloc(sizeof(*file), GFP_NOIO);
6604 if (!file)
6605 return -ENOMEM;
6606
6607 err = 0;
6608 spin_lock(&mddev->lock);
6609 /* bitmap enabled */
6610 if (mddev->bitmap_info.file) {
6611 ptr = file_path(mddev->bitmap_info.file, file->pathname,
6612 sizeof(file->pathname));
6613 if (IS_ERR(ptr))
6614 err = PTR_ERR(ptr);
6615 else
6616 memmove(file->pathname, ptr,
6617 sizeof(file->pathname)-(ptr-file->pathname));
6618 }
6619 spin_unlock(&mddev->lock);
6620
6621 if (err == 0 &&
6622 copy_to_user(arg, file, sizeof(*file)))
6623 err = -EFAULT;
6624
6625 kfree(file);
6626 return err;
6627}
6628
6629static int get_disk_info(struct mddev *mddev, void __user * arg)
6630{
6631 mdu_disk_info_t info;
6632 struct md_rdev *rdev;
6633
6634 if (copy_from_user(&info, arg, sizeof(info)))
6635 return -EFAULT;
6636
6637 rcu_read_lock();
6638 rdev = md_find_rdev_nr_rcu(mddev, info.number);
6639 if (rdev) {
6640 info.major = MAJOR(rdev->bdev->bd_dev);
6641 info.minor = MINOR(rdev->bdev->bd_dev);
6642 info.raid_disk = rdev->raid_disk;
6643 info.state = 0;
6644 if (test_bit(Faulty, &rdev->flags))
6645 info.state |= (1<<MD_DISK_FAULTY);
6646 else if (test_bit(In_sync, &rdev->flags)) {
6647 info.state |= (1<<MD_DISK_ACTIVE);
6648 info.state |= (1<<MD_DISK_SYNC);
6649 }
6650 if (test_bit(Journal, &rdev->flags))
6651 info.state |= (1<<MD_DISK_JOURNAL);
6652 if (test_bit(WriteMostly, &rdev->flags))
6653 info.state |= (1<<MD_DISK_WRITEMOSTLY);
6654 if (test_bit(FailFast, &rdev->flags))
6655 info.state |= (1<<MD_DISK_FAILFAST);
6656 } else {
6657 info.major = info.minor = 0;
6658 info.raid_disk = -1;
6659 info.state = (1<<MD_DISK_REMOVED);
6660 }
6661 rcu_read_unlock();
6662
6663 if (copy_to_user(arg, &info, sizeof(info)))
6664 return -EFAULT;
6665
6666 return 0;
6667}
6668
6669int md_add_new_disk(struct mddev *mddev, struct mdu_disk_info_s *info)
6670{
6671 struct md_rdev *rdev;
6672 dev_t dev = MKDEV(info->major,info->minor);
6673
6674 if (mddev_is_clustered(mddev) &&
6675 !(info->state & ((1 << MD_DISK_CLUSTER_ADD) | (1 << MD_DISK_CANDIDATE)))) {
6676 pr_warn("%s: Cannot add to clustered mddev.\n",
6677 mdname(mddev));
6678 return -EINVAL;
6679 }
6680
6681 if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
6682 return -EOVERFLOW;
6683
6684 if (!mddev->raid_disks) {
6685 int err;
6686 /* expecting a device which has a superblock */
6687 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
6688 if (IS_ERR(rdev)) {
6689 pr_warn("md: md_import_device returned %ld\n",
6690 PTR_ERR(rdev));
6691 return PTR_ERR(rdev);
6692 }
6693 if (!list_empty(&mddev->disks)) {
6694 struct md_rdev *rdev0
6695 = list_entry(mddev->disks.next,
6696 struct md_rdev, same_set);
6697 err = super_types[mddev->major_version]
6698 .load_super(rdev, rdev0, mddev->minor_version);
6699 if (err < 0) {
6700 pr_warn("md: %pg has different UUID to %pg\n",
6701 rdev->bdev,
6702 rdev0->bdev);
6703 export_rdev(rdev);
6704 return -EINVAL;
6705 }
6706 }
6707 err = bind_rdev_to_array(rdev, mddev);
6708 if (err)
6709 export_rdev(rdev);
6710 return err;
6711 }
6712
6713 /*
6714 * md_add_new_disk can be used once the array is assembled
6715 * to add "hot spares". They must already have a superblock
6716 * written
6717 */
6718 if (mddev->pers) {
6719 int err;
6720 if (!mddev->pers->hot_add_disk) {
6721 pr_warn("%s: personality does not support diskops!\n",
6722 mdname(mddev));
6723 return -EINVAL;
6724 }
6725 if (mddev->persistent)
6726 rdev = md_import_device(dev, mddev->major_version,
6727 mddev->minor_version);
6728 else
6729 rdev = md_import_device(dev, -1, -1);
6730 if (IS_ERR(rdev)) {
6731 pr_warn("md: md_import_device returned %ld\n",
6732 PTR_ERR(rdev));
6733 return PTR_ERR(rdev);
6734 }
6735 /* set saved_raid_disk if appropriate */
6736 if (!mddev->persistent) {
6737 if (info->state & (1<<MD_DISK_SYNC) &&
6738 info->raid_disk < mddev->raid_disks) {
6739 rdev->raid_disk = info->raid_disk;
6740 set_bit(In_sync, &rdev->flags);
6741 clear_bit(Bitmap_sync, &rdev->flags);
6742 } else
6743 rdev->raid_disk = -1;
6744 rdev->saved_raid_disk = rdev->raid_disk;
6745 } else
6746 super_types[mddev->major_version].
6747 validate_super(mddev, rdev);
6748 if ((info->state & (1<<MD_DISK_SYNC)) &&
6749 rdev->raid_disk != info->raid_disk) {
6750 /* This was a hot-add request, but events doesn't
6751 * match, so reject it.
6752 */
6753 export_rdev(rdev);
6754 return -EINVAL;
6755 }
6756
6757 clear_bit(In_sync, &rdev->flags); /* just to be sure */
6758 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
6759 set_bit(WriteMostly, &rdev->flags);
6760 else
6761 clear_bit(WriteMostly, &rdev->flags);
6762 if (info->state & (1<<MD_DISK_FAILFAST))
6763 set_bit(FailFast, &rdev->flags);
6764 else
6765 clear_bit(FailFast, &rdev->flags);
6766
6767 if (info->state & (1<<MD_DISK_JOURNAL)) {
6768 struct md_rdev *rdev2;
6769 bool has_journal = false;
6770
6771 /* make sure no existing journal disk */
6772 rdev_for_each(rdev2, mddev) {
6773 if (test_bit(Journal, &rdev2->flags)) {
6774 has_journal = true;
6775 break;
6776 }
6777 }
6778 if (has_journal || mddev->bitmap) {
6779 export_rdev(rdev);
6780 return -EBUSY;
6781 }
6782 set_bit(Journal, &rdev->flags);
6783 }
6784 /*
6785 * check whether the device shows up in other nodes
6786 */
6787 if (mddev_is_clustered(mddev)) {
6788 if (info->state & (1 << MD_DISK_CANDIDATE))
6789 set_bit(Candidate, &rdev->flags);
6790 else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) {
6791 /* --add initiated by this node */
6792 err = md_cluster_ops->add_new_disk(mddev, rdev);
6793 if (err) {
6794 export_rdev(rdev);
6795 return err;
6796 }
6797 }
6798 }
6799
6800 rdev->raid_disk = -1;
6801 err = bind_rdev_to_array(rdev, mddev);
6802
6803 if (err)
6804 export_rdev(rdev);
6805
6806 if (mddev_is_clustered(mddev)) {
6807 if (info->state & (1 << MD_DISK_CANDIDATE)) {
6808 if (!err) {
6809 err = md_cluster_ops->new_disk_ack(mddev,
6810 err == 0);
6811 if (err)
6812 md_kick_rdev_from_array(rdev);
6813 }
6814 } else {
6815 if (err)
6816 md_cluster_ops->add_new_disk_cancel(mddev);
6817 else
6818 err = add_bound_rdev(rdev);
6819 }
6820
6821 } else if (!err)
6822 err = add_bound_rdev(rdev);
6823
6824 return err;
6825 }
6826
6827 /* otherwise, md_add_new_disk is only allowed
6828 * for major_version==0 superblocks
6829 */
6830 if (mddev->major_version != 0) {
6831 pr_warn("%s: ADD_NEW_DISK not supported\n", mdname(mddev));
6832 return -EINVAL;
6833 }
6834
6835 if (!(info->state & (1<<MD_DISK_FAULTY))) {
6836 int err;
6837 rdev = md_import_device(dev, -1, 0);
6838 if (IS_ERR(rdev)) {
6839 pr_warn("md: error, md_import_device() returned %ld\n",
6840 PTR_ERR(rdev));
6841 return PTR_ERR(rdev);
6842 }
6843 rdev->desc_nr = info->number;
6844 if (info->raid_disk < mddev->raid_disks)
6845 rdev->raid_disk = info->raid_disk;
6846 else
6847 rdev->raid_disk = -1;
6848
6849 if (rdev->raid_disk < mddev->raid_disks)
6850 if (info->state & (1<<MD_DISK_SYNC))
6851 set_bit(In_sync, &rdev->flags);
6852
6853 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
6854 set_bit(WriteMostly, &rdev->flags);
6855 if (info->state & (1<<MD_DISK_FAILFAST))
6856 set_bit(FailFast, &rdev->flags);
6857
6858 if (!mddev->persistent) {
6859 pr_debug("md: nonpersistent superblock ...\n");
6860 rdev->sb_start = bdev_nr_sectors(rdev->bdev);
6861 } else
6862 rdev->sb_start = calc_dev_sboffset(rdev);
6863 rdev->sectors = rdev->sb_start;
6864
6865 err = bind_rdev_to_array(rdev, mddev);
6866 if (err) {
6867 export_rdev(rdev);
6868 return err;
6869 }
6870 }
6871
6872 return 0;
6873}
6874
6875static int hot_remove_disk(struct mddev *mddev, dev_t dev)
6876{
6877 struct md_rdev *rdev;
6878
6879 if (!mddev->pers)
6880 return -ENODEV;
6881
6882 rdev = find_rdev(mddev, dev);
6883 if (!rdev)
6884 return -ENXIO;
6885
6886 if (rdev->raid_disk < 0)
6887 goto kick_rdev;
6888
6889 clear_bit(Blocked, &rdev->flags);
6890 remove_and_add_spares(mddev, rdev);
6891
6892 if (rdev->raid_disk >= 0)
6893 goto busy;
6894
6895kick_rdev:
6896 if (mddev_is_clustered(mddev)) {
6897 if (md_cluster_ops->remove_disk(mddev, rdev))
6898 goto busy;
6899 }
6900
6901 md_kick_rdev_from_array(rdev);
6902 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
6903 if (mddev->thread)
6904 md_wakeup_thread(mddev->thread);
6905 else
6906 md_update_sb(mddev, 1);
6907 md_new_event();
6908
6909 return 0;
6910busy:
6911 pr_debug("md: cannot remove active disk %pg from %s ...\n",
6912 rdev->bdev, mdname(mddev));
6913 return -EBUSY;
6914}
6915
6916static int hot_add_disk(struct mddev *mddev, dev_t dev)
6917{
6918 int err;
6919 struct md_rdev *rdev;
6920
6921 if (!mddev->pers)
6922 return -ENODEV;
6923
6924 if (mddev->major_version != 0) {
6925 pr_warn("%s: HOT_ADD may only be used with version-0 superblocks.\n",
6926 mdname(mddev));
6927 return -EINVAL;
6928 }
6929 if (!mddev->pers->hot_add_disk) {
6930 pr_warn("%s: personality does not support diskops!\n",
6931 mdname(mddev));
6932 return -EINVAL;
6933 }
6934
6935 rdev = md_import_device(dev, -1, 0);
6936 if (IS_ERR(rdev)) {
6937 pr_warn("md: error, md_import_device() returned %ld\n",
6938 PTR_ERR(rdev));
6939 return -EINVAL;
6940 }
6941
6942 if (mddev->persistent)
6943 rdev->sb_start = calc_dev_sboffset(rdev);
6944 else
6945 rdev->sb_start = bdev_nr_sectors(rdev->bdev);
6946
6947 rdev->sectors = rdev->sb_start;
6948
6949 if (test_bit(Faulty, &rdev->flags)) {
6950 pr_warn("md: can not hot-add faulty %pg disk to %s!\n",
6951 rdev->bdev, mdname(mddev));
6952 err = -EINVAL;
6953 goto abort_export;
6954 }
6955
6956 clear_bit(In_sync, &rdev->flags);
6957 rdev->desc_nr = -1;
6958 rdev->saved_raid_disk = -1;
6959 err = bind_rdev_to_array(rdev, mddev);
6960 if (err)
6961 goto abort_export;
6962
6963 /*
6964 * The rest should better be atomic, we can have disk failures
6965 * noticed in interrupt contexts ...
6966 */
6967
6968 rdev->raid_disk = -1;
6969
6970 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
6971 if (!mddev->thread)
6972 md_update_sb(mddev, 1);
6973 /*
6974 * If the new disk does not support REQ_NOWAIT,
6975 * disable on the whole MD.
6976 */
6977 if (!bdev_nowait(rdev->bdev)) {
6978 pr_info("%s: Disabling nowait because %pg does not support nowait\n",
6979 mdname(mddev), rdev->bdev);
6980 blk_queue_flag_clear(QUEUE_FLAG_NOWAIT, mddev->queue);
6981 }
6982 /*
6983 * Kick recovery, maybe this spare has to be added to the
6984 * array immediately.
6985 */
6986 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6987 md_wakeup_thread(mddev->thread);
6988 md_new_event();
6989 return 0;
6990
6991abort_export:
6992 export_rdev(rdev);
6993 return err;
6994}
6995
6996static int set_bitmap_file(struct mddev *mddev, int fd)
6997{
6998 int err = 0;
6999
7000 if (mddev->pers) {
7001 if (!mddev->pers->quiesce || !mddev->thread)
7002 return -EBUSY;
7003 if (mddev->recovery || mddev->sync_thread)
7004 return -EBUSY;
7005 /* we should be able to change the bitmap.. */
7006 }
7007
7008 if (fd >= 0) {
7009 struct inode *inode;
7010 struct file *f;
7011
7012 if (mddev->bitmap || mddev->bitmap_info.file)
7013 return -EEXIST; /* cannot add when bitmap is present */
7014 f = fget(fd);
7015
7016 if (f == NULL) {
7017 pr_warn("%s: error: failed to get bitmap file\n",
7018 mdname(mddev));
7019 return -EBADF;
7020 }
7021
7022 inode = f->f_mapping->host;
7023 if (!S_ISREG(inode->i_mode)) {
7024 pr_warn("%s: error: bitmap file must be a regular file\n",
7025 mdname(mddev));
7026 err = -EBADF;
7027 } else if (!(f->f_mode & FMODE_WRITE)) {
7028 pr_warn("%s: error: bitmap file must open for write\n",
7029 mdname(mddev));
7030 err = -EBADF;
7031 } else if (atomic_read(&inode->i_writecount) != 1) {
7032 pr_warn("%s: error: bitmap file is already in use\n",
7033 mdname(mddev));
7034 err = -EBUSY;
7035 }
7036 if (err) {
7037 fput(f);
7038 return err;
7039 }
7040 mddev->bitmap_info.file = f;
7041 mddev->bitmap_info.offset = 0; /* file overrides offset */
7042 } else if (mddev->bitmap == NULL)
7043 return -ENOENT; /* cannot remove what isn't there */
7044 err = 0;
7045 if (mddev->pers) {
7046 if (fd >= 0) {
7047 struct bitmap *bitmap;
7048
7049 bitmap = md_bitmap_create(mddev, -1);
7050 mddev_suspend(mddev);
7051 if (!IS_ERR(bitmap)) {
7052 mddev->bitmap = bitmap;
7053 err = md_bitmap_load(mddev);
7054 } else
7055 err = PTR_ERR(bitmap);
7056 if (err) {
7057 md_bitmap_destroy(mddev);
7058 fd = -1;
7059 }
7060 mddev_resume(mddev);
7061 } else if (fd < 0) {
7062 mddev_suspend(mddev);
7063 md_bitmap_destroy(mddev);
7064 mddev_resume(mddev);
7065 }
7066 }
7067 if (fd < 0) {
7068 struct file *f = mddev->bitmap_info.file;
7069 if (f) {
7070 spin_lock(&mddev->lock);
7071 mddev->bitmap_info.file = NULL;
7072 spin_unlock(&mddev->lock);
7073 fput(f);
7074 }
7075 }
7076
7077 return err;
7078}
7079
7080/*
7081 * md_set_array_info is used two different ways
7082 * The original usage is when creating a new array.
7083 * In this usage, raid_disks is > 0 and it together with
7084 * level, size, not_persistent,layout,chunksize determine the
7085 * shape of the array.
7086 * This will always create an array with a type-0.90.0 superblock.
7087 * The newer usage is when assembling an array.
7088 * In this case raid_disks will be 0, and the major_version field is
7089 * use to determine which style super-blocks are to be found on the devices.
7090 * The minor and patch _version numbers are also kept incase the
7091 * super_block handler wishes to interpret them.
7092 */
7093int md_set_array_info(struct mddev *mddev, struct mdu_array_info_s *info)
7094{
7095 if (info->raid_disks == 0) {
7096 /* just setting version number for superblock loading */
7097 if (info->major_version < 0 ||
7098 info->major_version >= ARRAY_SIZE(super_types) ||
7099 super_types[info->major_version].name == NULL) {
7100 /* maybe try to auto-load a module? */
7101 pr_warn("md: superblock version %d not known\n",
7102 info->major_version);
7103 return -EINVAL;
7104 }
7105 mddev->major_version = info->major_version;
7106 mddev->minor_version = info->minor_version;
7107 mddev->patch_version = info->patch_version;
7108 mddev->persistent = !info->not_persistent;
7109 /* ensure mddev_put doesn't delete this now that there
7110 * is some minimal configuration.
7111 */
7112 mddev->ctime = ktime_get_real_seconds();
7113 return 0;
7114 }
7115 mddev->major_version = MD_MAJOR_VERSION;
7116 mddev->minor_version = MD_MINOR_VERSION;
7117 mddev->patch_version = MD_PATCHLEVEL_VERSION;
7118 mddev->ctime = ktime_get_real_seconds();
7119
7120 mddev->level = info->level;
7121 mddev->clevel[0] = 0;
7122 mddev->dev_sectors = 2 * (sector_t)info->size;
7123 mddev->raid_disks = info->raid_disks;
7124 /* don't set md_minor, it is determined by which /dev/md* was
7125 * openned
7126 */
7127 if (info->state & (1<<MD_SB_CLEAN))
7128 mddev->recovery_cp = MaxSector;
7129 else
7130 mddev->recovery_cp = 0;
7131 mddev->persistent = ! info->not_persistent;
7132 mddev->external = 0;
7133
7134 mddev->layout = info->layout;
7135 if (mddev->level == 0)
7136 /* Cannot trust RAID0 layout info here */
7137 mddev->layout = -1;
7138 mddev->chunk_sectors = info->chunk_size >> 9;
7139
7140 if (mddev->persistent) {
7141 mddev->max_disks = MD_SB_DISKS;
7142 mddev->flags = 0;
7143 mddev->sb_flags = 0;
7144 }
7145 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
7146
7147 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
7148 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
7149 mddev->bitmap_info.offset = 0;
7150
7151 mddev->reshape_position = MaxSector;
7152
7153 /*
7154 * Generate a 128 bit UUID
7155 */
7156 get_random_bytes(mddev->uuid, 16);
7157
7158 mddev->new_level = mddev->level;
7159 mddev->new_chunk_sectors = mddev->chunk_sectors;
7160 mddev->new_layout = mddev->layout;
7161 mddev->delta_disks = 0;
7162 mddev->reshape_backwards = 0;
7163
7164 return 0;
7165}
7166
7167void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
7168{
7169 lockdep_assert_held(&mddev->reconfig_mutex);
7170
7171 if (mddev->external_size)
7172 return;
7173
7174 mddev->array_sectors = array_sectors;
7175}
7176EXPORT_SYMBOL(md_set_array_sectors);
7177
7178static int update_size(struct mddev *mddev, sector_t num_sectors)
7179{
7180 struct md_rdev *rdev;
7181 int rv;
7182 int fit = (num_sectors == 0);
7183 sector_t old_dev_sectors = mddev->dev_sectors;
7184
7185 if (mddev->pers->resize == NULL)
7186 return -EINVAL;
7187 /* The "num_sectors" is the number of sectors of each device that
7188 * is used. This can only make sense for arrays with redundancy.
7189 * linear and raid0 always use whatever space is available. We can only
7190 * consider changing this number if no resync or reconstruction is
7191 * happening, and if the new size is acceptable. It must fit before the
7192 * sb_start or, if that is <data_offset, it must fit before the size
7193 * of each device. If num_sectors is zero, we find the largest size
7194 * that fits.
7195 */
7196 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
7197 mddev->sync_thread)
7198 return -EBUSY;
7199 if (!md_is_rdwr(mddev))
7200 return -EROFS;
7201
7202 rdev_for_each(rdev, mddev) {
7203 sector_t avail = rdev->sectors;
7204
7205 if (fit && (num_sectors == 0 || num_sectors > avail))
7206 num_sectors = avail;
7207 if (avail < num_sectors)
7208 return -ENOSPC;
7209 }
7210 rv = mddev->pers->resize(mddev, num_sectors);
7211 if (!rv) {
7212 if (mddev_is_clustered(mddev))
7213 md_cluster_ops->update_size(mddev, old_dev_sectors);
7214 else if (mddev->queue) {
7215 set_capacity_and_notify(mddev->gendisk,
7216 mddev->array_sectors);
7217 }
7218 }
7219 return rv;
7220}
7221
7222static int update_raid_disks(struct mddev *mddev, int raid_disks)
7223{
7224 int rv;
7225 struct md_rdev *rdev;
7226 /* change the number of raid disks */
7227 if (mddev->pers->check_reshape == NULL)
7228 return -EINVAL;
7229 if (!md_is_rdwr(mddev))
7230 return -EROFS;
7231 if (raid_disks <= 0 ||
7232 (mddev->max_disks && raid_disks >= mddev->max_disks))
7233 return -EINVAL;
7234 if (mddev->sync_thread ||
7235 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
7236 test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) ||
7237 mddev->reshape_position != MaxSector)
7238 return -EBUSY;
7239
7240 rdev_for_each(rdev, mddev) {
7241 if (mddev->raid_disks < raid_disks &&
7242 rdev->data_offset < rdev->new_data_offset)
7243 return -EINVAL;
7244 if (mddev->raid_disks > raid_disks &&
7245 rdev->data_offset > rdev->new_data_offset)
7246 return -EINVAL;
7247 }
7248
7249 mddev->delta_disks = raid_disks - mddev->raid_disks;
7250 if (mddev->delta_disks < 0)
7251 mddev->reshape_backwards = 1;
7252 else if (mddev->delta_disks > 0)
7253 mddev->reshape_backwards = 0;
7254
7255 rv = mddev->pers->check_reshape(mddev);
7256 if (rv < 0) {
7257 mddev->delta_disks = 0;
7258 mddev->reshape_backwards = 0;
7259 }
7260 return rv;
7261}
7262
7263/*
7264 * update_array_info is used to change the configuration of an
7265 * on-line array.
7266 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
7267 * fields in the info are checked against the array.
7268 * Any differences that cannot be handled will cause an error.
7269 * Normally, only one change can be managed at a time.
7270 */
7271static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
7272{
7273 int rv = 0;
7274 int cnt = 0;
7275 int state = 0;
7276
7277 /* calculate expected state,ignoring low bits */
7278 if (mddev->bitmap && mddev->bitmap_info.offset)
7279 state |= (1 << MD_SB_BITMAP_PRESENT);
7280
7281 if (mddev->major_version != info->major_version ||
7282 mddev->minor_version != info->minor_version ||
7283/* mddev->patch_version != info->patch_version || */
7284 mddev->ctime != info->ctime ||
7285 mddev->level != info->level ||
7286/* mddev->layout != info->layout || */
7287 mddev->persistent != !info->not_persistent ||
7288 mddev->chunk_sectors != info->chunk_size >> 9 ||
7289 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
7290 ((state^info->state) & 0xfffffe00)
7291 )
7292 return -EINVAL;
7293 /* Check there is only one change */
7294 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
7295 cnt++;
7296 if (mddev->raid_disks != info->raid_disks)
7297 cnt++;
7298 if (mddev->layout != info->layout)
7299 cnt++;
7300 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
7301 cnt++;
7302 if (cnt == 0)
7303 return 0;
7304 if (cnt > 1)
7305 return -EINVAL;
7306
7307 if (mddev->layout != info->layout) {
7308 /* Change layout
7309 * we don't need to do anything at the md level, the
7310 * personality will take care of it all.
7311 */
7312 if (mddev->pers->check_reshape == NULL)
7313 return -EINVAL;
7314 else {
7315 mddev->new_layout = info->layout;
7316 rv = mddev->pers->check_reshape(mddev);
7317 if (rv)
7318 mddev->new_layout = mddev->layout;
7319 return rv;
7320 }
7321 }
7322 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
7323 rv = update_size(mddev, (sector_t)info->size * 2);
7324
7325 if (mddev->raid_disks != info->raid_disks)
7326 rv = update_raid_disks(mddev, info->raid_disks);
7327
7328 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
7329 if (mddev->pers->quiesce == NULL || mddev->thread == NULL) {
7330 rv = -EINVAL;
7331 goto err;
7332 }
7333 if (mddev->recovery || mddev->sync_thread) {
7334 rv = -EBUSY;
7335 goto err;
7336 }
7337 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
7338 struct bitmap *bitmap;
7339 /* add the bitmap */
7340 if (mddev->bitmap) {
7341 rv = -EEXIST;
7342 goto err;
7343 }
7344 if (mddev->bitmap_info.default_offset == 0) {
7345 rv = -EINVAL;
7346 goto err;
7347 }
7348 mddev->bitmap_info.offset =
7349 mddev->bitmap_info.default_offset;
7350 mddev->bitmap_info.space =
7351 mddev->bitmap_info.default_space;
7352 bitmap = md_bitmap_create(mddev, -1);
7353 mddev_suspend(mddev);
7354 if (!IS_ERR(bitmap)) {
7355 mddev->bitmap = bitmap;
7356 rv = md_bitmap_load(mddev);
7357 } else
7358 rv = PTR_ERR(bitmap);
7359 if (rv)
7360 md_bitmap_destroy(mddev);
7361 mddev_resume(mddev);
7362 } else {
7363 /* remove the bitmap */
7364 if (!mddev->bitmap) {
7365 rv = -ENOENT;
7366 goto err;
7367 }
7368 if (mddev->bitmap->storage.file) {
7369 rv = -EINVAL;
7370 goto err;
7371 }
7372 if (mddev->bitmap_info.nodes) {
7373 /* hold PW on all the bitmap lock */
7374 if (md_cluster_ops->lock_all_bitmaps(mddev) <= 0) {
7375 pr_warn("md: can't change bitmap to none since the array is in use by more than one node\n");
7376 rv = -EPERM;
7377 md_cluster_ops->unlock_all_bitmaps(mddev);
7378 goto err;
7379 }
7380
7381 mddev->bitmap_info.nodes = 0;
7382 md_cluster_ops->leave(mddev);
7383 module_put(md_cluster_mod);
7384 mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;
7385 }
7386 mddev_suspend(mddev);
7387 md_bitmap_destroy(mddev);
7388 mddev_resume(mddev);
7389 mddev->bitmap_info.offset = 0;
7390 }
7391 }
7392 md_update_sb(mddev, 1);
7393 return rv;
7394err:
7395 return rv;
7396}
7397
7398static int set_disk_faulty(struct mddev *mddev, dev_t dev)
7399{
7400 struct md_rdev *rdev;
7401 int err = 0;
7402
7403 if (mddev->pers == NULL)
7404 return -ENODEV;
7405
7406 rcu_read_lock();
7407 rdev = md_find_rdev_rcu(mddev, dev);
7408 if (!rdev)
7409 err = -ENODEV;
7410 else {
7411 md_error(mddev, rdev);
7412 if (test_bit(MD_BROKEN, &mddev->flags))
7413 err = -EBUSY;
7414 }
7415 rcu_read_unlock();
7416 return err;
7417}
7418
7419/*
7420 * We have a problem here : there is no easy way to give a CHS
7421 * virtual geometry. We currently pretend that we have a 2 heads
7422 * 4 sectors (with a BIG number of cylinders...). This drives
7423 * dosfs just mad... ;-)
7424 */
7425static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
7426{
7427 struct mddev *mddev = bdev->bd_disk->private_data;
7428
7429 geo->heads = 2;
7430 geo->sectors = 4;
7431 geo->cylinders = mddev->array_sectors / 8;
7432 return 0;
7433}
7434
7435static inline bool md_ioctl_valid(unsigned int cmd)
7436{
7437 switch (cmd) {
7438 case ADD_NEW_DISK:
7439 case GET_ARRAY_INFO:
7440 case GET_BITMAP_FILE:
7441 case GET_DISK_INFO:
7442 case HOT_ADD_DISK:
7443 case HOT_REMOVE_DISK:
7444 case RAID_VERSION:
7445 case RESTART_ARRAY_RW:
7446 case RUN_ARRAY:
7447 case SET_ARRAY_INFO:
7448 case SET_BITMAP_FILE:
7449 case SET_DISK_FAULTY:
7450 case STOP_ARRAY:
7451 case STOP_ARRAY_RO:
7452 case CLUSTERED_DISK_NACK:
7453 return true;
7454 default:
7455 return false;
7456 }
7457}
7458
7459static int __md_set_array_info(struct mddev *mddev, void __user *argp)
7460{
7461 mdu_array_info_t info;
7462 int err;
7463
7464 if (!argp)
7465 memset(&info, 0, sizeof(info));
7466 else if (copy_from_user(&info, argp, sizeof(info)))
7467 return -EFAULT;
7468
7469 if (mddev->pers) {
7470 err = update_array_info(mddev, &info);
7471 if (err)
7472 pr_warn("md: couldn't update array info. %d\n", err);
7473 return err;
7474 }
7475
7476 if (!list_empty(&mddev->disks)) {
7477 pr_warn("md: array %s already has disks!\n", mdname(mddev));
7478 return -EBUSY;
7479 }
7480
7481 if (mddev->raid_disks) {
7482 pr_warn("md: array %s already initialised!\n", mdname(mddev));
7483 return -EBUSY;
7484 }
7485
7486 err = md_set_array_info(mddev, &info);
7487 if (err)
7488 pr_warn("md: couldn't set array info. %d\n", err);
7489
7490 return err;
7491}
7492
7493static int md_ioctl(struct block_device *bdev, fmode_t mode,
7494 unsigned int cmd, unsigned long arg)
7495{
7496 int err = 0;
7497 void __user *argp = (void __user *)arg;
7498 struct mddev *mddev = NULL;
7499 bool did_set_md_closing = false;
7500
7501 if (!md_ioctl_valid(cmd))
7502 return -ENOTTY;
7503
7504 switch (cmd) {
7505 case RAID_VERSION:
7506 case GET_ARRAY_INFO:
7507 case GET_DISK_INFO:
7508 break;
7509 default:
7510 if (!capable(CAP_SYS_ADMIN))
7511 return -EACCES;
7512 }
7513
7514 /*
7515 * Commands dealing with the RAID driver but not any
7516 * particular array:
7517 */
7518 switch (cmd) {
7519 case RAID_VERSION:
7520 err = get_version(argp);
7521 goto out;
7522 default:;
7523 }
7524
7525 /*
7526 * Commands creating/starting a new array:
7527 */
7528
7529 mddev = bdev->bd_disk->private_data;
7530
7531 if (!mddev) {
7532 BUG();
7533 goto out;
7534 }
7535
7536 /* Some actions do not requires the mutex */
7537 switch (cmd) {
7538 case GET_ARRAY_INFO:
7539 if (!mddev->raid_disks && !mddev->external)
7540 err = -ENODEV;
7541 else
7542 err = get_array_info(mddev, argp);
7543 goto out;
7544
7545 case GET_DISK_INFO:
7546 if (!mddev->raid_disks && !mddev->external)
7547 err = -ENODEV;
7548 else
7549 err = get_disk_info(mddev, argp);
7550 goto out;
7551
7552 case SET_DISK_FAULTY:
7553 err = set_disk_faulty(mddev, new_decode_dev(arg));
7554 goto out;
7555
7556 case GET_BITMAP_FILE:
7557 err = get_bitmap_file(mddev, argp);
7558 goto out;
7559
7560 }
7561
7562 if (cmd == ADD_NEW_DISK || cmd == HOT_ADD_DISK)
7563 flush_rdev_wq(mddev);
7564
7565 if (cmd == HOT_REMOVE_DISK)
7566 /* need to ensure recovery thread has run */
7567 wait_event_interruptible_timeout(mddev->sb_wait,
7568 !test_bit(MD_RECOVERY_NEEDED,
7569 &mddev->recovery),
7570 msecs_to_jiffies(5000));
7571 if (cmd == STOP_ARRAY || cmd == STOP_ARRAY_RO) {
7572 /* Need to flush page cache, and ensure no-one else opens
7573 * and writes
7574 */
7575 mutex_lock(&mddev->open_mutex);
7576 if (mddev->pers && atomic_read(&mddev->openers) > 1) {
7577 mutex_unlock(&mddev->open_mutex);
7578 err = -EBUSY;
7579 goto out;
7580 }
7581 if (test_and_set_bit(MD_CLOSING, &mddev->flags)) {
7582 mutex_unlock(&mddev->open_mutex);
7583 err = -EBUSY;
7584 goto out;
7585 }
7586 did_set_md_closing = true;
7587 mutex_unlock(&mddev->open_mutex);
7588 sync_blockdev(bdev);
7589 }
7590 err = mddev_lock(mddev);
7591 if (err) {
7592 pr_debug("md: ioctl lock interrupted, reason %d, cmd %d\n",
7593 err, cmd);
7594 goto out;
7595 }
7596
7597 if (cmd == SET_ARRAY_INFO) {
7598 err = __md_set_array_info(mddev, argp);
7599 goto unlock;
7600 }
7601
7602 /*
7603 * Commands querying/configuring an existing array:
7604 */
7605 /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
7606 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
7607 if ((!mddev->raid_disks && !mddev->external)
7608 && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
7609 && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
7610 && cmd != GET_BITMAP_FILE) {
7611 err = -ENODEV;
7612 goto unlock;
7613 }
7614
7615 /*
7616 * Commands even a read-only array can execute:
7617 */
7618 switch (cmd) {
7619 case RESTART_ARRAY_RW:
7620 err = restart_array(mddev);
7621 goto unlock;
7622
7623 case STOP_ARRAY:
7624 err = do_md_stop(mddev, 0, bdev);
7625 goto unlock;
7626
7627 case STOP_ARRAY_RO:
7628 err = md_set_readonly(mddev, bdev);
7629 goto unlock;
7630
7631 case HOT_REMOVE_DISK:
7632 err = hot_remove_disk(mddev, new_decode_dev(arg));
7633 goto unlock;
7634
7635 case ADD_NEW_DISK:
7636 /* We can support ADD_NEW_DISK on read-only arrays
7637 * only if we are re-adding a preexisting device.
7638 * So require mddev->pers and MD_DISK_SYNC.
7639 */
7640 if (mddev->pers) {
7641 mdu_disk_info_t info;
7642 if (copy_from_user(&info, argp, sizeof(info)))
7643 err = -EFAULT;
7644 else if (!(info.state & (1<<MD_DISK_SYNC)))
7645 /* Need to clear read-only for this */
7646 break;
7647 else
7648 err = md_add_new_disk(mddev, &info);
7649 goto unlock;
7650 }
7651 break;
7652 }
7653
7654 /*
7655 * The remaining ioctls are changing the state of the
7656 * superblock, so we do not allow them on read-only arrays.
7657 */
7658 if (!md_is_rdwr(mddev) && mddev->pers) {
7659 if (mddev->ro != MD_AUTO_READ) {
7660 err = -EROFS;
7661 goto unlock;
7662 }
7663 mddev->ro = MD_RDWR;
7664 sysfs_notify_dirent_safe(mddev->sysfs_state);
7665 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7666 /* mddev_unlock will wake thread */
7667 /* If a device failed while we were read-only, we
7668 * need to make sure the metadata is updated now.
7669 */
7670 if (test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)) {
7671 mddev_unlock(mddev);
7672 wait_event(mddev->sb_wait,
7673 !test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags) &&
7674 !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
7675 mddev_lock_nointr(mddev);
7676 }
7677 }
7678
7679 switch (cmd) {
7680 case ADD_NEW_DISK:
7681 {
7682 mdu_disk_info_t info;
7683 if (copy_from_user(&info, argp, sizeof(info)))
7684 err = -EFAULT;
7685 else
7686 err = md_add_new_disk(mddev, &info);
7687 goto unlock;
7688 }
7689
7690 case CLUSTERED_DISK_NACK:
7691 if (mddev_is_clustered(mddev))
7692 md_cluster_ops->new_disk_ack(mddev, false);
7693 else
7694 err = -EINVAL;
7695 goto unlock;
7696
7697 case HOT_ADD_DISK:
7698 err = hot_add_disk(mddev, new_decode_dev(arg));
7699 goto unlock;
7700
7701 case RUN_ARRAY:
7702 err = do_md_run(mddev);
7703 goto unlock;
7704
7705 case SET_BITMAP_FILE:
7706 err = set_bitmap_file(mddev, (int)arg);
7707 goto unlock;
7708
7709 default:
7710 err = -EINVAL;
7711 goto unlock;
7712 }
7713
7714unlock:
7715 if (mddev->hold_active == UNTIL_IOCTL &&
7716 err != -EINVAL)
7717 mddev->hold_active = 0;
7718 mddev_unlock(mddev);
7719out:
7720 if(did_set_md_closing)
7721 clear_bit(MD_CLOSING, &mddev->flags);
7722 return err;
7723}
7724#ifdef CONFIG_COMPAT
7725static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
7726 unsigned int cmd, unsigned long arg)
7727{
7728 switch (cmd) {
7729 case HOT_REMOVE_DISK:
7730 case HOT_ADD_DISK:
7731 case SET_DISK_FAULTY:
7732 case SET_BITMAP_FILE:
7733 /* These take in integer arg, do not convert */
7734 break;
7735 default:
7736 arg = (unsigned long)compat_ptr(arg);
7737 break;
7738 }
7739
7740 return md_ioctl(bdev, mode, cmd, arg);
7741}
7742#endif /* CONFIG_COMPAT */
7743
7744static int md_set_read_only(struct block_device *bdev, bool ro)
7745{
7746 struct mddev *mddev = bdev->bd_disk->private_data;
7747 int err;
7748
7749 err = mddev_lock(mddev);
7750 if (err)
7751 return err;
7752
7753 if (!mddev->raid_disks && !mddev->external) {
7754 err = -ENODEV;
7755 goto out_unlock;
7756 }
7757
7758 /*
7759 * Transitioning to read-auto need only happen for arrays that call
7760 * md_write_start and which are not ready for writes yet.
7761 */
7762 if (!ro && mddev->ro == MD_RDONLY && mddev->pers) {
7763 err = restart_array(mddev);
7764 if (err)
7765 goto out_unlock;
7766 mddev->ro = MD_AUTO_READ;
7767 }
7768
7769out_unlock:
7770 mddev_unlock(mddev);
7771 return err;
7772}
7773
7774static int md_open(struct block_device *bdev, fmode_t mode)
7775{
7776 struct mddev *mddev;
7777 int err;
7778
7779 spin_lock(&all_mddevs_lock);
7780 mddev = mddev_get(bdev->bd_disk->private_data);
7781 spin_unlock(&all_mddevs_lock);
7782 if (!mddev)
7783 return -ENODEV;
7784
7785 err = mutex_lock_interruptible(&mddev->open_mutex);
7786 if (err)
7787 goto out;
7788
7789 err = -ENODEV;
7790 if (test_bit(MD_CLOSING, &mddev->flags))
7791 goto out_unlock;
7792
7793 atomic_inc(&mddev->openers);
7794 mutex_unlock(&mddev->open_mutex);
7795
7796 bdev_check_media_change(bdev);
7797 return 0;
7798
7799out_unlock:
7800 mutex_unlock(&mddev->open_mutex);
7801out:
7802 mddev_put(mddev);
7803 return err;
7804}
7805
7806static void md_release(struct gendisk *disk, fmode_t mode)
7807{
7808 struct mddev *mddev = disk->private_data;
7809
7810 BUG_ON(!mddev);
7811 atomic_dec(&mddev->openers);
7812 mddev_put(mddev);
7813}
7814
7815static unsigned int md_check_events(struct gendisk *disk, unsigned int clearing)
7816{
7817 struct mddev *mddev = disk->private_data;
7818 unsigned int ret = 0;
7819
7820 if (mddev->changed)
7821 ret = DISK_EVENT_MEDIA_CHANGE;
7822 mddev->changed = 0;
7823 return ret;
7824}
7825
7826static void md_free_disk(struct gendisk *disk)
7827{
7828 struct mddev *mddev = disk->private_data;
7829
7830 percpu_ref_exit(&mddev->writes_pending);
7831 bioset_exit(&mddev->bio_set);
7832 bioset_exit(&mddev->sync_set);
7833
7834 mddev_free(mddev);
7835}
7836
7837const struct block_device_operations md_fops =
7838{
7839 .owner = THIS_MODULE,
7840 .submit_bio = md_submit_bio,
7841 .open = md_open,
7842 .release = md_release,
7843 .ioctl = md_ioctl,
7844#ifdef CONFIG_COMPAT
7845 .compat_ioctl = md_compat_ioctl,
7846#endif
7847 .getgeo = md_getgeo,
7848 .check_events = md_check_events,
7849 .set_read_only = md_set_read_only,
7850 .free_disk = md_free_disk,
7851};
7852
7853static int md_thread(void *arg)
7854{
7855 struct md_thread *thread = arg;
7856
7857 /*
7858 * md_thread is a 'system-thread', it's priority should be very
7859 * high. We avoid resource deadlocks individually in each
7860 * raid personality. (RAID5 does preallocation) We also use RR and
7861 * the very same RT priority as kswapd, thus we will never get
7862 * into a priority inversion deadlock.
7863 *
7864 * we definitely have to have equal or higher priority than
7865 * bdflush, otherwise bdflush will deadlock if there are too
7866 * many dirty RAID5 blocks.
7867 */
7868
7869 allow_signal(SIGKILL);
7870 while (!kthread_should_stop()) {
7871
7872 /* We need to wait INTERRUPTIBLE so that
7873 * we don't add to the load-average.
7874 * That means we need to be sure no signals are
7875 * pending
7876 */
7877 if (signal_pending(current))
7878 flush_signals(current);
7879
7880 wait_event_interruptible_timeout
7881 (thread->wqueue,
7882 test_bit(THREAD_WAKEUP, &thread->flags)
7883 || kthread_should_stop() || kthread_should_park(),
7884 thread->timeout);
7885
7886 clear_bit(THREAD_WAKEUP, &thread->flags);
7887 if (kthread_should_park())
7888 kthread_parkme();
7889 if (!kthread_should_stop())
7890 thread->run(thread);
7891 }
7892
7893 return 0;
7894}
7895
7896void md_wakeup_thread(struct md_thread *thread)
7897{
7898 if (thread) {
7899 pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
7900 set_bit(THREAD_WAKEUP, &thread->flags);
7901 wake_up(&thread->wqueue);
7902 }
7903}
7904EXPORT_SYMBOL(md_wakeup_thread);
7905
7906struct md_thread *md_register_thread(void (*run) (struct md_thread *),
7907 struct mddev *mddev, const char *name)
7908{
7909 struct md_thread *thread;
7910
7911 thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
7912 if (!thread)
7913 return NULL;
7914
7915 init_waitqueue_head(&thread->wqueue);
7916
7917 thread->run = run;
7918 thread->mddev = mddev;
7919 thread->timeout = MAX_SCHEDULE_TIMEOUT;
7920 thread->tsk = kthread_run(md_thread, thread,
7921 "%s_%s",
7922 mdname(thread->mddev),
7923 name);
7924 if (IS_ERR(thread->tsk)) {
7925 kfree(thread);
7926 return NULL;
7927 }
7928 return thread;
7929}
7930EXPORT_SYMBOL(md_register_thread);
7931
7932void md_unregister_thread(struct md_thread **threadp)
7933{
7934 struct md_thread *thread;
7935
7936 /*
7937 * Locking ensures that mddev_unlock does not wake_up a
7938 * non-existent thread
7939 */
7940 spin_lock(&pers_lock);
7941 thread = *threadp;
7942 if (!thread) {
7943 spin_unlock(&pers_lock);
7944 return;
7945 }
7946 *threadp = NULL;
7947 spin_unlock(&pers_lock);
7948
7949 pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
7950 kthread_stop(thread->tsk);
7951 kfree(thread);
7952}
7953EXPORT_SYMBOL(md_unregister_thread);
7954
7955void md_error(struct mddev *mddev, struct md_rdev *rdev)
7956{
7957 if (!rdev || test_bit(Faulty, &rdev->flags))
7958 return;
7959
7960 if (!mddev->pers || !mddev->pers->error_handler)
7961 return;
7962 mddev->pers->error_handler(mddev, rdev);
7963
7964 if (mddev->degraded && !test_bit(MD_BROKEN, &mddev->flags))
7965 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7966 sysfs_notify_dirent_safe(rdev->sysfs_state);
7967 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7968 if (!test_bit(MD_BROKEN, &mddev->flags)) {
7969 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7970 md_wakeup_thread(mddev->thread);
7971 }
7972 if (mddev->event_work.func)
7973 queue_work(md_misc_wq, &mddev->event_work);
7974 md_new_event();
7975}
7976EXPORT_SYMBOL(md_error);
7977
7978/* seq_file implementation /proc/mdstat */
7979
7980static void status_unused(struct seq_file *seq)
7981{
7982 int i = 0;
7983 struct md_rdev *rdev;
7984
7985 seq_printf(seq, "unused devices: ");
7986
7987 list_for_each_entry(rdev, &pending_raid_disks, same_set) {
7988 i++;
7989 seq_printf(seq, "%pg ", rdev->bdev);
7990 }
7991 if (!i)
7992 seq_printf(seq, "<none>");
7993
7994 seq_printf(seq, "\n");
7995}
7996
7997static int status_resync(struct seq_file *seq, struct mddev *mddev)
7998{
7999 sector_t max_sectors, resync, res;
8000 unsigned long dt, db = 0;
8001 sector_t rt, curr_mark_cnt, resync_mark_cnt;
8002 int scale, recovery_active;
8003 unsigned int per_milli;
8004
8005 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
8006 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
8007 max_sectors = mddev->resync_max_sectors;
8008 else
8009 max_sectors = mddev->dev_sectors;
8010
8011 resync = mddev->curr_resync;
8012 if (resync < MD_RESYNC_ACTIVE) {
8013 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
8014 /* Still cleaning up */
8015 resync = max_sectors;
8016 } else if (resync > max_sectors) {
8017 resync = max_sectors;
8018 } else {
8019 resync -= atomic_read(&mddev->recovery_active);
8020 if (resync < MD_RESYNC_ACTIVE) {
8021 /*
8022 * Resync has started, but the subtraction has
8023 * yielded one of the special values. Force it
8024 * to active to ensure the status reports an
8025 * active resync.
8026 */
8027 resync = MD_RESYNC_ACTIVE;
8028 }
8029 }
8030
8031 if (resync == MD_RESYNC_NONE) {
8032 if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery)) {
8033 struct md_rdev *rdev;
8034
8035 rdev_for_each(rdev, mddev)
8036 if (rdev->raid_disk >= 0 &&
8037 !test_bit(Faulty, &rdev->flags) &&
8038 rdev->recovery_offset != MaxSector &&
8039 rdev->recovery_offset) {
8040 seq_printf(seq, "\trecover=REMOTE");
8041 return 1;
8042 }
8043 if (mddev->reshape_position != MaxSector)
8044 seq_printf(seq, "\treshape=REMOTE");
8045 else
8046 seq_printf(seq, "\tresync=REMOTE");
8047 return 1;
8048 }
8049 if (mddev->recovery_cp < MaxSector) {
8050 seq_printf(seq, "\tresync=PENDING");
8051 return 1;
8052 }
8053 return 0;
8054 }
8055 if (resync < MD_RESYNC_ACTIVE) {
8056 seq_printf(seq, "\tresync=DELAYED");
8057 return 1;
8058 }
8059
8060 WARN_ON(max_sectors == 0);
8061 /* Pick 'scale' such that (resync>>scale)*1000 will fit
8062 * in a sector_t, and (max_sectors>>scale) will fit in a
8063 * u32, as those are the requirements for sector_div.
8064 * Thus 'scale' must be at least 10
8065 */
8066 scale = 10;
8067 if (sizeof(sector_t) > sizeof(unsigned long)) {
8068 while ( max_sectors/2 > (1ULL<<(scale+32)))
8069 scale++;
8070 }
8071 res = (resync>>scale)*1000;
8072 sector_div(res, (u32)((max_sectors>>scale)+1));
8073
8074 per_milli = res;
8075 {
8076 int i, x = per_milli/50, y = 20-x;
8077 seq_printf(seq, "[");
8078 for (i = 0; i < x; i++)
8079 seq_printf(seq, "=");
8080 seq_printf(seq, ">");
8081 for (i = 0; i < y; i++)
8082 seq_printf(seq, ".");
8083 seq_printf(seq, "] ");
8084 }
8085 seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
8086 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
8087 "reshape" :
8088 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
8089 "check" :
8090 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
8091 "resync" : "recovery"))),
8092 per_milli/10, per_milli % 10,
8093 (unsigned long long) resync/2,
8094 (unsigned long long) max_sectors/2);
8095
8096 /*
8097 * dt: time from mark until now
8098 * db: blocks written from mark until now
8099 * rt: remaining time
8100 *
8101 * rt is a sector_t, which is always 64bit now. We are keeping
8102 * the original algorithm, but it is not really necessary.
8103 *
8104 * Original algorithm:
8105 * So we divide before multiply in case it is 32bit and close
8106 * to the limit.
8107 * We scale the divisor (db) by 32 to avoid losing precision
8108 * near the end of resync when the number of remaining sectors
8109 * is close to 'db'.
8110 * We then divide rt by 32 after multiplying by db to compensate.
8111 * The '+1' avoids division by zero if db is very small.
8112 */
8113 dt = ((jiffies - mddev->resync_mark) / HZ);
8114 if (!dt) dt++;
8115
8116 curr_mark_cnt = mddev->curr_mark_cnt;
8117 recovery_active = atomic_read(&mddev->recovery_active);
8118 resync_mark_cnt = mddev->resync_mark_cnt;
8119
8120 if (curr_mark_cnt >= (recovery_active + resync_mark_cnt))
8121 db = curr_mark_cnt - (recovery_active + resync_mark_cnt);
8122
8123 rt = max_sectors - resync; /* number of remaining sectors */
8124 rt = div64_u64(rt, db/32+1);
8125 rt *= dt;
8126 rt >>= 5;
8127
8128 seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
8129 ((unsigned long)rt % 60)/6);
8130
8131 seq_printf(seq, " speed=%ldK/sec", db/2/dt);
8132 return 1;
8133}
8134
8135static void *md_seq_start(struct seq_file *seq, loff_t *pos)
8136{
8137 struct list_head *tmp;
8138 loff_t l = *pos;
8139 struct mddev *mddev;
8140
8141 if (l == 0x10000) {
8142 ++*pos;
8143 return (void *)2;
8144 }
8145 if (l > 0x10000)
8146 return NULL;
8147 if (!l--)
8148 /* header */
8149 return (void*)1;
8150
8151 spin_lock(&all_mddevs_lock);
8152 list_for_each(tmp,&all_mddevs)
8153 if (!l--) {
8154 mddev = list_entry(tmp, struct mddev, all_mddevs);
8155 if (!mddev_get(mddev))
8156 continue;
8157 spin_unlock(&all_mddevs_lock);
8158 return mddev;
8159 }
8160 spin_unlock(&all_mddevs_lock);
8161 if (!l--)
8162 return (void*)2;/* tail */
8163 return NULL;
8164}
8165
8166static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
8167{
8168 struct list_head *tmp;
8169 struct mddev *next_mddev, *mddev = v;
8170 struct mddev *to_put = NULL;
8171
8172 ++*pos;
8173 if (v == (void*)2)
8174 return NULL;
8175
8176 spin_lock(&all_mddevs_lock);
8177 if (v == (void*)1) {
8178 tmp = all_mddevs.next;
8179 } else {
8180 to_put = mddev;
8181 tmp = mddev->all_mddevs.next;
8182 }
8183
8184 for (;;) {
8185 if (tmp == &all_mddevs) {
8186 next_mddev = (void*)2;
8187 *pos = 0x10000;
8188 break;
8189 }
8190 next_mddev = list_entry(tmp, struct mddev, all_mddevs);
8191 if (mddev_get(next_mddev))
8192 break;
8193 mddev = next_mddev;
8194 tmp = mddev->all_mddevs.next;
8195 }
8196 spin_unlock(&all_mddevs_lock);
8197
8198 if (to_put)
8199 mddev_put(mddev);
8200 return next_mddev;
8201
8202}
8203
8204static void md_seq_stop(struct seq_file *seq, void *v)
8205{
8206 struct mddev *mddev = v;
8207
8208 if (mddev && v != (void*)1 && v != (void*)2)
8209 mddev_put(mddev);
8210}
8211
8212static int md_seq_show(struct seq_file *seq, void *v)
8213{
8214 struct mddev *mddev = v;
8215 sector_t sectors;
8216 struct md_rdev *rdev;
8217
8218 if (v == (void*)1) {
8219 struct md_personality *pers;
8220 seq_printf(seq, "Personalities : ");
8221 spin_lock(&pers_lock);
8222 list_for_each_entry(pers, &pers_list, list)
8223 seq_printf(seq, "[%s] ", pers->name);
8224
8225 spin_unlock(&pers_lock);
8226 seq_printf(seq, "\n");
8227 seq->poll_event = atomic_read(&md_event_count);
8228 return 0;
8229 }
8230 if (v == (void*)2) {
8231 status_unused(seq);
8232 return 0;
8233 }
8234
8235 spin_lock(&mddev->lock);
8236 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
8237 seq_printf(seq, "%s : %sactive", mdname(mddev),
8238 mddev->pers ? "" : "in");
8239 if (mddev->pers) {
8240 if (mddev->ro == MD_RDONLY)
8241 seq_printf(seq, " (read-only)");
8242 if (mddev->ro == MD_AUTO_READ)
8243 seq_printf(seq, " (auto-read-only)");
8244 seq_printf(seq, " %s", mddev->pers->name);
8245 }
8246
8247 sectors = 0;
8248 rcu_read_lock();
8249 rdev_for_each_rcu(rdev, mddev) {
8250 seq_printf(seq, " %pg[%d]", rdev->bdev, rdev->desc_nr);
8251
8252 if (test_bit(WriteMostly, &rdev->flags))
8253 seq_printf(seq, "(W)");
8254 if (test_bit(Journal, &rdev->flags))
8255 seq_printf(seq, "(J)");
8256 if (test_bit(Faulty, &rdev->flags)) {
8257 seq_printf(seq, "(F)");
8258 continue;
8259 }
8260 if (rdev->raid_disk < 0)
8261 seq_printf(seq, "(S)"); /* spare */
8262 if (test_bit(Replacement, &rdev->flags))
8263 seq_printf(seq, "(R)");
8264 sectors += rdev->sectors;
8265 }
8266 rcu_read_unlock();
8267
8268 if (!list_empty(&mddev->disks)) {
8269 if (mddev->pers)
8270 seq_printf(seq, "\n %llu blocks",
8271 (unsigned long long)
8272 mddev->array_sectors / 2);
8273 else
8274 seq_printf(seq, "\n %llu blocks",
8275 (unsigned long long)sectors / 2);
8276 }
8277 if (mddev->persistent) {
8278 if (mddev->major_version != 0 ||
8279 mddev->minor_version != 90) {
8280 seq_printf(seq," super %d.%d",
8281 mddev->major_version,
8282 mddev->minor_version);
8283 }
8284 } else if (mddev->external)
8285 seq_printf(seq, " super external:%s",
8286 mddev->metadata_type);
8287 else
8288 seq_printf(seq, " super non-persistent");
8289
8290 if (mddev->pers) {
8291 mddev->pers->status(seq, mddev);
8292 seq_printf(seq, "\n ");
8293 if (mddev->pers->sync_request) {
8294 if (status_resync(seq, mddev))
8295 seq_printf(seq, "\n ");
8296 }
8297 } else
8298 seq_printf(seq, "\n ");
8299
8300 md_bitmap_status(seq, mddev->bitmap);
8301
8302 seq_printf(seq, "\n");
8303 }
8304 spin_unlock(&mddev->lock);
8305
8306 return 0;
8307}
8308
8309static const struct seq_operations md_seq_ops = {
8310 .start = md_seq_start,
8311 .next = md_seq_next,
8312 .stop = md_seq_stop,
8313 .show = md_seq_show,
8314};
8315
8316static int md_seq_open(struct inode *inode, struct file *file)
8317{
8318 struct seq_file *seq;
8319 int error;
8320
8321 error = seq_open(file, &md_seq_ops);
8322 if (error)
8323 return error;
8324
8325 seq = file->private_data;
8326 seq->poll_event = atomic_read(&md_event_count);
8327 return error;
8328}
8329
8330static int md_unloading;
8331static __poll_t mdstat_poll(struct file *filp, poll_table *wait)
8332{
8333 struct seq_file *seq = filp->private_data;
8334 __poll_t mask;
8335
8336 if (md_unloading)
8337 return EPOLLIN|EPOLLRDNORM|EPOLLERR|EPOLLPRI;
8338 poll_wait(filp, &md_event_waiters, wait);
8339
8340 /* always allow read */
8341 mask = EPOLLIN | EPOLLRDNORM;
8342
8343 if (seq->poll_event != atomic_read(&md_event_count))
8344 mask |= EPOLLERR | EPOLLPRI;
8345 return mask;
8346}
8347
8348static const struct proc_ops mdstat_proc_ops = {
8349 .proc_open = md_seq_open,
8350 .proc_read = seq_read,
8351 .proc_lseek = seq_lseek,
8352 .proc_release = seq_release,
8353 .proc_poll = mdstat_poll,
8354};
8355
8356int register_md_personality(struct md_personality *p)
8357{
8358 pr_debug("md: %s personality registered for level %d\n",
8359 p->name, p->level);
8360 spin_lock(&pers_lock);
8361 list_add_tail(&p->list, &pers_list);
8362 spin_unlock(&pers_lock);
8363 return 0;
8364}
8365EXPORT_SYMBOL(register_md_personality);
8366
8367int unregister_md_personality(struct md_personality *p)
8368{
8369 pr_debug("md: %s personality unregistered\n", p->name);
8370 spin_lock(&pers_lock);
8371 list_del_init(&p->list);
8372 spin_unlock(&pers_lock);
8373 return 0;
8374}
8375EXPORT_SYMBOL(unregister_md_personality);
8376
8377int register_md_cluster_operations(struct md_cluster_operations *ops,
8378 struct module *module)
8379{
8380 int ret = 0;
8381 spin_lock(&pers_lock);
8382 if (md_cluster_ops != NULL)
8383 ret = -EALREADY;
8384 else {
8385 md_cluster_ops = ops;
8386 md_cluster_mod = module;
8387 }
8388 spin_unlock(&pers_lock);
8389 return ret;
8390}
8391EXPORT_SYMBOL(register_md_cluster_operations);
8392
8393int unregister_md_cluster_operations(void)
8394{
8395 spin_lock(&pers_lock);
8396 md_cluster_ops = NULL;
8397 spin_unlock(&pers_lock);
8398 return 0;
8399}
8400EXPORT_SYMBOL(unregister_md_cluster_operations);
8401
8402int md_setup_cluster(struct mddev *mddev, int nodes)
8403{
8404 int ret;
8405 if (!md_cluster_ops)
8406 request_module("md-cluster");
8407 spin_lock(&pers_lock);
8408 /* ensure module won't be unloaded */
8409 if (!md_cluster_ops || !try_module_get(md_cluster_mod)) {
8410 pr_warn("can't find md-cluster module or get its reference.\n");
8411 spin_unlock(&pers_lock);
8412 return -ENOENT;
8413 }
8414 spin_unlock(&pers_lock);
8415
8416 ret = md_cluster_ops->join(mddev, nodes);
8417 if (!ret)
8418 mddev->safemode_delay = 0;
8419 return ret;
8420}
8421
8422void md_cluster_stop(struct mddev *mddev)
8423{
8424 if (!md_cluster_ops)
8425 return;
8426 md_cluster_ops->leave(mddev);
8427 module_put(md_cluster_mod);
8428}
8429
8430static int is_mddev_idle(struct mddev *mddev, int init)
8431{
8432 struct md_rdev *rdev;
8433 int idle;
8434 int curr_events;
8435
8436 idle = 1;
8437 rcu_read_lock();
8438 rdev_for_each_rcu(rdev, mddev) {
8439 struct gendisk *disk = rdev->bdev->bd_disk;
8440 curr_events = (int)part_stat_read_accum(disk->part0, sectors) -
8441 atomic_read(&disk->sync_io);
8442 /* sync IO will cause sync_io to increase before the disk_stats
8443 * as sync_io is counted when a request starts, and
8444 * disk_stats is counted when it completes.
8445 * So resync activity will cause curr_events to be smaller than
8446 * when there was no such activity.
8447 * non-sync IO will cause disk_stat to increase without
8448 * increasing sync_io so curr_events will (eventually)
8449 * be larger than it was before. Once it becomes
8450 * substantially larger, the test below will cause
8451 * the array to appear non-idle, and resync will slow
8452 * down.
8453 * If there is a lot of outstanding resync activity when
8454 * we set last_event to curr_events, then all that activity
8455 * completing might cause the array to appear non-idle
8456 * and resync will be slowed down even though there might
8457 * not have been non-resync activity. This will only
8458 * happen once though. 'last_events' will soon reflect
8459 * the state where there is little or no outstanding
8460 * resync requests, and further resync activity will
8461 * always make curr_events less than last_events.
8462 *
8463 */
8464 if (init || curr_events - rdev->last_events > 64) {
8465 rdev->last_events = curr_events;
8466 idle = 0;
8467 }
8468 }
8469 rcu_read_unlock();
8470 return idle;
8471}
8472
8473void md_done_sync(struct mddev *mddev, int blocks, int ok)
8474{
8475 /* another "blocks" (512byte) blocks have been synced */
8476 atomic_sub(blocks, &mddev->recovery_active);
8477 wake_up(&mddev->recovery_wait);
8478 if (!ok) {
8479 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8480 set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
8481 md_wakeup_thread(mddev->thread);
8482 // stop recovery, signal do_sync ....
8483 }
8484}
8485EXPORT_SYMBOL(md_done_sync);
8486
8487/* md_write_start(mddev, bi)
8488 * If we need to update some array metadata (e.g. 'active' flag
8489 * in superblock) before writing, schedule a superblock update
8490 * and wait for it to complete.
8491 * A return value of 'false' means that the write wasn't recorded
8492 * and cannot proceed as the array is being suspend.
8493 */
8494bool md_write_start(struct mddev *mddev, struct bio *bi)
8495{
8496 int did_change = 0;
8497
8498 if (bio_data_dir(bi) != WRITE)
8499 return true;
8500
8501 BUG_ON(mddev->ro == MD_RDONLY);
8502 if (mddev->ro == MD_AUTO_READ) {
8503 /* need to switch to read/write */
8504 mddev->ro = MD_RDWR;
8505 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8506 md_wakeup_thread(mddev->thread);
8507 md_wakeup_thread(mddev->sync_thread);
8508 did_change = 1;
8509 }
8510 rcu_read_lock();
8511 percpu_ref_get(&mddev->writes_pending);
8512 smp_mb(); /* Match smp_mb in set_in_sync() */
8513 if (mddev->safemode == 1)
8514 mddev->safemode = 0;
8515 /* sync_checkers is always 0 when writes_pending is in per-cpu mode */
8516 if (mddev->in_sync || mddev->sync_checkers) {
8517 spin_lock(&mddev->lock);
8518 if (mddev->in_sync) {
8519 mddev->in_sync = 0;
8520 set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
8521 set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
8522 md_wakeup_thread(mddev->thread);
8523 did_change = 1;
8524 }
8525 spin_unlock(&mddev->lock);
8526 }
8527 rcu_read_unlock();
8528 if (did_change)
8529 sysfs_notify_dirent_safe(mddev->sysfs_state);
8530 if (!mddev->has_superblocks)
8531 return true;
8532 wait_event(mddev->sb_wait,
8533 !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags) ||
8534 mddev->suspended);
8535 if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) {
8536 percpu_ref_put(&mddev->writes_pending);
8537 return false;
8538 }
8539 return true;
8540}
8541EXPORT_SYMBOL(md_write_start);
8542
8543/* md_write_inc can only be called when md_write_start() has
8544 * already been called at least once of the current request.
8545 * It increments the counter and is useful when a single request
8546 * is split into several parts. Each part causes an increment and
8547 * so needs a matching md_write_end().
8548 * Unlike md_write_start(), it is safe to call md_write_inc() inside
8549 * a spinlocked region.
8550 */
8551void md_write_inc(struct mddev *mddev, struct bio *bi)
8552{
8553 if (bio_data_dir(bi) != WRITE)
8554 return;
8555 WARN_ON_ONCE(mddev->in_sync || !md_is_rdwr(mddev));
8556 percpu_ref_get(&mddev->writes_pending);
8557}
8558EXPORT_SYMBOL(md_write_inc);
8559
8560void md_write_end(struct mddev *mddev)
8561{
8562 percpu_ref_put(&mddev->writes_pending);
8563
8564 if (mddev->safemode == 2)
8565 md_wakeup_thread(mddev->thread);
8566 else if (mddev->safemode_delay)
8567 /* The roundup() ensures this only performs locking once
8568 * every ->safemode_delay jiffies
8569 */
8570 mod_timer(&mddev->safemode_timer,
8571 roundup(jiffies, mddev->safemode_delay) +
8572 mddev->safemode_delay);
8573}
8574
8575EXPORT_SYMBOL(md_write_end);
8576
8577/* This is used by raid0 and raid10 */
8578void md_submit_discard_bio(struct mddev *mddev, struct md_rdev *rdev,
8579 struct bio *bio, sector_t start, sector_t size)
8580{
8581 struct bio *discard_bio = NULL;
8582
8583 if (__blkdev_issue_discard(rdev->bdev, start, size, GFP_NOIO,
8584 &discard_bio) || !discard_bio)
8585 return;
8586
8587 bio_chain(discard_bio, bio);
8588 bio_clone_blkg_association(discard_bio, bio);
8589 if (mddev->gendisk)
8590 trace_block_bio_remap(discard_bio,
8591 disk_devt(mddev->gendisk),
8592 bio->bi_iter.bi_sector);
8593 submit_bio_noacct(discard_bio);
8594}
8595EXPORT_SYMBOL_GPL(md_submit_discard_bio);
8596
8597int acct_bioset_init(struct mddev *mddev)
8598{
8599 int err = 0;
8600
8601 if (!bioset_initialized(&mddev->io_acct_set))
8602 err = bioset_init(&mddev->io_acct_set, BIO_POOL_SIZE,
8603 offsetof(struct md_io_acct, bio_clone), 0);
8604 return err;
8605}
8606EXPORT_SYMBOL_GPL(acct_bioset_init);
8607
8608void acct_bioset_exit(struct mddev *mddev)
8609{
8610 bioset_exit(&mddev->io_acct_set);
8611}
8612EXPORT_SYMBOL_GPL(acct_bioset_exit);
8613
8614static void md_end_io_acct(struct bio *bio)
8615{
8616 struct md_io_acct *md_io_acct = bio->bi_private;
8617 struct bio *orig_bio = md_io_acct->orig_bio;
8618
8619 orig_bio->bi_status = bio->bi_status;
8620
8621 bio_end_io_acct(orig_bio, md_io_acct->start_time);
8622 bio_put(bio);
8623 bio_endio(orig_bio);
8624}
8625
8626/*
8627 * Used by personalities that don't already clone the bio and thus can't
8628 * easily add the timestamp to their extended bio structure.
8629 */
8630void md_account_bio(struct mddev *mddev, struct bio **bio)
8631{
8632 struct block_device *bdev = (*bio)->bi_bdev;
8633 struct md_io_acct *md_io_acct;
8634 struct bio *clone;
8635
8636 if (!blk_queue_io_stat(bdev->bd_disk->queue))
8637 return;
8638
8639 clone = bio_alloc_clone(bdev, *bio, GFP_NOIO, &mddev->io_acct_set);
8640 md_io_acct = container_of(clone, struct md_io_acct, bio_clone);
8641 md_io_acct->orig_bio = *bio;
8642 md_io_acct->start_time = bio_start_io_acct(*bio);
8643
8644 clone->bi_end_io = md_end_io_acct;
8645 clone->bi_private = md_io_acct;
8646 *bio = clone;
8647}
8648EXPORT_SYMBOL_GPL(md_account_bio);
8649
8650/* md_allow_write(mddev)
8651 * Calling this ensures that the array is marked 'active' so that writes
8652 * may proceed without blocking. It is important to call this before
8653 * attempting a GFP_KERNEL allocation while holding the mddev lock.
8654 * Must be called with mddev_lock held.
8655 */
8656void md_allow_write(struct mddev *mddev)
8657{
8658 if (!mddev->pers)
8659 return;
8660 if (!md_is_rdwr(mddev))
8661 return;
8662 if (!mddev->pers->sync_request)
8663 return;
8664
8665 spin_lock(&mddev->lock);
8666 if (mddev->in_sync) {
8667 mddev->in_sync = 0;
8668 set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
8669 set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
8670 if (mddev->safemode_delay &&
8671 mddev->safemode == 0)
8672 mddev->safemode = 1;
8673 spin_unlock(&mddev->lock);
8674 md_update_sb(mddev, 0);
8675 sysfs_notify_dirent_safe(mddev->sysfs_state);
8676 /* wait for the dirty state to be recorded in the metadata */
8677 wait_event(mddev->sb_wait,
8678 !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
8679 } else
8680 spin_unlock(&mddev->lock);
8681}
8682EXPORT_SYMBOL_GPL(md_allow_write);
8683
8684#define SYNC_MARKS 10
8685#define SYNC_MARK_STEP (3*HZ)
8686#define UPDATE_FREQUENCY (5*60*HZ)
8687void md_do_sync(struct md_thread *thread)
8688{
8689 struct mddev *mddev = thread->mddev;
8690 struct mddev *mddev2;
8691 unsigned int currspeed = 0, window;
8692 sector_t max_sectors,j, io_sectors, recovery_done;
8693 unsigned long mark[SYNC_MARKS];
8694 unsigned long update_time;
8695 sector_t mark_cnt[SYNC_MARKS];
8696 int last_mark,m;
8697 sector_t last_check;
8698 int skipped = 0;
8699 struct md_rdev *rdev;
8700 char *desc, *action = NULL;
8701 struct blk_plug plug;
8702 int ret;
8703
8704 /* just incase thread restarts... */
8705 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
8706 test_bit(MD_RECOVERY_WAIT, &mddev->recovery))
8707 return;
8708 if (!md_is_rdwr(mddev)) {/* never try to sync a read-only array */
8709 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8710 return;
8711 }
8712
8713 if (mddev_is_clustered(mddev)) {
8714 ret = md_cluster_ops->resync_start(mddev);
8715 if (ret)
8716 goto skip;
8717
8718 set_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags);
8719 if (!(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
8720 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ||
8721 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
8722 && ((unsigned long long)mddev->curr_resync_completed
8723 < (unsigned long long)mddev->resync_max_sectors))
8724 goto skip;
8725 }
8726
8727 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8728 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
8729 desc = "data-check";
8730 action = "check";
8731 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
8732 desc = "requested-resync";
8733 action = "repair";
8734 } else
8735 desc = "resync";
8736 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
8737 desc = "reshape";
8738 else
8739 desc = "recovery";
8740
8741 mddev->last_sync_action = action ?: desc;
8742
8743 /*
8744 * Before starting a resync we must have set curr_resync to
8745 * 2, and then checked that every "conflicting" array has curr_resync
8746 * less than ours. When we find one that is the same or higher
8747 * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
8748 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
8749 * This will mean we have to start checking from the beginning again.
8750 *
8751 */
8752
8753 do {
8754 int mddev2_minor = -1;
8755 mddev->curr_resync = MD_RESYNC_DELAYED;
8756
8757 try_again:
8758 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8759 goto skip;
8760 spin_lock(&all_mddevs_lock);
8761 list_for_each_entry(mddev2, &all_mddevs, all_mddevs) {
8762 if (test_bit(MD_DELETED, &mddev2->flags))
8763 continue;
8764 if (mddev2 == mddev)
8765 continue;
8766 if (!mddev->parallel_resync
8767 && mddev2->curr_resync
8768 && match_mddev_units(mddev, mddev2)) {
8769 DEFINE_WAIT(wq);
8770 if (mddev < mddev2 &&
8771 mddev->curr_resync == MD_RESYNC_DELAYED) {
8772 /* arbitrarily yield */
8773 mddev->curr_resync = MD_RESYNC_YIELDED;
8774 wake_up(&resync_wait);
8775 }
8776 if (mddev > mddev2 &&
8777 mddev->curr_resync == MD_RESYNC_YIELDED)
8778 /* no need to wait here, we can wait the next
8779 * time 'round when curr_resync == 2
8780 */
8781 continue;
8782 /* We need to wait 'interruptible' so as not to
8783 * contribute to the load average, and not to
8784 * be caught by 'softlockup'
8785 */
8786 prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
8787 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8788 mddev2->curr_resync >= mddev->curr_resync) {
8789 if (mddev2_minor != mddev2->md_minor) {
8790 mddev2_minor = mddev2->md_minor;
8791 pr_info("md: delaying %s of %s until %s has finished (they share one or more physical units)\n",
8792 desc, mdname(mddev),
8793 mdname(mddev2));
8794 }
8795 spin_unlock(&all_mddevs_lock);
8796
8797 if (signal_pending(current))
8798 flush_signals(current);
8799 schedule();
8800 finish_wait(&resync_wait, &wq);
8801 goto try_again;
8802 }
8803 finish_wait(&resync_wait, &wq);
8804 }
8805 }
8806 spin_unlock(&all_mddevs_lock);
8807 } while (mddev->curr_resync < MD_RESYNC_DELAYED);
8808
8809 j = 0;
8810 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8811 /* resync follows the size requested by the personality,
8812 * which defaults to physical size, but can be virtual size
8813 */
8814 max_sectors = mddev->resync_max_sectors;
8815 atomic64_set(&mddev->resync_mismatches, 0);
8816 /* we don't use the checkpoint if there's a bitmap */
8817 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8818 j = mddev->resync_min;
8819 else if (!mddev->bitmap)
8820 j = mddev->recovery_cp;
8821
8822 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
8823 max_sectors = mddev->resync_max_sectors;
8824 /*
8825 * If the original node aborts reshaping then we continue the
8826 * reshaping, so set j again to avoid restart reshape from the
8827 * first beginning
8828 */
8829 if (mddev_is_clustered(mddev) &&
8830 mddev->reshape_position != MaxSector)
8831 j = mddev->reshape_position;
8832 } else {
8833 /* recovery follows the physical size of devices */
8834 max_sectors = mddev->dev_sectors;
8835 j = MaxSector;
8836 rcu_read_lock();
8837 rdev_for_each_rcu(rdev, mddev)
8838 if (rdev->raid_disk >= 0 &&
8839 !test_bit(Journal, &rdev->flags) &&
8840 !test_bit(Faulty, &rdev->flags) &&
8841 !test_bit(In_sync, &rdev->flags) &&
8842 rdev->recovery_offset < j)
8843 j = rdev->recovery_offset;
8844 rcu_read_unlock();
8845
8846 /* If there is a bitmap, we need to make sure all
8847 * writes that started before we added a spare
8848 * complete before we start doing a recovery.
8849 * Otherwise the write might complete and (via
8850 * bitmap_endwrite) set a bit in the bitmap after the
8851 * recovery has checked that bit and skipped that
8852 * region.
8853 */
8854 if (mddev->bitmap) {
8855 mddev->pers->quiesce(mddev, 1);
8856 mddev->pers->quiesce(mddev, 0);
8857 }
8858 }
8859
8860 pr_info("md: %s of RAID array %s\n", desc, mdname(mddev));
8861 pr_debug("md: minimum _guaranteed_ speed: %d KB/sec/disk.\n", speed_min(mddev));
8862 pr_debug("md: using maximum available idle IO bandwidth (but not more than %d KB/sec) for %s.\n",
8863 speed_max(mddev), desc);
8864
8865 is_mddev_idle(mddev, 1); /* this initializes IO event counters */
8866
8867 io_sectors = 0;
8868 for (m = 0; m < SYNC_MARKS; m++) {
8869 mark[m] = jiffies;
8870 mark_cnt[m] = io_sectors;
8871 }
8872 last_mark = 0;
8873 mddev->resync_mark = mark[last_mark];
8874 mddev->resync_mark_cnt = mark_cnt[last_mark];
8875
8876 /*
8877 * Tune reconstruction:
8878 */
8879 window = 32 * (PAGE_SIZE / 512);
8880 pr_debug("md: using %dk window, over a total of %lluk.\n",
8881 window/2, (unsigned long long)max_sectors/2);
8882
8883 atomic_set(&mddev->recovery_active, 0);
8884 last_check = 0;
8885
8886 if (j>2) {
8887 pr_debug("md: resuming %s of %s from checkpoint.\n",
8888 desc, mdname(mddev));
8889 mddev->curr_resync = j;
8890 } else
8891 mddev->curr_resync = MD_RESYNC_ACTIVE; /* no longer delayed */
8892 mddev->curr_resync_completed = j;
8893 sysfs_notify_dirent_safe(mddev->sysfs_completed);
8894 md_new_event();
8895 update_time = jiffies;
8896
8897 blk_start_plug(&plug);
8898 while (j < max_sectors) {
8899 sector_t sectors;
8900
8901 skipped = 0;
8902
8903 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8904 ((mddev->curr_resync > mddev->curr_resync_completed &&
8905 (mddev->curr_resync - mddev->curr_resync_completed)
8906 > (max_sectors >> 4)) ||
8907 time_after_eq(jiffies, update_time + UPDATE_FREQUENCY) ||
8908 (j - mddev->curr_resync_completed)*2
8909 >= mddev->resync_max - mddev->curr_resync_completed ||
8910 mddev->curr_resync_completed > mddev->resync_max
8911 )) {
8912 /* time to update curr_resync_completed */
8913 wait_event(mddev->recovery_wait,
8914 atomic_read(&mddev->recovery_active) == 0);
8915 mddev->curr_resync_completed = j;
8916 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
8917 j > mddev->recovery_cp)
8918 mddev->recovery_cp = j;
8919 update_time = jiffies;
8920 set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
8921 sysfs_notify_dirent_safe(mddev->sysfs_completed);
8922 }
8923
8924 while (j >= mddev->resync_max &&
8925 !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8926 /* As this condition is controlled by user-space,
8927 * we can block indefinitely, so use '_interruptible'
8928 * to avoid triggering warnings.
8929 */
8930 flush_signals(current); /* just in case */
8931 wait_event_interruptible(mddev->recovery_wait,
8932 mddev->resync_max > j
8933 || test_bit(MD_RECOVERY_INTR,
8934 &mddev->recovery));
8935 }
8936
8937 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8938 break;
8939
8940 sectors = mddev->pers->sync_request(mddev, j, &skipped);
8941 if (sectors == 0) {
8942 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8943 break;
8944 }
8945
8946 if (!skipped) { /* actual IO requested */
8947 io_sectors += sectors;
8948 atomic_add(sectors, &mddev->recovery_active);
8949 }
8950
8951 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8952 break;
8953
8954 j += sectors;
8955 if (j > max_sectors)
8956 /* when skipping, extra large numbers can be returned. */
8957 j = max_sectors;
8958 if (j > 2)
8959 mddev->curr_resync = j;
8960 mddev->curr_mark_cnt = io_sectors;
8961 if (last_check == 0)
8962 /* this is the earliest that rebuild will be
8963 * visible in /proc/mdstat
8964 */
8965 md_new_event();
8966
8967 if (last_check + window > io_sectors || j == max_sectors)
8968 continue;
8969
8970 last_check = io_sectors;
8971 repeat:
8972 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
8973 /* step marks */
8974 int next = (last_mark+1) % SYNC_MARKS;
8975
8976 mddev->resync_mark = mark[next];
8977 mddev->resync_mark_cnt = mark_cnt[next];
8978 mark[next] = jiffies;
8979 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
8980 last_mark = next;
8981 }
8982
8983 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8984 break;
8985
8986 /*
8987 * this loop exits only if either when we are slower than
8988 * the 'hard' speed limit, or the system was IO-idle for
8989 * a jiffy.
8990 * the system might be non-idle CPU-wise, but we only care
8991 * about not overloading the IO subsystem. (things like an
8992 * e2fsck being done on the RAID array should execute fast)
8993 */
8994 cond_resched();
8995
8996 recovery_done = io_sectors - atomic_read(&mddev->recovery_active);
8997 currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2
8998 /((jiffies-mddev->resync_mark)/HZ +1) +1;
8999
9000 if (currspeed > speed_min(mddev)) {
9001 if (currspeed > speed_max(mddev)) {
9002 msleep(500);
9003 goto repeat;
9004 }
9005 if (!is_mddev_idle(mddev, 0)) {
9006 /*
9007 * Give other IO more of a chance.
9008 * The faster the devices, the less we wait.
9009 */
9010 wait_event(mddev->recovery_wait,
9011 !atomic_read(&mddev->recovery_active));
9012 }
9013 }
9014 }
9015 pr_info("md: %s: %s %s.\n",mdname(mddev), desc,
9016 test_bit(MD_RECOVERY_INTR, &mddev->recovery)
9017 ? "interrupted" : "done");
9018 /*
9019 * this also signals 'finished resyncing' to md_stop
9020 */
9021 blk_finish_plug(&plug);
9022 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
9023
9024 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9025 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
9026 mddev->curr_resync >= MD_RESYNC_ACTIVE) {
9027 mddev->curr_resync_completed = mddev->curr_resync;
9028 sysfs_notify_dirent_safe(mddev->sysfs_completed);
9029 }
9030 mddev->pers->sync_request(mddev, max_sectors, &skipped);
9031
9032 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
9033 mddev->curr_resync >= MD_RESYNC_ACTIVE) {
9034 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
9035 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
9036 if (mddev->curr_resync >= mddev->recovery_cp) {
9037 pr_debug("md: checkpointing %s of %s.\n",
9038 desc, mdname(mddev));
9039 if (test_bit(MD_RECOVERY_ERROR,
9040 &mddev->recovery))
9041 mddev->recovery_cp =
9042 mddev->curr_resync_completed;
9043 else
9044 mddev->recovery_cp =
9045 mddev->curr_resync;
9046 }
9047 } else
9048 mddev->recovery_cp = MaxSector;
9049 } else {
9050 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
9051 mddev->curr_resync = MaxSector;
9052 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9053 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery)) {
9054 rcu_read_lock();
9055 rdev_for_each_rcu(rdev, mddev)
9056 if (rdev->raid_disk >= 0 &&
9057 mddev->delta_disks >= 0 &&
9058 !test_bit(Journal, &rdev->flags) &&
9059 !test_bit(Faulty, &rdev->flags) &&
9060 !test_bit(In_sync, &rdev->flags) &&
9061 rdev->recovery_offset < mddev->curr_resync)
9062 rdev->recovery_offset = mddev->curr_resync;
9063 rcu_read_unlock();
9064 }
9065 }
9066 }
9067 skip:
9068 /* set CHANGE_PENDING here since maybe another update is needed,
9069 * so other nodes are informed. It should be harmless for normal
9070 * raid */
9071 set_mask_bits(&mddev->sb_flags, 0,
9072 BIT(MD_SB_CHANGE_PENDING) | BIT(MD_SB_CHANGE_DEVS));
9073
9074 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9075 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
9076 mddev->delta_disks > 0 &&
9077 mddev->pers->finish_reshape &&
9078 mddev->pers->size &&
9079 mddev->queue) {
9080 mddev_lock_nointr(mddev);
9081 md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0));
9082 mddev_unlock(mddev);
9083 if (!mddev_is_clustered(mddev))
9084 set_capacity_and_notify(mddev->gendisk,
9085 mddev->array_sectors);
9086 }
9087
9088 spin_lock(&mddev->lock);
9089 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
9090 /* We completed so min/max setting can be forgotten if used. */
9091 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
9092 mddev->resync_min = 0;
9093 mddev->resync_max = MaxSector;
9094 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
9095 mddev->resync_min = mddev->curr_resync_completed;
9096 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
9097 mddev->curr_resync = MD_RESYNC_NONE;
9098 spin_unlock(&mddev->lock);
9099
9100 wake_up(&resync_wait);
9101 md_wakeup_thread(mddev->thread);
9102 return;
9103}
9104EXPORT_SYMBOL_GPL(md_do_sync);
9105
9106static int remove_and_add_spares(struct mddev *mddev,
9107 struct md_rdev *this)
9108{
9109 struct md_rdev *rdev;
9110 int spares = 0;
9111 int removed = 0;
9112 bool remove_some = false;
9113
9114 if (this && test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
9115 /* Mustn't remove devices when resync thread is running */
9116 return 0;
9117
9118 rdev_for_each(rdev, mddev) {
9119 if ((this == NULL || rdev == this) &&
9120 rdev->raid_disk >= 0 &&
9121 !test_bit(Blocked, &rdev->flags) &&
9122 test_bit(Faulty, &rdev->flags) &&
9123 atomic_read(&rdev->nr_pending)==0) {
9124 /* Faulty non-Blocked devices with nr_pending == 0
9125 * never get nr_pending incremented,
9126 * never get Faulty cleared, and never get Blocked set.
9127 * So we can synchronize_rcu now rather than once per device
9128 */
9129 remove_some = true;
9130 set_bit(RemoveSynchronized, &rdev->flags);
9131 }
9132 }
9133
9134 if (remove_some)
9135 synchronize_rcu();
9136 rdev_for_each(rdev, mddev) {
9137 if ((this == NULL || rdev == this) &&
9138 rdev->raid_disk >= 0 &&
9139 !test_bit(Blocked, &rdev->flags) &&
9140 ((test_bit(RemoveSynchronized, &rdev->flags) ||
9141 (!test_bit(In_sync, &rdev->flags) &&
9142 !test_bit(Journal, &rdev->flags))) &&
9143 atomic_read(&rdev->nr_pending)==0)) {
9144 if (mddev->pers->hot_remove_disk(
9145 mddev, rdev) == 0) {
9146 sysfs_unlink_rdev(mddev, rdev);
9147 rdev->saved_raid_disk = rdev->raid_disk;
9148 rdev->raid_disk = -1;
9149 removed++;
9150 }
9151 }
9152 if (remove_some && test_bit(RemoveSynchronized, &rdev->flags))
9153 clear_bit(RemoveSynchronized, &rdev->flags);
9154 }
9155
9156 if (removed && mddev->kobj.sd)
9157 sysfs_notify_dirent_safe(mddev->sysfs_degraded);
9158
9159 if (this && removed)
9160 goto no_add;
9161
9162 rdev_for_each(rdev, mddev) {
9163 if (this && this != rdev)
9164 continue;
9165 if (test_bit(Candidate, &rdev->flags))
9166 continue;
9167 if (rdev->raid_disk >= 0 &&
9168 !test_bit(In_sync, &rdev->flags) &&
9169 !test_bit(Journal, &rdev->flags) &&
9170 !test_bit(Faulty, &rdev->flags))
9171 spares++;
9172 if (rdev->raid_disk >= 0)
9173 continue;
9174 if (test_bit(Faulty, &rdev->flags))
9175 continue;
9176 if (!test_bit(Journal, &rdev->flags)) {
9177 if (!md_is_rdwr(mddev) &&
9178 !(rdev->saved_raid_disk >= 0 &&
9179 !test_bit(Bitmap_sync, &rdev->flags)))
9180 continue;
9181
9182 rdev->recovery_offset = 0;
9183 }
9184 if (mddev->pers->hot_add_disk(mddev, rdev) == 0) {
9185 /* failure here is OK */
9186 sysfs_link_rdev(mddev, rdev);
9187 if (!test_bit(Journal, &rdev->flags))
9188 spares++;
9189 md_new_event();
9190 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
9191 }
9192 }
9193no_add:
9194 if (removed)
9195 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
9196 return spares;
9197}
9198
9199static void md_start_sync(struct work_struct *ws)
9200{
9201 struct mddev *mddev = container_of(ws, struct mddev, del_work);
9202
9203 mddev->sync_thread = md_register_thread(md_do_sync,
9204 mddev,
9205 "resync");
9206 if (!mddev->sync_thread) {
9207 pr_warn("%s: could not start resync thread...\n",
9208 mdname(mddev));
9209 /* leave the spares where they are, it shouldn't hurt */
9210 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9211 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9212 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9213 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9214 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9215 wake_up(&resync_wait);
9216 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
9217 &mddev->recovery))
9218 if (mddev->sysfs_action)
9219 sysfs_notify_dirent_safe(mddev->sysfs_action);
9220 } else
9221 md_wakeup_thread(mddev->sync_thread);
9222 sysfs_notify_dirent_safe(mddev->sysfs_action);
9223 md_new_event();
9224}
9225
9226/*
9227 * This routine is regularly called by all per-raid-array threads to
9228 * deal with generic issues like resync and super-block update.
9229 * Raid personalities that don't have a thread (linear/raid0) do not
9230 * need this as they never do any recovery or update the superblock.
9231 *
9232 * It does not do any resync itself, but rather "forks" off other threads
9233 * to do that as needed.
9234 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
9235 * "->recovery" and create a thread at ->sync_thread.
9236 * When the thread finishes it sets MD_RECOVERY_DONE
9237 * and wakeups up this thread which will reap the thread and finish up.
9238 * This thread also removes any faulty devices (with nr_pending == 0).
9239 *
9240 * The overall approach is:
9241 * 1/ if the superblock needs updating, update it.
9242 * 2/ If a recovery thread is running, don't do anything else.
9243 * 3/ If recovery has finished, clean up, possibly marking spares active.
9244 * 4/ If there are any faulty devices, remove them.
9245 * 5/ If array is degraded, try to add spares devices
9246 * 6/ If array has spares or is not in-sync, start a resync thread.
9247 */
9248void md_check_recovery(struct mddev *mddev)
9249{
9250 if (test_bit(MD_ALLOW_SB_UPDATE, &mddev->flags) && mddev->sb_flags) {
9251 /* Write superblock - thread that called mddev_suspend()
9252 * holds reconfig_mutex for us.
9253 */
9254 set_bit(MD_UPDATING_SB, &mddev->flags);
9255 smp_mb__after_atomic();
9256 if (test_bit(MD_ALLOW_SB_UPDATE, &mddev->flags))
9257 md_update_sb(mddev, 0);
9258 clear_bit_unlock(MD_UPDATING_SB, &mddev->flags);
9259 wake_up(&mddev->sb_wait);
9260 }
9261
9262 if (mddev->suspended)
9263 return;
9264
9265 if (mddev->bitmap)
9266 md_bitmap_daemon_work(mddev);
9267
9268 if (signal_pending(current)) {
9269 if (mddev->pers->sync_request && !mddev->external) {
9270 pr_debug("md: %s in immediate safe mode\n",
9271 mdname(mddev));
9272 mddev->safemode = 2;
9273 }
9274 flush_signals(current);
9275 }
9276
9277 if (!md_is_rdwr(mddev) &&
9278 !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
9279 return;
9280 if ( ! (
9281 (mddev->sb_flags & ~ (1<<MD_SB_CHANGE_PENDING)) ||
9282 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
9283 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
9284 (mddev->external == 0 && mddev->safemode == 1) ||
9285 (mddev->safemode == 2
9286 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
9287 ))
9288 return;
9289
9290 if (mddev_trylock(mddev)) {
9291 int spares = 0;
9292 bool try_set_sync = mddev->safemode != 0;
9293
9294 if (!mddev->external && mddev->safemode == 1)
9295 mddev->safemode = 0;
9296
9297 if (!md_is_rdwr(mddev)) {
9298 struct md_rdev *rdev;
9299 if (!mddev->external && mddev->in_sync)
9300 /* 'Blocked' flag not needed as failed devices
9301 * will be recorded if array switched to read/write.
9302 * Leaving it set will prevent the device
9303 * from being removed.
9304 */
9305 rdev_for_each(rdev, mddev)
9306 clear_bit(Blocked, &rdev->flags);
9307 /* On a read-only array we can:
9308 * - remove failed devices
9309 * - add already-in_sync devices if the array itself
9310 * is in-sync.
9311 * As we only add devices that are already in-sync,
9312 * we can activate the spares immediately.
9313 */
9314 remove_and_add_spares(mddev, NULL);
9315 /* There is no thread, but we need to call
9316 * ->spare_active and clear saved_raid_disk
9317 */
9318 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
9319 md_unregister_thread(&mddev->sync_thread);
9320 md_reap_sync_thread(mddev);
9321 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9322 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9323 clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
9324 goto unlock;
9325 }
9326
9327 if (mddev_is_clustered(mddev)) {
9328 struct md_rdev *rdev, *tmp;
9329 /* kick the device if another node issued a
9330 * remove disk.
9331 */
9332 rdev_for_each_safe(rdev, tmp, mddev) {
9333 if (test_and_clear_bit(ClusterRemove, &rdev->flags) &&
9334 rdev->raid_disk < 0)
9335 md_kick_rdev_from_array(rdev);
9336 }
9337 }
9338
9339 if (try_set_sync && !mddev->external && !mddev->in_sync) {
9340 spin_lock(&mddev->lock);
9341 set_in_sync(mddev);
9342 spin_unlock(&mddev->lock);
9343 }
9344
9345 if (mddev->sb_flags)
9346 md_update_sb(mddev, 0);
9347
9348 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
9349 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
9350 /* resync/recovery still happening */
9351 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9352 goto unlock;
9353 }
9354 if (mddev->sync_thread) {
9355 md_unregister_thread(&mddev->sync_thread);
9356 md_reap_sync_thread(mddev);
9357 goto unlock;
9358 }
9359 /* Set RUNNING before clearing NEEDED to avoid
9360 * any transients in the value of "sync_action".
9361 */
9362 mddev->curr_resync_completed = 0;
9363 spin_lock(&mddev->lock);
9364 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9365 spin_unlock(&mddev->lock);
9366 /* Clear some bits that don't mean anything, but
9367 * might be left set
9368 */
9369 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
9370 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
9371
9372 if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
9373 test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
9374 goto not_running;
9375 /* no recovery is running.
9376 * remove any failed drives, then
9377 * add spares if possible.
9378 * Spares are also removed and re-added, to allow
9379 * the personality to fail the re-add.
9380 */
9381
9382 if (mddev->reshape_position != MaxSector) {
9383 if (mddev->pers->check_reshape == NULL ||
9384 mddev->pers->check_reshape(mddev) != 0)
9385 /* Cannot proceed */
9386 goto not_running;
9387 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9388 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9389 } else if ((spares = remove_and_add_spares(mddev, NULL))) {
9390 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9391 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9392 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9393 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9394 } else if (mddev->recovery_cp < MaxSector) {
9395 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9396 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
9397 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
9398 /* nothing to be done ... */
9399 goto not_running;
9400
9401 if (mddev->pers->sync_request) {
9402 if (spares) {
9403 /* We are adding a device or devices to an array
9404 * which has the bitmap stored on all devices.
9405 * So make sure all bitmap pages get written
9406 */
9407 md_bitmap_write_all(mddev->bitmap);
9408 }
9409 INIT_WORK(&mddev->del_work, md_start_sync);
9410 queue_work(md_misc_wq, &mddev->del_work);
9411 goto unlock;
9412 }
9413 not_running:
9414 if (!mddev->sync_thread) {
9415 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9416 wake_up(&resync_wait);
9417 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
9418 &mddev->recovery))
9419 if (mddev->sysfs_action)
9420 sysfs_notify_dirent_safe(mddev->sysfs_action);
9421 }
9422 unlock:
9423 wake_up(&mddev->sb_wait);
9424 mddev_unlock(mddev);
9425 }
9426}
9427EXPORT_SYMBOL(md_check_recovery);
9428
9429void md_reap_sync_thread(struct mddev *mddev)
9430{
9431 struct md_rdev *rdev;
9432 sector_t old_dev_sectors = mddev->dev_sectors;
9433 bool is_reshaped = false;
9434
9435 /* sync_thread should be unregistered, collect result */
9436 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
9437 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
9438 mddev->degraded != mddev->raid_disks) {
9439 /* success...*/
9440 /* activate any spares */
9441 if (mddev->pers->spare_active(mddev)) {
9442 sysfs_notify_dirent_safe(mddev->sysfs_degraded);
9443 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
9444 }
9445 }
9446 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
9447 mddev->pers->finish_reshape) {
9448 mddev->pers->finish_reshape(mddev);
9449 if (mddev_is_clustered(mddev))
9450 is_reshaped = true;
9451 }
9452
9453 /* If array is no-longer degraded, then any saved_raid_disk
9454 * information must be scrapped.
9455 */
9456 if (!mddev->degraded)
9457 rdev_for_each(rdev, mddev)
9458 rdev->saved_raid_disk = -1;
9459
9460 md_update_sb(mddev, 1);
9461 /* MD_SB_CHANGE_PENDING should be cleared by md_update_sb, so we can
9462 * call resync_finish here if MD_CLUSTER_RESYNC_LOCKED is set by
9463 * clustered raid */
9464 if (test_and_clear_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags))
9465 md_cluster_ops->resync_finish(mddev);
9466 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
9467 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
9468 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
9469 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
9470 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
9471 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
9472 /*
9473 * We call md_cluster_ops->update_size here because sync_size could
9474 * be changed by md_update_sb, and MD_RECOVERY_RESHAPE is cleared,
9475 * so it is time to update size across cluster.
9476 */
9477 if (mddev_is_clustered(mddev) && is_reshaped
9478 && !test_bit(MD_CLOSING, &mddev->flags))
9479 md_cluster_ops->update_size(mddev, old_dev_sectors);
9480 wake_up(&resync_wait);
9481 /* flag recovery needed just to double check */
9482 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9483 sysfs_notify_dirent_safe(mddev->sysfs_completed);
9484 sysfs_notify_dirent_safe(mddev->sysfs_action);
9485 md_new_event();
9486 if (mddev->event_work.func)
9487 queue_work(md_misc_wq, &mddev->event_work);
9488}
9489EXPORT_SYMBOL(md_reap_sync_thread);
9490
9491void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
9492{
9493 sysfs_notify_dirent_safe(rdev->sysfs_state);
9494 wait_event_timeout(rdev->blocked_wait,
9495 !test_bit(Blocked, &rdev->flags) &&
9496 !test_bit(BlockedBadBlocks, &rdev->flags),
9497 msecs_to_jiffies(5000));
9498 rdev_dec_pending(rdev, mddev);
9499}
9500EXPORT_SYMBOL(md_wait_for_blocked_rdev);
9501
9502void md_finish_reshape(struct mddev *mddev)
9503{
9504 /* called be personality module when reshape completes. */
9505 struct md_rdev *rdev;
9506
9507 rdev_for_each(rdev, mddev) {
9508 if (rdev->data_offset > rdev->new_data_offset)
9509 rdev->sectors += rdev->data_offset - rdev->new_data_offset;
9510 else
9511 rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
9512 rdev->data_offset = rdev->new_data_offset;
9513 }
9514}
9515EXPORT_SYMBOL(md_finish_reshape);
9516
9517/* Bad block management */
9518
9519/* Returns 1 on success, 0 on failure */
9520int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
9521 int is_new)
9522{
9523 struct mddev *mddev = rdev->mddev;
9524 int rv;
9525 if (is_new)
9526 s += rdev->new_data_offset;
9527 else
9528 s += rdev->data_offset;
9529 rv = badblocks_set(&rdev->badblocks, s, sectors, 0);
9530 if (rv == 0) {
9531 /* Make sure they get written out promptly */
9532 if (test_bit(ExternalBbl, &rdev->flags))
9533 sysfs_notify_dirent_safe(rdev->sysfs_unack_badblocks);
9534 sysfs_notify_dirent_safe(rdev->sysfs_state);
9535 set_mask_bits(&mddev->sb_flags, 0,
9536 BIT(MD_SB_CHANGE_CLEAN) | BIT(MD_SB_CHANGE_PENDING));
9537 md_wakeup_thread(rdev->mddev->thread);
9538 return 1;
9539 } else
9540 return 0;
9541}
9542EXPORT_SYMBOL_GPL(rdev_set_badblocks);
9543
9544int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
9545 int is_new)
9546{
9547 int rv;
9548 if (is_new)
9549 s += rdev->new_data_offset;
9550 else
9551 s += rdev->data_offset;
9552 rv = badblocks_clear(&rdev->badblocks, s, sectors);
9553 if ((rv == 0) && test_bit(ExternalBbl, &rdev->flags))
9554 sysfs_notify_dirent_safe(rdev->sysfs_badblocks);
9555 return rv;
9556}
9557EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
9558
9559static int md_notify_reboot(struct notifier_block *this,
9560 unsigned long code, void *x)
9561{
9562 struct mddev *mddev, *n;
9563 int need_delay = 0;
9564
9565 spin_lock(&all_mddevs_lock);
9566 list_for_each_entry_safe(mddev, n, &all_mddevs, all_mddevs) {
9567 if (!mddev_get(mddev))
9568 continue;
9569 spin_unlock(&all_mddevs_lock);
9570 if (mddev_trylock(mddev)) {
9571 if (mddev->pers)
9572 __md_stop_writes(mddev);
9573 if (mddev->persistent)
9574 mddev->safemode = 2;
9575 mddev_unlock(mddev);
9576 }
9577 need_delay = 1;
9578 mddev_put(mddev);
9579 spin_lock(&all_mddevs_lock);
9580 }
9581 spin_unlock(&all_mddevs_lock);
9582
9583 /*
9584 * certain more exotic SCSI devices are known to be
9585 * volatile wrt too early system reboots. While the
9586 * right place to handle this issue is the given
9587 * driver, we do want to have a safe RAID driver ...
9588 */
9589 if (need_delay)
9590 msleep(1000);
9591
9592 return NOTIFY_DONE;
9593}
9594
9595static struct notifier_block md_notifier = {
9596 .notifier_call = md_notify_reboot,
9597 .next = NULL,
9598 .priority = INT_MAX, /* before any real devices */
9599};
9600
9601static void md_geninit(void)
9602{
9603 pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
9604
9605 proc_create("mdstat", S_IRUGO, NULL, &mdstat_proc_ops);
9606}
9607
9608static int __init md_init(void)
9609{
9610 int ret = -ENOMEM;
9611
9612 md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
9613 if (!md_wq)
9614 goto err_wq;
9615
9616 md_misc_wq = alloc_workqueue("md_misc", 0, 0);
9617 if (!md_misc_wq)
9618 goto err_misc_wq;
9619
9620 md_rdev_misc_wq = alloc_workqueue("md_rdev_misc", 0, 0);
9621 if (!md_rdev_misc_wq)
9622 goto err_rdev_misc_wq;
9623
9624 ret = __register_blkdev(MD_MAJOR, "md", md_probe);
9625 if (ret < 0)
9626 goto err_md;
9627
9628 ret = __register_blkdev(0, "mdp", md_probe);
9629 if (ret < 0)
9630 goto err_mdp;
9631 mdp_major = ret;
9632
9633 register_reboot_notifier(&md_notifier);
9634 raid_table_header = register_sysctl_table(raid_root_table);
9635
9636 md_geninit();
9637 return 0;
9638
9639err_mdp:
9640 unregister_blkdev(MD_MAJOR, "md");
9641err_md:
9642 destroy_workqueue(md_rdev_misc_wq);
9643err_rdev_misc_wq:
9644 destroy_workqueue(md_misc_wq);
9645err_misc_wq:
9646 destroy_workqueue(md_wq);
9647err_wq:
9648 return ret;
9649}
9650
9651static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev)
9652{
9653 struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
9654 struct md_rdev *rdev2, *tmp;
9655 int role, ret;
9656
9657 /*
9658 * If size is changed in another node then we need to
9659 * do resize as well.
9660 */
9661 if (mddev->dev_sectors != le64_to_cpu(sb->size)) {
9662 ret = mddev->pers->resize(mddev, le64_to_cpu(sb->size));
9663 if (ret)
9664 pr_info("md-cluster: resize failed\n");
9665 else
9666 md_bitmap_update_sb(mddev->bitmap);
9667 }
9668
9669 /* Check for change of roles in the active devices */
9670 rdev_for_each_safe(rdev2, tmp, mddev) {
9671 if (test_bit(Faulty, &rdev2->flags))
9672 continue;
9673
9674 /* Check if the roles changed */
9675 role = le16_to_cpu(sb->dev_roles[rdev2->desc_nr]);
9676
9677 if (test_bit(Candidate, &rdev2->flags)) {
9678 if (role == MD_DISK_ROLE_FAULTY) {
9679 pr_info("md: Removing Candidate device %pg because add failed\n",
9680 rdev2->bdev);
9681 md_kick_rdev_from_array(rdev2);
9682 continue;
9683 }
9684 else
9685 clear_bit(Candidate, &rdev2->flags);
9686 }
9687
9688 if (role != rdev2->raid_disk) {
9689 /*
9690 * got activated except reshape is happening.
9691 */
9692 if (rdev2->raid_disk == -1 && role != MD_DISK_ROLE_SPARE &&
9693 !(le32_to_cpu(sb->feature_map) &
9694 MD_FEATURE_RESHAPE_ACTIVE)) {
9695 rdev2->saved_raid_disk = role;
9696 ret = remove_and_add_spares(mddev, rdev2);
9697 pr_info("Activated spare: %pg\n",
9698 rdev2->bdev);
9699 /* wakeup mddev->thread here, so array could
9700 * perform resync with the new activated disk */
9701 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9702 md_wakeup_thread(mddev->thread);
9703 }
9704 /* device faulty
9705 * We just want to do the minimum to mark the disk
9706 * as faulty. The recovery is performed by the
9707 * one who initiated the error.
9708 */
9709 if (role == MD_DISK_ROLE_FAULTY ||
9710 role == MD_DISK_ROLE_JOURNAL) {
9711 md_error(mddev, rdev2);
9712 clear_bit(Blocked, &rdev2->flags);
9713 }
9714 }
9715 }
9716
9717 if (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) {
9718 ret = update_raid_disks(mddev, le32_to_cpu(sb->raid_disks));
9719 if (ret)
9720 pr_warn("md: updating array disks failed. %d\n", ret);
9721 }
9722
9723 /*
9724 * Since mddev->delta_disks has already updated in update_raid_disks,
9725 * so it is time to check reshape.
9726 */
9727 if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
9728 (le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
9729 /*
9730 * reshape is happening in the remote node, we need to
9731 * update reshape_position and call start_reshape.
9732 */
9733 mddev->reshape_position = le64_to_cpu(sb->reshape_position);
9734 if (mddev->pers->update_reshape_pos)
9735 mddev->pers->update_reshape_pos(mddev);
9736 if (mddev->pers->start_reshape)
9737 mddev->pers->start_reshape(mddev);
9738 } else if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
9739 mddev->reshape_position != MaxSector &&
9740 !(le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
9741 /* reshape is just done in another node. */
9742 mddev->reshape_position = MaxSector;
9743 if (mddev->pers->update_reshape_pos)
9744 mddev->pers->update_reshape_pos(mddev);
9745 }
9746
9747 /* Finally set the event to be up to date */
9748 mddev->events = le64_to_cpu(sb->events);
9749}
9750
9751static int read_rdev(struct mddev *mddev, struct md_rdev *rdev)
9752{
9753 int err;
9754 struct page *swapout = rdev->sb_page;
9755 struct mdp_superblock_1 *sb;
9756
9757 /* Store the sb page of the rdev in the swapout temporary
9758 * variable in case we err in the future
9759 */
9760 rdev->sb_page = NULL;
9761 err = alloc_disk_sb(rdev);
9762 if (err == 0) {
9763 ClearPageUptodate(rdev->sb_page);
9764 rdev->sb_loaded = 0;
9765 err = super_types[mddev->major_version].
9766 load_super(rdev, NULL, mddev->minor_version);
9767 }
9768 if (err < 0) {
9769 pr_warn("%s: %d Could not reload rdev(%d) err: %d. Restoring old values\n",
9770 __func__, __LINE__, rdev->desc_nr, err);
9771 if (rdev->sb_page)
9772 put_page(rdev->sb_page);
9773 rdev->sb_page = swapout;
9774 rdev->sb_loaded = 1;
9775 return err;
9776 }
9777
9778 sb = page_address(rdev->sb_page);
9779 /* Read the offset unconditionally, even if MD_FEATURE_RECOVERY_OFFSET
9780 * is not set
9781 */
9782
9783 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET))
9784 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
9785
9786 /* The other node finished recovery, call spare_active to set
9787 * device In_sync and mddev->degraded
9788 */
9789 if (rdev->recovery_offset == MaxSector &&
9790 !test_bit(In_sync, &rdev->flags) &&
9791 mddev->pers->spare_active(mddev))
9792 sysfs_notify_dirent_safe(mddev->sysfs_degraded);
9793
9794 put_page(swapout);
9795 return 0;
9796}
9797
9798void md_reload_sb(struct mddev *mddev, int nr)
9799{
9800 struct md_rdev *rdev = NULL, *iter;
9801 int err;
9802
9803 /* Find the rdev */
9804 rdev_for_each_rcu(iter, mddev) {
9805 if (iter->desc_nr == nr) {
9806 rdev = iter;
9807 break;
9808 }
9809 }
9810
9811 if (!rdev) {
9812 pr_warn("%s: %d Could not find rdev with nr %d\n", __func__, __LINE__, nr);
9813 return;
9814 }
9815
9816 err = read_rdev(mddev, rdev);
9817 if (err < 0)
9818 return;
9819
9820 check_sb_changes(mddev, rdev);
9821
9822 /* Read all rdev's to update recovery_offset */
9823 rdev_for_each_rcu(rdev, mddev) {
9824 if (!test_bit(Faulty, &rdev->flags))
9825 read_rdev(mddev, rdev);
9826 }
9827}
9828EXPORT_SYMBOL(md_reload_sb);
9829
9830#ifndef MODULE
9831
9832/*
9833 * Searches all registered partitions for autorun RAID arrays
9834 * at boot time.
9835 */
9836
9837static DEFINE_MUTEX(detected_devices_mutex);
9838static LIST_HEAD(all_detected_devices);
9839struct detected_devices_node {
9840 struct list_head list;
9841 dev_t dev;
9842};
9843
9844void md_autodetect_dev(dev_t dev)
9845{
9846 struct detected_devices_node *node_detected_dev;
9847
9848 node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
9849 if (node_detected_dev) {
9850 node_detected_dev->dev = dev;
9851 mutex_lock(&detected_devices_mutex);
9852 list_add_tail(&node_detected_dev->list, &all_detected_devices);
9853 mutex_unlock(&detected_devices_mutex);
9854 }
9855}
9856
9857void md_autostart_arrays(int part)
9858{
9859 struct md_rdev *rdev;
9860 struct detected_devices_node *node_detected_dev;
9861 dev_t dev;
9862 int i_scanned, i_passed;
9863
9864 i_scanned = 0;
9865 i_passed = 0;
9866
9867 pr_info("md: Autodetecting RAID arrays.\n");
9868
9869 mutex_lock(&detected_devices_mutex);
9870 while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
9871 i_scanned++;
9872 node_detected_dev = list_entry(all_detected_devices.next,
9873 struct detected_devices_node, list);
9874 list_del(&node_detected_dev->list);
9875 dev = node_detected_dev->dev;
9876 kfree(node_detected_dev);
9877 mutex_unlock(&detected_devices_mutex);
9878 rdev = md_import_device(dev,0, 90);
9879 mutex_lock(&detected_devices_mutex);
9880 if (IS_ERR(rdev))
9881 continue;
9882
9883 if (test_bit(Faulty, &rdev->flags))
9884 continue;
9885
9886 set_bit(AutoDetected, &rdev->flags);
9887 list_add(&rdev->same_set, &pending_raid_disks);
9888 i_passed++;
9889 }
9890 mutex_unlock(&detected_devices_mutex);
9891
9892 pr_debug("md: Scanned %d and added %d devices.\n", i_scanned, i_passed);
9893
9894 autorun_devices(part);
9895}
9896
9897#endif /* !MODULE */
9898
9899static __exit void md_exit(void)
9900{
9901 struct mddev *mddev, *n;
9902 int delay = 1;
9903
9904 unregister_blkdev(MD_MAJOR,"md");
9905 unregister_blkdev(mdp_major, "mdp");
9906 unregister_reboot_notifier(&md_notifier);
9907 unregister_sysctl_table(raid_table_header);
9908
9909 /* We cannot unload the modules while some process is
9910 * waiting for us in select() or poll() - wake them up
9911 */
9912 md_unloading = 1;
9913 while (waitqueue_active(&md_event_waiters)) {
9914 /* not safe to leave yet */
9915 wake_up(&md_event_waiters);
9916 msleep(delay);
9917 delay += delay;
9918 }
9919 remove_proc_entry("mdstat", NULL);
9920
9921 spin_lock(&all_mddevs_lock);
9922 list_for_each_entry_safe(mddev, n, &all_mddevs, all_mddevs) {
9923 if (!mddev_get(mddev))
9924 continue;
9925 spin_unlock(&all_mddevs_lock);
9926 export_array(mddev);
9927 mddev->ctime = 0;
9928 mddev->hold_active = 0;
9929 /*
9930 * As the mddev is now fully clear, mddev_put will schedule
9931 * the mddev for destruction by a workqueue, and the
9932 * destroy_workqueue() below will wait for that to complete.
9933 */
9934 mddev_put(mddev);
9935 spin_lock(&all_mddevs_lock);
9936 }
9937 spin_unlock(&all_mddevs_lock);
9938
9939 destroy_workqueue(md_rdev_misc_wq);
9940 destroy_workqueue(md_misc_wq);
9941 destroy_workqueue(md_wq);
9942}
9943
9944subsys_initcall(md_init);
9945module_exit(md_exit)
9946
9947static int get_ro(char *buffer, const struct kernel_param *kp)
9948{
9949 return sprintf(buffer, "%d\n", start_readonly);
9950}
9951static int set_ro(const char *val, const struct kernel_param *kp)
9952{
9953 return kstrtouint(val, 10, (unsigned int *)&start_readonly);
9954}
9955
9956module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
9957module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
9958module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
9959module_param(create_on_open, bool, S_IRUSR|S_IWUSR);
9960
9961MODULE_LICENSE("GPL");
9962MODULE_DESCRIPTION("MD RAID framework");
9963MODULE_ALIAS("md");
9964MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);
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
57#ifndef MODULE
58static void autostart_arrays(int part);
59#endif
60
61/* pers_list is a list of registered personalities protected
62 * by pers_lock.
63 * pers_lock does extra service to protect accesses to
64 * mddev->thread when the mutex cannot be held.
65 */
66static LIST_HEAD(pers_list);
67static DEFINE_SPINLOCK(pers_lock);
68
69static void md_print_devices(void);
70
71static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
72static struct workqueue_struct *md_wq;
73static struct workqueue_struct *md_misc_wq;
74
75#define MD_BUG(x...) { printk("md: bug in file %s, line %d\n", __FILE__, __LINE__); md_print_devices(); }
76
77/*
78 * Default number of read corrections we'll attempt on an rdev
79 * before ejecting it from the array. We divide the read error
80 * count by 2 for every hour elapsed between read errors.
81 */
82#define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
83/*
84 * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
85 * is 1000 KB/sec, so the extra system load does not show up that much.
86 * Increase it if you want to have more _guaranteed_ speed. Note that
87 * the RAID driver will use the maximum available bandwidth if the IO
88 * subsystem is idle. There is also an 'absolute maximum' reconstruction
89 * speed limit - in case reconstruction slows down your system despite
90 * idle IO detection.
91 *
92 * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
93 * or /sys/block/mdX/md/sync_speed_{min,max}
94 */
95
96static int sysctl_speed_limit_min = 1000;
97static int sysctl_speed_limit_max = 200000;
98static inline int speed_min(struct mddev *mddev)
99{
100 return mddev->sync_speed_min ?
101 mddev->sync_speed_min : sysctl_speed_limit_min;
102}
103
104static inline int speed_max(struct mddev *mddev)
105{
106 return mddev->sync_speed_max ?
107 mddev->sync_speed_max : sysctl_speed_limit_max;
108}
109
110static struct ctl_table_header *raid_table_header;
111
112static ctl_table raid_table[] = {
113 {
114 .procname = "speed_limit_min",
115 .data = &sysctl_speed_limit_min,
116 .maxlen = sizeof(int),
117 .mode = S_IRUGO|S_IWUSR,
118 .proc_handler = proc_dointvec,
119 },
120 {
121 .procname = "speed_limit_max",
122 .data = &sysctl_speed_limit_max,
123 .maxlen = sizeof(int),
124 .mode = S_IRUGO|S_IWUSR,
125 .proc_handler = proc_dointvec,
126 },
127 { }
128};
129
130static ctl_table raid_dir_table[] = {
131 {
132 .procname = "raid",
133 .maxlen = 0,
134 .mode = S_IRUGO|S_IXUGO,
135 .child = raid_table,
136 },
137 { }
138};
139
140static ctl_table raid_root_table[] = {
141 {
142 .procname = "dev",
143 .maxlen = 0,
144 .mode = 0555,
145 .child = raid_dir_table,
146 },
147 { }
148};
149
150static const struct block_device_operations md_fops;
151
152static int start_readonly;
153
154/* bio_clone_mddev
155 * like bio_clone, but with a local bio set
156 */
157
158static void mddev_bio_destructor(struct bio *bio)
159{
160 struct mddev *mddev, **mddevp;
161
162 mddevp = (void*)bio;
163 mddev = mddevp[-1];
164
165 bio_free(bio, mddev->bio_set);
166}
167
168struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
169 struct mddev *mddev)
170{
171 struct bio *b;
172 struct mddev **mddevp;
173
174 if (!mddev || !mddev->bio_set)
175 return bio_alloc(gfp_mask, nr_iovecs);
176
177 b = bio_alloc_bioset(gfp_mask, nr_iovecs,
178 mddev->bio_set);
179 if (!b)
180 return NULL;
181 mddevp = (void*)b;
182 mddevp[-1] = mddev;
183 b->bi_destructor = mddev_bio_destructor;
184 return b;
185}
186EXPORT_SYMBOL_GPL(bio_alloc_mddev);
187
188struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
189 struct mddev *mddev)
190{
191 struct bio *b;
192 struct mddev **mddevp;
193
194 if (!mddev || !mddev->bio_set)
195 return bio_clone(bio, gfp_mask);
196
197 b = bio_alloc_bioset(gfp_mask, bio->bi_max_vecs,
198 mddev->bio_set);
199 if (!b)
200 return NULL;
201 mddevp = (void*)b;
202 mddevp[-1] = mddev;
203 b->bi_destructor = mddev_bio_destructor;
204 __bio_clone(b, bio);
205 if (bio_integrity(bio)) {
206 int ret;
207
208 ret = bio_integrity_clone(b, bio, gfp_mask, mddev->bio_set);
209
210 if (ret < 0) {
211 bio_put(b);
212 return NULL;
213 }
214 }
215
216 return b;
217}
218EXPORT_SYMBOL_GPL(bio_clone_mddev);
219
220void md_trim_bio(struct bio *bio, int offset, int size)
221{
222 /* 'bio' is a cloned bio which we need to trim to match
223 * the given offset and size.
224 * This requires adjusting bi_sector, bi_size, and bi_io_vec
225 */
226 int i;
227 struct bio_vec *bvec;
228 int sofar = 0;
229
230 size <<= 9;
231 if (offset == 0 && size == bio->bi_size)
232 return;
233
234 bio->bi_sector += offset;
235 bio->bi_size = size;
236 offset <<= 9;
237 clear_bit(BIO_SEG_VALID, &bio->bi_flags);
238
239 while (bio->bi_idx < bio->bi_vcnt &&
240 bio->bi_io_vec[bio->bi_idx].bv_len <= offset) {
241 /* remove this whole bio_vec */
242 offset -= bio->bi_io_vec[bio->bi_idx].bv_len;
243 bio->bi_idx++;
244 }
245 if (bio->bi_idx < bio->bi_vcnt) {
246 bio->bi_io_vec[bio->bi_idx].bv_offset += offset;
247 bio->bi_io_vec[bio->bi_idx].bv_len -= offset;
248 }
249 /* avoid any complications with bi_idx being non-zero*/
250 if (bio->bi_idx) {
251 memmove(bio->bi_io_vec, bio->bi_io_vec+bio->bi_idx,
252 (bio->bi_vcnt - bio->bi_idx) * sizeof(struct bio_vec));
253 bio->bi_vcnt -= bio->bi_idx;
254 bio->bi_idx = 0;
255 }
256 /* Make sure vcnt and last bv are not too big */
257 bio_for_each_segment(bvec, bio, i) {
258 if (sofar + bvec->bv_len > size)
259 bvec->bv_len = size - sofar;
260 if (bvec->bv_len == 0) {
261 bio->bi_vcnt = i;
262 break;
263 }
264 sofar += bvec->bv_len;
265 }
266}
267EXPORT_SYMBOL_GPL(md_trim_bio);
268
269/*
270 * We have a system wide 'event count' that is incremented
271 * on any 'interesting' event, and readers of /proc/mdstat
272 * can use 'poll' or 'select' to find out when the event
273 * count increases.
274 *
275 * Events are:
276 * start array, stop array, error, add device, remove device,
277 * start build, activate spare
278 */
279static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
280static atomic_t md_event_count;
281void md_new_event(struct mddev *mddev)
282{
283 atomic_inc(&md_event_count);
284 wake_up(&md_event_waiters);
285}
286EXPORT_SYMBOL_GPL(md_new_event);
287
288/* Alternate version that can be called from interrupts
289 * when calling sysfs_notify isn't needed.
290 */
291static void md_new_event_inintr(struct mddev *mddev)
292{
293 atomic_inc(&md_event_count);
294 wake_up(&md_event_waiters);
295}
296
297/*
298 * Enables to iterate over all existing md arrays
299 * all_mddevs_lock protects this list.
300 */
301static LIST_HEAD(all_mddevs);
302static DEFINE_SPINLOCK(all_mddevs_lock);
303
304
305/*
306 * iterates through all used mddevs in the system.
307 * We take care to grab the all_mddevs_lock whenever navigating
308 * the list, and to always hold a refcount when unlocked.
309 * Any code which breaks out of this loop while own
310 * a reference to the current mddev and must mddev_put it.
311 */
312#define for_each_mddev(_mddev,_tmp) \
313 \
314 for (({ spin_lock(&all_mddevs_lock); \
315 _tmp = all_mddevs.next; \
316 _mddev = NULL;}); \
317 ({ if (_tmp != &all_mddevs) \
318 mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\
319 spin_unlock(&all_mddevs_lock); \
320 if (_mddev) mddev_put(_mddev); \
321 _mddev = list_entry(_tmp, struct mddev, all_mddevs); \
322 _tmp != &all_mddevs;}); \
323 ({ spin_lock(&all_mddevs_lock); \
324 _tmp = _tmp->next;}) \
325 )
326
327
328/* Rather than calling directly into the personality make_request function,
329 * IO requests come here first so that we can check if the device is
330 * being suspended pending a reconfiguration.
331 * We hold a refcount over the call to ->make_request. By the time that
332 * call has finished, the bio has been linked into some internal structure
333 * and so is visible to ->quiesce(), so we don't need the refcount any more.
334 */
335static void md_make_request(struct request_queue *q, struct bio *bio)
336{
337 const int rw = bio_data_dir(bio);
338 struct mddev *mddev = q->queuedata;
339 int cpu;
340 unsigned int sectors;
341
342 if (mddev == NULL || mddev->pers == NULL
343 || !mddev->ready) {
344 bio_io_error(bio);
345 return;
346 }
347 smp_rmb(); /* Ensure implications of 'active' are visible */
348 rcu_read_lock();
349 if (mddev->suspended) {
350 DEFINE_WAIT(__wait);
351 for (;;) {
352 prepare_to_wait(&mddev->sb_wait, &__wait,
353 TASK_UNINTERRUPTIBLE);
354 if (!mddev->suspended)
355 break;
356 rcu_read_unlock();
357 schedule();
358 rcu_read_lock();
359 }
360 finish_wait(&mddev->sb_wait, &__wait);
361 }
362 atomic_inc(&mddev->active_io);
363 rcu_read_unlock();
364
365 /*
366 * save the sectors now since our bio can
367 * go away inside make_request
368 */
369 sectors = bio_sectors(bio);
370 mddev->pers->make_request(mddev, bio);
371
372 cpu = part_stat_lock();
373 part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
374 part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors);
375 part_stat_unlock();
376
377 if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
378 wake_up(&mddev->sb_wait);
379}
380
381/* mddev_suspend makes sure no new requests are submitted
382 * to the device, and that any requests that have been submitted
383 * are completely handled.
384 * Once ->stop is called and completes, the module will be completely
385 * unused.
386 */
387void mddev_suspend(struct mddev *mddev)
388{
389 BUG_ON(mddev->suspended);
390 mddev->suspended = 1;
391 synchronize_rcu();
392 wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
393 mddev->pers->quiesce(mddev, 1);
394
395 del_timer_sync(&mddev->safemode_timer);
396}
397EXPORT_SYMBOL_GPL(mddev_suspend);
398
399void mddev_resume(struct mddev *mddev)
400{
401 mddev->suspended = 0;
402 wake_up(&mddev->sb_wait);
403 mddev->pers->quiesce(mddev, 0);
404
405 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
406 md_wakeup_thread(mddev->thread);
407 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
408}
409EXPORT_SYMBOL_GPL(mddev_resume);
410
411int mddev_congested(struct mddev *mddev, int bits)
412{
413 return mddev->suspended;
414}
415EXPORT_SYMBOL(mddev_congested);
416
417/*
418 * Generic flush handling for md
419 */
420
421static void md_end_flush(struct bio *bio, int err)
422{
423 struct md_rdev *rdev = bio->bi_private;
424 struct mddev *mddev = rdev->mddev;
425
426 rdev_dec_pending(rdev, mddev);
427
428 if (atomic_dec_and_test(&mddev->flush_pending)) {
429 /* The pre-request flush has finished */
430 queue_work(md_wq, &mddev->flush_work);
431 }
432 bio_put(bio);
433}
434
435static void md_submit_flush_data(struct work_struct *ws);
436
437static void submit_flushes(struct work_struct *ws)
438{
439 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
440 struct md_rdev *rdev;
441
442 INIT_WORK(&mddev->flush_work, md_submit_flush_data);
443 atomic_set(&mddev->flush_pending, 1);
444 rcu_read_lock();
445 rdev_for_each_rcu(rdev, mddev)
446 if (rdev->raid_disk >= 0 &&
447 !test_bit(Faulty, &rdev->flags)) {
448 /* Take two references, one is dropped
449 * when request finishes, one after
450 * we reclaim rcu_read_lock
451 */
452 struct bio *bi;
453 atomic_inc(&rdev->nr_pending);
454 atomic_inc(&rdev->nr_pending);
455 rcu_read_unlock();
456 bi = bio_alloc_mddev(GFP_NOIO, 0, mddev);
457 bi->bi_end_io = md_end_flush;
458 bi->bi_private = rdev;
459 bi->bi_bdev = rdev->bdev;
460 atomic_inc(&mddev->flush_pending);
461 submit_bio(WRITE_FLUSH, bi);
462 rcu_read_lock();
463 rdev_dec_pending(rdev, mddev);
464 }
465 rcu_read_unlock();
466 if (atomic_dec_and_test(&mddev->flush_pending))
467 queue_work(md_wq, &mddev->flush_work);
468}
469
470static void md_submit_flush_data(struct work_struct *ws)
471{
472 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
473 struct bio *bio = mddev->flush_bio;
474
475 if (bio->bi_size == 0)
476 /* an empty barrier - all done */
477 bio_endio(bio, 0);
478 else {
479 bio->bi_rw &= ~REQ_FLUSH;
480 mddev->pers->make_request(mddev, bio);
481 }
482
483 mddev->flush_bio = NULL;
484 wake_up(&mddev->sb_wait);
485}
486
487void md_flush_request(struct mddev *mddev, struct bio *bio)
488{
489 spin_lock_irq(&mddev->write_lock);
490 wait_event_lock_irq(mddev->sb_wait,
491 !mddev->flush_bio,
492 mddev->write_lock, /*nothing*/);
493 mddev->flush_bio = bio;
494 spin_unlock_irq(&mddev->write_lock);
495
496 INIT_WORK(&mddev->flush_work, submit_flushes);
497 queue_work(md_wq, &mddev->flush_work);
498}
499EXPORT_SYMBOL(md_flush_request);
500
501/* Support for plugging.
502 * This mirrors the plugging support in request_queue, but does not
503 * require having a whole queue or request structures.
504 * We allocate an md_plug_cb for each md device and each thread it gets
505 * plugged on. This links tot the private plug_handle structure in the
506 * personality data where we keep a count of the number of outstanding
507 * plugs so other code can see if a plug is active.
508 */
509struct md_plug_cb {
510 struct blk_plug_cb cb;
511 struct mddev *mddev;
512};
513
514static void plugger_unplug(struct blk_plug_cb *cb)
515{
516 struct md_plug_cb *mdcb = container_of(cb, struct md_plug_cb, cb);
517 if (atomic_dec_and_test(&mdcb->mddev->plug_cnt))
518 md_wakeup_thread(mdcb->mddev->thread);
519 kfree(mdcb);
520}
521
522/* Check that an unplug wakeup will come shortly.
523 * If not, wakeup the md thread immediately
524 */
525int mddev_check_plugged(struct mddev *mddev)
526{
527 struct blk_plug *plug = current->plug;
528 struct md_plug_cb *mdcb;
529
530 if (!plug)
531 return 0;
532
533 list_for_each_entry(mdcb, &plug->cb_list, cb.list) {
534 if (mdcb->cb.callback == plugger_unplug &&
535 mdcb->mddev == mddev) {
536 /* Already on the list, move to top */
537 if (mdcb != list_first_entry(&plug->cb_list,
538 struct md_plug_cb,
539 cb.list))
540 list_move(&mdcb->cb.list, &plug->cb_list);
541 return 1;
542 }
543 }
544 /* Not currently on the callback list */
545 mdcb = kmalloc(sizeof(*mdcb), GFP_ATOMIC);
546 if (!mdcb)
547 return 0;
548
549 mdcb->mddev = mddev;
550 mdcb->cb.callback = plugger_unplug;
551 atomic_inc(&mddev->plug_cnt);
552 list_add(&mdcb->cb.list, &plug->cb_list);
553 return 1;
554}
555EXPORT_SYMBOL_GPL(mddev_check_plugged);
556
557static inline struct mddev *mddev_get(struct mddev *mddev)
558{
559 atomic_inc(&mddev->active);
560 return mddev;
561}
562
563static void mddev_delayed_delete(struct work_struct *ws);
564
565static void mddev_put(struct mddev *mddev)
566{
567 struct bio_set *bs = NULL;
568
569 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
570 return;
571 if (!mddev->raid_disks && list_empty(&mddev->disks) &&
572 mddev->ctime == 0 && !mddev->hold_active) {
573 /* Array is not configured at all, and not held active,
574 * so destroy it */
575 list_del_init(&mddev->all_mddevs);
576 bs = mddev->bio_set;
577 mddev->bio_set = NULL;
578 if (mddev->gendisk) {
579 /* We did a probe so need to clean up. Call
580 * queue_work inside the spinlock so that
581 * flush_workqueue() after mddev_find will
582 * succeed in waiting for the work to be done.
583 */
584 INIT_WORK(&mddev->del_work, mddev_delayed_delete);
585 queue_work(md_misc_wq, &mddev->del_work);
586 } else
587 kfree(mddev);
588 }
589 spin_unlock(&all_mddevs_lock);
590 if (bs)
591 bioset_free(bs);
592}
593
594void mddev_init(struct mddev *mddev)
595{
596 mutex_init(&mddev->open_mutex);
597 mutex_init(&mddev->reconfig_mutex);
598 mutex_init(&mddev->bitmap_info.mutex);
599 INIT_LIST_HEAD(&mddev->disks);
600 INIT_LIST_HEAD(&mddev->all_mddevs);
601 init_timer(&mddev->safemode_timer);
602 atomic_set(&mddev->active, 1);
603 atomic_set(&mddev->openers, 0);
604 atomic_set(&mddev->active_io, 0);
605 atomic_set(&mddev->plug_cnt, 0);
606 spin_lock_init(&mddev->write_lock);
607 atomic_set(&mddev->flush_pending, 0);
608 init_waitqueue_head(&mddev->sb_wait);
609 init_waitqueue_head(&mddev->recovery_wait);
610 mddev->reshape_position = MaxSector;
611 mddev->reshape_backwards = 0;
612 mddev->resync_min = 0;
613 mddev->resync_max = MaxSector;
614 mddev->level = LEVEL_NONE;
615}
616EXPORT_SYMBOL_GPL(mddev_init);
617
618static struct mddev * mddev_find(dev_t unit)
619{
620 struct mddev *mddev, *new = NULL;
621
622 if (unit && MAJOR(unit) != MD_MAJOR)
623 unit &= ~((1<<MdpMinorShift)-1);
624
625 retry:
626 spin_lock(&all_mddevs_lock);
627
628 if (unit) {
629 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
630 if (mddev->unit == unit) {
631 mddev_get(mddev);
632 spin_unlock(&all_mddevs_lock);
633 kfree(new);
634 return mddev;
635 }
636
637 if (new) {
638 list_add(&new->all_mddevs, &all_mddevs);
639 spin_unlock(&all_mddevs_lock);
640 new->hold_active = UNTIL_IOCTL;
641 return new;
642 }
643 } else if (new) {
644 /* find an unused unit number */
645 static int next_minor = 512;
646 int start = next_minor;
647 int is_free = 0;
648 int dev = 0;
649 while (!is_free) {
650 dev = MKDEV(MD_MAJOR, next_minor);
651 next_minor++;
652 if (next_minor > MINORMASK)
653 next_minor = 0;
654 if (next_minor == start) {
655 /* Oh dear, all in use. */
656 spin_unlock(&all_mddevs_lock);
657 kfree(new);
658 return NULL;
659 }
660
661 is_free = 1;
662 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
663 if (mddev->unit == dev) {
664 is_free = 0;
665 break;
666 }
667 }
668 new->unit = dev;
669 new->md_minor = MINOR(dev);
670 new->hold_active = UNTIL_STOP;
671 list_add(&new->all_mddevs, &all_mddevs);
672 spin_unlock(&all_mddevs_lock);
673 return new;
674 }
675 spin_unlock(&all_mddevs_lock);
676
677 new = kzalloc(sizeof(*new), GFP_KERNEL);
678 if (!new)
679 return NULL;
680
681 new->unit = unit;
682 if (MAJOR(unit) == MD_MAJOR)
683 new->md_minor = MINOR(unit);
684 else
685 new->md_minor = MINOR(unit) >> MdpMinorShift;
686
687 mddev_init(new);
688
689 goto retry;
690}
691
692static inline int mddev_lock(struct mddev * mddev)
693{
694 return mutex_lock_interruptible(&mddev->reconfig_mutex);
695}
696
697static inline int mddev_is_locked(struct mddev *mddev)
698{
699 return mutex_is_locked(&mddev->reconfig_mutex);
700}
701
702static inline int mddev_trylock(struct mddev * mddev)
703{
704 return mutex_trylock(&mddev->reconfig_mutex);
705}
706
707static struct attribute_group md_redundancy_group;
708
709static void mddev_unlock(struct mddev * mddev)
710{
711 if (mddev->to_remove) {
712 /* These cannot be removed under reconfig_mutex as
713 * an access to the files will try to take reconfig_mutex
714 * while holding the file unremovable, which leads to
715 * a deadlock.
716 * So hold set sysfs_active while the remove in happeing,
717 * and anything else which might set ->to_remove or my
718 * otherwise change the sysfs namespace will fail with
719 * -EBUSY if sysfs_active is still set.
720 * We set sysfs_active under reconfig_mutex and elsewhere
721 * test it under the same mutex to ensure its correct value
722 * is seen.
723 */
724 struct attribute_group *to_remove = mddev->to_remove;
725 mddev->to_remove = NULL;
726 mddev->sysfs_active = 1;
727 mutex_unlock(&mddev->reconfig_mutex);
728
729 if (mddev->kobj.sd) {
730 if (to_remove != &md_redundancy_group)
731 sysfs_remove_group(&mddev->kobj, to_remove);
732 if (mddev->pers == NULL ||
733 mddev->pers->sync_request == NULL) {
734 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
735 if (mddev->sysfs_action)
736 sysfs_put(mddev->sysfs_action);
737 mddev->sysfs_action = NULL;
738 }
739 }
740 mddev->sysfs_active = 0;
741 } else
742 mutex_unlock(&mddev->reconfig_mutex);
743
744 /* As we've dropped the mutex we need a spinlock to
745 * make sure the thread doesn't disappear
746 */
747 spin_lock(&pers_lock);
748 md_wakeup_thread(mddev->thread);
749 spin_unlock(&pers_lock);
750}
751
752static struct md_rdev * find_rdev_nr(struct mddev *mddev, int nr)
753{
754 struct md_rdev *rdev;
755
756 rdev_for_each(rdev, mddev)
757 if (rdev->desc_nr == nr)
758 return rdev;
759
760 return NULL;
761}
762
763static struct md_rdev * find_rdev(struct mddev * mddev, dev_t dev)
764{
765 struct md_rdev *rdev;
766
767 rdev_for_each(rdev, mddev)
768 if (rdev->bdev->bd_dev == dev)
769 return rdev;
770
771 return NULL;
772}
773
774static struct md_personality *find_pers(int level, char *clevel)
775{
776 struct md_personality *pers;
777 list_for_each_entry(pers, &pers_list, list) {
778 if (level != LEVEL_NONE && pers->level == level)
779 return pers;
780 if (strcmp(pers->name, clevel)==0)
781 return pers;
782 }
783 return NULL;
784}
785
786/* return the offset of the super block in 512byte sectors */
787static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
788{
789 sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
790 return MD_NEW_SIZE_SECTORS(num_sectors);
791}
792
793static int alloc_disk_sb(struct md_rdev * rdev)
794{
795 if (rdev->sb_page)
796 MD_BUG();
797
798 rdev->sb_page = alloc_page(GFP_KERNEL);
799 if (!rdev->sb_page) {
800 printk(KERN_ALERT "md: out of memory.\n");
801 return -ENOMEM;
802 }
803
804 return 0;
805}
806
807void md_rdev_clear(struct md_rdev *rdev)
808{
809 if (rdev->sb_page) {
810 put_page(rdev->sb_page);
811 rdev->sb_loaded = 0;
812 rdev->sb_page = NULL;
813 rdev->sb_start = 0;
814 rdev->sectors = 0;
815 }
816 if (rdev->bb_page) {
817 put_page(rdev->bb_page);
818 rdev->bb_page = NULL;
819 }
820 kfree(rdev->badblocks.page);
821 rdev->badblocks.page = NULL;
822}
823EXPORT_SYMBOL_GPL(md_rdev_clear);
824
825static void super_written(struct bio *bio, int error)
826{
827 struct md_rdev *rdev = bio->bi_private;
828 struct mddev *mddev = rdev->mddev;
829
830 if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags)) {
831 printk("md: super_written gets error=%d, uptodate=%d\n",
832 error, test_bit(BIO_UPTODATE, &bio->bi_flags));
833 WARN_ON(test_bit(BIO_UPTODATE, &bio->bi_flags));
834 md_error(mddev, rdev);
835 }
836
837 if (atomic_dec_and_test(&mddev->pending_writes))
838 wake_up(&mddev->sb_wait);
839 bio_put(bio);
840}
841
842void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
843 sector_t sector, int size, struct page *page)
844{
845 /* write first size bytes of page to sector of rdev
846 * Increment mddev->pending_writes before returning
847 * and decrement it on completion, waking up sb_wait
848 * if zero is reached.
849 * If an error occurred, call md_error
850 */
851 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, mddev);
852
853 bio->bi_bdev = rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev;
854 bio->bi_sector = sector;
855 bio_add_page(bio, page, size, 0);
856 bio->bi_private = rdev;
857 bio->bi_end_io = super_written;
858
859 atomic_inc(&mddev->pending_writes);
860 submit_bio(WRITE_FLUSH_FUA, bio);
861}
862
863void md_super_wait(struct mddev *mddev)
864{
865 /* wait for all superblock writes that were scheduled to complete */
866 DEFINE_WAIT(wq);
867 for(;;) {
868 prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
869 if (atomic_read(&mddev->pending_writes)==0)
870 break;
871 schedule();
872 }
873 finish_wait(&mddev->sb_wait, &wq);
874}
875
876static void bi_complete(struct bio *bio, int error)
877{
878 complete((struct completion*)bio->bi_private);
879}
880
881int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
882 struct page *page, int rw, bool metadata_op)
883{
884 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev);
885 struct completion event;
886 int ret;
887
888 rw |= REQ_SYNC;
889
890 bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
891 rdev->meta_bdev : rdev->bdev;
892 if (metadata_op)
893 bio->bi_sector = sector + rdev->sb_start;
894 else if (rdev->mddev->reshape_position != MaxSector &&
895 (rdev->mddev->reshape_backwards ==
896 (sector >= rdev->mddev->reshape_position)))
897 bio->bi_sector = sector + rdev->new_data_offset;
898 else
899 bio->bi_sector = sector + rdev->data_offset;
900 bio_add_page(bio, page, size, 0);
901 init_completion(&event);
902 bio->bi_private = &event;
903 bio->bi_end_io = bi_complete;
904 submit_bio(rw, bio);
905 wait_for_completion(&event);
906
907 ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
908 bio_put(bio);
909 return ret;
910}
911EXPORT_SYMBOL_GPL(sync_page_io);
912
913static int read_disk_sb(struct md_rdev * rdev, int size)
914{
915 char b[BDEVNAME_SIZE];
916 if (!rdev->sb_page) {
917 MD_BUG();
918 return -EINVAL;
919 }
920 if (rdev->sb_loaded)
921 return 0;
922
923
924 if (!sync_page_io(rdev, 0, size, rdev->sb_page, READ, true))
925 goto fail;
926 rdev->sb_loaded = 1;
927 return 0;
928
929fail:
930 printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
931 bdevname(rdev->bdev,b));
932 return -EINVAL;
933}
934
935static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
936{
937 return sb1->set_uuid0 == sb2->set_uuid0 &&
938 sb1->set_uuid1 == sb2->set_uuid1 &&
939 sb1->set_uuid2 == sb2->set_uuid2 &&
940 sb1->set_uuid3 == sb2->set_uuid3;
941}
942
943static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
944{
945 int ret;
946 mdp_super_t *tmp1, *tmp2;
947
948 tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
949 tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
950
951 if (!tmp1 || !tmp2) {
952 ret = 0;
953 printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
954 goto abort;
955 }
956
957 *tmp1 = *sb1;
958 *tmp2 = *sb2;
959
960 /*
961 * nr_disks is not constant
962 */
963 tmp1->nr_disks = 0;
964 tmp2->nr_disks = 0;
965
966 ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
967abort:
968 kfree(tmp1);
969 kfree(tmp2);
970 return ret;
971}
972
973
974static u32 md_csum_fold(u32 csum)
975{
976 csum = (csum & 0xffff) + (csum >> 16);
977 return (csum & 0xffff) + (csum >> 16);
978}
979
980static unsigned int calc_sb_csum(mdp_super_t * sb)
981{
982 u64 newcsum = 0;
983 u32 *sb32 = (u32*)sb;
984 int i;
985 unsigned int disk_csum, csum;
986
987 disk_csum = sb->sb_csum;
988 sb->sb_csum = 0;
989
990 for (i = 0; i < MD_SB_BYTES/4 ; i++)
991 newcsum += sb32[i];
992 csum = (newcsum & 0xffffffff) + (newcsum>>32);
993
994
995#ifdef CONFIG_ALPHA
996 /* This used to use csum_partial, which was wrong for several
997 * reasons including that different results are returned on
998 * different architectures. It isn't critical that we get exactly
999 * the same return value as before (we always csum_fold before
1000 * testing, and that removes any differences). However as we
1001 * know that csum_partial always returned a 16bit value on
1002 * alphas, do a fold to maximise conformity to previous behaviour.
1003 */
1004 sb->sb_csum = md_csum_fold(disk_csum);
1005#else
1006 sb->sb_csum = disk_csum;
1007#endif
1008 return csum;
1009}
1010
1011
1012/*
1013 * Handle superblock details.
1014 * We want to be able to handle multiple superblock formats
1015 * so we have a common interface to them all, and an array of
1016 * different handlers.
1017 * We rely on user-space to write the initial superblock, and support
1018 * reading and updating of superblocks.
1019 * Interface methods are:
1020 * int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
1021 * loads and validates a superblock on dev.
1022 * if refdev != NULL, compare superblocks on both devices
1023 * Return:
1024 * 0 - dev has a superblock that is compatible with refdev
1025 * 1 - dev has a superblock that is compatible and newer than refdev
1026 * so dev should be used as the refdev in future
1027 * -EINVAL superblock incompatible or invalid
1028 * -othererror e.g. -EIO
1029 *
1030 * int validate_super(struct mddev *mddev, struct md_rdev *dev)
1031 * Verify that dev is acceptable into mddev.
1032 * The first time, mddev->raid_disks will be 0, and data from
1033 * dev should be merged in. Subsequent calls check that dev
1034 * is new enough. Return 0 or -EINVAL
1035 *
1036 * void sync_super(struct mddev *mddev, struct md_rdev *dev)
1037 * Update the superblock for rdev with data in mddev
1038 * This does not write to disc.
1039 *
1040 */
1041
1042struct super_type {
1043 char *name;
1044 struct module *owner;
1045 int (*load_super)(struct md_rdev *rdev,
1046 struct md_rdev *refdev,
1047 int minor_version);
1048 int (*validate_super)(struct mddev *mddev,
1049 struct md_rdev *rdev);
1050 void (*sync_super)(struct mddev *mddev,
1051 struct md_rdev *rdev);
1052 unsigned long long (*rdev_size_change)(struct md_rdev *rdev,
1053 sector_t num_sectors);
1054 int (*allow_new_offset)(struct md_rdev *rdev,
1055 unsigned long long new_offset);
1056};
1057
1058/*
1059 * Check that the given mddev has no bitmap.
1060 *
1061 * This function is called from the run method of all personalities that do not
1062 * support bitmaps. It prints an error message and returns non-zero if mddev
1063 * has a bitmap. Otherwise, it returns 0.
1064 *
1065 */
1066int md_check_no_bitmap(struct mddev *mddev)
1067{
1068 if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
1069 return 0;
1070 printk(KERN_ERR "%s: bitmaps are not supported for %s\n",
1071 mdname(mddev), mddev->pers->name);
1072 return 1;
1073}
1074EXPORT_SYMBOL(md_check_no_bitmap);
1075
1076/*
1077 * load_super for 0.90.0
1078 */
1079static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
1080{
1081 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1082 mdp_super_t *sb;
1083 int ret;
1084
1085 /*
1086 * Calculate the position of the superblock (512byte sectors),
1087 * it's at the end of the disk.
1088 *
1089 * It also happens to be a multiple of 4Kb.
1090 */
1091 rdev->sb_start = calc_dev_sboffset(rdev);
1092
1093 ret = read_disk_sb(rdev, MD_SB_BYTES);
1094 if (ret) return ret;
1095
1096 ret = -EINVAL;
1097
1098 bdevname(rdev->bdev, b);
1099 sb = page_address(rdev->sb_page);
1100
1101 if (sb->md_magic != MD_SB_MAGIC) {
1102 printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
1103 b);
1104 goto abort;
1105 }
1106
1107 if (sb->major_version != 0 ||
1108 sb->minor_version < 90 ||
1109 sb->minor_version > 91) {
1110 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
1111 sb->major_version, sb->minor_version,
1112 b);
1113 goto abort;
1114 }
1115
1116 if (sb->raid_disks <= 0)
1117 goto abort;
1118
1119 if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
1120 printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
1121 b);
1122 goto abort;
1123 }
1124
1125 rdev->preferred_minor = sb->md_minor;
1126 rdev->data_offset = 0;
1127 rdev->new_data_offset = 0;
1128 rdev->sb_size = MD_SB_BYTES;
1129 rdev->badblocks.shift = -1;
1130
1131 if (sb->level == LEVEL_MULTIPATH)
1132 rdev->desc_nr = -1;
1133 else
1134 rdev->desc_nr = sb->this_disk.number;
1135
1136 if (!refdev) {
1137 ret = 1;
1138 } else {
1139 __u64 ev1, ev2;
1140 mdp_super_t *refsb = page_address(refdev->sb_page);
1141 if (!uuid_equal(refsb, sb)) {
1142 printk(KERN_WARNING "md: %s has different UUID to %s\n",
1143 b, bdevname(refdev->bdev,b2));
1144 goto abort;
1145 }
1146 if (!sb_equal(refsb, sb)) {
1147 printk(KERN_WARNING "md: %s has same UUID"
1148 " but different superblock to %s\n",
1149 b, bdevname(refdev->bdev, b2));
1150 goto abort;
1151 }
1152 ev1 = md_event(sb);
1153 ev2 = md_event(refsb);
1154 if (ev1 > ev2)
1155 ret = 1;
1156 else
1157 ret = 0;
1158 }
1159 rdev->sectors = rdev->sb_start;
1160 /* Limit to 4TB as metadata cannot record more than that.
1161 * (not needed for Linear and RAID0 as metadata doesn't
1162 * record this size)
1163 */
1164 if (rdev->sectors >= (2ULL << 32) && sb->level >= 1)
1165 rdev->sectors = (2ULL << 32) - 2;
1166
1167 if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
1168 /* "this cannot possibly happen" ... */
1169 ret = -EINVAL;
1170
1171 abort:
1172 return ret;
1173}
1174
1175/*
1176 * validate_super for 0.90.0
1177 */
1178static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
1179{
1180 mdp_disk_t *desc;
1181 mdp_super_t *sb = page_address(rdev->sb_page);
1182 __u64 ev1 = md_event(sb);
1183
1184 rdev->raid_disk = -1;
1185 clear_bit(Faulty, &rdev->flags);
1186 clear_bit(In_sync, &rdev->flags);
1187 clear_bit(WriteMostly, &rdev->flags);
1188
1189 if (mddev->raid_disks == 0) {
1190 mddev->major_version = 0;
1191 mddev->minor_version = sb->minor_version;
1192 mddev->patch_version = sb->patch_version;
1193 mddev->external = 0;
1194 mddev->chunk_sectors = sb->chunk_size >> 9;
1195 mddev->ctime = sb->ctime;
1196 mddev->utime = sb->utime;
1197 mddev->level = sb->level;
1198 mddev->clevel[0] = 0;
1199 mddev->layout = sb->layout;
1200 mddev->raid_disks = sb->raid_disks;
1201 mddev->dev_sectors = ((sector_t)sb->size) * 2;
1202 mddev->events = ev1;
1203 mddev->bitmap_info.offset = 0;
1204 mddev->bitmap_info.space = 0;
1205 /* bitmap can use 60 K after the 4K superblocks */
1206 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
1207 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
1208 mddev->reshape_backwards = 0;
1209
1210 if (mddev->minor_version >= 91) {
1211 mddev->reshape_position = sb->reshape_position;
1212 mddev->delta_disks = sb->delta_disks;
1213 mddev->new_level = sb->new_level;
1214 mddev->new_layout = sb->new_layout;
1215 mddev->new_chunk_sectors = sb->new_chunk >> 9;
1216 if (mddev->delta_disks < 0)
1217 mddev->reshape_backwards = 1;
1218 } else {
1219 mddev->reshape_position = MaxSector;
1220 mddev->delta_disks = 0;
1221 mddev->new_level = mddev->level;
1222 mddev->new_layout = mddev->layout;
1223 mddev->new_chunk_sectors = mddev->chunk_sectors;
1224 }
1225
1226 if (sb->state & (1<<MD_SB_CLEAN))
1227 mddev->recovery_cp = MaxSector;
1228 else {
1229 if (sb->events_hi == sb->cp_events_hi &&
1230 sb->events_lo == sb->cp_events_lo) {
1231 mddev->recovery_cp = sb->recovery_cp;
1232 } else
1233 mddev->recovery_cp = 0;
1234 }
1235
1236 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
1237 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
1238 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
1239 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
1240
1241 mddev->max_disks = MD_SB_DISKS;
1242
1243 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
1244 mddev->bitmap_info.file == NULL) {
1245 mddev->bitmap_info.offset =
1246 mddev->bitmap_info.default_offset;
1247 mddev->bitmap_info.space =
1248 mddev->bitmap_info.space;
1249 }
1250
1251 } else if (mddev->pers == NULL) {
1252 /* Insist on good event counter while assembling, except
1253 * for spares (which don't need an event count) */
1254 ++ev1;
1255 if (sb->disks[rdev->desc_nr].state & (
1256 (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
1257 if (ev1 < mddev->events)
1258 return -EINVAL;
1259 } else if (mddev->bitmap) {
1260 /* if adding to array with a bitmap, then we can accept an
1261 * older device ... but not too old.
1262 */
1263 if (ev1 < mddev->bitmap->events_cleared)
1264 return 0;
1265 } else {
1266 if (ev1 < mddev->events)
1267 /* just a hot-add of a new device, leave raid_disk at -1 */
1268 return 0;
1269 }
1270
1271 if (mddev->level != LEVEL_MULTIPATH) {
1272 desc = sb->disks + rdev->desc_nr;
1273
1274 if (desc->state & (1<<MD_DISK_FAULTY))
1275 set_bit(Faulty, &rdev->flags);
1276 else if (desc->state & (1<<MD_DISK_SYNC) /* &&
1277 desc->raid_disk < mddev->raid_disks */) {
1278 set_bit(In_sync, &rdev->flags);
1279 rdev->raid_disk = desc->raid_disk;
1280 } else if (desc->state & (1<<MD_DISK_ACTIVE)) {
1281 /* active but not in sync implies recovery up to
1282 * reshape position. We don't know exactly where
1283 * that is, so set to zero for now */
1284 if (mddev->minor_version >= 91) {
1285 rdev->recovery_offset = 0;
1286 rdev->raid_disk = desc->raid_disk;
1287 }
1288 }
1289 if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
1290 set_bit(WriteMostly, &rdev->flags);
1291 } else /* MULTIPATH are always insync */
1292 set_bit(In_sync, &rdev->flags);
1293 return 0;
1294}
1295
1296/*
1297 * sync_super for 0.90.0
1298 */
1299static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
1300{
1301 mdp_super_t *sb;
1302 struct md_rdev *rdev2;
1303 int next_spare = mddev->raid_disks;
1304
1305
1306 /* make rdev->sb match mddev data..
1307 *
1308 * 1/ zero out disks
1309 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
1310 * 3/ any empty disks < next_spare become removed
1311 *
1312 * disks[0] gets initialised to REMOVED because
1313 * we cannot be sure from other fields if it has
1314 * been initialised or not.
1315 */
1316 int i;
1317 int active=0, working=0,failed=0,spare=0,nr_disks=0;
1318
1319 rdev->sb_size = MD_SB_BYTES;
1320
1321 sb = page_address(rdev->sb_page);
1322
1323 memset(sb, 0, sizeof(*sb));
1324
1325 sb->md_magic = MD_SB_MAGIC;
1326 sb->major_version = mddev->major_version;
1327 sb->patch_version = mddev->patch_version;
1328 sb->gvalid_words = 0; /* ignored */
1329 memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
1330 memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
1331 memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
1332 memcpy(&sb->set_uuid3, mddev->uuid+12,4);
1333
1334 sb->ctime = mddev->ctime;
1335 sb->level = mddev->level;
1336 sb->size = mddev->dev_sectors / 2;
1337 sb->raid_disks = mddev->raid_disks;
1338 sb->md_minor = mddev->md_minor;
1339 sb->not_persistent = 0;
1340 sb->utime = mddev->utime;
1341 sb->state = 0;
1342 sb->events_hi = (mddev->events>>32);
1343 sb->events_lo = (u32)mddev->events;
1344
1345 if (mddev->reshape_position == MaxSector)
1346 sb->minor_version = 90;
1347 else {
1348 sb->minor_version = 91;
1349 sb->reshape_position = mddev->reshape_position;
1350 sb->new_level = mddev->new_level;
1351 sb->delta_disks = mddev->delta_disks;
1352 sb->new_layout = mddev->new_layout;
1353 sb->new_chunk = mddev->new_chunk_sectors << 9;
1354 }
1355 mddev->minor_version = sb->minor_version;
1356 if (mddev->in_sync)
1357 {
1358 sb->recovery_cp = mddev->recovery_cp;
1359 sb->cp_events_hi = (mddev->events>>32);
1360 sb->cp_events_lo = (u32)mddev->events;
1361 if (mddev->recovery_cp == MaxSector)
1362 sb->state = (1<< MD_SB_CLEAN);
1363 } else
1364 sb->recovery_cp = 0;
1365
1366 sb->layout = mddev->layout;
1367 sb->chunk_size = mddev->chunk_sectors << 9;
1368
1369 if (mddev->bitmap && mddev->bitmap_info.file == NULL)
1370 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
1371
1372 sb->disks[0].state = (1<<MD_DISK_REMOVED);
1373 rdev_for_each(rdev2, mddev) {
1374 mdp_disk_t *d;
1375 int desc_nr;
1376 int is_active = test_bit(In_sync, &rdev2->flags);
1377
1378 if (rdev2->raid_disk >= 0 &&
1379 sb->minor_version >= 91)
1380 /* we have nowhere to store the recovery_offset,
1381 * but if it is not below the reshape_position,
1382 * we can piggy-back on that.
1383 */
1384 is_active = 1;
1385 if (rdev2->raid_disk < 0 ||
1386 test_bit(Faulty, &rdev2->flags))
1387 is_active = 0;
1388 if (is_active)
1389 desc_nr = rdev2->raid_disk;
1390 else
1391 desc_nr = next_spare++;
1392 rdev2->desc_nr = desc_nr;
1393 d = &sb->disks[rdev2->desc_nr];
1394 nr_disks++;
1395 d->number = rdev2->desc_nr;
1396 d->major = MAJOR(rdev2->bdev->bd_dev);
1397 d->minor = MINOR(rdev2->bdev->bd_dev);
1398 if (is_active)
1399 d->raid_disk = rdev2->raid_disk;
1400 else
1401 d->raid_disk = rdev2->desc_nr; /* compatibility */
1402 if (test_bit(Faulty, &rdev2->flags))
1403 d->state = (1<<MD_DISK_FAULTY);
1404 else if (is_active) {
1405 d->state = (1<<MD_DISK_ACTIVE);
1406 if (test_bit(In_sync, &rdev2->flags))
1407 d->state |= (1<<MD_DISK_SYNC);
1408 active++;
1409 working++;
1410 } else {
1411 d->state = 0;
1412 spare++;
1413 working++;
1414 }
1415 if (test_bit(WriteMostly, &rdev2->flags))
1416 d->state |= (1<<MD_DISK_WRITEMOSTLY);
1417 }
1418 /* now set the "removed" and "faulty" bits on any missing devices */
1419 for (i=0 ; i < mddev->raid_disks ; i++) {
1420 mdp_disk_t *d = &sb->disks[i];
1421 if (d->state == 0 && d->number == 0) {
1422 d->number = i;
1423 d->raid_disk = i;
1424 d->state = (1<<MD_DISK_REMOVED);
1425 d->state |= (1<<MD_DISK_FAULTY);
1426 failed++;
1427 }
1428 }
1429 sb->nr_disks = nr_disks;
1430 sb->active_disks = active;
1431 sb->working_disks = working;
1432 sb->failed_disks = failed;
1433 sb->spare_disks = spare;
1434
1435 sb->this_disk = sb->disks[rdev->desc_nr];
1436 sb->sb_csum = calc_sb_csum(sb);
1437}
1438
1439/*
1440 * rdev_size_change for 0.90.0
1441 */
1442static unsigned long long
1443super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1444{
1445 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1446 return 0; /* component must fit device */
1447 if (rdev->mddev->bitmap_info.offset)
1448 return 0; /* can't move bitmap */
1449 rdev->sb_start = calc_dev_sboffset(rdev);
1450 if (!num_sectors || num_sectors > rdev->sb_start)
1451 num_sectors = rdev->sb_start;
1452 /* Limit to 4TB as metadata cannot record more than that.
1453 * 4TB == 2^32 KB, or 2*2^32 sectors.
1454 */
1455 if (num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1)
1456 num_sectors = (2ULL << 32) - 2;
1457 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1458 rdev->sb_page);
1459 md_super_wait(rdev->mddev);
1460 return num_sectors;
1461}
1462
1463static int
1464super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset)
1465{
1466 /* non-zero offset changes not possible with v0.90 */
1467 return new_offset == 0;
1468}
1469
1470/*
1471 * version 1 superblock
1472 */
1473
1474static __le32 calc_sb_1_csum(struct mdp_superblock_1 * sb)
1475{
1476 __le32 disk_csum;
1477 u32 csum;
1478 unsigned long long newcsum;
1479 int size = 256 + le32_to_cpu(sb->max_dev)*2;
1480 __le32 *isuper = (__le32*)sb;
1481 int i;
1482
1483 disk_csum = sb->sb_csum;
1484 sb->sb_csum = 0;
1485 newcsum = 0;
1486 for (i=0; size>=4; size -= 4 )
1487 newcsum += le32_to_cpu(*isuper++);
1488
1489 if (size == 2)
1490 newcsum += le16_to_cpu(*(__le16*) isuper);
1491
1492 csum = (newcsum & 0xffffffff) + (newcsum >> 32);
1493 sb->sb_csum = disk_csum;
1494 return cpu_to_le32(csum);
1495}
1496
1497static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
1498 int acknowledged);
1499static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
1500{
1501 struct mdp_superblock_1 *sb;
1502 int ret;
1503 sector_t sb_start;
1504 sector_t sectors;
1505 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1506 int bmask;
1507
1508 /*
1509 * Calculate the position of the superblock in 512byte sectors.
1510 * It is always aligned to a 4K boundary and
1511 * depeding on minor_version, it can be:
1512 * 0: At least 8K, but less than 12K, from end of device
1513 * 1: At start of device
1514 * 2: 4K from start of device.
1515 */
1516 switch(minor_version) {
1517 case 0:
1518 sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;
1519 sb_start -= 8*2;
1520 sb_start &= ~(sector_t)(4*2-1);
1521 break;
1522 case 1:
1523 sb_start = 0;
1524 break;
1525 case 2:
1526 sb_start = 8;
1527 break;
1528 default:
1529 return -EINVAL;
1530 }
1531 rdev->sb_start = sb_start;
1532
1533 /* superblock is rarely larger than 1K, but it can be larger,
1534 * and it is safe to read 4k, so we do that
1535 */
1536 ret = read_disk_sb(rdev, 4096);
1537 if (ret) return ret;
1538
1539
1540 sb = page_address(rdev->sb_page);
1541
1542 if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
1543 sb->major_version != cpu_to_le32(1) ||
1544 le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
1545 le64_to_cpu(sb->super_offset) != rdev->sb_start ||
1546 (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
1547 return -EINVAL;
1548
1549 if (calc_sb_1_csum(sb) != sb->sb_csum) {
1550 printk("md: invalid superblock checksum on %s\n",
1551 bdevname(rdev->bdev,b));
1552 return -EINVAL;
1553 }
1554 if (le64_to_cpu(sb->data_size) < 10) {
1555 printk("md: data_size too small on %s\n",
1556 bdevname(rdev->bdev,b));
1557 return -EINVAL;
1558 }
1559 if (sb->pad0 ||
1560 sb->pad3[0] ||
1561 memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1])))
1562 /* Some padding is non-zero, might be a new feature */
1563 return -EINVAL;
1564
1565 rdev->preferred_minor = 0xffff;
1566 rdev->data_offset = le64_to_cpu(sb->data_offset);
1567 rdev->new_data_offset = rdev->data_offset;
1568 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) &&
1569 (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
1570 rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset);
1571 atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
1572
1573 rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
1574 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1575 if (rdev->sb_size & bmask)
1576 rdev->sb_size = (rdev->sb_size | bmask) + 1;
1577
1578 if (minor_version
1579 && rdev->data_offset < sb_start + (rdev->sb_size/512))
1580 return -EINVAL;
1581 if (minor_version
1582 && rdev->new_data_offset < sb_start + (rdev->sb_size/512))
1583 return -EINVAL;
1584
1585 if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
1586 rdev->desc_nr = -1;
1587 else
1588 rdev->desc_nr = le32_to_cpu(sb->dev_number);
1589
1590 if (!rdev->bb_page) {
1591 rdev->bb_page = alloc_page(GFP_KERNEL);
1592 if (!rdev->bb_page)
1593 return -ENOMEM;
1594 }
1595 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
1596 rdev->badblocks.count == 0) {
1597 /* need to load the bad block list.
1598 * Currently we limit it to one page.
1599 */
1600 s32 offset;
1601 sector_t bb_sector;
1602 u64 *bbp;
1603 int i;
1604 int sectors = le16_to_cpu(sb->bblog_size);
1605 if (sectors > (PAGE_SIZE / 512))
1606 return -EINVAL;
1607 offset = le32_to_cpu(sb->bblog_offset);
1608 if (offset == 0)
1609 return -EINVAL;
1610 bb_sector = (long long)offset;
1611 if (!sync_page_io(rdev, bb_sector, sectors << 9,
1612 rdev->bb_page, READ, true))
1613 return -EIO;
1614 bbp = (u64 *)page_address(rdev->bb_page);
1615 rdev->badblocks.shift = sb->bblog_shift;
1616 for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
1617 u64 bb = le64_to_cpu(*bbp);
1618 int count = bb & (0x3ff);
1619 u64 sector = bb >> 10;
1620 sector <<= sb->bblog_shift;
1621 count <<= sb->bblog_shift;
1622 if (bb + 1 == 0)
1623 break;
1624 if (md_set_badblocks(&rdev->badblocks,
1625 sector, count, 1) == 0)
1626 return -EINVAL;
1627 }
1628 } else if (sb->bblog_offset == 0)
1629 rdev->badblocks.shift = -1;
1630
1631 if (!refdev) {
1632 ret = 1;
1633 } else {
1634 __u64 ev1, ev2;
1635 struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
1636
1637 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1638 sb->level != refsb->level ||
1639 sb->layout != refsb->layout ||
1640 sb->chunksize != refsb->chunksize) {
1641 printk(KERN_WARNING "md: %s has strangely different"
1642 " superblock to %s\n",
1643 bdevname(rdev->bdev,b),
1644 bdevname(refdev->bdev,b2));
1645 return -EINVAL;
1646 }
1647 ev1 = le64_to_cpu(sb->events);
1648 ev2 = le64_to_cpu(refsb->events);
1649
1650 if (ev1 > ev2)
1651 ret = 1;
1652 else
1653 ret = 0;
1654 }
1655 if (minor_version) {
1656 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9);
1657 sectors -= rdev->data_offset;
1658 } else
1659 sectors = rdev->sb_start;
1660 if (sectors < le64_to_cpu(sb->data_size))
1661 return -EINVAL;
1662 rdev->sectors = le64_to_cpu(sb->data_size);
1663 return ret;
1664}
1665
1666static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
1667{
1668 struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
1669 __u64 ev1 = le64_to_cpu(sb->events);
1670
1671 rdev->raid_disk = -1;
1672 clear_bit(Faulty, &rdev->flags);
1673 clear_bit(In_sync, &rdev->flags);
1674 clear_bit(WriteMostly, &rdev->flags);
1675
1676 if (mddev->raid_disks == 0) {
1677 mddev->major_version = 1;
1678 mddev->patch_version = 0;
1679 mddev->external = 0;
1680 mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
1681 mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
1682 mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
1683 mddev->level = le32_to_cpu(sb->level);
1684 mddev->clevel[0] = 0;
1685 mddev->layout = le32_to_cpu(sb->layout);
1686 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
1687 mddev->dev_sectors = le64_to_cpu(sb->size);
1688 mddev->events = ev1;
1689 mddev->bitmap_info.offset = 0;
1690 mddev->bitmap_info.space = 0;
1691 /* Default location for bitmap is 1K after superblock
1692 * using 3K - total of 4K
1693 */
1694 mddev->bitmap_info.default_offset = 1024 >> 9;
1695 mddev->bitmap_info.default_space = (4096-1024) >> 9;
1696 mddev->reshape_backwards = 0;
1697
1698 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1699 memcpy(mddev->uuid, sb->set_uuid, 16);
1700
1701 mddev->max_disks = (4096-256)/2;
1702
1703 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1704 mddev->bitmap_info.file == NULL) {
1705 mddev->bitmap_info.offset =
1706 (__s32)le32_to_cpu(sb->bitmap_offset);
1707 /* Metadata doesn't record how much space is available.
1708 * For 1.0, we assume we can use up to the superblock
1709 * if before, else to 4K beyond superblock.
1710 * For others, assume no change is possible.
1711 */
1712 if (mddev->minor_version > 0)
1713 mddev->bitmap_info.space = 0;
1714 else if (mddev->bitmap_info.offset > 0)
1715 mddev->bitmap_info.space =
1716 8 - mddev->bitmap_info.offset;
1717 else
1718 mddev->bitmap_info.space =
1719 -mddev->bitmap_info.offset;
1720 }
1721
1722 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
1723 mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1724 mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1725 mddev->new_level = le32_to_cpu(sb->new_level);
1726 mddev->new_layout = le32_to_cpu(sb->new_layout);
1727 mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
1728 if (mddev->delta_disks < 0 ||
1729 (mddev->delta_disks == 0 &&
1730 (le32_to_cpu(sb->feature_map)
1731 & MD_FEATURE_RESHAPE_BACKWARDS)))
1732 mddev->reshape_backwards = 1;
1733 } else {
1734 mddev->reshape_position = MaxSector;
1735 mddev->delta_disks = 0;
1736 mddev->new_level = mddev->level;
1737 mddev->new_layout = mddev->layout;
1738 mddev->new_chunk_sectors = mddev->chunk_sectors;
1739 }
1740
1741 } else if (mddev->pers == NULL) {
1742 /* Insist of good event counter while assembling, except for
1743 * spares (which don't need an event count) */
1744 ++ev1;
1745 if (rdev->desc_nr >= 0 &&
1746 rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
1747 le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < 0xfffe)
1748 if (ev1 < mddev->events)
1749 return -EINVAL;
1750 } else if (mddev->bitmap) {
1751 /* If adding to array with a bitmap, then we can accept an
1752 * older device, but not too old.
1753 */
1754 if (ev1 < mddev->bitmap->events_cleared)
1755 return 0;
1756 } else {
1757 if (ev1 < mddev->events)
1758 /* just a hot-add of a new device, leave raid_disk at -1 */
1759 return 0;
1760 }
1761 if (mddev->level != LEVEL_MULTIPATH) {
1762 int role;
1763 if (rdev->desc_nr < 0 ||
1764 rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
1765 role = 0xffff;
1766 rdev->desc_nr = -1;
1767 } else
1768 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
1769 switch(role) {
1770 case 0xffff: /* spare */
1771 break;
1772 case 0xfffe: /* faulty */
1773 set_bit(Faulty, &rdev->flags);
1774 break;
1775 default:
1776 if ((le32_to_cpu(sb->feature_map) &
1777 MD_FEATURE_RECOVERY_OFFSET))
1778 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
1779 else
1780 set_bit(In_sync, &rdev->flags);
1781 rdev->raid_disk = role;
1782 break;
1783 }
1784 if (sb->devflags & WriteMostly1)
1785 set_bit(WriteMostly, &rdev->flags);
1786 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT)
1787 set_bit(Replacement, &rdev->flags);
1788 } else /* MULTIPATH are always insync */
1789 set_bit(In_sync, &rdev->flags);
1790
1791 return 0;
1792}
1793
1794static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
1795{
1796 struct mdp_superblock_1 *sb;
1797 struct md_rdev *rdev2;
1798 int max_dev, i;
1799 /* make rdev->sb match mddev and rdev data. */
1800
1801 sb = page_address(rdev->sb_page);
1802
1803 sb->feature_map = 0;
1804 sb->pad0 = 0;
1805 sb->recovery_offset = cpu_to_le64(0);
1806 memset(sb->pad3, 0, sizeof(sb->pad3));
1807
1808 sb->utime = cpu_to_le64((__u64)mddev->utime);
1809 sb->events = cpu_to_le64(mddev->events);
1810 if (mddev->in_sync)
1811 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
1812 else
1813 sb->resync_offset = cpu_to_le64(0);
1814
1815 sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
1816
1817 sb->raid_disks = cpu_to_le32(mddev->raid_disks);
1818 sb->size = cpu_to_le64(mddev->dev_sectors);
1819 sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
1820 sb->level = cpu_to_le32(mddev->level);
1821 sb->layout = cpu_to_le32(mddev->layout);
1822
1823 if (test_bit(WriteMostly, &rdev->flags))
1824 sb->devflags |= WriteMostly1;
1825 else
1826 sb->devflags &= ~WriteMostly1;
1827 sb->data_offset = cpu_to_le64(rdev->data_offset);
1828 sb->data_size = cpu_to_le64(rdev->sectors);
1829
1830 if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
1831 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
1832 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1833 }
1834
1835 if (rdev->raid_disk >= 0 &&
1836 !test_bit(In_sync, &rdev->flags)) {
1837 sb->feature_map |=
1838 cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
1839 sb->recovery_offset =
1840 cpu_to_le64(rdev->recovery_offset);
1841 }
1842 if (test_bit(Replacement, &rdev->flags))
1843 sb->feature_map |=
1844 cpu_to_le32(MD_FEATURE_REPLACEMENT);
1845
1846 if (mddev->reshape_position != MaxSector) {
1847 sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
1848 sb->reshape_position = cpu_to_le64(mddev->reshape_position);
1849 sb->new_layout = cpu_to_le32(mddev->new_layout);
1850 sb->delta_disks = cpu_to_le32(mddev->delta_disks);
1851 sb->new_level = cpu_to_le32(mddev->new_level);
1852 sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
1853 if (mddev->delta_disks == 0 &&
1854 mddev->reshape_backwards)
1855 sb->feature_map
1856 |= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
1857 if (rdev->new_data_offset != rdev->data_offset) {
1858 sb->feature_map
1859 |= cpu_to_le32(MD_FEATURE_NEW_OFFSET);
1860 sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset
1861 - rdev->data_offset));
1862 }
1863 }
1864
1865 if (rdev->badblocks.count == 0)
1866 /* Nothing to do for bad blocks*/ ;
1867 else if (sb->bblog_offset == 0)
1868 /* Cannot record bad blocks on this device */
1869 md_error(mddev, rdev);
1870 else {
1871 struct badblocks *bb = &rdev->badblocks;
1872 u64 *bbp = (u64 *)page_address(rdev->bb_page);
1873 u64 *p = bb->page;
1874 sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
1875 if (bb->changed) {
1876 unsigned seq;
1877
1878retry:
1879 seq = read_seqbegin(&bb->lock);
1880
1881 memset(bbp, 0xff, PAGE_SIZE);
1882
1883 for (i = 0 ; i < bb->count ; i++) {
1884 u64 internal_bb = *p++;
1885 u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
1886 | BB_LEN(internal_bb));
1887 *bbp++ = cpu_to_le64(store_bb);
1888 }
1889 bb->changed = 0;
1890 if (read_seqretry(&bb->lock, seq))
1891 goto retry;
1892
1893 bb->sector = (rdev->sb_start +
1894 (int)le32_to_cpu(sb->bblog_offset));
1895 bb->size = le16_to_cpu(sb->bblog_size);
1896 }
1897 }
1898
1899 max_dev = 0;
1900 rdev_for_each(rdev2, mddev)
1901 if (rdev2->desc_nr+1 > max_dev)
1902 max_dev = rdev2->desc_nr+1;
1903
1904 if (max_dev > le32_to_cpu(sb->max_dev)) {
1905 int bmask;
1906 sb->max_dev = cpu_to_le32(max_dev);
1907 rdev->sb_size = max_dev * 2 + 256;
1908 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1909 if (rdev->sb_size & bmask)
1910 rdev->sb_size = (rdev->sb_size | bmask) + 1;
1911 } else
1912 max_dev = le32_to_cpu(sb->max_dev);
1913
1914 for (i=0; i<max_dev;i++)
1915 sb->dev_roles[i] = cpu_to_le16(0xfffe);
1916
1917 rdev_for_each(rdev2, mddev) {
1918 i = rdev2->desc_nr;
1919 if (test_bit(Faulty, &rdev2->flags))
1920 sb->dev_roles[i] = cpu_to_le16(0xfffe);
1921 else if (test_bit(In_sync, &rdev2->flags))
1922 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1923 else if (rdev2->raid_disk >= 0)
1924 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1925 else
1926 sb->dev_roles[i] = cpu_to_le16(0xffff);
1927 }
1928
1929 sb->sb_csum = calc_sb_1_csum(sb);
1930}
1931
1932static unsigned long long
1933super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1934{
1935 struct mdp_superblock_1 *sb;
1936 sector_t max_sectors;
1937 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1938 return 0; /* component must fit device */
1939 if (rdev->data_offset != rdev->new_data_offset)
1940 return 0; /* too confusing */
1941 if (rdev->sb_start < rdev->data_offset) {
1942 /* minor versions 1 and 2; superblock before data */
1943 max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9;
1944 max_sectors -= rdev->data_offset;
1945 if (!num_sectors || num_sectors > max_sectors)
1946 num_sectors = max_sectors;
1947 } else if (rdev->mddev->bitmap_info.offset) {
1948 /* minor version 0 with bitmap we can't move */
1949 return 0;
1950 } else {
1951 /* minor version 0; superblock after data */
1952 sector_t sb_start;
1953 sb_start = (i_size_read(rdev->bdev->bd_inode) >> 9) - 8*2;
1954 sb_start &= ~(sector_t)(4*2 - 1);
1955 max_sectors = rdev->sectors + sb_start - rdev->sb_start;
1956 if (!num_sectors || num_sectors > max_sectors)
1957 num_sectors = max_sectors;
1958 rdev->sb_start = sb_start;
1959 }
1960 sb = page_address(rdev->sb_page);
1961 sb->data_size = cpu_to_le64(num_sectors);
1962 sb->super_offset = rdev->sb_start;
1963 sb->sb_csum = calc_sb_1_csum(sb);
1964 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1965 rdev->sb_page);
1966 md_super_wait(rdev->mddev);
1967 return num_sectors;
1968
1969}
1970
1971static int
1972super_1_allow_new_offset(struct md_rdev *rdev,
1973 unsigned long long new_offset)
1974{
1975 /* All necessary checks on new >= old have been done */
1976 struct bitmap *bitmap;
1977 if (new_offset >= rdev->data_offset)
1978 return 1;
1979
1980 /* with 1.0 metadata, there is no metadata to tread on
1981 * so we can always move back */
1982 if (rdev->mddev->minor_version == 0)
1983 return 1;
1984
1985 /* otherwise we must be sure not to step on
1986 * any metadata, so stay:
1987 * 36K beyond start of superblock
1988 * beyond end of badblocks
1989 * beyond write-intent bitmap
1990 */
1991 if (rdev->sb_start + (32+4)*2 > new_offset)
1992 return 0;
1993 bitmap = rdev->mddev->bitmap;
1994 if (bitmap && !rdev->mddev->bitmap_info.file &&
1995 rdev->sb_start + rdev->mddev->bitmap_info.offset +
1996 bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
1997 return 0;
1998 if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
1999 return 0;
2000
2001 return 1;
2002}
2003
2004static struct super_type super_types[] = {
2005 [0] = {
2006 .name = "0.90.0",
2007 .owner = THIS_MODULE,
2008 .load_super = super_90_load,
2009 .validate_super = super_90_validate,
2010 .sync_super = super_90_sync,
2011 .rdev_size_change = super_90_rdev_size_change,
2012 .allow_new_offset = super_90_allow_new_offset,
2013 },
2014 [1] = {
2015 .name = "md-1",
2016 .owner = THIS_MODULE,
2017 .load_super = super_1_load,
2018 .validate_super = super_1_validate,
2019 .sync_super = super_1_sync,
2020 .rdev_size_change = super_1_rdev_size_change,
2021 .allow_new_offset = super_1_allow_new_offset,
2022 },
2023};
2024
2025static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
2026{
2027 if (mddev->sync_super) {
2028 mddev->sync_super(mddev, rdev);
2029 return;
2030 }
2031
2032 BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));
2033
2034 super_types[mddev->major_version].sync_super(mddev, rdev);
2035}
2036
2037static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
2038{
2039 struct md_rdev *rdev, *rdev2;
2040
2041 rcu_read_lock();
2042 rdev_for_each_rcu(rdev, mddev1)
2043 rdev_for_each_rcu(rdev2, mddev2)
2044 if (rdev->bdev->bd_contains ==
2045 rdev2->bdev->bd_contains) {
2046 rcu_read_unlock();
2047 return 1;
2048 }
2049 rcu_read_unlock();
2050 return 0;
2051}
2052
2053static LIST_HEAD(pending_raid_disks);
2054
2055/*
2056 * Try to register data integrity profile for an mddev
2057 *
2058 * This is called when an array is started and after a disk has been kicked
2059 * from the array. It only succeeds if all working and active component devices
2060 * are integrity capable with matching profiles.
2061 */
2062int md_integrity_register(struct mddev *mddev)
2063{
2064 struct md_rdev *rdev, *reference = NULL;
2065
2066 if (list_empty(&mddev->disks))
2067 return 0; /* nothing to do */
2068 if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
2069 return 0; /* shouldn't register, or already is */
2070 rdev_for_each(rdev, mddev) {
2071 /* skip spares and non-functional disks */
2072 if (test_bit(Faulty, &rdev->flags))
2073 continue;
2074 if (rdev->raid_disk < 0)
2075 continue;
2076 if (!reference) {
2077 /* Use the first rdev as the reference */
2078 reference = rdev;
2079 continue;
2080 }
2081 /* does this rdev's profile match the reference profile? */
2082 if (blk_integrity_compare(reference->bdev->bd_disk,
2083 rdev->bdev->bd_disk) < 0)
2084 return -EINVAL;
2085 }
2086 if (!reference || !bdev_get_integrity(reference->bdev))
2087 return 0;
2088 /*
2089 * All component devices are integrity capable and have matching
2090 * profiles, register the common profile for the md device.
2091 */
2092 if (blk_integrity_register(mddev->gendisk,
2093 bdev_get_integrity(reference->bdev)) != 0) {
2094 printk(KERN_ERR "md: failed to register integrity for %s\n",
2095 mdname(mddev));
2096 return -EINVAL;
2097 }
2098 printk(KERN_NOTICE "md: data integrity enabled on %s\n", mdname(mddev));
2099 if (bioset_integrity_create(mddev->bio_set, BIO_POOL_SIZE)) {
2100 printk(KERN_ERR "md: failed to create integrity pool for %s\n",
2101 mdname(mddev));
2102 return -EINVAL;
2103 }
2104 return 0;
2105}
2106EXPORT_SYMBOL(md_integrity_register);
2107
2108/* Disable data integrity if non-capable/non-matching disk is being added */
2109void md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
2110{
2111 struct blk_integrity *bi_rdev = bdev_get_integrity(rdev->bdev);
2112 struct blk_integrity *bi_mddev = blk_get_integrity(mddev->gendisk);
2113
2114 if (!bi_mddev) /* nothing to do */
2115 return;
2116 if (rdev->raid_disk < 0) /* skip spares */
2117 return;
2118 if (bi_rdev && blk_integrity_compare(mddev->gendisk,
2119 rdev->bdev->bd_disk) >= 0)
2120 return;
2121 printk(KERN_NOTICE "disabling data integrity on %s\n", mdname(mddev));
2122 blk_integrity_unregister(mddev->gendisk);
2123}
2124EXPORT_SYMBOL(md_integrity_add_rdev);
2125
2126static int bind_rdev_to_array(struct md_rdev * rdev, struct mddev * mddev)
2127{
2128 char b[BDEVNAME_SIZE];
2129 struct kobject *ko;
2130 char *s;
2131 int err;
2132
2133 if (rdev->mddev) {
2134 MD_BUG();
2135 return -EINVAL;
2136 }
2137
2138 /* prevent duplicates */
2139 if (find_rdev(mddev, rdev->bdev->bd_dev))
2140 return -EEXIST;
2141
2142 /* make sure rdev->sectors exceeds mddev->dev_sectors */
2143 if (rdev->sectors && (mddev->dev_sectors == 0 ||
2144 rdev->sectors < mddev->dev_sectors)) {
2145 if (mddev->pers) {
2146 /* Cannot change size, so fail
2147 * If mddev->level <= 0, then we don't care
2148 * about aligning sizes (e.g. linear)
2149 */
2150 if (mddev->level > 0)
2151 return -ENOSPC;
2152 } else
2153 mddev->dev_sectors = rdev->sectors;
2154 }
2155
2156 /* Verify rdev->desc_nr is unique.
2157 * If it is -1, assign a free number, else
2158 * check number is not in use
2159 */
2160 if (rdev->desc_nr < 0) {
2161 int choice = 0;
2162 if (mddev->pers) choice = mddev->raid_disks;
2163 while (find_rdev_nr(mddev, choice))
2164 choice++;
2165 rdev->desc_nr = choice;
2166 } else {
2167 if (find_rdev_nr(mddev, rdev->desc_nr))
2168 return -EBUSY;
2169 }
2170 if (mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
2171 printk(KERN_WARNING "md: %s: array is limited to %d devices\n",
2172 mdname(mddev), mddev->max_disks);
2173 return -EBUSY;
2174 }
2175 bdevname(rdev->bdev,b);
2176 while ( (s=strchr(b, '/')) != NULL)
2177 *s = '!';
2178
2179 rdev->mddev = mddev;
2180 printk(KERN_INFO "md: bind<%s>\n", b);
2181
2182 if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
2183 goto fail;
2184
2185 ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
2186 if (sysfs_create_link(&rdev->kobj, ko, "block"))
2187 /* failure here is OK */;
2188 rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
2189
2190 list_add_rcu(&rdev->same_set, &mddev->disks);
2191 bd_link_disk_holder(rdev->bdev, mddev->gendisk);
2192
2193 /* May as well allow recovery to be retried once */
2194 mddev->recovery_disabled++;
2195
2196 return 0;
2197
2198 fail:
2199 printk(KERN_WARNING "md: failed to register dev-%s for %s\n",
2200 b, mdname(mddev));
2201 return err;
2202}
2203
2204static void md_delayed_delete(struct work_struct *ws)
2205{
2206 struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
2207 kobject_del(&rdev->kobj);
2208 kobject_put(&rdev->kobj);
2209}
2210
2211static void unbind_rdev_from_array(struct md_rdev * rdev)
2212{
2213 char b[BDEVNAME_SIZE];
2214 if (!rdev->mddev) {
2215 MD_BUG();
2216 return;
2217 }
2218 bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
2219 list_del_rcu(&rdev->same_set);
2220 printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
2221 rdev->mddev = NULL;
2222 sysfs_remove_link(&rdev->kobj, "block");
2223 sysfs_put(rdev->sysfs_state);
2224 rdev->sysfs_state = NULL;
2225 rdev->badblocks.count = 0;
2226 /* We need to delay this, otherwise we can deadlock when
2227 * writing to 'remove' to "dev/state". We also need
2228 * to delay it due to rcu usage.
2229 */
2230 synchronize_rcu();
2231 INIT_WORK(&rdev->del_work, md_delayed_delete);
2232 kobject_get(&rdev->kobj);
2233 queue_work(md_misc_wq, &rdev->del_work);
2234}
2235
2236/*
2237 * prevent the device from being mounted, repartitioned or
2238 * otherwise reused by a RAID array (or any other kernel
2239 * subsystem), by bd_claiming the device.
2240 */
2241static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared)
2242{
2243 int err = 0;
2244 struct block_device *bdev;
2245 char b[BDEVNAME_SIZE];
2246
2247 bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
2248 shared ? (struct md_rdev *)lock_rdev : rdev);
2249 if (IS_ERR(bdev)) {
2250 printk(KERN_ERR "md: could not open %s.\n",
2251 __bdevname(dev, b));
2252 return PTR_ERR(bdev);
2253 }
2254 rdev->bdev = bdev;
2255 return err;
2256}
2257
2258static void unlock_rdev(struct md_rdev *rdev)
2259{
2260 struct block_device *bdev = rdev->bdev;
2261 rdev->bdev = NULL;
2262 if (!bdev)
2263 MD_BUG();
2264 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
2265}
2266
2267void md_autodetect_dev(dev_t dev);
2268
2269static void export_rdev(struct md_rdev * rdev)
2270{
2271 char b[BDEVNAME_SIZE];
2272 printk(KERN_INFO "md: export_rdev(%s)\n",
2273 bdevname(rdev->bdev,b));
2274 if (rdev->mddev)
2275 MD_BUG();
2276 md_rdev_clear(rdev);
2277#ifndef MODULE
2278 if (test_bit(AutoDetected, &rdev->flags))
2279 md_autodetect_dev(rdev->bdev->bd_dev);
2280#endif
2281 unlock_rdev(rdev);
2282 kobject_put(&rdev->kobj);
2283}
2284
2285static void kick_rdev_from_array(struct md_rdev * rdev)
2286{
2287 unbind_rdev_from_array(rdev);
2288 export_rdev(rdev);
2289}
2290
2291static void export_array(struct mddev *mddev)
2292{
2293 struct md_rdev *rdev, *tmp;
2294
2295 rdev_for_each_safe(rdev, tmp, mddev) {
2296 if (!rdev->mddev) {
2297 MD_BUG();
2298 continue;
2299 }
2300 kick_rdev_from_array(rdev);
2301 }
2302 if (!list_empty(&mddev->disks))
2303 MD_BUG();
2304 mddev->raid_disks = 0;
2305 mddev->major_version = 0;
2306}
2307
2308static void print_desc(mdp_disk_t *desc)
2309{
2310 printk(" DISK<N:%d,(%d,%d),R:%d,S:%d>\n", desc->number,
2311 desc->major,desc->minor,desc->raid_disk,desc->state);
2312}
2313
2314static void print_sb_90(mdp_super_t *sb)
2315{
2316 int i;
2317
2318 printk(KERN_INFO
2319 "md: SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n",
2320 sb->major_version, sb->minor_version, sb->patch_version,
2321 sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3,
2322 sb->ctime);
2323 printk(KERN_INFO "md: L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n",
2324 sb->level, sb->size, sb->nr_disks, sb->raid_disks,
2325 sb->md_minor, sb->layout, sb->chunk_size);
2326 printk(KERN_INFO "md: UT:%08x ST:%d AD:%d WD:%d"
2327 " FD:%d SD:%d CSUM:%08x E:%08lx\n",
2328 sb->utime, sb->state, sb->active_disks, sb->working_disks,
2329 sb->failed_disks, sb->spare_disks,
2330 sb->sb_csum, (unsigned long)sb->events_lo);
2331
2332 printk(KERN_INFO);
2333 for (i = 0; i < MD_SB_DISKS; i++) {
2334 mdp_disk_t *desc;
2335
2336 desc = sb->disks + i;
2337 if (desc->number || desc->major || desc->minor ||
2338 desc->raid_disk || (desc->state && (desc->state != 4))) {
2339 printk(" D %2d: ", i);
2340 print_desc(desc);
2341 }
2342 }
2343 printk(KERN_INFO "md: THIS: ");
2344 print_desc(&sb->this_disk);
2345}
2346
2347static void print_sb_1(struct mdp_superblock_1 *sb)
2348{
2349 __u8 *uuid;
2350
2351 uuid = sb->set_uuid;
2352 printk(KERN_INFO
2353 "md: SB: (V:%u) (F:0x%08x) Array-ID:<%pU>\n"
2354 "md: Name: \"%s\" CT:%llu\n",
2355 le32_to_cpu(sb->major_version),
2356 le32_to_cpu(sb->feature_map),
2357 uuid,
2358 sb->set_name,
2359 (unsigned long long)le64_to_cpu(sb->ctime)
2360 & MD_SUPERBLOCK_1_TIME_SEC_MASK);
2361
2362 uuid = sb->device_uuid;
2363 printk(KERN_INFO
2364 "md: L%u SZ%llu RD:%u LO:%u CS:%u DO:%llu DS:%llu SO:%llu"
2365 " RO:%llu\n"
2366 "md: Dev:%08x UUID: %pU\n"
2367 "md: (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
2368 "md: (MaxDev:%u) \n",
2369 le32_to_cpu(sb->level),
2370 (unsigned long long)le64_to_cpu(sb->size),
2371 le32_to_cpu(sb->raid_disks),
2372 le32_to_cpu(sb->layout),
2373 le32_to_cpu(sb->chunksize),
2374 (unsigned long long)le64_to_cpu(sb->data_offset),
2375 (unsigned long long)le64_to_cpu(sb->data_size),
2376 (unsigned long long)le64_to_cpu(sb->super_offset),
2377 (unsigned long long)le64_to_cpu(sb->recovery_offset),
2378 le32_to_cpu(sb->dev_number),
2379 uuid,
2380 sb->devflags,
2381 (unsigned long long)le64_to_cpu(sb->utime) & MD_SUPERBLOCK_1_TIME_SEC_MASK,
2382 (unsigned long long)le64_to_cpu(sb->events),
2383 (unsigned long long)le64_to_cpu(sb->resync_offset),
2384 le32_to_cpu(sb->sb_csum),
2385 le32_to_cpu(sb->max_dev)
2386 );
2387}
2388
2389static void print_rdev(struct md_rdev *rdev, int major_version)
2390{
2391 char b[BDEVNAME_SIZE];
2392 printk(KERN_INFO "md: rdev %s, Sect:%08llu F:%d S:%d DN:%u\n",
2393 bdevname(rdev->bdev, b), (unsigned long long)rdev->sectors,
2394 test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags),
2395 rdev->desc_nr);
2396 if (rdev->sb_loaded) {
2397 printk(KERN_INFO "md: rdev superblock (MJ:%d):\n", major_version);
2398 switch (major_version) {
2399 case 0:
2400 print_sb_90(page_address(rdev->sb_page));
2401 break;
2402 case 1:
2403 print_sb_1(page_address(rdev->sb_page));
2404 break;
2405 }
2406 } else
2407 printk(KERN_INFO "md: no rdev superblock!\n");
2408}
2409
2410static void md_print_devices(void)
2411{
2412 struct list_head *tmp;
2413 struct md_rdev *rdev;
2414 struct mddev *mddev;
2415 char b[BDEVNAME_SIZE];
2416
2417 printk("\n");
2418 printk("md: **********************************\n");
2419 printk("md: * <COMPLETE RAID STATE PRINTOUT> *\n");
2420 printk("md: **********************************\n");
2421 for_each_mddev(mddev, tmp) {
2422
2423 if (mddev->bitmap)
2424 bitmap_print_sb(mddev->bitmap);
2425 else
2426 printk("%s: ", mdname(mddev));
2427 rdev_for_each(rdev, mddev)
2428 printk("<%s>", bdevname(rdev->bdev,b));
2429 printk("\n");
2430
2431 rdev_for_each(rdev, mddev)
2432 print_rdev(rdev, mddev->major_version);
2433 }
2434 printk("md: **********************************\n");
2435 printk("\n");
2436}
2437
2438
2439static void sync_sbs(struct mddev * mddev, int nospares)
2440{
2441 /* Update each superblock (in-memory image), but
2442 * if we are allowed to, skip spares which already
2443 * have the right event counter, or have one earlier
2444 * (which would mean they aren't being marked as dirty
2445 * with the rest of the array)
2446 */
2447 struct md_rdev *rdev;
2448 rdev_for_each(rdev, mddev) {
2449 if (rdev->sb_events == mddev->events ||
2450 (nospares &&
2451 rdev->raid_disk < 0 &&
2452 rdev->sb_events+1 == mddev->events)) {
2453 /* Don't update this superblock */
2454 rdev->sb_loaded = 2;
2455 } else {
2456 sync_super(mddev, rdev);
2457 rdev->sb_loaded = 1;
2458 }
2459 }
2460}
2461
2462static void md_update_sb(struct mddev * mddev, int force_change)
2463{
2464 struct md_rdev *rdev;
2465 int sync_req;
2466 int nospares = 0;
2467 int any_badblocks_changed = 0;
2468
2469repeat:
2470 /* First make sure individual recovery_offsets are correct */
2471 rdev_for_each(rdev, mddev) {
2472 if (rdev->raid_disk >= 0 &&
2473 mddev->delta_disks >= 0 &&
2474 !test_bit(In_sync, &rdev->flags) &&
2475 mddev->curr_resync_completed > rdev->recovery_offset)
2476 rdev->recovery_offset = mddev->curr_resync_completed;
2477
2478 }
2479 if (!mddev->persistent) {
2480 clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2481 clear_bit(MD_CHANGE_DEVS, &mddev->flags);
2482 if (!mddev->external) {
2483 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2484 rdev_for_each(rdev, mddev) {
2485 if (rdev->badblocks.changed) {
2486 rdev->badblocks.changed = 0;
2487 md_ack_all_badblocks(&rdev->badblocks);
2488 md_error(mddev, rdev);
2489 }
2490 clear_bit(Blocked, &rdev->flags);
2491 clear_bit(BlockedBadBlocks, &rdev->flags);
2492 wake_up(&rdev->blocked_wait);
2493 }
2494 }
2495 wake_up(&mddev->sb_wait);
2496 return;
2497 }
2498
2499 spin_lock_irq(&mddev->write_lock);
2500
2501 mddev->utime = get_seconds();
2502
2503 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
2504 force_change = 1;
2505 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
2506 /* just a clean<-> dirty transition, possibly leave spares alone,
2507 * though if events isn't the right even/odd, we will have to do
2508 * spares after all
2509 */
2510 nospares = 1;
2511 if (force_change)
2512 nospares = 0;
2513 if (mddev->degraded)
2514 /* If the array is degraded, then skipping spares is both
2515 * dangerous and fairly pointless.
2516 * Dangerous because a device that was removed from the array
2517 * might have a event_count that still looks up-to-date,
2518 * so it can be re-added without a resync.
2519 * Pointless because if there are any spares to skip,
2520 * then a recovery will happen and soon that array won't
2521 * be degraded any more and the spare can go back to sleep then.
2522 */
2523 nospares = 0;
2524
2525 sync_req = mddev->in_sync;
2526
2527 /* If this is just a dirty<->clean transition, and the array is clean
2528 * and 'events' is odd, we can roll back to the previous clean state */
2529 if (nospares
2530 && (mddev->in_sync && mddev->recovery_cp == MaxSector)
2531 && mddev->can_decrease_events
2532 && mddev->events != 1) {
2533 mddev->events--;
2534 mddev->can_decrease_events = 0;
2535 } else {
2536 /* otherwise we have to go forward and ... */
2537 mddev->events ++;
2538 mddev->can_decrease_events = nospares;
2539 }
2540
2541 if (!mddev->events) {
2542 /*
2543 * oops, this 64-bit counter should never wrap.
2544 * Either we are in around ~1 trillion A.C., assuming
2545 * 1 reboot per second, or we have a bug:
2546 */
2547 MD_BUG();
2548 mddev->events --;
2549 }
2550
2551 rdev_for_each(rdev, mddev) {
2552 if (rdev->badblocks.changed)
2553 any_badblocks_changed++;
2554 if (test_bit(Faulty, &rdev->flags))
2555 set_bit(FaultRecorded, &rdev->flags);
2556 }
2557
2558 sync_sbs(mddev, nospares);
2559 spin_unlock_irq(&mddev->write_lock);
2560
2561 pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
2562 mdname(mddev), mddev->in_sync);
2563
2564 bitmap_update_sb(mddev->bitmap);
2565 rdev_for_each(rdev, mddev) {
2566 char b[BDEVNAME_SIZE];
2567
2568 if (rdev->sb_loaded != 1)
2569 continue; /* no noise on spare devices */
2570
2571 if (!test_bit(Faulty, &rdev->flags) &&
2572 rdev->saved_raid_disk == -1) {
2573 md_super_write(mddev,rdev,
2574 rdev->sb_start, rdev->sb_size,
2575 rdev->sb_page);
2576 pr_debug("md: (write) %s's sb offset: %llu\n",
2577 bdevname(rdev->bdev, b),
2578 (unsigned long long)rdev->sb_start);
2579 rdev->sb_events = mddev->events;
2580 if (rdev->badblocks.size) {
2581 md_super_write(mddev, rdev,
2582 rdev->badblocks.sector,
2583 rdev->badblocks.size << 9,
2584 rdev->bb_page);
2585 rdev->badblocks.size = 0;
2586 }
2587
2588 } else if (test_bit(Faulty, &rdev->flags))
2589 pr_debug("md: %s (skipping faulty)\n",
2590 bdevname(rdev->bdev, b));
2591 else
2592 pr_debug("(skipping incremental s/r ");
2593
2594 if (mddev->level == LEVEL_MULTIPATH)
2595 /* only need to write one superblock... */
2596 break;
2597 }
2598 md_super_wait(mddev);
2599 /* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
2600
2601 spin_lock_irq(&mddev->write_lock);
2602 if (mddev->in_sync != sync_req ||
2603 test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
2604 /* have to write it out again */
2605 spin_unlock_irq(&mddev->write_lock);
2606 goto repeat;
2607 }
2608 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2609 spin_unlock_irq(&mddev->write_lock);
2610 wake_up(&mddev->sb_wait);
2611 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2612 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
2613
2614 rdev_for_each(rdev, mddev) {
2615 if (test_and_clear_bit(FaultRecorded, &rdev->flags))
2616 clear_bit(Blocked, &rdev->flags);
2617
2618 if (any_badblocks_changed)
2619 md_ack_all_badblocks(&rdev->badblocks);
2620 clear_bit(BlockedBadBlocks, &rdev->flags);
2621 wake_up(&rdev->blocked_wait);
2622 }
2623}
2624
2625/* words written to sysfs files may, or may not, be \n terminated.
2626 * We want to accept with case. For this we use cmd_match.
2627 */
2628static int cmd_match(const char *cmd, const char *str)
2629{
2630 /* See if cmd, written into a sysfs file, matches
2631 * str. They must either be the same, or cmd can
2632 * have a trailing newline
2633 */
2634 while (*cmd && *str && *cmd == *str) {
2635 cmd++;
2636 str++;
2637 }
2638 if (*cmd == '\n')
2639 cmd++;
2640 if (*str || *cmd)
2641 return 0;
2642 return 1;
2643}
2644
2645struct rdev_sysfs_entry {
2646 struct attribute attr;
2647 ssize_t (*show)(struct md_rdev *, char *);
2648 ssize_t (*store)(struct md_rdev *, const char *, size_t);
2649};
2650
2651static ssize_t
2652state_show(struct md_rdev *rdev, char *page)
2653{
2654 char *sep = "";
2655 size_t len = 0;
2656
2657 if (test_bit(Faulty, &rdev->flags) ||
2658 rdev->badblocks.unacked_exist) {
2659 len+= sprintf(page+len, "%sfaulty",sep);
2660 sep = ",";
2661 }
2662 if (test_bit(In_sync, &rdev->flags)) {
2663 len += sprintf(page+len, "%sin_sync",sep);
2664 sep = ",";
2665 }
2666 if (test_bit(WriteMostly, &rdev->flags)) {
2667 len += sprintf(page+len, "%swrite_mostly",sep);
2668 sep = ",";
2669 }
2670 if (test_bit(Blocked, &rdev->flags) ||
2671 (rdev->badblocks.unacked_exist
2672 && !test_bit(Faulty, &rdev->flags))) {
2673 len += sprintf(page+len, "%sblocked", sep);
2674 sep = ",";
2675 }
2676 if (!test_bit(Faulty, &rdev->flags) &&
2677 !test_bit(In_sync, &rdev->flags)) {
2678 len += sprintf(page+len, "%sspare", sep);
2679 sep = ",";
2680 }
2681 if (test_bit(WriteErrorSeen, &rdev->flags)) {
2682 len += sprintf(page+len, "%swrite_error", sep);
2683 sep = ",";
2684 }
2685 if (test_bit(WantReplacement, &rdev->flags)) {
2686 len += sprintf(page+len, "%swant_replacement", sep);
2687 sep = ",";
2688 }
2689 if (test_bit(Replacement, &rdev->flags)) {
2690 len += sprintf(page+len, "%sreplacement", sep);
2691 sep = ",";
2692 }
2693
2694 return len+sprintf(page+len, "\n");
2695}
2696
2697static ssize_t
2698state_store(struct md_rdev *rdev, const char *buf, size_t len)
2699{
2700 /* can write
2701 * faulty - simulates an error
2702 * remove - disconnects the device
2703 * writemostly - sets write_mostly
2704 * -writemostly - clears write_mostly
2705 * blocked - sets the Blocked flags
2706 * -blocked - clears the Blocked and possibly simulates an error
2707 * insync - sets Insync providing device isn't active
2708 * write_error - sets WriteErrorSeen
2709 * -write_error - clears WriteErrorSeen
2710 */
2711 int err = -EINVAL;
2712 if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2713 md_error(rdev->mddev, rdev);
2714 if (test_bit(Faulty, &rdev->flags))
2715 err = 0;
2716 else
2717 err = -EBUSY;
2718 } else if (cmd_match(buf, "remove")) {
2719 if (rdev->raid_disk >= 0)
2720 err = -EBUSY;
2721 else {
2722 struct mddev *mddev = rdev->mddev;
2723 kick_rdev_from_array(rdev);
2724 if (mddev->pers)
2725 md_update_sb(mddev, 1);
2726 md_new_event(mddev);
2727 err = 0;
2728 }
2729 } else if (cmd_match(buf, "writemostly")) {
2730 set_bit(WriteMostly, &rdev->flags);
2731 err = 0;
2732 } else if (cmd_match(buf, "-writemostly")) {
2733 clear_bit(WriteMostly, &rdev->flags);
2734 err = 0;
2735 } else if (cmd_match(buf, "blocked")) {
2736 set_bit(Blocked, &rdev->flags);
2737 err = 0;
2738 } else if (cmd_match(buf, "-blocked")) {
2739 if (!test_bit(Faulty, &rdev->flags) &&
2740 rdev->badblocks.unacked_exist) {
2741 /* metadata handler doesn't understand badblocks,
2742 * so we need to fail the device
2743 */
2744 md_error(rdev->mddev, rdev);
2745 }
2746 clear_bit(Blocked, &rdev->flags);
2747 clear_bit(BlockedBadBlocks, &rdev->flags);
2748 wake_up(&rdev->blocked_wait);
2749 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2750 md_wakeup_thread(rdev->mddev->thread);
2751
2752 err = 0;
2753 } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
2754 set_bit(In_sync, &rdev->flags);
2755 err = 0;
2756 } else if (cmd_match(buf, "write_error")) {
2757 set_bit(WriteErrorSeen, &rdev->flags);
2758 err = 0;
2759 } else if (cmd_match(buf, "-write_error")) {
2760 clear_bit(WriteErrorSeen, &rdev->flags);
2761 err = 0;
2762 } else if (cmd_match(buf, "want_replacement")) {
2763 /* Any non-spare device that is not a replacement can
2764 * become want_replacement at any time, but we then need to
2765 * check if recovery is needed.
2766 */
2767 if (rdev->raid_disk >= 0 &&
2768 !test_bit(Replacement, &rdev->flags))
2769 set_bit(WantReplacement, &rdev->flags);
2770 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2771 md_wakeup_thread(rdev->mddev->thread);
2772 err = 0;
2773 } else if (cmd_match(buf, "-want_replacement")) {
2774 /* Clearing 'want_replacement' is always allowed.
2775 * Once replacements starts it is too late though.
2776 */
2777 err = 0;
2778 clear_bit(WantReplacement, &rdev->flags);
2779 } else if (cmd_match(buf, "replacement")) {
2780 /* Can only set a device as a replacement when array has not
2781 * yet been started. Once running, replacement is automatic
2782 * from spares, or by assigning 'slot'.
2783 */
2784 if (rdev->mddev->pers)
2785 err = -EBUSY;
2786 else {
2787 set_bit(Replacement, &rdev->flags);
2788 err = 0;
2789 }
2790 } else if (cmd_match(buf, "-replacement")) {
2791 /* Similarly, can only clear Replacement before start */
2792 if (rdev->mddev->pers)
2793 err = -EBUSY;
2794 else {
2795 clear_bit(Replacement, &rdev->flags);
2796 err = 0;
2797 }
2798 }
2799 if (!err)
2800 sysfs_notify_dirent_safe(rdev->sysfs_state);
2801 return err ? err : len;
2802}
2803static struct rdev_sysfs_entry rdev_state =
2804__ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store);
2805
2806static ssize_t
2807errors_show(struct md_rdev *rdev, char *page)
2808{
2809 return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
2810}
2811
2812static ssize_t
2813errors_store(struct md_rdev *rdev, const char *buf, size_t len)
2814{
2815 char *e;
2816 unsigned long n = simple_strtoul(buf, &e, 10);
2817 if (*buf && (*e == 0 || *e == '\n')) {
2818 atomic_set(&rdev->corrected_errors, n);
2819 return len;
2820 }
2821 return -EINVAL;
2822}
2823static struct rdev_sysfs_entry rdev_errors =
2824__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
2825
2826static ssize_t
2827slot_show(struct md_rdev *rdev, char *page)
2828{
2829 if (rdev->raid_disk < 0)
2830 return sprintf(page, "none\n");
2831 else
2832 return sprintf(page, "%d\n", rdev->raid_disk);
2833}
2834
2835static ssize_t
2836slot_store(struct md_rdev *rdev, const char *buf, size_t len)
2837{
2838 char *e;
2839 int err;
2840 int slot = simple_strtoul(buf, &e, 10);
2841 if (strncmp(buf, "none", 4)==0)
2842 slot = -1;
2843 else if (e==buf || (*e && *e!= '\n'))
2844 return -EINVAL;
2845 if (rdev->mddev->pers && slot == -1) {
2846 /* Setting 'slot' on an active array requires also
2847 * updating the 'rd%d' link, and communicating
2848 * with the personality with ->hot_*_disk.
2849 * For now we only support removing
2850 * failed/spare devices. This normally happens automatically,
2851 * but not when the metadata is externally managed.
2852 */
2853 if (rdev->raid_disk == -1)
2854 return -EEXIST;
2855 /* personality does all needed checks */
2856 if (rdev->mddev->pers->hot_remove_disk == NULL)
2857 return -EINVAL;
2858 err = rdev->mddev->pers->
2859 hot_remove_disk(rdev->mddev, rdev);
2860 if (err)
2861 return err;
2862 sysfs_unlink_rdev(rdev->mddev, rdev);
2863 rdev->raid_disk = -1;
2864 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2865 md_wakeup_thread(rdev->mddev->thread);
2866 } else if (rdev->mddev->pers) {
2867 /* Activating a spare .. or possibly reactivating
2868 * if we ever get bitmaps working here.
2869 */
2870
2871 if (rdev->raid_disk != -1)
2872 return -EBUSY;
2873
2874 if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
2875 return -EBUSY;
2876
2877 if (rdev->mddev->pers->hot_add_disk == NULL)
2878 return -EINVAL;
2879
2880 if (slot >= rdev->mddev->raid_disks &&
2881 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
2882 return -ENOSPC;
2883
2884 rdev->raid_disk = slot;
2885 if (test_bit(In_sync, &rdev->flags))
2886 rdev->saved_raid_disk = slot;
2887 else
2888 rdev->saved_raid_disk = -1;
2889 clear_bit(In_sync, &rdev->flags);
2890 err = rdev->mddev->pers->
2891 hot_add_disk(rdev->mddev, rdev);
2892 if (err) {
2893 rdev->raid_disk = -1;
2894 return err;
2895 } else
2896 sysfs_notify_dirent_safe(rdev->sysfs_state);
2897 if (sysfs_link_rdev(rdev->mddev, rdev))
2898 /* failure here is OK */;
2899 /* don't wakeup anyone, leave that to userspace. */
2900 } else {
2901 if (slot >= rdev->mddev->raid_disks &&
2902 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
2903 return -ENOSPC;
2904 rdev->raid_disk = slot;
2905 /* assume it is working */
2906 clear_bit(Faulty, &rdev->flags);
2907 clear_bit(WriteMostly, &rdev->flags);
2908 set_bit(In_sync, &rdev->flags);
2909 sysfs_notify_dirent_safe(rdev->sysfs_state);
2910 }
2911 return len;
2912}
2913
2914
2915static struct rdev_sysfs_entry rdev_slot =
2916__ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
2917
2918static ssize_t
2919offset_show(struct md_rdev *rdev, char *page)
2920{
2921 return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
2922}
2923
2924static ssize_t
2925offset_store(struct md_rdev *rdev, const char *buf, size_t len)
2926{
2927 unsigned long long offset;
2928 if (strict_strtoull(buf, 10, &offset) < 0)
2929 return -EINVAL;
2930 if (rdev->mddev->pers && rdev->raid_disk >= 0)
2931 return -EBUSY;
2932 if (rdev->sectors && rdev->mddev->external)
2933 /* Must set offset before size, so overlap checks
2934 * can be sane */
2935 return -EBUSY;
2936 rdev->data_offset = offset;
2937 rdev->new_data_offset = offset;
2938 return len;
2939}
2940
2941static struct rdev_sysfs_entry rdev_offset =
2942__ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
2943
2944static ssize_t new_offset_show(struct md_rdev *rdev, char *page)
2945{
2946 return sprintf(page, "%llu\n",
2947 (unsigned long long)rdev->new_data_offset);
2948}
2949
2950static ssize_t new_offset_store(struct md_rdev *rdev,
2951 const char *buf, size_t len)
2952{
2953 unsigned long long new_offset;
2954 struct mddev *mddev = rdev->mddev;
2955
2956 if (strict_strtoull(buf, 10, &new_offset) < 0)
2957 return -EINVAL;
2958
2959 if (mddev->sync_thread)
2960 return -EBUSY;
2961 if (new_offset == rdev->data_offset)
2962 /* reset is always permitted */
2963 ;
2964 else if (new_offset > rdev->data_offset) {
2965 /* must not push array size beyond rdev_sectors */
2966 if (new_offset - rdev->data_offset
2967 + mddev->dev_sectors > rdev->sectors)
2968 return -E2BIG;
2969 }
2970 /* Metadata worries about other space details. */
2971
2972 /* decreasing the offset is inconsistent with a backwards
2973 * reshape.
2974 */
2975 if (new_offset < rdev->data_offset &&
2976 mddev->reshape_backwards)
2977 return -EINVAL;
2978 /* Increasing offset is inconsistent with forwards
2979 * reshape. reshape_direction should be set to
2980 * 'backwards' first.
2981 */
2982 if (new_offset > rdev->data_offset &&
2983 !mddev->reshape_backwards)
2984 return -EINVAL;
2985
2986 if (mddev->pers && mddev->persistent &&
2987 !super_types[mddev->major_version]
2988 .allow_new_offset(rdev, new_offset))
2989 return -E2BIG;
2990 rdev->new_data_offset = new_offset;
2991 if (new_offset > rdev->data_offset)
2992 mddev->reshape_backwards = 1;
2993 else if (new_offset < rdev->data_offset)
2994 mddev->reshape_backwards = 0;
2995
2996 return len;
2997}
2998static struct rdev_sysfs_entry rdev_new_offset =
2999__ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store);
3000
3001static ssize_t
3002rdev_size_show(struct md_rdev *rdev, char *page)
3003{
3004 return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
3005}
3006
3007static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
3008{
3009 /* check if two start/length pairs overlap */
3010 if (s1+l1 <= s2)
3011 return 0;
3012 if (s2+l2 <= s1)
3013 return 0;
3014 return 1;
3015}
3016
3017static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
3018{
3019 unsigned long long blocks;
3020 sector_t new;
3021
3022 if (strict_strtoull(buf, 10, &blocks) < 0)
3023 return -EINVAL;
3024
3025 if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
3026 return -EINVAL; /* sector conversion overflow */
3027
3028 new = blocks * 2;
3029 if (new != blocks * 2)
3030 return -EINVAL; /* unsigned long long to sector_t overflow */
3031
3032 *sectors = new;
3033 return 0;
3034}
3035
3036static ssize_t
3037rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
3038{
3039 struct mddev *my_mddev = rdev->mddev;
3040 sector_t oldsectors = rdev->sectors;
3041 sector_t sectors;
3042
3043 if (strict_blocks_to_sectors(buf, §ors) < 0)
3044 return -EINVAL;
3045 if (rdev->data_offset != rdev->new_data_offset)
3046 return -EINVAL; /* too confusing */
3047 if (my_mddev->pers && rdev->raid_disk >= 0) {
3048 if (my_mddev->persistent) {
3049 sectors = super_types[my_mddev->major_version].
3050 rdev_size_change(rdev, sectors);
3051 if (!sectors)
3052 return -EBUSY;
3053 } else if (!sectors)
3054 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
3055 rdev->data_offset;
3056 }
3057 if (sectors < my_mddev->dev_sectors)
3058 return -EINVAL; /* component must fit device */
3059
3060 rdev->sectors = sectors;
3061 if (sectors > oldsectors && my_mddev->external) {
3062 /* need to check that all other rdevs with the same ->bdev
3063 * do not overlap. We need to unlock the mddev to avoid
3064 * a deadlock. We have already changed rdev->sectors, and if
3065 * we have to change it back, we will have the lock again.
3066 */
3067 struct mddev *mddev;
3068 int overlap = 0;
3069 struct list_head *tmp;
3070
3071 mddev_unlock(my_mddev);
3072 for_each_mddev(mddev, tmp) {
3073 struct md_rdev *rdev2;
3074
3075 mddev_lock(mddev);
3076 rdev_for_each(rdev2, mddev)
3077 if (rdev->bdev == rdev2->bdev &&
3078 rdev != rdev2 &&
3079 overlaps(rdev->data_offset, rdev->sectors,
3080 rdev2->data_offset,
3081 rdev2->sectors)) {
3082 overlap = 1;
3083 break;
3084 }
3085 mddev_unlock(mddev);
3086 if (overlap) {
3087 mddev_put(mddev);
3088 break;
3089 }
3090 }
3091 mddev_lock(my_mddev);
3092 if (overlap) {
3093 /* Someone else could have slipped in a size
3094 * change here, but doing so is just silly.
3095 * We put oldsectors back because we *know* it is
3096 * safe, and trust userspace not to race with
3097 * itself
3098 */
3099 rdev->sectors = oldsectors;
3100 return -EBUSY;
3101 }
3102 }
3103 return len;
3104}
3105
3106static struct rdev_sysfs_entry rdev_size =
3107__ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
3108
3109
3110static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
3111{
3112 unsigned long long recovery_start = rdev->recovery_offset;
3113
3114 if (test_bit(In_sync, &rdev->flags) ||
3115 recovery_start == MaxSector)
3116 return sprintf(page, "none\n");
3117
3118 return sprintf(page, "%llu\n", recovery_start);
3119}
3120
3121static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
3122{
3123 unsigned long long recovery_start;
3124
3125 if (cmd_match(buf, "none"))
3126 recovery_start = MaxSector;
3127 else if (strict_strtoull(buf, 10, &recovery_start))
3128 return -EINVAL;
3129
3130 if (rdev->mddev->pers &&
3131 rdev->raid_disk >= 0)
3132 return -EBUSY;
3133
3134 rdev->recovery_offset = recovery_start;
3135 if (recovery_start == MaxSector)
3136 set_bit(In_sync, &rdev->flags);
3137 else
3138 clear_bit(In_sync, &rdev->flags);
3139 return len;
3140}
3141
3142static struct rdev_sysfs_entry rdev_recovery_start =
3143__ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);
3144
3145
3146static ssize_t
3147badblocks_show(struct badblocks *bb, char *page, int unack);
3148static ssize_t
3149badblocks_store(struct badblocks *bb, const char *page, size_t len, int unack);
3150
3151static ssize_t bb_show(struct md_rdev *rdev, char *page)
3152{
3153 return badblocks_show(&rdev->badblocks, page, 0);
3154}
3155static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
3156{
3157 int rv = badblocks_store(&rdev->badblocks, page, len, 0);
3158 /* Maybe that ack was all we needed */
3159 if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags))
3160 wake_up(&rdev->blocked_wait);
3161 return rv;
3162}
3163static struct rdev_sysfs_entry rdev_bad_blocks =
3164__ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);
3165
3166
3167static ssize_t ubb_show(struct md_rdev *rdev, char *page)
3168{
3169 return badblocks_show(&rdev->badblocks, page, 1);
3170}
3171static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
3172{
3173 return badblocks_store(&rdev->badblocks, page, len, 1);
3174}
3175static struct rdev_sysfs_entry rdev_unack_bad_blocks =
3176__ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store);
3177
3178static struct attribute *rdev_default_attrs[] = {
3179 &rdev_state.attr,
3180 &rdev_errors.attr,
3181 &rdev_slot.attr,
3182 &rdev_offset.attr,
3183 &rdev_new_offset.attr,
3184 &rdev_size.attr,
3185 &rdev_recovery_start.attr,
3186 &rdev_bad_blocks.attr,
3187 &rdev_unack_bad_blocks.attr,
3188 NULL,
3189};
3190static ssize_t
3191rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
3192{
3193 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
3194 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
3195 struct mddev *mddev = rdev->mddev;
3196 ssize_t rv;
3197
3198 if (!entry->show)
3199 return -EIO;
3200
3201 rv = mddev ? mddev_lock(mddev) : -EBUSY;
3202 if (!rv) {
3203 if (rdev->mddev == NULL)
3204 rv = -EBUSY;
3205 else
3206 rv = entry->show(rdev, page);
3207 mddev_unlock(mddev);
3208 }
3209 return rv;
3210}
3211
3212static ssize_t
3213rdev_attr_store(struct kobject *kobj, struct attribute *attr,
3214 const char *page, size_t length)
3215{
3216 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
3217 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
3218 ssize_t rv;
3219 struct mddev *mddev = rdev->mddev;
3220
3221 if (!entry->store)
3222 return -EIO;
3223 if (!capable(CAP_SYS_ADMIN))
3224 return -EACCES;
3225 rv = mddev ? mddev_lock(mddev): -EBUSY;
3226 if (!rv) {
3227 if (rdev->mddev == NULL)
3228 rv = -EBUSY;
3229 else
3230 rv = entry->store(rdev, page, length);
3231 mddev_unlock(mddev);
3232 }
3233 return rv;
3234}
3235
3236static void rdev_free(struct kobject *ko)
3237{
3238 struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
3239 kfree(rdev);
3240}
3241static const struct sysfs_ops rdev_sysfs_ops = {
3242 .show = rdev_attr_show,
3243 .store = rdev_attr_store,
3244};
3245static struct kobj_type rdev_ktype = {
3246 .release = rdev_free,
3247 .sysfs_ops = &rdev_sysfs_ops,
3248 .default_attrs = rdev_default_attrs,
3249};
3250
3251int md_rdev_init(struct md_rdev *rdev)
3252{
3253 rdev->desc_nr = -1;
3254 rdev->saved_raid_disk = -1;
3255 rdev->raid_disk = -1;
3256 rdev->flags = 0;
3257 rdev->data_offset = 0;
3258 rdev->new_data_offset = 0;
3259 rdev->sb_events = 0;
3260 rdev->last_read_error.tv_sec = 0;
3261 rdev->last_read_error.tv_nsec = 0;
3262 rdev->sb_loaded = 0;
3263 rdev->bb_page = NULL;
3264 atomic_set(&rdev->nr_pending, 0);
3265 atomic_set(&rdev->read_errors, 0);
3266 atomic_set(&rdev->corrected_errors, 0);
3267
3268 INIT_LIST_HEAD(&rdev->same_set);
3269 init_waitqueue_head(&rdev->blocked_wait);
3270
3271 /* Add space to store bad block list.
3272 * This reserves the space even on arrays where it cannot
3273 * be used - I wonder if that matters
3274 */
3275 rdev->badblocks.count = 0;
3276 rdev->badblocks.shift = 0;
3277 rdev->badblocks.page = kmalloc(PAGE_SIZE, GFP_KERNEL);
3278 seqlock_init(&rdev->badblocks.lock);
3279 if (rdev->badblocks.page == NULL)
3280 return -ENOMEM;
3281
3282 return 0;
3283}
3284EXPORT_SYMBOL_GPL(md_rdev_init);
3285/*
3286 * Import a device. If 'super_format' >= 0, then sanity check the superblock
3287 *
3288 * mark the device faulty if:
3289 *
3290 * - the device is nonexistent (zero size)
3291 * - the device has no valid superblock
3292 *
3293 * a faulty rdev _never_ has rdev->sb set.
3294 */
3295static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
3296{
3297 char b[BDEVNAME_SIZE];
3298 int err;
3299 struct md_rdev *rdev;
3300 sector_t size;
3301
3302 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
3303 if (!rdev) {
3304 printk(KERN_ERR "md: could not alloc mem for new device!\n");
3305 return ERR_PTR(-ENOMEM);
3306 }
3307
3308 err = md_rdev_init(rdev);
3309 if (err)
3310 goto abort_free;
3311 err = alloc_disk_sb(rdev);
3312 if (err)
3313 goto abort_free;
3314
3315 err = lock_rdev(rdev, newdev, super_format == -2);
3316 if (err)
3317 goto abort_free;
3318
3319 kobject_init(&rdev->kobj, &rdev_ktype);
3320
3321 size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
3322 if (!size) {
3323 printk(KERN_WARNING
3324 "md: %s has zero or unknown size, marking faulty!\n",
3325 bdevname(rdev->bdev,b));
3326 err = -EINVAL;
3327 goto abort_free;
3328 }
3329
3330 if (super_format >= 0) {
3331 err = super_types[super_format].
3332 load_super(rdev, NULL, super_minor);
3333 if (err == -EINVAL) {
3334 printk(KERN_WARNING
3335 "md: %s does not have a valid v%d.%d "
3336 "superblock, not importing!\n",
3337 bdevname(rdev->bdev,b),
3338 super_format, super_minor);
3339 goto abort_free;
3340 }
3341 if (err < 0) {
3342 printk(KERN_WARNING
3343 "md: could not read %s's sb, not importing!\n",
3344 bdevname(rdev->bdev,b));
3345 goto abort_free;
3346 }
3347 }
3348 if (super_format == -1)
3349 /* hot-add for 0.90, or non-persistent: so no badblocks */
3350 rdev->badblocks.shift = -1;
3351
3352 return rdev;
3353
3354abort_free:
3355 if (rdev->bdev)
3356 unlock_rdev(rdev);
3357 md_rdev_clear(rdev);
3358 kfree(rdev);
3359 return ERR_PTR(err);
3360}
3361
3362/*
3363 * Check a full RAID array for plausibility
3364 */
3365
3366
3367static void analyze_sbs(struct mddev * mddev)
3368{
3369 int i;
3370 struct md_rdev *rdev, *freshest, *tmp;
3371 char b[BDEVNAME_SIZE];
3372
3373 freshest = NULL;
3374 rdev_for_each_safe(rdev, tmp, mddev)
3375 switch (super_types[mddev->major_version].
3376 load_super(rdev, freshest, mddev->minor_version)) {
3377 case 1:
3378 freshest = rdev;
3379 break;
3380 case 0:
3381 break;
3382 default:
3383 printk( KERN_ERR \
3384 "md: fatal superblock inconsistency in %s"
3385 " -- removing from array\n",
3386 bdevname(rdev->bdev,b));
3387 kick_rdev_from_array(rdev);
3388 }
3389
3390
3391 super_types[mddev->major_version].
3392 validate_super(mddev, freshest);
3393
3394 i = 0;
3395 rdev_for_each_safe(rdev, tmp, mddev) {
3396 if (mddev->max_disks &&
3397 (rdev->desc_nr >= mddev->max_disks ||
3398 i > mddev->max_disks)) {
3399 printk(KERN_WARNING
3400 "md: %s: %s: only %d devices permitted\n",
3401 mdname(mddev), bdevname(rdev->bdev, b),
3402 mddev->max_disks);
3403 kick_rdev_from_array(rdev);
3404 continue;
3405 }
3406 if (rdev != freshest)
3407 if (super_types[mddev->major_version].
3408 validate_super(mddev, rdev)) {
3409 printk(KERN_WARNING "md: kicking non-fresh %s"
3410 " from array!\n",
3411 bdevname(rdev->bdev,b));
3412 kick_rdev_from_array(rdev);
3413 continue;
3414 }
3415 if (mddev->level == LEVEL_MULTIPATH) {
3416 rdev->desc_nr = i++;
3417 rdev->raid_disk = rdev->desc_nr;
3418 set_bit(In_sync, &rdev->flags);
3419 } else if (rdev->raid_disk >= (mddev->raid_disks - min(0, mddev->delta_disks))) {
3420 rdev->raid_disk = -1;
3421 clear_bit(In_sync, &rdev->flags);
3422 }
3423 }
3424}
3425
3426/* Read a fixed-point number.
3427 * Numbers in sysfs attributes should be in "standard" units where
3428 * possible, so time should be in seconds.
3429 * However we internally use a a much smaller unit such as
3430 * milliseconds or jiffies.
3431 * This function takes a decimal number with a possible fractional
3432 * component, and produces an integer which is the result of
3433 * multiplying that number by 10^'scale'.
3434 * all without any floating-point arithmetic.
3435 */
3436int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
3437{
3438 unsigned long result = 0;
3439 long decimals = -1;
3440 while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
3441 if (*cp == '.')
3442 decimals = 0;
3443 else if (decimals < scale) {
3444 unsigned int value;
3445 value = *cp - '0';
3446 result = result * 10 + value;
3447 if (decimals >= 0)
3448 decimals++;
3449 }
3450 cp++;
3451 }
3452 if (*cp == '\n')
3453 cp++;
3454 if (*cp)
3455 return -EINVAL;
3456 if (decimals < 0)
3457 decimals = 0;
3458 while (decimals < scale) {
3459 result *= 10;
3460 decimals ++;
3461 }
3462 *res = result;
3463 return 0;
3464}
3465
3466
3467static void md_safemode_timeout(unsigned long data);
3468
3469static ssize_t
3470safe_delay_show(struct mddev *mddev, char *page)
3471{
3472 int msec = (mddev->safemode_delay*1000)/HZ;
3473 return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
3474}
3475static ssize_t
3476safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
3477{
3478 unsigned long msec;
3479
3480 if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
3481 return -EINVAL;
3482 if (msec == 0)
3483 mddev->safemode_delay = 0;
3484 else {
3485 unsigned long old_delay = mddev->safemode_delay;
3486 mddev->safemode_delay = (msec*HZ)/1000;
3487 if (mddev->safemode_delay == 0)
3488 mddev->safemode_delay = 1;
3489 if (mddev->safemode_delay < old_delay)
3490 md_safemode_timeout((unsigned long)mddev);
3491 }
3492 return len;
3493}
3494static struct md_sysfs_entry md_safe_delay =
3495__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
3496
3497static ssize_t
3498level_show(struct mddev *mddev, char *page)
3499{
3500 struct md_personality *p = mddev->pers;
3501 if (p)
3502 return sprintf(page, "%s\n", p->name);
3503 else if (mddev->clevel[0])
3504 return sprintf(page, "%s\n", mddev->clevel);
3505 else if (mddev->level != LEVEL_NONE)
3506 return sprintf(page, "%d\n", mddev->level);
3507 else
3508 return 0;
3509}
3510
3511static ssize_t
3512level_store(struct mddev *mddev, const char *buf, size_t len)
3513{
3514 char clevel[16];
3515 ssize_t rv = len;
3516 struct md_personality *pers;
3517 long level;
3518 void *priv;
3519 struct md_rdev *rdev;
3520
3521 if (mddev->pers == NULL) {
3522 if (len == 0)
3523 return 0;
3524 if (len >= sizeof(mddev->clevel))
3525 return -ENOSPC;
3526 strncpy(mddev->clevel, buf, len);
3527 if (mddev->clevel[len-1] == '\n')
3528 len--;
3529 mddev->clevel[len] = 0;
3530 mddev->level = LEVEL_NONE;
3531 return rv;
3532 }
3533
3534 /* request to change the personality. Need to ensure:
3535 * - array is not engaged in resync/recovery/reshape
3536 * - old personality can be suspended
3537 * - new personality will access other array.
3538 */
3539
3540 if (mddev->sync_thread ||
3541 mddev->reshape_position != MaxSector ||
3542 mddev->sysfs_active)
3543 return -EBUSY;
3544
3545 if (!mddev->pers->quiesce) {
3546 printk(KERN_WARNING "md: %s: %s does not support online personality change\n",
3547 mdname(mddev), mddev->pers->name);
3548 return -EINVAL;
3549 }
3550
3551 /* Now find the new personality */
3552 if (len == 0 || len >= sizeof(clevel))
3553 return -EINVAL;
3554 strncpy(clevel, buf, len);
3555 if (clevel[len-1] == '\n')
3556 len--;
3557 clevel[len] = 0;
3558 if (strict_strtol(clevel, 10, &level))
3559 level = LEVEL_NONE;
3560
3561 if (request_module("md-%s", clevel) != 0)
3562 request_module("md-level-%s", clevel);
3563 spin_lock(&pers_lock);
3564 pers = find_pers(level, clevel);
3565 if (!pers || !try_module_get(pers->owner)) {
3566 spin_unlock(&pers_lock);
3567 printk(KERN_WARNING "md: personality %s not loaded\n", clevel);
3568 return -EINVAL;
3569 }
3570 spin_unlock(&pers_lock);
3571
3572 if (pers == mddev->pers) {
3573 /* Nothing to do! */
3574 module_put(pers->owner);
3575 return rv;
3576 }
3577 if (!pers->takeover) {
3578 module_put(pers->owner);
3579 printk(KERN_WARNING "md: %s: %s does not support personality takeover\n",
3580 mdname(mddev), clevel);
3581 return -EINVAL;
3582 }
3583
3584 rdev_for_each(rdev, mddev)
3585 rdev->new_raid_disk = rdev->raid_disk;
3586
3587 /* ->takeover must set new_* and/or delta_disks
3588 * if it succeeds, and may set them when it fails.
3589 */
3590 priv = pers->takeover(mddev);
3591 if (IS_ERR(priv)) {
3592 mddev->new_level = mddev->level;
3593 mddev->new_layout = mddev->layout;
3594 mddev->new_chunk_sectors = mddev->chunk_sectors;
3595 mddev->raid_disks -= mddev->delta_disks;
3596 mddev->delta_disks = 0;
3597 mddev->reshape_backwards = 0;
3598 module_put(pers->owner);
3599 printk(KERN_WARNING "md: %s: %s would not accept array\n",
3600 mdname(mddev), clevel);
3601 return PTR_ERR(priv);
3602 }
3603
3604 /* Looks like we have a winner */
3605 mddev_suspend(mddev);
3606 mddev->pers->stop(mddev);
3607
3608 if (mddev->pers->sync_request == NULL &&
3609 pers->sync_request != NULL) {
3610 /* need to add the md_redundancy_group */
3611 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
3612 printk(KERN_WARNING
3613 "md: cannot register extra attributes for %s\n",
3614 mdname(mddev));
3615 mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, NULL, "sync_action");
3616 }
3617 if (mddev->pers->sync_request != NULL &&
3618 pers->sync_request == NULL) {
3619 /* need to remove the md_redundancy_group */
3620 if (mddev->to_remove == NULL)
3621 mddev->to_remove = &md_redundancy_group;
3622 }
3623
3624 if (mddev->pers->sync_request == NULL &&
3625 mddev->external) {
3626 /* We are converting from a no-redundancy array
3627 * to a redundancy array and metadata is managed
3628 * externally so we need to be sure that writes
3629 * won't block due to a need to transition
3630 * clean->dirty
3631 * until external management is started.
3632 */
3633 mddev->in_sync = 0;
3634 mddev->safemode_delay = 0;
3635 mddev->safemode = 0;
3636 }
3637
3638 rdev_for_each(rdev, mddev) {
3639 if (rdev->raid_disk < 0)
3640 continue;
3641 if (rdev->new_raid_disk >= mddev->raid_disks)
3642 rdev->new_raid_disk = -1;
3643 if (rdev->new_raid_disk == rdev->raid_disk)
3644 continue;
3645 sysfs_unlink_rdev(mddev, rdev);
3646 }
3647 rdev_for_each(rdev, mddev) {
3648 if (rdev->raid_disk < 0)
3649 continue;
3650 if (rdev->new_raid_disk == rdev->raid_disk)
3651 continue;
3652 rdev->raid_disk = rdev->new_raid_disk;
3653 if (rdev->raid_disk < 0)
3654 clear_bit(In_sync, &rdev->flags);
3655 else {
3656 if (sysfs_link_rdev(mddev, rdev))
3657 printk(KERN_WARNING "md: cannot register rd%d"
3658 " for %s after level change\n",
3659 rdev->raid_disk, mdname(mddev));
3660 }
3661 }
3662
3663 module_put(mddev->pers->owner);
3664 mddev->pers = pers;
3665 mddev->private = priv;
3666 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3667 mddev->level = mddev->new_level;
3668 mddev->layout = mddev->new_layout;
3669 mddev->chunk_sectors = mddev->new_chunk_sectors;
3670 mddev->delta_disks = 0;
3671 mddev->reshape_backwards = 0;
3672 mddev->degraded = 0;
3673 if (mddev->pers->sync_request == NULL) {
3674 /* this is now an array without redundancy, so
3675 * it must always be in_sync
3676 */
3677 mddev->in_sync = 1;
3678 del_timer_sync(&mddev->safemode_timer);
3679 }
3680 pers->run(mddev);
3681 set_bit(MD_CHANGE_DEVS, &mddev->flags);
3682 mddev_resume(mddev);
3683 sysfs_notify(&mddev->kobj, NULL, "level");
3684 md_new_event(mddev);
3685 return rv;
3686}
3687
3688static struct md_sysfs_entry md_level =
3689__ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
3690
3691
3692static ssize_t
3693layout_show(struct mddev *mddev, char *page)
3694{
3695 /* just a number, not meaningful for all levels */
3696 if (mddev->reshape_position != MaxSector &&
3697 mddev->layout != mddev->new_layout)
3698 return sprintf(page, "%d (%d)\n",
3699 mddev->new_layout, mddev->layout);
3700 return sprintf(page, "%d\n", mddev->layout);
3701}
3702
3703static ssize_t
3704layout_store(struct mddev *mddev, const char *buf, size_t len)
3705{
3706 char *e;
3707 unsigned long n = simple_strtoul(buf, &e, 10);
3708
3709 if (!*buf || (*e && *e != '\n'))
3710 return -EINVAL;
3711
3712 if (mddev->pers) {
3713 int err;
3714 if (mddev->pers->check_reshape == NULL)
3715 return -EBUSY;
3716 mddev->new_layout = n;
3717 err = mddev->pers->check_reshape(mddev);
3718 if (err) {
3719 mddev->new_layout = mddev->layout;
3720 return err;
3721 }
3722 } else {
3723 mddev->new_layout = n;
3724 if (mddev->reshape_position == MaxSector)
3725 mddev->layout = n;
3726 }
3727 return len;
3728}
3729static struct md_sysfs_entry md_layout =
3730__ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
3731
3732
3733static ssize_t
3734raid_disks_show(struct mddev *mddev, char *page)
3735{
3736 if (mddev->raid_disks == 0)
3737 return 0;
3738 if (mddev->reshape_position != MaxSector &&
3739 mddev->delta_disks != 0)
3740 return sprintf(page, "%d (%d)\n", mddev->raid_disks,
3741 mddev->raid_disks - mddev->delta_disks);
3742 return sprintf(page, "%d\n", mddev->raid_disks);
3743}
3744
3745static int update_raid_disks(struct mddev *mddev, int raid_disks);
3746
3747static ssize_t
3748raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
3749{
3750 char *e;
3751 int rv = 0;
3752 unsigned long n = simple_strtoul(buf, &e, 10);
3753
3754 if (!*buf || (*e && *e != '\n'))
3755 return -EINVAL;
3756
3757 if (mddev->pers)
3758 rv = update_raid_disks(mddev, n);
3759 else if (mddev->reshape_position != MaxSector) {
3760 struct md_rdev *rdev;
3761 int olddisks = mddev->raid_disks - mddev->delta_disks;
3762
3763 rdev_for_each(rdev, mddev) {
3764 if (olddisks < n &&
3765 rdev->data_offset < rdev->new_data_offset)
3766 return -EINVAL;
3767 if (olddisks > n &&
3768 rdev->data_offset > rdev->new_data_offset)
3769 return -EINVAL;
3770 }
3771 mddev->delta_disks = n - olddisks;
3772 mddev->raid_disks = n;
3773 mddev->reshape_backwards = (mddev->delta_disks < 0);
3774 } else
3775 mddev->raid_disks = n;
3776 return rv ? rv : len;
3777}
3778static struct md_sysfs_entry md_raid_disks =
3779__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
3780
3781static ssize_t
3782chunk_size_show(struct mddev *mddev, char *page)
3783{
3784 if (mddev->reshape_position != MaxSector &&
3785 mddev->chunk_sectors != mddev->new_chunk_sectors)
3786 return sprintf(page, "%d (%d)\n",
3787 mddev->new_chunk_sectors << 9,
3788 mddev->chunk_sectors << 9);
3789 return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
3790}
3791
3792static ssize_t
3793chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
3794{
3795 char *e;
3796 unsigned long n = simple_strtoul(buf, &e, 10);
3797
3798 if (!*buf || (*e && *e != '\n'))
3799 return -EINVAL;
3800
3801 if (mddev->pers) {
3802 int err;
3803 if (mddev->pers->check_reshape == NULL)
3804 return -EBUSY;
3805 mddev->new_chunk_sectors = n >> 9;
3806 err = mddev->pers->check_reshape(mddev);
3807 if (err) {
3808 mddev->new_chunk_sectors = mddev->chunk_sectors;
3809 return err;
3810 }
3811 } else {
3812 mddev->new_chunk_sectors = n >> 9;
3813 if (mddev->reshape_position == MaxSector)
3814 mddev->chunk_sectors = n >> 9;
3815 }
3816 return len;
3817}
3818static struct md_sysfs_entry md_chunk_size =
3819__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
3820
3821static ssize_t
3822resync_start_show(struct mddev *mddev, char *page)
3823{
3824 if (mddev->recovery_cp == MaxSector)
3825 return sprintf(page, "none\n");
3826 return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
3827}
3828
3829static ssize_t
3830resync_start_store(struct mddev *mddev, const char *buf, size_t len)
3831{
3832 char *e;
3833 unsigned long long n = simple_strtoull(buf, &e, 10);
3834
3835 if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
3836 return -EBUSY;
3837 if (cmd_match(buf, "none"))
3838 n = MaxSector;
3839 else if (!*buf || (*e && *e != '\n'))
3840 return -EINVAL;
3841
3842 mddev->recovery_cp = n;
3843 return len;
3844}
3845static struct md_sysfs_entry md_resync_start =
3846__ATTR(resync_start, S_IRUGO|S_IWUSR, resync_start_show, resync_start_store);
3847
3848/*
3849 * The array state can be:
3850 *
3851 * clear
3852 * No devices, no size, no level
3853 * Equivalent to STOP_ARRAY ioctl
3854 * inactive
3855 * May have some settings, but array is not active
3856 * all IO results in error
3857 * When written, doesn't tear down array, but just stops it
3858 * suspended (not supported yet)
3859 * All IO requests will block. The array can be reconfigured.
3860 * Writing this, if accepted, will block until array is quiescent
3861 * readonly
3862 * no resync can happen. no superblocks get written.
3863 * write requests fail
3864 * read-auto
3865 * like readonly, but behaves like 'clean' on a write request.
3866 *
3867 * clean - no pending writes, but otherwise active.
3868 * When written to inactive array, starts without resync
3869 * If a write request arrives then
3870 * if metadata is known, mark 'dirty' and switch to 'active'.
3871 * if not known, block and switch to write-pending
3872 * If written to an active array that has pending writes, then fails.
3873 * active
3874 * fully active: IO and resync can be happening.
3875 * When written to inactive array, starts with resync
3876 *
3877 * write-pending
3878 * clean, but writes are blocked waiting for 'active' to be written.
3879 *
3880 * active-idle
3881 * like active, but no writes have been seen for a while (100msec).
3882 *
3883 */
3884enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
3885 write_pending, active_idle, bad_word};
3886static char *array_states[] = {
3887 "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
3888 "write-pending", "active-idle", NULL };
3889
3890static int match_word(const char *word, char **list)
3891{
3892 int n;
3893 for (n=0; list[n]; n++)
3894 if (cmd_match(word, list[n]))
3895 break;
3896 return n;
3897}
3898
3899static ssize_t
3900array_state_show(struct mddev *mddev, char *page)
3901{
3902 enum array_state st = inactive;
3903
3904 if (mddev->pers)
3905 switch(mddev->ro) {
3906 case 1:
3907 st = readonly;
3908 break;
3909 case 2:
3910 st = read_auto;
3911 break;
3912 case 0:
3913 if (mddev->in_sync)
3914 st = clean;
3915 else if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
3916 st = write_pending;
3917 else if (mddev->safemode)
3918 st = active_idle;
3919 else
3920 st = active;
3921 }
3922 else {
3923 if (list_empty(&mddev->disks) &&
3924 mddev->raid_disks == 0 &&
3925 mddev->dev_sectors == 0)
3926 st = clear;
3927 else
3928 st = inactive;
3929 }
3930 return sprintf(page, "%s\n", array_states[st]);
3931}
3932
3933static int do_md_stop(struct mddev * mddev, int ro, struct block_device *bdev);
3934static int md_set_readonly(struct mddev * mddev, struct block_device *bdev);
3935static int do_md_run(struct mddev * mddev);
3936static int restart_array(struct mddev *mddev);
3937
3938static ssize_t
3939array_state_store(struct mddev *mddev, const char *buf, size_t len)
3940{
3941 int err = -EINVAL;
3942 enum array_state st = match_word(buf, array_states);
3943 switch(st) {
3944 case bad_word:
3945 break;
3946 case clear:
3947 /* stopping an active array */
3948 if (atomic_read(&mddev->openers) > 0)
3949 return -EBUSY;
3950 err = do_md_stop(mddev, 0, NULL);
3951 break;
3952 case inactive:
3953 /* stopping an active array */
3954 if (mddev->pers) {
3955 if (atomic_read(&mddev->openers) > 0)
3956 return -EBUSY;
3957 err = do_md_stop(mddev, 2, NULL);
3958 } else
3959 err = 0; /* already inactive */
3960 break;
3961 case suspended:
3962 break; /* not supported yet */
3963 case readonly:
3964 if (mddev->pers)
3965 err = md_set_readonly(mddev, NULL);
3966 else {
3967 mddev->ro = 1;
3968 set_disk_ro(mddev->gendisk, 1);
3969 err = do_md_run(mddev);
3970 }
3971 break;
3972 case read_auto:
3973 if (mddev->pers) {
3974 if (mddev->ro == 0)
3975 err = md_set_readonly(mddev, NULL);
3976 else if (mddev->ro == 1)
3977 err = restart_array(mddev);
3978 if (err == 0) {
3979 mddev->ro = 2;
3980 set_disk_ro(mddev->gendisk, 0);
3981 }
3982 } else {
3983 mddev->ro = 2;
3984 err = do_md_run(mddev);
3985 }
3986 break;
3987 case clean:
3988 if (mddev->pers) {
3989 restart_array(mddev);
3990 spin_lock_irq(&mddev->write_lock);
3991 if (atomic_read(&mddev->writes_pending) == 0) {
3992 if (mddev->in_sync == 0) {
3993 mddev->in_sync = 1;
3994 if (mddev->safemode == 1)
3995 mddev->safemode = 0;
3996 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3997 }
3998 err = 0;
3999 } else
4000 err = -EBUSY;
4001 spin_unlock_irq(&mddev->write_lock);
4002 } else
4003 err = -EINVAL;
4004 break;
4005 case active:
4006 if (mddev->pers) {
4007 restart_array(mddev);
4008 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
4009 wake_up(&mddev->sb_wait);
4010 err = 0;
4011 } else {
4012 mddev->ro = 0;
4013 set_disk_ro(mddev->gendisk, 0);
4014 err = do_md_run(mddev);
4015 }
4016 break;
4017 case write_pending:
4018 case active_idle:
4019 /* these cannot be set */
4020 break;
4021 }
4022 if (err)
4023 return err;
4024 else {
4025 if (mddev->hold_active == UNTIL_IOCTL)
4026 mddev->hold_active = 0;
4027 sysfs_notify_dirent_safe(mddev->sysfs_state);
4028 return len;
4029 }
4030}
4031static struct md_sysfs_entry md_array_state =
4032__ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
4033
4034static ssize_t
4035max_corrected_read_errors_show(struct mddev *mddev, char *page) {
4036 return sprintf(page, "%d\n",
4037 atomic_read(&mddev->max_corr_read_errors));
4038}
4039
4040static ssize_t
4041max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
4042{
4043 char *e;
4044 unsigned long n = simple_strtoul(buf, &e, 10);
4045
4046 if (*buf && (*e == 0 || *e == '\n')) {
4047 atomic_set(&mddev->max_corr_read_errors, n);
4048 return len;
4049 }
4050 return -EINVAL;
4051}
4052
4053static struct md_sysfs_entry max_corr_read_errors =
4054__ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
4055 max_corrected_read_errors_store);
4056
4057static ssize_t
4058null_show(struct mddev *mddev, char *page)
4059{
4060 return -EINVAL;
4061}
4062
4063static ssize_t
4064new_dev_store(struct mddev *mddev, const char *buf, size_t len)
4065{
4066 /* buf must be %d:%d\n? giving major and minor numbers */
4067 /* The new device is added to the array.
4068 * If the array has a persistent superblock, we read the
4069 * superblock to initialise info and check validity.
4070 * Otherwise, only checking done is that in bind_rdev_to_array,
4071 * which mainly checks size.
4072 */
4073 char *e;
4074 int major = simple_strtoul(buf, &e, 10);
4075 int minor;
4076 dev_t dev;
4077 struct md_rdev *rdev;
4078 int err;
4079
4080 if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
4081 return -EINVAL;
4082 minor = simple_strtoul(e+1, &e, 10);
4083 if (*e && *e != '\n')
4084 return -EINVAL;
4085 dev = MKDEV(major, minor);
4086 if (major != MAJOR(dev) ||
4087 minor != MINOR(dev))
4088 return -EOVERFLOW;
4089
4090
4091 if (mddev->persistent) {
4092 rdev = md_import_device(dev, mddev->major_version,
4093 mddev->minor_version);
4094 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
4095 struct md_rdev *rdev0
4096 = list_entry(mddev->disks.next,
4097 struct md_rdev, same_set);
4098 err = super_types[mddev->major_version]
4099 .load_super(rdev, rdev0, mddev->minor_version);
4100 if (err < 0)
4101 goto out;
4102 }
4103 } else if (mddev->external)
4104 rdev = md_import_device(dev, -2, -1);
4105 else
4106 rdev = md_import_device(dev, -1, -1);
4107
4108 if (IS_ERR(rdev))
4109 return PTR_ERR(rdev);
4110 err = bind_rdev_to_array(rdev, mddev);
4111 out:
4112 if (err)
4113 export_rdev(rdev);
4114 return err ? err : len;
4115}
4116
4117static struct md_sysfs_entry md_new_device =
4118__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
4119
4120static ssize_t
4121bitmap_store(struct mddev *mddev, const char *buf, size_t len)
4122{
4123 char *end;
4124 unsigned long chunk, end_chunk;
4125
4126 if (!mddev->bitmap)
4127 goto out;
4128 /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
4129 while (*buf) {
4130 chunk = end_chunk = simple_strtoul(buf, &end, 0);
4131 if (buf == end) break;
4132 if (*end == '-') { /* range */
4133 buf = end + 1;
4134 end_chunk = simple_strtoul(buf, &end, 0);
4135 if (buf == end) break;
4136 }
4137 if (*end && !isspace(*end)) break;
4138 bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
4139 buf = skip_spaces(end);
4140 }
4141 bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
4142out:
4143 return len;
4144}
4145
4146static struct md_sysfs_entry md_bitmap =
4147__ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
4148
4149static ssize_t
4150size_show(struct mddev *mddev, char *page)
4151{
4152 return sprintf(page, "%llu\n",
4153 (unsigned long long)mddev->dev_sectors / 2);
4154}
4155
4156static int update_size(struct mddev *mddev, sector_t num_sectors);
4157
4158static ssize_t
4159size_store(struct mddev *mddev, const char *buf, size_t len)
4160{
4161 /* If array is inactive, we can reduce the component size, but
4162 * not increase it (except from 0).
4163 * If array is active, we can try an on-line resize
4164 */
4165 sector_t sectors;
4166 int err = strict_blocks_to_sectors(buf, §ors);
4167
4168 if (err < 0)
4169 return err;
4170 if (mddev->pers) {
4171 err = update_size(mddev, sectors);
4172 md_update_sb(mddev, 1);
4173 } else {
4174 if (mddev->dev_sectors == 0 ||
4175 mddev->dev_sectors > sectors)
4176 mddev->dev_sectors = sectors;
4177 else
4178 err = -ENOSPC;
4179 }
4180 return err ? err : len;
4181}
4182
4183static struct md_sysfs_entry md_size =
4184__ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
4185
4186
4187/* Metdata version.
4188 * This is one of
4189 * 'none' for arrays with no metadata (good luck...)
4190 * 'external' for arrays with externally managed metadata,
4191 * or N.M for internally known formats
4192 */
4193static ssize_t
4194metadata_show(struct mddev *mddev, char *page)
4195{
4196 if (mddev->persistent)
4197 return sprintf(page, "%d.%d\n",
4198 mddev->major_version, mddev->minor_version);
4199 else if (mddev->external)
4200 return sprintf(page, "external:%s\n", mddev->metadata_type);
4201 else
4202 return sprintf(page, "none\n");
4203}
4204
4205static ssize_t
4206metadata_store(struct mddev *mddev, const char *buf, size_t len)
4207{
4208 int major, minor;
4209 char *e;
4210 /* Changing the details of 'external' metadata is
4211 * always permitted. Otherwise there must be
4212 * no devices attached to the array.
4213 */
4214 if (mddev->external && strncmp(buf, "external:", 9) == 0)
4215 ;
4216 else if (!list_empty(&mddev->disks))
4217 return -EBUSY;
4218
4219 if (cmd_match(buf, "none")) {
4220 mddev->persistent = 0;
4221 mddev->external = 0;
4222 mddev->major_version = 0;
4223 mddev->minor_version = 90;
4224 return len;
4225 }
4226 if (strncmp(buf, "external:", 9) == 0) {
4227 size_t namelen = len-9;
4228 if (namelen >= sizeof(mddev->metadata_type))
4229 namelen = sizeof(mddev->metadata_type)-1;
4230 strncpy(mddev->metadata_type, buf+9, namelen);
4231 mddev->metadata_type[namelen] = 0;
4232 if (namelen && mddev->metadata_type[namelen-1] == '\n')
4233 mddev->metadata_type[--namelen] = 0;
4234 mddev->persistent = 0;
4235 mddev->external = 1;
4236 mddev->major_version = 0;
4237 mddev->minor_version = 90;
4238 return len;
4239 }
4240 major = simple_strtoul(buf, &e, 10);
4241 if (e==buf || *e != '.')
4242 return -EINVAL;
4243 buf = e+1;
4244 minor = simple_strtoul(buf, &e, 10);
4245 if (e==buf || (*e && *e != '\n') )
4246 return -EINVAL;
4247 if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
4248 return -ENOENT;
4249 mddev->major_version = major;
4250 mddev->minor_version = minor;
4251 mddev->persistent = 1;
4252 mddev->external = 0;
4253 return len;
4254}
4255
4256static struct md_sysfs_entry md_metadata =
4257__ATTR(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
4258
4259static ssize_t
4260action_show(struct mddev *mddev, char *page)
4261{
4262 char *type = "idle";
4263 if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
4264 type = "frozen";
4265 else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
4266 (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))) {
4267 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
4268 type = "reshape";
4269 else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
4270 if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
4271 type = "resync";
4272 else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
4273 type = "check";
4274 else
4275 type = "repair";
4276 } else if (test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
4277 type = "recover";
4278 }
4279 return sprintf(page, "%s\n", type);
4280}
4281
4282static void reap_sync_thread(struct mddev *mddev);
4283
4284static ssize_t
4285action_store(struct mddev *mddev, const char *page, size_t len)
4286{
4287 if (!mddev->pers || !mddev->pers->sync_request)
4288 return -EINVAL;
4289
4290 if (cmd_match(page, "frozen"))
4291 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4292 else
4293 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4294
4295 if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
4296 if (mddev->sync_thread) {
4297 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4298 reap_sync_thread(mddev);
4299 }
4300 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
4301 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
4302 return -EBUSY;
4303 else if (cmd_match(page, "resync"))
4304 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4305 else if (cmd_match(page, "recover")) {
4306 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
4307 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4308 } else if (cmd_match(page, "reshape")) {
4309 int err;
4310 if (mddev->pers->start_reshape == NULL)
4311 return -EINVAL;
4312 err = mddev->pers->start_reshape(mddev);
4313 if (err)
4314 return err;
4315 sysfs_notify(&mddev->kobj, NULL, "degraded");
4316 } else {
4317 if (cmd_match(page, "check"))
4318 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
4319 else if (!cmd_match(page, "repair"))
4320 return -EINVAL;
4321 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
4322 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4323 }
4324 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4325 md_wakeup_thread(mddev->thread);
4326 sysfs_notify_dirent_safe(mddev->sysfs_action);
4327 return len;
4328}
4329
4330static ssize_t
4331mismatch_cnt_show(struct mddev *mddev, char *page)
4332{
4333 return sprintf(page, "%llu\n",
4334 (unsigned long long) mddev->resync_mismatches);
4335}
4336
4337static struct md_sysfs_entry md_scan_mode =
4338__ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
4339
4340
4341static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
4342
4343static ssize_t
4344sync_min_show(struct mddev *mddev, char *page)
4345{
4346 return sprintf(page, "%d (%s)\n", speed_min(mddev),
4347 mddev->sync_speed_min ? "local": "system");
4348}
4349
4350static ssize_t
4351sync_min_store(struct mddev *mddev, const char *buf, size_t len)
4352{
4353 int min;
4354 char *e;
4355 if (strncmp(buf, "system", 6)==0) {
4356 mddev->sync_speed_min = 0;
4357 return len;
4358 }
4359 min = simple_strtoul(buf, &e, 10);
4360 if (buf == e || (*e && *e != '\n') || min <= 0)
4361 return -EINVAL;
4362 mddev->sync_speed_min = min;
4363 return len;
4364}
4365
4366static struct md_sysfs_entry md_sync_min =
4367__ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
4368
4369static ssize_t
4370sync_max_show(struct mddev *mddev, char *page)
4371{
4372 return sprintf(page, "%d (%s)\n", speed_max(mddev),
4373 mddev->sync_speed_max ? "local": "system");
4374}
4375
4376static ssize_t
4377sync_max_store(struct mddev *mddev, const char *buf, size_t len)
4378{
4379 int max;
4380 char *e;
4381 if (strncmp(buf, "system", 6)==0) {
4382 mddev->sync_speed_max = 0;
4383 return len;
4384 }
4385 max = simple_strtoul(buf, &e, 10);
4386 if (buf == e || (*e && *e != '\n') || max <= 0)
4387 return -EINVAL;
4388 mddev->sync_speed_max = max;
4389 return len;
4390}
4391
4392static struct md_sysfs_entry md_sync_max =
4393__ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
4394
4395static ssize_t
4396degraded_show(struct mddev *mddev, char *page)
4397{
4398 return sprintf(page, "%d\n", mddev->degraded);
4399}
4400static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
4401
4402static ssize_t
4403sync_force_parallel_show(struct mddev *mddev, char *page)
4404{
4405 return sprintf(page, "%d\n", mddev->parallel_resync);
4406}
4407
4408static ssize_t
4409sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
4410{
4411 long n;
4412
4413 if (strict_strtol(buf, 10, &n))
4414 return -EINVAL;
4415
4416 if (n != 0 && n != 1)
4417 return -EINVAL;
4418
4419 mddev->parallel_resync = n;
4420
4421 if (mddev->sync_thread)
4422 wake_up(&resync_wait);
4423
4424 return len;
4425}
4426
4427/* force parallel resync, even with shared block devices */
4428static struct md_sysfs_entry md_sync_force_parallel =
4429__ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
4430 sync_force_parallel_show, sync_force_parallel_store);
4431
4432static ssize_t
4433sync_speed_show(struct mddev *mddev, char *page)
4434{
4435 unsigned long resync, dt, db;
4436 if (mddev->curr_resync == 0)
4437 return sprintf(page, "none\n");
4438 resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
4439 dt = (jiffies - mddev->resync_mark) / HZ;
4440 if (!dt) dt++;
4441 db = resync - mddev->resync_mark_cnt;
4442 return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
4443}
4444
4445static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
4446
4447static ssize_t
4448sync_completed_show(struct mddev *mddev, char *page)
4449{
4450 unsigned long long max_sectors, resync;
4451
4452 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4453 return sprintf(page, "none\n");
4454
4455 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
4456 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
4457 max_sectors = mddev->resync_max_sectors;
4458 else
4459 max_sectors = mddev->dev_sectors;
4460
4461 resync = mddev->curr_resync_completed;
4462 return sprintf(page, "%llu / %llu\n", resync, max_sectors);
4463}
4464
4465static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
4466
4467static ssize_t
4468min_sync_show(struct mddev *mddev, char *page)
4469{
4470 return sprintf(page, "%llu\n",
4471 (unsigned long long)mddev->resync_min);
4472}
4473static ssize_t
4474min_sync_store(struct mddev *mddev, const char *buf, size_t len)
4475{
4476 unsigned long long min;
4477 if (strict_strtoull(buf, 10, &min))
4478 return -EINVAL;
4479 if (min > mddev->resync_max)
4480 return -EINVAL;
4481 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4482 return -EBUSY;
4483
4484 /* Must be a multiple of chunk_size */
4485 if (mddev->chunk_sectors) {
4486 sector_t temp = min;
4487 if (sector_div(temp, mddev->chunk_sectors))
4488 return -EINVAL;
4489 }
4490 mddev->resync_min = min;
4491
4492 return len;
4493}
4494
4495static struct md_sysfs_entry md_min_sync =
4496__ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
4497
4498static ssize_t
4499max_sync_show(struct mddev *mddev, char *page)
4500{
4501 if (mddev->resync_max == MaxSector)
4502 return sprintf(page, "max\n");
4503 else
4504 return sprintf(page, "%llu\n",
4505 (unsigned long long)mddev->resync_max);
4506}
4507static ssize_t
4508max_sync_store(struct mddev *mddev, const char *buf, size_t len)
4509{
4510 if (strncmp(buf, "max", 3) == 0)
4511 mddev->resync_max = MaxSector;
4512 else {
4513 unsigned long long max;
4514 if (strict_strtoull(buf, 10, &max))
4515 return -EINVAL;
4516 if (max < mddev->resync_min)
4517 return -EINVAL;
4518 if (max < mddev->resync_max &&
4519 mddev->ro == 0 &&
4520 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4521 return -EBUSY;
4522
4523 /* Must be a multiple of chunk_size */
4524 if (mddev->chunk_sectors) {
4525 sector_t temp = max;
4526 if (sector_div(temp, mddev->chunk_sectors))
4527 return -EINVAL;
4528 }
4529 mddev->resync_max = max;
4530 }
4531 wake_up(&mddev->recovery_wait);
4532 return len;
4533}
4534
4535static struct md_sysfs_entry md_max_sync =
4536__ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
4537
4538static ssize_t
4539suspend_lo_show(struct mddev *mddev, char *page)
4540{
4541 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
4542}
4543
4544static ssize_t
4545suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
4546{
4547 char *e;
4548 unsigned long long new = simple_strtoull(buf, &e, 10);
4549 unsigned long long old = mddev->suspend_lo;
4550
4551 if (mddev->pers == NULL ||
4552 mddev->pers->quiesce == NULL)
4553 return -EINVAL;
4554 if (buf == e || (*e && *e != '\n'))
4555 return -EINVAL;
4556
4557 mddev->suspend_lo = new;
4558 if (new >= old)
4559 /* Shrinking suspended region */
4560 mddev->pers->quiesce(mddev, 2);
4561 else {
4562 /* Expanding suspended region - need to wait */
4563 mddev->pers->quiesce(mddev, 1);
4564 mddev->pers->quiesce(mddev, 0);
4565 }
4566 return len;
4567}
4568static struct md_sysfs_entry md_suspend_lo =
4569__ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
4570
4571
4572static ssize_t
4573suspend_hi_show(struct mddev *mddev, char *page)
4574{
4575 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
4576}
4577
4578static ssize_t
4579suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
4580{
4581 char *e;
4582 unsigned long long new = simple_strtoull(buf, &e, 10);
4583 unsigned long long old = mddev->suspend_hi;
4584
4585 if (mddev->pers == NULL ||
4586 mddev->pers->quiesce == NULL)
4587 return -EINVAL;
4588 if (buf == e || (*e && *e != '\n'))
4589 return -EINVAL;
4590
4591 mddev->suspend_hi = new;
4592 if (new <= old)
4593 /* Shrinking suspended region */
4594 mddev->pers->quiesce(mddev, 2);
4595 else {
4596 /* Expanding suspended region - need to wait */
4597 mddev->pers->quiesce(mddev, 1);
4598 mddev->pers->quiesce(mddev, 0);
4599 }
4600 return len;
4601}
4602static struct md_sysfs_entry md_suspend_hi =
4603__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
4604
4605static ssize_t
4606reshape_position_show(struct mddev *mddev, char *page)
4607{
4608 if (mddev->reshape_position != MaxSector)
4609 return sprintf(page, "%llu\n",
4610 (unsigned long long)mddev->reshape_position);
4611 strcpy(page, "none\n");
4612 return 5;
4613}
4614
4615static ssize_t
4616reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
4617{
4618 struct md_rdev *rdev;
4619 char *e;
4620 unsigned long long new = simple_strtoull(buf, &e, 10);
4621 if (mddev->pers)
4622 return -EBUSY;
4623 if (buf == e || (*e && *e != '\n'))
4624 return -EINVAL;
4625 mddev->reshape_position = new;
4626 mddev->delta_disks = 0;
4627 mddev->reshape_backwards = 0;
4628 mddev->new_level = mddev->level;
4629 mddev->new_layout = mddev->layout;
4630 mddev->new_chunk_sectors = mddev->chunk_sectors;
4631 rdev_for_each(rdev, mddev)
4632 rdev->new_data_offset = rdev->data_offset;
4633 return len;
4634}
4635
4636static struct md_sysfs_entry md_reshape_position =
4637__ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
4638 reshape_position_store);
4639
4640static ssize_t
4641reshape_direction_show(struct mddev *mddev, char *page)
4642{
4643 return sprintf(page, "%s\n",
4644 mddev->reshape_backwards ? "backwards" : "forwards");
4645}
4646
4647static ssize_t
4648reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
4649{
4650 int backwards = 0;
4651 if (cmd_match(buf, "forwards"))
4652 backwards = 0;
4653 else if (cmd_match(buf, "backwards"))
4654 backwards = 1;
4655 else
4656 return -EINVAL;
4657 if (mddev->reshape_backwards == backwards)
4658 return len;
4659
4660 /* check if we are allowed to change */
4661 if (mddev->delta_disks)
4662 return -EBUSY;
4663
4664 if (mddev->persistent &&
4665 mddev->major_version == 0)
4666 return -EINVAL;
4667
4668 mddev->reshape_backwards = backwards;
4669 return len;
4670}
4671
4672static struct md_sysfs_entry md_reshape_direction =
4673__ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
4674 reshape_direction_store);
4675
4676static ssize_t
4677array_size_show(struct mddev *mddev, char *page)
4678{
4679 if (mddev->external_size)
4680 return sprintf(page, "%llu\n",
4681 (unsigned long long)mddev->array_sectors/2);
4682 else
4683 return sprintf(page, "default\n");
4684}
4685
4686static ssize_t
4687array_size_store(struct mddev *mddev, const char *buf, size_t len)
4688{
4689 sector_t sectors;
4690
4691 if (strncmp(buf, "default", 7) == 0) {
4692 if (mddev->pers)
4693 sectors = mddev->pers->size(mddev, 0, 0);
4694 else
4695 sectors = mddev->array_sectors;
4696
4697 mddev->external_size = 0;
4698 } else {
4699 if (strict_blocks_to_sectors(buf, §ors) < 0)
4700 return -EINVAL;
4701 if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
4702 return -E2BIG;
4703
4704 mddev->external_size = 1;
4705 }
4706
4707 mddev->array_sectors = sectors;
4708 if (mddev->pers) {
4709 set_capacity(mddev->gendisk, mddev->array_sectors);
4710 revalidate_disk(mddev->gendisk);
4711 }
4712 return len;
4713}
4714
4715static struct md_sysfs_entry md_array_size =
4716__ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
4717 array_size_store);
4718
4719static struct attribute *md_default_attrs[] = {
4720 &md_level.attr,
4721 &md_layout.attr,
4722 &md_raid_disks.attr,
4723 &md_chunk_size.attr,
4724 &md_size.attr,
4725 &md_resync_start.attr,
4726 &md_metadata.attr,
4727 &md_new_device.attr,
4728 &md_safe_delay.attr,
4729 &md_array_state.attr,
4730 &md_reshape_position.attr,
4731 &md_reshape_direction.attr,
4732 &md_array_size.attr,
4733 &max_corr_read_errors.attr,
4734 NULL,
4735};
4736
4737static struct attribute *md_redundancy_attrs[] = {
4738 &md_scan_mode.attr,
4739 &md_mismatches.attr,
4740 &md_sync_min.attr,
4741 &md_sync_max.attr,
4742 &md_sync_speed.attr,
4743 &md_sync_force_parallel.attr,
4744 &md_sync_completed.attr,
4745 &md_min_sync.attr,
4746 &md_max_sync.attr,
4747 &md_suspend_lo.attr,
4748 &md_suspend_hi.attr,
4749 &md_bitmap.attr,
4750 &md_degraded.attr,
4751 NULL,
4752};
4753static struct attribute_group md_redundancy_group = {
4754 .name = NULL,
4755 .attrs = md_redundancy_attrs,
4756};
4757
4758
4759static ssize_t
4760md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
4761{
4762 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
4763 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
4764 ssize_t rv;
4765
4766 if (!entry->show)
4767 return -EIO;
4768 spin_lock(&all_mddevs_lock);
4769 if (list_empty(&mddev->all_mddevs)) {
4770 spin_unlock(&all_mddevs_lock);
4771 return -EBUSY;
4772 }
4773 mddev_get(mddev);
4774 spin_unlock(&all_mddevs_lock);
4775
4776 rv = mddev_lock(mddev);
4777 if (!rv) {
4778 rv = entry->show(mddev, page);
4779 mddev_unlock(mddev);
4780 }
4781 mddev_put(mddev);
4782 return rv;
4783}
4784
4785static ssize_t
4786md_attr_store(struct kobject *kobj, struct attribute *attr,
4787 const char *page, size_t length)
4788{
4789 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
4790 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
4791 ssize_t rv;
4792
4793 if (!entry->store)
4794 return -EIO;
4795 if (!capable(CAP_SYS_ADMIN))
4796 return -EACCES;
4797 spin_lock(&all_mddevs_lock);
4798 if (list_empty(&mddev->all_mddevs)) {
4799 spin_unlock(&all_mddevs_lock);
4800 return -EBUSY;
4801 }
4802 mddev_get(mddev);
4803 spin_unlock(&all_mddevs_lock);
4804 rv = mddev_lock(mddev);
4805 if (!rv) {
4806 rv = entry->store(mddev, page, length);
4807 mddev_unlock(mddev);
4808 }
4809 mddev_put(mddev);
4810 return rv;
4811}
4812
4813static void md_free(struct kobject *ko)
4814{
4815 struct mddev *mddev = container_of(ko, struct mddev, kobj);
4816
4817 if (mddev->sysfs_state)
4818 sysfs_put(mddev->sysfs_state);
4819
4820 if (mddev->gendisk) {
4821 del_gendisk(mddev->gendisk);
4822 put_disk(mddev->gendisk);
4823 }
4824 if (mddev->queue)
4825 blk_cleanup_queue(mddev->queue);
4826
4827 kfree(mddev);
4828}
4829
4830static const struct sysfs_ops md_sysfs_ops = {
4831 .show = md_attr_show,
4832 .store = md_attr_store,
4833};
4834static struct kobj_type md_ktype = {
4835 .release = md_free,
4836 .sysfs_ops = &md_sysfs_ops,
4837 .default_attrs = md_default_attrs,
4838};
4839
4840int mdp_major = 0;
4841
4842static void mddev_delayed_delete(struct work_struct *ws)
4843{
4844 struct mddev *mddev = container_of(ws, struct mddev, del_work);
4845
4846 sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
4847 kobject_del(&mddev->kobj);
4848 kobject_put(&mddev->kobj);
4849}
4850
4851static int md_alloc(dev_t dev, char *name)
4852{
4853 static DEFINE_MUTEX(disks_mutex);
4854 struct mddev *mddev = mddev_find(dev);
4855 struct gendisk *disk;
4856 int partitioned;
4857 int shift;
4858 int unit;
4859 int error;
4860
4861 if (!mddev)
4862 return -ENODEV;
4863
4864 partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
4865 shift = partitioned ? MdpMinorShift : 0;
4866 unit = MINOR(mddev->unit) >> shift;
4867
4868 /* wait for any previous instance of this device to be
4869 * completely removed (mddev_delayed_delete).
4870 */
4871 flush_workqueue(md_misc_wq);
4872
4873 mutex_lock(&disks_mutex);
4874 error = -EEXIST;
4875 if (mddev->gendisk)
4876 goto abort;
4877
4878 if (name) {
4879 /* Need to ensure that 'name' is not a duplicate.
4880 */
4881 struct mddev *mddev2;
4882 spin_lock(&all_mddevs_lock);
4883
4884 list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
4885 if (mddev2->gendisk &&
4886 strcmp(mddev2->gendisk->disk_name, name) == 0) {
4887 spin_unlock(&all_mddevs_lock);
4888 goto abort;
4889 }
4890 spin_unlock(&all_mddevs_lock);
4891 }
4892
4893 error = -ENOMEM;
4894 mddev->queue = blk_alloc_queue(GFP_KERNEL);
4895 if (!mddev->queue)
4896 goto abort;
4897 mddev->queue->queuedata = mddev;
4898
4899 blk_queue_make_request(mddev->queue, md_make_request);
4900 blk_set_stacking_limits(&mddev->queue->limits);
4901
4902 disk = alloc_disk(1 << shift);
4903 if (!disk) {
4904 blk_cleanup_queue(mddev->queue);
4905 mddev->queue = NULL;
4906 goto abort;
4907 }
4908 disk->major = MAJOR(mddev->unit);
4909 disk->first_minor = unit << shift;
4910 if (name)
4911 strcpy(disk->disk_name, name);
4912 else if (partitioned)
4913 sprintf(disk->disk_name, "md_d%d", unit);
4914 else
4915 sprintf(disk->disk_name, "md%d", unit);
4916 disk->fops = &md_fops;
4917 disk->private_data = mddev;
4918 disk->queue = mddev->queue;
4919 blk_queue_flush(mddev->queue, REQ_FLUSH | REQ_FUA);
4920 /* Allow extended partitions. This makes the
4921 * 'mdp' device redundant, but we can't really
4922 * remove it now.
4923 */
4924 disk->flags |= GENHD_FL_EXT_DEVT;
4925 mddev->gendisk = disk;
4926 /* As soon as we call add_disk(), another thread could get
4927 * through to md_open, so make sure it doesn't get too far
4928 */
4929 mutex_lock(&mddev->open_mutex);
4930 add_disk(disk);
4931
4932 error = kobject_init_and_add(&mddev->kobj, &md_ktype,
4933 &disk_to_dev(disk)->kobj, "%s", "md");
4934 if (error) {
4935 /* This isn't possible, but as kobject_init_and_add is marked
4936 * __must_check, we must do something with the result
4937 */
4938 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
4939 disk->disk_name);
4940 error = 0;
4941 }
4942 if (mddev->kobj.sd &&
4943 sysfs_create_group(&mddev->kobj, &md_bitmap_group))
4944 printk(KERN_DEBUG "pointless warning\n");
4945 mutex_unlock(&mddev->open_mutex);
4946 abort:
4947 mutex_unlock(&disks_mutex);
4948 if (!error && mddev->kobj.sd) {
4949 kobject_uevent(&mddev->kobj, KOBJ_ADD);
4950 mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
4951 }
4952 mddev_put(mddev);
4953 return error;
4954}
4955
4956static struct kobject *md_probe(dev_t dev, int *part, void *data)
4957{
4958 md_alloc(dev, NULL);
4959 return NULL;
4960}
4961
4962static int add_named_array(const char *val, struct kernel_param *kp)
4963{
4964 /* val must be "md_*" where * is not all digits.
4965 * We allocate an array with a large free minor number, and
4966 * set the name to val. val must not already be an active name.
4967 */
4968 int len = strlen(val);
4969 char buf[DISK_NAME_LEN];
4970
4971 while (len && val[len-1] == '\n')
4972 len--;
4973 if (len >= DISK_NAME_LEN)
4974 return -E2BIG;
4975 strlcpy(buf, val, len+1);
4976 if (strncmp(buf, "md_", 3) != 0)
4977 return -EINVAL;
4978 return md_alloc(0, buf);
4979}
4980
4981static void md_safemode_timeout(unsigned long data)
4982{
4983 struct mddev *mddev = (struct mddev *) data;
4984
4985 if (!atomic_read(&mddev->writes_pending)) {
4986 mddev->safemode = 1;
4987 if (mddev->external)
4988 sysfs_notify_dirent_safe(mddev->sysfs_state);
4989 }
4990 md_wakeup_thread(mddev->thread);
4991}
4992
4993static int start_dirty_degraded;
4994
4995int md_run(struct mddev *mddev)
4996{
4997 int err;
4998 struct md_rdev *rdev;
4999 struct md_personality *pers;
5000
5001 if (list_empty(&mddev->disks))
5002 /* cannot run an array with no devices.. */
5003 return -EINVAL;
5004
5005 if (mddev->pers)
5006 return -EBUSY;
5007 /* Cannot run until previous stop completes properly */
5008 if (mddev->sysfs_active)
5009 return -EBUSY;
5010
5011 /*
5012 * Analyze all RAID superblock(s)
5013 */
5014 if (!mddev->raid_disks) {
5015 if (!mddev->persistent)
5016 return -EINVAL;
5017 analyze_sbs(mddev);
5018 }
5019
5020 if (mddev->level != LEVEL_NONE)
5021 request_module("md-level-%d", mddev->level);
5022 else if (mddev->clevel[0])
5023 request_module("md-%s", mddev->clevel);
5024
5025 /*
5026 * Drop all container device buffers, from now on
5027 * the only valid external interface is through the md
5028 * device.
5029 */
5030 rdev_for_each(rdev, mddev) {
5031 if (test_bit(Faulty, &rdev->flags))
5032 continue;
5033 sync_blockdev(rdev->bdev);
5034 invalidate_bdev(rdev->bdev);
5035
5036 /* perform some consistency tests on the device.
5037 * We don't want the data to overlap the metadata,
5038 * Internal Bitmap issues have been handled elsewhere.
5039 */
5040 if (rdev->meta_bdev) {
5041 /* Nothing to check */;
5042 } else if (rdev->data_offset < rdev->sb_start) {
5043 if (mddev->dev_sectors &&
5044 rdev->data_offset + mddev->dev_sectors
5045 > rdev->sb_start) {
5046 printk("md: %s: data overlaps metadata\n",
5047 mdname(mddev));
5048 return -EINVAL;
5049 }
5050 } else {
5051 if (rdev->sb_start + rdev->sb_size/512
5052 > rdev->data_offset) {
5053 printk("md: %s: metadata overlaps data\n",
5054 mdname(mddev));
5055 return -EINVAL;
5056 }
5057 }
5058 sysfs_notify_dirent_safe(rdev->sysfs_state);
5059 }
5060
5061 if (mddev->bio_set == NULL)
5062 mddev->bio_set = bioset_create(BIO_POOL_SIZE,
5063 sizeof(struct mddev *));
5064
5065 spin_lock(&pers_lock);
5066 pers = find_pers(mddev->level, mddev->clevel);
5067 if (!pers || !try_module_get(pers->owner)) {
5068 spin_unlock(&pers_lock);
5069 if (mddev->level != LEVEL_NONE)
5070 printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
5071 mddev->level);
5072 else
5073 printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
5074 mddev->clevel);
5075 return -EINVAL;
5076 }
5077 mddev->pers = pers;
5078 spin_unlock(&pers_lock);
5079 if (mddev->level != pers->level) {
5080 mddev->level = pers->level;
5081 mddev->new_level = pers->level;
5082 }
5083 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
5084
5085 if (mddev->reshape_position != MaxSector &&
5086 pers->start_reshape == NULL) {
5087 /* This personality cannot handle reshaping... */
5088 mddev->pers = NULL;
5089 module_put(pers->owner);
5090 return -EINVAL;
5091 }
5092
5093 if (pers->sync_request) {
5094 /* Warn if this is a potentially silly
5095 * configuration.
5096 */
5097 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
5098 struct md_rdev *rdev2;
5099 int warned = 0;
5100
5101 rdev_for_each(rdev, mddev)
5102 rdev_for_each(rdev2, mddev) {
5103 if (rdev < rdev2 &&
5104 rdev->bdev->bd_contains ==
5105 rdev2->bdev->bd_contains) {
5106 printk(KERN_WARNING
5107 "%s: WARNING: %s appears to be"
5108 " on the same physical disk as"
5109 " %s.\n",
5110 mdname(mddev),
5111 bdevname(rdev->bdev,b),
5112 bdevname(rdev2->bdev,b2));
5113 warned = 1;
5114 }
5115 }
5116
5117 if (warned)
5118 printk(KERN_WARNING
5119 "True protection against single-disk"
5120 " failure might be compromised.\n");
5121 }
5122
5123 mddev->recovery = 0;
5124 /* may be over-ridden by personality */
5125 mddev->resync_max_sectors = mddev->dev_sectors;
5126
5127 mddev->ok_start_degraded = start_dirty_degraded;
5128
5129 if (start_readonly && mddev->ro == 0)
5130 mddev->ro = 2; /* read-only, but switch on first write */
5131
5132 err = mddev->pers->run(mddev);
5133 if (err)
5134 printk(KERN_ERR "md: pers->run() failed ...\n");
5135 else if (mddev->pers->size(mddev, 0, 0) < mddev->array_sectors) {
5136 WARN_ONCE(!mddev->external_size, "%s: default size too small,"
5137 " but 'external_size' not in effect?\n", __func__);
5138 printk(KERN_ERR
5139 "md: invalid array_size %llu > default size %llu\n",
5140 (unsigned long long)mddev->array_sectors / 2,
5141 (unsigned long long)mddev->pers->size(mddev, 0, 0) / 2);
5142 err = -EINVAL;
5143 mddev->pers->stop(mddev);
5144 }
5145 if (err == 0 && mddev->pers->sync_request &&
5146 (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
5147 err = bitmap_create(mddev);
5148 if (err) {
5149 printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
5150 mdname(mddev), err);
5151 mddev->pers->stop(mddev);
5152 }
5153 }
5154 if (err) {
5155 module_put(mddev->pers->owner);
5156 mddev->pers = NULL;
5157 bitmap_destroy(mddev);
5158 return err;
5159 }
5160 if (mddev->pers->sync_request) {
5161 if (mddev->kobj.sd &&
5162 sysfs_create_group(&mddev->kobj, &md_redundancy_group))
5163 printk(KERN_WARNING
5164 "md: cannot register extra attributes for %s\n",
5165 mdname(mddev));
5166 mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
5167 } else if (mddev->ro == 2) /* auto-readonly not meaningful */
5168 mddev->ro = 0;
5169
5170 atomic_set(&mddev->writes_pending,0);
5171 atomic_set(&mddev->max_corr_read_errors,
5172 MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
5173 mddev->safemode = 0;
5174 mddev->safemode_timer.function = md_safemode_timeout;
5175 mddev->safemode_timer.data = (unsigned long) mddev;
5176 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
5177 mddev->in_sync = 1;
5178 smp_wmb();
5179 mddev->ready = 1;
5180 rdev_for_each(rdev, mddev)
5181 if (rdev->raid_disk >= 0)
5182 if (sysfs_link_rdev(mddev, rdev))
5183 /* failure here is OK */;
5184
5185 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5186
5187 if (mddev->flags)
5188 md_update_sb(mddev, 0);
5189
5190 md_new_event(mddev);
5191 sysfs_notify_dirent_safe(mddev->sysfs_state);
5192 sysfs_notify_dirent_safe(mddev->sysfs_action);
5193 sysfs_notify(&mddev->kobj, NULL, "degraded");
5194 return 0;
5195}
5196EXPORT_SYMBOL_GPL(md_run);
5197
5198static int do_md_run(struct mddev *mddev)
5199{
5200 int err;
5201
5202 err = md_run(mddev);
5203 if (err)
5204 goto out;
5205 err = bitmap_load(mddev);
5206 if (err) {
5207 bitmap_destroy(mddev);
5208 goto out;
5209 }
5210
5211 md_wakeup_thread(mddev->thread);
5212 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
5213
5214 set_capacity(mddev->gendisk, mddev->array_sectors);
5215 revalidate_disk(mddev->gendisk);
5216 mddev->changed = 1;
5217 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
5218out:
5219 return err;
5220}
5221
5222static int restart_array(struct mddev *mddev)
5223{
5224 struct gendisk *disk = mddev->gendisk;
5225
5226 /* Complain if it has no devices */
5227 if (list_empty(&mddev->disks))
5228 return -ENXIO;
5229 if (!mddev->pers)
5230 return -EINVAL;
5231 if (!mddev->ro)
5232 return -EBUSY;
5233 mddev->safemode = 0;
5234 mddev->ro = 0;
5235 set_disk_ro(disk, 0);
5236 printk(KERN_INFO "md: %s switched to read-write mode.\n",
5237 mdname(mddev));
5238 /* Kick recovery or resync if necessary */
5239 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5240 md_wakeup_thread(mddev->thread);
5241 md_wakeup_thread(mddev->sync_thread);
5242 sysfs_notify_dirent_safe(mddev->sysfs_state);
5243 return 0;
5244}
5245
5246/* similar to deny_write_access, but accounts for our holding a reference
5247 * to the file ourselves */
5248static int deny_bitmap_write_access(struct file * file)
5249{
5250 struct inode *inode = file->f_mapping->host;
5251
5252 spin_lock(&inode->i_lock);
5253 if (atomic_read(&inode->i_writecount) > 1) {
5254 spin_unlock(&inode->i_lock);
5255 return -ETXTBSY;
5256 }
5257 atomic_set(&inode->i_writecount, -1);
5258 spin_unlock(&inode->i_lock);
5259
5260 return 0;
5261}
5262
5263void restore_bitmap_write_access(struct file *file)
5264{
5265 struct inode *inode = file->f_mapping->host;
5266
5267 spin_lock(&inode->i_lock);
5268 atomic_set(&inode->i_writecount, 1);
5269 spin_unlock(&inode->i_lock);
5270}
5271
5272static void md_clean(struct mddev *mddev)
5273{
5274 mddev->array_sectors = 0;
5275 mddev->external_size = 0;
5276 mddev->dev_sectors = 0;
5277 mddev->raid_disks = 0;
5278 mddev->recovery_cp = 0;
5279 mddev->resync_min = 0;
5280 mddev->resync_max = MaxSector;
5281 mddev->reshape_position = MaxSector;
5282 mddev->external = 0;
5283 mddev->persistent = 0;
5284 mddev->level = LEVEL_NONE;
5285 mddev->clevel[0] = 0;
5286 mddev->flags = 0;
5287 mddev->ro = 0;
5288 mddev->metadata_type[0] = 0;
5289 mddev->chunk_sectors = 0;
5290 mddev->ctime = mddev->utime = 0;
5291 mddev->layout = 0;
5292 mddev->max_disks = 0;
5293 mddev->events = 0;
5294 mddev->can_decrease_events = 0;
5295 mddev->delta_disks = 0;
5296 mddev->reshape_backwards = 0;
5297 mddev->new_level = LEVEL_NONE;
5298 mddev->new_layout = 0;
5299 mddev->new_chunk_sectors = 0;
5300 mddev->curr_resync = 0;
5301 mddev->resync_mismatches = 0;
5302 mddev->suspend_lo = mddev->suspend_hi = 0;
5303 mddev->sync_speed_min = mddev->sync_speed_max = 0;
5304 mddev->recovery = 0;
5305 mddev->in_sync = 0;
5306 mddev->changed = 0;
5307 mddev->degraded = 0;
5308 mddev->safemode = 0;
5309 mddev->merge_check_needed = 0;
5310 mddev->bitmap_info.offset = 0;
5311 mddev->bitmap_info.default_offset = 0;
5312 mddev->bitmap_info.default_space = 0;
5313 mddev->bitmap_info.chunksize = 0;
5314 mddev->bitmap_info.daemon_sleep = 0;
5315 mddev->bitmap_info.max_write_behind = 0;
5316}
5317
5318static void __md_stop_writes(struct mddev *mddev)
5319{
5320 if (mddev->sync_thread) {
5321 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5322 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5323 reap_sync_thread(mddev);
5324 }
5325
5326 del_timer_sync(&mddev->safemode_timer);
5327
5328 bitmap_flush(mddev);
5329 md_super_wait(mddev);
5330
5331 if (!mddev->in_sync || mddev->flags) {
5332 /* mark array as shutdown cleanly */
5333 mddev->in_sync = 1;
5334 md_update_sb(mddev, 1);
5335 }
5336}
5337
5338void md_stop_writes(struct mddev *mddev)
5339{
5340 mddev_lock(mddev);
5341 __md_stop_writes(mddev);
5342 mddev_unlock(mddev);
5343}
5344EXPORT_SYMBOL_GPL(md_stop_writes);
5345
5346void md_stop(struct mddev *mddev)
5347{
5348 mddev->ready = 0;
5349 mddev->pers->stop(mddev);
5350 if (mddev->pers->sync_request && mddev->to_remove == NULL)
5351 mddev->to_remove = &md_redundancy_group;
5352 module_put(mddev->pers->owner);
5353 mddev->pers = NULL;
5354 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5355}
5356EXPORT_SYMBOL_GPL(md_stop);
5357
5358static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
5359{
5360 int err = 0;
5361 mutex_lock(&mddev->open_mutex);
5362 if (atomic_read(&mddev->openers) > !!bdev) {
5363 printk("md: %s still in use.\n",mdname(mddev));
5364 err = -EBUSY;
5365 goto out;
5366 }
5367 if (bdev)
5368 sync_blockdev(bdev);
5369 if (mddev->pers) {
5370 __md_stop_writes(mddev);
5371
5372 err = -ENXIO;
5373 if (mddev->ro==1)
5374 goto out;
5375 mddev->ro = 1;
5376 set_disk_ro(mddev->gendisk, 1);
5377 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5378 sysfs_notify_dirent_safe(mddev->sysfs_state);
5379 err = 0;
5380 }
5381out:
5382 mutex_unlock(&mddev->open_mutex);
5383 return err;
5384}
5385
5386/* mode:
5387 * 0 - completely stop and dis-assemble array
5388 * 2 - stop but do not disassemble array
5389 */
5390static int do_md_stop(struct mddev * mddev, int mode,
5391 struct block_device *bdev)
5392{
5393 struct gendisk *disk = mddev->gendisk;
5394 struct md_rdev *rdev;
5395
5396 mutex_lock(&mddev->open_mutex);
5397 if (atomic_read(&mddev->openers) > !!bdev ||
5398 mddev->sysfs_active) {
5399 printk("md: %s still in use.\n",mdname(mddev));
5400 mutex_unlock(&mddev->open_mutex);
5401 return -EBUSY;
5402 }
5403 if (bdev)
5404 /* It is possible IO was issued on some other
5405 * open file which was closed before we took ->open_mutex.
5406 * As that was not the last close __blkdev_put will not
5407 * have called sync_blockdev, so we must.
5408 */
5409 sync_blockdev(bdev);
5410
5411 if (mddev->pers) {
5412 if (mddev->ro)
5413 set_disk_ro(disk, 0);
5414
5415 __md_stop_writes(mddev);
5416 md_stop(mddev);
5417 mddev->queue->merge_bvec_fn = NULL;
5418 mddev->queue->backing_dev_info.congested_fn = NULL;
5419
5420 /* tell userspace to handle 'inactive' */
5421 sysfs_notify_dirent_safe(mddev->sysfs_state);
5422
5423 rdev_for_each(rdev, mddev)
5424 if (rdev->raid_disk >= 0)
5425 sysfs_unlink_rdev(mddev, rdev);
5426
5427 set_capacity(disk, 0);
5428 mutex_unlock(&mddev->open_mutex);
5429 mddev->changed = 1;
5430 revalidate_disk(disk);
5431
5432 if (mddev->ro)
5433 mddev->ro = 0;
5434 } else
5435 mutex_unlock(&mddev->open_mutex);
5436 /*
5437 * Free resources if final stop
5438 */
5439 if (mode == 0) {
5440 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
5441
5442 bitmap_destroy(mddev);
5443 if (mddev->bitmap_info.file) {
5444 restore_bitmap_write_access(mddev->bitmap_info.file);
5445 fput(mddev->bitmap_info.file);
5446 mddev->bitmap_info.file = NULL;
5447 }
5448 mddev->bitmap_info.offset = 0;
5449
5450 export_array(mddev);
5451
5452 md_clean(mddev);
5453 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
5454 if (mddev->hold_active == UNTIL_STOP)
5455 mddev->hold_active = 0;
5456 }
5457 blk_integrity_unregister(disk);
5458 md_new_event(mddev);
5459 sysfs_notify_dirent_safe(mddev->sysfs_state);
5460 return 0;
5461}
5462
5463#ifndef MODULE
5464static void autorun_array(struct mddev *mddev)
5465{
5466 struct md_rdev *rdev;
5467 int err;
5468
5469 if (list_empty(&mddev->disks))
5470 return;
5471
5472 printk(KERN_INFO "md: running: ");
5473
5474 rdev_for_each(rdev, mddev) {
5475 char b[BDEVNAME_SIZE];
5476 printk("<%s>", bdevname(rdev->bdev,b));
5477 }
5478 printk("\n");
5479
5480 err = do_md_run(mddev);
5481 if (err) {
5482 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
5483 do_md_stop(mddev, 0, NULL);
5484 }
5485}
5486
5487/*
5488 * lets try to run arrays based on all disks that have arrived
5489 * until now. (those are in pending_raid_disks)
5490 *
5491 * the method: pick the first pending disk, collect all disks with
5492 * the same UUID, remove all from the pending list and put them into
5493 * the 'same_array' list. Then order this list based on superblock
5494 * update time (freshest comes first), kick out 'old' disks and
5495 * compare superblocks. If everything's fine then run it.
5496 *
5497 * If "unit" is allocated, then bump its reference count
5498 */
5499static void autorun_devices(int part)
5500{
5501 struct md_rdev *rdev0, *rdev, *tmp;
5502 struct mddev *mddev;
5503 char b[BDEVNAME_SIZE];
5504
5505 printk(KERN_INFO "md: autorun ...\n");
5506 while (!list_empty(&pending_raid_disks)) {
5507 int unit;
5508 dev_t dev;
5509 LIST_HEAD(candidates);
5510 rdev0 = list_entry(pending_raid_disks.next,
5511 struct md_rdev, same_set);
5512
5513 printk(KERN_INFO "md: considering %s ...\n",
5514 bdevname(rdev0->bdev,b));
5515 INIT_LIST_HEAD(&candidates);
5516 rdev_for_each_list(rdev, tmp, &pending_raid_disks)
5517 if (super_90_load(rdev, rdev0, 0) >= 0) {
5518 printk(KERN_INFO "md: adding %s ...\n",
5519 bdevname(rdev->bdev,b));
5520 list_move(&rdev->same_set, &candidates);
5521 }
5522 /*
5523 * now we have a set of devices, with all of them having
5524 * mostly sane superblocks. It's time to allocate the
5525 * mddev.
5526 */
5527 if (part) {
5528 dev = MKDEV(mdp_major,
5529 rdev0->preferred_minor << MdpMinorShift);
5530 unit = MINOR(dev) >> MdpMinorShift;
5531 } else {
5532 dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
5533 unit = MINOR(dev);
5534 }
5535 if (rdev0->preferred_minor != unit) {
5536 printk(KERN_INFO "md: unit number in %s is bad: %d\n",
5537 bdevname(rdev0->bdev, b), rdev0->preferred_minor);
5538 break;
5539 }
5540
5541 md_probe(dev, NULL, NULL);
5542 mddev = mddev_find(dev);
5543 if (!mddev || !mddev->gendisk) {
5544 if (mddev)
5545 mddev_put(mddev);
5546 printk(KERN_ERR
5547 "md: cannot allocate memory for md drive.\n");
5548 break;
5549 }
5550 if (mddev_lock(mddev))
5551 printk(KERN_WARNING "md: %s locked, cannot run\n",
5552 mdname(mddev));
5553 else if (mddev->raid_disks || mddev->major_version
5554 || !list_empty(&mddev->disks)) {
5555 printk(KERN_WARNING
5556 "md: %s already running, cannot run %s\n",
5557 mdname(mddev), bdevname(rdev0->bdev,b));
5558 mddev_unlock(mddev);
5559 } else {
5560 printk(KERN_INFO "md: created %s\n", mdname(mddev));
5561 mddev->persistent = 1;
5562 rdev_for_each_list(rdev, tmp, &candidates) {
5563 list_del_init(&rdev->same_set);
5564 if (bind_rdev_to_array(rdev, mddev))
5565 export_rdev(rdev);
5566 }
5567 autorun_array(mddev);
5568 mddev_unlock(mddev);
5569 }
5570 /* on success, candidates will be empty, on error
5571 * it won't...
5572 */
5573 rdev_for_each_list(rdev, tmp, &candidates) {
5574 list_del_init(&rdev->same_set);
5575 export_rdev(rdev);
5576 }
5577 mddev_put(mddev);
5578 }
5579 printk(KERN_INFO "md: ... autorun DONE.\n");
5580}
5581#endif /* !MODULE */
5582
5583static int get_version(void __user * arg)
5584{
5585 mdu_version_t ver;
5586
5587 ver.major = MD_MAJOR_VERSION;
5588 ver.minor = MD_MINOR_VERSION;
5589 ver.patchlevel = MD_PATCHLEVEL_VERSION;
5590
5591 if (copy_to_user(arg, &ver, sizeof(ver)))
5592 return -EFAULT;
5593
5594 return 0;
5595}
5596
5597static int get_array_info(struct mddev * mddev, void __user * arg)
5598{
5599 mdu_array_info_t info;
5600 int nr,working,insync,failed,spare;
5601 struct md_rdev *rdev;
5602
5603 nr=working=insync=failed=spare=0;
5604 rdev_for_each(rdev, mddev) {
5605 nr++;
5606 if (test_bit(Faulty, &rdev->flags))
5607 failed++;
5608 else {
5609 working++;
5610 if (test_bit(In_sync, &rdev->flags))
5611 insync++;
5612 else
5613 spare++;
5614 }
5615 }
5616
5617 info.major_version = mddev->major_version;
5618 info.minor_version = mddev->minor_version;
5619 info.patch_version = MD_PATCHLEVEL_VERSION;
5620 info.ctime = mddev->ctime;
5621 info.level = mddev->level;
5622 info.size = mddev->dev_sectors / 2;
5623 if (info.size != mddev->dev_sectors / 2) /* overflow */
5624 info.size = -1;
5625 info.nr_disks = nr;
5626 info.raid_disks = mddev->raid_disks;
5627 info.md_minor = mddev->md_minor;
5628 info.not_persistent= !mddev->persistent;
5629
5630 info.utime = mddev->utime;
5631 info.state = 0;
5632 if (mddev->in_sync)
5633 info.state = (1<<MD_SB_CLEAN);
5634 if (mddev->bitmap && mddev->bitmap_info.offset)
5635 info.state = (1<<MD_SB_BITMAP_PRESENT);
5636 info.active_disks = insync;
5637 info.working_disks = working;
5638 info.failed_disks = failed;
5639 info.spare_disks = spare;
5640
5641 info.layout = mddev->layout;
5642 info.chunk_size = mddev->chunk_sectors << 9;
5643
5644 if (copy_to_user(arg, &info, sizeof(info)))
5645 return -EFAULT;
5646
5647 return 0;
5648}
5649
5650static int get_bitmap_file(struct mddev * mddev, void __user * arg)
5651{
5652 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
5653 char *ptr, *buf = NULL;
5654 int err = -ENOMEM;
5655
5656 if (md_allow_write(mddev))
5657 file = kmalloc(sizeof(*file), GFP_NOIO);
5658 else
5659 file = kmalloc(sizeof(*file), GFP_KERNEL);
5660
5661 if (!file)
5662 goto out;
5663
5664 /* bitmap disabled, zero the first byte and copy out */
5665 if (!mddev->bitmap || !mddev->bitmap->storage.file) {
5666 file->pathname[0] = '\0';
5667 goto copy_out;
5668 }
5669
5670 buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
5671 if (!buf)
5672 goto out;
5673
5674 ptr = d_path(&mddev->bitmap->storage.file->f_path,
5675 buf, sizeof(file->pathname));
5676 if (IS_ERR(ptr))
5677 goto out;
5678
5679 strcpy(file->pathname, ptr);
5680
5681copy_out:
5682 err = 0;
5683 if (copy_to_user(arg, file, sizeof(*file)))
5684 err = -EFAULT;
5685out:
5686 kfree(buf);
5687 kfree(file);
5688 return err;
5689}
5690
5691static int get_disk_info(struct mddev * mddev, void __user * arg)
5692{
5693 mdu_disk_info_t info;
5694 struct md_rdev *rdev;
5695
5696 if (copy_from_user(&info, arg, sizeof(info)))
5697 return -EFAULT;
5698
5699 rdev = find_rdev_nr(mddev, info.number);
5700 if (rdev) {
5701 info.major = MAJOR(rdev->bdev->bd_dev);
5702 info.minor = MINOR(rdev->bdev->bd_dev);
5703 info.raid_disk = rdev->raid_disk;
5704 info.state = 0;
5705 if (test_bit(Faulty, &rdev->flags))
5706 info.state |= (1<<MD_DISK_FAULTY);
5707 else if (test_bit(In_sync, &rdev->flags)) {
5708 info.state |= (1<<MD_DISK_ACTIVE);
5709 info.state |= (1<<MD_DISK_SYNC);
5710 }
5711 if (test_bit(WriteMostly, &rdev->flags))
5712 info.state |= (1<<MD_DISK_WRITEMOSTLY);
5713 } else {
5714 info.major = info.minor = 0;
5715 info.raid_disk = -1;
5716 info.state = (1<<MD_DISK_REMOVED);
5717 }
5718
5719 if (copy_to_user(arg, &info, sizeof(info)))
5720 return -EFAULT;
5721
5722 return 0;
5723}
5724
5725static int add_new_disk(struct mddev * mddev, mdu_disk_info_t *info)
5726{
5727 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
5728 struct md_rdev *rdev;
5729 dev_t dev = MKDEV(info->major,info->minor);
5730
5731 if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
5732 return -EOVERFLOW;
5733
5734 if (!mddev->raid_disks) {
5735 int err;
5736 /* expecting a device which has a superblock */
5737 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
5738 if (IS_ERR(rdev)) {
5739 printk(KERN_WARNING
5740 "md: md_import_device returned %ld\n",
5741 PTR_ERR(rdev));
5742 return PTR_ERR(rdev);
5743 }
5744 if (!list_empty(&mddev->disks)) {
5745 struct md_rdev *rdev0
5746 = list_entry(mddev->disks.next,
5747 struct md_rdev, same_set);
5748 err = super_types[mddev->major_version]
5749 .load_super(rdev, rdev0, mddev->minor_version);
5750 if (err < 0) {
5751 printk(KERN_WARNING
5752 "md: %s has different UUID to %s\n",
5753 bdevname(rdev->bdev,b),
5754 bdevname(rdev0->bdev,b2));
5755 export_rdev(rdev);
5756 return -EINVAL;
5757 }
5758 }
5759 err = bind_rdev_to_array(rdev, mddev);
5760 if (err)
5761 export_rdev(rdev);
5762 return err;
5763 }
5764
5765 /*
5766 * add_new_disk can be used once the array is assembled
5767 * to add "hot spares". They must already have a superblock
5768 * written
5769 */
5770 if (mddev->pers) {
5771 int err;
5772 if (!mddev->pers->hot_add_disk) {
5773 printk(KERN_WARNING
5774 "%s: personality does not support diskops!\n",
5775 mdname(mddev));
5776 return -EINVAL;
5777 }
5778 if (mddev->persistent)
5779 rdev = md_import_device(dev, mddev->major_version,
5780 mddev->minor_version);
5781 else
5782 rdev = md_import_device(dev, -1, -1);
5783 if (IS_ERR(rdev)) {
5784 printk(KERN_WARNING
5785 "md: md_import_device returned %ld\n",
5786 PTR_ERR(rdev));
5787 return PTR_ERR(rdev);
5788 }
5789 /* set saved_raid_disk if appropriate */
5790 if (!mddev->persistent) {
5791 if (info->state & (1<<MD_DISK_SYNC) &&
5792 info->raid_disk < mddev->raid_disks) {
5793 rdev->raid_disk = info->raid_disk;
5794 set_bit(In_sync, &rdev->flags);
5795 } else
5796 rdev->raid_disk = -1;
5797 } else
5798 super_types[mddev->major_version].
5799 validate_super(mddev, rdev);
5800 if ((info->state & (1<<MD_DISK_SYNC)) &&
5801 rdev->raid_disk != info->raid_disk) {
5802 /* This was a hot-add request, but events doesn't
5803 * match, so reject it.
5804 */
5805 export_rdev(rdev);
5806 return -EINVAL;
5807 }
5808
5809 if (test_bit(In_sync, &rdev->flags))
5810 rdev->saved_raid_disk = rdev->raid_disk;
5811 else
5812 rdev->saved_raid_disk = -1;
5813
5814 clear_bit(In_sync, &rdev->flags); /* just to be sure */
5815 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
5816 set_bit(WriteMostly, &rdev->flags);
5817 else
5818 clear_bit(WriteMostly, &rdev->flags);
5819
5820 rdev->raid_disk = -1;
5821 err = bind_rdev_to_array(rdev, mddev);
5822 if (!err && !mddev->pers->hot_remove_disk) {
5823 /* If there is hot_add_disk but no hot_remove_disk
5824 * then added disks for geometry changes,
5825 * and should be added immediately.
5826 */
5827 super_types[mddev->major_version].
5828 validate_super(mddev, rdev);
5829 err = mddev->pers->hot_add_disk(mddev, rdev);
5830 if (err)
5831 unbind_rdev_from_array(rdev);
5832 }
5833 if (err)
5834 export_rdev(rdev);
5835 else
5836 sysfs_notify_dirent_safe(rdev->sysfs_state);
5837
5838 md_update_sb(mddev, 1);
5839 if (mddev->degraded)
5840 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
5841 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5842 if (!err)
5843 md_new_event(mddev);
5844 md_wakeup_thread(mddev->thread);
5845 return err;
5846 }
5847
5848 /* otherwise, add_new_disk is only allowed
5849 * for major_version==0 superblocks
5850 */
5851 if (mddev->major_version != 0) {
5852 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
5853 mdname(mddev));
5854 return -EINVAL;
5855 }
5856
5857 if (!(info->state & (1<<MD_DISK_FAULTY))) {
5858 int err;
5859 rdev = md_import_device(dev, -1, 0);
5860 if (IS_ERR(rdev)) {
5861 printk(KERN_WARNING
5862 "md: error, md_import_device() returned %ld\n",
5863 PTR_ERR(rdev));
5864 return PTR_ERR(rdev);
5865 }
5866 rdev->desc_nr = info->number;
5867 if (info->raid_disk < mddev->raid_disks)
5868 rdev->raid_disk = info->raid_disk;
5869 else
5870 rdev->raid_disk = -1;
5871
5872 if (rdev->raid_disk < mddev->raid_disks)
5873 if (info->state & (1<<MD_DISK_SYNC))
5874 set_bit(In_sync, &rdev->flags);
5875
5876 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
5877 set_bit(WriteMostly, &rdev->flags);
5878
5879 if (!mddev->persistent) {
5880 printk(KERN_INFO "md: nonpersistent superblock ...\n");
5881 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
5882 } else
5883 rdev->sb_start = calc_dev_sboffset(rdev);
5884 rdev->sectors = rdev->sb_start;
5885
5886 err = bind_rdev_to_array(rdev, mddev);
5887 if (err) {
5888 export_rdev(rdev);
5889 return err;
5890 }
5891 }
5892
5893 return 0;
5894}
5895
5896static int hot_remove_disk(struct mddev * mddev, dev_t dev)
5897{
5898 char b[BDEVNAME_SIZE];
5899 struct md_rdev *rdev;
5900
5901 rdev = find_rdev(mddev, dev);
5902 if (!rdev)
5903 return -ENXIO;
5904
5905 if (rdev->raid_disk >= 0)
5906 goto busy;
5907
5908 kick_rdev_from_array(rdev);
5909 md_update_sb(mddev, 1);
5910 md_new_event(mddev);
5911
5912 return 0;
5913busy:
5914 printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
5915 bdevname(rdev->bdev,b), mdname(mddev));
5916 return -EBUSY;
5917}
5918
5919static int hot_add_disk(struct mddev * mddev, dev_t dev)
5920{
5921 char b[BDEVNAME_SIZE];
5922 int err;
5923 struct md_rdev *rdev;
5924
5925 if (!mddev->pers)
5926 return -ENODEV;
5927
5928 if (mddev->major_version != 0) {
5929 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
5930 " version-0 superblocks.\n",
5931 mdname(mddev));
5932 return -EINVAL;
5933 }
5934 if (!mddev->pers->hot_add_disk) {
5935 printk(KERN_WARNING
5936 "%s: personality does not support diskops!\n",
5937 mdname(mddev));
5938 return -EINVAL;
5939 }
5940
5941 rdev = md_import_device(dev, -1, 0);
5942 if (IS_ERR(rdev)) {
5943 printk(KERN_WARNING
5944 "md: error, md_import_device() returned %ld\n",
5945 PTR_ERR(rdev));
5946 return -EINVAL;
5947 }
5948
5949 if (mddev->persistent)
5950 rdev->sb_start = calc_dev_sboffset(rdev);
5951 else
5952 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
5953
5954 rdev->sectors = rdev->sb_start;
5955
5956 if (test_bit(Faulty, &rdev->flags)) {
5957 printk(KERN_WARNING
5958 "md: can not hot-add faulty %s disk to %s!\n",
5959 bdevname(rdev->bdev,b), mdname(mddev));
5960 err = -EINVAL;
5961 goto abort_export;
5962 }
5963 clear_bit(In_sync, &rdev->flags);
5964 rdev->desc_nr = -1;
5965 rdev->saved_raid_disk = -1;
5966 err = bind_rdev_to_array(rdev, mddev);
5967 if (err)
5968 goto abort_export;
5969
5970 /*
5971 * The rest should better be atomic, we can have disk failures
5972 * noticed in interrupt contexts ...
5973 */
5974
5975 rdev->raid_disk = -1;
5976
5977 md_update_sb(mddev, 1);
5978
5979 /*
5980 * Kick recovery, maybe this spare has to be added to the
5981 * array immediately.
5982 */
5983 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5984 md_wakeup_thread(mddev->thread);
5985 md_new_event(mddev);
5986 return 0;
5987
5988abort_export:
5989 export_rdev(rdev);
5990 return err;
5991}
5992
5993static int set_bitmap_file(struct mddev *mddev, int fd)
5994{
5995 int err;
5996
5997 if (mddev->pers) {
5998 if (!mddev->pers->quiesce)
5999 return -EBUSY;
6000 if (mddev->recovery || mddev->sync_thread)
6001 return -EBUSY;
6002 /* we should be able to change the bitmap.. */
6003 }
6004
6005
6006 if (fd >= 0) {
6007 if (mddev->bitmap)
6008 return -EEXIST; /* cannot add when bitmap is present */
6009 mddev->bitmap_info.file = fget(fd);
6010
6011 if (mddev->bitmap_info.file == NULL) {
6012 printk(KERN_ERR "%s: error: failed to get bitmap file\n",
6013 mdname(mddev));
6014 return -EBADF;
6015 }
6016
6017 err = deny_bitmap_write_access(mddev->bitmap_info.file);
6018 if (err) {
6019 printk(KERN_ERR "%s: error: bitmap file is already in use\n",
6020 mdname(mddev));
6021 fput(mddev->bitmap_info.file);
6022 mddev->bitmap_info.file = NULL;
6023 return err;
6024 }
6025 mddev->bitmap_info.offset = 0; /* file overrides offset */
6026 } else if (mddev->bitmap == NULL)
6027 return -ENOENT; /* cannot remove what isn't there */
6028 err = 0;
6029 if (mddev->pers) {
6030 mddev->pers->quiesce(mddev, 1);
6031 if (fd >= 0) {
6032 err = bitmap_create(mddev);
6033 if (!err)
6034 err = bitmap_load(mddev);
6035 }
6036 if (fd < 0 || err) {
6037 bitmap_destroy(mddev);
6038 fd = -1; /* make sure to put the file */
6039 }
6040 mddev->pers->quiesce(mddev, 0);
6041 }
6042 if (fd < 0) {
6043 if (mddev->bitmap_info.file) {
6044 restore_bitmap_write_access(mddev->bitmap_info.file);
6045 fput(mddev->bitmap_info.file);
6046 }
6047 mddev->bitmap_info.file = NULL;
6048 }
6049
6050 return err;
6051}
6052
6053/*
6054 * set_array_info is used two different ways
6055 * The original usage is when creating a new array.
6056 * In this usage, raid_disks is > 0 and it together with
6057 * level, size, not_persistent,layout,chunksize determine the
6058 * shape of the array.
6059 * This will always create an array with a type-0.90.0 superblock.
6060 * The newer usage is when assembling an array.
6061 * In this case raid_disks will be 0, and the major_version field is
6062 * use to determine which style super-blocks are to be found on the devices.
6063 * The minor and patch _version numbers are also kept incase the
6064 * super_block handler wishes to interpret them.
6065 */
6066static int set_array_info(struct mddev * mddev, mdu_array_info_t *info)
6067{
6068
6069 if (info->raid_disks == 0) {
6070 /* just setting version number for superblock loading */
6071 if (info->major_version < 0 ||
6072 info->major_version >= ARRAY_SIZE(super_types) ||
6073 super_types[info->major_version].name == NULL) {
6074 /* maybe try to auto-load a module? */
6075 printk(KERN_INFO
6076 "md: superblock version %d not known\n",
6077 info->major_version);
6078 return -EINVAL;
6079 }
6080 mddev->major_version = info->major_version;
6081 mddev->minor_version = info->minor_version;
6082 mddev->patch_version = info->patch_version;
6083 mddev->persistent = !info->not_persistent;
6084 /* ensure mddev_put doesn't delete this now that there
6085 * is some minimal configuration.
6086 */
6087 mddev->ctime = get_seconds();
6088 return 0;
6089 }
6090 mddev->major_version = MD_MAJOR_VERSION;
6091 mddev->minor_version = MD_MINOR_VERSION;
6092 mddev->patch_version = MD_PATCHLEVEL_VERSION;
6093 mddev->ctime = get_seconds();
6094
6095 mddev->level = info->level;
6096 mddev->clevel[0] = 0;
6097 mddev->dev_sectors = 2 * (sector_t)info->size;
6098 mddev->raid_disks = info->raid_disks;
6099 /* don't set md_minor, it is determined by which /dev/md* was
6100 * openned
6101 */
6102 if (info->state & (1<<MD_SB_CLEAN))
6103 mddev->recovery_cp = MaxSector;
6104 else
6105 mddev->recovery_cp = 0;
6106 mddev->persistent = ! info->not_persistent;
6107 mddev->external = 0;
6108
6109 mddev->layout = info->layout;
6110 mddev->chunk_sectors = info->chunk_size >> 9;
6111
6112 mddev->max_disks = MD_SB_DISKS;
6113
6114 if (mddev->persistent)
6115 mddev->flags = 0;
6116 set_bit(MD_CHANGE_DEVS, &mddev->flags);
6117
6118 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
6119 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
6120 mddev->bitmap_info.offset = 0;
6121
6122 mddev->reshape_position = MaxSector;
6123
6124 /*
6125 * Generate a 128 bit UUID
6126 */
6127 get_random_bytes(mddev->uuid, 16);
6128
6129 mddev->new_level = mddev->level;
6130 mddev->new_chunk_sectors = mddev->chunk_sectors;
6131 mddev->new_layout = mddev->layout;
6132 mddev->delta_disks = 0;
6133 mddev->reshape_backwards = 0;
6134
6135 return 0;
6136}
6137
6138void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
6139{
6140 WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);
6141
6142 if (mddev->external_size)
6143 return;
6144
6145 mddev->array_sectors = array_sectors;
6146}
6147EXPORT_SYMBOL(md_set_array_sectors);
6148
6149static int update_size(struct mddev *mddev, sector_t num_sectors)
6150{
6151 struct md_rdev *rdev;
6152 int rv;
6153 int fit = (num_sectors == 0);
6154
6155 if (mddev->pers->resize == NULL)
6156 return -EINVAL;
6157 /* The "num_sectors" is the number of sectors of each device that
6158 * is used. This can only make sense for arrays with redundancy.
6159 * linear and raid0 always use whatever space is available. We can only
6160 * consider changing this number if no resync or reconstruction is
6161 * happening, and if the new size is acceptable. It must fit before the
6162 * sb_start or, if that is <data_offset, it must fit before the size
6163 * of each device. If num_sectors is zero, we find the largest size
6164 * that fits.
6165 */
6166 if (mddev->sync_thread)
6167 return -EBUSY;
6168
6169 rdev_for_each(rdev, mddev) {
6170 sector_t avail = rdev->sectors;
6171
6172 if (fit && (num_sectors == 0 || num_sectors > avail))
6173 num_sectors = avail;
6174 if (avail < num_sectors)
6175 return -ENOSPC;
6176 }
6177 rv = mddev->pers->resize(mddev, num_sectors);
6178 if (!rv)
6179 revalidate_disk(mddev->gendisk);
6180 return rv;
6181}
6182
6183static int update_raid_disks(struct mddev *mddev, int raid_disks)
6184{
6185 int rv;
6186 struct md_rdev *rdev;
6187 /* change the number of raid disks */
6188 if (mddev->pers->check_reshape == NULL)
6189 return -EINVAL;
6190 if (raid_disks <= 0 ||
6191 (mddev->max_disks && raid_disks >= mddev->max_disks))
6192 return -EINVAL;
6193 if (mddev->sync_thread || mddev->reshape_position != MaxSector)
6194 return -EBUSY;
6195
6196 rdev_for_each(rdev, mddev) {
6197 if (mddev->raid_disks < raid_disks &&
6198 rdev->data_offset < rdev->new_data_offset)
6199 return -EINVAL;
6200 if (mddev->raid_disks > raid_disks &&
6201 rdev->data_offset > rdev->new_data_offset)
6202 return -EINVAL;
6203 }
6204
6205 mddev->delta_disks = raid_disks - mddev->raid_disks;
6206 if (mddev->delta_disks < 0)
6207 mddev->reshape_backwards = 1;
6208 else if (mddev->delta_disks > 0)
6209 mddev->reshape_backwards = 0;
6210
6211 rv = mddev->pers->check_reshape(mddev);
6212 if (rv < 0) {
6213 mddev->delta_disks = 0;
6214 mddev->reshape_backwards = 0;
6215 }
6216 return rv;
6217}
6218
6219
6220/*
6221 * update_array_info is used to change the configuration of an
6222 * on-line array.
6223 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
6224 * fields in the info are checked against the array.
6225 * Any differences that cannot be handled will cause an error.
6226 * Normally, only one change can be managed at a time.
6227 */
6228static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
6229{
6230 int rv = 0;
6231 int cnt = 0;
6232 int state = 0;
6233
6234 /* calculate expected state,ignoring low bits */
6235 if (mddev->bitmap && mddev->bitmap_info.offset)
6236 state |= (1 << MD_SB_BITMAP_PRESENT);
6237
6238 if (mddev->major_version != info->major_version ||
6239 mddev->minor_version != info->minor_version ||
6240/* mddev->patch_version != info->patch_version || */
6241 mddev->ctime != info->ctime ||
6242 mddev->level != info->level ||
6243/* mddev->layout != info->layout || */
6244 !mddev->persistent != info->not_persistent||
6245 mddev->chunk_sectors != info->chunk_size >> 9 ||
6246 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
6247 ((state^info->state) & 0xfffffe00)
6248 )
6249 return -EINVAL;
6250 /* Check there is only one change */
6251 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
6252 cnt++;
6253 if (mddev->raid_disks != info->raid_disks)
6254 cnt++;
6255 if (mddev->layout != info->layout)
6256 cnt++;
6257 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
6258 cnt++;
6259 if (cnt == 0)
6260 return 0;
6261 if (cnt > 1)
6262 return -EINVAL;
6263
6264 if (mddev->layout != info->layout) {
6265 /* Change layout
6266 * we don't need to do anything at the md level, the
6267 * personality will take care of it all.
6268 */
6269 if (mddev->pers->check_reshape == NULL)
6270 return -EINVAL;
6271 else {
6272 mddev->new_layout = info->layout;
6273 rv = mddev->pers->check_reshape(mddev);
6274 if (rv)
6275 mddev->new_layout = mddev->layout;
6276 return rv;
6277 }
6278 }
6279 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
6280 rv = update_size(mddev, (sector_t)info->size * 2);
6281
6282 if (mddev->raid_disks != info->raid_disks)
6283 rv = update_raid_disks(mddev, info->raid_disks);
6284
6285 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
6286 if (mddev->pers->quiesce == NULL)
6287 return -EINVAL;
6288 if (mddev->recovery || mddev->sync_thread)
6289 return -EBUSY;
6290 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
6291 /* add the bitmap */
6292 if (mddev->bitmap)
6293 return -EEXIST;
6294 if (mddev->bitmap_info.default_offset == 0)
6295 return -EINVAL;
6296 mddev->bitmap_info.offset =
6297 mddev->bitmap_info.default_offset;
6298 mddev->bitmap_info.space =
6299 mddev->bitmap_info.default_space;
6300 mddev->pers->quiesce(mddev, 1);
6301 rv = bitmap_create(mddev);
6302 if (!rv)
6303 rv = bitmap_load(mddev);
6304 if (rv)
6305 bitmap_destroy(mddev);
6306 mddev->pers->quiesce(mddev, 0);
6307 } else {
6308 /* remove the bitmap */
6309 if (!mddev->bitmap)
6310 return -ENOENT;
6311 if (mddev->bitmap->storage.file)
6312 return -EINVAL;
6313 mddev->pers->quiesce(mddev, 1);
6314 bitmap_destroy(mddev);
6315 mddev->pers->quiesce(mddev, 0);
6316 mddev->bitmap_info.offset = 0;
6317 }
6318 }
6319 md_update_sb(mddev, 1);
6320 return rv;
6321}
6322
6323static int set_disk_faulty(struct mddev *mddev, dev_t dev)
6324{
6325 struct md_rdev *rdev;
6326
6327 if (mddev->pers == NULL)
6328 return -ENODEV;
6329
6330 rdev = find_rdev(mddev, dev);
6331 if (!rdev)
6332 return -ENODEV;
6333
6334 md_error(mddev, rdev);
6335 if (!test_bit(Faulty, &rdev->flags))
6336 return -EBUSY;
6337 return 0;
6338}
6339
6340/*
6341 * We have a problem here : there is no easy way to give a CHS
6342 * virtual geometry. We currently pretend that we have a 2 heads
6343 * 4 sectors (with a BIG number of cylinders...). This drives
6344 * dosfs just mad... ;-)
6345 */
6346static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
6347{
6348 struct mddev *mddev = bdev->bd_disk->private_data;
6349
6350 geo->heads = 2;
6351 geo->sectors = 4;
6352 geo->cylinders = mddev->array_sectors / 8;
6353 return 0;
6354}
6355
6356static int md_ioctl(struct block_device *bdev, fmode_t mode,
6357 unsigned int cmd, unsigned long arg)
6358{
6359 int err = 0;
6360 void __user *argp = (void __user *)arg;
6361 struct mddev *mddev = NULL;
6362 int ro;
6363
6364 switch (cmd) {
6365 case RAID_VERSION:
6366 case GET_ARRAY_INFO:
6367 case GET_DISK_INFO:
6368 break;
6369 default:
6370 if (!capable(CAP_SYS_ADMIN))
6371 return -EACCES;
6372 }
6373
6374 /*
6375 * Commands dealing with the RAID driver but not any
6376 * particular array:
6377 */
6378 switch (cmd)
6379 {
6380 case RAID_VERSION:
6381 err = get_version(argp);
6382 goto done;
6383
6384 case PRINT_RAID_DEBUG:
6385 err = 0;
6386 md_print_devices();
6387 goto done;
6388
6389#ifndef MODULE
6390 case RAID_AUTORUN:
6391 err = 0;
6392 autostart_arrays(arg);
6393 goto done;
6394#endif
6395 default:;
6396 }
6397
6398 /*
6399 * Commands creating/starting a new array:
6400 */
6401
6402 mddev = bdev->bd_disk->private_data;
6403
6404 if (!mddev) {
6405 BUG();
6406 goto abort;
6407 }
6408
6409 err = mddev_lock(mddev);
6410 if (err) {
6411 printk(KERN_INFO
6412 "md: ioctl lock interrupted, reason %d, cmd %d\n",
6413 err, cmd);
6414 goto abort;
6415 }
6416
6417 switch (cmd)
6418 {
6419 case SET_ARRAY_INFO:
6420 {
6421 mdu_array_info_t info;
6422 if (!arg)
6423 memset(&info, 0, sizeof(info));
6424 else if (copy_from_user(&info, argp, sizeof(info))) {
6425 err = -EFAULT;
6426 goto abort_unlock;
6427 }
6428 if (mddev->pers) {
6429 err = update_array_info(mddev, &info);
6430 if (err) {
6431 printk(KERN_WARNING "md: couldn't update"
6432 " array info. %d\n", err);
6433 goto abort_unlock;
6434 }
6435 goto done_unlock;
6436 }
6437 if (!list_empty(&mddev->disks)) {
6438 printk(KERN_WARNING
6439 "md: array %s already has disks!\n",
6440 mdname(mddev));
6441 err = -EBUSY;
6442 goto abort_unlock;
6443 }
6444 if (mddev->raid_disks) {
6445 printk(KERN_WARNING
6446 "md: array %s already initialised!\n",
6447 mdname(mddev));
6448 err = -EBUSY;
6449 goto abort_unlock;
6450 }
6451 err = set_array_info(mddev, &info);
6452 if (err) {
6453 printk(KERN_WARNING "md: couldn't set"
6454 " array info. %d\n", err);
6455 goto abort_unlock;
6456 }
6457 }
6458 goto done_unlock;
6459
6460 default:;
6461 }
6462
6463 /*
6464 * Commands querying/configuring an existing array:
6465 */
6466 /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
6467 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
6468 if ((!mddev->raid_disks && !mddev->external)
6469 && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
6470 && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
6471 && cmd != GET_BITMAP_FILE) {
6472 err = -ENODEV;
6473 goto abort_unlock;
6474 }
6475
6476 /*
6477 * Commands even a read-only array can execute:
6478 */
6479 switch (cmd)
6480 {
6481 case GET_ARRAY_INFO:
6482 err = get_array_info(mddev, argp);
6483 goto done_unlock;
6484
6485 case GET_BITMAP_FILE:
6486 err = get_bitmap_file(mddev, argp);
6487 goto done_unlock;
6488
6489 case GET_DISK_INFO:
6490 err = get_disk_info(mddev, argp);
6491 goto done_unlock;
6492
6493 case RESTART_ARRAY_RW:
6494 err = restart_array(mddev);
6495 goto done_unlock;
6496
6497 case STOP_ARRAY:
6498 err = do_md_stop(mddev, 0, bdev);
6499 goto done_unlock;
6500
6501 case STOP_ARRAY_RO:
6502 err = md_set_readonly(mddev, bdev);
6503 goto done_unlock;
6504
6505 case BLKROSET:
6506 if (get_user(ro, (int __user *)(arg))) {
6507 err = -EFAULT;
6508 goto done_unlock;
6509 }
6510 err = -EINVAL;
6511
6512 /* if the bdev is going readonly the value of mddev->ro
6513 * does not matter, no writes are coming
6514 */
6515 if (ro)
6516 goto done_unlock;
6517
6518 /* are we are already prepared for writes? */
6519 if (mddev->ro != 1)
6520 goto done_unlock;
6521
6522 /* transitioning to readauto need only happen for
6523 * arrays that call md_write_start
6524 */
6525 if (mddev->pers) {
6526 err = restart_array(mddev);
6527 if (err == 0) {
6528 mddev->ro = 2;
6529 set_disk_ro(mddev->gendisk, 0);
6530 }
6531 }
6532 goto done_unlock;
6533 }
6534
6535 /*
6536 * The remaining ioctls are changing the state of the
6537 * superblock, so we do not allow them on read-only arrays.
6538 * However non-MD ioctls (e.g. get-size) will still come through
6539 * here and hit the 'default' below, so only disallow
6540 * 'md' ioctls, and switch to rw mode if started auto-readonly.
6541 */
6542 if (_IOC_TYPE(cmd) == MD_MAJOR && mddev->ro && mddev->pers) {
6543 if (mddev->ro == 2) {
6544 mddev->ro = 0;
6545 sysfs_notify_dirent_safe(mddev->sysfs_state);
6546 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6547 md_wakeup_thread(mddev->thread);
6548 } else {
6549 err = -EROFS;
6550 goto abort_unlock;
6551 }
6552 }
6553
6554 switch (cmd)
6555 {
6556 case ADD_NEW_DISK:
6557 {
6558 mdu_disk_info_t info;
6559 if (copy_from_user(&info, argp, sizeof(info)))
6560 err = -EFAULT;
6561 else
6562 err = add_new_disk(mddev, &info);
6563 goto done_unlock;
6564 }
6565
6566 case HOT_REMOVE_DISK:
6567 err = hot_remove_disk(mddev, new_decode_dev(arg));
6568 goto done_unlock;
6569
6570 case HOT_ADD_DISK:
6571 err = hot_add_disk(mddev, new_decode_dev(arg));
6572 goto done_unlock;
6573
6574 case SET_DISK_FAULTY:
6575 err = set_disk_faulty(mddev, new_decode_dev(arg));
6576 goto done_unlock;
6577
6578 case RUN_ARRAY:
6579 err = do_md_run(mddev);
6580 goto done_unlock;
6581
6582 case SET_BITMAP_FILE:
6583 err = set_bitmap_file(mddev, (int)arg);
6584 goto done_unlock;
6585
6586 default:
6587 err = -EINVAL;
6588 goto abort_unlock;
6589 }
6590
6591done_unlock:
6592abort_unlock:
6593 if (mddev->hold_active == UNTIL_IOCTL &&
6594 err != -EINVAL)
6595 mddev->hold_active = 0;
6596 mddev_unlock(mddev);
6597
6598 return err;
6599done:
6600 if (err)
6601 MD_BUG();
6602abort:
6603 return err;
6604}
6605#ifdef CONFIG_COMPAT
6606static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
6607 unsigned int cmd, unsigned long arg)
6608{
6609 switch (cmd) {
6610 case HOT_REMOVE_DISK:
6611 case HOT_ADD_DISK:
6612 case SET_DISK_FAULTY:
6613 case SET_BITMAP_FILE:
6614 /* These take in integer arg, do not convert */
6615 break;
6616 default:
6617 arg = (unsigned long)compat_ptr(arg);
6618 break;
6619 }
6620
6621 return md_ioctl(bdev, mode, cmd, arg);
6622}
6623#endif /* CONFIG_COMPAT */
6624
6625static int md_open(struct block_device *bdev, fmode_t mode)
6626{
6627 /*
6628 * Succeed if we can lock the mddev, which confirms that
6629 * it isn't being stopped right now.
6630 */
6631 struct mddev *mddev = mddev_find(bdev->bd_dev);
6632 int err;
6633
6634 if (!mddev)
6635 return -ENODEV;
6636
6637 if (mddev->gendisk != bdev->bd_disk) {
6638 /* we are racing with mddev_put which is discarding this
6639 * bd_disk.
6640 */
6641 mddev_put(mddev);
6642 /* Wait until bdev->bd_disk is definitely gone */
6643 flush_workqueue(md_misc_wq);
6644 /* Then retry the open from the top */
6645 return -ERESTARTSYS;
6646 }
6647 BUG_ON(mddev != bdev->bd_disk->private_data);
6648
6649 if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
6650 goto out;
6651
6652 err = 0;
6653 atomic_inc(&mddev->openers);
6654 mutex_unlock(&mddev->open_mutex);
6655
6656 check_disk_change(bdev);
6657 out:
6658 return err;
6659}
6660
6661static int md_release(struct gendisk *disk, fmode_t mode)
6662{
6663 struct mddev *mddev = disk->private_data;
6664
6665 BUG_ON(!mddev);
6666 atomic_dec(&mddev->openers);
6667 mddev_put(mddev);
6668
6669 return 0;
6670}
6671
6672static int md_media_changed(struct gendisk *disk)
6673{
6674 struct mddev *mddev = disk->private_data;
6675
6676 return mddev->changed;
6677}
6678
6679static int md_revalidate(struct gendisk *disk)
6680{
6681 struct mddev *mddev = disk->private_data;
6682
6683 mddev->changed = 0;
6684 return 0;
6685}
6686static const struct block_device_operations md_fops =
6687{
6688 .owner = THIS_MODULE,
6689 .open = md_open,
6690 .release = md_release,
6691 .ioctl = md_ioctl,
6692#ifdef CONFIG_COMPAT
6693 .compat_ioctl = md_compat_ioctl,
6694#endif
6695 .getgeo = md_getgeo,
6696 .media_changed = md_media_changed,
6697 .revalidate_disk= md_revalidate,
6698};
6699
6700static int md_thread(void * arg)
6701{
6702 struct md_thread *thread = arg;
6703
6704 /*
6705 * md_thread is a 'system-thread', it's priority should be very
6706 * high. We avoid resource deadlocks individually in each
6707 * raid personality. (RAID5 does preallocation) We also use RR and
6708 * the very same RT priority as kswapd, thus we will never get
6709 * into a priority inversion deadlock.
6710 *
6711 * we definitely have to have equal or higher priority than
6712 * bdflush, otherwise bdflush will deadlock if there are too
6713 * many dirty RAID5 blocks.
6714 */
6715
6716 allow_signal(SIGKILL);
6717 while (!kthread_should_stop()) {
6718
6719 /* We need to wait INTERRUPTIBLE so that
6720 * we don't add to the load-average.
6721 * That means we need to be sure no signals are
6722 * pending
6723 */
6724 if (signal_pending(current))
6725 flush_signals(current);
6726
6727 wait_event_interruptible_timeout
6728 (thread->wqueue,
6729 test_bit(THREAD_WAKEUP, &thread->flags)
6730 || kthread_should_stop(),
6731 thread->timeout);
6732
6733 clear_bit(THREAD_WAKEUP, &thread->flags);
6734 if (!kthread_should_stop())
6735 thread->run(thread->mddev);
6736 }
6737
6738 return 0;
6739}
6740
6741void md_wakeup_thread(struct md_thread *thread)
6742{
6743 if (thread) {
6744 pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
6745 set_bit(THREAD_WAKEUP, &thread->flags);
6746 wake_up(&thread->wqueue);
6747 }
6748}
6749
6750struct md_thread *md_register_thread(void (*run) (struct mddev *), struct mddev *mddev,
6751 const char *name)
6752{
6753 struct md_thread *thread;
6754
6755 thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
6756 if (!thread)
6757 return NULL;
6758
6759 init_waitqueue_head(&thread->wqueue);
6760
6761 thread->run = run;
6762 thread->mddev = mddev;
6763 thread->timeout = MAX_SCHEDULE_TIMEOUT;
6764 thread->tsk = kthread_run(md_thread, thread,
6765 "%s_%s",
6766 mdname(thread->mddev),
6767 name);
6768 if (IS_ERR(thread->tsk)) {
6769 kfree(thread);
6770 return NULL;
6771 }
6772 return thread;
6773}
6774
6775void md_unregister_thread(struct md_thread **threadp)
6776{
6777 struct md_thread *thread = *threadp;
6778 if (!thread)
6779 return;
6780 pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
6781 /* Locking ensures that mddev_unlock does not wake_up a
6782 * non-existent thread
6783 */
6784 spin_lock(&pers_lock);
6785 *threadp = NULL;
6786 spin_unlock(&pers_lock);
6787
6788 kthread_stop(thread->tsk);
6789 kfree(thread);
6790}
6791
6792void md_error(struct mddev *mddev, struct md_rdev *rdev)
6793{
6794 if (!mddev) {
6795 MD_BUG();
6796 return;
6797 }
6798
6799 if (!rdev || test_bit(Faulty, &rdev->flags))
6800 return;
6801
6802 if (!mddev->pers || !mddev->pers->error_handler)
6803 return;
6804 mddev->pers->error_handler(mddev,rdev);
6805 if (mddev->degraded)
6806 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
6807 sysfs_notify_dirent_safe(rdev->sysfs_state);
6808 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6809 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6810 md_wakeup_thread(mddev->thread);
6811 if (mddev->event_work.func)
6812 queue_work(md_misc_wq, &mddev->event_work);
6813 md_new_event_inintr(mddev);
6814}
6815
6816/* seq_file implementation /proc/mdstat */
6817
6818static void status_unused(struct seq_file *seq)
6819{
6820 int i = 0;
6821 struct md_rdev *rdev;
6822
6823 seq_printf(seq, "unused devices: ");
6824
6825 list_for_each_entry(rdev, &pending_raid_disks, same_set) {
6826 char b[BDEVNAME_SIZE];
6827 i++;
6828 seq_printf(seq, "%s ",
6829 bdevname(rdev->bdev,b));
6830 }
6831 if (!i)
6832 seq_printf(seq, "<none>");
6833
6834 seq_printf(seq, "\n");
6835}
6836
6837
6838static void status_resync(struct seq_file *seq, struct mddev * mddev)
6839{
6840 sector_t max_sectors, resync, res;
6841 unsigned long dt, db;
6842 sector_t rt;
6843 int scale;
6844 unsigned int per_milli;
6845
6846 resync = mddev->curr_resync - atomic_read(&mddev->recovery_active);
6847
6848 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
6849 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
6850 max_sectors = mddev->resync_max_sectors;
6851 else
6852 max_sectors = mddev->dev_sectors;
6853
6854 /*
6855 * Should not happen.
6856 */
6857 if (!max_sectors) {
6858 MD_BUG();
6859 return;
6860 }
6861 /* Pick 'scale' such that (resync>>scale)*1000 will fit
6862 * in a sector_t, and (max_sectors>>scale) will fit in a
6863 * u32, as those are the requirements for sector_div.
6864 * Thus 'scale' must be at least 10
6865 */
6866 scale = 10;
6867 if (sizeof(sector_t) > sizeof(unsigned long)) {
6868 while ( max_sectors/2 > (1ULL<<(scale+32)))
6869 scale++;
6870 }
6871 res = (resync>>scale)*1000;
6872 sector_div(res, (u32)((max_sectors>>scale)+1));
6873
6874 per_milli = res;
6875 {
6876 int i, x = per_milli/50, y = 20-x;
6877 seq_printf(seq, "[");
6878 for (i = 0; i < x; i++)
6879 seq_printf(seq, "=");
6880 seq_printf(seq, ">");
6881 for (i = 0; i < y; i++)
6882 seq_printf(seq, ".");
6883 seq_printf(seq, "] ");
6884 }
6885 seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
6886 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
6887 "reshape" :
6888 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
6889 "check" :
6890 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
6891 "resync" : "recovery"))),
6892 per_milli/10, per_milli % 10,
6893 (unsigned long long) resync/2,
6894 (unsigned long long) max_sectors/2);
6895
6896 /*
6897 * dt: time from mark until now
6898 * db: blocks written from mark until now
6899 * rt: remaining time
6900 *
6901 * rt is a sector_t, so could be 32bit or 64bit.
6902 * So we divide before multiply in case it is 32bit and close
6903 * to the limit.
6904 * We scale the divisor (db) by 32 to avoid losing precision
6905 * near the end of resync when the number of remaining sectors
6906 * is close to 'db'.
6907 * We then divide rt by 32 after multiplying by db to compensate.
6908 * The '+1' avoids division by zero if db is very small.
6909 */
6910 dt = ((jiffies - mddev->resync_mark) / HZ);
6911 if (!dt) dt++;
6912 db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
6913 - mddev->resync_mark_cnt;
6914
6915 rt = max_sectors - resync; /* number of remaining sectors */
6916 sector_div(rt, db/32+1);
6917 rt *= dt;
6918 rt >>= 5;
6919
6920 seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
6921 ((unsigned long)rt % 60)/6);
6922
6923 seq_printf(seq, " speed=%ldK/sec", db/2/dt);
6924}
6925
6926static void *md_seq_start(struct seq_file *seq, loff_t *pos)
6927{
6928 struct list_head *tmp;
6929 loff_t l = *pos;
6930 struct mddev *mddev;
6931
6932 if (l >= 0x10000)
6933 return NULL;
6934 if (!l--)
6935 /* header */
6936 return (void*)1;
6937
6938 spin_lock(&all_mddevs_lock);
6939 list_for_each(tmp,&all_mddevs)
6940 if (!l--) {
6941 mddev = list_entry(tmp, struct mddev, all_mddevs);
6942 mddev_get(mddev);
6943 spin_unlock(&all_mddevs_lock);
6944 return mddev;
6945 }
6946 spin_unlock(&all_mddevs_lock);
6947 if (!l--)
6948 return (void*)2;/* tail */
6949 return NULL;
6950}
6951
6952static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
6953{
6954 struct list_head *tmp;
6955 struct mddev *next_mddev, *mddev = v;
6956
6957 ++*pos;
6958 if (v == (void*)2)
6959 return NULL;
6960
6961 spin_lock(&all_mddevs_lock);
6962 if (v == (void*)1)
6963 tmp = all_mddevs.next;
6964 else
6965 tmp = mddev->all_mddevs.next;
6966 if (tmp != &all_mddevs)
6967 next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
6968 else {
6969 next_mddev = (void*)2;
6970 *pos = 0x10000;
6971 }
6972 spin_unlock(&all_mddevs_lock);
6973
6974 if (v != (void*)1)
6975 mddev_put(mddev);
6976 return next_mddev;
6977
6978}
6979
6980static void md_seq_stop(struct seq_file *seq, void *v)
6981{
6982 struct mddev *mddev = v;
6983
6984 if (mddev && v != (void*)1 && v != (void*)2)
6985 mddev_put(mddev);
6986}
6987
6988static int md_seq_show(struct seq_file *seq, void *v)
6989{
6990 struct mddev *mddev = v;
6991 sector_t sectors;
6992 struct md_rdev *rdev;
6993
6994 if (v == (void*)1) {
6995 struct md_personality *pers;
6996 seq_printf(seq, "Personalities : ");
6997 spin_lock(&pers_lock);
6998 list_for_each_entry(pers, &pers_list, list)
6999 seq_printf(seq, "[%s] ", pers->name);
7000
7001 spin_unlock(&pers_lock);
7002 seq_printf(seq, "\n");
7003 seq->poll_event = atomic_read(&md_event_count);
7004 return 0;
7005 }
7006 if (v == (void*)2) {
7007 status_unused(seq);
7008 return 0;
7009 }
7010
7011 if (mddev_lock(mddev) < 0)
7012 return -EINTR;
7013
7014 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
7015 seq_printf(seq, "%s : %sactive", mdname(mddev),
7016 mddev->pers ? "" : "in");
7017 if (mddev->pers) {
7018 if (mddev->ro==1)
7019 seq_printf(seq, " (read-only)");
7020 if (mddev->ro==2)
7021 seq_printf(seq, " (auto-read-only)");
7022 seq_printf(seq, " %s", mddev->pers->name);
7023 }
7024
7025 sectors = 0;
7026 rdev_for_each(rdev, mddev) {
7027 char b[BDEVNAME_SIZE];
7028 seq_printf(seq, " %s[%d]",
7029 bdevname(rdev->bdev,b), rdev->desc_nr);
7030 if (test_bit(WriteMostly, &rdev->flags))
7031 seq_printf(seq, "(W)");
7032 if (test_bit(Faulty, &rdev->flags)) {
7033 seq_printf(seq, "(F)");
7034 continue;
7035 }
7036 if (rdev->raid_disk < 0)
7037 seq_printf(seq, "(S)"); /* spare */
7038 if (test_bit(Replacement, &rdev->flags))
7039 seq_printf(seq, "(R)");
7040 sectors += rdev->sectors;
7041 }
7042
7043 if (!list_empty(&mddev->disks)) {
7044 if (mddev->pers)
7045 seq_printf(seq, "\n %llu blocks",
7046 (unsigned long long)
7047 mddev->array_sectors / 2);
7048 else
7049 seq_printf(seq, "\n %llu blocks",
7050 (unsigned long long)sectors / 2);
7051 }
7052 if (mddev->persistent) {
7053 if (mddev->major_version != 0 ||
7054 mddev->minor_version != 90) {
7055 seq_printf(seq," super %d.%d",
7056 mddev->major_version,
7057 mddev->minor_version);
7058 }
7059 } else if (mddev->external)
7060 seq_printf(seq, " super external:%s",
7061 mddev->metadata_type);
7062 else
7063 seq_printf(seq, " super non-persistent");
7064
7065 if (mddev->pers) {
7066 mddev->pers->status(seq, mddev);
7067 seq_printf(seq, "\n ");
7068 if (mddev->pers->sync_request) {
7069 if (mddev->curr_resync > 2) {
7070 status_resync(seq, mddev);
7071 seq_printf(seq, "\n ");
7072 } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
7073 seq_printf(seq, "\tresync=DELAYED\n ");
7074 else if (mddev->recovery_cp < MaxSector)
7075 seq_printf(seq, "\tresync=PENDING\n ");
7076 }
7077 } else
7078 seq_printf(seq, "\n ");
7079
7080 bitmap_status(seq, mddev->bitmap);
7081
7082 seq_printf(seq, "\n");
7083 }
7084 mddev_unlock(mddev);
7085
7086 return 0;
7087}
7088
7089static const struct seq_operations md_seq_ops = {
7090 .start = md_seq_start,
7091 .next = md_seq_next,
7092 .stop = md_seq_stop,
7093 .show = md_seq_show,
7094};
7095
7096static int md_seq_open(struct inode *inode, struct file *file)
7097{
7098 struct seq_file *seq;
7099 int error;
7100
7101 error = seq_open(file, &md_seq_ops);
7102 if (error)
7103 return error;
7104
7105 seq = file->private_data;
7106 seq->poll_event = atomic_read(&md_event_count);
7107 return error;
7108}
7109
7110static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
7111{
7112 struct seq_file *seq = filp->private_data;
7113 int mask;
7114
7115 poll_wait(filp, &md_event_waiters, wait);
7116
7117 /* always allow read */
7118 mask = POLLIN | POLLRDNORM;
7119
7120 if (seq->poll_event != atomic_read(&md_event_count))
7121 mask |= POLLERR | POLLPRI;
7122 return mask;
7123}
7124
7125static const struct file_operations md_seq_fops = {
7126 .owner = THIS_MODULE,
7127 .open = md_seq_open,
7128 .read = seq_read,
7129 .llseek = seq_lseek,
7130 .release = seq_release_private,
7131 .poll = mdstat_poll,
7132};
7133
7134int register_md_personality(struct md_personality *p)
7135{
7136 spin_lock(&pers_lock);
7137 list_add_tail(&p->list, &pers_list);
7138 printk(KERN_INFO "md: %s personality registered for level %d\n", p->name, p->level);
7139 spin_unlock(&pers_lock);
7140 return 0;
7141}
7142
7143int unregister_md_personality(struct md_personality *p)
7144{
7145 printk(KERN_INFO "md: %s personality unregistered\n", p->name);
7146 spin_lock(&pers_lock);
7147 list_del_init(&p->list);
7148 spin_unlock(&pers_lock);
7149 return 0;
7150}
7151
7152static int is_mddev_idle(struct mddev *mddev, int init)
7153{
7154 struct md_rdev * rdev;
7155 int idle;
7156 int curr_events;
7157
7158 idle = 1;
7159 rcu_read_lock();
7160 rdev_for_each_rcu(rdev, mddev) {
7161 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
7162 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
7163 (int)part_stat_read(&disk->part0, sectors[1]) -
7164 atomic_read(&disk->sync_io);
7165 /* sync IO will cause sync_io to increase before the disk_stats
7166 * as sync_io is counted when a request starts, and
7167 * disk_stats is counted when it completes.
7168 * So resync activity will cause curr_events to be smaller than
7169 * when there was no such activity.
7170 * non-sync IO will cause disk_stat to increase without
7171 * increasing sync_io so curr_events will (eventually)
7172 * be larger than it was before. Once it becomes
7173 * substantially larger, the test below will cause
7174 * the array to appear non-idle, and resync will slow
7175 * down.
7176 * If there is a lot of outstanding resync activity when
7177 * we set last_event to curr_events, then all that activity
7178 * completing might cause the array to appear non-idle
7179 * and resync will be slowed down even though there might
7180 * not have been non-resync activity. This will only
7181 * happen once though. 'last_events' will soon reflect
7182 * the state where there is little or no outstanding
7183 * resync requests, and further resync activity will
7184 * always make curr_events less than last_events.
7185 *
7186 */
7187 if (init || curr_events - rdev->last_events > 64) {
7188 rdev->last_events = curr_events;
7189 idle = 0;
7190 }
7191 }
7192 rcu_read_unlock();
7193 return idle;
7194}
7195
7196void md_done_sync(struct mddev *mddev, int blocks, int ok)
7197{
7198 /* another "blocks" (512byte) blocks have been synced */
7199 atomic_sub(blocks, &mddev->recovery_active);
7200 wake_up(&mddev->recovery_wait);
7201 if (!ok) {
7202 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7203 md_wakeup_thread(mddev->thread);
7204 // stop recovery, signal do_sync ....
7205 }
7206}
7207
7208
7209/* md_write_start(mddev, bi)
7210 * If we need to update some array metadata (e.g. 'active' flag
7211 * in superblock) before writing, schedule a superblock update
7212 * and wait for it to complete.
7213 */
7214void md_write_start(struct mddev *mddev, struct bio *bi)
7215{
7216 int did_change = 0;
7217 if (bio_data_dir(bi) != WRITE)
7218 return;
7219
7220 BUG_ON(mddev->ro == 1);
7221 if (mddev->ro == 2) {
7222 /* need to switch to read/write */
7223 mddev->ro = 0;
7224 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7225 md_wakeup_thread(mddev->thread);
7226 md_wakeup_thread(mddev->sync_thread);
7227 did_change = 1;
7228 }
7229 atomic_inc(&mddev->writes_pending);
7230 if (mddev->safemode == 1)
7231 mddev->safemode = 0;
7232 if (mddev->in_sync) {
7233 spin_lock_irq(&mddev->write_lock);
7234 if (mddev->in_sync) {
7235 mddev->in_sync = 0;
7236 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7237 set_bit(MD_CHANGE_PENDING, &mddev->flags);
7238 md_wakeup_thread(mddev->thread);
7239 did_change = 1;
7240 }
7241 spin_unlock_irq(&mddev->write_lock);
7242 }
7243 if (did_change)
7244 sysfs_notify_dirent_safe(mddev->sysfs_state);
7245 wait_event(mddev->sb_wait,
7246 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
7247}
7248
7249void md_write_end(struct mddev *mddev)
7250{
7251 if (atomic_dec_and_test(&mddev->writes_pending)) {
7252 if (mddev->safemode == 2)
7253 md_wakeup_thread(mddev->thread);
7254 else if (mddev->safemode_delay)
7255 mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
7256 }
7257}
7258
7259/* md_allow_write(mddev)
7260 * Calling this ensures that the array is marked 'active' so that writes
7261 * may proceed without blocking. It is important to call this before
7262 * attempting a GFP_KERNEL allocation while holding the mddev lock.
7263 * Must be called with mddev_lock held.
7264 *
7265 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
7266 * is dropped, so return -EAGAIN after notifying userspace.
7267 */
7268int md_allow_write(struct mddev *mddev)
7269{
7270 if (!mddev->pers)
7271 return 0;
7272 if (mddev->ro)
7273 return 0;
7274 if (!mddev->pers->sync_request)
7275 return 0;
7276
7277 spin_lock_irq(&mddev->write_lock);
7278 if (mddev->in_sync) {
7279 mddev->in_sync = 0;
7280 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7281 set_bit(MD_CHANGE_PENDING, &mddev->flags);
7282 if (mddev->safemode_delay &&
7283 mddev->safemode == 0)
7284 mddev->safemode = 1;
7285 spin_unlock_irq(&mddev->write_lock);
7286 md_update_sb(mddev, 0);
7287 sysfs_notify_dirent_safe(mddev->sysfs_state);
7288 } else
7289 spin_unlock_irq(&mddev->write_lock);
7290
7291 if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
7292 return -EAGAIN;
7293 else
7294 return 0;
7295}
7296EXPORT_SYMBOL_GPL(md_allow_write);
7297
7298#define SYNC_MARKS 10
7299#define SYNC_MARK_STEP (3*HZ)
7300void md_do_sync(struct mddev *mddev)
7301{
7302 struct mddev *mddev2;
7303 unsigned int currspeed = 0,
7304 window;
7305 sector_t max_sectors,j, io_sectors;
7306 unsigned long mark[SYNC_MARKS];
7307 sector_t mark_cnt[SYNC_MARKS];
7308 int last_mark,m;
7309 struct list_head *tmp;
7310 sector_t last_check;
7311 int skipped = 0;
7312 struct md_rdev *rdev;
7313 char *desc;
7314 struct blk_plug plug;
7315
7316 /* just incase thread restarts... */
7317 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7318 return;
7319 if (mddev->ro) /* never try to sync a read-only array */
7320 return;
7321
7322 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7323 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
7324 desc = "data-check";
7325 else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7326 desc = "requested-resync";
7327 else
7328 desc = "resync";
7329 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7330 desc = "reshape";
7331 else
7332 desc = "recovery";
7333
7334 /* we overload curr_resync somewhat here.
7335 * 0 == not engaged in resync at all
7336 * 2 == checking that there is no conflict with another sync
7337 * 1 == like 2, but have yielded to allow conflicting resync to
7338 * commense
7339 * other == active in resync - this many blocks
7340 *
7341 * Before starting a resync we must have set curr_resync to
7342 * 2, and then checked that every "conflicting" array has curr_resync
7343 * less than ours. When we find one that is the same or higher
7344 * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
7345 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
7346 * This will mean we have to start checking from the beginning again.
7347 *
7348 */
7349
7350 do {
7351 mddev->curr_resync = 2;
7352
7353 try_again:
7354 if (kthread_should_stop())
7355 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7356
7357 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7358 goto skip;
7359 for_each_mddev(mddev2, tmp) {
7360 if (mddev2 == mddev)
7361 continue;
7362 if (!mddev->parallel_resync
7363 && mddev2->curr_resync
7364 && match_mddev_units(mddev, mddev2)) {
7365 DEFINE_WAIT(wq);
7366 if (mddev < mddev2 && mddev->curr_resync == 2) {
7367 /* arbitrarily yield */
7368 mddev->curr_resync = 1;
7369 wake_up(&resync_wait);
7370 }
7371 if (mddev > mddev2 && mddev->curr_resync == 1)
7372 /* no need to wait here, we can wait the next
7373 * time 'round when curr_resync == 2
7374 */
7375 continue;
7376 /* We need to wait 'interruptible' so as not to
7377 * contribute to the load average, and not to
7378 * be caught by 'softlockup'
7379 */
7380 prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
7381 if (!kthread_should_stop() &&
7382 mddev2->curr_resync >= mddev->curr_resync) {
7383 printk(KERN_INFO "md: delaying %s of %s"
7384 " until %s has finished (they"
7385 " share one or more physical units)\n",
7386 desc, mdname(mddev), mdname(mddev2));
7387 mddev_put(mddev2);
7388 if (signal_pending(current))
7389 flush_signals(current);
7390 schedule();
7391 finish_wait(&resync_wait, &wq);
7392 goto try_again;
7393 }
7394 finish_wait(&resync_wait, &wq);
7395 }
7396 }
7397 } while (mddev->curr_resync < 2);
7398
7399 j = 0;
7400 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7401 /* resync follows the size requested by the personality,
7402 * which defaults to physical size, but can be virtual size
7403 */
7404 max_sectors = mddev->resync_max_sectors;
7405 mddev->resync_mismatches = 0;
7406 /* we don't use the checkpoint if there's a bitmap */
7407 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7408 j = mddev->resync_min;
7409 else if (!mddev->bitmap)
7410 j = mddev->recovery_cp;
7411
7412 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7413 max_sectors = mddev->resync_max_sectors;
7414 else {
7415 /* recovery follows the physical size of devices */
7416 max_sectors = mddev->dev_sectors;
7417 j = MaxSector;
7418 rcu_read_lock();
7419 rdev_for_each_rcu(rdev, mddev)
7420 if (rdev->raid_disk >= 0 &&
7421 !test_bit(Faulty, &rdev->flags) &&
7422 !test_bit(In_sync, &rdev->flags) &&
7423 rdev->recovery_offset < j)
7424 j = rdev->recovery_offset;
7425 rcu_read_unlock();
7426 }
7427
7428 printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
7429 printk(KERN_INFO "md: minimum _guaranteed_ speed:"
7430 " %d KB/sec/disk.\n", speed_min(mddev));
7431 printk(KERN_INFO "md: using maximum available idle IO bandwidth "
7432 "(but not more than %d KB/sec) for %s.\n",
7433 speed_max(mddev), desc);
7434
7435 is_mddev_idle(mddev, 1); /* this initializes IO event counters */
7436
7437 io_sectors = 0;
7438 for (m = 0; m < SYNC_MARKS; m++) {
7439 mark[m] = jiffies;
7440 mark_cnt[m] = io_sectors;
7441 }
7442 last_mark = 0;
7443 mddev->resync_mark = mark[last_mark];
7444 mddev->resync_mark_cnt = mark_cnt[last_mark];
7445
7446 /*
7447 * Tune reconstruction:
7448 */
7449 window = 32*(PAGE_SIZE/512);
7450 printk(KERN_INFO "md: using %dk window, over a total of %lluk.\n",
7451 window/2, (unsigned long long)max_sectors/2);
7452
7453 atomic_set(&mddev->recovery_active, 0);
7454 last_check = 0;
7455
7456 if (j>2) {
7457 printk(KERN_INFO
7458 "md: resuming %s of %s from checkpoint.\n",
7459 desc, mdname(mddev));
7460 mddev->curr_resync = j;
7461 }
7462 mddev->curr_resync_completed = j;
7463
7464 blk_start_plug(&plug);
7465 while (j < max_sectors) {
7466 sector_t sectors;
7467
7468 skipped = 0;
7469
7470 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7471 ((mddev->curr_resync > mddev->curr_resync_completed &&
7472 (mddev->curr_resync - mddev->curr_resync_completed)
7473 > (max_sectors >> 4)) ||
7474 (j - mddev->curr_resync_completed)*2
7475 >= mddev->resync_max - mddev->curr_resync_completed
7476 )) {
7477 /* time to update curr_resync_completed */
7478 wait_event(mddev->recovery_wait,
7479 atomic_read(&mddev->recovery_active) == 0);
7480 mddev->curr_resync_completed = j;
7481 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7482 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
7483 }
7484
7485 while (j >= mddev->resync_max && !kthread_should_stop()) {
7486 /* As this condition is controlled by user-space,
7487 * we can block indefinitely, so use '_interruptible'
7488 * to avoid triggering warnings.
7489 */
7490 flush_signals(current); /* just in case */
7491 wait_event_interruptible(mddev->recovery_wait,
7492 mddev->resync_max > j
7493 || kthread_should_stop());
7494 }
7495
7496 if (kthread_should_stop())
7497 goto interrupted;
7498
7499 sectors = mddev->pers->sync_request(mddev, j, &skipped,
7500 currspeed < speed_min(mddev));
7501 if (sectors == 0) {
7502 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7503 goto out;
7504 }
7505
7506 if (!skipped) { /* actual IO requested */
7507 io_sectors += sectors;
7508 atomic_add(sectors, &mddev->recovery_active);
7509 }
7510
7511 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7512 break;
7513
7514 j += sectors;
7515 if (j>1) mddev->curr_resync = j;
7516 mddev->curr_mark_cnt = io_sectors;
7517 if (last_check == 0)
7518 /* this is the earliest that rebuild will be
7519 * visible in /proc/mdstat
7520 */
7521 md_new_event(mddev);
7522
7523 if (last_check + window > io_sectors || j == max_sectors)
7524 continue;
7525
7526 last_check = io_sectors;
7527 repeat:
7528 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
7529 /* step marks */
7530 int next = (last_mark+1) % SYNC_MARKS;
7531
7532 mddev->resync_mark = mark[next];
7533 mddev->resync_mark_cnt = mark_cnt[next];
7534 mark[next] = jiffies;
7535 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
7536 last_mark = next;
7537 }
7538
7539
7540 if (kthread_should_stop())
7541 goto interrupted;
7542
7543
7544 /*
7545 * this loop exits only if either when we are slower than
7546 * the 'hard' speed limit, or the system was IO-idle for
7547 * a jiffy.
7548 * the system might be non-idle CPU-wise, but we only care
7549 * about not overloading the IO subsystem. (things like an
7550 * e2fsck being done on the RAID array should execute fast)
7551 */
7552 cond_resched();
7553
7554 currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
7555 /((jiffies-mddev->resync_mark)/HZ +1) +1;
7556
7557 if (currspeed > speed_min(mddev)) {
7558 if ((currspeed > speed_max(mddev)) ||
7559 !is_mddev_idle(mddev, 0)) {
7560 msleep(500);
7561 goto repeat;
7562 }
7563 }
7564 }
7565 printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc);
7566 /*
7567 * this also signals 'finished resyncing' to md_stop
7568 */
7569 out:
7570 blk_finish_plug(&plug);
7571 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
7572
7573 /* tell personality that we are finished */
7574 mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
7575
7576 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
7577 mddev->curr_resync > 2) {
7578 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7579 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
7580 if (mddev->curr_resync >= mddev->recovery_cp) {
7581 printk(KERN_INFO
7582 "md: checkpointing %s of %s.\n",
7583 desc, mdname(mddev));
7584 mddev->recovery_cp =
7585 mddev->curr_resync_completed;
7586 }
7587 } else
7588 mddev->recovery_cp = MaxSector;
7589 } else {
7590 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7591 mddev->curr_resync = MaxSector;
7592 rcu_read_lock();
7593 rdev_for_each_rcu(rdev, mddev)
7594 if (rdev->raid_disk >= 0 &&
7595 mddev->delta_disks >= 0 &&
7596 !test_bit(Faulty, &rdev->flags) &&
7597 !test_bit(In_sync, &rdev->flags) &&
7598 rdev->recovery_offset < mddev->curr_resync)
7599 rdev->recovery_offset = mddev->curr_resync;
7600 rcu_read_unlock();
7601 }
7602 }
7603 skip:
7604 set_bit(MD_CHANGE_DEVS, &mddev->flags);
7605
7606 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
7607 /* We completed so min/max setting can be forgotten if used. */
7608 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7609 mddev->resync_min = 0;
7610 mddev->resync_max = MaxSector;
7611 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7612 mddev->resync_min = mddev->curr_resync_completed;
7613 mddev->curr_resync = 0;
7614 wake_up(&resync_wait);
7615 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
7616 md_wakeup_thread(mddev->thread);
7617 return;
7618
7619 interrupted:
7620 /*
7621 * got a signal, exit.
7622 */
7623 printk(KERN_INFO
7624 "md: md_do_sync() got signal ... exiting\n");
7625 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7626 goto out;
7627
7628}
7629EXPORT_SYMBOL_GPL(md_do_sync);
7630
7631static int remove_and_add_spares(struct mddev *mddev)
7632{
7633 struct md_rdev *rdev;
7634 int spares = 0;
7635 int removed = 0;
7636
7637 mddev->curr_resync_completed = 0;
7638
7639 rdev_for_each(rdev, mddev)
7640 if (rdev->raid_disk >= 0 &&
7641 !test_bit(Blocked, &rdev->flags) &&
7642 (test_bit(Faulty, &rdev->flags) ||
7643 ! test_bit(In_sync, &rdev->flags)) &&
7644 atomic_read(&rdev->nr_pending)==0) {
7645 if (mddev->pers->hot_remove_disk(
7646 mddev, rdev) == 0) {
7647 sysfs_unlink_rdev(mddev, rdev);
7648 rdev->raid_disk = -1;
7649 removed++;
7650 }
7651 }
7652 if (removed)
7653 sysfs_notify(&mddev->kobj, NULL,
7654 "degraded");
7655
7656
7657 rdev_for_each(rdev, mddev) {
7658 if (rdev->raid_disk >= 0 &&
7659 !test_bit(In_sync, &rdev->flags) &&
7660 !test_bit(Faulty, &rdev->flags))
7661 spares++;
7662 if (rdev->raid_disk < 0
7663 && !test_bit(Faulty, &rdev->flags)) {
7664 rdev->recovery_offset = 0;
7665 if (mddev->pers->
7666 hot_add_disk(mddev, rdev) == 0) {
7667 if (sysfs_link_rdev(mddev, rdev))
7668 /* failure here is OK */;
7669 spares++;
7670 md_new_event(mddev);
7671 set_bit(MD_CHANGE_DEVS, &mddev->flags);
7672 }
7673 }
7674 }
7675 if (removed)
7676 set_bit(MD_CHANGE_DEVS, &mddev->flags);
7677 return spares;
7678}
7679
7680static void reap_sync_thread(struct mddev *mddev)
7681{
7682 struct md_rdev *rdev;
7683
7684 /* resync has finished, collect result */
7685 md_unregister_thread(&mddev->sync_thread);
7686 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
7687 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
7688 /* success...*/
7689 /* activate any spares */
7690 if (mddev->pers->spare_active(mddev)) {
7691 sysfs_notify(&mddev->kobj, NULL,
7692 "degraded");
7693 set_bit(MD_CHANGE_DEVS, &mddev->flags);
7694 }
7695 }
7696 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7697 mddev->pers->finish_reshape)
7698 mddev->pers->finish_reshape(mddev);
7699
7700 /* If array is no-longer degraded, then any saved_raid_disk
7701 * information must be scrapped. Also if any device is now
7702 * In_sync we must scrape the saved_raid_disk for that device
7703 * do the superblock for an incrementally recovered device
7704 * written out.
7705 */
7706 rdev_for_each(rdev, mddev)
7707 if (!mddev->degraded ||
7708 test_bit(In_sync, &rdev->flags))
7709 rdev->saved_raid_disk = -1;
7710
7711 md_update_sb(mddev, 1);
7712 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7713 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7714 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7715 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
7716 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
7717 /* flag recovery needed just to double check */
7718 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7719 sysfs_notify_dirent_safe(mddev->sysfs_action);
7720 md_new_event(mddev);
7721 if (mddev->event_work.func)
7722 queue_work(md_misc_wq, &mddev->event_work);
7723}
7724
7725/*
7726 * This routine is regularly called by all per-raid-array threads to
7727 * deal with generic issues like resync and super-block update.
7728 * Raid personalities that don't have a thread (linear/raid0) do not
7729 * need this as they never do any recovery or update the superblock.
7730 *
7731 * It does not do any resync itself, but rather "forks" off other threads
7732 * to do that as needed.
7733 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
7734 * "->recovery" and create a thread at ->sync_thread.
7735 * When the thread finishes it sets MD_RECOVERY_DONE
7736 * and wakeups up this thread which will reap the thread and finish up.
7737 * This thread also removes any faulty devices (with nr_pending == 0).
7738 *
7739 * The overall approach is:
7740 * 1/ if the superblock needs updating, update it.
7741 * 2/ If a recovery thread is running, don't do anything else.
7742 * 3/ If recovery has finished, clean up, possibly marking spares active.
7743 * 4/ If there are any faulty devices, remove them.
7744 * 5/ If array is degraded, try to add spares devices
7745 * 6/ If array has spares or is not in-sync, start a resync thread.
7746 */
7747void md_check_recovery(struct mddev *mddev)
7748{
7749 if (mddev->suspended)
7750 return;
7751
7752 if (mddev->bitmap)
7753 bitmap_daemon_work(mddev);
7754
7755 if (signal_pending(current)) {
7756 if (mddev->pers->sync_request && !mddev->external) {
7757 printk(KERN_INFO "md: %s in immediate safe mode\n",
7758 mdname(mddev));
7759 mddev->safemode = 2;
7760 }
7761 flush_signals(current);
7762 }
7763
7764 if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
7765 return;
7766 if ( ! (
7767 (mddev->flags & ~ (1<<MD_CHANGE_PENDING)) ||
7768 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
7769 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
7770 (mddev->external == 0 && mddev->safemode == 1) ||
7771 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
7772 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
7773 ))
7774 return;
7775
7776 if (mddev_trylock(mddev)) {
7777 int spares = 0;
7778
7779 if (mddev->ro) {
7780 /* Only thing we do on a ro array is remove
7781 * failed devices.
7782 */
7783 struct md_rdev *rdev;
7784 rdev_for_each(rdev, mddev)
7785 if (rdev->raid_disk >= 0 &&
7786 !test_bit(Blocked, &rdev->flags) &&
7787 test_bit(Faulty, &rdev->flags) &&
7788 atomic_read(&rdev->nr_pending)==0) {
7789 if (mddev->pers->hot_remove_disk(
7790 mddev, rdev) == 0) {
7791 sysfs_unlink_rdev(mddev, rdev);
7792 rdev->raid_disk = -1;
7793 }
7794 }
7795 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7796 goto unlock;
7797 }
7798
7799 if (!mddev->external) {
7800 int did_change = 0;
7801 spin_lock_irq(&mddev->write_lock);
7802 if (mddev->safemode &&
7803 !atomic_read(&mddev->writes_pending) &&
7804 !mddev->in_sync &&
7805 mddev->recovery_cp == MaxSector) {
7806 mddev->in_sync = 1;
7807 did_change = 1;
7808 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7809 }
7810 if (mddev->safemode == 1)
7811 mddev->safemode = 0;
7812 spin_unlock_irq(&mddev->write_lock);
7813 if (did_change)
7814 sysfs_notify_dirent_safe(mddev->sysfs_state);
7815 }
7816
7817 if (mddev->flags)
7818 md_update_sb(mddev, 0);
7819
7820 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
7821 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
7822 /* resync/recovery still happening */
7823 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7824 goto unlock;
7825 }
7826 if (mddev->sync_thread) {
7827 reap_sync_thread(mddev);
7828 goto unlock;
7829 }
7830 /* Set RUNNING before clearing NEEDED to avoid
7831 * any transients in the value of "sync_action".
7832 */
7833 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7834 /* Clear some bits that don't mean anything, but
7835 * might be left set
7836 */
7837 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
7838 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
7839
7840 if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
7841 test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
7842 goto unlock;
7843 /* no recovery is running.
7844 * remove any failed drives, then
7845 * add spares if possible.
7846 * Spare are also removed and re-added, to allow
7847 * the personality to fail the re-add.
7848 */
7849
7850 if (mddev->reshape_position != MaxSector) {
7851 if (mddev->pers->check_reshape == NULL ||
7852 mddev->pers->check_reshape(mddev) != 0)
7853 /* Cannot proceed */
7854 goto unlock;
7855 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7856 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7857 } else if ((spares = remove_and_add_spares(mddev))) {
7858 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7859 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
7860 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
7861 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7862 } else if (mddev->recovery_cp < MaxSector) {
7863 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7864 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7865 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
7866 /* nothing to be done ... */
7867 goto unlock;
7868
7869 if (mddev->pers->sync_request) {
7870 if (spares) {
7871 /* We are adding a device or devices to an array
7872 * which has the bitmap stored on all devices.
7873 * So make sure all bitmap pages get written
7874 */
7875 bitmap_write_all(mddev->bitmap);
7876 }
7877 mddev->sync_thread = md_register_thread(md_do_sync,
7878 mddev,
7879 "resync");
7880 if (!mddev->sync_thread) {
7881 printk(KERN_ERR "%s: could not start resync"
7882 " thread...\n",
7883 mdname(mddev));
7884 /* leave the spares where they are, it shouldn't hurt */
7885 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7886 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7887 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7888 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
7889 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
7890 } else
7891 md_wakeup_thread(mddev->sync_thread);
7892 sysfs_notify_dirent_safe(mddev->sysfs_action);
7893 md_new_event(mddev);
7894 }
7895 unlock:
7896 if (!mddev->sync_thread) {
7897 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7898 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
7899 &mddev->recovery))
7900 if (mddev->sysfs_action)
7901 sysfs_notify_dirent_safe(mddev->sysfs_action);
7902 }
7903 mddev_unlock(mddev);
7904 }
7905}
7906
7907void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
7908{
7909 sysfs_notify_dirent_safe(rdev->sysfs_state);
7910 wait_event_timeout(rdev->blocked_wait,
7911 !test_bit(Blocked, &rdev->flags) &&
7912 !test_bit(BlockedBadBlocks, &rdev->flags),
7913 msecs_to_jiffies(5000));
7914 rdev_dec_pending(rdev, mddev);
7915}
7916EXPORT_SYMBOL(md_wait_for_blocked_rdev);
7917
7918void md_finish_reshape(struct mddev *mddev)
7919{
7920 /* called be personality module when reshape completes. */
7921 struct md_rdev *rdev;
7922
7923 rdev_for_each(rdev, mddev) {
7924 if (rdev->data_offset > rdev->new_data_offset)
7925 rdev->sectors += rdev->data_offset - rdev->new_data_offset;
7926 else
7927 rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
7928 rdev->data_offset = rdev->new_data_offset;
7929 }
7930}
7931EXPORT_SYMBOL(md_finish_reshape);
7932
7933/* Bad block management.
7934 * We can record which blocks on each device are 'bad' and so just
7935 * fail those blocks, or that stripe, rather than the whole device.
7936 * Entries in the bad-block table are 64bits wide. This comprises:
7937 * Length of bad-range, in sectors: 0-511 for lengths 1-512
7938 * Start of bad-range, sector offset, 54 bits (allows 8 exbibytes)
7939 * A 'shift' can be set so that larger blocks are tracked and
7940 * consequently larger devices can be covered.
7941 * 'Acknowledged' flag - 1 bit. - the most significant bit.
7942 *
7943 * Locking of the bad-block table uses a seqlock so md_is_badblock
7944 * might need to retry if it is very unlucky.
7945 * We will sometimes want to check for bad blocks in a bi_end_io function,
7946 * so we use the write_seqlock_irq variant.
7947 *
7948 * When looking for a bad block we specify a range and want to
7949 * know if any block in the range is bad. So we binary-search
7950 * to the last range that starts at-or-before the given endpoint,
7951 * (or "before the sector after the target range")
7952 * then see if it ends after the given start.
7953 * We return
7954 * 0 if there are no known bad blocks in the range
7955 * 1 if there are known bad block which are all acknowledged
7956 * -1 if there are bad blocks which have not yet been acknowledged in metadata.
7957 * plus the start/length of the first bad section we overlap.
7958 */
7959int md_is_badblock(struct badblocks *bb, sector_t s, int sectors,
7960 sector_t *first_bad, int *bad_sectors)
7961{
7962 int hi;
7963 int lo = 0;
7964 u64 *p = bb->page;
7965 int rv = 0;
7966 sector_t target = s + sectors;
7967 unsigned seq;
7968
7969 if (bb->shift > 0) {
7970 /* round the start down, and the end up */
7971 s >>= bb->shift;
7972 target += (1<<bb->shift) - 1;
7973 target >>= bb->shift;
7974 sectors = target - s;
7975 }
7976 /* 'target' is now the first block after the bad range */
7977
7978retry:
7979 seq = read_seqbegin(&bb->lock);
7980
7981 hi = bb->count;
7982
7983 /* Binary search between lo and hi for 'target'
7984 * i.e. for the last range that starts before 'target'
7985 */
7986 /* INVARIANT: ranges before 'lo' and at-or-after 'hi'
7987 * are known not to be the last range before target.
7988 * VARIANT: hi-lo is the number of possible
7989 * ranges, and decreases until it reaches 1
7990 */
7991 while (hi - lo > 1) {
7992 int mid = (lo + hi) / 2;
7993 sector_t a = BB_OFFSET(p[mid]);
7994 if (a < target)
7995 /* This could still be the one, earlier ranges
7996 * could not. */
7997 lo = mid;
7998 else
7999 /* This and later ranges are definitely out. */
8000 hi = mid;
8001 }
8002 /* 'lo' might be the last that started before target, but 'hi' isn't */
8003 if (hi > lo) {
8004 /* need to check all range that end after 's' to see if
8005 * any are unacknowledged.
8006 */
8007 while (lo >= 0 &&
8008 BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > s) {
8009 if (BB_OFFSET(p[lo]) < target) {
8010 /* starts before the end, and finishes after
8011 * the start, so they must overlap
8012 */
8013 if (rv != -1 && BB_ACK(p[lo]))
8014 rv = 1;
8015 else
8016 rv = -1;
8017 *first_bad = BB_OFFSET(p[lo]);
8018 *bad_sectors = BB_LEN(p[lo]);
8019 }
8020 lo--;
8021 }
8022 }
8023
8024 if (read_seqretry(&bb->lock, seq))
8025 goto retry;
8026
8027 return rv;
8028}
8029EXPORT_SYMBOL_GPL(md_is_badblock);
8030
8031/*
8032 * Add a range of bad blocks to the table.
8033 * This might extend the table, or might contract it
8034 * if two adjacent ranges can be merged.
8035 * We binary-search to find the 'insertion' point, then
8036 * decide how best to handle it.
8037 */
8038static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
8039 int acknowledged)
8040{
8041 u64 *p;
8042 int lo, hi;
8043 int rv = 1;
8044
8045 if (bb->shift < 0)
8046 /* badblocks are disabled */
8047 return 0;
8048
8049 if (bb->shift) {
8050 /* round the start down, and the end up */
8051 sector_t next = s + sectors;
8052 s >>= bb->shift;
8053 next += (1<<bb->shift) - 1;
8054 next >>= bb->shift;
8055 sectors = next - s;
8056 }
8057
8058 write_seqlock_irq(&bb->lock);
8059
8060 p = bb->page;
8061 lo = 0;
8062 hi = bb->count;
8063 /* Find the last range that starts at-or-before 's' */
8064 while (hi - lo > 1) {
8065 int mid = (lo + hi) / 2;
8066 sector_t a = BB_OFFSET(p[mid]);
8067 if (a <= s)
8068 lo = mid;
8069 else
8070 hi = mid;
8071 }
8072 if (hi > lo && BB_OFFSET(p[lo]) > s)
8073 hi = lo;
8074
8075 if (hi > lo) {
8076 /* we found a range that might merge with the start
8077 * of our new range
8078 */
8079 sector_t a = BB_OFFSET(p[lo]);
8080 sector_t e = a + BB_LEN(p[lo]);
8081 int ack = BB_ACK(p[lo]);
8082 if (e >= s) {
8083 /* Yes, we can merge with a previous range */
8084 if (s == a && s + sectors >= e)
8085 /* new range covers old */
8086 ack = acknowledged;
8087 else
8088 ack = ack && acknowledged;
8089
8090 if (e < s + sectors)
8091 e = s + sectors;
8092 if (e - a <= BB_MAX_LEN) {
8093 p[lo] = BB_MAKE(a, e-a, ack);
8094 s = e;
8095 } else {
8096 /* does not all fit in one range,
8097 * make p[lo] maximal
8098 */
8099 if (BB_LEN(p[lo]) != BB_MAX_LEN)
8100 p[lo] = BB_MAKE(a, BB_MAX_LEN, ack);
8101 s = a + BB_MAX_LEN;
8102 }
8103 sectors = e - s;
8104 }
8105 }
8106 if (sectors && hi < bb->count) {
8107 /* 'hi' points to the first range that starts after 's'.
8108 * Maybe we can merge with the start of that range */
8109 sector_t a = BB_OFFSET(p[hi]);
8110 sector_t e = a + BB_LEN(p[hi]);
8111 int ack = BB_ACK(p[hi]);
8112 if (a <= s + sectors) {
8113 /* merging is possible */
8114 if (e <= s + sectors) {
8115 /* full overlap */
8116 e = s + sectors;
8117 ack = acknowledged;
8118 } else
8119 ack = ack && acknowledged;
8120
8121 a = s;
8122 if (e - a <= BB_MAX_LEN) {
8123 p[hi] = BB_MAKE(a, e-a, ack);
8124 s = e;
8125 } else {
8126 p[hi] = BB_MAKE(a, BB_MAX_LEN, ack);
8127 s = a + BB_MAX_LEN;
8128 }
8129 sectors = e - s;
8130 lo = hi;
8131 hi++;
8132 }
8133 }
8134 if (sectors == 0 && hi < bb->count) {
8135 /* we might be able to combine lo and hi */
8136 /* Note: 's' is at the end of 'lo' */
8137 sector_t a = BB_OFFSET(p[hi]);
8138 int lolen = BB_LEN(p[lo]);
8139 int hilen = BB_LEN(p[hi]);
8140 int newlen = lolen + hilen - (s - a);
8141 if (s >= a && newlen < BB_MAX_LEN) {
8142 /* yes, we can combine them */
8143 int ack = BB_ACK(p[lo]) && BB_ACK(p[hi]);
8144 p[lo] = BB_MAKE(BB_OFFSET(p[lo]), newlen, ack);
8145 memmove(p + hi, p + hi + 1,
8146 (bb->count - hi - 1) * 8);
8147 bb->count--;
8148 }
8149 }
8150 while (sectors) {
8151 /* didn't merge (it all).
8152 * Need to add a range just before 'hi' */
8153 if (bb->count >= MD_MAX_BADBLOCKS) {
8154 /* No room for more */
8155 rv = 0;
8156 break;
8157 } else {
8158 int this_sectors = sectors;
8159 memmove(p + hi + 1, p + hi,
8160 (bb->count - hi) * 8);
8161 bb->count++;
8162
8163 if (this_sectors > BB_MAX_LEN)
8164 this_sectors = BB_MAX_LEN;
8165 p[hi] = BB_MAKE(s, this_sectors, acknowledged);
8166 sectors -= this_sectors;
8167 s += this_sectors;
8168 }
8169 }
8170
8171 bb->changed = 1;
8172 if (!acknowledged)
8173 bb->unacked_exist = 1;
8174 write_sequnlock_irq(&bb->lock);
8175
8176 return rv;
8177}
8178
8179int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
8180 int is_new)
8181{
8182 int rv;
8183 if (is_new)
8184 s += rdev->new_data_offset;
8185 else
8186 s += rdev->data_offset;
8187 rv = md_set_badblocks(&rdev->badblocks,
8188 s, sectors, 0);
8189 if (rv) {
8190 /* Make sure they get written out promptly */
8191 sysfs_notify_dirent_safe(rdev->sysfs_state);
8192 set_bit(MD_CHANGE_CLEAN, &rdev->mddev->flags);
8193 md_wakeup_thread(rdev->mddev->thread);
8194 }
8195 return rv;
8196}
8197EXPORT_SYMBOL_GPL(rdev_set_badblocks);
8198
8199/*
8200 * Remove a range of bad blocks from the table.
8201 * This may involve extending the table if we spilt a region,
8202 * but it must not fail. So if the table becomes full, we just
8203 * drop the remove request.
8204 */
8205static int md_clear_badblocks(struct badblocks *bb, sector_t s, int sectors)
8206{
8207 u64 *p;
8208 int lo, hi;
8209 sector_t target = s + sectors;
8210 int rv = 0;
8211
8212 if (bb->shift > 0) {
8213 /* When clearing we round the start up and the end down.
8214 * This should not matter as the shift should align with
8215 * the block size and no rounding should ever be needed.
8216 * However it is better the think a block is bad when it
8217 * isn't than to think a block is not bad when it is.
8218 */
8219 s += (1<<bb->shift) - 1;
8220 s >>= bb->shift;
8221 target >>= bb->shift;
8222 sectors = target - s;
8223 }
8224
8225 write_seqlock_irq(&bb->lock);
8226
8227 p = bb->page;
8228 lo = 0;
8229 hi = bb->count;
8230 /* Find the last range that starts before 'target' */
8231 while (hi - lo > 1) {
8232 int mid = (lo + hi) / 2;
8233 sector_t a = BB_OFFSET(p[mid]);
8234 if (a < target)
8235 lo = mid;
8236 else
8237 hi = mid;
8238 }
8239 if (hi > lo) {
8240 /* p[lo] is the last range that could overlap the
8241 * current range. Earlier ranges could also overlap,
8242 * but only this one can overlap the end of the range.
8243 */
8244 if (BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > target) {
8245 /* Partial overlap, leave the tail of this range */
8246 int ack = BB_ACK(p[lo]);
8247 sector_t a = BB_OFFSET(p[lo]);
8248 sector_t end = a + BB_LEN(p[lo]);
8249
8250 if (a < s) {
8251 /* we need to split this range */
8252 if (bb->count >= MD_MAX_BADBLOCKS) {
8253 rv = 0;
8254 goto out;
8255 }
8256 memmove(p+lo+1, p+lo, (bb->count - lo) * 8);
8257 bb->count++;
8258 p[lo] = BB_MAKE(a, s-a, ack);
8259 lo++;
8260 }
8261 p[lo] = BB_MAKE(target, end - target, ack);
8262 /* there is no longer an overlap */
8263 hi = lo;
8264 lo--;
8265 }
8266 while (lo >= 0 &&
8267 BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > s) {
8268 /* This range does overlap */
8269 if (BB_OFFSET(p[lo]) < s) {
8270 /* Keep the early parts of this range. */
8271 int ack = BB_ACK(p[lo]);
8272 sector_t start = BB_OFFSET(p[lo]);
8273 p[lo] = BB_MAKE(start, s - start, ack);
8274 /* now low doesn't overlap, so.. */
8275 break;
8276 }
8277 lo--;
8278 }
8279 /* 'lo' is strictly before, 'hi' is strictly after,
8280 * anything between needs to be discarded
8281 */
8282 if (hi - lo > 1) {
8283 memmove(p+lo+1, p+hi, (bb->count - hi) * 8);
8284 bb->count -= (hi - lo - 1);
8285 }
8286 }
8287
8288 bb->changed = 1;
8289out:
8290 write_sequnlock_irq(&bb->lock);
8291 return rv;
8292}
8293
8294int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
8295 int is_new)
8296{
8297 if (is_new)
8298 s += rdev->new_data_offset;
8299 else
8300 s += rdev->data_offset;
8301 return md_clear_badblocks(&rdev->badblocks,
8302 s, sectors);
8303}
8304EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
8305
8306/*
8307 * Acknowledge all bad blocks in a list.
8308 * This only succeeds if ->changed is clear. It is used by
8309 * in-kernel metadata updates
8310 */
8311void md_ack_all_badblocks(struct badblocks *bb)
8312{
8313 if (bb->page == NULL || bb->changed)
8314 /* no point even trying */
8315 return;
8316 write_seqlock_irq(&bb->lock);
8317
8318 if (bb->changed == 0 && bb->unacked_exist) {
8319 u64 *p = bb->page;
8320 int i;
8321 for (i = 0; i < bb->count ; i++) {
8322 if (!BB_ACK(p[i])) {
8323 sector_t start = BB_OFFSET(p[i]);
8324 int len = BB_LEN(p[i]);
8325 p[i] = BB_MAKE(start, len, 1);
8326 }
8327 }
8328 bb->unacked_exist = 0;
8329 }
8330 write_sequnlock_irq(&bb->lock);
8331}
8332EXPORT_SYMBOL_GPL(md_ack_all_badblocks);
8333
8334/* sysfs access to bad-blocks list.
8335 * We present two files.
8336 * 'bad-blocks' lists sector numbers and lengths of ranges that
8337 * are recorded as bad. The list is truncated to fit within
8338 * the one-page limit of sysfs.
8339 * Writing "sector length" to this file adds an acknowledged
8340 * bad block list.
8341 * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
8342 * been acknowledged. Writing to this file adds bad blocks
8343 * without acknowledging them. This is largely for testing.
8344 */
8345
8346static ssize_t
8347badblocks_show(struct badblocks *bb, char *page, int unack)
8348{
8349 size_t len;
8350 int i;
8351 u64 *p = bb->page;
8352 unsigned seq;
8353
8354 if (bb->shift < 0)
8355 return 0;
8356
8357retry:
8358 seq = read_seqbegin(&bb->lock);
8359
8360 len = 0;
8361 i = 0;
8362
8363 while (len < PAGE_SIZE && i < bb->count) {
8364 sector_t s = BB_OFFSET(p[i]);
8365 unsigned int length = BB_LEN(p[i]);
8366 int ack = BB_ACK(p[i]);
8367 i++;
8368
8369 if (unack && ack)
8370 continue;
8371
8372 len += snprintf(page+len, PAGE_SIZE-len, "%llu %u\n",
8373 (unsigned long long)s << bb->shift,
8374 length << bb->shift);
8375 }
8376 if (unack && len == 0)
8377 bb->unacked_exist = 0;
8378
8379 if (read_seqretry(&bb->lock, seq))
8380 goto retry;
8381
8382 return len;
8383}
8384
8385#define DO_DEBUG 1
8386
8387static ssize_t
8388badblocks_store(struct badblocks *bb, const char *page, size_t len, int unack)
8389{
8390 unsigned long long sector;
8391 int length;
8392 char newline;
8393#ifdef DO_DEBUG
8394 /* Allow clearing via sysfs *only* for testing/debugging.
8395 * Normally only a successful write may clear a badblock
8396 */
8397 int clear = 0;
8398 if (page[0] == '-') {
8399 clear = 1;
8400 page++;
8401 }
8402#endif /* DO_DEBUG */
8403
8404 switch (sscanf(page, "%llu %d%c", §or, &length, &newline)) {
8405 case 3:
8406 if (newline != '\n')
8407 return -EINVAL;
8408 case 2:
8409 if (length <= 0)
8410 return -EINVAL;
8411 break;
8412 default:
8413 return -EINVAL;
8414 }
8415
8416#ifdef DO_DEBUG
8417 if (clear) {
8418 md_clear_badblocks(bb, sector, length);
8419 return len;
8420 }
8421#endif /* DO_DEBUG */
8422 if (md_set_badblocks(bb, sector, length, !unack))
8423 return len;
8424 else
8425 return -ENOSPC;
8426}
8427
8428static int md_notify_reboot(struct notifier_block *this,
8429 unsigned long code, void *x)
8430{
8431 struct list_head *tmp;
8432 struct mddev *mddev;
8433 int need_delay = 0;
8434
8435 for_each_mddev(mddev, tmp) {
8436 if (mddev_trylock(mddev)) {
8437 if (mddev->pers)
8438 __md_stop_writes(mddev);
8439 mddev->safemode = 2;
8440 mddev_unlock(mddev);
8441 }
8442 need_delay = 1;
8443 }
8444 /*
8445 * certain more exotic SCSI devices are known to be
8446 * volatile wrt too early system reboots. While the
8447 * right place to handle this issue is the given
8448 * driver, we do want to have a safe RAID driver ...
8449 */
8450 if (need_delay)
8451 mdelay(1000*1);
8452
8453 return NOTIFY_DONE;
8454}
8455
8456static struct notifier_block md_notifier = {
8457 .notifier_call = md_notify_reboot,
8458 .next = NULL,
8459 .priority = INT_MAX, /* before any real devices */
8460};
8461
8462static void md_geninit(void)
8463{
8464 pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
8465
8466 proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
8467}
8468
8469static int __init md_init(void)
8470{
8471 int ret = -ENOMEM;
8472
8473 md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
8474 if (!md_wq)
8475 goto err_wq;
8476
8477 md_misc_wq = alloc_workqueue("md_misc", 0, 0);
8478 if (!md_misc_wq)
8479 goto err_misc_wq;
8480
8481 if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
8482 goto err_md;
8483
8484 if ((ret = register_blkdev(0, "mdp")) < 0)
8485 goto err_mdp;
8486 mdp_major = ret;
8487
8488 blk_register_region(MKDEV(MD_MAJOR, 0), 1UL<<MINORBITS, THIS_MODULE,
8489 md_probe, NULL, NULL);
8490 blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
8491 md_probe, NULL, NULL);
8492
8493 register_reboot_notifier(&md_notifier);
8494 raid_table_header = register_sysctl_table(raid_root_table);
8495
8496 md_geninit();
8497 return 0;
8498
8499err_mdp:
8500 unregister_blkdev(MD_MAJOR, "md");
8501err_md:
8502 destroy_workqueue(md_misc_wq);
8503err_misc_wq:
8504 destroy_workqueue(md_wq);
8505err_wq:
8506 return ret;
8507}
8508
8509#ifndef MODULE
8510
8511/*
8512 * Searches all registered partitions for autorun RAID arrays
8513 * at boot time.
8514 */
8515
8516static LIST_HEAD(all_detected_devices);
8517struct detected_devices_node {
8518 struct list_head list;
8519 dev_t dev;
8520};
8521
8522void md_autodetect_dev(dev_t dev)
8523{
8524 struct detected_devices_node *node_detected_dev;
8525
8526 node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
8527 if (node_detected_dev) {
8528 node_detected_dev->dev = dev;
8529 list_add_tail(&node_detected_dev->list, &all_detected_devices);
8530 } else {
8531 printk(KERN_CRIT "md: md_autodetect_dev: kzalloc failed"
8532 ", skipping dev(%d,%d)\n", MAJOR(dev), MINOR(dev));
8533 }
8534}
8535
8536
8537static void autostart_arrays(int part)
8538{
8539 struct md_rdev *rdev;
8540 struct detected_devices_node *node_detected_dev;
8541 dev_t dev;
8542 int i_scanned, i_passed;
8543
8544 i_scanned = 0;
8545 i_passed = 0;
8546
8547 printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
8548
8549 while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
8550 i_scanned++;
8551 node_detected_dev = list_entry(all_detected_devices.next,
8552 struct detected_devices_node, list);
8553 list_del(&node_detected_dev->list);
8554 dev = node_detected_dev->dev;
8555 kfree(node_detected_dev);
8556 rdev = md_import_device(dev,0, 90);
8557 if (IS_ERR(rdev))
8558 continue;
8559
8560 if (test_bit(Faulty, &rdev->flags)) {
8561 MD_BUG();
8562 continue;
8563 }
8564 set_bit(AutoDetected, &rdev->flags);
8565 list_add(&rdev->same_set, &pending_raid_disks);
8566 i_passed++;
8567 }
8568
8569 printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
8570 i_scanned, i_passed);
8571
8572 autorun_devices(part);
8573}
8574
8575#endif /* !MODULE */
8576
8577static __exit void md_exit(void)
8578{
8579 struct mddev *mddev;
8580 struct list_head *tmp;
8581
8582 blk_unregister_region(MKDEV(MD_MAJOR,0), 1U << MINORBITS);
8583 blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
8584
8585 unregister_blkdev(MD_MAJOR,"md");
8586 unregister_blkdev(mdp_major, "mdp");
8587 unregister_reboot_notifier(&md_notifier);
8588 unregister_sysctl_table(raid_table_header);
8589 remove_proc_entry("mdstat", NULL);
8590 for_each_mddev(mddev, tmp) {
8591 export_array(mddev);
8592 mddev->hold_active = 0;
8593 }
8594 destroy_workqueue(md_misc_wq);
8595 destroy_workqueue(md_wq);
8596}
8597
8598subsys_initcall(md_init);
8599module_exit(md_exit)
8600
8601static int get_ro(char *buffer, struct kernel_param *kp)
8602{
8603 return sprintf(buffer, "%d", start_readonly);
8604}
8605static int set_ro(const char *val, struct kernel_param *kp)
8606{
8607 char *e;
8608 int num = simple_strtoul(val, &e, 10);
8609 if (*val && (*e == '\0' || *e == '\n')) {
8610 start_readonly = num;
8611 return 0;
8612 }
8613 return -EINVAL;
8614}
8615
8616module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
8617module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
8618
8619module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
8620
8621EXPORT_SYMBOL(register_md_personality);
8622EXPORT_SYMBOL(unregister_md_personality);
8623EXPORT_SYMBOL(md_error);
8624EXPORT_SYMBOL(md_done_sync);
8625EXPORT_SYMBOL(md_write_start);
8626EXPORT_SYMBOL(md_write_end);
8627EXPORT_SYMBOL(md_register_thread);
8628EXPORT_SYMBOL(md_unregister_thread);
8629EXPORT_SYMBOL(md_wakeup_thread);
8630EXPORT_SYMBOL(md_check_recovery);
8631MODULE_LICENSE("GPL");
8632MODULE_DESCRIPTION("MD RAID framework");
8633MODULE_ALIAS("md");
8634MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);