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