projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
md/raid5: be careful not to resize_stripes too big.
[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++) {
1820 u64 internal_bb = *p++;
1821 u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
1822 | BB_LEN(internal_bb));
1823 *bbp++ = cpu_to_le64(store_bb);
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
c804cdec
N		 4403 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
4404 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
58c0fed4 4405 max_sectors = mddev->resync_max_sectors;
88202a0c 4406 else
58c0fed4 4407 max_sectors = mddev->dev_sectors;
88202a0c 4408
acb180b0 4409 resync = mddev->curr_resync_completed;
13ae864b 4410 return sprintf(page, "%llu / %llu\n", resync, max_sectors);
88202a0c
N		 4411}
4412
80ca3a44 4413static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
88202a0c 4414
5e96ee65 4415static ssize_t
fd01b88c 4416min_sync_show(struct mddev *mddev, char *page)
5e96ee65
NB		 4417{
4418 return sprintf(page, "%llu\n",
4419 (unsigned long long)mddev->resync_min);
4420}
4421static ssize_t
fd01b88c 4422min_sync_store(struct mddev *mddev, const char *buf, size_t len)
5e96ee65
NB		 4423{
4424 unsigned long long min;
4425 if (strict_strtoull(buf, 10, &min))
4426 return -EINVAL;
4427 if (min > mddev->resync_max)
4428 return -EINVAL;
4429 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4430 return -EBUSY;
4431
4432 /* Must be a multiple of chunk_size */
9d8f0363 4433 if (mddev->chunk_sectors) {
2ac06c33 4434 sector_t temp = min;
9d8f0363 4435 if (sector_div(temp, mddev->chunk_sectors))
5e96ee65
NB		 4436 return -EINVAL;
4437 }
4438 mddev->resync_min = min;
4439
4440 return len;
4441}
4442
4443static struct md_sysfs_entry md_min_sync =
4444__ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
4445
c6207277 4446static ssize_t
fd01b88c 4447max_sync_show(struct mddev *mddev, char *page)
c6207277
N		 4448{
4449 if (mddev->resync_max == MaxSector)
4450 return sprintf(page, "max\n");
4451 else
4452 return sprintf(page, "%llu\n",
4453 (unsigned long long)mddev->resync_max);
4454}
4455static ssize_t
fd01b88c 4456max_sync_store(struct mddev *mddev, const char *buf, size_t len)
c6207277
N		 4457{
4458 if (strncmp(buf, "max", 3) == 0)
4459 mddev->resync_max = MaxSector;
4460 else {
5e96ee65
NB		 4461 unsigned long long max;
4462 if (strict_strtoull(buf, 10, &max))
4463 return -EINVAL;
4464 if (max < mddev->resync_min)
c6207277
N		 4465 return -EINVAL;
4466 if (max < mddev->resync_max &&
4d484a4a 4467 mddev->ro == 0 &&
c6207277
N		 4468 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4469 return -EBUSY;
4470
4471 /* Must be a multiple of chunk_size */
9d8f0363 4472 if (mddev->chunk_sectors) {
2ac06c33 4473 sector_t temp = max;
9d8f0363 4474 if (sector_div(temp, mddev->chunk_sectors))
c6207277
N		 4475 return -EINVAL;
4476 }
4477 mddev->resync_max = max;
4478 }
4479 wake_up(&mddev->recovery_wait);
4480 return len;
4481}
4482
4483static struct md_sysfs_entry md_max_sync =
4484__ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
4485
e464eafd 4486static ssize_t
fd01b88c 4487suspend_lo_show(struct mddev *mddev, char *page)
e464eafd
N		 4488{
4489 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
4490}
4491
4492static ssize_t
fd01b88c 4493suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
e464eafd
N		 4494{
4495 char *e;
4496 unsigned long long new = simple_strtoull(buf, &e, 10);
23ddff37 4497 unsigned long long old = mddev->suspend_lo;
e464eafd 4498
b8d966ef
N		 4499 if (mddev->pers == NULL ||
4500 mddev->pers->quiesce == NULL)
e464eafd
N		 4501 return -EINVAL;
4502 if (buf == e || (*e && *e != '\n'))
4503 return -EINVAL;
23ddff37
N		 4504
4505 mddev->suspend_lo = new;
4506 if (new >= old)
4507 /* Shrinking suspended region */
e464eafd 4508 mddev->pers->quiesce(mddev, 2);
23ddff37
N		 4509 else {
4510 /* Expanding suspended region - need to wait */
4511 mddev->pers->quiesce(mddev, 1);
4512 mddev->pers->quiesce(mddev, 0);
4513 }
4514 return len;
e464eafd
N		 4515}
4516static struct md_sysfs_entry md_suspend_lo =
4517__ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
4518
4519
4520static ssize_t
fd01b88c 4521suspend_hi_show(struct mddev *mddev, char *page)
e464eafd
N		 4522{
4523 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
4524}
4525
4526static ssize_t
fd01b88c 4527suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
e464eafd
N		 4528{
4529 char *e;
4530 unsigned long long new = simple_strtoull(buf, &e, 10);
23ddff37 4531 unsigned long long old = mddev->suspend_hi;
e464eafd 4532
b8d966ef
N		 4533 if (mddev->pers == NULL ||
4534 mddev->pers->quiesce == NULL)
e464eafd
N		 4535 return -EINVAL;
4536 if (buf == e || (*e && *e != '\n'))
4537 return -EINVAL;
23ddff37
N		 4538
4539 mddev->suspend_hi = new;
4540 if (new <= old)
4541 /* Shrinking suspended region */
4542 mddev->pers->quiesce(mddev, 2);
4543 else {
4544 /* Expanding suspended region - need to wait */
e464eafd
N		 4545 mddev->pers->quiesce(mddev, 1);
4546 mddev->pers->quiesce(mddev, 0);
23ddff37
N		 4547 }
4548 return len;
e464eafd
N		 4549}
4550static struct md_sysfs_entry md_suspend_hi =
4551__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
4552
08a02ecd 4553static ssize_t
fd01b88c 4554reshape_position_show(struct mddev *mddev, char *page)
08a02ecd
N		 4555{
4556 if (mddev->reshape_position != MaxSector)
4557 return sprintf(page, "%llu\n",
4558 (unsigned long long)mddev->reshape_position);
4559 strcpy(page, "none\n");
4560 return 5;
4561}
4562
4563static ssize_t
fd01b88c 4564reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
08a02ecd 4565{
c6563a8c 4566 struct md_rdev *rdev;
08a02ecd
N		 4567 char *e;
4568 unsigned long long new = simple_strtoull(buf, &e, 10);
4569 if (mddev->pers)
4570 return -EBUSY;
4571 if (buf == e || (*e && *e != '\n'))
4572 return -EINVAL;
4573 mddev->reshape_position = new;
4574 mddev->delta_disks = 0;
2c810cdd 4575 mddev->reshape_backwards = 0;
08a02ecd
N		 4576 mddev->new_level = mddev->level;
4577 mddev->new_layout = mddev->layout;
664e7c41 4578 mddev->new_chunk_sectors = mddev->chunk_sectors;
c6563a8c
N		 4579 rdev_for_each(rdev, mddev)
4580 rdev->new_data_offset = rdev->data_offset;
08a02ecd
N		 4581 return len;
4582}
4583
4584static struct md_sysfs_entry md_reshape_position =
4585__ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
4586 reshape_position_store);
4587
2c810cdd
N		 4588static ssize_t
4589reshape_direction_show(struct mddev *mddev, char *page)
4590{
4591 return sprintf(page, "%s\n",
4592 mddev->reshape_backwards ? "backwards" : "forwards");
4593}
4594
4595static ssize_t
4596reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
4597{
4598 int backwards = 0;
4599 if (cmd_match(buf, "forwards"))
4600 backwards = 0;
4601 else if (cmd_match(buf, "backwards"))
4602 backwards = 1;
4603 else
4604 return -EINVAL;
4605 if (mddev->reshape_backwards == backwards)
4606 return len;
4607
4608 /* check if we are allowed to change */
4609 if (mddev->delta_disks)
4610 return -EBUSY;
4611
4612 if (mddev->persistent &&
4613 mddev->major_version == 0)
4614 return -EINVAL;
4615
4616 mddev->reshape_backwards = backwards;
4617 return len;
4618}
4619
4620static struct md_sysfs_entry md_reshape_direction =
4621__ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
4622 reshape_direction_store);
4623
b522adcd 4624static ssize_t
fd01b88c 4625array_size_show(struct mddev *mddev, char *page)
b522adcd
DW		 4626{
4627 if (mddev->external_size)
4628 return sprintf(page, "%llu\n",
4629 (unsigned long long)mddev->array_sectors/2);
4630 else
4631 return sprintf(page, "default\n");
4632}
4633
4634static ssize_t
fd01b88c 4635array_size_store(struct mddev *mddev, const char *buf, size_t len)
b522adcd
DW		 4636{
4637 sector_t sectors;
4638
4639 if (strncmp(buf, "default", 7) == 0) {
4640 if (mddev->pers)
4641 sectors = mddev->pers->size(mddev, 0, 0);
4642 else
4643 sectors = mddev->array_sectors;
4644
4645 mddev->external_size = 0;
4646 } else {
4647 if (strict_blocks_to_sectors(buf, &sectors) < 0)
4648 return -EINVAL;
4649 if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
2b69c839 4650 return -E2BIG;
b522adcd
DW		 4651
4652 mddev->external_size = 1;
4653 }
4654
4655 mddev->array_sectors = sectors;
cbe6ef1d
N		 4656 if (mddev->pers) {
4657 set_capacity(mddev->gendisk, mddev->array_sectors);
449aad3e 4658 revalidate_disk(mddev->gendisk);
cbe6ef1d 4659 }
b522adcd
DW		 4660 return len;
4661}
4662
4663static struct md_sysfs_entry md_array_size =
4664__ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
4665 array_size_store);
e464eafd 4666
eae1701f
N		 4667static struct attribute *md_default_attrs[] = {
4668 &md_level.attr,
d4dbd025 4669 &md_layout.attr,
eae1701f 4670 &md_raid_disks.attr,
3b34380a 4671 &md_chunk_size.attr,
a35b0d69 4672 &md_size.attr,
a94213b1 4673 &md_resync_start.attr,
8bb93aac 4674 &md_metadata.attr,
6d7ff738 4675 &md_new_device.attr,
16f17b39 4676 &md_safe_delay.attr,
9e653b63 4677 &md_array_state.attr,
08a02ecd 4678 &md_reshape_position.attr,
2c810cdd 4679 &md_reshape_direction.attr,
b522adcd 4680 &md_array_size.attr,
1e50915f 4681 &max_corr_read_errors.attr,
411036fa
N		 4682 NULL,
4683};
4684
4685static struct attribute *md_redundancy_attrs[] = {
24dd469d 4686 &md_scan_mode.attr,
9d88883e 4687 &md_mismatches.attr,
88202a0c
N		 4688 &md_sync_min.attr,
4689 &md_sync_max.attr,
4690 &md_sync_speed.attr,
90b08710 4691 &md_sync_force_parallel.attr,
88202a0c 4692 &md_sync_completed.attr,
5e96ee65 4693 &md_min_sync.attr,
c6207277 4694 &md_max_sync.attr,
e464eafd
N		 4695 &md_suspend_lo.attr,
4696 &md_suspend_hi.attr,
9b1d1dac 4697 &md_bitmap.attr,
d7f3d291 4698 &md_degraded.attr,
eae1701f
N		 4699 NULL,
4700};
411036fa
N		 4701static struct attribute_group md_redundancy_group = {
4702 .name = NULL,
4703 .attrs = md_redundancy_attrs,
4704};
4705
eae1701f
N		 4706
4707static ssize_t
4708md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
4709{
4710 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
fd01b88c 4711 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
96de1e66 4712 ssize_t rv;
eae1701f
N		 4713
4714 if (!entry->show)
4715 return -EIO;
af8a2434
N		 4716 spin_lock(&all_mddevs_lock);
4717 if (list_empty(&mddev->all_mddevs)) {
4718 spin_unlock(&all_mddevs_lock);
4719 return -EBUSY;
4720 }
4721 mddev_get(mddev);
4722 spin_unlock(&all_mddevs_lock);
4723
5dc5cf7d
IM		 4724 rv = mddev_lock(mddev);
4725 if (!rv) {
4726 rv = entry->show(mddev, page);
4727 mddev_unlock(mddev);
4728 }
af8a2434 4729 mddev_put(mddev);
96de1e66 4730 return rv;
eae1701f
N		 4731}
4732
4733static ssize_t
4734md_attr_store(struct kobject *kobj, struct attribute *attr,
4735 const char *page, size_t length)
4736{
4737 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
fd01b88c 4738 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
96de1e66 4739 ssize_t rv;
eae1701f
N		 4740
4741 if (!entry->store)
4742 return -EIO;
67463acb
N		 4743 if (!capable(CAP_SYS_ADMIN))
4744 return -EACCES;
af8a2434
N		 4745 spin_lock(&all_mddevs_lock);
4746 if (list_empty(&mddev->all_mddevs)) {
4747 spin_unlock(&all_mddevs_lock);
4748 return -EBUSY;
4749 }
4750 mddev_get(mddev);
4751 spin_unlock(&all_mddevs_lock);
5dc5cf7d
IM		 4752 rv = mddev_lock(mddev);
4753 if (!rv) {
4754 rv = entry->store(mddev, page, length);
4755 mddev_unlock(mddev);
4756 }
af8a2434 4757 mddev_put(mddev);
96de1e66 4758 return rv;
eae1701f
N		 4759}
4760
4761static void md_free(struct kobject *ko)
4762{
fd01b88c 4763 struct mddev *mddev = container_of(ko, struct mddev, kobj);
a21d1504
N		 4764
4765 if (mddev->sysfs_state)
4766 sysfs_put(mddev->sysfs_state);
4767
4768 if (mddev->gendisk) {
4769 del_gendisk(mddev->gendisk);
4770 put_disk(mddev->gendisk);
4771 }
4772 if (mddev->queue)
4773 blk_cleanup_queue(mddev->queue);
4774
eae1701f
N		 4775 kfree(mddev);
4776}
4777
52cf25d0 4778static const struct sysfs_ops md_sysfs_ops = {
eae1701f
N		 4779 .show = md_attr_show,
4780 .store = md_attr_store,
4781};
4782static struct kobj_type md_ktype = {
4783 .release = md_free,
4784 .sysfs_ops = &md_sysfs_ops,
4785 .default_attrs = md_default_attrs,
4786};
4787
1da177e4
LT		 4788int mdp_major = 0;
4789
5fd3a17e
DW		 4790static void mddev_delayed_delete(struct work_struct *ws)
4791{
fd01b88c 4792 struct mddev *mddev = container_of(ws, struct mddev, del_work);
5fd3a17e 4793
43a70507 4794 sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
5fd3a17e
DW		 4795 kobject_del(&mddev->kobj);
4796 kobject_put(&mddev->kobj);
4797}
4798
efeb53c0 4799static int md_alloc(dev_t dev, char *name)
1da177e4 4800{
48c9c27b 4801 static DEFINE_MUTEX(disks_mutex);
fd01b88c 4802 struct mddev *mddev = mddev_find(dev);
1da177e4 4803 struct gendisk *disk;
efeb53c0
N		 4804 int partitioned;
4805 int shift;
4806 int unit;
3830c62f 4807 int error;
1da177e4
LT		 4808
4809 if (!mddev)
efeb53c0
N		 4810 return -ENODEV;
4811
4812 partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
4813 shift = partitioned ? MdpMinorShift : 0;
4814 unit = MINOR(mddev->unit) >> shift;
1da177e4 4815
e804ac78
TH		 4816 /* wait for any previous instance of this device to be
4817 * completely removed (mddev_delayed_delete).
d3374825 4818 */
e804ac78 4819 flush_workqueue(md_misc_wq);
d3374825 4820
48c9c27b 4821 mutex_lock(&disks_mutex);
0909dc44
N		 4822 error = -EEXIST;
4823 if (mddev->gendisk)
4824 goto abort;
efeb53c0
N		 4825
4826 if (name) {
4827 /* Need to ensure that 'name' is not a duplicate.
4828 */
fd01b88c 4829 struct mddev *mddev2;
efeb53c0
N		 4830 spin_lock(&all_mddevs_lock);
4831
4832 list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
4833 if (mddev2->gendisk &&
4834 strcmp(mddev2->gendisk->disk_name, name) == 0) {
4835 spin_unlock(&all_mddevs_lock);
0909dc44 4836 goto abort;
efeb53c0
N		 4837 }
4838 spin_unlock(&all_mddevs_lock);
1da177e4 4839 }
8b765398 4840
0909dc44 4841 error = -ENOMEM;
8b765398 4842 mddev->queue = blk_alloc_queue(GFP_KERNEL);
0909dc44
N		 4843 if (!mddev->queue)
4844 goto abort;
409c57f3
N		 4845 mddev->queue->queuedata = mddev;
4846
409c57f3 4847 blk_queue_make_request(mddev->queue, md_make_request);
b1bd055d 4848 blk_set_stacking_limits(&mddev->queue->limits);
8b765398 4849
1da177e4
LT		 4850 disk = alloc_disk(1 << shift);
4851 if (!disk) {
8b765398
N		 4852 blk_cleanup_queue(mddev->queue);
4853 mddev->queue = NULL;
0909dc44 4854 goto abort;
1da177e4 4855 }
efeb53c0 4856 disk->major = MAJOR(mddev->unit);
1da177e4 4857 disk->first_minor = unit << shift;
efeb53c0
N		 4858 if (name)
4859 strcpy(disk->disk_name, name);
4860 else if (partitioned)
1da177e4 4861 sprintf(disk->disk_name, "md_d%d", unit);
ce7b0f46 4862 else
1da177e4 4863 sprintf(disk->disk_name, "md%d", unit);
1da177e4
LT		 4864 disk->fops = &md_fops;
4865 disk->private_data = mddev;
4866 disk->queue = mddev->queue;
b0140891 4867 blk_queue_flush(mddev->queue, REQ_FLUSH | REQ_FUA);
92850bbd 4868 /* Allow extended partitions. This makes the
d3374825 4869 * 'mdp' device redundant, but we can't really
92850bbd
N		 4870 * remove it now.
4871 */
4872 disk->flags |= GENHD_FL_EXT_DEVT;
1da177e4 4873 mddev->gendisk = disk;
b0140891
N		 4874 /* As soon as we call add_disk(), another thread could get
4875 * through to md_open, so make sure it doesn't get too far
4876 */
4877 mutex_lock(&mddev->open_mutex);
4878 add_disk(disk);
4879
ed9e1982
TH		 4880 error = kobject_init_and_add(&mddev->kobj, &md_ktype,
4881 &disk_to_dev(disk)->kobj, "%s", "md");
0909dc44
N		 4882 if (error) {
4883 /* This isn't possible, but as kobject_init_and_add is marked
4884 * __must_check, we must do something with the result
4885 */
5e55e2f5
N		 4886 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
4887 disk->disk_name);
0909dc44
N		 4888 error = 0;
4889 }
00bcb4ac
N		 4890 if (mddev->kobj.sd &&
4891 sysfs_create_group(&mddev->kobj, &md_bitmap_group))
43a70507 4892 printk(KERN_DEBUG "pointless warning\n");
b0140891 4893 mutex_unlock(&mddev->open_mutex);
0909dc44
N		 4894 abort:
4895 mutex_unlock(&disks_mutex);
00bcb4ac 4896 if (!error && mddev->kobj.sd) {
3830c62f 4897 kobject_uevent(&mddev->kobj, KOBJ_ADD);
00bcb4ac 4898 mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
b62b7590 4899 }
d3374825 4900 mddev_put(mddev);
0909dc44 4901 return error;
efeb53c0
N		 4902}
4903
4904static struct kobject *md_probe(dev_t dev, int *part, void *data)
4905{
4906 md_alloc(dev, NULL);
1da177e4
LT		 4907 return NULL;
4908}
4909
efeb53c0
N		 4910static int add_named_array(const char *val, struct kernel_param *kp)
4911{
4912 /* val must be "md_*" where * is not all digits.
4913 * We allocate an array with a large free minor number, and
4914 * set the name to val. val must not already be an active name.
4915 */
4916 int len = strlen(val);
4917 char buf[DISK_NAME_LEN];
4918
4919 while (len && val[len-1] == '\n')
4920 len--;
4921 if (len >= DISK_NAME_LEN)
4922 return -E2BIG;
4923 strlcpy(buf, val, len+1);
4924 if (strncmp(buf, "md_", 3) != 0)
4925 return -EINVAL;
4926 return md_alloc(0, buf);
4927}
4928
1da177e4
LT		 4929static void md_safemode_timeout(unsigned long data)
4930{
fd01b88c 4931 struct mddev *mddev = (struct mddev *) data;
1da177e4 4932
0fd62b86
NB		 4933 if (!atomic_read(&mddev->writes_pending)) {
4934 mddev->safemode = 1;
4935 if (mddev->external)
00bcb4ac 4936 sysfs_notify_dirent_safe(mddev->sysfs_state);
0fd62b86 4937 }
1da177e4
LT		 4938 md_wakeup_thread(mddev->thread);
4939}
4940
6ff8d8ec 4941static int start_dirty_degraded;
1da177e4 4942
fd01b88c 4943int md_run(struct mddev *mddev)
1da177e4 4944{
2604b703 4945 int err;
3cb03002 4946 struct md_rdev *rdev;
84fc4b56 4947 struct md_personality *pers;
1da177e4 4948
a757e64c
N		 4949 if (list_empty(&mddev->disks))
4950 /* cannot run an array with no devices.. */
1da177e4 4951 return -EINVAL;
1da177e4
LT		 4952
4953 if (mddev->pers)
4954 return -EBUSY;
bb4f1e9d
N		 4955 /* Cannot run until previous stop completes properly */
4956 if (mddev->sysfs_active)
4957 return -EBUSY;
b6eb127d 4958
1da177e4
LT		 4959 /*
4960 * Analyze all RAID superblock(s)
4961 */
1ec4a939
N		 4962 if (!mddev->raid_disks) {
4963 if (!mddev->persistent)
4964 return -EINVAL;
a757e64c 4965 analyze_sbs(mddev);
1ec4a939 4966 }
1da177e4 4967
d9d166c2
N		 4968 if (mddev->level != LEVEL_NONE)
4969 request_module("md-level-%d", mddev->level);
4970 else if (mddev->clevel[0])
4971 request_module("md-%s", mddev->clevel);
1da177e4
LT		 4972
4973 /*
4974 * Drop all container device buffers, from now on
4975 * the only valid external interface is through the md
4976 * device.
1da177e4 4977 */
dafb20fa 4978 rdev_for_each(rdev, mddev) {
b2d444d7 4979 if (test_bit(Faulty, &rdev->flags))
1da177e4
LT		 4980 continue;
4981 sync_blockdev(rdev->bdev);
f98393a6 4982 invalidate_bdev(rdev->bdev);
f0d76d70
N		 4983
4984 /* perform some consistency tests on the device.
4985 * We don't want the data to overlap the metadata,
58c0fed4 4986 * Internal Bitmap issues have been handled elsewhere.
f0d76d70 4987 */
a6ff7e08
JB		 4988 if (rdev->meta_bdev) {
4989 /* Nothing to check */;
4990 } else if (rdev->data_offset < rdev->sb_start) {
58c0fed4
AN		 4991 if (mddev->dev_sectors &&
4992 rdev->data_offset + mddev->dev_sectors
0f420358 4993 > rdev->sb_start) {
f0d76d70
N		 4994 printk("md: %s: data overlaps metadata\n",
4995 mdname(mddev));
4996 return -EINVAL;
4997 }
4998 } else {
0f420358 4999 if (rdev->sb_start + rdev->sb_size/512
f0d76d70
N		 5000 > rdev->data_offset) {
5001 printk("md: %s: metadata overlaps data\n",
5002 mdname(mddev));
5003 return -EINVAL;
5004 }
5005 }
00bcb4ac 5006 sysfs_notify_dirent_safe(rdev->sysfs_state);
1da177e4
LT		 5007 }
5008
a167f663 5009 if (mddev->bio_set == NULL)
395c72a7 5010 mddev->bio_set = bioset_create(BIO_POOL_SIZE, 0);
a167f663 5011
1da177e4 5012 spin_lock(&pers_lock);
d9d166c2 5013 pers = find_pers(mddev->level, mddev->clevel);
2604b703 5014 if (!pers || !try_module_get(pers->owner)) {
1da177e4 5015 spin_unlock(&pers_lock);
d9d166c2
N		 5016 if (mddev->level != LEVEL_NONE)
5017 printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
5018 mddev->level);
5019 else
5020 printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
5021 mddev->clevel);
1da177e4
LT		 5022 return -EINVAL;
5023 }
2604b703 5024 mddev->pers = pers;
1da177e4 5025 spin_unlock(&pers_lock);
34817e8c
N		 5026 if (mddev->level != pers->level) {
5027 mddev->level = pers->level;
5028 mddev->new_level = pers->level;
5029 }
d9d166c2 5030 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
1da177e4 5031
f6705578 5032 if (mddev->reshape_position != MaxSector &&
63c70c4f 5033 pers->start_reshape == NULL) {
f6705578
N		 5034 /* This personality cannot handle reshaping... */
5035 mddev->pers = NULL;
5036 module_put(pers->owner);
5037 return -EINVAL;
5038 }
5039
7dd5e7c3
N		 5040 if (pers->sync_request) {
5041 /* Warn if this is a potentially silly
5042 * configuration.
5043 */
5044 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
3cb03002 5045 struct md_rdev *rdev2;
7dd5e7c3 5046 int warned = 0;
159ec1fc 5047
dafb20fa
N		 5048 rdev_for_each(rdev, mddev)
5049 rdev_for_each(rdev2, mddev) {
7dd5e7c3
N		 5050 if (rdev < rdev2 &&
5051 rdev->bdev->bd_contains ==
5052 rdev2->bdev->bd_contains) {
5053 printk(KERN_WARNING
5054 "%s: WARNING: %s appears to be"
5055 " on the same physical disk as"
5056 " %s.\n",
5057 mdname(mddev),
5058 bdevname(rdev->bdev,b),
5059 bdevname(rdev2->bdev,b2));
5060 warned = 1;
5061 }
5062 }
159ec1fc 5063
7dd5e7c3
N		 5064 if (warned)
5065 printk(KERN_WARNING
5066 "True protection against single-disk"
5067 " failure might be compromised.\n");
5068 }
5069
657390d2 5070 mddev->recovery = 0;
58c0fed4
AN		 5071 /* may be over-ridden by personality */
5072 mddev->resync_max_sectors = mddev->dev_sectors;
5073
6ff8d8ec 5074 mddev->ok_start_degraded = start_dirty_degraded;
1da177e4 5075
0f9552b5 5076 if (start_readonly && mddev->ro == 0)
f91de92e
N		 5077 mddev->ro = 2; /* read-only, but switch on first write */
5078
b15c2e57 5079 err = mddev->pers->run(mddev);
13e53df3
AN		 5080 if (err)
5081 printk(KERN_ERR "md: pers->run() failed ...\n");
b522adcd
DW		 5082 else if (mddev->pers->size(mddev, 0, 0) < mddev->array_sectors) {
5083 WARN_ONCE(!mddev->external_size, "%s: default size too small,"
5084 " but 'external_size' not in effect?\n", __func__);
5085 printk(KERN_ERR
5086 "md: invalid array_size %llu > default size %llu\n",
5087 (unsigned long long)mddev->array_sectors / 2,
5088 (unsigned long long)mddev->pers->size(mddev, 0, 0) / 2);
5089 err = -EINVAL;
5090 mddev->pers->stop(mddev);
5091 }
ef99bf48
N		 5092 if (err == 0 && mddev->pers->sync_request &&
5093 (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
b15c2e57
N		 5094 err = bitmap_create(mddev);
5095 if (err) {
5096 printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
5097 mdname(mddev), err);
5098 mddev->pers->stop(mddev);
5099 }
5100 }
1da177e4 5101 if (err) {
1da177e4
LT		 5102 module_put(mddev->pers->owner);
5103 mddev->pers = NULL;
32a7627c
N		 5104 bitmap_destroy(mddev);
5105 return err;
1da177e4 5106 }
5e55e2f5 5107 if (mddev->pers->sync_request) {
00bcb4ac
N		 5108 if (mddev->kobj.sd &&
5109 sysfs_create_group(&mddev->kobj, &md_redundancy_group))
5e55e2f5
N		 5110 printk(KERN_WARNING
5111 "md: cannot register extra attributes for %s\n",
5112 mdname(mddev));
00bcb4ac 5113 mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
5e55e2f5 5114 } else if (mddev->ro == 2) /* auto-readonly not meaningful */
fd9d49ca
N		 5115 mddev->ro = 0;
5116
1da177e4 5117 atomic_set(&mddev->writes_pending,0);
1e50915f
RB		 5118 atomic_set(&mddev->max_corr_read_errors,
5119 MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
1da177e4
LT		 5120 mddev->safemode = 0;
5121 mddev->safemode_timer.function = md_safemode_timeout;
5122 mddev->safemode_timer.data = (unsigned long) mddev;
16f17b39 5123 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
1da177e4 5124 mddev->in_sync = 1;
0ca69886
N		 5125 smp_wmb();
5126 mddev->ready = 1;
dafb20fa 5127 rdev_for_each(rdev, mddev)
36fad858
NK		 5128 if (rdev->raid_disk >= 0)
5129 if (sysfs_link_rdev(mddev, rdev))
00bcb4ac 5130 /* failure here is OK */;
1da177e4
LT		 5131
5132 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5133
850b2b42
N		 5134 if (mddev->flags)
5135 md_update_sb(mddev, 0);
1da177e4 5136
d7603b7e 5137 md_new_event(mddev);
00bcb4ac
N		 5138 sysfs_notify_dirent_safe(mddev->sysfs_state);
5139 sysfs_notify_dirent_safe(mddev->sysfs_action);
a99ac971 5140 sysfs_notify(&mddev->kobj, NULL, "degraded");
1da177e4
LT		 5141 return 0;
5142}
390ee602 5143EXPORT_SYMBOL_GPL(md_run);
1da177e4 5144
fd01b88c 5145static int do_md_run(struct mddev *mddev)
fe60b014
N		 5146{
5147 int err;
5148
5149 err = md_run(mddev);
5150 if (err)
5151 goto out;
69e51b44
N		 5152 err = bitmap_load(mddev);
5153 if (err) {
5154 bitmap_destroy(mddev);
5155 goto out;
5156 }
0fd018af
JB		 5157
5158 md_wakeup_thread(mddev->thread);
5159 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
5160
fe60b014
N		 5161 set_capacity(mddev->gendisk, mddev->array_sectors);
5162 revalidate_disk(mddev->gendisk);
f0b4f7e2 5163 mddev->changed = 1;
fe60b014
N		 5164 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
5165out:
5166 return err;
5167}
5168
fd01b88c 5169static int restart_array(struct mddev *mddev)
1da177e4
LT		 5170{
5171 struct gendisk *disk = mddev->gendisk;
1da177e4 5172
80fab1d7 5173 /* Complain if it has no devices */
1da177e4 5174 if (list_empty(&mddev->disks))
80fab1d7
AN		 5175 return -ENXIO;
5176 if (!mddev->pers)
5177 return -EINVAL;
5178 if (!mddev->ro)
5179 return -EBUSY;
5180 mddev->safemode = 0;
5181 mddev->ro = 0;
5182 set_disk_ro(disk, 0);
5183 printk(KERN_INFO "md: %s switched to read-write mode.\n",
5184 mdname(mddev));
5185 /* Kick recovery or resync if necessary */
5186 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5187 md_wakeup_thread(mddev->thread);
5188 md_wakeup_thread(mddev->sync_thread);
00bcb4ac 5189 sysfs_notify_dirent_safe(mddev->sysfs_state);
80fab1d7 5190 return 0;
1da177e4
LT		 5191}
5192
acc55e22
N		 5193/* similar to deny_write_access, but accounts for our holding a reference
5194 * to the file ourselves */
5195static int deny_bitmap_write_access(struct file * file)
5196{
5197 struct inode *inode = file->f_mapping->host;
5198
5199 spin_lock(&inode->i_lock);
5200 if (atomic_read(&inode->i_writecount) > 1) {
5201 spin_unlock(&inode->i_lock);
5202 return -ETXTBSY;
5203 }
5204 atomic_set(&inode->i_writecount, -1);
5205 spin_unlock(&inode->i_lock);
5206
5207 return 0;
5208}
5209
43a70507 5210void restore_bitmap_write_access(struct file *file)
acc55e22
N		 5211{
5212 struct inode *inode = file->f_mapping->host;
5213
5214 spin_lock(&inode->i_lock);
5215 atomic_set(&inode->i_writecount, 1);
5216 spin_unlock(&inode->i_lock);
5217}
5218
fd01b88c 5219static void md_clean(struct mddev *mddev)
6177b472
N		 5220{
5221 mddev->array_sectors = 0;
5222 mddev->external_size = 0;
5223 mddev->dev_sectors = 0;
5224 mddev->raid_disks = 0;
5225 mddev->recovery_cp = 0;
5226 mddev->resync_min = 0;
5227 mddev->resync_max = MaxSector;
5228 mddev->reshape_position = MaxSector;
5229 mddev->external = 0;
5230 mddev->persistent = 0;
5231 mddev->level = LEVEL_NONE;
5232 mddev->clevel[0] = 0;
5233 mddev->flags = 0;
5234 mddev->ro = 0;
5235 mddev->metadata_type[0] = 0;
5236 mddev->chunk_sectors = 0;
5237 mddev->ctime = mddev->utime = 0;
5238 mddev->layout = 0;
5239 mddev->max_disks = 0;
5240 mddev->events = 0;
a8707c08 5241 mddev->can_decrease_events = 0;
6177b472 5242 mddev->delta_disks = 0;
2c810cdd 5243 mddev->reshape_backwards = 0;
6177b472
N		 5244 mddev->new_level = LEVEL_NONE;
5245 mddev->new_layout = 0;
5246 mddev->new_chunk_sectors = 0;
5247 mddev->curr_resync = 0;
7f7583d4 5248 atomic64_set(&mddev->resync_mismatches, 0);
6177b472
N		 5249 mddev->suspend_lo = mddev->suspend_hi = 0;
5250 mddev->sync_speed_min = mddev->sync_speed_max = 0;
5251 mddev->recovery = 0;
5252 mddev->in_sync = 0;
f0b4f7e2 5253 mddev->changed = 0;
6177b472 5254 mddev->degraded = 0;
6177b472 5255 mddev->safemode = 0;
050b6615 5256 mddev->merge_check_needed = 0;
6177b472
N		 5257 mddev->bitmap_info.offset = 0;
5258 mddev->bitmap_info.default_offset = 0;
6409bb05 5259 mddev->bitmap_info.default_space = 0;
6177b472
N		 5260 mddev->bitmap_info.chunksize = 0;
5261 mddev->bitmap_info.daemon_sleep = 0;
5262 mddev->bitmap_info.max_write_behind = 0;
5263}
5264
fd01b88c 5265static void __md_stop_writes(struct mddev *mddev)
a047e125
N		 5266{
5267 if (mddev->sync_thread) {
5268 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5269 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7ebc0be7 5270 reap_sync_thread(mddev);
a047e125
N		 5271 }
5272
5273 del_timer_sync(&mddev->safemode_timer);
5274
5275 bitmap_flush(mddev);
5276 md_super_wait(mddev);
5277
5278 if (!mddev->in_sync || mddev->flags) {
5279 /* mark array as shutdown cleanly */
5280 mddev->in_sync = 1;
5281 md_update_sb(mddev, 1);
5282 }
5283}
defad61a 5284
fd01b88c 5285void md_stop_writes(struct mddev *mddev)
defad61a
N		 5286{
5287 mddev_lock(mddev);
5288 __md_stop_writes(mddev);
5289 mddev_unlock(mddev);
5290}
390ee602 5291EXPORT_SYMBOL_GPL(md_stop_writes);
a047e125 5292
fd01b88c 5293void md_stop(struct mddev *mddev)
6177b472 5294{
0ca69886 5295 mddev->ready = 0;
6177b472
N		 5296 mddev->pers->stop(mddev);
5297 if (mddev->pers->sync_request && mddev->to_remove == NULL)
5298 mddev->to_remove = &md_redundancy_group;
5299 module_put(mddev->pers->owner);
5300 mddev->pers = NULL;
cca9cf90 5301 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
6177b472 5302}
390ee602 5303EXPORT_SYMBOL_GPL(md_stop);
6177b472 5304
a05b7ea0 5305static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
a4bd82d0
N		 5306{
5307 int err = 0;
5308 mutex_lock(&mddev->open_mutex);
a05b7ea0 5309 if (atomic_read(&mddev->openers) > !!bdev) {
a4bd82d0
N		 5310 printk("md: %s still in use.\n",mdname(mddev));
5311 err = -EBUSY;
5312 goto out;
5313 }
a05b7ea0
N		 5314 if (bdev)
5315 sync_blockdev(bdev);
a4bd82d0 5316 if (mddev->pers) {
defad61a 5317 __md_stop_writes(mddev);
a4bd82d0
N		 5318
5319 err = -ENXIO;
5320 if (mddev->ro==1)
5321 goto out;
5322 mddev->ro = 1;
5323 set_disk_ro(mddev->gendisk, 1);
5324 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
00bcb4ac 5325 sysfs_notify_dirent_safe(mddev->sysfs_state);
a4bd82d0
N		 5326 err = 0;
5327 }
5328out:
5329 mutex_unlock(&mddev->open_mutex);
5330 return err;
5331}
5332
9e653b63
N		 5333/* mode:
5334 * 0 - completely stop and dis-assemble array
9e653b63
N		 5335 * 2 - stop but do not disassemble array
5336 */
a05b7ea0
N		 5337static int do_md_stop(struct mddev * mddev, int mode,
5338 struct block_device *bdev)
1da177e4 5339{
1da177e4 5340 struct gendisk *disk = mddev->gendisk;
3cb03002 5341 struct md_rdev *rdev;
1da177e4 5342
c8c00a69 5343 mutex_lock(&mddev->open_mutex);
a05b7ea0 5344 if (atomic_read(&mddev->openers) > !!bdev ||
bb4f1e9d 5345 mddev->sysfs_active) {
df5b20cf 5346 printk("md: %s still in use.\n",mdname(mddev));
6e17b027
N		 5347 mutex_unlock(&mddev->open_mutex);
5348 return -EBUSY;
5349 }
a05b7ea0
N		 5350 if (bdev)
5351 /* It is possible IO was issued on some other
5352 * open file which was closed before we took ->open_mutex.
5353 * As that was not the last close __blkdev_put will not
5354 * have called sync_blockdev, so we must.
5355 */
5356 sync_blockdev(bdev);
1da177e4 5357
6e17b027 5358 if (mddev->pers) {
a4bd82d0
N		 5359 if (mddev->ro)
5360 set_disk_ro(disk, 0);
409c57f3 5361
defad61a 5362 __md_stop_writes(mddev);
a4bd82d0
N		 5363 md_stop(mddev);
5364 mddev->queue->merge_bvec_fn = NULL;
a4bd82d0 5365 mddev->queue->backing_dev_info.congested_fn = NULL;
6177b472 5366
a4bd82d0 5367 /* tell userspace to handle 'inactive' */
00bcb4ac 5368 sysfs_notify_dirent_safe(mddev->sysfs_state);
0d4ca600 5369
dafb20fa 5370 rdev_for_each(rdev, mddev)
36fad858
NK		 5371 if (rdev->raid_disk >= 0)
5372 sysfs_unlink_rdev(mddev, rdev);
c4647292 5373
a4bd82d0 5374 set_capacity(disk, 0);
6e17b027 5375 mutex_unlock(&mddev->open_mutex);
f0b4f7e2 5376 mddev->changed = 1;
a4bd82d0 5377 revalidate_disk(disk);
0d4ca600 5378
a4bd82d0
N		 5379 if (mddev->ro)
5380 mddev->ro = 0;
6e17b027
N		 5381 } else
5382 mutex_unlock(&mddev->open_mutex);
1da177e4
LT		 5383 /*
5384 * Free resources if final stop
5385 */
9e653b63 5386 if (mode == 0) {
1da177e4
LT		 5387 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
5388
978f946b 5389 bitmap_destroy(mddev);
c3d9714e
N		 5390 if (mddev->bitmap_info.file) {
5391 restore_bitmap_write_access(mddev->bitmap_info.file);
5392 fput(mddev->bitmap_info.file);
5393 mddev->bitmap_info.file = NULL;
978f946b 5394 }
c3d9714e 5395 mddev->bitmap_info.offset = 0;
978f946b 5396
1da177e4
LT		 5397 export_array(mddev);
5398
6177b472 5399 md_clean(mddev);
934d9c23 5400 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
efeb53c0
N		 5401 if (mddev->hold_active == UNTIL_STOP)
5402 mddev->hold_active = 0;
a4bd82d0 5403 }
3f9d99c1 5404 blk_integrity_unregister(disk);
d7603b7e 5405 md_new_event(mddev);
00bcb4ac 5406 sysfs_notify_dirent_safe(mddev->sysfs_state);
6e17b027 5407 return 0;
1da177e4
LT		 5408}
5409
fdee8ae4 5410#ifndef MODULE
fd01b88c 5411static void autorun_array(struct mddev *mddev)
1da177e4 5412{
3cb03002 5413 struct md_rdev *rdev;
1da177e4
LT		 5414 int err;
5415
a757e64c 5416 if (list_empty(&mddev->disks))
1da177e4 5417 return;
1da177e4
LT		 5418
5419 printk(KERN_INFO "md: running: ");
5420
dafb20fa 5421 rdev_for_each(rdev, mddev) {
1da177e4
LT		 5422 char b[BDEVNAME_SIZE];
5423 printk("<%s>", bdevname(rdev->bdev,b));
5424 }
5425 printk("\n");
5426
d710e138 5427 err = do_md_run(mddev);
1da177e4
LT		 5428 if (err) {
5429 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
a05b7ea0 5430 do_md_stop(mddev, 0, NULL);
1da177e4
LT		 5431 }
5432}
5433
5434/*
5435 * lets try to run arrays based on all disks that have arrived
5436 * until now. (those are in pending_raid_disks)
5437 *
5438 * the method: pick the first pending disk, collect all disks with
5439 * the same UUID, remove all from the pending list and put them into
5440 * the 'same_array' list. Then order this list based on superblock
5441 * update time (freshest comes first), kick out 'old' disks and
5442 * compare superblocks. If everything's fine then run it.
5443 *
5444 * If "unit" is allocated, then bump its reference count
5445 */
5446static void autorun_devices(int part)
5447{
3cb03002 5448 struct md_rdev *rdev0, *rdev, *tmp;
fd01b88c 5449 struct mddev *mddev;
1da177e4
LT		 5450 char b[BDEVNAME_SIZE];
5451
5452 printk(KERN_INFO "md: autorun ...\n");
5453 while (!list_empty(&pending_raid_disks)) {
e8703fe1 5454 int unit;
1da177e4 5455 dev_t dev;
ad01c9e3 5456 LIST_HEAD(candidates);
1da177e4 5457 rdev0 = list_entry(pending_raid_disks.next,
3cb03002 5458 struct md_rdev, same_set);
1da177e4
LT		 5459
5460 printk(KERN_INFO "md: considering %s ...\n",
5461 bdevname(rdev0->bdev,b));
5462 INIT_LIST_HEAD(&candidates);
159ec1fc 5463 rdev_for_each_list(rdev, tmp, &pending_raid_disks)
1da177e4
LT		 5464 if (super_90_load(rdev, rdev0, 0) >= 0) {
5465 printk(KERN_INFO "md: adding %s ...\n",
5466 bdevname(rdev->bdev,b));
5467 list_move(&rdev->same_set, &candidates);
5468 }
5469 /*
5470 * now we have a set of devices, with all of them having
5471 * mostly sane superblocks. It's time to allocate the
5472 * mddev.
5473 */
e8703fe1
N		 5474 if (part) {
5475 dev = MKDEV(mdp_major,
5476 rdev0->preferred_minor << MdpMinorShift);
5477 unit = MINOR(dev) >> MdpMinorShift;
5478 } else {
5479 dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
5480 unit = MINOR(dev);
5481 }
5482 if (rdev0->preferred_minor != unit) {
1da177e4
LT		 5483 printk(KERN_INFO "md: unit number in %s is bad: %d\n",
5484 bdevname(rdev0->bdev, b), rdev0->preferred_minor);
5485 break;
5486 }
1da177e4
LT		 5487
5488 md_probe(dev, NULL, NULL);
5489 mddev = mddev_find(dev);
9bbbca3a
NB		 5490 if (!mddev || !mddev->gendisk) {
5491 if (mddev)
5492 mddev_put(mddev);
5493 printk(KERN_ERR
1da177e4
LT		 5494 "md: cannot allocate memory for md drive.\n");
5495 break;
5496 }
5497 if (mddev_lock(mddev))
5498 printk(KERN_WARNING "md: %s locked, cannot run\n",
5499 mdname(mddev));
5500 else if (mddev->raid_disks || mddev->major_version
5501 || !list_empty(&mddev->disks)) {
5502 printk(KERN_WARNING
5503 "md: %s already running, cannot run %s\n",
5504 mdname(mddev), bdevname(rdev0->bdev,b));
5505 mddev_unlock(mddev);
5506 } else {
5507 printk(KERN_INFO "md: created %s\n", mdname(mddev));
1ec4a939 5508 mddev->persistent = 1;
159ec1fc 5509 rdev_for_each_list(rdev, tmp, &candidates) {
1da177e4
LT		 5510 list_del_init(&rdev->same_set);
5511 if (bind_rdev_to_array(rdev, mddev))
5512 export_rdev(rdev);
5513 }
5514 autorun_array(mddev);
5515 mddev_unlock(mddev);
5516 }
5517 /* on success, candidates will be empty, on error
5518 * it won't...
5519 */
159ec1fc 5520 rdev_for_each_list(rdev, tmp, &candidates) {
4b80991c 5521 list_del_init(&rdev->same_set);
1da177e4 5522 export_rdev(rdev);
4b80991c 5523 }
1da177e4
LT		 5524 mddev_put(mddev);
5525 }
5526 printk(KERN_INFO "md: ... autorun DONE.\n");
5527}
fdee8ae4 5528#endif /* !MODULE */
1da177e4 5529
1da177e4
LT		 5530static int get_version(void __user * arg)
5531{
5532 mdu_version_t ver;
5533
5534 ver.major = MD_MAJOR_VERSION;
5535 ver.minor = MD_MINOR_VERSION;
5536 ver.patchlevel = MD_PATCHLEVEL_VERSION;
5537
5538 if (copy_to_user(arg, &ver, sizeof(ver)))
5539 return -EFAULT;
5540
5541 return 0;
5542}
5543
fd01b88c 5544static int get_array_info(struct mddev * mddev, void __user * arg)
1da177e4
LT		 5545{
5546 mdu_array_info_t info;
a9f326eb 5547 int nr,working,insync,failed,spare;
3cb03002 5548 struct md_rdev *rdev;
1da177e4 5549
1ca69c4b
N		 5550 nr = working = insync = failed = spare = 0;
5551 rcu_read_lock();
5552 rdev_for_each_rcu(rdev, mddev) {
1da177e4 5553 nr++;
b2d444d7 5554 if (test_bit(Faulty, &rdev->flags))
1da177e4
LT		 5555 failed++;
5556 else {
5557 working++;
b2d444d7 5558 if (test_bit(In_sync, &rdev->flags))
a9f326eb 5559 insync++;
1da177e4
LT		 5560 else
5561 spare++;
5562 }
5563 }
1ca69c4b 5564 rcu_read_unlock();
1da177e4
LT		 5565
5566 info.major_version = mddev->major_version;
5567 info.minor_version = mddev->minor_version;
5568 info.patch_version = MD_PATCHLEVEL_VERSION;
5569 info.ctime = mddev->ctime;
5570 info.level = mddev->level;
58c0fed4
AN		 5571 info.size = mddev->dev_sectors / 2;
5572 if (info.size != mddev->dev_sectors / 2) /* overflow */
284ae7ca 5573 info.size = -1;
1da177e4
LT		 5574 info.nr_disks = nr;
5575 info.raid_disks = mddev->raid_disks;
5576 info.md_minor = mddev->md_minor;
5577 info.not_persistent= !mddev->persistent;
5578
5579 info.utime = mddev->utime;
5580 info.state = 0;
5581 if (mddev->in_sync)
5582 info.state = (1<<MD_SB_CLEAN);
c3d9714e 5583 if (mddev->bitmap && mddev->bitmap_info.offset)
36fa3063 5584 info.state = (1<<MD_SB_BITMAP_PRESENT);
a9f326eb 5585 info.active_disks = insync;
1da177e4
LT		 5586 info.working_disks = working;
5587 info.failed_disks = failed;
5588 info.spare_disks = spare;
5589
5590 info.layout = mddev->layout;
9d8f0363 5591 info.chunk_size = mddev->chunk_sectors << 9;
1da177e4
LT		 5592
5593 if (copy_to_user(arg, &info, sizeof(info)))
5594 return -EFAULT;
5595
5596 return 0;
5597}
5598
fd01b88c 5599static int get_bitmap_file(struct mddev * mddev, void __user * arg)
32a7627c
N		 5600{
5601 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
5602 char *ptr, *buf = NULL;
5603 int err = -ENOMEM;
5604
b5470dc5
DW		 5605 if (md_allow_write(mddev))
5606 file = kmalloc(sizeof(*file), GFP_NOIO);
5607 else
5608 file = kmalloc(sizeof(*file), GFP_KERNEL);
2a2275d6 5609
32a7627c
N		 5610 if (!file)
5611 goto out;
5612
5613 /* bitmap disabled, zero the first byte and copy out */
1ec885cd 5614 if (!mddev->bitmap || !mddev->bitmap->storage.file) {
32a7627c
N		 5615 file->pathname[0] = '\0';
5616 goto copy_out;
5617 }
5618
5619 buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
5620 if (!buf)
5621 goto out;
5622
1ec885cd
N		 5623 ptr = d_path(&mddev->bitmap->storage.file->f_path,
5624 buf, sizeof(file->pathname));
6bcfd601 5625 if (IS_ERR(ptr))
32a7627c
N		 5626 goto out;
5627
5628 strcpy(file->pathname, ptr);
5629
5630copy_out:
5631 err = 0;
5632 if (copy_to_user(arg, file, sizeof(*file)))
5633 err = -EFAULT;
5634out:
5635 kfree(buf);
5636 kfree(file);
5637 return err;
5638}
5639
fd01b88c 5640static int get_disk_info(struct mddev * mddev, void __user * arg)
1da177e4
LT		 5641{
5642 mdu_disk_info_t info;
3cb03002 5643 struct md_rdev *rdev;
1da177e4
LT		 5644
5645 if (copy_from_user(&info, arg, sizeof(info)))
5646 return -EFAULT;
5647
1ca69c4b
N		 5648 rcu_read_lock();
5649 rdev = find_rdev_nr_rcu(mddev, info.number);
1da177e4
LT		 5650 if (rdev) {
5651 info.major = MAJOR(rdev->bdev->bd_dev);
5652 info.minor = MINOR(rdev->bdev->bd_dev);
5653 info.raid_disk = rdev->raid_disk;
5654 info.state = 0;
b2d444d7 5655 if (test_bit(Faulty, &rdev->flags))
1da177e4 5656 info.state |= (1<<MD_DISK_FAULTY);
b2d444d7 5657 else if (test_bit(In_sync, &rdev->flags)) {
1da177e4
LT		 5658 info.state |= (1<<MD_DISK_ACTIVE);
5659 info.state |= (1<<MD_DISK_SYNC);
5660 }
8ddf9efe
N		 5661 if (test_bit(WriteMostly, &rdev->flags))
5662 info.state |= (1<<MD_DISK_WRITEMOSTLY);
1da177e4
LT		 5663 } else {
5664 info.major = info.minor = 0;
5665 info.raid_disk = -1;
5666 info.state = (1<<MD_DISK_REMOVED);
5667 }
1ca69c4b 5668 rcu_read_unlock();
1da177e4
LT		 5669
5670 if (copy_to_user(arg, &info, sizeof(info)))
5671 return -EFAULT;
5672
5673 return 0;
5674}
5675
fd01b88c 5676static int add_new_disk(struct mddev * mddev, mdu_disk_info_t *info)
1da177e4
LT		 5677{
5678 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
3cb03002 5679 struct md_rdev *rdev;
1da177e4
LT		 5680 dev_t dev = MKDEV(info->major,info->minor);
5681
5682 if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
5683 return -EOVERFLOW;
5684
5685 if (!mddev->raid_disks) {
5686 int err;
5687 /* expecting a device which has a superblock */
5688 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
5689 if (IS_ERR(rdev)) {
5690 printk(KERN_WARNING
5691 "md: md_import_device returned %ld\n",
5692 PTR_ERR(rdev));
5693 return PTR_ERR(rdev);
5694 }
5695 if (!list_empty(&mddev->disks)) {
3cb03002
N		 5696 struct md_rdev *rdev0
5697 = list_entry(mddev->disks.next,
5698 struct md_rdev, same_set);
a9f326eb 5699 err = super_types[mddev->major_version]
1da177e4
LT		 5700 .load_super(rdev, rdev0, mddev->minor_version);
5701 if (err < 0) {
5702 printk(KERN_WARNING
5703 "md: %s has different UUID to %s\n",
5704 bdevname(rdev->bdev,b),
5705 bdevname(rdev0->bdev,b2));
5706 export_rdev(rdev);
5707 return -EINVAL;
5708 }
5709 }
5710 err = bind_rdev_to_array(rdev, mddev);
5711 if (err)
5712 export_rdev(rdev);
5713 return err;
5714 }
5715
5716 /*
5717 * add_new_disk can be used once the array is assembled
5718 * to add "hot spares". They must already have a superblock
5719 * written
5720 */
5721 if (mddev->pers) {
5722 int err;
5723 if (!mddev->pers->hot_add_disk) {
5724 printk(KERN_WARNING
5725 "%s: personality does not support diskops!\n",
5726 mdname(mddev));
5727 return -EINVAL;
5728 }
7b1e35f6
N		 5729 if (mddev->persistent)
5730 rdev = md_import_device(dev, mddev->major_version,
5731 mddev->minor_version);
5732 else
5733 rdev = md_import_device(dev, -1, -1);
1da177e4
LT		 5734 if (IS_ERR(rdev)) {
5735 printk(KERN_WARNING
5736 "md: md_import_device returned %ld\n",
5737 PTR_ERR(rdev));
5738 return PTR_ERR(rdev);
5739 }
1a855a06 5740 /* set saved_raid_disk if appropriate */
41158c7e
N		 5741 if (!mddev->persistent) {
5742 if (info->state & (1<<MD_DISK_SYNC) &&
bf572541 5743 info->raid_disk < mddev->raid_disks) {
41158c7e 5744 rdev->raid_disk = info->raid_disk;
bf572541
N		 5745 set_bit(In_sync, &rdev->flags);
5746 } else
41158c7e
N		 5747 rdev->raid_disk = -1;
5748 } else
5749 super_types[mddev->major_version].
5750 validate_super(mddev, rdev);
bedd86b7 5751 if ((info->state & (1<<MD_DISK_SYNC)) &&
f4563091 5752 rdev->raid_disk != info->raid_disk) {
bedd86b7
N		 5753 /* This was a hot-add request, but events doesn't
5754 * match, so reject it.
5755 */
5756 export_rdev(rdev);
5757 return -EINVAL;
5758 }
5759
1a855a06
N		 5760 if (test_bit(In_sync, &rdev->flags))
5761 rdev->saved_raid_disk = rdev->raid_disk;
5762 else
5763 rdev->saved_raid_disk = -1;
41158c7e 5764
b2d444d7 5765 clear_bit(In_sync, &rdev->flags); /* just to be sure */
8ddf9efe
N		 5766 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
5767 set_bit(WriteMostly, &rdev->flags);
575a80fa
N		 5768 else
5769 clear_bit(WriteMostly, &rdev->flags);
8ddf9efe 5770
1da177e4
LT		 5771 rdev->raid_disk = -1;
5772 err = bind_rdev_to_array(rdev, mddev);
7c7546cc
N		 5773 if (!err && !mddev->pers->hot_remove_disk) {
5774 /* If there is hot_add_disk but no hot_remove_disk
5775 * then added disks for geometry changes,
5776 * and should be added immediately.
5777 */
5778 super_types[mddev->major_version].
5779 validate_super(mddev, rdev);
5780 err = mddev->pers->hot_add_disk(mddev, rdev);
5781 if (err)
5782 unbind_rdev_from_array(rdev);
5783 }
1da177e4
LT		 5784 if (err)
5785 export_rdev(rdev);
52664732 5786 else
00bcb4ac 5787 sysfs_notify_dirent_safe(rdev->sysfs_state);
c361777f 5788
17571284 5789 md_update_sb(mddev, 1);
72a23c21
NB		 5790 if (mddev->degraded)
5791 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
c361777f 5792 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9864c005 5793 if (!err)
5794 md_new_event(mddev);
005eca5e 5795 md_wakeup_thread(mddev->thread);
1da177e4
LT		 5796 return err;
5797 }
5798
5799 /* otherwise, add_new_disk is only allowed
5800 * for major_version==0 superblocks
5801 */
5802 if (mddev->major_version != 0) {
5803 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
5804 mdname(mddev));
5805 return -EINVAL;
5806 }
5807
5808 if (!(info->state & (1<<MD_DISK_FAULTY))) {
5809 int err;
d710e138 5810 rdev = md_import_device(dev, -1, 0);
1da177e4
LT		 5811 if (IS_ERR(rdev)) {
5812 printk(KERN_WARNING
5813 "md: error, md_import_device() returned %ld\n",
5814 PTR_ERR(rdev));
5815 return PTR_ERR(rdev);
5816 }
5817 rdev->desc_nr = info->number;
5818 if (info->raid_disk < mddev->raid_disks)
5819 rdev->raid_disk = info->raid_disk;
5820 else
5821 rdev->raid_disk = -1;
5822
1da177e4 5823 if (rdev->raid_disk < mddev->raid_disks)
b2d444d7
N		 5824 if (info->state & (1<<MD_DISK_SYNC))
5825 set_bit(In_sync, &rdev->flags);
1da177e4 5826
8ddf9efe
N		 5827 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
5828 set_bit(WriteMostly, &rdev->flags);
5829
1da177e4
LT		 5830 if (!mddev->persistent) {
5831 printk(KERN_INFO "md: nonpersistent superblock ...\n");
77304d2a
MS		 5832 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
5833 } else
57b2caa3 5834 rdev->sb_start = calc_dev_sboffset(rdev);
8190e754 5835 rdev->sectors = rdev->sb_start;
1da177e4 5836
2bf071bf
N		 5837 err = bind_rdev_to_array(rdev, mddev);
5838 if (err) {
5839 export_rdev(rdev);
5840 return err;
5841 }
1da177e4
LT		 5842 }
5843
5844 return 0;
5845}
5846
fd01b88c 5847static int hot_remove_disk(struct mddev * mddev, dev_t dev)
1da177e4
LT		 5848{
5849 char b[BDEVNAME_SIZE];
3cb03002 5850 struct md_rdev *rdev;
1da177e4 5851
1da177e4
LT		 5852 rdev = find_rdev(mddev, dev);
5853 if (!rdev)
5854 return -ENXIO;
5855
5856 if (rdev->raid_disk >= 0)
5857 goto busy;
5858
5859 kick_rdev_from_array(rdev);
850b2b42 5860 md_update_sb(mddev, 1);
d7603b7e 5861 md_new_event(mddev);
1da177e4
LT		 5862
5863 return 0;
5864busy:
fdefa4d8 5865 printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
1da177e4
LT		 5866 bdevname(rdev->bdev,b), mdname(mddev));
5867 return -EBUSY;
5868}
5869
fd01b88c 5870static int hot_add_disk(struct mddev * mddev, dev_t dev)
1da177e4
LT		 5871{
5872 char b[BDEVNAME_SIZE];
5873 int err;
3cb03002 5874 struct md_rdev *rdev;
1da177e4
LT		 5875
5876 if (!mddev->pers)
5877 return -ENODEV;
5878
5879 if (mddev->major_version != 0) {
5880 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
5881 " version-0 superblocks.\n",
5882 mdname(mddev));
5883 return -EINVAL;
5884 }
5885 if (!mddev->pers->hot_add_disk) {
5886 printk(KERN_WARNING
5887 "%s: personality does not support diskops!\n",
5888 mdname(mddev));
5889 return -EINVAL;
5890 }
5891
d710e138 5892 rdev = md_import_device(dev, -1, 0);
1da177e4
LT		 5893 if (IS_ERR(rdev)) {
5894 printk(KERN_WARNING
5895 "md: error, md_import_device() returned %ld\n",
5896 PTR_ERR(rdev));
5897 return -EINVAL;
5898 }
5899
5900 if (mddev->persistent)
57b2caa3 5901 rdev->sb_start = calc_dev_sboffset(rdev);
1da177e4 5902 else
77304d2a 5903 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
1da177e4 5904
8190e754 5905 rdev->sectors = rdev->sb_start;
1da177e4 5906
b2d444d7 5907 if (test_bit(Faulty, &rdev->flags)) {
1da177e4
LT		 5908 printk(KERN_WARNING
5909 "md: can not hot-add faulty %s disk to %s!\n",
5910 bdevname(rdev->bdev,b), mdname(mddev));
5911 err = -EINVAL;
5912 goto abort_export;
5913 }
b2d444d7 5914 clear_bit(In_sync, &rdev->flags);
1da177e4 5915 rdev->desc_nr = -1;
5842730d 5916 rdev->saved_raid_disk = -1;
2bf071bf
N		 5917 err = bind_rdev_to_array(rdev, mddev);
5918 if (err)
5919 goto abort_export;
1da177e4
LT		 5920
5921 /*
5922 * The rest should better be atomic, we can have disk failures
5923 * noticed in interrupt contexts ...
5924 */
5925
1da177e4
LT		 5926 rdev->raid_disk = -1;
5927
850b2b42 5928 md_update_sb(mddev, 1);
1da177e4
LT		 5929
5930 /*
5931 * Kick recovery, maybe this spare has to be added to the
5932 * array immediately.
5933 */
5934 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5935 md_wakeup_thread(mddev->thread);
d7603b7e 5936 md_new_event(mddev);
1da177e4
LT		 5937 return 0;
5938
1da177e4
LT		 5939abort_export:
5940 export_rdev(rdev);
5941 return err;
5942}
5943
fd01b88c 5944static int set_bitmap_file(struct mddev *mddev, int fd)
32a7627c
N		 5945{
5946 int err;
5947
36fa3063
N		 5948 if (mddev->pers) {
5949 if (!mddev->pers->quiesce)
5950 return -EBUSY;
5951 if (mddev->recovery || mddev->sync_thread)
5952 return -EBUSY;
5953 /* we should be able to change the bitmap.. */
5954 }
32a7627c 5955
32a7627c 5956
36fa3063
N		 5957 if (fd >= 0) {
5958 if (mddev->bitmap)
5959 return -EEXIST; /* cannot add when bitmap is present */
c3d9714e 5960 mddev->bitmap_info.file = fget(fd);
32a7627c 5961
c3d9714e 5962 if (mddev->bitmap_info.file == NULL) {
36fa3063
N		 5963 printk(KERN_ERR "%s: error: failed to get bitmap file\n",
5964 mdname(mddev));
5965 return -EBADF;
5966 }
5967
c3d9714e 5968 err = deny_bitmap_write_access(mddev->bitmap_info.file);
36fa3063
N		 5969 if (err) {
5970 printk(KERN_ERR "%s: error: bitmap file is already in use\n",
5971 mdname(mddev));
c3d9714e
N		 5972 fput(mddev->bitmap_info.file);
5973 mddev->bitmap_info.file = NULL;
36fa3063
N		 5974 return err;
5975 }
c3d9714e 5976 mddev->bitmap_info.offset = 0; /* file overrides offset */
36fa3063
N		 5977 } else if (mddev->bitmap == NULL)
5978 return -ENOENT; /* cannot remove what isn't there */
5979 err = 0;
5980 if (mddev->pers) {
5981 mddev->pers->quiesce(mddev, 1);
69e51b44 5982 if (fd >= 0) {
36fa3063 5983 err = bitmap_create(mddev);
69e51b44
N		 5984 if (!err)
5985 err = bitmap_load(mddev);
5986 }
d7375ab3 5987 if (fd < 0 || err) {
36fa3063 5988 bitmap_destroy(mddev);
d7375ab3
N		 5989 fd = -1; /* make sure to put the file */
5990 }
36fa3063 5991 mddev->pers->quiesce(mddev, 0);
d7375ab3
N		 5992 }
5993 if (fd < 0) {
c3d9714e
N		 5994 if (mddev->bitmap_info.file) {
5995 restore_bitmap_write_access(mddev->bitmap_info.file);
5996 fput(mddev->bitmap_info.file);
acc55e22 5997 }
c3d9714e 5998 mddev->bitmap_info.file = NULL;
36fa3063
N		 5999 }
6000
32a7627c
N		 6001 return err;
6002}
6003
1da177e4
LT		 6004/*
6005 * set_array_info is used two different ways
6006 * The original usage is when creating a new array.
6007 * In this usage, raid_disks is > 0 and it together with
6008 * level, size, not_persistent,layout,chunksize determine the
6009 * shape of the array.
6010 * This will always create an array with a type-0.90.0 superblock.
6011 * The newer usage is when assembling an array.
6012 * In this case raid_disks will be 0, and the major_version field is
6013 * use to determine which style super-blocks are to be found on the devices.
6014 * The minor and patch _version numbers are also kept incase the
6015 * super_block handler wishes to interpret them.
6016 */
fd01b88c 6017static int set_array_info(struct mddev * mddev, mdu_array_info_t *info)
1da177e4
LT		 6018{
6019
6020 if (info->raid_disks == 0) {
6021 /* just setting version number for superblock loading */
6022 if (info->major_version < 0 ||
50511da3 6023 info->major_version >= ARRAY_SIZE(super_types) ||
1da177e4
LT		 6024 super_types[info->major_version].name == NULL) {
6025 /* maybe try to auto-load a module? */
6026 printk(KERN_INFO
6027 "md: superblock version %d not known\n",
6028 info->major_version);
6029 return -EINVAL;
6030 }
6031 mddev->major_version = info->major_version;
6032 mddev->minor_version = info->minor_version;
6033 mddev->patch_version = info->patch_version;
3f9d7b0d 6034 mddev->persistent = !info->not_persistent;
cbd19983
N		 6035 /* ensure mddev_put doesn't delete this now that there
6036 * is some minimal configuration.
6037 */
6038 mddev->ctime = get_seconds();
1da177e4
LT		 6039 return 0;
6040 }
6041 mddev->major_version = MD_MAJOR_VERSION;
6042 mddev->minor_version = MD_MINOR_VERSION;
6043 mddev->patch_version = MD_PATCHLEVEL_VERSION;
6044 mddev->ctime = get_seconds();
6045
6046 mddev->level = info->level;
17115e03 6047 mddev->clevel[0] = 0;
58c0fed4 6048 mddev->dev_sectors = 2 * (sector_t)info->size;
1da177e4
LT		 6049 mddev->raid_disks = info->raid_disks;
6050 /* don't set md_minor, it is determined by which /dev/md* was
6051 * openned
6052 */
6053 if (info->state & (1<<MD_SB_CLEAN))
6054 mddev->recovery_cp = MaxSector;
6055 else
6056 mddev->recovery_cp = 0;
6057 mddev->persistent = ! info->not_persistent;
e691063a 6058 mddev->external = 0;
1da177e4
LT		 6059
6060 mddev->layout = info->layout;
9d8f0363 6061 mddev->chunk_sectors = info->chunk_size >> 9;
1da177e4
LT		 6062
6063 mddev->max_disks = MD_SB_DISKS;
6064
e691063a
N		 6065 if (mddev->persistent)
6066 mddev->flags = 0;
850b2b42 6067 set_bit(MD_CHANGE_DEVS, &mddev->flags);
1da177e4 6068
c3d9714e 6069 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
6409bb05 6070 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
c3d9714e 6071 mddev->bitmap_info.offset = 0;
b2a2703c 6072
f6705578
N		 6073 mddev->reshape_position = MaxSector;
6074
1da177e4
LT		 6075 /*
6076 * Generate a 128 bit UUID
6077 */
6078 get_random_bytes(mddev->uuid, 16);
6079
f6705578 6080 mddev->new_level = mddev->level;
664e7c41 6081 mddev->new_chunk_sectors = mddev->chunk_sectors;
f6705578
N		 6082 mddev->new_layout = mddev->layout;
6083 mddev->delta_disks = 0;
2c810cdd 6084 mddev->reshape_backwards = 0;
f6705578 6085
1da177e4
LT		 6086 return 0;
6087}
6088
fd01b88c 6089void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
1f403624 6090{
b522adcd
DW		 6091 WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);
6092
6093 if (mddev->external_size)
6094 return;
6095
1f403624
DW		 6096 mddev->array_sectors = array_sectors;
6097}
6098EXPORT_SYMBOL(md_set_array_sectors);
6099
fd01b88c 6100static int update_size(struct mddev *mddev, sector_t num_sectors)
a35b0d69 6101{
3cb03002 6102 struct md_rdev *rdev;
a35b0d69 6103 int rv;
d71f9f88 6104 int fit = (num_sectors == 0);
a35b0d69
N		 6105
6106 if (mddev->pers->resize == NULL)
6107 return -EINVAL;
d71f9f88
AN		 6108 /* The "num_sectors" is the number of sectors of each device that
6109 * is used. This can only make sense for arrays with redundancy.
6110 * linear and raid0 always use whatever space is available. We can only
6111 * consider changing this number if no resync or reconstruction is
6112 * happening, and if the new size is acceptable. It must fit before the
0f420358 6113 * sb_start or, if that is <data_offset, it must fit before the size
d71f9f88
AN		 6114 * of each device. If num_sectors is zero, we find the largest size
6115 * that fits.
a35b0d69
N		 6116 */
6117 if (mddev->sync_thread)
6118 return -EBUSY;
a4a6125a 6119
dafb20fa 6120 rdev_for_each(rdev, mddev) {
dd8ac336 6121 sector_t avail = rdev->sectors;
01ab5662 6122
d71f9f88
AN		 6123 if (fit && (num_sectors == 0 || num_sectors > avail))
6124 num_sectors = avail;
6125 if (avail < num_sectors)
a35b0d69
N		 6126 return -ENOSPC;
6127 }
d71f9f88 6128 rv = mddev->pers->resize(mddev, num_sectors);
449aad3e
N		 6129 if (!rv)
6130 revalidate_disk(mddev->gendisk);
a35b0d69
N		 6131 return rv;
6132}
6133
fd01b88c 6134static int update_raid_disks(struct mddev *mddev, int raid_disks)
da943b99
N		 6135{
6136 int rv;
c6563a8c 6137 struct md_rdev *rdev;
da943b99 6138 /* change the number of raid disks */
63c70c4f 6139 if (mddev->pers->check_reshape == NULL)
da943b99
N		 6140 return -EINVAL;
6141 if (raid_disks <= 0 ||
233fca36 6142 (mddev->max_disks && raid_disks >= mddev->max_disks))
da943b99 6143 return -EINVAL;
63c70c4f 6144 if (mddev->sync_thread || mddev->reshape_position != MaxSector)
da943b99 6145 return -EBUSY;
c6563a8c
N		 6146
6147 rdev_for_each(rdev, mddev) {
6148 if (mddev->raid_disks < raid_disks &&
6149 rdev->data_offset < rdev->new_data_offset)
6150 return -EINVAL;
6151 if (mddev->raid_disks > raid_disks &&
6152 rdev->data_offset > rdev->new_data_offset)
6153 return -EINVAL;
6154 }
6155
63c70c4f 6156 mddev->delta_disks = raid_disks - mddev->raid_disks;
2c810cdd
N		 6157 if (mddev->delta_disks < 0)
6158 mddev->reshape_backwards = 1;
6159 else if (mddev->delta_disks > 0)
6160 mddev->reshape_backwards = 0;
63c70c4f
N		 6161
6162 rv = mddev->pers->check_reshape(mddev);
2c810cdd 6163 if (rv < 0) {
de171cb9 6164 mddev->delta_disks = 0;
2c810cdd
N		 6165 mddev->reshape_backwards = 0;
6166 }
da943b99
N		 6167 return rv;
6168}
6169
6170
1da177e4
LT		 6171/*
6172 * update_array_info is used to change the configuration of an
6173 * on-line array.
6174 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
6175 * fields in the info are checked against the array.
6176 * Any differences that cannot be handled will cause an error.
6177 * Normally, only one change can be managed at a time.
6178 */
fd01b88c 6179static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
1da177e4
LT		 6180{
6181 int rv = 0;
6182 int cnt = 0;
36fa3063
N		 6183 int state = 0;
6184
6185 /* calculate expected state,ignoring low bits */
c3d9714e 6186 if (mddev->bitmap && mddev->bitmap_info.offset)
36fa3063 6187 state |= (1 << MD_SB_BITMAP_PRESENT);
1da177e4
LT		 6188
6189 if (mddev->major_version != info->major_version ||
6190 mddev->minor_version != info->minor_version ||
6191/* mddev->patch_version != info->patch_version || */
6192 mddev->ctime != info->ctime ||
6193 mddev->level != info->level ||
6194/* mddev->layout != info->layout || */
6195 !mddev->persistent != info->not_persistent||
9d8f0363 6196 mddev->chunk_sectors != info->chunk_size >> 9 ||
36fa3063
N		 6197 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
6198 ((state^info->state) & 0xfffffe00)
6199 )
1da177e4
LT		 6200 return -EINVAL;
6201 /* Check there is only one change */
58c0fed4
AN		 6202 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
6203 cnt++;
6204 if (mddev->raid_disks != info->raid_disks)
6205 cnt++;
6206 if (mddev->layout != info->layout)
6207 cnt++;
6208 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
6209 cnt++;
6210 if (cnt == 0)
6211 return 0;
6212 if (cnt > 1)
6213 return -EINVAL;
1da177e4
LT		 6214
6215 if (mddev->layout != info->layout) {
6216 /* Change layout
6217 * we don't need to do anything at the md level, the
6218 * personality will take care of it all.
6219 */
50ac168a 6220 if (mddev->pers->check_reshape == NULL)
1da177e4 6221 return -EINVAL;
597a711b
N		 6222 else {
6223 mddev->new_layout = info->layout;
50ac168a 6224 rv = mddev->pers->check_reshape(mddev);
597a711b
N		 6225 if (rv)
6226 mddev->new_layout = mddev->layout;
6227 return rv;
6228 }
1da177e4 6229 }
58c0fed4 6230 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
d71f9f88 6231 rv = update_size(mddev, (sector_t)info->size * 2);
a35b0d69 6232
da943b99
N		 6233 if (mddev->raid_disks != info->raid_disks)
6234 rv = update_raid_disks(mddev, info->raid_disks);
6235
36fa3063
N		 6236 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
6237 if (mddev->pers->quiesce == NULL)
6238 return -EINVAL;
6239 if (mddev->recovery || mddev->sync_thread)
6240 return -EBUSY;
6241 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
6242 /* add the bitmap */
6243 if (mddev->bitmap)
6244 return -EEXIST;
c3d9714e 6245 if (mddev->bitmap_info.default_offset == 0)
36fa3063 6246 return -EINVAL;
c3d9714e
N		 6247 mddev->bitmap_info.offset =
6248 mddev->bitmap_info.default_offset;
6409bb05
N		 6249 mddev->bitmap_info.space =
6250 mddev->bitmap_info.default_space;
36fa3063
N		 6251 mddev->pers->quiesce(mddev, 1);
6252 rv = bitmap_create(mddev);
69e51b44
N		 6253 if (!rv)
6254 rv = bitmap_load(mddev);
36fa3063
N		 6255 if (rv)
6256 bitmap_destroy(mddev);
6257 mddev->pers->quiesce(mddev, 0);
6258 } else {
6259 /* remove the bitmap */
6260 if (!mddev->bitmap)
6261 return -ENOENT;
1ec885cd 6262 if (mddev->bitmap->storage.file)
36fa3063
N		 6263 return -EINVAL;
6264 mddev->pers->quiesce(mddev, 1);
6265 bitmap_destroy(mddev);
6266 mddev->pers->quiesce(mddev, 0);
c3d9714e 6267 mddev->bitmap_info.offset = 0;
36fa3063
N		 6268 }
6269 }
850b2b42 6270 md_update_sb(mddev, 1);
1da177e4
LT		 6271 return rv;
6272}
6273
fd01b88c 6274static int set_disk_faulty(struct mddev *mddev, dev_t dev)
1da177e4 6275{
3cb03002 6276 struct md_rdev *rdev;
1ca69c4b 6277 int err = 0;
1da177e4
LT		 6278
6279 if (mddev->pers == NULL)
6280 return -ENODEV;
6281
1ca69c4b
N		 6282 rcu_read_lock();
6283 rdev = find_rdev_rcu(mddev, dev);
1da177e4 6284 if (!rdev)
1ca69c4b
N		 6285 err = -ENODEV;
6286 else {
6287 md_error(mddev, rdev);
6288 if (!test_bit(Faulty, &rdev->flags))
6289 err = -EBUSY;
6290 }
6291 rcu_read_unlock();
6292 return err;
1da177e4
LT		 6293}
6294
2f9618ce
AN		 6295/*
6296 * We have a problem here : there is no easy way to give a CHS
6297 * virtual geometry. We currently pretend that we have a 2 heads
6298 * 4 sectors (with a BIG number of cylinders...). This drives
6299 * dosfs just mad... ;-)
6300 */
a885c8c4
CH		 6301static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
6302{
fd01b88c 6303 struct mddev *mddev = bdev->bd_disk->private_data;
a885c8c4
CH		 6304
6305 geo->heads = 2;
6306 geo->sectors = 4;
49ce6cea 6307 geo->cylinders = mddev->array_sectors / 8;
a885c8c4
CH		 6308 return 0;
6309}
6310
a39907fa 6311static int md_ioctl(struct block_device *bdev, fmode_t mode,
1da177e4
LT		 6312 unsigned int cmd, unsigned long arg)
6313{
6314 int err = 0;
6315 void __user *argp = (void __user *)arg;
fd01b88c 6316 struct mddev *mddev = NULL;
e2218350 6317 int ro;
1da177e4 6318
506c9e44
N		 6319 switch (cmd) {
6320 case RAID_VERSION:
6321 case GET_ARRAY_INFO:
6322 case GET_DISK_INFO:
6323 break;
6324 default:
6325 if (!capable(CAP_SYS_ADMIN))
6326 return -EACCES;
6327 }
1da177e4
LT		 6328
6329 /*
6330 * Commands dealing with the RAID driver but not any
6331 * particular array:
6332 */
6333 switch (cmd)
6334 {
6335 case RAID_VERSION:
6336 err = get_version(argp);
6337 goto done;
6338
6339 case PRINT_RAID_DEBUG:
6340 err = 0;
6341 md_print_devices();
6342 goto done;
6343
6344#ifndef MODULE
6345 case RAID_AUTORUN:
6346 err = 0;
6347 autostart_arrays(arg);
6348 goto done;
6349#endif
6350 default:;
6351 }
6352
6353 /*
6354 * Commands creating/starting a new array:
6355 */
6356
a39907fa 6357 mddev = bdev->bd_disk->private_data;
1da177e4
LT		 6358
6359 if (!mddev) {
6360 BUG();
6361 goto abort;
6362 }
6363
1ca69c4b
N		 6364 /* Some actions do not requires the mutex */
6365 switch (cmd) {
6366 case GET_ARRAY_INFO:
6367 if (!mddev->raid_disks && !mddev->external)
6368 err = -ENODEV;
6369 else
6370 err = get_array_info(mddev, argp);
6371 goto abort;
6372
6373 case GET_DISK_INFO:
6374 if (!mddev->raid_disks && !mddev->external)
6375 err = -ENODEV;
6376 else
6377 err = get_disk_info(mddev, argp);
6378 goto abort;
6379
6380 case SET_DISK_FAULTY:
6381 err = set_disk_faulty(mddev, new_decode_dev(arg));
6382 goto abort;
6383 }
6384
1da177e4
LT		 6385 err = mddev_lock(mddev);
6386 if (err) {
6387 printk(KERN_INFO
6388 "md: ioctl lock interrupted, reason %d, cmd %d\n",
6389 err, cmd);
6390 goto abort;
6391 }
6392
6393 switch (cmd)
6394 {
6395 case SET_ARRAY_INFO:
6396 {
6397 mdu_array_info_t info;
6398 if (!arg)
6399 memset(&info, 0, sizeof(info));
6400 else if (copy_from_user(&info, argp, sizeof(info))) {
6401 err = -EFAULT;
6402 goto abort_unlock;
6403 }
6404 if (mddev->pers) {
6405 err = update_array_info(mddev, &info);
6406 if (err) {
6407 printk(KERN_WARNING "md: couldn't update"
6408 " array info. %d\n", err);
6409 goto abort_unlock;
6410 }
6411 goto done_unlock;
6412 }
6413 if (!list_empty(&mddev->disks)) {
6414 printk(KERN_WARNING
6415 "md: array %s already has disks!\n",
6416 mdname(mddev));
6417 err = -EBUSY;
6418 goto abort_unlock;
6419 }
6420 if (mddev->raid_disks) {
6421 printk(KERN_WARNING
6422 "md: array %s already initialised!\n",
6423 mdname(mddev));
6424 err = -EBUSY;
6425 goto abort_unlock;
6426 }
6427 err = set_array_info(mddev, &info);
6428 if (err) {
6429 printk(KERN_WARNING "md: couldn't set"
6430 " array info. %d\n", err);
6431 goto abort_unlock;
6432 }
6433 }
6434 goto done_unlock;
6435
6436 default:;
6437 }
6438
6439 /*
6440 * Commands querying/configuring an existing array:
6441 */
32a7627c 6442 /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
3f9d7b0d 6443 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
a17184a9
N		 6444 if ((!mddev->raid_disks && !mddev->external)
6445 && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
6446 && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
6447 && cmd != GET_BITMAP_FILE) {
1da177e4
LT		 6448 err = -ENODEV;
6449 goto abort_unlock;
6450 }
6451
6452 /*
6453 * Commands even a read-only array can execute:
6454 */
6455 switch (cmd)
6456 {
32a7627c 6457 case GET_BITMAP_FILE:
87162a28 6458 err = get_bitmap_file(mddev, argp);
32a7627c
N		 6459 goto done_unlock;
6460
1da177e4
LT		 6461 case RESTART_ARRAY_RW:
6462 err = restart_array(mddev);
6463 goto done_unlock;
6464
6465 case STOP_ARRAY:
a05b7ea0 6466 err = do_md_stop(mddev, 0, bdev);
1da177e4
LT		 6467 goto done_unlock;
6468
6469 case STOP_ARRAY_RO:
a05b7ea0 6470 err = md_set_readonly(mddev, bdev);
1da177e4
LT		 6471 goto done_unlock;
6472
e2218350
DW		 6473 case BLKROSET:
6474 if (get_user(ro, (int __user *)(arg))) {
6475 err = -EFAULT;
6476 goto done_unlock;
6477 }
6478 err = -EINVAL;
6479
6480 /* if the bdev is going readonly the value of mddev->ro
6481 * does not matter, no writes are coming
6482 */
6483 if (ro)
6484 goto done_unlock;
6485
6486 /* are we are already prepared for writes? */
6487 if (mddev->ro != 1)
6488 goto done_unlock;
6489
6490 /* transitioning to readauto need only happen for
6491 * arrays that call md_write_start
6492 */
6493 if (mddev->pers) {
6494 err = restart_array(mddev);
6495 if (err == 0) {
6496 mddev->ro = 2;
6497 set_disk_ro(mddev->gendisk, 0);
6498 }
6499 }
6500 goto done_unlock;
1da177e4
LT		 6501 }
6502
6503 /*
6504 * The remaining ioctls are changing the state of the
f91de92e
N		 6505 * superblock, so we do not allow them on read-only arrays.
6506 * However non-MD ioctls (e.g. get-size) will still come through
6507 * here and hit the 'default' below, so only disallow
6508 * 'md' ioctls, and switch to rw mode if started auto-readonly.
1da177e4 6509 */
bb57fc64 6510 if (_IOC_TYPE(cmd) == MD_MAJOR && mddev->ro && mddev->pers) {
f91de92e
N		 6511 if (mddev->ro == 2) {
6512 mddev->ro = 0;
00bcb4ac 6513 sysfs_notify_dirent_safe(mddev->sysfs_state);
0fd62b86
NB		 6514 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6515 md_wakeup_thread(mddev->thread);
f91de92e
N		 6516 } else {
6517 err = -EROFS;
6518 goto abort_unlock;
6519 }
1da177e4
LT		 6520 }
6521
6522 switch (cmd)
6523 {
6524 case ADD_NEW_DISK:
6525 {
6526 mdu_disk_info_t info;
6527 if (copy_from_user(&info, argp, sizeof(info)))
6528 err = -EFAULT;
6529 else
6530 err = add_new_disk(mddev, &info);
6531 goto done_unlock;
6532 }
6533
6534 case HOT_REMOVE_DISK:
6535 err = hot_remove_disk(mddev, new_decode_dev(arg));
6536 goto done_unlock;
6537
6538 case HOT_ADD_DISK:
6539 err = hot_add_disk(mddev, new_decode_dev(arg));
6540 goto done_unlock;
6541
1da177e4 6542 case RUN_ARRAY:
d710e138 6543 err = do_md_run(mddev);
1da177e4
LT		 6544 goto done_unlock;
6545
32a7627c
N		 6546 case SET_BITMAP_FILE:
6547 err = set_bitmap_file(mddev, (int)arg);
6548 goto done_unlock;
6549
1da177e4 6550 default:
1da177e4
LT		 6551 err = -EINVAL;
6552 goto abort_unlock;
6553 }
6554
6555done_unlock:
6556abort_unlock:
d3374825
N		 6557 if (mddev->hold_active == UNTIL_IOCTL &&
6558 err != -EINVAL)
6559 mddev->hold_active = 0;
1da177e4
LT		 6560 mddev_unlock(mddev);
6561
6562 return err;
6563done:
6564 if (err)
6565 MD_BUG();
6566abort:
6567 return err;
6568}
aa98aa31
AB		 6569#ifdef CONFIG_COMPAT
6570static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
6571 unsigned int cmd, unsigned long arg)
6572{
6573 switch (cmd) {
6574 case HOT_REMOVE_DISK:
6575 case HOT_ADD_DISK:
6576 case SET_DISK_FAULTY:
6577 case SET_BITMAP_FILE:
6578 /* These take in integer arg, do not convert */
6579 break;
6580 default:
6581 arg = (unsigned long)compat_ptr(arg);
6582 break;
6583 }
6584
6585 return md_ioctl(bdev, mode, cmd, arg);
6586}
6587#endif /* CONFIG_COMPAT */
1da177e4 6588
a39907fa 6589static int md_open(struct block_device *bdev, fmode_t mode)
1da177e4
LT		 6590{
6591 /*
6592 * Succeed if we can lock the mddev, which confirms that
6593 * it isn't being stopped right now.
6594 */
fd01b88c 6595 struct mddev *mddev = mddev_find(bdev->bd_dev);
1da177e4
LT		 6596 int err;
6597
0c098220
YL		 6598 if (!mddev)
6599 return -ENODEV;
6600
d3374825
N		 6601 if (mddev->gendisk != bdev->bd_disk) {
6602 /* we are racing with mddev_put which is discarding this
6603 * bd_disk.
6604 */
6605 mddev_put(mddev);
6606 /* Wait until bdev->bd_disk is definitely gone */
e804ac78 6607 flush_workqueue(md_misc_wq);
d3374825
N		 6608 /* Then retry the open from the top */
6609 return -ERESTARTSYS;
6610 }
6611 BUG_ON(mddev != bdev->bd_disk->private_data);
6612
c8c00a69 6613 if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
1da177e4
LT		 6614 goto out;
6615
6616 err = 0;
f2ea68cf 6617 atomic_inc(&mddev->openers);
c8c00a69 6618 mutex_unlock(&mddev->open_mutex);
1da177e4 6619
f0b4f7e2 6620 check_disk_change(bdev);
1da177e4
LT		 6621 out:
6622 return err;
6623}
6624
a39907fa 6625static int md_release(struct gendisk *disk, fmode_t mode)
1da177e4 6626{
fd01b88c 6627 struct mddev *mddev = disk->private_data;
1da177e4 6628
52e5f9d1 6629 BUG_ON(!mddev);
f2ea68cf 6630 atomic_dec(&mddev->openers);
1da177e4
LT		 6631 mddev_put(mddev);
6632
6633 return 0;
6634}
f0b4f7e2
N		 6635
6636static int md_media_changed(struct gendisk *disk)
6637{
fd01b88c 6638 struct mddev *mddev = disk->private_data;
f0b4f7e2
N		 6639
6640 return mddev->changed;
6641}
6642
6643static int md_revalidate(struct gendisk *disk)
6644{
fd01b88c 6645 struct mddev *mddev = disk->private_data;
f0b4f7e2
N		 6646
6647 mddev->changed = 0;
6648 return 0;
6649}
83d5cde4 6650static const struct block_device_operations md_fops =
1da177e4
LT		 6651{
6652 .owner = THIS_MODULE,
a39907fa
AV		 6653 .open = md_open,
6654 .release = md_release,
b492b852 6655 .ioctl = md_ioctl,
aa98aa31
AB		 6656#ifdef CONFIG_COMPAT
6657 .compat_ioctl = md_compat_ioctl,
6658#endif
a885c8c4 6659 .getgeo = md_getgeo,
f0b4f7e2
N		 6660 .media_changed = md_media_changed,
6661 .revalidate_disk= md_revalidate,
1da177e4
LT		 6662};
6663
75c96f85 6664static int md_thread(void * arg)
1da177e4 6665{
2b8bf345 6666 struct md_thread *thread = arg;
1da177e4 6667
1da177e4
LT		 6668 /*
6669 * md_thread is a 'system-thread', it's priority should be very
6670 * high. We avoid resource deadlocks individually in each
6671 * raid personality. (RAID5 does preallocation) We also use RR and
6672 * the very same RT priority as kswapd, thus we will never get
6673 * into a priority inversion deadlock.
6674 *
6675 * we definitely have to have equal or higher priority than
6676 * bdflush, otherwise bdflush will deadlock if there are too
6677 * many dirty RAID5 blocks.
6678 */
1da177e4 6679
6985c43f 6680 allow_signal(SIGKILL);
a6fb0934 6681 while (!kthread_should_stop()) {
1da177e4 6682
93588e22
N		 6683 /* We need to wait INTERRUPTIBLE so that
6684 * we don't add to the load-average.
6685 * That means we need to be sure no signals are
6686 * pending
6687 */
6688 if (signal_pending(current))
6689 flush_signals(current);
6690
6691 wait_event_interruptible_timeout
6692 (thread->wqueue,
6693 test_bit(THREAD_WAKEUP, &thread->flags)
6694 || kthread_should_stop(),
6695 thread->timeout);
1da177e4 6696
6c987910
N		 6697 clear_bit(THREAD_WAKEUP, &thread->flags);
6698 if (!kthread_should_stop())
4ed8731d 6699 thread->run(thread);
1da177e4 6700 }
a6fb0934 6701
1da177e4
LT		 6702 return 0;
6703}
6704
2b8bf345 6705void md_wakeup_thread(struct md_thread *thread)
1da177e4
LT		 6706{
6707 if (thread) {
36a4e1fe 6708 pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
1da177e4
LT		 6709 set_bit(THREAD_WAKEUP, &thread->flags);
6710 wake_up(&thread->wqueue);
6711 }
6712}
6713
4ed8731d
SL		 6714struct md_thread *md_register_thread(void (*run) (struct md_thread *),
6715 struct mddev *mddev, const char *name)
1da177e4 6716{
2b8bf345 6717 struct md_thread *thread;
1da177e4 6718
2b8bf345 6719 thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
1da177e4
LT		 6720 if (!thread)
6721 return NULL;
6722
1da177e4
LT		 6723 init_waitqueue_head(&thread->wqueue);
6724
1da177e4
LT		 6725 thread->run = run;
6726 thread->mddev = mddev;
32a7627c 6727 thread->timeout = MAX_SCHEDULE_TIMEOUT;
0da3c619
N		 6728 thread->tsk = kthread_run(md_thread, thread,
6729 "%s_%s",
6730 mdname(thread->mddev),
0232605d 6731 name);
a6fb0934 6732 if (IS_ERR(thread->tsk)) {
1da177e4
LT		 6733 kfree(thread);
6734 return NULL;
6735 }
1da177e4
LT		 6736 return thread;
6737}
6738
2b8bf345 6739void md_unregister_thread(struct md_thread **threadp)
1da177e4 6740{
2b8bf345 6741 struct md_thread *thread = *threadp;
e0cf8f04
N		 6742 if (!thread)
6743 return;
36a4e1fe 6744 pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
01f96c0a
N		 6745 /* Locking ensures that mddev_unlock does not wake_up a
6746 * non-existent thread
6747 */
6748 spin_lock(&pers_lock);
6749 *threadp = NULL;
6750 spin_unlock(&pers_lock);
a6fb0934
N		 6751
6752 kthread_stop(thread->tsk);
1da177e4
LT		 6753 kfree(thread);
6754}
6755
fd01b88c 6756void md_error(struct mddev *mddev, struct md_rdev *rdev)
1da177e4
LT		 6757{
6758 if (!mddev) {
6759 MD_BUG();
6760 return;
6761 }
6762
b2d444d7 6763 if (!rdev || test_bit(Faulty, &rdev->flags))
1da177e4 6764 return;
6bfe0b49 6765
de393cde 6766 if (!mddev->pers || !mddev->pers->error_handler)
1da177e4
LT		 6767 return;
6768 mddev->pers->error_handler(mddev,rdev);
72a23c21
NB		 6769 if (mddev->degraded)
6770 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
00bcb4ac 6771 sysfs_notify_dirent_safe(rdev->sysfs_state);
1da177e4
LT		 6772 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6773 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6774 md_wakeup_thread(mddev->thread);
768a418d 6775 if (mddev->event_work.func)
e804ac78 6776 queue_work(md_misc_wq, &mddev->event_work);
c331eb04 6777 md_new_event_inintr(mddev);
1da177e4
LT		 6778}
6779
6780/* seq_file implementation /proc/mdstat */
6781
6782static void status_unused(struct seq_file *seq)
6783{
6784 int i = 0;
3cb03002 6785 struct md_rdev *rdev;
1da177e4
LT		 6786
6787 seq_printf(seq, "unused devices: ");
6788
159ec1fc 6789 list_for_each_entry(rdev, &pending_raid_disks, same_set) {
1da177e4
LT		 6790 char b[BDEVNAME_SIZE];
6791 i++;
6792 seq_printf(seq, "%s ",
6793 bdevname(rdev->bdev,b));
6794 }
6795 if (!i)
6796 seq_printf(seq, "<none>");
6797
6798 seq_printf(seq, "\n");
6799}
6800
6801
fd01b88c 6802static void status_resync(struct seq_file *seq, struct mddev * mddev)
1da177e4 6803{
dd71cf6b
N		 6804 sector_t max_sectors, resync, res;
6805 unsigned long dt, db;
6806 sector_t rt;
4588b42e
N		 6807 int scale;
6808 unsigned int per_milli;
1da177e4 6809
dd71cf6b 6810 resync = mddev->curr_resync - atomic_read(&mddev->recovery_active);
1da177e4 6811
c804cdec
N		 6812 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
6813 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
dd71cf6b 6814 max_sectors = mddev->resync_max_sectors;
1da177e4 6815 else
dd71cf6b 6816 max_sectors = mddev->dev_sectors;
1da177e4
LT		 6817
6818 /*
6819 * Should not happen.
6820 */
dd71cf6b 6821 if (!max_sectors) {
1da177e4
LT		 6822 MD_BUG();
6823 return;
6824 }
4588b42e 6825 /* Pick 'scale' such that (resync>>scale)*1000 will fit
dd71cf6b 6826 * in a sector_t, and (max_sectors>>scale) will fit in a
4588b42e
N		 6827 * u32, as those are the requirements for sector_div.
6828 * Thus 'scale' must be at least 10
6829 */
6830 scale = 10;
6831 if (sizeof(sector_t) > sizeof(unsigned long)) {
dd71cf6b 6832 while ( max_sectors/2 > (1ULL<<(scale+32)))
4588b42e
N		 6833 scale++;
6834 }
6835 res = (resync>>scale)*1000;
dd71cf6b 6836 sector_div(res, (u32)((max_sectors>>scale)+1));
4588b42e
N		 6837
6838 per_milli = res;
1da177e4 6839 {
4588b42e 6840 int i, x = per_milli/50, y = 20-x;
1da177e4
LT		 6841 seq_printf(seq, "[");
6842 for (i = 0; i < x; i++)
6843 seq_printf(seq, "=");
6844 seq_printf(seq, ">");
6845 for (i = 0; i < y; i++)
6846 seq_printf(seq, ".");
6847 seq_printf(seq, "] ");
6848 }
4588b42e 6849 seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
ccfcc3c1
N		 6850 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
6851 "reshape" :
61df9d91
N		 6852 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
6853 "check" :
6854 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
6855 "resync" : "recovery"))),
6856 per_milli/10, per_milli % 10,
dd71cf6b
N		 6857 (unsigned long long) resync/2,
6858 (unsigned long long) max_sectors/2);
1da177e4
LT		 6859
6860 /*
1da177e4
LT		 6861 * dt: time from mark until now
6862 * db: blocks written from mark until now
6863 * rt: remaining time
dd71cf6b
N		 6864 *
6865 * rt is a sector_t, so could be 32bit or 64bit.
6866 * So we divide before multiply in case it is 32bit and close
6867 * to the limit.
25985edc 6868 * We scale the divisor (db) by 32 to avoid losing precision
dd71cf6b
N		 6869 * near the end of resync when the number of remaining sectors
6870 * is close to 'db'.
6871 * We then divide rt by 32 after multiplying by db to compensate.
6872 * The '+1' avoids division by zero if db is very small.
1da177e4
LT		 6873 */
6874 dt = ((jiffies - mddev->resync_mark) / HZ);
6875 if (!dt) dt++;
ff4e8d9a
N		 6876 db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
6877 - mddev->resync_mark_cnt;
1da177e4 6878
dd71cf6b
N		 6879 rt = max_sectors - resync; /* number of remaining sectors */
6880 sector_div(rt, db/32+1);
6881 rt *= dt;
6882 rt >>= 5;
6883
6884 seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
6885 ((unsigned long)rt % 60)/6);
1da177e4 6886
ff4e8d9a 6887 seq_printf(seq, " speed=%ldK/sec", db/2/dt);
1da177e4
LT		 6888}
6889
6890static void *md_seq_start(struct seq_file *seq, loff_t *pos)
6891{
6892 struct list_head *tmp;
6893 loff_t l = *pos;
fd01b88c 6894 struct mddev *mddev;
1da177e4
LT		 6895
6896 if (l >= 0x10000)
6897 return NULL;
6898 if (!l--)
6899 /* header */
6900 return (void*)1;
6901
6902 spin_lock(&all_mddevs_lock);
6903 list_for_each(tmp,&all_mddevs)
6904 if (!l--) {
fd01b88c 6905 mddev = list_entry(tmp, struct mddev, all_mddevs);
1da177e4
LT		 6906 mddev_get(mddev);
6907 spin_unlock(&all_mddevs_lock);
6908 return mddev;
6909 }
6910 spin_unlock(&all_mddevs_lock);
6911 if (!l--)
6912 return (void*)2;/* tail */
6913 return NULL;
6914}
6915
6916static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
6917{
6918 struct list_head *tmp;
fd01b88c 6919 struct mddev *next_mddev, *mddev = v;
1da177e4
LT		 6920
6921 ++*pos;
6922 if (v == (void*)2)
6923 return NULL;
6924
6925 spin_lock(&all_mddevs_lock);
6926 if (v == (void*)1)
6927 tmp = all_mddevs.next;
6928 else
6929 tmp = mddev->all_mddevs.next;
6930 if (tmp != &all_mddevs)
fd01b88c 6931 next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
1da177e4
LT		 6932 else {
6933 next_mddev = (void*)2;
6934 *pos = 0x10000;
6935 }
6936 spin_unlock(&all_mddevs_lock);
6937
6938 if (v != (void*)1)
6939 mddev_put(mddev);
6940 return next_mddev;
6941
6942}
6943
6944static void md_seq_stop(struct seq_file *seq, void *v)
6945{
fd01b88c 6946 struct mddev *mddev = v;
1da177e4
LT		 6947
6948 if (mddev && v != (void*)1 && v != (void*)2)
6949 mddev_put(mddev);
6950}
6951
6952static int md_seq_show(struct seq_file *seq, void *v)
6953{
fd01b88c 6954 struct mddev *mddev = v;
dd8ac336 6955 sector_t sectors;
3cb03002 6956 struct md_rdev *rdev;
1da177e4
LT		 6957
6958 if (v == (void*)1) {
84fc4b56 6959 struct md_personality *pers;
1da177e4
LT		 6960 seq_printf(seq, "Personalities : ");
6961 spin_lock(&pers_lock);
2604b703
N		 6962 list_for_each_entry(pers, &pers_list, list)
6963 seq_printf(seq, "[%s] ", pers->name);
1da177e4
LT		 6964
6965 spin_unlock(&pers_lock);
6966 seq_printf(seq, "\n");
f1514638 6967 seq->poll_event = atomic_read(&md_event_count);
1da177e4
LT		 6968 return 0;
6969 }
6970 if (v == (void*)2) {
6971 status_unused(seq);
6972 return 0;
6973 }
6974
5dc5cf7d 6975 if (mddev_lock(mddev) < 0)
1da177e4 6976 return -EINTR;
5dc5cf7d 6977
1da177e4
LT		 6978 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
6979 seq_printf(seq, "%s : %sactive", mdname(mddev),
6980 mddev->pers ? "" : "in");
6981 if (mddev->pers) {
f91de92e 6982 if (mddev->ro==1)
1da177e4 6983 seq_printf(seq, " (read-only)");
f91de92e 6984 if (mddev->ro==2)
52720ae7 6985 seq_printf(seq, " (auto-read-only)");
1da177e4
LT		 6986 seq_printf(seq, " %s", mddev->pers->name);
6987 }
6988
dd8ac336 6989 sectors = 0;
dafb20fa 6990 rdev_for_each(rdev, mddev) {
1da177e4
LT		 6991 char b[BDEVNAME_SIZE];
6992 seq_printf(seq, " %s[%d]",
6993 bdevname(rdev->bdev,b), rdev->desc_nr);
8ddf9efe
N		 6994 if (test_bit(WriteMostly, &rdev->flags))
6995 seq_printf(seq, "(W)");
b2d444d7 6996 if (test_bit(Faulty, &rdev->flags)) {
1da177e4
LT		 6997 seq_printf(seq, "(F)");
6998 continue;
2d78f8c4
N		 6999 }
7000 if (rdev->raid_disk < 0)
b325a32e 7001 seq_printf(seq, "(S)"); /* spare */
2d78f8c4
N		 7002 if (test_bit(Replacement, &rdev->flags))
7003 seq_printf(seq, "(R)");
dd8ac336 7004 sectors += rdev->sectors;
1da177e4
LT		 7005 }
7006
7007 if (!list_empty(&mddev->disks)) {
7008 if (mddev->pers)
7009 seq_printf(seq, "\n %llu blocks",
f233ea5c
AN		 7010 (unsigned long long)
7011 mddev->array_sectors / 2);
1da177e4
LT		 7012 else
7013 seq_printf(seq, "\n %llu blocks",
dd8ac336 7014 (unsigned long long)sectors / 2);
1da177e4 7015 }
1cd6bf19
N		 7016 if (mddev->persistent) {
7017 if (mddev->major_version != 0 ||
7018 mddev->minor_version != 90) {
7019 seq_printf(seq," super %d.%d",
7020 mddev->major_version,
7021 mddev->minor_version);
7022 }
e691063a
N		 7023 } else if (mddev->external)
7024 seq_printf(seq, " super external:%s",
7025 mddev->metadata_type);
7026 else
1cd6bf19 7027 seq_printf(seq, " super non-persistent");
1da177e4
LT		 7028
7029 if (mddev->pers) {
d710e138 7030 mddev->pers->status(seq, mddev);
1da177e4 7031 seq_printf(seq, "\n ");
8e1b39d6
N		 7032 if (mddev->pers->sync_request) {
7033 if (mddev->curr_resync > 2) {
d710e138 7034 status_resync(seq, mddev);
8e1b39d6
N		 7035 seq_printf(seq, "\n ");
7036 } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
7037 seq_printf(seq, "\tresync=DELAYED\n ");
7038 else if (mddev->recovery_cp < MaxSector)
7039 seq_printf(seq, "\tresync=PENDING\n ");
7040 }
32a7627c
N		 7041 } else
7042 seq_printf(seq, "\n ");
7043
57148964 7044 bitmap_status(seq, mddev->bitmap);
1da177e4
LT		 7045
7046 seq_printf(seq, "\n");
7047 }
7048 mddev_unlock(mddev);
7049
7050 return 0;
7051}
7052
110518bc 7053static const struct seq_operations md_seq_ops = {
1da177e4
LT		 7054 .start = md_seq_start,
7055 .next = md_seq_next,
7056 .stop = md_seq_stop,
7057 .show = md_seq_show,
7058};
7059
7060static int md_seq_open(struct inode *inode, struct file *file)
7061{
f1514638 7062 struct seq_file *seq;
1da177e4
LT		 7063 int error;
7064
7065 error = seq_open(file, &md_seq_ops);
d7603b7e 7066 if (error)
f1514638
KS		 7067 return error;
7068
7069 seq = file->private_data;
7070 seq->poll_event = atomic_read(&md_event_count);
1da177e4
LT		 7071 return error;
7072}
7073
d7603b7e
N		 7074static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
7075{
f1514638 7076 struct seq_file *seq = filp->private_data;
d7603b7e
N		 7077 int mask;
7078
7079 poll_wait(filp, &md_event_waiters, wait);
7080
7081 /* always allow read */
7082 mask = POLLIN | POLLRDNORM;
7083
f1514638 7084 if (seq->poll_event != atomic_read(&md_event_count))
d7603b7e
N		 7085 mask |= POLLERR | POLLPRI;
7086 return mask;
7087}
7088
fa027c2a 7089static const struct file_operations md_seq_fops = {
e24650c2 7090 .owner = THIS_MODULE,
1da177e4
LT		 7091 .open = md_seq_open,
7092 .read = seq_read,
7093 .llseek = seq_lseek,
c3f94b40 7094 .release = seq_release_private,
d7603b7e 7095 .poll = mdstat_poll,
1da177e4
LT		 7096};
7097
84fc4b56 7098int register_md_personality(struct md_personality *p)
1da177e4 7099{
1da177e4 7100 spin_lock(&pers_lock);
2604b703
N		 7101 list_add_tail(&p->list, &pers_list);
7102 printk(KERN_INFO "md: %s personality registered for level %d\n", p->name, p->level);
1da177e4
LT		 7103 spin_unlock(&pers_lock);
7104 return 0;
7105}
7106
84fc4b56 7107int unregister_md_personality(struct md_personality *p)
1da177e4 7108{
2604b703 7109 printk(KERN_INFO "md: %s personality unregistered\n", p->name);
1da177e4 7110 spin_lock(&pers_lock);
2604b703 7111 list_del_init(&p->list);
1da177e4
LT		 7112 spin_unlock(&pers_lock);
7113 return 0;
7114}
7115
fd01b88c 7116static int is_mddev_idle(struct mddev *mddev, int init)
1da177e4 7117{
3cb03002 7118 struct md_rdev * rdev;
1da177e4 7119 int idle;
eea1bf38 7120 int curr_events;
1da177e4
LT		 7121
7122 idle = 1;
4b80991c
N		 7123 rcu_read_lock();
7124 rdev_for_each_rcu(rdev, mddev) {
1da177e4 7125 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
eea1bf38
N		 7126 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
7127 (int)part_stat_read(&disk->part0, sectors[1]) -
7128 atomic_read(&disk->sync_io);
713f6ab1
N		 7129 /* sync IO will cause sync_io to increase before the disk_stats
7130 * as sync_io is counted when a request starts, and
7131 * disk_stats is counted when it completes.
7132 * So resync activity will cause curr_events to be smaller than
7133 * when there was no such activity.
7134 * non-sync IO will cause disk_stat to increase without
7135 * increasing sync_io so curr_events will (eventually)
7136 * be larger than it was before. Once it becomes
7137 * substantially larger, the test below will cause
7138 * the array to appear non-idle, and resync will slow
7139 * down.
7140 * If there is a lot of outstanding resync activity when
7141 * we set last_event to curr_events, then all that activity
7142 * completing might cause the array to appear non-idle
7143 * and resync will be slowed down even though there might
7144 * not have been non-resync activity. This will only
7145 * happen once though. 'last_events' will soon reflect
7146 * the state where there is little or no outstanding
7147 * resync requests, and further resync activity will
7148 * always make curr_events less than last_events.
c0e48521 7149 *
1da177e4 7150 */
eea1bf38 7151 if (init || curr_events - rdev->last_events > 64) {
1da177e4
LT		 7152 rdev->last_events = curr_events;
7153 idle = 0;
7154 }
7155 }
4b80991c 7156 rcu_read_unlock();
1da177e4
LT		 7157 return idle;
7158}
7159
fd01b88c 7160void md_done_sync(struct mddev *mddev, int blocks, int ok)
1da177e4
LT		 7161{
7162 /* another "blocks" (512byte) blocks have been synced */
7163 atomic_sub(blocks, &mddev->recovery_active);
7164 wake_up(&mddev->recovery_wait);
7165 if (!ok) {
dfc70645 7166 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
1da177e4
LT		 7167 md_wakeup_thread(mddev->thread);
7168 // stop recovery, signal do_sync ....
7169 }
7170}
7171
7172
06d91a5f
N		 7173/* md_write_start(mddev, bi)
7174 * If we need to update some array metadata (e.g. 'active' flag
3d310eb7
N		 7175 * in superblock) before writing, schedule a superblock update
7176 * and wait for it to complete.
06d91a5f 7177 */
fd01b88c 7178void md_write_start(struct mddev *mddev, struct bio *bi)
1da177e4 7179{
0fd62b86 7180 int did_change = 0;
06d91a5f 7181 if (bio_data_dir(bi) != WRITE)
3d310eb7 7182 return;
06d91a5f 7183
f91de92e
N		 7184 BUG_ON(mddev->ro == 1);
7185 if (mddev->ro == 2) {
7186 /* need to switch to read/write */
7187 mddev->ro = 0;
7188 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7189 md_wakeup_thread(mddev->thread);
25156198 7190 md_wakeup_thread(mddev->sync_thread);
0fd62b86 7191 did_change = 1;
f91de92e 7192 }
06d91a5f 7193 atomic_inc(&mddev->writes_pending);
31a59e34
N		 7194 if (mddev->safemode == 1)
7195 mddev->safemode = 0;
06d91a5f 7196 if (mddev->in_sync) {
a9701a30 7197 spin_lock_irq(&mddev->write_lock);
3d310eb7
N		 7198 if (mddev->in_sync) {
7199 mddev->in_sync = 0;
850b2b42 7200 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
070dc6dd 7201 set_bit(MD_CHANGE_PENDING, &mddev->flags);
3d310eb7 7202 md_wakeup_thread(mddev->thread);
0fd62b86 7203 did_change = 1;
3d310eb7 7204 }
a9701a30 7205 spin_unlock_irq(&mddev->write_lock);
06d91a5f 7206 }
0fd62b86 7207 if (did_change)
00bcb4ac 7208 sysfs_notify_dirent_safe(mddev->sysfs_state);
09a44cc1 7209 wait_event(mddev->sb_wait,
09a44cc1 7210 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
1da177e4
LT		 7211}
7212
fd01b88c 7213void md_write_end(struct mddev *mddev)
1da177e4
LT		 7214{
7215 if (atomic_dec_and_test(&mddev->writes_pending)) {
7216 if (mddev->safemode == 2)
7217 md_wakeup_thread(mddev->thread);
16f17b39 7218 else if (mddev->safemode_delay)
1da177e4
LT		 7219 mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
7220 }
7221}
7222
2a2275d6
N		 7223/* md_allow_write(mddev)
7224 * Calling this ensures that the array is marked 'active' so that writes
7225 * may proceed without blocking. It is important to call this before
7226 * attempting a GFP_KERNEL allocation while holding the mddev lock.
7227 * Must be called with mddev_lock held.
b5470dc5
DW		 7228 *
7229 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
7230 * is dropped, so return -EAGAIN after notifying userspace.
2a2275d6 7231 */
fd01b88c 7232int md_allow_write(struct mddev *mddev)
2a2275d6
N		 7233{
7234 if (!mddev->pers)
b5470dc5 7235 return 0;
2a2275d6 7236 if (mddev->ro)
b5470dc5 7237 return 0;
1a0fd497 7238 if (!mddev->pers->sync_request)
b5470dc5 7239 return 0;
2a2275d6
N		 7240
7241 spin_lock_irq(&mddev->write_lock);
7242 if (mddev->in_sync) {
7243 mddev->in_sync = 0;
7244 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
070dc6dd 7245 set_bit(MD_CHANGE_PENDING, &mddev->flags);
2a2275d6
N		 7246 if (mddev->safemode_delay &&
7247 mddev->safemode == 0)
7248 mddev->safemode = 1;
7249 spin_unlock_irq(&mddev->write_lock);
7250 md_update_sb(mddev, 0);
00bcb4ac 7251 sysfs_notify_dirent_safe(mddev->sysfs_state);
2a2275d6
N		 7252 } else
7253 spin_unlock_irq(&mddev->write_lock);
b5470dc5 7254
070dc6dd 7255 if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
b5470dc5
DW		 7256 return -EAGAIN;
7257 else
7258 return 0;
2a2275d6
N		 7259}
7260EXPORT_SYMBOL_GPL(md_allow_write);
7261
1da177e4
LT		 7262#define SYNC_MARKS 10
7263#define SYNC_MARK_STEP (3*HZ)
4ed8731d 7264void md_do_sync(struct md_thread *thread)
1da177e4 7265{
4ed8731d 7266 struct mddev *mddev = thread->mddev;
fd01b88c 7267 struct mddev *mddev2;
1da177e4
LT		 7268 unsigned int currspeed = 0,
7269 window;
57afd89f 7270 sector_t max_sectors,j, io_sectors;
1da177e4
LT		 7271 unsigned long mark[SYNC_MARKS];
7272 sector_t mark_cnt[SYNC_MARKS];
7273 int last_mark,m;
7274 struct list_head *tmp;
7275 sector_t last_check;
57afd89f 7276 int skipped = 0;
3cb03002 7277 struct md_rdev *rdev;
61df9d91 7278 char *desc;
7c2c57c9 7279 struct blk_plug plug;
1da177e4
LT		 7280
7281 /* just incase thread restarts... */
7282 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7283 return;
5fd6c1dc
N		 7284 if (mddev->ro) /* never try to sync a read-only array */
7285 return;
1da177e4 7286
61df9d91
N		 7287 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7288 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
7289 desc = "data-check";
7290 else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7291 desc = "requested-resync";
7292 else
7293 desc = "resync";
7294 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7295 desc = "reshape";
7296 else
7297 desc = "recovery";
7298
1da177e4
LT		 7299 /* we overload curr_resync somewhat here.
7300 * 0 == not engaged in resync at all
7301 * 2 == checking that there is no conflict with another sync
7302 * 1 == like 2, but have yielded to allow conflicting resync to
7303 * commense
7304 * other == active in resync - this many blocks
7305 *
7306 * Before starting a resync we must have set curr_resync to
7307 * 2, and then checked that every "conflicting" array has curr_resync
7308 * less than ours. When we find one that is the same or higher
7309 * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
7310 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
7311 * This will mean we have to start checking from the beginning again.
7312 *
7313 */
7314
7315 do {
7316 mddev->curr_resync = 2;
7317
7318 try_again:
404e4b43 7319 if (kthread_should_stop())
6985c43f 7320 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
404e4b43
N		 7321
7322 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
1da177e4 7323 goto skip;
29ac4aa3 7324 for_each_mddev(mddev2, tmp) {
1da177e4
LT		 7325 if (mddev2 == mddev)
7326 continue;
90b08710
BS		 7327 if (!mddev->parallel_resync
7328 && mddev2->curr_resync
7329 && match_mddev_units(mddev, mddev2)) {
1da177e4
LT		 7330 DEFINE_WAIT(wq);
7331 if (mddev < mddev2 && mddev->curr_resync == 2) {
7332 /* arbitrarily yield */
7333 mddev->curr_resync = 1;
7334 wake_up(&resync_wait);
7335 }
7336 if (mddev > mddev2 && mddev->curr_resync == 1)
7337 /* no need to wait here, we can wait the next
7338 * time 'round when curr_resync == 2
7339 */
7340 continue;
9744197c
N		 7341 /* We need to wait 'interruptible' so as not to
7342 * contribute to the load average, and not to
7343 * be caught by 'softlockup'
7344 */
7345 prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
787453c2 7346 if (!kthread_should_stop() &&
8712e553 7347 mddev2->curr_resync >= mddev->curr_resync) {
61df9d91
N		 7348 printk(KERN_INFO "md: delaying %s of %s"
7349 " until %s has finished (they"
1da177e4 7350 " share one or more physical units)\n",
61df9d91 7351 desc, mdname(mddev), mdname(mddev2));
1da177e4 7352 mddev_put(mddev2);
9744197c
N		 7353 if (signal_pending(current))
7354 flush_signals(current);
1da177e4
LT		 7355 schedule();
7356 finish_wait(&resync_wait, &wq);
7357 goto try_again;
7358 }
7359 finish_wait(&resync_wait, &wq);
7360 }
7361 }
7362 } while (mddev->curr_resync < 2);
7363
5fd6c1dc 7364 j = 0;
9d88883e 7365 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
1da177e4 7366 /* resync follows the size requested by the personality,
57afd89f 7367 * which defaults to physical size, but can be virtual size
1da177e4
LT		 7368 */
7369 max_sectors = mddev->resync_max_sectors;
7f7583d4 7370 atomic64_set(&mddev->resync_mismatches, 0);
5fd6c1dc 7371 /* we don't use the checkpoint if there's a bitmap */
5e96ee65
NB		 7372 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7373 j = mddev->resync_min;
7374 else if (!mddev->bitmap)
5fd6c1dc 7375 j = mddev->recovery_cp;
5e96ee65 7376
ccfcc3c1 7377 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
c804cdec 7378 max_sectors = mddev->resync_max_sectors;
5fd6c1dc 7379 else {
1da177e4 7380 /* recovery follows the physical size of devices */
58c0fed4 7381 max_sectors = mddev->dev_sectors;
5fd6c1dc 7382 j = MaxSector;
4e59ca7d 7383 rcu_read_lock();
dafb20fa 7384 rdev_for_each_rcu(rdev, mddev)
5fd6c1dc
N		 7385 if (rdev->raid_disk >= 0 &&
7386 !test_bit(Faulty, &rdev->flags) &&
7387 !test_bit(In_sync, &rdev->flags) &&
7388 rdev->recovery_offset < j)
7389 j = rdev->recovery_offset;
4e59ca7d 7390 rcu_read_unlock();
5fd6c1dc 7391 }
1da177e4 7392
61df9d91
N		 7393 printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
7394 printk(KERN_INFO "md: minimum _guaranteed_ speed:"
7395 " %d KB/sec/disk.\n", speed_min(mddev));
338cec32 7396 printk(KERN_INFO "md: using maximum available idle IO bandwidth "
61df9d91
N		 7397 "(but not more than %d KB/sec) for %s.\n",
7398 speed_max(mddev), desc);
1da177e4 7399
eea1bf38 7400 is_mddev_idle(mddev, 1); /* this initializes IO event counters */
5fd6c1dc 7401
57afd89f 7402 io_sectors = 0;
1da177e4
LT		 7403 for (m = 0; m < SYNC_MARKS; m++) {
7404 mark[m] = jiffies;
57afd89f 7405 mark_cnt[m] = io_sectors;
1da177e4
LT		 7406 }
7407 last_mark = 0;
7408 mddev->resync_mark = mark[last_mark];
7409 mddev->resync_mark_cnt = mark_cnt[last_mark];
7410
7411 /*
7412 * Tune reconstruction:
7413 */
7414 window = 32*(PAGE_SIZE/512);
ac42450c
JB		 7415 printk(KERN_INFO "md: using %dk window, over a total of %lluk.\n",
7416 window/2, (unsigned long long)max_sectors/2);
1da177e4
LT		 7417
7418 atomic_set(&mddev->recovery_active, 0);
1da177e4
LT		 7419 last_check = 0;
7420
7421 if (j>2) {
7422 printk(KERN_INFO
61df9d91
N		 7423 "md: resuming %s of %s from checkpoint.\n",
7424 desc, mdname(mddev));
1da177e4
LT		 7425 mddev->curr_resync = j;
7426 }
75d3da43 7427 mddev->curr_resync_completed = j;
1da177e4 7428
7c2c57c9 7429 blk_start_plug(&plug);
1da177e4 7430 while (j < max_sectors) {
57afd89f 7431 sector_t sectors;
1da177e4 7432
57afd89f 7433 skipped = 0;
97e4f42d 7434
7a91ee1f
N		 7435 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7436 ((mddev->curr_resync > mddev->curr_resync_completed &&
7437 (mddev->curr_resync - mddev->curr_resync_completed)
7438 > (max_sectors >> 4)) ||
7439 (j - mddev->curr_resync_completed)*2
7440 >= mddev->resync_max - mddev->curr_resync_completed
7441 )) {
97e4f42d 7442 /* time to update curr_resync_completed */
97e4f42d
N		 7443 wait_event(mddev->recovery_wait,
7444 atomic_read(&mddev->recovery_active) == 0);
75d3da43 7445 mddev->curr_resync_completed = j;
070dc6dd 7446 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
acb180b0 7447 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
97e4f42d 7448 }
acb180b0 7449
e62e58a5
N		 7450 while (j >= mddev->resync_max && !kthread_should_stop()) {
7451 /* As this condition is controlled by user-space,
7452 * we can block indefinitely, so use '_interruptible'
7453 * to avoid triggering warnings.
7454 */
7455 flush_signals(current); /* just in case */
7456 wait_event_interruptible(mddev->recovery_wait,
7457 mddev->resync_max > j
7458 || kthread_should_stop());
7459 }
acb180b0
N		 7460
7461 if (kthread_should_stop())
7462 goto interrupted;
7463
57afd89f 7464 sectors = mddev->pers->sync_request(mddev, j, &skipped,
c6207277 7465 currspeed < speed_min(mddev));
57afd89f 7466 if (sectors == 0) {
dfc70645 7467 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
1da177e4
LT		 7468 goto out;
7469 }
57afd89f
N		 7470
7471 if (!skipped) { /* actual IO requested */
7472 io_sectors += sectors;
7473 atomic_add(sectors, &mddev->recovery_active);
7474 }
7475
e875ecea
N		 7476 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7477 break;
7478
1da177e4
LT		 7479 j += sectors;
7480 if (j>1) mddev->curr_resync = j;
ff4e8d9a 7481 mddev->curr_mark_cnt = io_sectors;
d7603b7e 7482 if (last_check == 0)
e875ecea 7483 /* this is the earliest that rebuild will be
d7603b7e
N		 7484 * visible in /proc/mdstat
7485 */
7486 md_new_event(mddev);
57afd89f
N		 7487
7488 if (last_check + window > io_sectors || j == max_sectors)
1da177e4
LT		 7489 continue;
7490
57afd89f 7491 last_check = io_sectors;
1da177e4
LT		 7492 repeat:
7493 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
7494 /* step marks */
7495 int next = (last_mark+1) % SYNC_MARKS;
7496
7497 mddev->resync_mark = mark[next];
7498 mddev->resync_mark_cnt = mark_cnt[next];
7499 mark[next] = jiffies;
57afd89f 7500 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
1da177e4
LT		 7501 last_mark = next;
7502 }
7503
7504
c6207277
N		 7505 if (kthread_should_stop())
7506 goto interrupted;
7507
1da177e4
LT		 7508
7509 /*
7510 * this loop exits only if either when we are slower than
7511 * the 'hard' speed limit, or the system was IO-idle for
7512 * a jiffy.
7513 * the system might be non-idle CPU-wise, but we only care
7514 * about not overloading the IO subsystem. (things like an
7515 * e2fsck being done on the RAID array should execute fast)
7516 */
1da177e4
LT		 7517 cond_resched();
7518
57afd89f
N		 7519 currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
7520 /((jiffies-mddev->resync_mark)/HZ +1) +1;
1da177e4 7521
88202a0c
N		 7522 if (currspeed > speed_min(mddev)) {
7523 if ((currspeed > speed_max(mddev)) ||
eea1bf38 7524 !is_mddev_idle(mddev, 0)) {
c0e48521 7525 msleep(500);
1da177e4
LT		 7526 goto repeat;
7527 }
7528 }
7529 }
61df9d91 7530 printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc);
1da177e4
LT		 7531 /*
7532 * this also signals 'finished resyncing' to md_stop
7533 */
7534 out:
7c2c57c9 7535 blk_finish_plug(&plug);
1da177e4
LT		 7536 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
7537
7538 /* tell personality that we are finished */
57afd89f 7539 mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
1da177e4 7540
dfc70645 7541 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
5fd6c1dc
N		 7542 mddev->curr_resync > 2) {
7543 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7544 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
7545 if (mddev->curr_resync >= mddev->recovery_cp) {
7546 printk(KERN_INFO
61df9d91
N		 7547 "md: checkpointing %s of %s.\n",
7548 desc, mdname(mddev));
db91ff55
N		 7549 mddev->recovery_cp =
7550 mddev->curr_resync_completed;
5fd6c1dc
N		 7551 }
7552 } else
7553 mddev->recovery_cp = MaxSector;
7554 } else {
7555 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7556 mddev->curr_resync = MaxSector;
4e59ca7d 7557 rcu_read_lock();
dafb20fa 7558 rdev_for_each_rcu(rdev, mddev)
5fd6c1dc 7559 if (rdev->raid_disk >= 0 &&
70fffd0b 7560 mddev->delta_disks >= 0 &&
5fd6c1dc
N		 7561 !test_bit(Faulty, &rdev->flags) &&
7562 !test_bit(In_sync, &rdev->flags) &&
7563 rdev->recovery_offset < mddev->curr_resync)
7564 rdev->recovery_offset = mddev->curr_resync;
4e59ca7d 7565 rcu_read_unlock();
5fd6c1dc 7566 }
1da177e4 7567 }
db91ff55 7568 skip:
17571284 7569 set_bit(MD_CHANGE_DEVS, &mddev->flags);
1da177e4 7570
c07b70ad
N		 7571 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
7572 /* We completed so min/max setting can be forgotten if used. */
7573 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7574 mddev->resync_min = 0;
7575 mddev->resync_max = MaxSector;
7576 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7577 mddev->resync_min = mddev->curr_resync_completed;
1da177e4
LT		 7578 mddev->curr_resync = 0;
7579 wake_up(&resync_wait);
7580 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
7581 md_wakeup_thread(mddev->thread);
c6207277
N		 7582 return;
7583
7584 interrupted:
7585 /*
7586 * got a signal, exit.
7587 */
7588 printk(KERN_INFO
7589 "md: md_do_sync() got signal ... exiting\n");
7590 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7591 goto out;
7592
1da177e4 7593}
29269553 7594EXPORT_SYMBOL_GPL(md_do_sync);
1da177e4 7595
fd01b88c 7596static int remove_and_add_spares(struct mddev *mddev)
b4c4c7b8 7597{
3cb03002 7598 struct md_rdev *rdev;
b4c4c7b8 7599 int spares = 0;
f2a371c5 7600 int removed = 0;
b4c4c7b8 7601
97e4f42d
N		 7602 mddev->curr_resync_completed = 0;
7603
dafb20fa 7604 rdev_for_each(rdev, mddev)
b4c4c7b8 7605 if (rdev->raid_disk >= 0 &&
6bfe0b49 7606 !test_bit(Blocked, &rdev->flags) &&
b4c4c7b8
N		 7607 (test_bit(Faulty, &rdev->flags) ||
7608 ! test_bit(In_sync, &rdev->flags)) &&
7609 atomic_read(&rdev->nr_pending)==0) {
7610 if (mddev->pers->hot_remove_disk(
b8321b68 7611 mddev, rdev) == 0) {
36fad858 7612 sysfs_unlink_rdev(mddev, rdev);
b4c4c7b8 7613 rdev->raid_disk = -1;
f2a371c5 7614 removed++;
b4c4c7b8
N		 7615 }
7616 }
f2a371c5
N		 7617 if (removed)
7618 sysfs_notify(&mddev->kobj, NULL,
7619 "degraded");
7620
b4c4c7b8 7621
dafb20fa 7622 rdev_for_each(rdev, mddev) {
7bfec5f3
N		 7623 if (rdev->raid_disk >= 0 &&
7624 !test_bit(In_sync, &rdev->flags) &&
7625 !test_bit(Faulty, &rdev->flags))
7626 spares++;
7627 if (rdev->raid_disk < 0
7628 && !test_bit(Faulty, &rdev->flags)) {
7629 rdev->recovery_offset = 0;
7630 if (mddev->pers->
7631 hot_add_disk(mddev, rdev) == 0) {
7632 if (sysfs_link_rdev(mddev, rdev))
7633 /* failure here is OK */;
dfc70645 7634 spares++;
7bfec5f3
N		 7635 md_new_event(mddev);
7636 set_bit(MD_CHANGE_DEVS, &mddev->flags);
b4c4c7b8 7637 }
dfc70645 7638 }
b4c4c7b8
N		 7639 }
7640 return spares;
7641}
7ebc0be7 7642
fd01b88c 7643static void reap_sync_thread(struct mddev *mddev)
7ebc0be7 7644{
3cb03002 7645 struct md_rdev *rdev;
7ebc0be7
N		 7646
7647 /* resync has finished, collect result */
01f96c0a 7648 md_unregister_thread(&mddev->sync_thread);
7ebc0be7
N		 7649 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
7650 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
7651 /* success...*/
7652 /* activate any spares */
7653 if (mddev->pers->spare_active(mddev))
7654 sysfs_notify(&mddev->kobj, NULL,
7655 "degraded");
7656 }
7657 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7658 mddev->pers->finish_reshape)
7659 mddev->pers->finish_reshape(mddev);
7ebc0be7 7660
d70ed2e4
AW		 7661 /* If array is no-longer degraded, then any saved_raid_disk
7662 * information must be scrapped. Also if any device is now
7663 * In_sync we must scrape the saved_raid_disk for that device
7664 * do the superblock for an incrementally recovered device
7665 * written out.
7ebc0be7 7666 */
dafb20fa 7667 rdev_for_each(rdev, mddev)
d70ed2e4
AW		 7668 if (!mddev->degraded ||
7669 test_bit(In_sync, &rdev->flags))
7ebc0be7
N		 7670 rdev->saved_raid_disk = -1;
7671
d70ed2e4 7672 md_update_sb(mddev, 1);
7ebc0be7
N		 7673 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7674 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7675 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7676 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
7677 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
7678 /* flag recovery needed just to double check */
7679 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7680 sysfs_notify_dirent_safe(mddev->sysfs_action);
7681 md_new_event(mddev);
768e587e
JB		 7682 if (mddev->event_work.func)
7683 queue_work(md_misc_wq, &mddev->event_work);
7ebc0be7
N		 7684}
7685
1da177e4
LT		 7686/*
7687 * This routine is regularly called by all per-raid-array threads to
7688 * deal with generic issues like resync and super-block update.
7689 * Raid personalities that don't have a thread (linear/raid0) do not
7690 * need this as they never do any recovery or update the superblock.
7691 *
7692 * It does not do any resync itself, but rather "forks" off other threads
7693 * to do that as needed.
7694 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
7695 * "->recovery" and create a thread at ->sync_thread.
dfc70645 7696 * When the thread finishes it sets MD_RECOVERY_DONE
1da177e4
LT		 7697 * and wakeups up this thread which will reap the thread and finish up.
7698 * This thread also removes any faulty devices (with nr_pending == 0).
7699 *
7700 * The overall approach is:
7701 * 1/ if the superblock needs updating, update it.
7702 * 2/ If a recovery thread is running, don't do anything else.
7703 * 3/ If recovery has finished, clean up, possibly marking spares active.
7704 * 4/ If there are any faulty devices, remove them.
7705 * 5/ If array is degraded, try to add spares devices
7706 * 6/ If array has spares or is not in-sync, start a resync thread.
7707 */
fd01b88c 7708void md_check_recovery(struct mddev *mddev)
1da177e4 7709{
68866e42
JB		 7710 if (mddev->suspended)
7711 return;
7712
5f40402d 7713 if (mddev->bitmap)
aa5cbd10 7714 bitmap_daemon_work(mddev);
1da177e4 7715
fca4d848 7716 if (signal_pending(current)) {
31a59e34 7717 if (mddev->pers->sync_request && !mddev->external) {
fca4d848
N		 7718 printk(KERN_INFO "md: %s in immediate safe mode\n",
7719 mdname(mddev));
7720 mddev->safemode = 2;
7721 }
7722 flush_signals(current);
7723 }
7724
c89a8eee
N		 7725 if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
7726 return;
1da177e4 7727 if ( ! (
126925c0 7728 (mddev->flags & ~ (1<<MD_CHANGE_PENDING)) ||
1da177e4 7729 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
fca4d848 7730 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
31a59e34 7731 (mddev->external == 0 && mddev->safemode == 1) ||
fca4d848
N		 7732 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
7733 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
1da177e4
LT		 7734 ))
7735 return;
fca4d848 7736
df5b89b3 7737 if (mddev_trylock(mddev)) {
b4c4c7b8 7738 int spares = 0;
fca4d848 7739
c89a8eee
N		 7740 if (mddev->ro) {
7741 /* Only thing we do on a ro array is remove
7742 * failed devices.
7743 */
3cb03002 7744 struct md_rdev *rdev;
dafb20fa 7745 rdev_for_each(rdev, mddev)
a8c42c7f
N		 7746 if (rdev->raid_disk >= 0 &&
7747 !test_bit(Blocked, &rdev->flags) &&
7748 test_bit(Faulty, &rdev->flags) &&
7749 atomic_read(&rdev->nr_pending)==0) {
7750 if (mddev->pers->hot_remove_disk(
b8321b68 7751 mddev, rdev) == 0) {
36fad858 7752 sysfs_unlink_rdev(mddev, rdev);
a8c42c7f
N		 7753 rdev->raid_disk = -1;
7754 }
7755 }
c89a8eee
N		 7756 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7757 goto unlock;
7758 }
7759
31a59e34 7760 if (!mddev->external) {
0fd62b86 7761 int did_change = 0;
31a59e34
N		 7762 spin_lock_irq(&mddev->write_lock);
7763 if (mddev->safemode &&
7764 !atomic_read(&mddev->writes_pending) &&
7765 !mddev->in_sync &&
7766 mddev->recovery_cp == MaxSector) {
7767 mddev->in_sync = 1;
0fd62b86 7768 did_change = 1;
070dc6dd 7769 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
31a59e34
N		 7770 }
7771 if (mddev->safemode == 1)
7772 mddev->safemode = 0;
7773 spin_unlock_irq(&mddev->write_lock);
0fd62b86 7774 if (did_change)
00bcb4ac 7775 sysfs_notify_dirent_safe(mddev->sysfs_state);
fca4d848 7776 }
fca4d848 7777
850b2b42
N		 7778 if (mddev->flags)
7779 md_update_sb(mddev, 0);
06d91a5f 7780
1da177e4
LT		 7781 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
7782 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
7783 /* resync/recovery still happening */
7784 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7785 goto unlock;
7786 }
7787 if (mddev->sync_thread) {
7ebc0be7 7788 reap_sync_thread(mddev);
1da177e4
LT		 7789 goto unlock;
7790 }
72a23c21
NB		 7791 /* Set RUNNING before clearing NEEDED to avoid
7792 * any transients in the value of "sync_action".
7793 */
7794 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
24dd469d
N		 7795 /* Clear some bits that don't mean anything, but
7796 * might be left set
7797 */
24dd469d
N		 7798 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
7799 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
1da177e4 7800
ed209584
N		 7801 if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
7802 test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
5fd6c1dc 7803 goto unlock;
1da177e4
LT		 7804 /* no recovery is running.
7805 * remove any failed drives, then
7806 * add spares if possible.
7807 * Spare are also removed and re-added, to allow
7808 * the personality to fail the re-add.
7809 */
1da177e4 7810
b4c4c7b8 7811 if (mddev->reshape_position != MaxSector) {
50ac168a
N		 7812 if (mddev->pers->check_reshape == NULL ||
7813 mddev->pers->check_reshape(mddev) != 0)
b4c4c7b8
N		 7814 /* Cannot proceed */
7815 goto unlock;
7816 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
72a23c21 7817 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
b4c4c7b8 7818 } else if ((spares = remove_and_add_spares(mddev))) {
24dd469d
N		 7819 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7820 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
56ac36d7 7821 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
72a23c21 7822 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
24dd469d
N		 7823 } else if (mddev->recovery_cp < MaxSector) {
7824 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
72a23c21 7825 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
24dd469d
N		 7826 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
7827 /* nothing to be done ... */
1da177e4 7828 goto unlock;
24dd469d 7829
1da177e4 7830 if (mddev->pers->sync_request) {
ef99bf48 7831 if (spares) {
a654b9d8
N		 7832 /* We are adding a device or devices to an array
7833 * which has the bitmap stored on all devices.
7834 * So make sure all bitmap pages get written
7835 */
7836 bitmap_write_all(mddev->bitmap);
7837 }
1da177e4
LT		 7838 mddev->sync_thread = md_register_thread(md_do_sync,
7839 mddev,
0da3c619 7840 "resync");
1da177e4
LT		 7841 if (!mddev->sync_thread) {
7842 printk(KERN_ERR "%s: could not start resync"
7843 " thread...\n",
7844 mdname(mddev));
7845 /* leave the spares where they are, it shouldn't hurt */
7ebc0be7
N		 7846 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7847 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7848 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7849 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
7850 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
d7603b7e 7851 } else
1da177e4 7852 md_wakeup_thread(mddev->sync_thread);
00bcb4ac 7853 sysfs_notify_dirent_safe(mddev->sysfs_action);
d7603b7e 7854 md_new_event(mddev);
1da177e4
LT		 7855 }
7856 unlock:
72a23c21
NB		 7857 if (!mddev->sync_thread) {
7858 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7859 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
7860 &mddev->recovery))
0c3573f1 7861 if (mddev->sysfs_action)
00bcb4ac 7862 sysfs_notify_dirent_safe(mddev->sysfs_action);
72a23c21 7863 }
1da177e4
LT		 7864 mddev_unlock(mddev);
7865 }
7866}
7867
fd01b88c 7868void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
6bfe0b49 7869{
00bcb4ac 7870 sysfs_notify_dirent_safe(rdev->sysfs_state);
6bfe0b49 7871 wait_event_timeout(rdev->blocked_wait,
de393cde
N		 7872 !test_bit(Blocked, &rdev->flags) &&
7873 !test_bit(BlockedBadBlocks, &rdev->flags),
6bfe0b49
DW		 7874 msecs_to_jiffies(5000));
7875 rdev_dec_pending(rdev, mddev);
7876}
7877EXPORT_SYMBOL(md_wait_for_blocked_rdev);
7878
c6563a8c
N		 7879void md_finish_reshape(struct mddev *mddev)
7880{
7881 /* called be personality module when reshape completes. */
7882 struct md_rdev *rdev;
7883
7884 rdev_for_each(rdev, mddev) {
7885 if (rdev->data_offset > rdev->new_data_offset)
7886 rdev->sectors += rdev->data_offset - rdev->new_data_offset;
7887 else
7888 rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
7889 rdev->data_offset = rdev->new_data_offset;
7890 }
7891}
7892EXPORT_SYMBOL(md_finish_reshape);
2230dfe4
N		 7893
7894/* Bad block management.
7895 * We can record which blocks on each device are 'bad' and so just
7896 * fail those blocks, or that stripe, rather than the whole device.
7897 * Entries in the bad-block table are 64bits wide. This comprises:
7898 * Length of bad-range, in sectors: 0-511 for lengths 1-512
7899 * Start of bad-range, sector offset, 54 bits (allows 8 exbibytes)
7900 * A 'shift' can be set so that larger blocks are tracked and
7901 * consequently larger devices can be covered.
7902 * 'Acknowledged' flag - 1 bit. - the most significant bit.
7903 *
7904 * Locking of the bad-block table uses a seqlock so md_is_badblock
7905 * might need to retry if it is very unlucky.
7906 * We will sometimes want to check for bad blocks in a bi_end_io function,
7907 * so we use the write_seqlock_irq variant.
7908 *
7909 * When looking for a bad block we specify a range and want to
7910 * know if any block in the range is bad. So we binary-search
7911 * to the last range that starts at-or-before the given endpoint,
7912 * (or "before the sector after the target range")
7913 * then see if it ends after the given start.
7914 * We return
7915 * 0 if there are no known bad blocks in the range
7916 * 1 if there are known bad block which are all acknowledged
7917 * -1 if there are bad blocks which have not yet been acknowledged in metadata.
7918 * plus the start/length of the first bad section we overlap.
7919 */
7920int md_is_badblock(struct badblocks *bb, sector_t s, int sectors,
7921 sector_t *first_bad, int *bad_sectors)
7922{
7923 int hi;
7924 int lo = 0;
7925 u64 *p = bb->page;
7926 int rv = 0;
7927 sector_t target = s + sectors;
7928 unsigned seq;
7929
7930 if (bb->shift > 0) {
7931 /* round the start down, and the end up */
7932 s >>= bb->shift;
7933 target += (1<<bb->shift) - 1;
7934 target >>= bb->shift;
7935 sectors = target - s;
7936 }
7937 /* 'target' is now the first block after the bad range */
7938
7939retry:
7940 seq = read_seqbegin(&bb->lock);
7941
7942 hi = bb->count;
7943
7944 /* Binary search between lo and hi for 'target'
7945 * i.e. for the last range that starts before 'target'
7946 */
7947 /* INVARIANT: ranges before 'lo' and at-or-after 'hi'
7948 * are known not to be the last range before target.
7949 * VARIANT: hi-lo is the number of possible
7950 * ranges, and decreases until it reaches 1
7951 */
7952 while (hi - lo > 1) {
7953 int mid = (lo + hi) / 2;
7954 sector_t a = BB_OFFSET(p[mid]);
7955 if (a < target)
7956 /* This could still be the one, earlier ranges
7957 * could not. */
7958 lo = mid;
7959 else
7960 /* This and later ranges are definitely out. */
7961 hi = mid;
7962 }
7963 /* 'lo' might be the last that started before target, but 'hi' isn't */
7964 if (hi > lo) {
7965 /* need to check all range that end after 's' to see if
7966 * any are unacknowledged.
7967 */
7968 while (lo >= 0 &&
7969 BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > s) {
7970 if (BB_OFFSET(p[lo]) < target) {
7971 /* starts before the end, and finishes after
7972 * the start, so they must overlap
7973 */
7974 if (rv != -1 && BB_ACK(p[lo]))
7975 rv = 1;
7976 else
7977 rv = -1;
7978 *first_bad = BB_OFFSET(p[lo]);
7979 *bad_sectors = BB_LEN(p[lo]);
7980 }
7981 lo--;
7982 }
7983 }
7984
7985 if (read_seqretry(&bb->lock, seq))
7986 goto retry;
7987
7988 return rv;
7989}
7990EXPORT_SYMBOL_GPL(md_is_badblock);
7991
7992/*
7993 * Add a range of bad blocks to the table.
7994 * This might extend the table, or might contract it
7995 * if two adjacent ranges can be merged.
7996 * We binary-search to find the 'insertion' point, then
7997 * decide how best to handle it.
7998 */
7999static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
8000 int acknowledged)
8001{
8002 u64 *p;
8003 int lo, hi;
8004 int rv = 1;
8005
8006 if (bb->shift < 0)
8007 /* badblocks are disabled */
8008 return 0;
8009
8010 if (bb->shift) {
8011 /* round the start down, and the end up */
8012 sector_t next = s + sectors;
8013 s >>= bb->shift;
8014 next += (1<<bb->shift) - 1;
8015 next >>= bb->shift;
8016 sectors = next - s;
8017 }
8018
8019 write_seqlock_irq(&bb->lock);
8020
8021 p = bb->page;
8022 lo = 0;
8023 hi = bb->count;
8024 /* Find the last range that starts at-or-before 's' */
8025 while (hi - lo > 1) {
8026 int mid = (lo + hi) / 2;
8027 sector_t a = BB_OFFSET(p[mid]);
8028 if (a <= s)
8029 lo = mid;
8030 else
8031 hi = mid;
8032 }
8033 if (hi > lo && BB_OFFSET(p[lo]) > s)
8034 hi = lo;
8035
8036 if (hi > lo) {
8037 /* we found a range that might merge with the start
8038 * of our new range
8039 */
8040 sector_t a = BB_OFFSET(p[lo]);
8041 sector_t e = a + BB_LEN(p[lo]);
8042 int ack = BB_ACK(p[lo]);
8043 if (e >= s) {
8044 /* Yes, we can merge with a previous range */
8045 if (s == a && s + sectors >= e)
8046 /* new range covers old */
8047 ack = acknowledged;
8048 else
8049 ack = ack && acknowledged;
8050
8051 if (e < s + sectors)
8052 e = s + sectors;
8053 if (e - a <= BB_MAX_LEN) {
8054 p[lo] = BB_MAKE(a, e-a, ack);
8055 s = e;
8056 } else {
8057 /* does not all fit in one range,
8058 * make p[lo] maximal
8059 */
8060 if (BB_LEN(p[lo]) != BB_MAX_LEN)
8061 p[lo] = BB_MAKE(a, BB_MAX_LEN, ack);
8062 s = a + BB_MAX_LEN;
8063 }
8064 sectors = e - s;
8065 }
8066 }
8067 if (sectors && hi < bb->count) {
8068 /* 'hi' points to the first range that starts after 's'.
8069 * Maybe we can merge with the start of that range */
8070 sector_t a = BB_OFFSET(p[hi]);
8071 sector_t e = a + BB_LEN(p[hi]);
8072 int ack = BB_ACK(p[hi]);
8073 if (a <= s + sectors) {
8074 /* merging is possible */
8075 if (e <= s + sectors) {
8076 /* full overlap */
8077 e = s + sectors;
8078 ack = acknowledged;
8079 } else
8080 ack = ack && acknowledged;
8081
8082 a = s;
8083 if (e - a <= BB_MAX_LEN) {
8084 p[hi] = BB_MAKE(a, e-a, ack);
8085 s = e;
8086 } else {
8087 p[hi] = BB_MAKE(a, BB_MAX_LEN, ack);
8088 s = a + BB_MAX_LEN;
8089 }
8090 sectors = e - s;
8091 lo = hi;
8092 hi++;
8093 }
8094 }
8095 if (sectors == 0 && hi < bb->count) {
8096 /* we might be able to combine lo and hi */
8097 /* Note: 's' is at the end of 'lo' */
8098 sector_t a = BB_OFFSET(p[hi]);
8099 int lolen = BB_LEN(p[lo]);
8100 int hilen = BB_LEN(p[hi]);
8101 int newlen = lolen + hilen - (s - a);
8102 if (s >= a && newlen < BB_MAX_LEN) {
8103 /* yes, we can combine them */
8104 int ack = BB_ACK(p[lo]) && BB_ACK(p[hi]);
8105 p[lo] = BB_MAKE(BB_OFFSET(p[lo]), newlen, ack);
8106 memmove(p + hi, p + hi + 1,
8107 (bb->count - hi - 1) * 8);
8108 bb->count--;
8109 }
8110 }
8111 while (sectors) {
8112 /* didn't merge (it all).
8113 * Need to add a range just before 'hi' */
8114 if (bb->count >= MD_MAX_BADBLOCKS) {
8115 /* No room for more */
8116 rv = 0;
8117 break;
8118 } else {
8119 int this_sectors = sectors;
8120 memmove(p + hi + 1, p + hi,
8121 (bb->count - hi) * 8);
8122 bb->count++;
8123
8124 if (this_sectors > BB_MAX_LEN)
8125 this_sectors = BB_MAX_LEN;
8126 p[hi] = BB_MAKE(s, this_sectors, acknowledged);
8127 sectors -= this_sectors;
8128 s += this_sectors;
8129 }
8130 }
8131
8132 bb->changed = 1;
de393cde
N		 8133 if (!acknowledged)
8134 bb->unacked_exist = 1;
2230dfe4
N		 8135 write_sequnlock_irq(&bb->lock);
8136
8137 return rv;
8138}
8139
3cb03002 8140int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
c6563a8c 8141 int is_new)
2230dfe4 8142{
c6563a8c
N		 8143 int rv;
8144 if (is_new)
8145 s += rdev->new_data_offset;
8146 else
8147 s += rdev->data_offset;
8148 rv = md_set_badblocks(&rdev->badblocks,
8149 s, sectors, 0);
2230dfe4
N		 8150 if (rv) {
8151 /* Make sure they get written out promptly */
8bd2f0a0 8152 sysfs_notify_dirent_safe(rdev->sysfs_state);
2230dfe4
N		 8153 set_bit(MD_CHANGE_CLEAN, &rdev->mddev->flags);
8154 md_wakeup_thread(rdev->mddev->thread);
8155 }
8156 return rv;
8157}
8158EXPORT_SYMBOL_GPL(rdev_set_badblocks);
8159
8160/*
8161 * Remove a range of bad blocks from the table.
8162 * This may involve extending the table if we spilt a region,
8163 * but it must not fail. So if the table becomes full, we just
8164 * drop the remove request.
8165 */
8166static int md_clear_badblocks(struct badblocks *bb, sector_t s, int sectors)
8167{
8168 u64 *p;
8169 int lo, hi;
8170 sector_t target = s + sectors;
8171 int rv = 0;
8172
8173 if (bb->shift > 0) {
8174 /* When clearing we round the start up and the end down.
8175 * This should not matter as the shift should align with
8176 * the block size and no rounding should ever be needed.
8177 * However it is better the think a block is bad when it
8178 * isn't than to think a block is not bad when it is.
8179 */
8180 s += (1<<bb->shift) - 1;
8181 s >>= bb->shift;
8182 target >>= bb->shift;
8183 sectors = target - s;
8184 }
8185
8186 write_seqlock_irq(&bb->lock);
8187
8188 p = bb->page;
8189 lo = 0;
8190 hi = bb->count;
8191 /* Find the last range that starts before 'target' */
8192 while (hi - lo > 1) {
8193 int mid = (lo + hi) / 2;
8194 sector_t a = BB_OFFSET(p[mid]);
8195 if (a < target)
8196 lo = mid;
8197 else
8198 hi = mid;
8199 }
8200 if (hi > lo) {
8201 /* p[lo] is the last range that could overlap the
8202 * current range. Earlier ranges could also overlap,
8203 * but only this one can overlap the end of the range.
8204 */
8205 if (BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > target) {
8206 /* Partial overlap, leave the tail of this range */
8207 int ack = BB_ACK(p[lo]);
8208 sector_t a = BB_OFFSET(p[lo]);
8209 sector_t end = a + BB_LEN(p[lo]);
8210
8211 if (a < s) {
8212 /* we need to split this range */
8213 if (bb->count >= MD_MAX_BADBLOCKS) {
8214 rv = 0;
8215 goto out;
8216 }
8217 memmove(p+lo+1, p+lo, (bb->count - lo) * 8);
8218 bb->count++;
8219 p[lo] = BB_MAKE(a, s-a, ack);
8220 lo++;
8221 }
8222 p[lo] = BB_MAKE(target, end - target, ack);
8223 /* there is no longer an overlap */
8224 hi = lo;
8225 lo--;
8226 }
8227 while (lo >= 0 &&
8228 BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > s) {
8229 /* This range does overlap */
8230 if (BB_OFFSET(p[lo]) < s) {
8231 /* Keep the early parts of this range. */
8232 int ack = BB_ACK(p[lo]);
8233 sector_t start = BB_OFFSET(p[lo]);
8234 p[lo] = BB_MAKE(start, s - start, ack);
8235 /* now low doesn't overlap, so.. */
8236 break;
8237 }
8238 lo--;
8239 }
8240 /* 'lo' is strictly before, 'hi' is strictly after,
8241 * anything between needs to be discarded
8242 */
8243 if (hi - lo > 1) {
8244 memmove(p+lo+1, p+hi, (bb->count - hi) * 8);
8245 bb->count -= (hi - lo - 1);
8246 }
8247 }
8248
8249 bb->changed = 1;
8250out:
8251 write_sequnlock_irq(&bb->lock);
8252 return rv;
8253}
8254
c6563a8c
N		 8255int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
8256 int is_new)
2230dfe4 8257{
c6563a8c
N		 8258 if (is_new)
8259 s += rdev->new_data_offset;
8260 else
8261 s += rdev->data_offset;
2230dfe4 8262 return md_clear_badblocks(&rdev->badblocks,
c6563a8c 8263 s, sectors);
2230dfe4
N		 8264}
8265EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
8266
8267/*
8268 * Acknowledge all bad blocks in a list.
8269 * This only succeeds if ->changed is clear. It is used by
8270 * in-kernel metadata updates
8271 */
8272void md_ack_all_badblocks(struct badblocks *bb)
8273{
8274 if (bb->page == NULL || bb->changed)
8275 /* no point even trying */
8276 return;
8277 write_seqlock_irq(&bb->lock);
8278
ecb178bb 8279 if (bb->changed == 0 && bb->unacked_exist) {
2230dfe4
N		 8280 u64 *p = bb->page;
8281 int i;
8282 for (i = 0; i < bb->count ; i++) {
8283 if (!BB_ACK(p[i])) {
8284 sector_t start = BB_OFFSET(p[i]);
8285 int len = BB_LEN(p[i]);
8286 p[i] = BB_MAKE(start, len, 1);
8287 }
8288 }
de393cde 8289 bb->unacked_exist = 0;
2230dfe4
N		 8290 }
8291 write_sequnlock_irq(&bb->lock);
8292}
8293EXPORT_SYMBOL_GPL(md_ack_all_badblocks);
8294
16c791a5
N		 8295/* sysfs access to bad-blocks list.
8296 * We present two files.
8297 * 'bad-blocks' lists sector numbers and lengths of ranges that
8298 * are recorded as bad. The list is truncated to fit within
8299 * the one-page limit of sysfs.
8300 * Writing "sector length" to this file adds an acknowledged
8301 * bad block list.
8302 * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
8303 * been acknowledged. Writing to this file adds bad blocks
8304 * without acknowledging them. This is largely for testing.
8305 */
8306
8307static ssize_t
8308badblocks_show(struct badblocks *bb, char *page, int unack)
8309{
8310 size_t len;
8311 int i;
8312 u64 *p = bb->page;
8313 unsigned seq;
8314
8315 if (bb->shift < 0)
8316 return 0;
8317
8318retry:
8319 seq = read_seqbegin(&bb->lock);
8320
8321 len = 0;
8322 i = 0;
8323
8324 while (len < PAGE_SIZE && i < bb->count) {
8325 sector_t s = BB_OFFSET(p[i]);
8326 unsigned int length = BB_LEN(p[i]);
8327 int ack = BB_ACK(p[i]);
8328 i++;
8329
8330 if (unack && ack)
8331 continue;
8332
8333 len += snprintf(page+len, PAGE_SIZE-len, "%llu %u\n",
8334 (unsigned long long)s << bb->shift,
8335 length << bb->shift);
8336 }
de393cde
N		 8337 if (unack && len == 0)
8338 bb->unacked_exist = 0;
16c791a5
N		 8339
8340 if (read_seqretry(&bb->lock, seq))
8341 goto retry;
8342
8343 return len;
8344}
8345
8346#define DO_DEBUG 1
8347
8348static ssize_t
8349badblocks_store(struct badblocks *bb, const char *page, size_t len, int unack)
8350{
8351 unsigned long long sector;
8352 int length;
8353 char newline;
8354#ifdef DO_DEBUG
8355 /* Allow clearing via sysfs *only* for testing/debugging.
8356 * Normally only a successful write may clear a badblock
8357 */
8358 int clear = 0;
8359 if (page[0] == '-') {
8360 clear = 1;
8361 page++;
8362 }
8363#endif /* DO_DEBUG */
8364
8365 switch (sscanf(page, "%llu %d%c", &sector, &length, &newline)) {
8366 case 3:
8367 if (newline != '\n')
8368 return -EINVAL;
8369 case 2:
8370 if (length <= 0)
8371 return -EINVAL;
8372 break;
8373 default:
8374 return -EINVAL;
8375 }
8376
8377#ifdef DO_DEBUG
8378 if (clear) {
8379 md_clear_badblocks(bb, sector, length);
8380 return len;
8381 }
8382#endif /* DO_DEBUG */
8383 if (md_set_badblocks(bb, sector, length, !unack))
8384 return len;
8385 else
8386 return -ENOSPC;
8387}
8388
75c96f85
AB		 8389static int md_notify_reboot(struct notifier_block *this,
8390 unsigned long code, void *x)
1da177e4
LT		 8391{
8392 struct list_head *tmp;
fd01b88c 8393 struct mddev *mddev;
2dba6a91 8394 int need_delay = 0;
1da177e4 8395
c744a65c
N		 8396 for_each_mddev(mddev, tmp) {
8397 if (mddev_trylock(mddev)) {
30b8aa91
N		 8398 if (mddev->pers)
8399 __md_stop_writes(mddev);
c744a65c
N		 8400 mddev->safemode = 2;
8401 mddev_unlock(mddev);
2dba6a91 8402 }
c744a65c 8403 need_delay = 1;
1da177e4 8404 }
c744a65c
N		 8405 /*
8406 * certain more exotic SCSI devices are known to be
8407 * volatile wrt too early system reboots. While the
8408 * right place to handle this issue is the given
8409 * driver, we do want to have a safe RAID driver ...
8410 */
8411 if (need_delay)
8412 mdelay(1000*1);
8413
1da177e4
LT		 8414 return NOTIFY_DONE;
8415}
8416
75c96f85 8417static struct notifier_block md_notifier = {
1da177e4
LT		 8418 .notifier_call = md_notify_reboot,
8419 .next = NULL,
8420 .priority = INT_MAX, /* before any real devices */
8421};
8422
8423static void md_geninit(void)
8424{
36a4e1fe 8425 pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
1da177e4 8426
c7705f34 8427 proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
1da177e4
LT		 8428}
8429
75c96f85 8430static int __init md_init(void)
1da177e4 8431{
e804ac78
TH		 8432 int ret = -ENOMEM;
8433
ada609ee 8434 md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
e804ac78
TH		 8435 if (!md_wq)
8436 goto err_wq;
8437
8438 md_misc_wq = alloc_workqueue("md_misc", 0, 0);
8439 if (!md_misc_wq)
8440 goto err_misc_wq;
8441
8442 if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
8443 goto err_md;
8444
8445 if ((ret = register_blkdev(0, "mdp")) < 0)
8446 goto err_mdp;
8447 mdp_major = ret;
8448
3dbd8c2e 8449 blk_register_region(MKDEV(MD_MAJOR, 0), 1UL<<MINORBITS, THIS_MODULE,
e8703fe1
N		 8450 md_probe, NULL, NULL);
8451 blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
1da177e4
LT		 8452 md_probe, NULL, NULL);
8453
1da177e4 8454 register_reboot_notifier(&md_notifier);
0b4d4147 8455 raid_table_header = register_sysctl_table(raid_root_table);
1da177e4
LT		 8456
8457 md_geninit();
d710e138 8458 return 0;
1da177e4 8459
e804ac78
TH		 8460err_mdp:
8461 unregister_blkdev(MD_MAJOR, "md");
8462err_md:
8463 destroy_workqueue(md_misc_wq);
8464err_misc_wq:
8465 destroy_workqueue(md_wq);
8466err_wq:
8467 return ret;
8468}
1da177e4
LT		 8469
8470#ifndef MODULE
8471
8472/*
8473 * Searches all registered partitions for autorun RAID arrays
8474 * at boot time.
8475 */
4d936ec1
ME		 8476
8477static LIST_HEAD(all_detected_devices);
8478struct detected_devices_node {
8479 struct list_head list;
8480 dev_t dev;
8481};
1da177e4
LT		 8482
8483void md_autodetect_dev(dev_t dev)
8484{
4d936ec1
ME		 8485 struct detected_devices_node *node_detected_dev;
8486
8487 node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
8488 if (node_detected_dev) {
8489 node_detected_dev->dev = dev;
8490 list_add_tail(&node_detected_dev->list, &all_detected_devices);
8491 } else {
8492 printk(KERN_CRIT "md: md_autodetect_dev: kzalloc failed"
8493 ", skipping dev(%d,%d)\n", MAJOR(dev), MINOR(dev));
8494 }
1da177e4
LT		 8495}
8496
8497
8498static void autostart_arrays(int part)
8499{
3cb03002 8500 struct md_rdev *rdev;
4d936ec1
ME		 8501 struct detected_devices_node *node_detected_dev;
8502 dev_t dev;
8503 int i_scanned, i_passed;
1da177e4 8504
4d936ec1
ME		 8505 i_scanned = 0;
8506 i_passed = 0;
1da177e4 8507
4d936ec1 8508 printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
1da177e4 8509
4d936ec1
ME		 8510 while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
8511 i_scanned++;
8512 node_detected_dev = list_entry(all_detected_devices.next,
8513 struct detected_devices_node, list);
8514 list_del(&node_detected_dev->list);
8515 dev = node_detected_dev->dev;
8516 kfree(node_detected_dev);
df968c4e 8517 rdev = md_import_device(dev,0, 90);
1da177e4
LT		 8518 if (IS_ERR(rdev))
8519 continue;
8520
b2d444d7 8521 if (test_bit(Faulty, &rdev->flags)) {
1da177e4
LT		 8522 MD_BUG();
8523 continue;
8524 }
d0fae18f 8525 set_bit(AutoDetected, &rdev->flags);
1da177e4 8526 list_add(&rdev->same_set, &pending_raid_disks);
4d936ec1 8527 i_passed++;
1da177e4 8528 }
4d936ec1
ME		 8529
8530 printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
8531 i_scanned, i_passed);
1da177e4
LT		 8532
8533 autorun_devices(part);
8534}
8535
fdee8ae4 8536#endif /* !MODULE */
1da177e4
LT		 8537
8538static __exit void md_exit(void)
8539{
fd01b88c 8540 struct mddev *mddev;
1da177e4 8541 struct list_head *tmp;
8ab5e4c1 8542
3dbd8c2e 8543 blk_unregister_region(MKDEV(MD_MAJOR,0), 1U << MINORBITS);
e8703fe1 8544 blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
1da177e4 8545
3dbd8c2e 8546 unregister_blkdev(MD_MAJOR,"md");
1da177e4
LT		 8547 unregister_blkdev(mdp_major, "mdp");
8548 unregister_reboot_notifier(&md_notifier);
8549 unregister_sysctl_table(raid_table_header);
8550 remove_proc_entry("mdstat", NULL);
29ac4aa3 8551 for_each_mddev(mddev, tmp) {
1da177e4 8552 export_array(mddev);
d3374825 8553 mddev->hold_active = 0;
1da177e4 8554 }
e804ac78
TH		 8555 destroy_workqueue(md_misc_wq);
8556 destroy_workqueue(md_wq);
1da177e4
LT		 8557}
8558
685784aa 8559subsys_initcall(md_init);
1da177e4
LT		 8560module_exit(md_exit)
8561
f91de92e
N		 8562static int get_ro(char *buffer, struct kernel_param *kp)
8563{
8564 return sprintf(buffer, "%d", start_readonly);
8565}
8566static int set_ro(const char *val, struct kernel_param *kp)
8567{
8568 char *e;
8569 int num = simple_strtoul(val, &e, 10);
8570 if (*val && (*e == '\0' || *e == '\n')) {
8571 start_readonly = num;
4dbcdc75 8572 return 0;
f91de92e
N		 8573 }
8574 return -EINVAL;
8575}
8576
80ca3a44
N		 8577module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
8578module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
6ff8d8ec 8579
efeb53c0 8580module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
f91de92e 8581
1da177e4
LT		 8582EXPORT_SYMBOL(register_md_personality);
8583EXPORT_SYMBOL(unregister_md_personality);
8584EXPORT_SYMBOL(md_error);
8585EXPORT_SYMBOL(md_done_sync);
8586EXPORT_SYMBOL(md_write_start);
8587EXPORT_SYMBOL(md_write_end);
1da177e4
LT		 8588EXPORT_SYMBOL(md_register_thread);
8589EXPORT_SYMBOL(md_unregister_thread);
8590EXPORT_SYMBOL(md_wakeup_thread);
1da177e4
LT		 8591EXPORT_SYMBOL(md_check_recovery);
8592MODULE_LICENSE("GPL");
0efb9e61 8593MODULE_DESCRIPTION("MD RAID framework");
aa1595e9 8594MODULE_ALIAS("md");
72008652 8595MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);
kernel source for telekom puls (alcatel/mediatek)