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