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