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