blob: 1a7b3f088fd47e8babb5e06d219e147f6ef90fc0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 md.c : Multiple Devices driver for Linux
NeilBrownf72ffdd2014-09-30 14:23:59 +10003 Copyright (C) 1998, 1999, 2000 Ingo Molnar
Linus Torvalds1da177e2005-04-16 15:20:36 -07004
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
NeilBrown32a76272005-06-21 17:17:14 -070022 - persistent bitmap code
23 Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
24
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 This program is free software; you can redistribute it and/or modify
26 it under the terms of the GNU General Public License as published by
27 the Free Software Foundation; either version 2, or (at your option)
28 any later version.
29
30 You should have received a copy of the GNU General Public License
31 (for example /usr/src/linux/COPYING); if not, write to the Free
32 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33*/
34
NeilBrowna6fb0932005-09-09 16:23:56 -070035#include <linux/kthread.h>
NeilBrownbff61972009-03-31 14:33:13 +110036#include <linux/blkdev.h>
Vishal Vermafc974ee2015-12-24 19:20:34 -070037#include <linux/badblocks.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/sysctl.h>
NeilBrownbff61972009-03-31 14:33:13 +110039#include <linux/seq_file.h>
Al Viroff01bb482011-09-16 02:31:11 -040040#include <linux/fs.h>
NeilBrownd7603b72006-01-06 00:20:30 -080041#include <linux/poll.h>
NeilBrown16f17b32006-06-26 00:27:37 -070042#include <linux/ctype.h>
André Goddard Rosae7d28602009-12-14 18:01:06 -080043#include <linux/string.h>
NeilBrownfb4d8c72008-10-13 11:55:12 +110044#include <linux/hdreg.h>
45#include <linux/proc_fs.h>
46#include <linux/random.h>
Paul Gortmaker056075c2011-07-03 13:58:33 -040047#include <linux/module.h>
NeilBrownfb4d8c72008-10-13 11:55:12 +110048#include <linux/reboot.h>
NeilBrown32a76272005-06-21 17:17:14 -070049#include <linux/file.h>
Arnd Bergmannaa98aa32009-12-14 12:50:05 +110050#include <linux/compat.h>
Stephen Rothwell25570722008-10-15 09:09:21 +110051#include <linux/delay.h>
NeilBrownbff61972009-03-31 14:33:13 +110052#include <linux/raid/md_p.h>
53#include <linux/raid/md_u.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090054#include <linux/slab.h>
NeilBrown43b2e5d2009-03-31 14:33:13 +110055#include "md.h"
Christoph Hellwigef740c32009-03-31 14:27:03 +110056#include "bitmap.h"
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -050057#include "md-cluster.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#ifndef MODULE
NeilBrownd710e132008-10-13 11:55:12 +110060static void autostart_arrays(int part);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#endif
62
NeilBrown01f96c02011-09-21 15:30:20 +100063/* pers_list is a list of registered personalities protected
64 * by pers_lock.
65 * pers_lock does extra service to protect accesses to
66 * mddev->thread when the mutex cannot be held.
67 */
NeilBrown2604b702006-01-06 00:20:36 -080068static LIST_HEAD(pers_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069static DEFINE_SPINLOCK(pers_lock);
70
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -050071struct md_cluster_operations *md_cluster_ops;
Goldwyn Rodrigues589a1c42014-06-07 02:39:37 -050072EXPORT_SYMBOL(md_cluster_ops);
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -050073struct module *md_cluster_mod;
74EXPORT_SYMBOL(md_cluster_mod);
75
Bernd Schubert90b08712008-05-23 13:04:38 -070076static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
Tejun Heoe804ac72010-10-15 15:36:08 +020077static struct workqueue_struct *md_wq;
78static struct workqueue_struct *md_misc_wq;
Bernd Schubert90b08712008-05-23 13:04:38 -070079
NeilBrown746d3202013-04-24 11:42:41 +100080static int remove_and_add_spares(struct mddev *mddev,
81 struct md_rdev *this);
NeilBrown5aa61f42014-12-15 12:56:57 +110082static void mddev_detach(struct mddev *mddev);
NeilBrown746d3202013-04-24 11:42:41 +100083
Linus Torvalds1da177e2005-04-16 15:20:36 -070084/*
Robert Becker1e509152009-12-14 12:49:58 +110085 * Default number of read corrections we'll attempt on an rdev
86 * before ejecting it from the array. We divide the read error
87 * count by 2 for every hour elapsed between read errors.
88 */
89#define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
90/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
92 * is 1000 KB/sec, so the extra system load does not show up that much.
93 * Increase it if you want to have more _guaranteed_ speed. Note that
Adrian Bunk338cec32005-09-10 00:26:54 -070094 * the RAID driver will use the maximum available bandwidth if the IO
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 * subsystem is idle. There is also an 'absolute maximum' reconstruction
96 * speed limit - in case reconstruction slows down your system despite
97 * idle IO detection.
98 *
99 * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
NeilBrown88202a02006-01-06 00:21:36 -0800100 * or /sys/block/mdX/md/sync_speed_{min,max}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 */
102
103static int sysctl_speed_limit_min = 1000;
104static int sysctl_speed_limit_max = 200000;
NeilBrownfd01b882011-10-11 16:47:53 +1100105static inline int speed_min(struct mddev *mddev)
NeilBrown88202a02006-01-06 00:21:36 -0800106{
107 return mddev->sync_speed_min ?
108 mddev->sync_speed_min : sysctl_speed_limit_min;
109}
110
NeilBrownfd01b882011-10-11 16:47:53 +1100111static inline int speed_max(struct mddev *mddev)
NeilBrown88202a02006-01-06 00:21:36 -0800112{
113 return mddev->sync_speed_max ?
114 mddev->sync_speed_max : sysctl_speed_limit_max;
115}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
117static struct ctl_table_header *raid_table_header;
118
Joe Perches82592c32013-11-14 15:16:18 +1100119static struct ctl_table raid_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 .procname = "speed_limit_min",
122 .data = &sysctl_speed_limit_min,
123 .maxlen = sizeof(int),
NeilBrown80ca3a42006-07-10 04:44:18 -0700124 .mode = S_IRUGO|S_IWUSR,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800125 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 },
127 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 .procname = "speed_limit_max",
129 .data = &sysctl_speed_limit_max,
130 .maxlen = sizeof(int),
NeilBrown80ca3a42006-07-10 04:44:18 -0700131 .mode = S_IRUGO|S_IWUSR,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800132 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 },
Eric W. Biederman894d2492009-11-05 14:34:02 -0800134 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135};
136
Joe Perches82592c32013-11-14 15:16:18 +1100137static struct ctl_table raid_dir_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 .procname = "raid",
140 .maxlen = 0,
NeilBrown80ca3a42006-07-10 04:44:18 -0700141 .mode = S_IRUGO|S_IXUGO,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 .child = raid_table,
143 },
Eric W. Biederman894d2492009-11-05 14:34:02 -0800144 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145};
146
Joe Perches82592c32013-11-14 15:16:18 +1100147static struct ctl_table raid_root_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 .procname = "dev",
150 .maxlen = 0,
151 .mode = 0555,
152 .child = raid_dir_table,
153 },
Eric W. Biederman894d2492009-11-05 14:34:02 -0800154 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155};
156
Alexey Dobriyan83d5cde2009-09-21 17:01:13 -0700157static const struct block_device_operations md_fops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
NeilBrownf91de922005-11-08 21:39:36 -0800159static int start_readonly;
160
NeilBrowna167f662010-10-26 18:31:13 +1100161/* bio_clone_mddev
162 * like bio_clone, but with a local bio set
163 */
164
NeilBrowna167f662010-10-26 18:31:13 +1100165struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
NeilBrownfd01b882011-10-11 16:47:53 +1100166 struct mddev *mddev)
NeilBrowna167f662010-10-26 18:31:13 +1100167{
168 struct bio *b;
NeilBrowna167f662010-10-26 18:31:13 +1100169
170 if (!mddev || !mddev->bio_set)
171 return bio_alloc(gfp_mask, nr_iovecs);
172
Kent Overstreet395c72a2012-09-06 15:34:55 -0700173 b = bio_alloc_bioset(gfp_mask, nr_iovecs, mddev->bio_set);
NeilBrowna167f662010-10-26 18:31:13 +1100174 if (!b)
175 return NULL;
NeilBrowna167f662010-10-26 18:31:13 +1100176 return b;
177}
178EXPORT_SYMBOL_GPL(bio_alloc_mddev);
179
180struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
NeilBrownfd01b882011-10-11 16:47:53 +1100181 struct mddev *mddev)
NeilBrowna167f662010-10-26 18:31:13 +1100182{
NeilBrowna167f662010-10-26 18:31:13 +1100183 if (!mddev || !mddev->bio_set)
184 return bio_clone(bio, gfp_mask);
185
Kent Overstreetbf800ef2012-09-06 15:35:02 -0700186 return bio_clone_bioset(bio, gfp_mask, mddev->bio_set);
NeilBrowna167f662010-10-26 18:31:13 +1100187}
188EXPORT_SYMBOL_GPL(bio_clone_mddev);
189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190/*
NeilBrownd7603b72006-01-06 00:20:30 -0800191 * We have a system wide 'event count' that is incremented
192 * on any 'interesting' event, and readers of /proc/mdstat
193 * can use 'poll' or 'select' to find out when the event
194 * count increases.
195 *
196 * Events are:
197 * start array, stop array, error, add device, remove device,
198 * start build, activate spare
199 */
NeilBrown2989ddb2006-01-06 00:20:43 -0800200static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
NeilBrownd7603b72006-01-06 00:20:30 -0800201static atomic_t md_event_count;
NeilBrownfd01b882011-10-11 16:47:53 +1100202void md_new_event(struct mddev *mddev)
NeilBrownd7603b72006-01-06 00:20:30 -0800203{
204 atomic_inc(&md_event_count);
205 wake_up(&md_event_waiters);
206}
NeilBrown29269552006-03-27 01:18:10 -0800207EXPORT_SYMBOL_GPL(md_new_event);
NeilBrownd7603b72006-01-06 00:20:30 -0800208
209/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 * Enables to iterate over all existing md arrays
211 * all_mddevs_lock protects this list.
212 */
213static LIST_HEAD(all_mddevs);
214static DEFINE_SPINLOCK(all_mddevs_lock);
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216/*
217 * iterates through all used mddevs in the system.
218 * We take care to grab the all_mddevs_lock whenever navigating
219 * the list, and to always hold a refcount when unlocked.
220 * Any code which breaks out of this loop while own
221 * a reference to the current mddev and must mddev_put it.
222 */
NeilBrownfd01b882011-10-11 16:47:53 +1100223#define for_each_mddev(_mddev,_tmp) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 \
NeilBrownf72ffdd2014-09-30 14:23:59 +1000225 for (({ spin_lock(&all_mddevs_lock); \
NeilBrownfd01b882011-10-11 16:47:53 +1100226 _tmp = all_mddevs.next; \
227 _mddev = NULL;}); \
228 ({ if (_tmp != &all_mddevs) \
229 mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 spin_unlock(&all_mddevs_lock); \
NeilBrownfd01b882011-10-11 16:47:53 +1100231 if (_mddev) mddev_put(_mddev); \
232 _mddev = list_entry(_tmp, struct mddev, all_mddevs); \
233 _tmp != &all_mddevs;}); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 ({ spin_lock(&all_mddevs_lock); \
NeilBrownfd01b882011-10-11 16:47:53 +1100235 _tmp = _tmp->next;}) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 )
237
NeilBrown409c57f2009-03-31 14:39:39 +1100238/* Rather than calling directly into the personality make_request function,
239 * IO requests come here first so that we can check if the device is
240 * being suspended pending a reconfiguration.
241 * We hold a refcount over the call to ->make_request. By the time that
242 * call has finished, the bio has been linked into some internal structure
243 * and so is visible to ->quiesce(), so we don't need the refcount any more.
244 */
Jens Axboedece1632015-11-05 10:41:16 -0700245static blk_qc_t md_make_request(struct request_queue *q, struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246{
NeilBrown49077322010-03-25 16:20:56 +1100247 const int rw = bio_data_dir(bio);
NeilBrownfd01b882011-10-11 16:47:53 +1100248 struct mddev *mddev = q->queuedata;
Chris Masone91ece52011-02-07 19:21:48 -0500249 unsigned int sectors;
Gu Zheng74672d02015-04-03 08:44:47 +0800250 int cpu;
NeilBrown49077322010-03-25 16:20:56 +1100251
Kent Overstreet54efd502015-04-23 22:37:18 -0700252 blk_queue_split(q, &bio, q->bio_split);
253
NeilBrown274d8cb2016-01-04 16:16:58 +1100254 if (mddev == NULL || mddev->pers == NULL) {
NeilBrown409c57f2009-03-31 14:39:39 +1100255 bio_io_error(bio);
Jens Axboedece1632015-11-05 10:41:16 -0700256 return BLK_QC_T_NONE;
NeilBrown409c57f2009-03-31 14:39:39 +1100257 }
Sebastian Riemerbbfa57c2013-02-21 13:28:09 +1100258 if (mddev->ro == 1 && unlikely(rw == WRITE)) {
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200259 if (bio_sectors(bio) != 0)
260 bio->bi_error = -EROFS;
261 bio_endio(bio);
Jens Axboedece1632015-11-05 10:41:16 -0700262 return BLK_QC_T_NONE;
Sebastian Riemerbbfa57c2013-02-21 13:28:09 +1100263 }
NeilBrown0ca69882011-01-14 09:14:33 +1100264 smp_rmb(); /* Ensure implications of 'active' are visible */
NeilBrown409c57f2009-03-31 14:39:39 +1100265 rcu_read_lock();
Tejun Heoe9c74692010-09-03 11:56:18 +0200266 if (mddev->suspended) {
NeilBrown409c57f2009-03-31 14:39:39 +1100267 DEFINE_WAIT(__wait);
268 for (;;) {
269 prepare_to_wait(&mddev->sb_wait, &__wait,
270 TASK_UNINTERRUPTIBLE);
Tejun Heoe9c74692010-09-03 11:56:18 +0200271 if (!mddev->suspended)
NeilBrown409c57f2009-03-31 14:39:39 +1100272 break;
273 rcu_read_unlock();
274 schedule();
275 rcu_read_lock();
276 }
277 finish_wait(&mddev->sb_wait, &__wait);
278 }
279 atomic_inc(&mddev->active_io);
280 rcu_read_unlock();
NeilBrown49077322010-03-25 16:20:56 +1100281
Chris Masone91ece52011-02-07 19:21:48 -0500282 /*
283 * save the sectors now since our bio can
284 * go away inside make_request
285 */
286 sectors = bio_sectors(bio);
Shaohua Li9c573de2016-04-25 16:52:38 -0700287 /* bio could be mergeable after passing to underlayer */
Jens Axboe1eff9d32016-08-05 15:35:16 -0600288 bio->bi_opf &= ~REQ_NOMERGE;
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200289 mddev->pers->make_request(mddev, bio);
NeilBrown49077322010-03-25 16:20:56 +1100290
Gu Zheng74672d02015-04-03 08:44:47 +0800291 cpu = part_stat_lock();
292 part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
293 part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors);
294 part_stat_unlock();
NeilBrown49077322010-03-25 16:20:56 +1100295
NeilBrown409c57f2009-03-31 14:39:39 +1100296 if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
297 wake_up(&mddev->sb_wait);
Jens Axboedece1632015-11-05 10:41:16 -0700298
299 return BLK_QC_T_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300}
301
NeilBrown9e35b992010-04-06 14:23:02 +1000302/* mddev_suspend makes sure no new requests are submitted
303 * to the device, and that any requests that have been submitted
304 * are completely handled.
NeilBrownafa0f552014-12-15 12:56:58 +1100305 * Once mddev_detach() is called and completes, the module will be
306 * completely unused.
NeilBrown9e35b992010-04-06 14:23:02 +1000307 */
NeilBrownfd01b882011-10-11 16:47:53 +1100308void mddev_suspend(struct mddev *mddev)
NeilBrown409c57f2009-03-31 14:39:39 +1100309{
Heinz Mauelshagen092398d2016-05-03 19:43:57 +0200310 WARN_ON_ONCE(mddev->thread && current == mddev->thread->tsk);
Mikulas Patocka0dc10e52015-12-18 15:19:16 +1100311 if (mddev->suspended++)
312 return;
NeilBrown409c57f2009-03-31 14:39:39 +1100313 synchronize_rcu();
314 wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
315 mddev->pers->quiesce(mddev, 1);
Jonathan Brassow0d9f4f12012-05-16 04:06:14 -0500316
317 del_timer_sync(&mddev->safemode_timer);
NeilBrown409c57f2009-03-31 14:39:39 +1100318}
NeilBrown390ee602010-06-01 19:37:27 +1000319EXPORT_SYMBOL_GPL(mddev_suspend);
NeilBrown409c57f2009-03-31 14:39:39 +1100320
NeilBrownfd01b882011-10-11 16:47:53 +1100321void mddev_resume(struct mddev *mddev)
NeilBrown409c57f2009-03-31 14:39:39 +1100322{
Mikulas Patocka0dc10e52015-12-18 15:19:16 +1100323 if (--mddev->suspended)
324 return;
NeilBrown409c57f2009-03-31 14:39:39 +1100325 wake_up(&mddev->sb_wait);
326 mddev->pers->quiesce(mddev, 0);
Jonathan Brassow0fd018a2011-06-07 17:49:36 -0500327
Jonathan Brassow47525e52012-05-22 13:55:29 +1000328 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
Jonathan Brassow0fd018a2011-06-07 17:49:36 -0500329 md_wakeup_thread(mddev->thread);
330 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
NeilBrown409c57f2009-03-31 14:39:39 +1100331}
NeilBrown390ee602010-06-01 19:37:27 +1000332EXPORT_SYMBOL_GPL(mddev_resume);
NeilBrown409c57f2009-03-31 14:39:39 +1100333
NeilBrownfd01b882011-10-11 16:47:53 +1100334int mddev_congested(struct mddev *mddev, int bits)
NeilBrown3fa841d2009-09-23 18:10:29 +1000335{
NeilBrown5c675f82014-12-15 12:56:56 +1100336 struct md_personality *pers = mddev->pers;
337 int ret = 0;
338
339 rcu_read_lock();
340 if (mddev->suspended)
341 ret = 1;
342 else if (pers && pers->congested)
343 ret = pers->congested(mddev, bits);
344 rcu_read_unlock();
345 return ret;
NeilBrown3fa841d2009-09-23 18:10:29 +1000346}
NeilBrown5c675f82014-12-15 12:56:56 +1100347EXPORT_SYMBOL_GPL(mddev_congested);
348static int md_congested(void *data, int bits)
349{
350 struct mddev *mddev = data;
351 return mddev_congested(mddev, bits);
352}
NeilBrown3fa841d2009-09-23 18:10:29 +1000353
NeilBrowna2826aa2009-12-14 12:49:49 +1100354/*
Tejun Heoe9c74692010-09-03 11:56:18 +0200355 * Generic flush handling for md
NeilBrowna2826aa2009-12-14 12:49:49 +1100356 */
357
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200358static void md_end_flush(struct bio *bio)
NeilBrowna2826aa2009-12-14 12:49:49 +1100359{
NeilBrown3cb03002011-10-11 16:45:26 +1100360 struct md_rdev *rdev = bio->bi_private;
NeilBrownfd01b882011-10-11 16:47:53 +1100361 struct mddev *mddev = rdev->mddev;
NeilBrowna2826aa2009-12-14 12:49:49 +1100362
363 rdev_dec_pending(rdev, mddev);
364
365 if (atomic_dec_and_test(&mddev->flush_pending)) {
Tejun Heoe9c74692010-09-03 11:56:18 +0200366 /* The pre-request flush has finished */
Tejun Heoe804ac72010-10-15 15:36:08 +0200367 queue_work(md_wq, &mddev->flush_work);
NeilBrowna2826aa2009-12-14 12:49:49 +1100368 }
369 bio_put(bio);
370}
371
NeilBrowna7a07e62010-12-09 16:04:25 +1100372static void md_submit_flush_data(struct work_struct *ws);
373
NeilBrowna035fc32010-12-09 16:17:51 +1100374static void submit_flushes(struct work_struct *ws)
NeilBrowna2826aa2009-12-14 12:49:49 +1100375{
NeilBrownfd01b882011-10-11 16:47:53 +1100376 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
NeilBrown3cb03002011-10-11 16:45:26 +1100377 struct md_rdev *rdev;
NeilBrowna2826aa2009-12-14 12:49:49 +1100378
NeilBrowna7a07e62010-12-09 16:04:25 +1100379 INIT_WORK(&mddev->flush_work, md_submit_flush_data);
380 atomic_set(&mddev->flush_pending, 1);
NeilBrowna2826aa2009-12-14 12:49:49 +1100381 rcu_read_lock();
NeilBrowndafb20f2012-03-19 12:46:39 +1100382 rdev_for_each_rcu(rdev, mddev)
NeilBrowna2826aa2009-12-14 12:49:49 +1100383 if (rdev->raid_disk >= 0 &&
384 !test_bit(Faulty, &rdev->flags)) {
385 /* Take two references, one is dropped
386 * when request finishes, one after
387 * we reclaim rcu_read_lock
388 */
389 struct bio *bi;
390 atomic_inc(&rdev->nr_pending);
391 atomic_inc(&rdev->nr_pending);
392 rcu_read_unlock();
Shaohua Lib5e1b8c2012-05-21 09:26:59 +1000393 bi = bio_alloc_mddev(GFP_NOIO, 0, mddev);
Tejun Heoe9c74692010-09-03 11:56:18 +0200394 bi->bi_end_io = md_end_flush;
NeilBrowna2826aa2009-12-14 12:49:49 +1100395 bi->bi_private = rdev;
396 bi->bi_bdev = rdev->bdev;
Mike Christie796a5cf2016-06-05 14:32:07 -0500397 bio_set_op_attrs(bi, REQ_OP_WRITE, WRITE_FLUSH);
NeilBrowna2826aa2009-12-14 12:49:49 +1100398 atomic_inc(&mddev->flush_pending);
Mike Christie4e49ea42016-06-05 14:31:41 -0500399 submit_bio(bi);
NeilBrowna2826aa2009-12-14 12:49:49 +1100400 rcu_read_lock();
401 rdev_dec_pending(rdev, mddev);
402 }
403 rcu_read_unlock();
NeilBrowna7a07e62010-12-09 16:04:25 +1100404 if (atomic_dec_and_test(&mddev->flush_pending))
405 queue_work(md_wq, &mddev->flush_work);
NeilBrowna2826aa2009-12-14 12:49:49 +1100406}
407
Tejun Heoe9c74692010-09-03 11:56:18 +0200408static void md_submit_flush_data(struct work_struct *ws)
NeilBrowna2826aa2009-12-14 12:49:49 +1100409{
NeilBrownfd01b882011-10-11 16:47:53 +1100410 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
Tejun Heoe9c74692010-09-03 11:56:18 +0200411 struct bio *bio = mddev->flush_bio;
NeilBrowna2826aa2009-12-14 12:49:49 +1100412
Kent Overstreet4f024f32013-10-11 15:44:27 -0700413 if (bio->bi_iter.bi_size == 0)
NeilBrowna2826aa2009-12-14 12:49:49 +1100414 /* an empty barrier - all done */
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200415 bio_endio(bio);
NeilBrowna2826aa2009-12-14 12:49:49 +1100416 else {
Jens Axboe1eff9d32016-08-05 15:35:16 -0600417 bio->bi_opf &= ~REQ_PREFLUSH;
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200418 mddev->pers->make_request(mddev, bio);
NeilBrowna2826aa2009-12-14 12:49:49 +1100419 }
NeilBrown2b74e122010-12-09 15:59:01 +1100420
421 mddev->flush_bio = NULL;
422 wake_up(&mddev->sb_wait);
NeilBrowna2826aa2009-12-14 12:49:49 +1100423}
424
NeilBrownfd01b882011-10-11 16:47:53 +1100425void md_flush_request(struct mddev *mddev, struct bio *bio)
NeilBrowna2826aa2009-12-14 12:49:49 +1100426{
NeilBrown85572d72014-12-15 12:56:56 +1100427 spin_lock_irq(&mddev->lock);
NeilBrowna2826aa2009-12-14 12:49:49 +1100428 wait_event_lock_irq(mddev->sb_wait,
Tejun Heoe9c74692010-09-03 11:56:18 +0200429 !mddev->flush_bio,
NeilBrown85572d72014-12-15 12:56:56 +1100430 mddev->lock);
Tejun Heoe9c74692010-09-03 11:56:18 +0200431 mddev->flush_bio = bio;
NeilBrown85572d72014-12-15 12:56:56 +1100432 spin_unlock_irq(&mddev->lock);
NeilBrowna2826aa2009-12-14 12:49:49 +1100433
NeilBrowna035fc32010-12-09 16:17:51 +1100434 INIT_WORK(&mddev->flush_work, submit_flushes);
435 queue_work(md_wq, &mddev->flush_work);
NeilBrowna2826aa2009-12-14 12:49:49 +1100436}
Tejun Heoe9c74692010-09-03 11:56:18 +0200437EXPORT_SYMBOL(md_flush_request);
NeilBrown409c57f2009-03-31 14:39:39 +1100438
NeilBrown74018dc2012-07-31 09:08:15 +0200439void md_unplug(struct blk_plug_cb *cb, bool from_schedule)
NeilBrown97658cd2011-04-18 18:25:42 +1000440{
NeilBrown9cbb1752012-07-31 09:08:14 +0200441 struct mddev *mddev = cb->data;
442 md_wakeup_thread(mddev->thread);
443 kfree(cb);
NeilBrown97658cd2011-04-18 18:25:42 +1000444}
NeilBrown9cbb1752012-07-31 09:08:14 +0200445EXPORT_SYMBOL(md_unplug);
NeilBrown2ac87402010-06-01 19:37:29 +1000446
NeilBrownfd01b882011-10-11 16:47:53 +1100447static inline struct mddev *mddev_get(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448{
449 atomic_inc(&mddev->active);
450 return mddev;
451}
452
Dan Williams5fd3a172009-03-04 00:57:25 -0700453static void mddev_delayed_delete(struct work_struct *ws);
NeilBrownd3374822009-01-09 08:31:10 +1100454
NeilBrownfd01b882011-10-11 16:47:53 +1100455static void mddev_put(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456{
NeilBrowna167f662010-10-26 18:31:13 +1100457 struct bio_set *bs = NULL;
458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
460 return;
NeilBrownd3374822009-01-09 08:31:10 +1100461 if (!mddev->raid_disks && list_empty(&mddev->disks) &&
NeilBrowncbd19982009-12-30 12:08:49 +1100462 mddev->ctime == 0 && !mddev->hold_active) {
463 /* Array is not configured at all, and not held active,
464 * so destroy it */
NeilBrownaf8a2432011-12-08 15:49:46 +1100465 list_del_init(&mddev->all_mddevs);
NeilBrowna167f662010-10-26 18:31:13 +1100466 bs = mddev->bio_set;
467 mddev->bio_set = NULL;
NeilBrownd3374822009-01-09 08:31:10 +1100468 if (mddev->gendisk) {
Tejun Heoe804ac72010-10-15 15:36:08 +0200469 /* We did a probe so need to clean up. Call
470 * queue_work inside the spinlock so that
471 * flush_workqueue() after mddev_find will
472 * succeed in waiting for the work to be done.
NeilBrownd3374822009-01-09 08:31:10 +1100473 */
474 INIT_WORK(&mddev->del_work, mddev_delayed_delete);
Tejun Heoe804ac72010-10-15 15:36:08 +0200475 queue_work(md_misc_wq, &mddev->del_work);
NeilBrownd3374822009-01-09 08:31:10 +1100476 } else
477 kfree(mddev);
478 }
479 spin_unlock(&all_mddevs_lock);
NeilBrowna167f662010-10-26 18:31:13 +1100480 if (bs)
481 bioset_free(bs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482}
483
Sasha Levin25b2edf2015-07-24 18:19:58 -0400484static void md_safemode_timeout(unsigned long data);
485
NeilBrownfd01b882011-10-11 16:47:53 +1100486void mddev_init(struct mddev *mddev)
NeilBrownfafd7fb2010-04-01 15:55:30 +1100487{
488 mutex_init(&mddev->open_mutex);
489 mutex_init(&mddev->reconfig_mutex);
490 mutex_init(&mddev->bitmap_info.mutex);
491 INIT_LIST_HEAD(&mddev->disks);
492 INIT_LIST_HEAD(&mddev->all_mddevs);
Sasha Levin25b2edf2015-07-24 18:19:58 -0400493 setup_timer(&mddev->safemode_timer, md_safemode_timeout,
494 (unsigned long) mddev);
NeilBrownfafd7fb2010-04-01 15:55:30 +1100495 atomic_set(&mddev->active, 1);
496 atomic_set(&mddev->openers, 0);
497 atomic_set(&mddev->active_io, 0);
NeilBrown85572d72014-12-15 12:56:56 +1100498 spin_lock_init(&mddev->lock);
NeilBrownfafd7fb2010-04-01 15:55:30 +1100499 atomic_set(&mddev->flush_pending, 0);
500 init_waitqueue_head(&mddev->sb_wait);
501 init_waitqueue_head(&mddev->recovery_wait);
502 mddev->reshape_position = MaxSector;
NeilBrown2c810cd2012-05-21 09:27:00 +1000503 mddev->reshape_backwards = 0;
Jonathan Brassowc4a39552013-06-25 01:23:59 -0500504 mddev->last_sync_action = "none";
NeilBrownfafd7fb2010-04-01 15:55:30 +1100505 mddev->resync_min = 0;
506 mddev->resync_max = MaxSector;
507 mddev->level = LEVEL_NONE;
508}
NeilBrown390ee602010-06-01 19:37:27 +1000509EXPORT_SYMBOL_GPL(mddev_init);
NeilBrownfafd7fb2010-04-01 15:55:30 +1100510
NeilBrownf72ffdd2014-09-30 14:23:59 +1000511static struct mddev *mddev_find(dev_t unit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512{
NeilBrownfd01b882011-10-11 16:47:53 +1100513 struct mddev *mddev, *new = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
NeilBrown8f5f02c2011-02-16 13:58:51 +1100515 if (unit && MAJOR(unit) != MD_MAJOR)
516 unit &= ~((1<<MdpMinorShift)-1);
517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 retry:
519 spin_lock(&all_mddevs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
NeilBrownefeb53c2009-01-09 08:31:10 +1100521 if (unit) {
522 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
523 if (mddev->unit == unit) {
524 mddev_get(mddev);
525 spin_unlock(&all_mddevs_lock);
526 kfree(new);
527 return mddev;
528 }
529
530 if (new) {
531 list_add(&new->all_mddevs, &all_mddevs);
532 spin_unlock(&all_mddevs_lock);
533 new->hold_active = UNTIL_IOCTL;
534 return new;
535 }
536 } else if (new) {
537 /* find an unused unit number */
538 static int next_minor = 512;
539 int start = next_minor;
540 int is_free = 0;
541 int dev = 0;
542 while (!is_free) {
543 dev = MKDEV(MD_MAJOR, next_minor);
544 next_minor++;
545 if (next_minor > MINORMASK)
546 next_minor = 0;
547 if (next_minor == start) {
548 /* Oh dear, all in use. */
549 spin_unlock(&all_mddevs_lock);
550 kfree(new);
551 return NULL;
552 }
NeilBrownf72ffdd2014-09-30 14:23:59 +1000553
NeilBrownefeb53c2009-01-09 08:31:10 +1100554 is_free = 1;
555 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
556 if (mddev->unit == dev) {
557 is_free = 0;
558 break;
559 }
560 }
561 new->unit = dev;
562 new->md_minor = MINOR(dev);
563 new->hold_active = UNTIL_STOP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 list_add(&new->all_mddevs, &all_mddevs);
565 spin_unlock(&all_mddevs_lock);
566 return new;
567 }
568 spin_unlock(&all_mddevs_lock);
569
NeilBrown9ffae0c2006-01-06 00:20:32 -0800570 new = kzalloc(sizeof(*new), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 if (!new)
572 return NULL;
573
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 new->unit = unit;
575 if (MAJOR(unit) == MD_MAJOR)
576 new->md_minor = MINOR(unit);
577 else
578 new->md_minor = MINOR(unit) >> MdpMinorShift;
579
NeilBrownfafd7fb2010-04-01 15:55:30 +1100580 mddev_init(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 goto retry;
583}
584
NeilBrownb6eb1272010-04-15 10:13:47 +1000585static struct attribute_group md_redundancy_group;
586
NeilBrown5c47daf2014-12-15 12:57:01 +1100587void mddev_unlock(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588{
NeilBrowna64c8762010-04-14 17:15:37 +1000589 if (mddev->to_remove) {
NeilBrownb6eb1272010-04-15 10:13:47 +1000590 /* These cannot be removed under reconfig_mutex as
591 * an access to the files will try to take reconfig_mutex
592 * while holding the file unremovable, which leads to
593 * a deadlock.
NeilBrownbb4f1e92010-08-08 21:18:03 +1000594 * So hold set sysfs_active while the remove in happeing,
595 * and anything else which might set ->to_remove or my
596 * otherwise change the sysfs namespace will fail with
597 * -EBUSY if sysfs_active is still set.
598 * We set sysfs_active under reconfig_mutex and elsewhere
599 * test it under the same mutex to ensure its correct value
600 * is seen.
NeilBrownb6eb1272010-04-15 10:13:47 +1000601 */
NeilBrowna64c8762010-04-14 17:15:37 +1000602 struct attribute_group *to_remove = mddev->to_remove;
603 mddev->to_remove = NULL;
NeilBrownbb4f1e92010-08-08 21:18:03 +1000604 mddev->sysfs_active = 1;
NeilBrownb6eb1272010-04-15 10:13:47 +1000605 mutex_unlock(&mddev->reconfig_mutex);
606
NeilBrown00bcb4a2010-06-01 19:37:23 +1000607 if (mddev->kobj.sd) {
608 if (to_remove != &md_redundancy_group)
609 sysfs_remove_group(&mddev->kobj, to_remove);
610 if (mddev->pers == NULL ||
611 mddev->pers->sync_request == NULL) {
612 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
613 if (mddev->sysfs_action)
614 sysfs_put(mddev->sysfs_action);
615 mddev->sysfs_action = NULL;
616 }
NeilBrowna64c8762010-04-14 17:15:37 +1000617 }
NeilBrownbb4f1e92010-08-08 21:18:03 +1000618 mddev->sysfs_active = 0;
NeilBrownb6eb1272010-04-15 10:13:47 +1000619 } else
620 mutex_unlock(&mddev->reconfig_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
Chris Dunlop751e67c2011-10-19 16:48:26 +1100622 /* As we've dropped the mutex we need a spinlock to
623 * make sure the thread doesn't disappear
NeilBrown01f96c02011-09-21 15:30:20 +1000624 */
625 spin_lock(&pers_lock);
NeilBrown005eca52005-08-22 13:11:08 -0700626 md_wakeup_thread(mddev->thread);
NeilBrown01f96c02011-09-21 15:30:20 +1000627 spin_unlock(&pers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628}
NeilBrown5c47daf2014-12-15 12:57:01 +1100629EXPORT_SYMBOL_GPL(mddev_unlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
Goldwyn Rodrigues57d051d2015-04-14 10:43:55 -0500631struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr)
NeilBrown1ca69c42012-10-11 13:37:33 +1100632{
633 struct md_rdev *rdev;
634
635 rdev_for_each_rcu(rdev, mddev)
636 if (rdev->desc_nr == nr)
637 return rdev;
638
639 return NULL;
640}
Goldwyn Rodrigues57d051d2015-04-14 10:43:55 -0500641EXPORT_SYMBOL_GPL(md_find_rdev_nr_rcu);
NeilBrown1ca69c42012-10-11 13:37:33 +1100642
643static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644{
NeilBrown3cb03002011-10-11 16:45:26 +1100645 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
NeilBrowndafb20f2012-03-19 12:46:39 +1100647 rdev_for_each(rdev, mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 if (rdev->bdev->bd_dev == dev)
649 return rdev;
Cheng Renquan159ec1f2009-01-09 08:31:08 +1100650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 return NULL;
652}
653
NeilBrown1ca69c42012-10-11 13:37:33 +1100654static struct md_rdev *find_rdev_rcu(struct mddev *mddev, dev_t dev)
655{
656 struct md_rdev *rdev;
657
658 rdev_for_each_rcu(rdev, mddev)
659 if (rdev->bdev->bd_dev == dev)
660 return rdev;
661
662 return NULL;
663}
664
NeilBrown84fc4b52011-10-11 16:49:58 +1100665static struct md_personality *find_pers(int level, char *clevel)
NeilBrown2604b702006-01-06 00:20:36 -0800666{
NeilBrown84fc4b52011-10-11 16:49:58 +1100667 struct md_personality *pers;
NeilBrownd9d166c2006-01-06 00:20:51 -0800668 list_for_each_entry(pers, &pers_list, list) {
669 if (level != LEVEL_NONE && pers->level == level)
NeilBrown2604b702006-01-06 00:20:36 -0800670 return pers;
NeilBrownd9d166c2006-01-06 00:20:51 -0800671 if (strcmp(pers->name, clevel)==0)
672 return pers;
673 }
NeilBrown2604b702006-01-06 00:20:36 -0800674 return NULL;
675}
676
Andre Nollb73df2d2008-07-11 22:02:23 +1000677/* return the offset of the super block in 512byte sectors */
NeilBrown3cb03002011-10-11 16:45:26 +1100678static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679{
Jonathan Brassow57b2caa2011-01-14 09:14:33 +1100680 sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
Andre Nollb73df2d2008-07-11 22:02:23 +1000681 return MD_NEW_SIZE_SECTORS(num_sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682}
683
NeilBrownf72ffdd2014-09-30 14:23:59 +1000684static int alloc_disk_sb(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 rdev->sb_page = alloc_page(GFP_KERNEL);
687 if (!rdev->sb_page) {
688 printk(KERN_ALERT "md: out of memory.\n");
Andre Nollebc24332008-07-11 22:02:20 +1000689 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 }
691
692 return 0;
693}
694
NeilBrown545c8792012-05-22 13:54:30 +1000695void md_rdev_clear(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696{
697 if (rdev->sb_page) {
NeilBrown2d1f3b52006-01-06 00:20:31 -0800698 put_page(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 rdev->sb_loaded = 0;
700 rdev->sb_page = NULL;
Andre Noll0f420352008-07-11 22:02:23 +1000701 rdev->sb_start = 0;
Andre Nolldd8ac332009-03-31 14:33:13 +1100702 rdev->sectors = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 }
NeilBrown2699b672011-07-28 11:31:47 +1000704 if (rdev->bb_page) {
705 put_page(rdev->bb_page);
706 rdev->bb_page = NULL;
707 }
Dan Williamsd3b407f2016-01-06 12:19:22 -0800708 badblocks_exit(&rdev->badblocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709}
NeilBrown545c8792012-05-22 13:54:30 +1000710EXPORT_SYMBOL_GPL(md_rdev_clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200712static void super_written(struct bio *bio)
NeilBrown7bfa19f2005-06-21 17:17:28 -0700713{
NeilBrown3cb03002011-10-11 16:45:26 +1100714 struct md_rdev *rdev = bio->bi_private;
NeilBrownfd01b882011-10-11 16:47:53 +1100715 struct mddev *mddev = rdev->mddev;
NeilBrown7bfa19f2005-06-21 17:17:28 -0700716
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200717 if (bio->bi_error) {
718 printk("md: super_written gets error=%d\n", bio->bi_error);
NeilBrowna9701a32005-11-08 21:39:34 -0800719 md_error(mddev, rdev);
NeilBrown3a0f5bb2006-10-03 01:16:03 -0700720 }
NeilBrown7bfa19f2005-06-21 17:17:28 -0700721
NeilBrowna9701a32005-11-08 21:39:34 -0800722 if (atomic_dec_and_test(&mddev->pending_writes))
723 wake_up(&mddev->sb_wait);
Shaohua Lied3b98c2016-03-29 14:00:19 -0700724 rdev_dec_pending(rdev, mddev);
Neil Brownf8b58ed2005-06-27 22:29:34 -0700725 bio_put(bio);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700726}
727
NeilBrownfd01b882011-10-11 16:47:53 +1100728void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
NeilBrown7bfa19f2005-06-21 17:17:28 -0700729 sector_t sector, int size, struct page *page)
730{
731 /* write first size bytes of page to sector of rdev
732 * Increment mddev->pending_writes before returning
733 * and decrement it on completion, waking up sb_wait
734 * if zero is reached.
735 * If an error occurred, call md_error
736 */
NeilBrowna167f662010-10-26 18:31:13 +1100737 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, mddev);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700738
Shaohua Lied3b98c2016-03-29 14:00:19 -0700739 atomic_inc(&rdev->nr_pending);
740
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100741 bio->bi_bdev = rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev;
Kent Overstreet4f024f32013-10-11 15:44:27 -0700742 bio->bi_iter.bi_sector = sector;
NeilBrown7bfa19f2005-06-21 17:17:28 -0700743 bio_add_page(bio, page, size, 0);
744 bio->bi_private = rdev;
745 bio->bi_end_io = super_written;
Mike Christie796a5cf2016-06-05 14:32:07 -0500746 bio_set_op_attrs(bio, REQ_OP_WRITE, WRITE_FLUSH_FUA);
NeilBrowna9701a32005-11-08 21:39:34 -0800747
NeilBrown7bfa19f2005-06-21 17:17:28 -0700748 atomic_inc(&mddev->pending_writes);
Mike Christie4e49ea42016-06-05 14:31:41 -0500749 submit_bio(bio);
NeilBrowna9701a32005-11-08 21:39:34 -0800750}
751
NeilBrownfd01b882011-10-11 16:47:53 +1100752void md_super_wait(struct mddev *mddev)
NeilBrowna9701a32005-11-08 21:39:34 -0800753{
Tejun Heoe9c74692010-09-03 11:56:18 +0200754 /* wait for all superblock writes that were scheduled to complete */
NeilBrown1967cd52014-09-09 14:20:28 +1000755 wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700756}
757
NeilBrown3cb03002011-10-11 16:45:26 +1100758int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
Mike Christie796a5cf2016-06-05 14:32:07 -0500759 struct page *page, int op, int op_flags, bool metadata_op)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760{
NeilBrowna167f662010-10-26 18:31:13 +1100761 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 int ret;
763
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100764 bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
765 rdev->meta_bdev : rdev->bdev;
Mike Christie796a5cf2016-06-05 14:32:07 -0500766 bio_set_op_attrs(bio, op, op_flags);
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100767 if (metadata_op)
Kent Overstreet4f024f32013-10-11 15:44:27 -0700768 bio->bi_iter.bi_sector = sector + rdev->sb_start;
NeilBrown1fdd6fc92012-05-21 09:28:32 +1000769 else if (rdev->mddev->reshape_position != MaxSector &&
770 (rdev->mddev->reshape_backwards ==
771 (sector >= rdev->mddev->reshape_position)))
Kent Overstreet4f024f32013-10-11 15:44:27 -0700772 bio->bi_iter.bi_sector = sector + rdev->new_data_offset;
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100773 else
Kent Overstreet4f024f32013-10-11 15:44:27 -0700774 bio->bi_iter.bi_sector = sector + rdev->data_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 bio_add_page(bio, page, size, 0);
Mike Christie4e49ea42016-06-05 14:31:41 -0500776
777 submit_bio_wait(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200779 ret = !bio->bi_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 bio_put(bio);
781 return ret;
782}
NeilBrowna8745db2006-01-06 00:20:34 -0800783EXPORT_SYMBOL_GPL(sync_page_io);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
NeilBrownf72ffdd2014-09-30 14:23:59 +1000785static int read_disk_sb(struct md_rdev *rdev, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786{
787 char b[BDEVNAME_SIZE];
NeilBrown403df472014-09-30 15:52:29 +1000788
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 if (rdev->sb_loaded)
790 return 0;
791
Mike Christie796a5cf2016-06-05 14:32:07 -0500792 if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, 0, true))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 goto fail;
794 rdev->sb_loaded = 1;
795 return 0;
796
797fail:
798 printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
799 bdevname(rdev->bdev,b));
800 return -EINVAL;
801}
802
803static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
804{
NeilBrownf72ffdd2014-09-30 14:23:59 +1000805 return sb1->set_uuid0 == sb2->set_uuid0 &&
Andre Noll05710462008-07-11 22:02:20 +1000806 sb1->set_uuid1 == sb2->set_uuid1 &&
807 sb1->set_uuid2 == sb2->set_uuid2 &&
808 sb1->set_uuid3 == sb2->set_uuid3;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809}
810
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
812{
813 int ret;
814 mdp_super_t *tmp1, *tmp2;
815
816 tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
817 tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
818
819 if (!tmp1 || !tmp2) {
820 ret = 0;
Andre Noll35020f12008-03-23 15:10:33 +0100821 printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 goto abort;
823 }
824
825 *tmp1 = *sb1;
826 *tmp2 = *sb2;
827
828 /*
829 * nr_disks is not constant
830 */
831 tmp1->nr_disks = 0;
832 tmp2->nr_disks = 0;
833
Andre Nollce0c8e02008-07-11 22:02:20 +1000834 ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835abort:
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700836 kfree(tmp1);
837 kfree(tmp2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 return ret;
839}
840
NeilBrown4d167f02007-05-09 02:35:37 -0700841static u32 md_csum_fold(u32 csum)
842{
843 csum = (csum & 0xffff) + (csum >> 16);
844 return (csum & 0xffff) + (csum >> 16);
845}
846
NeilBrownf72ffdd2014-09-30 14:23:59 +1000847static unsigned int calc_sb_csum(mdp_super_t *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848{
NeilBrown4d167f02007-05-09 02:35:37 -0700849 u64 newcsum = 0;
850 u32 *sb32 = (u32*)sb;
851 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 unsigned int disk_csum, csum;
853
854 disk_csum = sb->sb_csum;
855 sb->sb_csum = 0;
NeilBrown4d167f02007-05-09 02:35:37 -0700856
857 for (i = 0; i < MD_SB_BYTES/4 ; i++)
858 newcsum += sb32[i];
859 csum = (newcsum & 0xffffffff) + (newcsum>>32);
860
NeilBrown4d167f02007-05-09 02:35:37 -0700861#ifdef CONFIG_ALPHA
862 /* This used to use csum_partial, which was wrong for several
863 * reasons including that different results are returned on
864 * different architectures. It isn't critical that we get exactly
865 * the same return value as before (we always csum_fold before
866 * testing, and that removes any differences). However as we
867 * know that csum_partial always returned a 16bit value on
868 * alphas, do a fold to maximise conformity to previous behaviour.
869 */
870 sb->sb_csum = md_csum_fold(disk_csum);
871#else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 sb->sb_csum = disk_csum;
NeilBrown4d167f02007-05-09 02:35:37 -0700873#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 return csum;
875}
876
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877/*
878 * Handle superblock details.
879 * We want to be able to handle multiple superblock formats
880 * so we have a common interface to them all, and an array of
881 * different handlers.
882 * We rely on user-space to write the initial superblock, and support
883 * reading and updating of superblocks.
884 * Interface methods are:
NeilBrown3cb03002011-10-11 16:45:26 +1100885 * int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 * loads and validates a superblock on dev.
887 * if refdev != NULL, compare superblocks on both devices
888 * Return:
889 * 0 - dev has a superblock that is compatible with refdev
890 * 1 - dev has a superblock that is compatible and newer than refdev
891 * so dev should be used as the refdev in future
892 * -EINVAL superblock incompatible or invalid
893 * -othererror e.g. -EIO
894 *
NeilBrownfd01b882011-10-11 16:47:53 +1100895 * int validate_super(struct mddev *mddev, struct md_rdev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 * Verify that dev is acceptable into mddev.
897 * The first time, mddev->raid_disks will be 0, and data from
898 * dev should be merged in. Subsequent calls check that dev
899 * is new enough. Return 0 or -EINVAL
900 *
NeilBrownfd01b882011-10-11 16:47:53 +1100901 * void sync_super(struct mddev *mddev, struct md_rdev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 * Update the superblock for rdev with data in mddev
903 * This does not write to disc.
904 *
905 */
906
907struct super_type {
Chris Webb0cd17fe2008-06-28 08:31:46 +1000908 char *name;
909 struct module *owner;
NeilBrownc6563a82012-05-21 09:27:00 +1000910 int (*load_super)(struct md_rdev *rdev,
911 struct md_rdev *refdev,
Chris Webb0cd17fe2008-06-28 08:31:46 +1000912 int minor_version);
NeilBrownc6563a82012-05-21 09:27:00 +1000913 int (*validate_super)(struct mddev *mddev,
914 struct md_rdev *rdev);
915 void (*sync_super)(struct mddev *mddev,
916 struct md_rdev *rdev);
NeilBrown3cb03002011-10-11 16:45:26 +1100917 unsigned long long (*rdev_size_change)(struct md_rdev *rdev,
Andre Noll15f4a5f2008-07-21 14:42:12 +1000918 sector_t num_sectors);
NeilBrownc6563a82012-05-21 09:27:00 +1000919 int (*allow_new_offset)(struct md_rdev *rdev,
920 unsigned long long new_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921};
922
923/*
Andre Noll0894cc32009-06-18 08:49:23 +1000924 * Check that the given mddev has no bitmap.
925 *
926 * This function is called from the run method of all personalities that do not
927 * support bitmaps. It prints an error message and returns non-zero if mddev
928 * has a bitmap. Otherwise, it returns 0.
929 *
930 */
NeilBrownfd01b882011-10-11 16:47:53 +1100931int md_check_no_bitmap(struct mddev *mddev)
Andre Noll0894cc32009-06-18 08:49:23 +1000932{
NeilBrownc3d97142009-12-14 12:49:52 +1100933 if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
Andre Noll0894cc32009-06-18 08:49:23 +1000934 return 0;
935 printk(KERN_ERR "%s: bitmaps are not supported for %s\n",
936 mdname(mddev), mddev->pers->name);
937 return 1;
938}
939EXPORT_SYMBOL(md_check_no_bitmap);
940
941/*
NeilBrownf72ffdd2014-09-30 14:23:59 +1000942 * load_super for 0.90.0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 */
NeilBrown3cb03002011-10-11 16:45:26 +1100944static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945{
946 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
947 mdp_super_t *sb;
948 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
950 /*
Andre Noll0f420352008-07-11 22:02:23 +1000951 * Calculate the position of the superblock (512byte sectors),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 * it's at the end of the disk.
953 *
954 * It also happens to be a multiple of 4Kb.
955 */
Jonathan Brassow57b2caa2011-01-14 09:14:33 +1100956 rdev->sb_start = calc_dev_sboffset(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957
NeilBrown0002b272005-09-09 16:23:53 -0700958 ret = read_disk_sb(rdev, MD_SB_BYTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 if (ret) return ret;
960
961 ret = -EINVAL;
962
963 bdevname(rdev->bdev, b);
Namhyung Kim65a06f062011-07-27 11:00:36 +1000964 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
966 if (sb->md_magic != MD_SB_MAGIC) {
967 printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
968 b);
969 goto abort;
970 }
971
972 if (sb->major_version != 0 ||
NeilBrownf6705572006-03-27 01:18:11 -0800973 sb->minor_version < 90 ||
974 sb->minor_version > 91) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
976 sb->major_version, sb->minor_version,
977 b);
978 goto abort;
979 }
980
981 if (sb->raid_disks <= 0)
982 goto abort;
983
NeilBrown4d167f02007-05-09 02:35:37 -0700984 if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
986 b);
987 goto abort;
988 }
989
990 rdev->preferred_minor = sb->md_minor;
991 rdev->data_offset = 0;
NeilBrownc6563a82012-05-21 09:27:00 +1000992 rdev->new_data_offset = 0;
NeilBrown0002b272005-09-09 16:23:53 -0700993 rdev->sb_size = MD_SB_BYTES;
NeilBrown9f2f3832011-07-28 11:31:47 +1000994 rdev->badblocks.shift = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995
996 if (sb->level == LEVEL_MULTIPATH)
997 rdev->desc_nr = -1;
998 else
999 rdev->desc_nr = sb->this_disk.number;
1000
Harvey Harrison9a7b2b02008-04-28 02:15:49 -07001001 if (!refdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 ret = 1;
Harvey Harrison9a7b2b02008-04-28 02:15:49 -07001003 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 __u64 ev1, ev2;
Namhyung Kim65a06f062011-07-27 11:00:36 +10001005 mdp_super_t *refsb = page_address(refdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 if (!uuid_equal(refsb, sb)) {
1007 printk(KERN_WARNING "md: %s has different UUID to %s\n",
1008 b, bdevname(refdev->bdev,b2));
1009 goto abort;
1010 }
1011 if (!sb_equal(refsb, sb)) {
1012 printk(KERN_WARNING "md: %s has same UUID"
1013 " but different superblock to %s\n",
1014 b, bdevname(refdev->bdev, b2));
1015 goto abort;
1016 }
1017 ev1 = md_event(sb);
1018 ev2 = md_event(refsb);
1019 if (ev1 > ev2)
1020 ret = 1;
NeilBrownf72ffdd2014-09-30 14:23:59 +10001021 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 ret = 0;
1023 }
NeilBrown8190e752009-06-18 08:48:58 +10001024 rdev->sectors = rdev->sb_start;
NeilBrown667a5312012-08-16 16:46:12 +10001025 /* Limit to 4TB as metadata cannot record more than that.
1026 * (not needed for Linear and RAID0 as metadata doesn't
1027 * record this size)
1028 */
Arnd Bergmann3312c952015-12-21 10:51:01 +11001029 if (IS_ENABLED(CONFIG_LBDAF) && (u64)rdev->sectors >= (2ULL << 32) &&
1030 sb->level >= 1)
1031 rdev->sectors = (sector_t)(2ULL << 32) - 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032
NeilBrown27a7b262011-09-10 17:21:28 +10001033 if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
NeilBrown2bf071b2006-01-06 00:20:55 -08001034 /* "this cannot possibly happen" ... */
1035 ret = -EINVAL;
1036
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 abort:
1038 return ret;
1039}
1040
1041/*
1042 * validate_super for 0.90.0
1043 */
NeilBrownfd01b882011-10-11 16:47:53 +11001044static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045{
1046 mdp_disk_t *desc;
Namhyung Kim65a06f062011-07-27 11:00:36 +10001047 mdp_super_t *sb = page_address(rdev->sb_page);
NeilBrown07d84d102006-06-26 00:27:56 -07001048 __u64 ev1 = md_event(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049
NeilBrown41158c72005-06-21 17:17:25 -07001050 rdev->raid_disk = -1;
NeilBrownc5d79ad2008-02-06 01:39:54 -08001051 clear_bit(Faulty, &rdev->flags);
1052 clear_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11001053 clear_bit(Bitmap_sync, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001054 clear_bit(WriteMostly, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001055
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 if (mddev->raid_disks == 0) {
1057 mddev->major_version = 0;
1058 mddev->minor_version = sb->minor_version;
1059 mddev->patch_version = sb->patch_version;
NeilBrowne6910632008-02-06 01:39:51 -08001060 mddev->external = 0;
Andre Noll9d8f0362009-06-18 08:45:01 +10001061 mddev->chunk_sectors = sb->chunk_size >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 mddev->ctime = sb->ctime;
1063 mddev->utime = sb->utime;
1064 mddev->level = sb->level;
NeilBrownd9d166c2006-01-06 00:20:51 -08001065 mddev->clevel[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 mddev->layout = sb->layout;
1067 mddev->raid_disks = sb->raid_disks;
NeilBrown27a7b262011-09-10 17:21:28 +10001068 mddev->dev_sectors = ((sector_t)sb->size) * 2;
NeilBrown07d84d102006-06-26 00:27:56 -07001069 mddev->events = ev1;
NeilBrownc3d97142009-12-14 12:49:52 +11001070 mddev->bitmap_info.offset = 0;
NeilBrown6409bb02012-05-22 13:55:07 +10001071 mddev->bitmap_info.space = 0;
1072 /* bitmap can use 60 K after the 4K superblocks */
NeilBrownc3d97142009-12-14 12:49:52 +11001073 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
NeilBrown6409bb02012-05-22 13:55:07 +10001074 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
NeilBrown2c810cd2012-05-21 09:27:00 +10001075 mddev->reshape_backwards = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
NeilBrownf6705572006-03-27 01:18:11 -08001077 if (mddev->minor_version >= 91) {
1078 mddev->reshape_position = sb->reshape_position;
1079 mddev->delta_disks = sb->delta_disks;
1080 mddev->new_level = sb->new_level;
1081 mddev->new_layout = sb->new_layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001082 mddev->new_chunk_sectors = sb->new_chunk >> 9;
NeilBrown2c810cd2012-05-21 09:27:00 +10001083 if (mddev->delta_disks < 0)
1084 mddev->reshape_backwards = 1;
NeilBrownf6705572006-03-27 01:18:11 -08001085 } else {
1086 mddev->reshape_position = MaxSector;
1087 mddev->delta_disks = 0;
1088 mddev->new_level = mddev->level;
1089 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001090 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownf6705572006-03-27 01:18:11 -08001091 }
1092
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 if (sb->state & (1<<MD_SB_CLEAN))
1094 mddev->recovery_cp = MaxSector;
1095 else {
NeilBrownf72ffdd2014-09-30 14:23:59 +10001096 if (sb->events_hi == sb->cp_events_hi &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 sb->events_lo == sb->cp_events_lo) {
1098 mddev->recovery_cp = sb->recovery_cp;
1099 } else
1100 mddev->recovery_cp = 0;
1101 }
1102
1103 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
1104 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
1105 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
1106 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
1107
1108 mddev->max_disks = MD_SB_DISKS;
NeilBrowna654b9d82005-06-21 17:17:27 -07001109
1110 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
NeilBrown6409bb02012-05-22 13:55:07 +10001111 mddev->bitmap_info.file == NULL) {
NeilBrownc3d97142009-12-14 12:49:52 +11001112 mddev->bitmap_info.offset =
1113 mddev->bitmap_info.default_offset;
NeilBrown6409bb02012-05-22 13:55:07 +10001114 mddev->bitmap_info.space =
Dave Jonesc9ad0202013-08-19 22:26:32 -04001115 mddev->bitmap_info.default_space;
NeilBrown6409bb02012-05-22 13:55:07 +10001116 }
NeilBrowna654b9d82005-06-21 17:17:27 -07001117
NeilBrown41158c72005-06-21 17:17:25 -07001118 } else if (mddev->pers == NULL) {
NeilBrownbe6800a2010-05-18 10:17:09 +10001119 /* Insist on good event counter while assembling, except
1120 * for spares (which don't need an event count) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 ++ev1;
NeilBrownbe6800a2010-05-18 10:17:09 +10001122 if (sb->disks[rdev->desc_nr].state & (
1123 (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
NeilBrownf72ffdd2014-09-30 14:23:59 +10001124 if (ev1 < mddev->events)
NeilBrownbe6800a2010-05-18 10:17:09 +10001125 return -EINVAL;
NeilBrown41158c72005-06-21 17:17:25 -07001126 } else if (mddev->bitmap) {
1127 /* if adding to array with a bitmap, then we can accept an
1128 * older device ... but not too old.
1129 */
NeilBrown41158c72005-06-21 17:17:25 -07001130 if (ev1 < mddev->bitmap->events_cleared)
1131 return 0;
NeilBrown8313b8e2013-12-12 10:13:33 +11001132 if (ev1 < mddev->events)
1133 set_bit(Bitmap_sync, &rdev->flags);
NeilBrown07d84d102006-06-26 00:27:56 -07001134 } else {
1135 if (ev1 < mddev->events)
1136 /* just a hot-add of a new device, leave raid_disk at -1 */
1137 return 0;
1138 }
NeilBrown41158c72005-06-21 17:17:25 -07001139
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 if (mddev->level != LEVEL_MULTIPATH) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 desc = sb->disks + rdev->desc_nr;
1142
1143 if (desc->state & (1<<MD_DISK_FAULTY))
NeilBrownb2d444d2005-11-08 21:39:31 -08001144 set_bit(Faulty, &rdev->flags);
NeilBrown7c7546c2006-06-26 00:27:41 -07001145 else if (desc->state & (1<<MD_DISK_SYNC) /* &&
1146 desc->raid_disk < mddev->raid_disks */) {
NeilBrownb2d444d2005-11-08 21:39:31 -08001147 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 rdev->raid_disk = desc->raid_disk;
NeilBrownf4667222013-12-09 12:04:56 +11001149 rdev->saved_raid_disk = desc->raid_disk;
NeilBrown0261cd9f2009-11-13 17:40:48 +11001150 } else if (desc->state & (1<<MD_DISK_ACTIVE)) {
1151 /* active but not in sync implies recovery up to
1152 * reshape position. We don't know exactly where
1153 * that is, so set to zero for now */
1154 if (mddev->minor_version >= 91) {
1155 rdev->recovery_offset = 0;
1156 rdev->raid_disk = desc->raid_disk;
1157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07001159 if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
1160 set_bit(WriteMostly, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001161 } else /* MULTIPATH are always insync */
NeilBrownb2d444d2005-11-08 21:39:31 -08001162 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 return 0;
1164}
1165
1166/*
1167 * sync_super for 0.90.0
1168 */
NeilBrownfd01b882011-10-11 16:47:53 +11001169static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170{
1171 mdp_super_t *sb;
NeilBrown3cb03002011-10-11 16:45:26 +11001172 struct md_rdev *rdev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 int next_spare = mddev->raid_disks;
NeilBrown19133a42005-11-08 21:39:35 -08001174
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 /* make rdev->sb match mddev data..
1176 *
1177 * 1/ zero out disks
1178 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
1179 * 3/ any empty disks < next_spare become removed
1180 *
1181 * disks[0] gets initialised to REMOVED because
1182 * we cannot be sure from other fields if it has
1183 * been initialised or not.
1184 */
1185 int i;
1186 int active=0, working=0,failed=0,spare=0,nr_disks=0;
1187
NeilBrown61181562005-09-09 16:24:02 -07001188 rdev->sb_size = MD_SB_BYTES;
1189
Namhyung Kim65a06f062011-07-27 11:00:36 +10001190 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191
1192 memset(sb, 0, sizeof(*sb));
1193
1194 sb->md_magic = MD_SB_MAGIC;
1195 sb->major_version = mddev->major_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 sb->patch_version = mddev->patch_version;
1197 sb->gvalid_words = 0; /* ignored */
1198 memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
1199 memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
1200 memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
1201 memcpy(&sb->set_uuid3, mddev->uuid+12,4);
1202
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11001203 sb->ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 sb->level = mddev->level;
Andre Noll58c0fed2009-03-31 14:33:13 +11001205 sb->size = mddev->dev_sectors / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 sb->raid_disks = mddev->raid_disks;
1207 sb->md_minor = mddev->md_minor;
NeilBrowne6910632008-02-06 01:39:51 -08001208 sb->not_persistent = 0;
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11001209 sb->utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 sb->state = 0;
1211 sb->events_hi = (mddev->events>>32);
1212 sb->events_lo = (u32)mddev->events;
1213
NeilBrownf6705572006-03-27 01:18:11 -08001214 if (mddev->reshape_position == MaxSector)
1215 sb->minor_version = 90;
1216 else {
1217 sb->minor_version = 91;
1218 sb->reshape_position = mddev->reshape_position;
1219 sb->new_level = mddev->new_level;
1220 sb->delta_disks = mddev->delta_disks;
1221 sb->new_layout = mddev->new_layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001222 sb->new_chunk = mddev->new_chunk_sectors << 9;
NeilBrownf6705572006-03-27 01:18:11 -08001223 }
1224 mddev->minor_version = sb->minor_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 if (mddev->in_sync)
1226 {
1227 sb->recovery_cp = mddev->recovery_cp;
1228 sb->cp_events_hi = (mddev->events>>32);
1229 sb->cp_events_lo = (u32)mddev->events;
1230 if (mddev->recovery_cp == MaxSector)
1231 sb->state = (1<< MD_SB_CLEAN);
1232 } else
1233 sb->recovery_cp = 0;
1234
1235 sb->layout = mddev->layout;
Andre Noll9d8f0362009-06-18 08:45:01 +10001236 sb->chunk_size = mddev->chunk_sectors << 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237
NeilBrownc3d97142009-12-14 12:49:52 +11001238 if (mddev->bitmap && mddev->bitmap_info.file == NULL)
NeilBrowna654b9d82005-06-21 17:17:27 -07001239 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
1240
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 sb->disks[0].state = (1<<MD_DISK_REMOVED);
NeilBrowndafb20f2012-03-19 12:46:39 +11001242 rdev_for_each(rdev2, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 mdp_disk_t *d;
NeilBrown86e6ffd2005-11-08 21:39:24 -08001244 int desc_nr;
NeilBrown0261cd9f2009-11-13 17:40:48 +11001245 int is_active = test_bit(In_sync, &rdev2->flags);
1246
1247 if (rdev2->raid_disk >= 0 &&
1248 sb->minor_version >= 91)
1249 /* we have nowhere to store the recovery_offset,
1250 * but if it is not below the reshape_position,
1251 * we can piggy-back on that.
1252 */
1253 is_active = 1;
1254 if (rdev2->raid_disk < 0 ||
1255 test_bit(Faulty, &rdev2->flags))
1256 is_active = 0;
1257 if (is_active)
NeilBrown86e6ffd2005-11-08 21:39:24 -08001258 desc_nr = rdev2->raid_disk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 else
NeilBrown86e6ffd2005-11-08 21:39:24 -08001260 desc_nr = next_spare++;
NeilBrown19133a42005-11-08 21:39:35 -08001261 rdev2->desc_nr = desc_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 d = &sb->disks[rdev2->desc_nr];
1263 nr_disks++;
1264 d->number = rdev2->desc_nr;
1265 d->major = MAJOR(rdev2->bdev->bd_dev);
1266 d->minor = MINOR(rdev2->bdev->bd_dev);
NeilBrown0261cd9f2009-11-13 17:40:48 +11001267 if (is_active)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 d->raid_disk = rdev2->raid_disk;
1269 else
1270 d->raid_disk = rdev2->desc_nr; /* compatibility */
NeilBrown1be78922006-03-27 01:18:03 -08001271 if (test_bit(Faulty, &rdev2->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 d->state = (1<<MD_DISK_FAULTY);
NeilBrown0261cd9f2009-11-13 17:40:48 +11001273 else if (is_active) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 d->state = (1<<MD_DISK_ACTIVE);
NeilBrown0261cd9f2009-11-13 17:40:48 +11001275 if (test_bit(In_sync, &rdev2->flags))
1276 d->state |= (1<<MD_DISK_SYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 active++;
1278 working++;
1279 } else {
1280 d->state = 0;
1281 spare++;
1282 working++;
1283 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07001284 if (test_bit(WriteMostly, &rdev2->flags))
1285 d->state |= (1<<MD_DISK_WRITEMOSTLY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 /* now set the "removed" and "faulty" bits on any missing devices */
1288 for (i=0 ; i < mddev->raid_disks ; i++) {
1289 mdp_disk_t *d = &sb->disks[i];
1290 if (d->state == 0 && d->number == 0) {
1291 d->number = i;
1292 d->raid_disk = i;
1293 d->state = (1<<MD_DISK_REMOVED);
1294 d->state |= (1<<MD_DISK_FAULTY);
1295 failed++;
1296 }
1297 }
1298 sb->nr_disks = nr_disks;
1299 sb->active_disks = active;
1300 sb->working_disks = working;
1301 sb->failed_disks = failed;
1302 sb->spare_disks = spare;
1303
1304 sb->this_disk = sb->disks[rdev->desc_nr];
1305 sb->sb_csum = calc_sb_csum(sb);
1306}
1307
1308/*
Chris Webb0cd17fe2008-06-28 08:31:46 +10001309 * rdev_size_change for 0.90.0
1310 */
1311static unsigned long long
NeilBrown3cb03002011-10-11 16:45:26 +11001312super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001313{
Andre Noll58c0fed2009-03-31 14:33:13 +11001314 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001315 return 0; /* component must fit device */
NeilBrownc3d97142009-12-14 12:49:52 +11001316 if (rdev->mddev->bitmap_info.offset)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001317 return 0; /* can't move bitmap */
Jonathan Brassow57b2caa2011-01-14 09:14:33 +11001318 rdev->sb_start = calc_dev_sboffset(rdev);
Andre Noll15f4a5f2008-07-21 14:42:12 +10001319 if (!num_sectors || num_sectors > rdev->sb_start)
1320 num_sectors = rdev->sb_start;
NeilBrown27a7b262011-09-10 17:21:28 +10001321 /* Limit to 4TB as metadata cannot record more than that.
1322 * 4TB == 2^32 KB, or 2*2^32 sectors.
1323 */
Arnd Bergmann3312c952015-12-21 10:51:01 +11001324 if (IS_ENABLED(CONFIG_LBDAF) && (u64)num_sectors >= (2ULL << 32) &&
1325 rdev->mddev->level >= 1)
1326 num_sectors = (sector_t)(2ULL << 32) - 2;
Andre Noll0f420352008-07-11 22:02:23 +10001327 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001328 rdev->sb_page);
1329 md_super_wait(rdev->mddev);
Justin Maggardc26a44e2010-11-24 16:36:17 +11001330 return num_sectors;
Chris Webb0cd17fe2008-06-28 08:31:46 +10001331}
1332
NeilBrownc6563a82012-05-21 09:27:00 +10001333static int
1334super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset)
1335{
1336 /* non-zero offset changes not possible with v0.90 */
1337 return new_offset == 0;
1338}
Chris Webb0cd17fe2008-06-28 08:31:46 +10001339
1340/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 * version 1 superblock
1342 */
1343
NeilBrownf72ffdd2014-09-30 14:23:59 +10001344static __le32 calc_sb_1_csum(struct mdp_superblock_1 *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345{
NeilBrown1c05b4b2006-10-21 10:24:08 -07001346 __le32 disk_csum;
1347 u32 csum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 unsigned long long newcsum;
1349 int size = 256 + le32_to_cpu(sb->max_dev)*2;
NeilBrown1c05b4b2006-10-21 10:24:08 -07001350 __le32 *isuper = (__le32*)sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351
1352 disk_csum = sb->sb_csum;
1353 sb->sb_csum = 0;
1354 newcsum = 0;
NeilBrown1f3c9902012-12-11 13:09:00 +11001355 for (; size >= 4; size -= 4)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 newcsum += le32_to_cpu(*isuper++);
1357
1358 if (size == 2)
NeilBrown1c05b4b2006-10-21 10:24:08 -07001359 newcsum += le16_to_cpu(*(__le16*) isuper);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
1361 csum = (newcsum & 0xffffffff) + (newcsum >> 32);
1362 sb->sb_csum = disk_csum;
1363 return cpu_to_le32(csum);
1364}
1365
NeilBrown3cb03002011-10-11 16:45:26 +11001366static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367{
1368 struct mdp_superblock_1 *sb;
1369 int ret;
Andre Noll0f420352008-07-11 22:02:23 +10001370 sector_t sb_start;
NeilBrownc6563a82012-05-21 09:27:00 +10001371 sector_t sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
NeilBrown0002b272005-09-09 16:23:53 -07001373 int bmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374
1375 /*
Andre Noll0f420352008-07-11 22:02:23 +10001376 * Calculate the position of the superblock in 512byte sectors.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 * It is always aligned to a 4K boundary and
1378 * depeding on minor_version, it can be:
1379 * 0: At least 8K, but less than 12K, from end of device
1380 * 1: At start of device
1381 * 2: 4K from start of device.
1382 */
1383 switch(minor_version) {
1384 case 0:
Mike Snitzer77304d22010-11-08 14:39:12 +01001385 sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;
Andre Noll0f420352008-07-11 22:02:23 +10001386 sb_start -= 8*2;
1387 sb_start &= ~(sector_t)(4*2-1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 break;
1389 case 1:
Andre Noll0f420352008-07-11 22:02:23 +10001390 sb_start = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 break;
1392 case 2:
Andre Noll0f420352008-07-11 22:02:23 +10001393 sb_start = 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 break;
1395 default:
1396 return -EINVAL;
1397 }
Andre Noll0f420352008-07-11 22:02:23 +10001398 rdev->sb_start = sb_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
NeilBrown0002b272005-09-09 16:23:53 -07001400 /* superblock is rarely larger than 1K, but it can be larger,
1401 * and it is safe to read 4k, so we do that
1402 */
1403 ret = read_disk_sb(rdev, 4096);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 if (ret) return ret;
1405
Namhyung Kim65a06f062011-07-27 11:00:36 +10001406 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407
1408 if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
1409 sb->major_version != cpu_to_le32(1) ||
1410 le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
Andre Noll0f420352008-07-11 22:02:23 +10001411 le64_to_cpu(sb->super_offset) != rdev->sb_start ||
NeilBrown71c08052005-09-09 16:23:51 -07001412 (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 return -EINVAL;
1414
1415 if (calc_sb_1_csum(sb) != sb->sb_csum) {
1416 printk("md: invalid superblock checksum on %s\n",
1417 bdevname(rdev->bdev,b));
1418 return -EINVAL;
1419 }
1420 if (le64_to_cpu(sb->data_size) < 10) {
1421 printk("md: data_size too small on %s\n",
1422 bdevname(rdev->bdev,b));
1423 return -EINVAL;
1424 }
NeilBrownc6563a82012-05-21 09:27:00 +10001425 if (sb->pad0 ||
1426 sb->pad3[0] ||
1427 memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1])))
1428 /* Some padding is non-zero, might be a new feature */
1429 return -EINVAL;
NeilBrowne11e93f2007-05-09 02:35:36 -07001430
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 rdev->preferred_minor = 0xffff;
1432 rdev->data_offset = le64_to_cpu(sb->data_offset);
NeilBrownc6563a82012-05-21 09:27:00 +10001433 rdev->new_data_offset = rdev->data_offset;
1434 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) &&
1435 (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
1436 rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset);
NeilBrown4dbcdc72006-01-06 00:20:52 -08001437 atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
NeilBrown0002b272005-09-09 16:23:53 -07001439 rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
Martin K. Petersene1defc42009-05-22 17:17:49 -04001440 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
NeilBrown0002b272005-09-09 16:23:53 -07001441 if (rdev->sb_size & bmask)
NeilBrowna1801f82008-03-04 14:29:31 -08001442 rdev->sb_size = (rdev->sb_size | bmask) + 1;
1443
1444 if (minor_version
Andre Noll0f420352008-07-11 22:02:23 +10001445 && rdev->data_offset < sb_start + (rdev->sb_size/512))
NeilBrowna1801f82008-03-04 14:29:31 -08001446 return -EINVAL;
NeilBrownc6563a82012-05-21 09:27:00 +10001447 if (minor_version
1448 && rdev->new_data_offset < sb_start + (rdev->sb_size/512))
1449 return -EINVAL;
NeilBrown0002b272005-09-09 16:23:53 -07001450
NeilBrown31b65a02006-07-10 04:44:14 -07001451 if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
1452 rdev->desc_nr = -1;
1453 else
1454 rdev->desc_nr = le32_to_cpu(sb->dev_number);
1455
NeilBrown2699b672011-07-28 11:31:47 +10001456 if (!rdev->bb_page) {
1457 rdev->bb_page = alloc_page(GFP_KERNEL);
1458 if (!rdev->bb_page)
1459 return -ENOMEM;
1460 }
1461 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
1462 rdev->badblocks.count == 0) {
1463 /* need to load the bad block list.
1464 * Currently we limit it to one page.
1465 */
1466 s32 offset;
1467 sector_t bb_sector;
1468 u64 *bbp;
1469 int i;
1470 int sectors = le16_to_cpu(sb->bblog_size);
1471 if (sectors > (PAGE_SIZE / 512))
1472 return -EINVAL;
1473 offset = le32_to_cpu(sb->bblog_offset);
1474 if (offset == 0)
1475 return -EINVAL;
1476 bb_sector = (long long)offset;
1477 if (!sync_page_io(rdev, bb_sector, sectors << 9,
Mike Christie796a5cf2016-06-05 14:32:07 -05001478 rdev->bb_page, REQ_OP_READ, 0, true))
NeilBrown2699b672011-07-28 11:31:47 +10001479 return -EIO;
1480 bbp = (u64 *)page_address(rdev->bb_page);
1481 rdev->badblocks.shift = sb->bblog_shift;
1482 for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
1483 u64 bb = le64_to_cpu(*bbp);
1484 int count = bb & (0x3ff);
1485 u64 sector = bb >> 10;
1486 sector <<= sb->bblog_shift;
1487 count <<= sb->bblog_shift;
1488 if (bb + 1 == 0)
1489 break;
Vishal Vermafc974ee2015-12-24 19:20:34 -07001490 if (badblocks_set(&rdev->badblocks, sector, count, 1))
NeilBrown2699b672011-07-28 11:31:47 +10001491 return -EINVAL;
1492 }
NeilBrown486adf72013-04-24 11:42:44 +10001493 } else if (sb->bblog_offset != 0)
1494 rdev->badblocks.shift = 0;
NeilBrown2699b672011-07-28 11:31:47 +10001495
Harvey Harrison9a7b2b02008-04-28 02:15:49 -07001496 if (!refdev) {
NeilBrown8ed75462006-02-03 03:03:41 -08001497 ret = 1;
Harvey Harrison9a7b2b02008-04-28 02:15:49 -07001498 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 __u64 ev1, ev2;
Namhyung Kim65a06f062011-07-27 11:00:36 +10001500 struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501
1502 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1503 sb->level != refsb->level ||
1504 sb->layout != refsb->layout ||
1505 sb->chunksize != refsb->chunksize) {
1506 printk(KERN_WARNING "md: %s has strangely different"
1507 " superblock to %s\n",
1508 bdevname(rdev->bdev,b),
1509 bdevname(refdev->bdev,b2));
1510 return -EINVAL;
1511 }
1512 ev1 = le64_to_cpu(sb->events);
1513 ev2 = le64_to_cpu(refsb->events);
1514
1515 if (ev1 > ev2)
NeilBrown8ed75462006-02-03 03:03:41 -08001516 ret = 1;
1517 else
1518 ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 }
NeilBrownc6563a82012-05-21 09:27:00 +10001520 if (minor_version) {
1521 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9);
1522 sectors -= rdev->data_offset;
1523 } else
1524 sectors = rdev->sb_start;
1525 if (sectors < le64_to_cpu(sb->data_size))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 return -EINVAL;
Andre Nolldd8ac332009-03-31 14:33:13 +11001527 rdev->sectors = le64_to_cpu(sb->data_size);
NeilBrown8ed75462006-02-03 03:03:41 -08001528 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529}
1530
NeilBrownfd01b882011-10-11 16:47:53 +11001531static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532{
Namhyung Kim65a06f062011-07-27 11:00:36 +10001533 struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
NeilBrown07d84d102006-06-26 00:27:56 -07001534 __u64 ev1 = le64_to_cpu(sb->events);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535
NeilBrown41158c72005-06-21 17:17:25 -07001536 rdev->raid_disk = -1;
NeilBrownc5d79ad2008-02-06 01:39:54 -08001537 clear_bit(Faulty, &rdev->flags);
1538 clear_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11001539 clear_bit(Bitmap_sync, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001540 clear_bit(WriteMostly, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001541
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 if (mddev->raid_disks == 0) {
1543 mddev->major_version = 1;
1544 mddev->patch_version = 0;
NeilBrowne6910632008-02-06 01:39:51 -08001545 mddev->external = 0;
Andre Noll9d8f0362009-06-18 08:45:01 +10001546 mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11001547 mddev->ctime = le64_to_cpu(sb->ctime);
1548 mddev->utime = le64_to_cpu(sb->utime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 mddev->level = le32_to_cpu(sb->level);
NeilBrownd9d166c2006-01-06 00:20:51 -08001550 mddev->clevel[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 mddev->layout = le32_to_cpu(sb->layout);
1552 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
Andre Noll58c0fed2009-03-31 14:33:13 +11001553 mddev->dev_sectors = le64_to_cpu(sb->size);
NeilBrown07d84d102006-06-26 00:27:56 -07001554 mddev->events = ev1;
NeilBrownc3d97142009-12-14 12:49:52 +11001555 mddev->bitmap_info.offset = 0;
NeilBrown6409bb02012-05-22 13:55:07 +10001556 mddev->bitmap_info.space = 0;
1557 /* Default location for bitmap is 1K after superblock
1558 * using 3K - total of 4K
1559 */
NeilBrownc3d97142009-12-14 12:49:52 +11001560 mddev->bitmap_info.default_offset = 1024 >> 9;
NeilBrown6409bb02012-05-22 13:55:07 +10001561 mddev->bitmap_info.default_space = (4096-1024) >> 9;
NeilBrown2c810cd2012-05-21 09:27:00 +10001562 mddev->reshape_backwards = 0;
1563
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1565 memcpy(mddev->uuid, sb->set_uuid, 16);
1566
1567 mddev->max_disks = (4096-256)/2;
NeilBrowna654b9d82005-06-21 17:17:27 -07001568
NeilBrown71c08052005-09-09 16:23:51 -07001569 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
NeilBrown6409bb02012-05-22 13:55:07 +10001570 mddev->bitmap_info.file == NULL) {
NeilBrownc3d97142009-12-14 12:49:52 +11001571 mddev->bitmap_info.offset =
1572 (__s32)le32_to_cpu(sb->bitmap_offset);
NeilBrown6409bb02012-05-22 13:55:07 +10001573 /* Metadata doesn't record how much space is available.
1574 * For 1.0, we assume we can use up to the superblock
1575 * if before, else to 4K beyond superblock.
1576 * For others, assume no change is possible.
1577 */
1578 if (mddev->minor_version > 0)
1579 mddev->bitmap_info.space = 0;
1580 else if (mddev->bitmap_info.offset > 0)
1581 mddev->bitmap_info.space =
1582 8 - mddev->bitmap_info.offset;
1583 else
1584 mddev->bitmap_info.space =
1585 -mddev->bitmap_info.offset;
1586 }
NeilBrowne11e93f2007-05-09 02:35:36 -07001587
NeilBrownf6705572006-03-27 01:18:11 -08001588 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
1589 mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1590 mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1591 mddev->new_level = le32_to_cpu(sb->new_level);
1592 mddev->new_layout = le32_to_cpu(sb->new_layout);
Andre Noll664e7c42009-06-18 08:45:27 +10001593 mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
NeilBrown2c810cd2012-05-21 09:27:00 +10001594 if (mddev->delta_disks < 0 ||
1595 (mddev->delta_disks == 0 &&
1596 (le32_to_cpu(sb->feature_map)
1597 & MD_FEATURE_RESHAPE_BACKWARDS)))
1598 mddev->reshape_backwards = 1;
NeilBrownf6705572006-03-27 01:18:11 -08001599 } else {
1600 mddev->reshape_position = MaxSector;
1601 mddev->delta_disks = 0;
1602 mddev->new_level = mddev->level;
1603 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001604 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownf6705572006-03-27 01:18:11 -08001605 }
1606
Song Liu486b0f72016-08-19 15:34:01 -07001607 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)
Shaohua Lia62ab492016-01-06 14:37:13 -08001608 set_bit(MD_HAS_JOURNAL, &mddev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001609 } else if (mddev->pers == NULL) {
NeilBrownbe6800a2010-05-18 10:17:09 +10001610 /* Insist of good event counter while assembling, except for
1611 * spares (which don't need an event count) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 ++ev1;
NeilBrownbe6800a2010-05-18 10:17:09 +10001613 if (rdev->desc_nr >= 0 &&
1614 rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
Song Liua3dfbda2015-10-08 21:54:11 -07001615 (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX ||
1616 le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL))
NeilBrownbe6800a2010-05-18 10:17:09 +10001617 if (ev1 < mddev->events)
1618 return -EINVAL;
NeilBrown41158c72005-06-21 17:17:25 -07001619 } else if (mddev->bitmap) {
1620 /* If adding to array with a bitmap, then we can accept an
1621 * older device, but not too old.
1622 */
NeilBrown41158c72005-06-21 17:17:25 -07001623 if (ev1 < mddev->bitmap->events_cleared)
1624 return 0;
NeilBrown8313b8e2013-12-12 10:13:33 +11001625 if (ev1 < mddev->events)
1626 set_bit(Bitmap_sync, &rdev->flags);
NeilBrown07d84d102006-06-26 00:27:56 -07001627 } else {
1628 if (ev1 < mddev->events)
1629 /* just a hot-add of a new device, leave raid_disk at -1 */
1630 return 0;
1631 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 if (mddev->level != LEVEL_MULTIPATH) {
1633 int role;
NeilBrown3673f302009-08-03 10:59:56 +10001634 if (rdev->desc_nr < 0 ||
1635 rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
Song Liuc4d4c912015-08-13 14:31:54 -07001636 role = MD_DISK_ROLE_SPARE;
NeilBrown3673f302009-08-03 10:59:56 +10001637 rdev->desc_nr = -1;
1638 } else
1639 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 switch(role) {
Song Liuc4d4c912015-08-13 14:31:54 -07001641 case MD_DISK_ROLE_SPARE: /* spare */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 break;
Song Liuc4d4c912015-08-13 14:31:54 -07001643 case MD_DISK_ROLE_FAULTY: /* faulty */
NeilBrownb2d444d2005-11-08 21:39:31 -08001644 set_bit(Faulty, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 break;
Song Liubac624f2015-08-13 14:31:55 -07001646 case MD_DISK_ROLE_JOURNAL: /* journal device */
1647 if (!(le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)) {
1648 /* journal device without journal feature */
1649 printk(KERN_WARNING
1650 "md: journal device provided without journal feature, ignoring the device\n");
1651 return -EINVAL;
1652 }
1653 set_bit(Journal, &rdev->flags);
Shaohua Li3069aa82015-08-13 14:31:56 -07001654 rdev->journal_tail = le64_to_cpu(sb->journal_tail);
Shaohua Li9b156032015-12-18 15:19:16 +11001655 rdev->raid_disk = 0;
Song Liubac624f2015-08-13 14:31:55 -07001656 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 default:
NeilBrownf4667222013-12-09 12:04:56 +11001658 rdev->saved_raid_disk = role;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001659 if ((le32_to_cpu(sb->feature_map) &
NeilBrownf4667222013-12-09 12:04:56 +11001660 MD_FEATURE_RECOVERY_OFFSET)) {
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001661 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
NeilBrownf4667222013-12-09 12:04:56 +11001662 if (!(le32_to_cpu(sb->feature_map) &
1663 MD_FEATURE_RECOVERY_BITMAP))
1664 rdev->saved_raid_disk = -1;
Guoqing Jiangbdab1a22019-07-24 11:09:20 +02001665 } else {
1666 /*
1667 * If the array is FROZEN, then the device can't
1668 * be in_sync with rest of array.
1669 */
1670 if (!test_bit(MD_RECOVERY_FROZEN,
1671 &mddev->recovery))
1672 set_bit(In_sync, &rdev->flags);
1673 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 rdev->raid_disk = role;
1675 break;
1676 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07001677 if (sb->devflags & WriteMostly1)
1678 set_bit(WriteMostly, &rdev->flags);
NeilBrown2d78f8c2011-12-23 10:17:51 +11001679 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT)
1680 set_bit(Replacement, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001681 } else /* MULTIPATH are always insync */
NeilBrownb2d444d2005-11-08 21:39:31 -08001682 set_bit(In_sync, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001683
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 return 0;
1685}
1686
NeilBrownfd01b882011-10-11 16:47:53 +11001687static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688{
1689 struct mdp_superblock_1 *sb;
NeilBrown3cb03002011-10-11 16:45:26 +11001690 struct md_rdev *rdev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 int max_dev, i;
1692 /* make rdev->sb match mddev and rdev data. */
1693
Namhyung Kim65a06f062011-07-27 11:00:36 +10001694 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695
1696 sb->feature_map = 0;
1697 sb->pad0 = 0;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001698 sb->recovery_offset = cpu_to_le64(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 memset(sb->pad3, 0, sizeof(sb->pad3));
1700
1701 sb->utime = cpu_to_le64((__u64)mddev->utime);
1702 sb->events = cpu_to_le64(mddev->events);
1703 if (mddev->in_sync)
1704 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
Shaohua Libd18f642015-09-02 13:49:50 -07001705 else if (test_bit(MD_JOURNAL_CLEAN, &mddev->flags))
1706 sb->resync_offset = cpu_to_le64(MaxSector);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 else
1708 sb->resync_offset = cpu_to_le64(0);
1709
NeilBrown1c05b4b2006-10-21 10:24:08 -07001710 sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
NeilBrown4dbcdc72006-01-06 00:20:52 -08001711
NeilBrownf0ca3402006-02-02 14:28:04 -08001712 sb->raid_disks = cpu_to_le32(mddev->raid_disks);
Andre Noll58c0fed2009-03-31 14:33:13 +11001713 sb->size = cpu_to_le64(mddev->dev_sectors);
Andre Noll9d8f0362009-06-18 08:45:01 +10001714 sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
NeilBrown62e1e382009-05-26 09:40:59 +10001715 sb->level = cpu_to_le32(mddev->level);
1716 sb->layout = cpu_to_le32(mddev->layout);
NeilBrownf0ca3402006-02-02 14:28:04 -08001717
NeilBrownaeb9b212011-08-25 14:43:08 +10001718 if (test_bit(WriteMostly, &rdev->flags))
1719 sb->devflags |= WriteMostly1;
1720 else
1721 sb->devflags &= ~WriteMostly1;
NeilBrownc6563a82012-05-21 09:27:00 +10001722 sb->data_offset = cpu_to_le64(rdev->data_offset);
1723 sb->data_size = cpu_to_le64(rdev->sectors);
NeilBrownaeb9b212011-08-25 14:43:08 +10001724
NeilBrownc3d97142009-12-14 12:49:52 +11001725 if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
1726 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
NeilBrown71c08052005-09-09 16:23:51 -07001727 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
NeilBrowna654b9d82005-06-21 17:17:27 -07001728 }
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001729
Shaohua Lif2076e72015-10-08 21:54:12 -07001730 if (rdev->raid_disk >= 0 && !test_bit(Journal, &rdev->flags) &&
NeilBrown97e4f422009-03-31 14:33:13 +11001731 !test_bit(In_sync, &rdev->flags)) {
NeilBrown93be75f2009-12-14 12:50:06 +11001732 sb->feature_map |=
1733 cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
1734 sb->recovery_offset =
1735 cpu_to_le64(rdev->recovery_offset);
NeilBrownf4667222013-12-09 12:04:56 +11001736 if (rdev->saved_raid_disk >= 0 && mddev->bitmap)
1737 sb->feature_map |=
1738 cpu_to_le32(MD_FEATURE_RECOVERY_BITMAP);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001739 }
Shaohua Li3069aa82015-08-13 14:31:56 -07001740 /* Note: recovery_offset and journal_tail share space */
1741 if (test_bit(Journal, &rdev->flags))
1742 sb->journal_tail = cpu_to_le64(rdev->journal_tail);
NeilBrown2d78f8c2011-12-23 10:17:51 +11001743 if (test_bit(Replacement, &rdev->flags))
1744 sb->feature_map |=
1745 cpu_to_le32(MD_FEATURE_REPLACEMENT);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001746
NeilBrownf6705572006-03-27 01:18:11 -08001747 if (mddev->reshape_position != MaxSector) {
1748 sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
1749 sb->reshape_position = cpu_to_le64(mddev->reshape_position);
1750 sb->new_layout = cpu_to_le32(mddev->new_layout);
1751 sb->delta_disks = cpu_to_le32(mddev->delta_disks);
1752 sb->new_level = cpu_to_le32(mddev->new_level);
Andre Noll664e7c42009-06-18 08:45:27 +10001753 sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
NeilBrown2c810cd2012-05-21 09:27:00 +10001754 if (mddev->delta_disks == 0 &&
1755 mddev->reshape_backwards)
1756 sb->feature_map
1757 |= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
NeilBrownc6563a82012-05-21 09:27:00 +10001758 if (rdev->new_data_offset != rdev->data_offset) {
1759 sb->feature_map
1760 |= cpu_to_le32(MD_FEATURE_NEW_OFFSET);
1761 sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset
1762 - rdev->data_offset));
1763 }
NeilBrownf6705572006-03-27 01:18:11 -08001764 }
NeilBrowna654b9d82005-06-21 17:17:27 -07001765
Goldwyn Rodrigues3c462c82015-08-19 07:35:54 +10001766 if (mddev_is_clustered(mddev))
1767 sb->feature_map |= cpu_to_le32(MD_FEATURE_CLUSTERED);
1768
NeilBrown2699b672011-07-28 11:31:47 +10001769 if (rdev->badblocks.count == 0)
1770 /* Nothing to do for bad blocks*/ ;
1771 else if (sb->bblog_offset == 0)
1772 /* Cannot record bad blocks on this device */
1773 md_error(mddev, rdev);
1774 else {
1775 struct badblocks *bb = &rdev->badblocks;
1776 u64 *bbp = (u64 *)page_address(rdev->bb_page);
1777 u64 *p = bb->page;
1778 sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
1779 if (bb->changed) {
1780 unsigned seq;
1781
1782retry:
1783 seq = read_seqbegin(&bb->lock);
1784
1785 memset(bbp, 0xff, PAGE_SIZE);
1786
1787 for (i = 0 ; i < bb->count ; i++) {
majianpeng35f9ac22012-11-08 08:56:27 +08001788 u64 internal_bb = p[i];
NeilBrown2699b672011-07-28 11:31:47 +10001789 u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
1790 | BB_LEN(internal_bb));
majianpeng35f9ac22012-11-08 08:56:27 +08001791 bbp[i] = cpu_to_le64(store_bb);
NeilBrown2699b672011-07-28 11:31:47 +10001792 }
NeilBrownd0962932012-03-19 12:46:41 +11001793 bb->changed = 0;
NeilBrown2699b672011-07-28 11:31:47 +10001794 if (read_seqretry(&bb->lock, seq))
1795 goto retry;
1796
1797 bb->sector = (rdev->sb_start +
1798 (int)le32_to_cpu(sb->bblog_offset));
1799 bb->size = le16_to_cpu(sb->bblog_size);
NeilBrown2699b672011-07-28 11:31:47 +10001800 }
1801 }
1802
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 max_dev = 0;
NeilBrowndafb20f2012-03-19 12:46:39 +11001804 rdev_for_each(rdev2, mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 if (rdev2->desc_nr+1 > max_dev)
1806 max_dev = rdev2->desc_nr+1;
NeilBrowna778b732007-05-23 13:58:10 -07001807
NeilBrown70471da2009-08-03 10:59:57 +10001808 if (max_dev > le32_to_cpu(sb->max_dev)) {
1809 int bmask;
NeilBrowna778b732007-05-23 13:58:10 -07001810 sb->max_dev = cpu_to_le32(max_dev);
NeilBrown70471da2009-08-03 10:59:57 +10001811 rdev->sb_size = max_dev * 2 + 256;
1812 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1813 if (rdev->sb_size & bmask)
1814 rdev->sb_size = (rdev->sb_size | bmask) + 1;
NeilBrownddcf3522010-09-08 16:48:17 +10001815 } else
1816 max_dev = le32_to_cpu(sb->max_dev);
1817
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 for (i=0; i<max_dev;i++)
Song Liuc4d4c912015-08-13 14:31:54 -07001819 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_FAULTY);
NeilBrownf72ffdd2014-09-30 14:23:59 +10001820
Song Liua97b7892015-10-08 21:54:09 -07001821 if (test_bit(MD_HAS_JOURNAL, &mddev->flags))
1822 sb->feature_map |= cpu_to_le32(MD_FEATURE_JOURNAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823
NeilBrowndafb20f2012-03-19 12:46:39 +11001824 rdev_for_each(rdev2, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 i = rdev2->desc_nr;
NeilBrownb2d444d2005-11-08 21:39:31 -08001826 if (test_bit(Faulty, &rdev2->flags))
Song Liuc4d4c912015-08-13 14:31:54 -07001827 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_FAULTY);
NeilBrownb2d444d2005-11-08 21:39:31 -08001828 else if (test_bit(In_sync, &rdev2->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
Song Liua97b7892015-10-08 21:54:09 -07001830 else if (test_bit(Journal, &rdev2->flags))
Song Liubac624f2015-08-13 14:31:55 -07001831 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_JOURNAL);
NeilBrown93be75f2009-12-14 12:50:06 +11001832 else if (rdev2->raid_disk >= 0)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001833 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 else
Song Liuc4d4c912015-08-13 14:31:54 -07001835 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 }
1837
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 sb->sb_csum = calc_sb_1_csum(sb);
1839}
1840
Chris Webb0cd17fe2008-06-28 08:31:46 +10001841static unsigned long long
NeilBrown3cb03002011-10-11 16:45:26 +11001842super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001843{
1844 struct mdp_superblock_1 *sb;
Andre Noll15f4a5f2008-07-21 14:42:12 +10001845 sector_t max_sectors;
Andre Noll58c0fed2009-03-31 14:33:13 +11001846 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001847 return 0; /* component must fit device */
NeilBrownc6563a82012-05-21 09:27:00 +10001848 if (rdev->data_offset != rdev->new_data_offset)
1849 return 0; /* too confusing */
Andre Noll0f420352008-07-11 22:02:23 +10001850 if (rdev->sb_start < rdev->data_offset) {
Chris Webb0cd17fe2008-06-28 08:31:46 +10001851 /* minor versions 1 and 2; superblock before data */
Mike Snitzer77304d22010-11-08 14:39:12 +01001852 max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9;
Andre Noll15f4a5f2008-07-21 14:42:12 +10001853 max_sectors -= rdev->data_offset;
1854 if (!num_sectors || num_sectors > max_sectors)
1855 num_sectors = max_sectors;
NeilBrownc3d97142009-12-14 12:49:52 +11001856 } else if (rdev->mddev->bitmap_info.offset) {
Chris Webb0cd17fe2008-06-28 08:31:46 +10001857 /* minor version 0 with bitmap we can't move */
1858 return 0;
1859 } else {
1860 /* minor version 0; superblock after data */
Andre Noll0f420352008-07-11 22:02:23 +10001861 sector_t sb_start;
Mike Snitzer77304d22010-11-08 14:39:12 +01001862 sb_start = (i_size_read(rdev->bdev->bd_inode) >> 9) - 8*2;
Andre Noll0f420352008-07-11 22:02:23 +10001863 sb_start &= ~(sector_t)(4*2 - 1);
Andre Nolldd8ac332009-03-31 14:33:13 +11001864 max_sectors = rdev->sectors + sb_start - rdev->sb_start;
Andre Noll15f4a5f2008-07-21 14:42:12 +10001865 if (!num_sectors || num_sectors > max_sectors)
1866 num_sectors = max_sectors;
Andre Noll0f420352008-07-11 22:02:23 +10001867 rdev->sb_start = sb_start;
Chris Webb0cd17fe2008-06-28 08:31:46 +10001868 }
Namhyung Kim65a06f062011-07-27 11:00:36 +10001869 sb = page_address(rdev->sb_page);
Andre Noll15f4a5f2008-07-21 14:42:12 +10001870 sb->data_size = cpu_to_le64(num_sectors);
Jason Yan39534032017-03-10 11:27:23 +08001871 sb->super_offset = cpu_to_le64(rdev->sb_start);
Chris Webb0cd17fe2008-06-28 08:31:46 +10001872 sb->sb_csum = calc_sb_1_csum(sb);
Andre Noll0f420352008-07-11 22:02:23 +10001873 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001874 rdev->sb_page);
1875 md_super_wait(rdev->mddev);
Justin Maggardc26a44e2010-11-24 16:36:17 +11001876 return num_sectors;
NeilBrownc6563a82012-05-21 09:27:00 +10001877
1878}
1879
1880static int
1881super_1_allow_new_offset(struct md_rdev *rdev,
1882 unsigned long long new_offset)
1883{
1884 /* All necessary checks on new >= old have been done */
1885 struct bitmap *bitmap;
1886 if (new_offset >= rdev->data_offset)
1887 return 1;
1888
1889 /* with 1.0 metadata, there is no metadata to tread on
1890 * so we can always move back */
1891 if (rdev->mddev->minor_version == 0)
1892 return 1;
1893
1894 /* otherwise we must be sure not to step on
1895 * any metadata, so stay:
1896 * 36K beyond start of superblock
1897 * beyond end of badblocks
1898 * beyond write-intent bitmap
1899 */
1900 if (rdev->sb_start + (32+4)*2 > new_offset)
1901 return 0;
1902 bitmap = rdev->mddev->bitmap;
1903 if (bitmap && !rdev->mddev->bitmap_info.file &&
1904 rdev->sb_start + rdev->mddev->bitmap_info.offset +
NeilBrown1ec885c2012-05-22 13:55:10 +10001905 bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
NeilBrownc6563a82012-05-21 09:27:00 +10001906 return 0;
1907 if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
1908 return 0;
1909
1910 return 1;
Chris Webb0cd17fe2008-06-28 08:31:46 +10001911}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912
Adrian Bunk75c96f82005-05-05 16:16:09 -07001913static struct super_type super_types[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 [0] = {
1915 .name = "0.90.0",
1916 .owner = THIS_MODULE,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001917 .load_super = super_90_load,
1918 .validate_super = super_90_validate,
1919 .sync_super = super_90_sync,
1920 .rdev_size_change = super_90_rdev_size_change,
NeilBrownc6563a82012-05-21 09:27:00 +10001921 .allow_new_offset = super_90_allow_new_offset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 },
1923 [1] = {
1924 .name = "md-1",
1925 .owner = THIS_MODULE,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001926 .load_super = super_1_load,
1927 .validate_super = super_1_validate,
1928 .sync_super = super_1_sync,
1929 .rdev_size_change = super_1_rdev_size_change,
NeilBrownc6563a82012-05-21 09:27:00 +10001930 .allow_new_offset = super_1_allow_new_offset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 },
1932};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933
NeilBrownfd01b882011-10-11 16:47:53 +11001934static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
Jonathan Brassow076f9682011-06-07 17:51:30 -05001935{
1936 if (mddev->sync_super) {
1937 mddev->sync_super(mddev, rdev);
1938 return;
1939 }
1940
1941 BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));
1942
1943 super_types[mddev->major_version].sync_super(mddev, rdev);
1944}
1945
NeilBrownfd01b882011-10-11 16:47:53 +11001946static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947{
NeilBrown3cb03002011-10-11 16:45:26 +11001948 struct md_rdev *rdev, *rdev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949
NeilBrown4b809912008-07-21 17:05:25 +10001950 rcu_read_lock();
Song Liu0b020e82015-09-03 23:00:35 -07001951 rdev_for_each_rcu(rdev, mddev1) {
1952 if (test_bit(Faulty, &rdev->flags) ||
1953 test_bit(Journal, &rdev->flags) ||
1954 rdev->raid_disk == -1)
1955 continue;
1956 rdev_for_each_rcu(rdev2, mddev2) {
1957 if (test_bit(Faulty, &rdev2->flags) ||
1958 test_bit(Journal, &rdev2->flags) ||
1959 rdev2->raid_disk == -1)
1960 continue;
NeilBrown7dd5e7c32007-02-28 20:11:35 -08001961 if (rdev->bdev->bd_contains ==
NeilBrown4b809912008-07-21 17:05:25 +10001962 rdev2->bdev->bd_contains) {
1963 rcu_read_unlock();
NeilBrown7dd5e7c32007-02-28 20:11:35 -08001964 return 1;
NeilBrown4b809912008-07-21 17:05:25 +10001965 }
Song Liu0b020e82015-09-03 23:00:35 -07001966 }
1967 }
NeilBrown4b809912008-07-21 17:05:25 +10001968 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 return 0;
1970}
1971
1972static LIST_HEAD(pending_raid_disks);
1973
Andre Nollac5e7112009-08-03 10:59:47 +10001974/*
1975 * Try to register data integrity profile for an mddev
1976 *
1977 * This is called when an array is started and after a disk has been kicked
1978 * from the array. It only succeeds if all working and active component devices
1979 * are integrity capable with matching profiles.
1980 */
NeilBrownfd01b882011-10-11 16:47:53 +11001981int md_integrity_register(struct mddev *mddev)
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11001982{
NeilBrown3cb03002011-10-11 16:45:26 +11001983 struct md_rdev *rdev, *reference = NULL;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11001984
Andre Nollac5e7112009-08-03 10:59:47 +10001985 if (list_empty(&mddev->disks))
1986 return 0; /* nothing to do */
Jonathan Brassow629acb62011-06-08 15:10:08 +10001987 if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
1988 return 0; /* shouldn't register, or already is */
NeilBrowndafb20f2012-03-19 12:46:39 +11001989 rdev_for_each(rdev, mddev) {
Andre Nollac5e7112009-08-03 10:59:47 +10001990 /* skip spares and non-functional disks */
1991 if (test_bit(Faulty, &rdev->flags))
1992 continue;
1993 if (rdev->raid_disk < 0)
1994 continue;
Andre Nollac5e7112009-08-03 10:59:47 +10001995 if (!reference) {
1996 /* Use the first rdev as the reference */
1997 reference = rdev;
1998 continue;
1999 }
2000 /* does this rdev's profile match the reference profile? */
2001 if (blk_integrity_compare(reference->bdev->bd_disk,
2002 rdev->bdev->bd_disk) < 0)
2003 return -EINVAL;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11002004 }
Martin K. Petersen89078d52011-03-28 20:09:12 -04002005 if (!reference || !bdev_get_integrity(reference->bdev))
2006 return 0;
Andre Nollac5e7112009-08-03 10:59:47 +10002007 /*
2008 * All component devices are integrity capable and have matching
2009 * profiles, register the common profile for the md device.
2010 */
Martin K. Petersen25520d52015-10-21 13:19:49 -04002011 blk_integrity_register(mddev->gendisk,
2012 bdev_get_integrity(reference->bdev));
2013
Martin K. Petersena91a2782011-03-17 11:11:05 +01002014 printk(KERN_NOTICE "md: data integrity enabled on %s\n", mdname(mddev));
2015 if (bioset_integrity_create(mddev->bio_set, BIO_POOL_SIZE)) {
2016 printk(KERN_ERR "md: failed to create integrity pool for %s\n",
2017 mdname(mddev));
2018 return -EINVAL;
2019 }
Andre Nollac5e7112009-08-03 10:59:47 +10002020 return 0;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11002021}
Andre Nollac5e7112009-08-03 10:59:47 +10002022EXPORT_SYMBOL(md_integrity_register);
2023
Dan Williams1501efa2016-01-13 16:00:07 -08002024/*
2025 * Attempt to add an rdev, but only if it is consistent with the current
2026 * integrity profile
2027 */
2028int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
Andre Nollac5e7112009-08-03 10:59:47 +10002029{
Jonathan Brassow2863b9e2012-10-11 13:38:58 +11002030 struct blk_integrity *bi_rdev;
2031 struct blk_integrity *bi_mddev;
Dan Williams1501efa2016-01-13 16:00:07 -08002032 char name[BDEVNAME_SIZE];
Jonathan Brassow2863b9e2012-10-11 13:38:58 +11002033
2034 if (!mddev->gendisk)
Dan Williams1501efa2016-01-13 16:00:07 -08002035 return 0;
Jonathan Brassow2863b9e2012-10-11 13:38:58 +11002036
2037 bi_rdev = bdev_get_integrity(rdev->bdev);
2038 bi_mddev = blk_get_integrity(mddev->gendisk);
Andre Nollac5e7112009-08-03 10:59:47 +10002039
2040 if (!bi_mddev) /* nothing to do */
Dan Williams1501efa2016-01-13 16:00:07 -08002041 return 0;
2042
2043 if (blk_integrity_compare(mddev->gendisk, rdev->bdev->bd_disk) != 0) {
2044 printk(KERN_NOTICE "%s: incompatible integrity profile for %s\n",
2045 mdname(mddev), bdevname(rdev->bdev, name));
2046 return -ENXIO;
2047 }
2048
2049 return 0;
Andre Nollac5e7112009-08-03 10:59:47 +10002050}
2051EXPORT_SYMBOL(md_integrity_add_rdev);
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11002052
NeilBrownf72ffdd2014-09-30 14:23:59 +10002053static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054{
NeilBrown7dd5e7c32007-02-28 20:11:35 -08002055 char b[BDEVNAME_SIZE];
NeilBrownf637b9f2005-11-08 21:39:37 -08002056 struct kobject *ko;
NeilBrown5e55e2f2007-03-26 21:32:14 -08002057 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058
Dan Williams11e2ede2008-04-30 00:52:32 -07002059 /* prevent duplicates */
2060 if (find_rdev(mddev, rdev->bdev->bd_dev))
2061 return -EEXIST;
2062
Andre Nolldd8ac332009-03-31 14:33:13 +11002063 /* make sure rdev->sectors exceeds mddev->dev_sectors */
Shaohua Lif6b6ec52015-12-21 10:51:02 +11002064 if (!test_bit(Journal, &rdev->flags) &&
2065 rdev->sectors &&
2066 (mddev->dev_sectors == 0 || rdev->sectors < mddev->dev_sectors)) {
NeilBrowna778b732007-05-23 13:58:10 -07002067 if (mddev->pers) {
2068 /* Cannot change size, so fail
2069 * If mddev->level <= 0, then we don't care
2070 * about aligning sizes (e.g. linear)
2071 */
2072 if (mddev->level > 0)
2073 return -ENOSPC;
2074 } else
Andre Nolldd8ac332009-03-31 14:33:13 +11002075 mddev->dev_sectors = rdev->sectors;
NeilBrown2bf071b2006-01-06 00:20:55 -08002076 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077
2078 /* Verify rdev->desc_nr is unique.
2079 * If it is -1, assign a free number, else
2080 * check number is not in use
2081 */
NeilBrown4878e9e2014-09-25 17:00:11 +10002082 rcu_read_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 if (rdev->desc_nr < 0) {
2084 int choice = 0;
NeilBrown4878e9e2014-09-25 17:00:11 +10002085 if (mddev->pers)
2086 choice = mddev->raid_disks;
Goldwyn Rodrigues57d051d2015-04-14 10:43:55 -05002087 while (md_find_rdev_nr_rcu(mddev, choice))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 choice++;
2089 rdev->desc_nr = choice;
2090 } else {
Goldwyn Rodrigues57d051d2015-04-14 10:43:55 -05002091 if (md_find_rdev_nr_rcu(mddev, rdev->desc_nr)) {
NeilBrown4878e9e2014-09-25 17:00:11 +10002092 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093 return -EBUSY;
NeilBrown4878e9e2014-09-25 17:00:11 +10002094 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 }
NeilBrown4878e9e2014-09-25 17:00:11 +10002096 rcu_read_unlock();
Shaohua Lif6b6ec52015-12-21 10:51:02 +11002097 if (!test_bit(Journal, &rdev->flags) &&
2098 mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
NeilBrownde01dfa2009-02-06 18:02:46 +11002099 printk(KERN_WARNING "md: %s: array is limited to %d devices\n",
2100 mdname(mddev), mddev->max_disks);
2101 return -EBUSY;
2102 }
NeilBrown19133a42005-11-08 21:39:35 -08002103 bdevname(rdev->bdev,b);
Rasmus Villemoes90a9bef2015-06-25 15:02:36 -07002104 strreplace(b, '/', '!');
Greg Kroah-Hartman649316b2007-12-17 23:05:35 -07002105
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 rdev->mddev = mddev;
NeilBrown19133a42005-11-08 21:39:35 -08002107 printk(KERN_INFO "md: bind<%s>\n", b);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002108
Greg Kroah-Hartmanb2d6db52007-12-17 23:05:35 -07002109 if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
NeilBrown5e55e2f2007-03-26 21:32:14 -08002110 goto fail;
NeilBrown86e6ffd2005-11-08 21:39:24 -08002111
Tejun Heo0762b8b2008-08-25 19:56:12 +09002112 ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
NeilBrown00bcb4a2010-06-01 19:37:23 +10002113 if (sysfs_create_link(&rdev->kobj, ko, "block"))
2114 /* failure here is OK */;
2115 rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
NeilBrown3c0ee632008-10-21 13:25:28 +11002116
NeilBrown4b809912008-07-21 17:05:25 +10002117 list_add_rcu(&rdev->same_set, &mddev->disks);
Tejun Heoe09b4572010-11-13 11:55:17 +01002118 bd_link_disk_holder(rdev->bdev, mddev->gendisk);
NeilBrown4044ba52009-01-09 08:31:11 +11002119
2120 /* May as well allow recovery to be retried once */
NeilBrown53890422011-07-27 11:00:36 +10002121 mddev->recovery_disabled++;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11002122
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 return 0;
NeilBrown5e55e2f2007-03-26 21:32:14 -08002124
2125 fail:
2126 printk(KERN_WARNING "md: failed to register dev-%s for %s\n",
2127 b, mdname(mddev));
2128 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129}
2130
NeilBrown177a99b2008-02-06 01:39:56 -08002131static void md_delayed_delete(struct work_struct *ws)
NeilBrown5792a282007-04-04 19:08:18 -07002132{
NeilBrown3cb03002011-10-11 16:45:26 +11002133 struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
NeilBrown5792a282007-04-04 19:08:18 -07002134 kobject_del(&rdev->kobj);
NeilBrown177a99b2008-02-06 01:39:56 -08002135 kobject_put(&rdev->kobj);
NeilBrown5792a282007-04-04 19:08:18 -07002136}
2137
NeilBrownf72ffdd2014-09-30 14:23:59 +10002138static void unbind_rdev_from_array(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139{
2140 char b[BDEVNAME_SIZE];
NeilBrown403df472014-09-30 15:52:29 +10002141
Tejun Heo49731ba2011-01-14 18:43:57 +01002142 bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
NeilBrown4b809912008-07-21 17:05:25 +10002143 list_del_rcu(&rdev->same_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
2145 rdev->mddev = NULL;
NeilBrown86e6ffd2005-11-08 21:39:24 -08002146 sysfs_remove_link(&rdev->kobj, "block");
NeilBrown3c0ee632008-10-21 13:25:28 +11002147 sysfs_put(rdev->sysfs_state);
2148 rdev->sysfs_state = NULL;
NeilBrown2230dfe2011-07-28 11:31:46 +10002149 rdev->badblocks.count = 0;
NeilBrown5792a282007-04-04 19:08:18 -07002150 /* We need to delay this, otherwise we can deadlock when
NeilBrown4b809912008-07-21 17:05:25 +10002151 * writing to 'remove' to "dev/state". We also need
2152 * to delay it due to rcu usage.
NeilBrown5792a282007-04-04 19:08:18 -07002153 */
NeilBrown4b809912008-07-21 17:05:25 +10002154 synchronize_rcu();
NeilBrown177a99b2008-02-06 01:39:56 -08002155 INIT_WORK(&rdev->del_work, md_delayed_delete);
2156 kobject_get(&rdev->kobj);
Tejun Heoe804ac72010-10-15 15:36:08 +02002157 queue_work(md_misc_wq, &rdev->del_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158}
2159
2160/*
2161 * prevent the device from being mounted, repartitioned or
2162 * otherwise reused by a RAID array (or any other kernel
2163 * subsystem), by bd_claiming the device.
2164 */
NeilBrown3cb03002011-10-11 16:45:26 +11002165static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166{
2167 int err = 0;
2168 struct block_device *bdev;
2169 char b[BDEVNAME_SIZE];
2170
Tejun Heod4d77622010-11-13 11:55:18 +01002171 bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
NeilBrown3cb03002011-10-11 16:45:26 +11002172 shared ? (struct md_rdev *)lock_rdev : rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 if (IS_ERR(bdev)) {
2174 printk(KERN_ERR "md: could not open %s.\n",
2175 __bdevname(dev, b));
2176 return PTR_ERR(bdev);
2177 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178 rdev->bdev = bdev;
2179 return err;
2180}
2181
NeilBrown3cb03002011-10-11 16:45:26 +11002182static void unlock_rdev(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183{
2184 struct block_device *bdev = rdev->bdev;
2185 rdev->bdev = NULL;
Tejun Heoe525fd82010-11-13 11:55:17 +01002186 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187}
2188
2189void md_autodetect_dev(dev_t dev);
2190
NeilBrownf72ffdd2014-09-30 14:23:59 +10002191static void export_rdev(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192{
2193 char b[BDEVNAME_SIZE];
NeilBrown403df472014-09-30 15:52:29 +10002194
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 printk(KERN_INFO "md: export_rdev(%s)\n",
2196 bdevname(rdev->bdev,b));
NeilBrown545c8792012-05-22 13:54:30 +10002197 md_rdev_clear(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198#ifndef MODULE
NeilBrownd0fae182008-03-04 14:29:31 -08002199 if (test_bit(AutoDetected, &rdev->flags))
2200 md_autodetect_dev(rdev->bdev->bd_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201#endif
2202 unlock_rdev(rdev);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002203 kobject_put(&rdev->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204}
2205
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05002206void md_kick_rdev_from_array(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207{
2208 unbind_rdev_from_array(rdev);
2209 export_rdev(rdev);
2210}
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05002211EXPORT_SYMBOL_GPL(md_kick_rdev_from_array);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212
NeilBrownfd01b882011-10-11 16:47:53 +11002213static void export_array(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214{
NeilBrown0638bb02014-09-25 17:43:47 +10002215 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216
NeilBrown0638bb02014-09-25 17:43:47 +10002217 while (!list_empty(&mddev->disks)) {
2218 rdev = list_first_entry(&mddev->disks, struct md_rdev,
2219 same_set);
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05002220 md_kick_rdev_from_array(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222 mddev->raid_disks = 0;
2223 mddev->major_version = 0;
2224}
2225
NeilBrownf72ffdd2014-09-30 14:23:59 +10002226static void sync_sbs(struct mddev *mddev, int nospares)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227{
NeilBrown42543762006-06-26 00:27:57 -07002228 /* Update each superblock (in-memory image), but
2229 * if we are allowed to, skip spares which already
2230 * have the right event counter, or have one earlier
2231 * (which would mean they aren't being marked as dirty
2232 * with the rest of the array)
2233 */
NeilBrown3cb03002011-10-11 16:45:26 +11002234 struct md_rdev *rdev;
NeilBrowndafb20f2012-03-19 12:46:39 +11002235 rdev_for_each(rdev, mddev) {
NeilBrown42543762006-06-26 00:27:57 -07002236 if (rdev->sb_events == mddev->events ||
2237 (nospares &&
2238 rdev->raid_disk < 0 &&
NeilBrown42543762006-06-26 00:27:57 -07002239 rdev->sb_events+1 == mddev->events)) {
2240 /* Don't update this superblock */
2241 rdev->sb_loaded = 2;
2242 } else {
Jonathan Brassow076f9682011-06-07 17:51:30 -05002243 sync_super(mddev, rdev);
NeilBrown42543762006-06-26 00:27:57 -07002244 rdev->sb_loaded = 1;
2245 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 }
2247}
2248
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002249static bool does_sb_need_changing(struct mddev *mddev)
2250{
2251 struct md_rdev *rdev;
2252 struct mdp_superblock_1 *sb;
2253 int role;
2254
2255 /* Find a good rdev */
2256 rdev_for_each(rdev, mddev)
2257 if ((rdev->raid_disk >= 0) && !test_bit(Faulty, &rdev->flags))
2258 break;
2259
2260 /* No good device found. */
2261 if (!rdev)
2262 return false;
2263
2264 sb = page_address(rdev->sb_page);
2265 /* Check if a device has become faulty or a spare become active */
2266 rdev_for_each(rdev, mddev) {
2267 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
2268 /* Device activated? */
2269 if (role == 0xffff && rdev->raid_disk >=0 &&
2270 !test_bit(Faulty, &rdev->flags))
2271 return true;
2272 /* Device turned faulty? */
2273 if (test_bit(Faulty, &rdev->flags) && (role < 0xfffd))
2274 return true;
2275 }
2276
2277 /* Check if any mddev parameters have changed */
2278 if ((mddev->dev_sectors != le64_to_cpu(sb->size)) ||
2279 (mddev->reshape_position != le64_to_cpu(sb->reshape_position)) ||
Jason Yan9a37d022017-03-10 11:49:12 +08002280 (mddev->layout != le32_to_cpu(sb->layout)) ||
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002281 (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) ||
2282 (mddev->chunk_sectors != le32_to_cpu(sb->chunksize)))
2283 return true;
2284
2285 return false;
2286}
2287
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05002288void md_update_sb(struct mddev *mddev, int force_change)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289{
NeilBrown3cb03002011-10-11 16:45:26 +11002290 struct md_rdev *rdev;
NeilBrown06d91a52005-06-21 17:17:12 -07002291 int sync_req;
NeilBrown42543762006-06-26 00:27:57 -07002292 int nospares = 0;
NeilBrown2699b672011-07-28 11:31:47 +10002293 int any_badblocks_changed = 0;
Guoqing Jiang23b63f92015-10-12 17:21:30 +08002294 int ret = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295
NeilBrownd87f0642013-04-24 11:42:40 +10002296 if (mddev->ro) {
2297 if (force_change)
2298 set_bit(MD_CHANGE_DEVS, &mddev->flags);
2299 return;
2300 }
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002301
Guoqing Jiang2c97cf12016-05-02 11:33:09 -04002302repeat:
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002303 if (mddev_is_clustered(mddev)) {
2304 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
2305 force_change = 1;
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04002306 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
2307 nospares = 1;
Guoqing Jiang23b63f92015-10-12 17:21:30 +08002308 ret = md_cluster_ops->metadata_update_start(mddev);
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002309 /* Has someone else has updated the sb */
2310 if (!does_sb_need_changing(mddev)) {
Guoqing Jiang23b63f92015-10-12 17:21:30 +08002311 if (ret == 0)
2312 md_cluster_ops->metadata_update_cancel(mddev);
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04002313 bit_clear_unless(&mddev->flags, BIT(MD_CHANGE_PENDING),
2314 BIT(MD_CHANGE_DEVS) |
2315 BIT(MD_CHANGE_CLEAN));
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002316 return;
2317 }
2318 }
Guoqing Jiang2c97cf12016-05-02 11:33:09 -04002319
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002320 /* First make sure individual recovery_offsets are correct */
NeilBrowndafb20f2012-03-19 12:46:39 +11002321 rdev_for_each(rdev, mddev) {
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002322 if (rdev->raid_disk >= 0 &&
2323 mddev->delta_disks >= 0 &&
Shaohua Lif2076e72015-10-08 21:54:12 -07002324 !test_bit(Journal, &rdev->flags) &&
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002325 !test_bit(In_sync, &rdev->flags) &&
2326 mddev->curr_resync_completed > rdev->recovery_offset)
2327 rdev->recovery_offset = mddev->curr_resync_completed;
2328
NeilBrownf72ffdd2014-09-30 14:23:59 +10002329 }
Dan Williamsbd52b742010-08-30 17:33:33 +10002330 if (!mddev->persistent) {
NeilBrown070dc6d2010-08-30 17:33:34 +10002331 clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002332 clear_bit(MD_CHANGE_DEVS, &mddev->flags);
NeilBrownde393cd2011-07-28 11:31:48 +10002333 if (!mddev->external) {
NeilBrownd97a41d2010-10-28 17:30:20 +11002334 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrowndafb20f2012-03-19 12:46:39 +11002335 rdev_for_each(rdev, mddev) {
NeilBrownde393cd2011-07-28 11:31:48 +10002336 if (rdev->badblocks.changed) {
NeilBrownd0962932012-03-19 12:46:41 +11002337 rdev->badblocks.changed = 0;
Vishal Vermafc974ee2015-12-24 19:20:34 -07002338 ack_all_badblocks(&rdev->badblocks);
NeilBrownde393cd2011-07-28 11:31:48 +10002339 md_error(mddev, rdev);
2340 }
2341 clear_bit(Blocked, &rdev->flags);
2342 clear_bit(BlockedBadBlocks, &rdev->flags);
2343 wake_up(&rdev->blocked_wait);
2344 }
2345 }
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002346 wake_up(&mddev->sb_wait);
2347 return;
2348 }
2349
NeilBrown85572d72014-12-15 12:56:56 +11002350 spin_lock(&mddev->lock);
NeilBrown84692192006-08-27 01:23:49 -07002351
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11002352 mddev->utime = ktime_get_real_seconds();
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002353
NeilBrown850b2b42006-10-03 01:15:46 -07002354 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
2355 force_change = 1;
2356 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
2357 /* just a clean<-> dirty transition, possibly leave spares alone,
2358 * though if events isn't the right even/odd, we will have to do
2359 * spares after all
2360 */
2361 nospares = 1;
2362 if (force_change)
2363 nospares = 0;
2364 if (mddev->degraded)
NeilBrown84692192006-08-27 01:23:49 -07002365 /* If the array is degraded, then skipping spares is both
2366 * dangerous and fairly pointless.
2367 * Dangerous because a device that was removed from the array
2368 * might have a event_count that still looks up-to-date,
2369 * so it can be re-added without a resync.
2370 * Pointless because if there are any spares to skip,
2371 * then a recovery will happen and soon that array won't
2372 * be degraded any more and the spare can go back to sleep then.
2373 */
NeilBrown850b2b42006-10-03 01:15:46 -07002374 nospares = 0;
NeilBrown84692192006-08-27 01:23:49 -07002375
NeilBrown06d91a52005-06-21 17:17:12 -07002376 sync_req = mddev->in_sync;
NeilBrown42543762006-06-26 00:27:57 -07002377
2378 /* If this is just a dirty<->clean transition, and the array is clean
2379 * and 'events' is odd, we can roll back to the previous clean state */
NeilBrown850b2b42006-10-03 01:15:46 -07002380 if (nospares
NeilBrown42543762006-06-26 00:27:57 -07002381 && (mddev->in_sync && mddev->recovery_cp == MaxSector)
NeilBrowna8707c02010-05-18 09:28:43 +10002382 && mddev->can_decrease_events
2383 && mddev->events != 1) {
NeilBrown42543762006-06-26 00:27:57 -07002384 mddev->events--;
NeilBrowna8707c02010-05-18 09:28:43 +10002385 mddev->can_decrease_events = 0;
2386 } else {
NeilBrown42543762006-06-26 00:27:57 -07002387 /* otherwise we have to go forward and ... */
2388 mddev->events ++;
NeilBrowna8707c02010-05-18 09:28:43 +10002389 mddev->can_decrease_events = nospares;
NeilBrown42543762006-06-26 00:27:57 -07002390 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391
NeilBrown403df472014-09-30 15:52:29 +10002392 /*
2393 * This 64-bit counter should never wrap.
2394 * Either we are in around ~1 trillion A.C., assuming
2395 * 1 reboot per second, or we have a bug...
2396 */
2397 WARN_ON(mddev->events == 0);
NeilBrown2699b672011-07-28 11:31:47 +10002398
NeilBrowndafb20f2012-03-19 12:46:39 +11002399 rdev_for_each(rdev, mddev) {
NeilBrown2699b672011-07-28 11:31:47 +10002400 if (rdev->badblocks.changed)
2401 any_badblocks_changed++;
NeilBrownde393cd2011-07-28 11:31:48 +10002402 if (test_bit(Faulty, &rdev->flags))
2403 set_bit(FaultRecorded, &rdev->flags);
2404 }
NeilBrown2699b672011-07-28 11:31:47 +10002405
NeilBrowne6910632008-02-06 01:39:51 -08002406 sync_sbs(mddev, nospares);
NeilBrown85572d72014-12-15 12:56:56 +11002407 spin_unlock(&mddev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408
NeilBrown36a4e1f2011-10-07 14:23:17 +11002409 pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
2410 mdname(mddev), mddev->in_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411
NeilBrown4ad13662007-07-17 04:06:13 -07002412 bitmap_update_sb(mddev->bitmap);
NeilBrowndafb20f2012-03-19 12:46:39 +11002413 rdev_for_each(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414 char b[BDEVNAME_SIZE];
NeilBrown36a4e1f2011-10-07 14:23:17 +11002415
NeilBrown42543762006-06-26 00:27:57 -07002416 if (rdev->sb_loaded != 1)
2417 continue; /* no noise on spare devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418
NeilBrownf4667222013-12-09 12:04:56 +11002419 if (!test_bit(Faulty, &rdev->flags)) {
NeilBrown7bfa19f2005-06-21 17:17:28 -07002420 md_super_write(mddev,rdev,
Andre Noll0f420352008-07-11 22:02:23 +10002421 rdev->sb_start, rdev->sb_size,
NeilBrown7bfa19f2005-06-21 17:17:28 -07002422 rdev->sb_page);
NeilBrown36a4e1f2011-10-07 14:23:17 +11002423 pr_debug("md: (write) %s's sb offset: %llu\n",
2424 bdevname(rdev->bdev, b),
2425 (unsigned long long)rdev->sb_start);
NeilBrown42543762006-06-26 00:27:57 -07002426 rdev->sb_events = mddev->events;
NeilBrown2699b672011-07-28 11:31:47 +10002427 if (rdev->badblocks.size) {
2428 md_super_write(mddev, rdev,
2429 rdev->badblocks.sector,
2430 rdev->badblocks.size << 9,
2431 rdev->bb_page);
2432 rdev->badblocks.size = 0;
2433 }
NeilBrown7bfa19f2005-06-21 17:17:28 -07002434
NeilBrownf4667222013-12-09 12:04:56 +11002435 } else
NeilBrown36a4e1f2011-10-07 14:23:17 +11002436 pr_debug("md: %s (skipping faulty)\n",
2437 bdevname(rdev->bdev, b));
Andrei Warkentind70ed2e2011-10-18 12:16:48 +11002438
NeilBrown7bfa19f2005-06-21 17:17:28 -07002439 if (mddev->level == LEVEL_MULTIPATH)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440 /* only need to write one superblock... */
2441 break;
2442 }
NeilBrowna9701a32005-11-08 21:39:34 -08002443 md_super_wait(mddev);
NeilBrown850b2b42006-10-03 01:15:46 -07002444 /* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
NeilBrown7bfa19f2005-06-21 17:17:28 -07002445
Guoqing Jiang2c97cf12016-05-02 11:33:09 -04002446 if (mddev_is_clustered(mddev) && ret == 0)
2447 md_cluster_ops->metadata_update_finish(mddev);
2448
NeilBrown850b2b42006-10-03 01:15:46 -07002449 if (mddev->in_sync != sync_req ||
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04002450 !bit_clear_unless(&mddev->flags, BIT(MD_CHANGE_PENDING),
2451 BIT(MD_CHANGE_DEVS) | BIT(MD_CHANGE_CLEAN)))
NeilBrown06d91a52005-06-21 17:17:12 -07002452 /* have to write it out again */
NeilBrown06d91a52005-06-21 17:17:12 -07002453 goto repeat;
NeilBrown3d310eb2005-06-21 17:17:26 -07002454 wake_up(&mddev->sb_wait);
NeilBrownacb180b2009-04-14 16:28:34 +10002455 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2456 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
NeilBrown06d91a52005-06-21 17:17:12 -07002457
NeilBrowndafb20f2012-03-19 12:46:39 +11002458 rdev_for_each(rdev, mddev) {
NeilBrownde393cd2011-07-28 11:31:48 +10002459 if (test_and_clear_bit(FaultRecorded, &rdev->flags))
2460 clear_bit(Blocked, &rdev->flags);
2461
2462 if (any_badblocks_changed)
Vishal Vermafc974ee2015-12-24 19:20:34 -07002463 ack_all_badblocks(&rdev->badblocks);
NeilBrownde393cd2011-07-28 11:31:48 +10002464 clear_bit(BlockedBadBlocks, &rdev->flags);
2465 wake_up(&rdev->blocked_wait);
2466 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467}
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05002468EXPORT_SYMBOL(md_update_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002470static int add_bound_rdev(struct md_rdev *rdev)
2471{
2472 struct mddev *mddev = rdev->mddev;
2473 int err = 0;
Shaohua Li87d4d912016-01-06 14:37:14 -08002474 bool add_journal = test_bit(Journal, &rdev->flags);
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002475
Shaohua Li87d4d912016-01-06 14:37:14 -08002476 if (!mddev->pers->hot_remove_disk || add_journal) {
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002477 /* If there is hot_add_disk but no hot_remove_disk
2478 * then added disks for geometry changes,
2479 * and should be added immediately.
2480 */
2481 super_types[mddev->major_version].
2482 validate_super(mddev, rdev);
Shaohua Li87d4d912016-01-06 14:37:14 -08002483 if (add_journal)
2484 mddev_suspend(mddev);
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002485 err = mddev->pers->hot_add_disk(mddev, rdev);
Shaohua Li87d4d912016-01-06 14:37:14 -08002486 if (add_journal)
2487 mddev_resume(mddev);
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002488 if (err) {
Guoqing Jiangdb767672016-06-02 23:32:05 -04002489 md_kick_rdev_from_array(rdev);
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002490 return err;
2491 }
2492 }
2493 sysfs_notify_dirent_safe(rdev->sysfs_state);
2494
2495 set_bit(MD_CHANGE_DEVS, &mddev->flags);
2496 if (mddev->degraded)
2497 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
2498 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2499 md_new_event(mddev);
2500 md_wakeup_thread(mddev->thread);
2501 return 0;
2502}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503
Andre Noll7f6ce762008-03-23 18:34:54 +01002504/* words written to sysfs files may, or may not, be \n terminated.
NeilBrownbce74da2006-01-06 00:20:41 -08002505 * We want to accept with case. For this we use cmd_match.
2506 */
2507static int cmd_match(const char *cmd, const char *str)
2508{
2509 /* See if cmd, written into a sysfs file, matches
2510 * str. They must either be the same, or cmd can
2511 * have a trailing newline
2512 */
2513 while (*cmd && *str && *cmd == *str) {
2514 cmd++;
2515 str++;
2516 }
2517 if (*cmd == '\n')
2518 cmd++;
2519 if (*str || *cmd)
2520 return 0;
2521 return 1;
2522}
2523
NeilBrown86e6ffd2005-11-08 21:39:24 -08002524struct rdev_sysfs_entry {
2525 struct attribute attr;
NeilBrown3cb03002011-10-11 16:45:26 +11002526 ssize_t (*show)(struct md_rdev *, char *);
2527 ssize_t (*store)(struct md_rdev *, const char *, size_t);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002528};
2529
2530static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002531state_show(struct md_rdev *rdev, char *page)
NeilBrown86e6ffd2005-11-08 21:39:24 -08002532{
2533 char *sep = "";
NeilBrown20a49ff2008-02-06 01:39:57 -08002534 size_t len = 0;
NeilBrown758bfc82014-12-15 12:56:59 +11002535 unsigned long flags = ACCESS_ONCE(rdev->flags);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002536
NeilBrown758bfc82014-12-15 12:56:59 +11002537 if (test_bit(Faulty, &flags) ||
NeilBrownde393cd2011-07-28 11:31:48 +10002538 rdev->badblocks.unacked_exist) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08002539 len+= sprintf(page+len, "%sfaulty",sep);
2540 sep = ",";
2541 }
NeilBrown758bfc82014-12-15 12:56:59 +11002542 if (test_bit(In_sync, &flags)) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08002543 len += sprintf(page+len, "%sin_sync",sep);
2544 sep = ",";
2545 }
Shaohua Liac6096e2015-10-04 09:20:11 -07002546 if (test_bit(Journal, &flags)) {
2547 len += sprintf(page+len, "%sjournal",sep);
2548 sep = ",";
2549 }
NeilBrown758bfc82014-12-15 12:56:59 +11002550 if (test_bit(WriteMostly, &flags)) {
NeilBrownf6556752006-06-26 00:28:01 -07002551 len += sprintf(page+len, "%swrite_mostly",sep);
2552 sep = ",";
2553 }
NeilBrown758bfc82014-12-15 12:56:59 +11002554 if (test_bit(Blocked, &flags) ||
NeilBrown52c64152011-12-08 16:22:48 +11002555 (rdev->badblocks.unacked_exist
NeilBrown758bfc82014-12-15 12:56:59 +11002556 && !test_bit(Faulty, &flags))) {
Dan Williams6bfe0b42008-04-30 00:52:32 -07002557 len += sprintf(page+len, "%sblocked", sep);
2558 sep = ",";
2559 }
NeilBrown758bfc82014-12-15 12:56:59 +11002560 if (!test_bit(Faulty, &flags) &&
Shaohua Lif2076e72015-10-08 21:54:12 -07002561 !test_bit(Journal, &flags) &&
NeilBrown758bfc82014-12-15 12:56:59 +11002562 !test_bit(In_sync, &flags)) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08002563 len += sprintf(page+len, "%sspare", sep);
2564 sep = ",";
2565 }
NeilBrown758bfc82014-12-15 12:56:59 +11002566 if (test_bit(WriteErrorSeen, &flags)) {
NeilBrownd7a9d442011-07-28 11:31:48 +10002567 len += sprintf(page+len, "%swrite_error", sep);
2568 sep = ",";
2569 }
NeilBrown758bfc82014-12-15 12:56:59 +11002570 if (test_bit(WantReplacement, &flags)) {
NeilBrown2d78f8c2011-12-23 10:17:51 +11002571 len += sprintf(page+len, "%swant_replacement", sep);
2572 sep = ",";
2573 }
NeilBrown758bfc82014-12-15 12:56:59 +11002574 if (test_bit(Replacement, &flags)) {
NeilBrown2d78f8c2011-12-23 10:17:51 +11002575 len += sprintf(page+len, "%sreplacement", sep);
2576 sep = ",";
2577 }
2578
NeilBrown86e6ffd2005-11-08 21:39:24 -08002579 return len+sprintf(page+len, "\n");
2580}
2581
NeilBrown45dc2de2006-06-26 00:27:58 -07002582static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002583state_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown45dc2de2006-06-26 00:27:58 -07002584{
2585 /* can write
NeilBrownde393cd2011-07-28 11:31:48 +10002586 * faulty - simulates an error
NeilBrown45dc2de2006-06-26 00:27:58 -07002587 * remove - disconnects the device
NeilBrownf6556752006-06-26 00:28:01 -07002588 * writemostly - sets write_mostly
2589 * -writemostly - clears write_mostly
NeilBrownde393cd2011-07-28 11:31:48 +10002590 * blocked - sets the Blocked flags
2591 * -blocked - clears the Blocked and possibly simulates an error
NeilBrown6d56e272009-04-14 12:01:57 +10002592 * insync - sets Insync providing device isn't active
NeilBrownf4667222013-12-09 12:04:56 +11002593 * -insync - clear Insync for a device with a slot assigned,
2594 * so that it gets rebuilt based on bitmap
NeilBrownd7a9d442011-07-28 11:31:48 +10002595 * write_error - sets WriteErrorSeen
2596 * -write_error - clears WriteErrorSeen
NeilBrown45dc2de2006-06-26 00:27:58 -07002597 */
2598 int err = -EINVAL;
2599 if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2600 md_error(rdev->mddev, rdev);
NeilBrown5ef56c82011-08-25 14:42:51 +10002601 if (test_bit(Faulty, &rdev->flags))
2602 err = 0;
2603 else
2604 err = -EBUSY;
NeilBrown45dc2de2006-06-26 00:27:58 -07002605 } else if (cmd_match(buf, "remove")) {
Shaohua Li5d881782016-07-28 09:06:34 -07002606 if (rdev->mddev->pers) {
2607 clear_bit(Blocked, &rdev->flags);
2608 remove_and_add_spares(rdev->mddev, rdev);
2609 }
NeilBrown45dc2de2006-06-26 00:27:58 -07002610 if (rdev->raid_disk >= 0)
2611 err = -EBUSY;
2612 else {
NeilBrownfd01b882011-10-11 16:47:53 +11002613 struct mddev *mddev = rdev->mddev;
NeilBrown45dc2de2006-06-26 00:27:58 -07002614 err = 0;
Guoqing Jianga9720902015-10-12 17:21:27 +08002615 if (mddev_is_clustered(mddev))
2616 err = md_cluster_ops->remove_disk(mddev, rdev);
2617
2618 if (err == 0) {
2619 md_kick_rdev_from_array(rdev);
2620 if (mddev->pers)
2621 md_update_sb(mddev, 1);
2622 md_new_event(mddev);
2623 }
NeilBrown45dc2de2006-06-26 00:27:58 -07002624 }
NeilBrownf6556752006-06-26 00:28:01 -07002625 } else if (cmd_match(buf, "writemostly")) {
2626 set_bit(WriteMostly, &rdev->flags);
2627 err = 0;
2628 } else if (cmd_match(buf, "-writemostly")) {
2629 clear_bit(WriteMostly, &rdev->flags);
2630 err = 0;
Dan Williams6bfe0b42008-04-30 00:52:32 -07002631 } else if (cmd_match(buf, "blocked")) {
2632 set_bit(Blocked, &rdev->flags);
2633 err = 0;
2634 } else if (cmd_match(buf, "-blocked")) {
NeilBrownde393cd2011-07-28 11:31:48 +10002635 if (!test_bit(Faulty, &rdev->flags) &&
NeilBrown7da64a02011-08-30 16:20:17 +10002636 rdev->badblocks.unacked_exist) {
NeilBrownde393cd2011-07-28 11:31:48 +10002637 /* metadata handler doesn't understand badblocks,
2638 * so we need to fail the device
2639 */
2640 md_error(rdev->mddev, rdev);
2641 }
Dan Williams6bfe0b42008-04-30 00:52:32 -07002642 clear_bit(Blocked, &rdev->flags);
NeilBrownde393cd2011-07-28 11:31:48 +10002643 clear_bit(BlockedBadBlocks, &rdev->flags);
Dan Williams6bfe0b42008-04-30 00:52:32 -07002644 wake_up(&rdev->blocked_wait);
2645 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2646 md_wakeup_thread(rdev->mddev->thread);
2647
2648 err = 0;
NeilBrown6d56e272009-04-14 12:01:57 +10002649 } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
2650 set_bit(In_sync, &rdev->flags);
2651 err = 0;
Shaohua Lif2076e72015-10-08 21:54:12 -07002652 } else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0 &&
2653 !test_bit(Journal, &rdev->flags)) {
NeilBrowne1960f82014-09-30 15:24:25 +10002654 if (rdev->mddev->pers == NULL) {
2655 clear_bit(In_sync, &rdev->flags);
2656 rdev->saved_raid_disk = rdev->raid_disk;
2657 rdev->raid_disk = -1;
2658 err = 0;
2659 }
NeilBrownd7a9d442011-07-28 11:31:48 +10002660 } else if (cmd_match(buf, "write_error")) {
2661 set_bit(WriteErrorSeen, &rdev->flags);
2662 err = 0;
2663 } else if (cmd_match(buf, "-write_error")) {
2664 clear_bit(WriteErrorSeen, &rdev->flags);
2665 err = 0;
NeilBrown2d78f8c2011-12-23 10:17:51 +11002666 } else if (cmd_match(buf, "want_replacement")) {
2667 /* Any non-spare device that is not a replacement can
2668 * become want_replacement at any time, but we then need to
2669 * check if recovery is needed.
2670 */
2671 if (rdev->raid_disk >= 0 &&
Shaohua Lif2076e72015-10-08 21:54:12 -07002672 !test_bit(Journal, &rdev->flags) &&
NeilBrown2d78f8c2011-12-23 10:17:51 +11002673 !test_bit(Replacement, &rdev->flags))
2674 set_bit(WantReplacement, &rdev->flags);
2675 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2676 md_wakeup_thread(rdev->mddev->thread);
2677 err = 0;
2678 } else if (cmd_match(buf, "-want_replacement")) {
2679 /* Clearing 'want_replacement' is always allowed.
2680 * Once replacements starts it is too late though.
2681 */
2682 err = 0;
2683 clear_bit(WantReplacement, &rdev->flags);
2684 } else if (cmd_match(buf, "replacement")) {
2685 /* Can only set a device as a replacement when array has not
2686 * yet been started. Once running, replacement is automatic
2687 * from spares, or by assigning 'slot'.
2688 */
2689 if (rdev->mddev->pers)
2690 err = -EBUSY;
2691 else {
2692 set_bit(Replacement, &rdev->flags);
2693 err = 0;
2694 }
2695 } else if (cmd_match(buf, "-replacement")) {
2696 /* Similarly, can only clear Replacement before start */
2697 if (rdev->mddev->pers)
2698 err = -EBUSY;
2699 else {
2700 clear_bit(Replacement, &rdev->flags);
2701 err = 0;
2702 }
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002703 } else if (cmd_match(buf, "re-add")) {
Yufen Yucd72ddca2019-04-02 14:22:14 +08002704 if (!rdev->mddev->pers)
2705 err = -EINVAL;
2706 else if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1) &&
2707 rdev->saved_raid_disk >= 0) {
Goldwyn Rodrigues97f6cd32015-04-14 10:45:42 -05002708 /* clear_bit is performed _after_ all the devices
2709 * have their local Faulty bit cleared. If any writes
2710 * happen in the meantime in the local node, they
2711 * will land in the local bitmap, which will be synced
2712 * by this node eventually
2713 */
2714 if (!mddev_is_clustered(rdev->mddev) ||
2715 (err = md_cluster_ops->gather_bitmaps(rdev)) == 0) {
2716 clear_bit(Faulty, &rdev->flags);
2717 err = add_bound_rdev(rdev);
2718 }
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002719 } else
2720 err = -EBUSY;
NeilBrown45dc2de2006-06-26 00:27:58 -07002721 }
NeilBrown00bcb4a2010-06-01 19:37:23 +10002722 if (!err)
2723 sysfs_notify_dirent_safe(rdev->sysfs_state);
NeilBrown45dc2de2006-06-26 00:27:58 -07002724 return err ? err : len;
2725}
NeilBrown80ca3a42006-07-10 04:44:18 -07002726static struct rdev_sysfs_entry rdev_state =
NeilBrown750f1992014-09-30 08:53:05 +10002727__ATTR_PREALLOC(state, S_IRUGO|S_IWUSR, state_show, state_store);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002728
2729static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002730errors_show(struct md_rdev *rdev, char *page)
NeilBrown4dbcdc72006-01-06 00:20:52 -08002731{
2732 return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
2733}
2734
2735static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002736errors_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown4dbcdc72006-01-06 00:20:52 -08002737{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03002738 unsigned int n;
2739 int rv;
2740
2741 rv = kstrtouint(buf, 10, &n);
2742 if (rv < 0)
2743 return rv;
2744 atomic_set(&rdev->corrected_errors, n);
2745 return len;
NeilBrown4dbcdc72006-01-06 00:20:52 -08002746}
2747static struct rdev_sysfs_entry rdev_errors =
NeilBrown80ca3a42006-07-10 04:44:18 -07002748__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
NeilBrown4dbcdc72006-01-06 00:20:52 -08002749
NeilBrown014236d2006-01-06 00:20:55 -08002750static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002751slot_show(struct md_rdev *rdev, char *page)
NeilBrown014236d2006-01-06 00:20:55 -08002752{
Shaohua Lif2076e72015-10-08 21:54:12 -07002753 if (test_bit(Journal, &rdev->flags))
2754 return sprintf(page, "journal\n");
2755 else if (rdev->raid_disk < 0)
NeilBrown014236d2006-01-06 00:20:55 -08002756 return sprintf(page, "none\n");
2757 else
2758 return sprintf(page, "%d\n", rdev->raid_disk);
2759}
2760
2761static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002762slot_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown014236d2006-01-06 00:20:55 -08002763{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03002764 int slot;
NeilBrownc303da62008-02-06 01:39:51 -08002765 int err;
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03002766
Shaohua Lif2076e72015-10-08 21:54:12 -07002767 if (test_bit(Journal, &rdev->flags))
2768 return -EBUSY;
NeilBrown014236d2006-01-06 00:20:55 -08002769 if (strncmp(buf, "none", 4)==0)
2770 slot = -1;
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03002771 else {
2772 err = kstrtouint(buf, 10, (unsigned int *)&slot);
2773 if (err < 0)
2774 return err;
2775 }
Neil Brown6c2fce22008-06-28 08:31:31 +10002776 if (rdev->mddev->pers && slot == -1) {
NeilBrownc303da62008-02-06 01:39:51 -08002777 /* Setting 'slot' on an active array requires also
2778 * updating the 'rd%d' link, and communicating
2779 * with the personality with ->hot_*_disk.
2780 * For now we only support removing
2781 * failed/spare devices. This normally happens automatically,
2782 * but not when the metadata is externally managed.
2783 */
NeilBrownc303da62008-02-06 01:39:51 -08002784 if (rdev->raid_disk == -1)
2785 return -EEXIST;
2786 /* personality does all needed checks */
Namhyung Kim01393f32011-06-09 11:42:54 +10002787 if (rdev->mddev->pers->hot_remove_disk == NULL)
NeilBrownc303da62008-02-06 01:39:51 -08002788 return -EINVAL;
NeilBrown746d3202013-04-24 11:42:41 +10002789 clear_bit(Blocked, &rdev->flags);
2790 remove_and_add_spares(rdev->mddev, rdev);
2791 if (rdev->raid_disk >= 0)
2792 return -EBUSY;
NeilBrownc303da62008-02-06 01:39:51 -08002793 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2794 md_wakeup_thread(rdev->mddev->thread);
Neil Brown6c2fce22008-06-28 08:31:31 +10002795 } else if (rdev->mddev->pers) {
Neil Brown6c2fce22008-06-28 08:31:31 +10002796 /* Activating a spare .. or possibly reactivating
NeilBrown6d56e272009-04-14 12:01:57 +10002797 * if we ever get bitmaps working here.
Neil Brown6c2fce22008-06-28 08:31:31 +10002798 */
Goldwyn Rodriguescb01c542015-12-18 15:19:16 +11002799 int err;
Neil Brown6c2fce22008-06-28 08:31:31 +10002800
2801 if (rdev->raid_disk != -1)
2802 return -EBUSY;
2803
NeilBrownc6751b22011-02-02 11:57:13 +11002804 if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
2805 return -EBUSY;
2806
Neil Brown6c2fce22008-06-28 08:31:31 +10002807 if (rdev->mddev->pers->hot_add_disk == NULL)
2808 return -EINVAL;
2809
NeilBrownba1b41b2011-01-14 09:14:34 +11002810 if (slot >= rdev->mddev->raid_disks &&
2811 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
2812 return -ENOSPC;
2813
Neil Brown6c2fce22008-06-28 08:31:31 +10002814 rdev->raid_disk = slot;
2815 if (test_bit(In_sync, &rdev->flags))
2816 rdev->saved_raid_disk = slot;
2817 else
2818 rdev->saved_raid_disk = -1;
NeilBrownd30519f2011-10-18 12:13:47 +11002819 clear_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11002820 clear_bit(Bitmap_sync, &rdev->flags);
Goldwyn Rodriguescb01c542015-12-18 15:19:16 +11002821 err = rdev->mddev->pers->
2822 hot_add_disk(rdev->mddev, rdev);
2823 if (err) {
2824 rdev->raid_disk = -1;
2825 return err;
2826 } else
2827 sysfs_notify_dirent_safe(rdev->sysfs_state);
2828 if (sysfs_link_rdev(rdev->mddev, rdev))
2829 /* failure here is OK */;
Neil Brown6c2fce22008-06-28 08:31:31 +10002830 /* don't wakeup anyone, leave that to userspace. */
NeilBrownc303da62008-02-06 01:39:51 -08002831 } else {
NeilBrownba1b41b2011-01-14 09:14:34 +11002832 if (slot >= rdev->mddev->raid_disks &&
2833 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
NeilBrownc303da62008-02-06 01:39:51 -08002834 return -ENOSPC;
2835 rdev->raid_disk = slot;
2836 /* assume it is working */
NeilBrownc5d79ad2008-02-06 01:39:54 -08002837 clear_bit(Faulty, &rdev->flags);
2838 clear_bit(WriteMostly, &rdev->flags);
NeilBrownc303da62008-02-06 01:39:51 -08002839 set_bit(In_sync, &rdev->flags);
NeilBrown00bcb4a2010-06-01 19:37:23 +10002840 sysfs_notify_dirent_safe(rdev->sysfs_state);
NeilBrownc303da62008-02-06 01:39:51 -08002841 }
NeilBrown014236d2006-01-06 00:20:55 -08002842 return len;
2843}
2844
NeilBrown014236d2006-01-06 00:20:55 -08002845static struct rdev_sysfs_entry rdev_slot =
NeilBrown80ca3a42006-07-10 04:44:18 -07002846__ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
NeilBrown014236d2006-01-06 00:20:55 -08002847
NeilBrown93c8cad2006-01-06 00:20:56 -08002848static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002849offset_show(struct md_rdev *rdev, char *page)
NeilBrown93c8cad2006-01-06 00:20:56 -08002850{
Andrew Morton6961ece2006-01-06 00:20:59 -08002851 return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
NeilBrown93c8cad2006-01-06 00:20:56 -08002852}
2853
2854static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002855offset_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown93c8cad2006-01-06 00:20:56 -08002856{
NeilBrownc6563a82012-05-21 09:27:00 +10002857 unsigned long long offset;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002858 if (kstrtoull(buf, 10, &offset) < 0)
NeilBrown93c8cad2006-01-06 00:20:56 -08002859 return -EINVAL;
Neil Brown8ed0a522008-06-28 08:31:29 +10002860 if (rdev->mddev->pers && rdev->raid_disk >= 0)
NeilBrown93c8cad2006-01-06 00:20:56 -08002861 return -EBUSY;
Andre Nolldd8ac332009-03-31 14:33:13 +11002862 if (rdev->sectors && rdev->mddev->external)
NeilBrownc5d79ad2008-02-06 01:39:54 -08002863 /* Must set offset before size, so overlap checks
2864 * can be sane */
2865 return -EBUSY;
NeilBrown93c8cad2006-01-06 00:20:56 -08002866 rdev->data_offset = offset;
NeilBrown25f7fd42012-07-19 15:59:18 +10002867 rdev->new_data_offset = offset;
NeilBrown93c8cad2006-01-06 00:20:56 -08002868 return len;
2869}
2870
2871static struct rdev_sysfs_entry rdev_offset =
NeilBrown80ca3a42006-07-10 04:44:18 -07002872__ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
NeilBrown93c8cad2006-01-06 00:20:56 -08002873
NeilBrownc6563a82012-05-21 09:27:00 +10002874static ssize_t new_offset_show(struct md_rdev *rdev, char *page)
2875{
2876 return sprintf(page, "%llu\n",
2877 (unsigned long long)rdev->new_data_offset);
2878}
2879
2880static ssize_t new_offset_store(struct md_rdev *rdev,
2881 const char *buf, size_t len)
2882{
2883 unsigned long long new_offset;
2884 struct mddev *mddev = rdev->mddev;
2885
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002886 if (kstrtoull(buf, 10, &new_offset) < 0)
NeilBrownc6563a82012-05-21 09:27:00 +10002887 return -EINVAL;
2888
NeilBrownf851b602014-12-11 10:02:10 +11002889 if (mddev->sync_thread ||
2890 test_bit(MD_RECOVERY_RUNNING,&mddev->recovery))
NeilBrownc6563a82012-05-21 09:27:00 +10002891 return -EBUSY;
2892 if (new_offset == rdev->data_offset)
2893 /* reset is always permitted */
2894 ;
2895 else if (new_offset > rdev->data_offset) {
2896 /* must not push array size beyond rdev_sectors */
2897 if (new_offset - rdev->data_offset
2898 + mddev->dev_sectors > rdev->sectors)
2899 return -E2BIG;
2900 }
2901 /* Metadata worries about other space details. */
2902
2903 /* decreasing the offset is inconsistent with a backwards
2904 * reshape.
2905 */
2906 if (new_offset < rdev->data_offset &&
2907 mddev->reshape_backwards)
2908 return -EINVAL;
2909 /* Increasing offset is inconsistent with forwards
2910 * reshape. reshape_direction should be set to
2911 * 'backwards' first.
2912 */
2913 if (new_offset > rdev->data_offset &&
2914 !mddev->reshape_backwards)
2915 return -EINVAL;
2916
2917 if (mddev->pers && mddev->persistent &&
2918 !super_types[mddev->major_version]
2919 .allow_new_offset(rdev, new_offset))
2920 return -E2BIG;
2921 rdev->new_data_offset = new_offset;
2922 if (new_offset > rdev->data_offset)
2923 mddev->reshape_backwards = 1;
2924 else if (new_offset < rdev->data_offset)
2925 mddev->reshape_backwards = 0;
2926
2927 return len;
2928}
2929static struct rdev_sysfs_entry rdev_new_offset =
2930__ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store);
2931
NeilBrown83303b62006-01-06 00:21:06 -08002932static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002933rdev_size_show(struct md_rdev *rdev, char *page)
NeilBrown83303b62006-01-06 00:21:06 -08002934{
Andre Nolldd8ac332009-03-31 14:33:13 +11002935 return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
NeilBrown83303b62006-01-06 00:21:06 -08002936}
2937
NeilBrownc5d79ad2008-02-06 01:39:54 -08002938static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
2939{
2940 /* check if two start/length pairs overlap */
2941 if (s1+l1 <= s2)
2942 return 0;
2943 if (s2+l2 <= s1)
2944 return 0;
2945 return 1;
2946}
2947
Dan Williamsb522adc2009-03-31 15:00:31 +11002948static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
2949{
2950 unsigned long long blocks;
2951 sector_t new;
2952
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002953 if (kstrtoull(buf, 10, &blocks) < 0)
Dan Williamsb522adc2009-03-31 15:00:31 +11002954 return -EINVAL;
2955
2956 if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
2957 return -EINVAL; /* sector conversion overflow */
2958
2959 new = blocks * 2;
2960 if (new != blocks * 2)
2961 return -EINVAL; /* unsigned long long to sector_t overflow */
2962
2963 *sectors = new;
2964 return 0;
2965}
2966
NeilBrown83303b62006-01-06 00:21:06 -08002967static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002968rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown83303b62006-01-06 00:21:06 -08002969{
NeilBrownfd01b882011-10-11 16:47:53 +11002970 struct mddev *my_mddev = rdev->mddev;
Andre Nolldd8ac332009-03-31 14:33:13 +11002971 sector_t oldsectors = rdev->sectors;
Dan Williamsb522adc2009-03-31 15:00:31 +11002972 sector_t sectors;
NeilBrown27c529b2008-03-04 14:29:33 -08002973
Shaohua Lif2076e72015-10-08 21:54:12 -07002974 if (test_bit(Journal, &rdev->flags))
2975 return -EBUSY;
Dan Williamsb522adc2009-03-31 15:00:31 +11002976 if (strict_blocks_to_sectors(buf, &sectors) < 0)
Neil Brownd7027452008-07-12 10:37:50 +10002977 return -EINVAL;
NeilBrownc6563a82012-05-21 09:27:00 +10002978 if (rdev->data_offset != rdev->new_data_offset)
2979 return -EINVAL; /* too confusing */
Chris Webb0cd17fe2008-06-28 08:31:46 +10002980 if (my_mddev->pers && rdev->raid_disk >= 0) {
Neil Brownd7027452008-07-12 10:37:50 +10002981 if (my_mddev->persistent) {
Andre Nolldd8ac332009-03-31 14:33:13 +11002982 sectors = super_types[my_mddev->major_version].
2983 rdev_size_change(rdev, sectors);
2984 if (!sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10002985 return -EBUSY;
Andre Nolldd8ac332009-03-31 14:33:13 +11002986 } else if (!sectors)
Mike Snitzer77304d22010-11-08 14:39:12 +01002987 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
Andre Nolldd8ac332009-03-31 14:33:13 +11002988 rdev->data_offset;
NeilBrowna6468532013-02-21 14:33:17 +11002989 if (!my_mddev->pers->resize)
2990 /* Cannot change size for RAID0 or Linear etc */
2991 return -EINVAL;
Chris Webb0cd17fe2008-06-28 08:31:46 +10002992 }
Andre Nolldd8ac332009-03-31 14:33:13 +11002993 if (sectors < my_mddev->dev_sectors)
Chris Webb7d3c6f82008-10-13 11:55:11 +11002994 return -EINVAL; /* component must fit device */
Chris Webb0cd17fe2008-06-28 08:31:46 +10002995
Andre Nolldd8ac332009-03-31 14:33:13 +11002996 rdev->sectors = sectors;
2997 if (sectors > oldsectors && my_mddev->external) {
NeilBrown8b1afc32014-09-29 15:33:20 +10002998 /* Need to check that all other rdevs with the same
2999 * ->bdev do not overlap. 'rcu' is sufficient to walk
3000 * the rdev lists safely.
3001 * This check does not provide a hard guarantee, it
3002 * just helps avoid dangerous mistakes.
NeilBrownc5d79ad2008-02-06 01:39:54 -08003003 */
NeilBrownfd01b882011-10-11 16:47:53 +11003004 struct mddev *mddev;
NeilBrownc5d79ad2008-02-06 01:39:54 -08003005 int overlap = 0;
Cheng Renquan159ec1f2009-01-09 08:31:08 +11003006 struct list_head *tmp;
NeilBrownc5d79ad2008-02-06 01:39:54 -08003007
NeilBrown8b1afc32014-09-29 15:33:20 +10003008 rcu_read_lock();
NeilBrown29ac4aa2008-02-06 01:39:58 -08003009 for_each_mddev(mddev, tmp) {
NeilBrown3cb03002011-10-11 16:45:26 +11003010 struct md_rdev *rdev2;
NeilBrownc5d79ad2008-02-06 01:39:54 -08003011
NeilBrowndafb20f2012-03-19 12:46:39 +11003012 rdev_for_each(rdev2, mddev)
NeilBrownf21e9ff2011-01-31 12:10:09 +11003013 if (rdev->bdev == rdev2->bdev &&
3014 rdev != rdev2 &&
3015 overlaps(rdev->data_offset, rdev->sectors,
3016 rdev2->data_offset,
3017 rdev2->sectors)) {
NeilBrownc5d79ad2008-02-06 01:39:54 -08003018 overlap = 1;
3019 break;
3020 }
NeilBrownc5d79ad2008-02-06 01:39:54 -08003021 if (overlap) {
3022 mddev_put(mddev);
3023 break;
3024 }
3025 }
NeilBrown8b1afc32014-09-29 15:33:20 +10003026 rcu_read_unlock();
NeilBrownc5d79ad2008-02-06 01:39:54 -08003027 if (overlap) {
3028 /* Someone else could have slipped in a size
3029 * change here, but doing so is just silly.
Andre Nolldd8ac332009-03-31 14:33:13 +11003030 * We put oldsectors back because we *know* it is
NeilBrownc5d79ad2008-02-06 01:39:54 -08003031 * safe, and trust userspace not to race with
3032 * itself
3033 */
Andre Nolldd8ac332009-03-31 14:33:13 +11003034 rdev->sectors = oldsectors;
NeilBrownc5d79ad2008-02-06 01:39:54 -08003035 return -EBUSY;
3036 }
3037 }
NeilBrown83303b62006-01-06 00:21:06 -08003038 return len;
3039}
3040
3041static struct rdev_sysfs_entry rdev_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07003042__ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
NeilBrown83303b62006-01-06 00:21:06 -08003043
NeilBrown3cb03002011-10-11 16:45:26 +11003044static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
Dan Williams06e3c812009-12-12 21:17:12 -07003045{
3046 unsigned long long recovery_start = rdev->recovery_offset;
3047
3048 if (test_bit(In_sync, &rdev->flags) ||
3049 recovery_start == MaxSector)
3050 return sprintf(page, "none\n");
3051
3052 return sprintf(page, "%llu\n", recovery_start);
3053}
3054
NeilBrown3cb03002011-10-11 16:45:26 +11003055static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
Dan Williams06e3c812009-12-12 21:17:12 -07003056{
3057 unsigned long long recovery_start;
3058
3059 if (cmd_match(buf, "none"))
3060 recovery_start = MaxSector;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09003061 else if (kstrtoull(buf, 10, &recovery_start))
Dan Williams06e3c812009-12-12 21:17:12 -07003062 return -EINVAL;
3063
3064 if (rdev->mddev->pers &&
3065 rdev->raid_disk >= 0)
3066 return -EBUSY;
3067
3068 rdev->recovery_offset = recovery_start;
3069 if (recovery_start == MaxSector)
3070 set_bit(In_sync, &rdev->flags);
3071 else
3072 clear_bit(In_sync, &rdev->flags);
3073 return len;
3074}
3075
3076static struct rdev_sysfs_entry rdev_recovery_start =
3077__ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);
3078
Vishal Vermafc974ee2015-12-24 19:20:34 -07003079/* sysfs access to bad-blocks list.
3080 * We present two files.
3081 * 'bad-blocks' lists sector numbers and lengths of ranges that
3082 * are recorded as bad. The list is truncated to fit within
3083 * the one-page limit of sysfs.
3084 * Writing "sector length" to this file adds an acknowledged
3085 * bad block list.
3086 * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
3087 * been acknowledged. Writing to this file adds bad blocks
3088 * without acknowledging them. This is largely for testing.
3089 */
NeilBrown3cb03002011-10-11 16:45:26 +11003090static ssize_t bb_show(struct md_rdev *rdev, char *page)
NeilBrown16c791a2011-07-28 11:31:47 +10003091{
3092 return badblocks_show(&rdev->badblocks, page, 0);
3093}
NeilBrown3cb03002011-10-11 16:45:26 +11003094static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
NeilBrown16c791a2011-07-28 11:31:47 +10003095{
NeilBrownde393cd2011-07-28 11:31:48 +10003096 int rv = badblocks_store(&rdev->badblocks, page, len, 0);
3097 /* Maybe that ack was all we needed */
3098 if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags))
3099 wake_up(&rdev->blocked_wait);
3100 return rv;
NeilBrown16c791a2011-07-28 11:31:47 +10003101}
3102static struct rdev_sysfs_entry rdev_bad_blocks =
3103__ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);
3104
NeilBrown3cb03002011-10-11 16:45:26 +11003105static ssize_t ubb_show(struct md_rdev *rdev, char *page)
NeilBrown16c791a2011-07-28 11:31:47 +10003106{
3107 return badblocks_show(&rdev->badblocks, page, 1);
3108}
NeilBrown3cb03002011-10-11 16:45:26 +11003109static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
NeilBrown16c791a2011-07-28 11:31:47 +10003110{
3111 return badblocks_store(&rdev->badblocks, page, len, 1);
3112}
3113static struct rdev_sysfs_entry rdev_unack_bad_blocks =
3114__ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store);
3115
NeilBrown86e6ffd2005-11-08 21:39:24 -08003116static struct attribute *rdev_default_attrs[] = {
3117 &rdev_state.attr,
NeilBrown4dbcdc72006-01-06 00:20:52 -08003118 &rdev_errors.attr,
NeilBrown014236d2006-01-06 00:20:55 -08003119 &rdev_slot.attr,
NeilBrown93c8cad2006-01-06 00:20:56 -08003120 &rdev_offset.attr,
NeilBrownc6563a82012-05-21 09:27:00 +10003121 &rdev_new_offset.attr,
NeilBrown83303b62006-01-06 00:21:06 -08003122 &rdev_size.attr,
Dan Williams06e3c812009-12-12 21:17:12 -07003123 &rdev_recovery_start.attr,
NeilBrown16c791a2011-07-28 11:31:47 +10003124 &rdev_bad_blocks.attr,
3125 &rdev_unack_bad_blocks.attr,
NeilBrown86e6ffd2005-11-08 21:39:24 -08003126 NULL,
3127};
3128static ssize_t
3129rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
3130{
3131 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
NeilBrown3cb03002011-10-11 16:45:26 +11003132 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
NeilBrown86e6ffd2005-11-08 21:39:24 -08003133
3134 if (!entry->show)
3135 return -EIO;
NeilBrown758bfc82014-12-15 12:56:59 +11003136 if (!rdev->mddev)
3137 return -EBUSY;
3138 return entry->show(rdev, page);
NeilBrown86e6ffd2005-11-08 21:39:24 -08003139}
3140
3141static ssize_t
3142rdev_attr_store(struct kobject *kobj, struct attribute *attr,
3143 const char *page, size_t length)
3144{
3145 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
NeilBrown3cb03002011-10-11 16:45:26 +11003146 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
NeilBrown27c529b2008-03-04 14:29:33 -08003147 ssize_t rv;
NeilBrownfd01b882011-10-11 16:47:53 +11003148 struct mddev *mddev = rdev->mddev;
NeilBrown86e6ffd2005-11-08 21:39:24 -08003149
3150 if (!entry->store)
3151 return -EIO;
NeilBrown67463ac2006-07-10 04:44:19 -07003152 if (!capable(CAP_SYS_ADMIN))
3153 return -EACCES;
NeilBrown27c529b2008-03-04 14:29:33 -08003154 rv = mddev ? mddev_lock(mddev): -EBUSY;
NeilBrownca388052008-02-06 01:39:55 -08003155 if (!rv) {
NeilBrown27c529b2008-03-04 14:29:33 -08003156 if (rdev->mddev == NULL)
3157 rv = -EBUSY;
3158 else
3159 rv = entry->store(rdev, page, length);
Dan Williams6a518302008-04-30 00:52:28 -07003160 mddev_unlock(mddev);
NeilBrownca388052008-02-06 01:39:55 -08003161 }
3162 return rv;
NeilBrown86e6ffd2005-11-08 21:39:24 -08003163}
3164
3165static void rdev_free(struct kobject *ko)
3166{
NeilBrown3cb03002011-10-11 16:45:26 +11003167 struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
NeilBrown86e6ffd2005-11-08 21:39:24 -08003168 kfree(rdev);
3169}
Emese Revfy52cf25d2010-01-19 02:58:23 +01003170static const struct sysfs_ops rdev_sysfs_ops = {
NeilBrown86e6ffd2005-11-08 21:39:24 -08003171 .show = rdev_attr_show,
3172 .store = rdev_attr_store,
3173};
3174static struct kobj_type rdev_ktype = {
3175 .release = rdev_free,
3176 .sysfs_ops = &rdev_sysfs_ops,
3177 .default_attrs = rdev_default_attrs,
3178};
3179
NeilBrown3cb03002011-10-11 16:45:26 +11003180int md_rdev_init(struct md_rdev *rdev)
NeilBrowne8bb9a82010-06-01 19:37:26 +10003181{
3182 rdev->desc_nr = -1;
3183 rdev->saved_raid_disk = -1;
3184 rdev->raid_disk = -1;
3185 rdev->flags = 0;
3186 rdev->data_offset = 0;
NeilBrownc6563a82012-05-21 09:27:00 +10003187 rdev->new_data_offset = 0;
NeilBrowne8bb9a82010-06-01 19:37:26 +10003188 rdev->sb_events = 0;
Arnd Bergmann0e3ef492016-06-17 17:33:10 +02003189 rdev->last_read_error = 0;
NeilBrown2699b672011-07-28 11:31:47 +10003190 rdev->sb_loaded = 0;
3191 rdev->bb_page = NULL;
NeilBrowne8bb9a82010-06-01 19:37:26 +10003192 atomic_set(&rdev->nr_pending, 0);
3193 atomic_set(&rdev->read_errors, 0);
3194 atomic_set(&rdev->corrected_errors, 0);
3195
3196 INIT_LIST_HEAD(&rdev->same_set);
3197 init_waitqueue_head(&rdev->blocked_wait);
NeilBrown2230dfe2011-07-28 11:31:46 +10003198
3199 /* Add space to store bad block list.
3200 * This reserves the space even on arrays where it cannot
3201 * be used - I wonder if that matters
3202 */
Vishal Vermafc974ee2015-12-24 19:20:34 -07003203 return badblocks_init(&rdev->badblocks, 0);
NeilBrowne8bb9a82010-06-01 19:37:26 +10003204}
3205EXPORT_SYMBOL_GPL(md_rdev_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206/*
3207 * Import a device. If 'super_format' >= 0, then sanity check the superblock
3208 *
3209 * mark the device faulty if:
3210 *
3211 * - the device is nonexistent (zero size)
3212 * - the device has no valid superblock
3213 *
3214 * a faulty rdev _never_ has rdev->sb set.
3215 */
NeilBrown3cb03002011-10-11 16:45:26 +11003216static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003217{
3218 char b[BDEVNAME_SIZE];
3219 int err;
NeilBrown3cb03002011-10-11 16:45:26 +11003220 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221 sector_t size;
3222
NeilBrown9ffae0c2006-01-06 00:20:32 -08003223 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003224 if (!rdev) {
3225 printk(KERN_ERR "md: could not alloc mem for new device!\n");
3226 return ERR_PTR(-ENOMEM);
3227 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228
NeilBrown2230dfe2011-07-28 11:31:46 +10003229 err = md_rdev_init(rdev);
3230 if (err)
3231 goto abort_free;
3232 err = alloc_disk_sb(rdev);
3233 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003234 goto abort_free;
3235
NeilBrownc5d79ad2008-02-06 01:39:54 -08003236 err = lock_rdev(rdev, newdev, super_format == -2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237 if (err)
3238 goto abort_free;
3239
Greg Kroah-Hartmanf9cb0742007-12-17 23:05:35 -07003240 kobject_init(&rdev->kobj, &rdev_ktype);
NeilBrown86e6ffd2005-11-08 21:39:24 -08003241
Mike Snitzer77304d22010-11-08 14:39:12 +01003242 size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003243 if (!size) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10003244 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07003245 "md: %s has zero or unknown size, marking faulty!\n",
3246 bdevname(rdev->bdev,b));
3247 err = -EINVAL;
3248 goto abort_free;
3249 }
3250
3251 if (super_format >= 0) {
3252 err = super_types[super_format].
3253 load_super(rdev, NULL, super_minor);
3254 if (err == -EINVAL) {
NeilBrowndf968c42007-07-17 04:06:11 -07003255 printk(KERN_WARNING
3256 "md: %s does not have a valid v%d.%d "
3257 "superblock, not importing!\n",
3258 bdevname(rdev->bdev,b),
3259 super_format, super_minor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003260 goto abort_free;
3261 }
3262 if (err < 0) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10003263 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264 "md: could not read %s's sb, not importing!\n",
3265 bdevname(rdev->bdev,b));
3266 goto abort_free;
3267 }
3268 }
Dan Williams6bfe0b42008-04-30 00:52:32 -07003269
Linus Torvalds1da177e2005-04-16 15:20:36 -07003270 return rdev;
3271
3272abort_free:
NeilBrown2699b672011-07-28 11:31:47 +10003273 if (rdev->bdev)
3274 unlock_rdev(rdev);
NeilBrown545c8792012-05-22 13:54:30 +10003275 md_rdev_clear(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003276 kfree(rdev);
3277 return ERR_PTR(err);
3278}
3279
3280/*
3281 * Check a full RAID array for plausibility
3282 */
3283
NeilBrownf72ffdd2014-09-30 14:23:59 +10003284static void analyze_sbs(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003285{
3286 int i;
NeilBrown3cb03002011-10-11 16:45:26 +11003287 struct md_rdev *rdev, *freshest, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003288 char b[BDEVNAME_SIZE];
3289
3290 freshest = NULL;
NeilBrowndafb20f2012-03-19 12:46:39 +11003291 rdev_for_each_safe(rdev, tmp, mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003292 switch (super_types[mddev->major_version].
3293 load_super(rdev, freshest, mddev->minor_version)) {
3294 case 1:
3295 freshest = rdev;
3296 break;
3297 case 0:
3298 break;
3299 default:
3300 printk( KERN_ERR \
3301 "md: fatal superblock inconsistency in %s"
NeilBrownf72ffdd2014-09-30 14:23:59 +10003302 " -- removing from array\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003303 bdevname(rdev->bdev,b));
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05003304 md_kick_rdev_from_array(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003305 }
3306
Linus Torvalds1da177e2005-04-16 15:20:36 -07003307 super_types[mddev->major_version].
3308 validate_super(mddev, freshest);
3309
3310 i = 0;
NeilBrowndafb20f2012-03-19 12:46:39 +11003311 rdev_for_each_safe(rdev, tmp, mddev) {
NeilBrown233fca32010-04-14 17:02:09 +10003312 if (mddev->max_disks &&
3313 (rdev->desc_nr >= mddev->max_disks ||
3314 i > mddev->max_disks)) {
NeilBrownde01dfa2009-02-06 18:02:46 +11003315 printk(KERN_WARNING
3316 "md: %s: %s: only %d devices permitted\n",
3317 mdname(mddev), bdevname(rdev->bdev, b),
3318 mddev->max_disks);
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05003319 md_kick_rdev_from_array(rdev);
NeilBrownde01dfa2009-02-06 18:02:46 +11003320 continue;
3321 }
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05003322 if (rdev != freshest) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003323 if (super_types[mddev->major_version].
3324 validate_super(mddev, rdev)) {
3325 printk(KERN_WARNING "md: kicking non-fresh %s"
3326 " from array!\n",
3327 bdevname(rdev->bdev,b));
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05003328 md_kick_rdev_from_array(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003329 continue;
3330 }
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05003331 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332 if (mddev->level == LEVEL_MULTIPATH) {
3333 rdev->desc_nr = i++;
3334 rdev->raid_disk = rdev->desc_nr;
NeilBrownb2d444d2005-11-08 21:39:31 -08003335 set_bit(In_sync, &rdev->flags);
Shaohua Lif2076e72015-10-08 21:54:12 -07003336 } else if (rdev->raid_disk >=
3337 (mddev->raid_disks - min(0, mddev->delta_disks)) &&
3338 !test_bit(Journal, &rdev->flags)) {
NeilBrowna778b732007-05-23 13:58:10 -07003339 rdev->raid_disk = -1;
3340 clear_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003341 }
3342 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003343}
3344
NeilBrown72e02072009-12-14 12:49:55 +11003345/* Read a fixed-point number.
3346 * Numbers in sysfs attributes should be in "standard" units where
3347 * possible, so time should be in seconds.
NeilBrownf72ffdd2014-09-30 14:23:59 +10003348 * However we internally use a a much smaller unit such as
NeilBrown72e02072009-12-14 12:49:55 +11003349 * milliseconds or jiffies.
3350 * This function takes a decimal number with a possible fractional
3351 * component, and produces an integer which is the result of
3352 * multiplying that number by 10^'scale'.
3353 * all without any floating-point arithmetic.
3354 */
3355int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
3356{
3357 unsigned long result = 0;
3358 long decimals = -1;
3359 while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
3360 if (*cp == '.')
3361 decimals = 0;
3362 else if (decimals < scale) {
3363 unsigned int value;
3364 value = *cp - '0';
3365 result = result * 10 + value;
3366 if (decimals >= 0)
3367 decimals++;
3368 }
3369 cp++;
3370 }
3371 if (*cp == '\n')
3372 cp++;
3373 if (*cp)
3374 return -EINVAL;
3375 if (decimals < 0)
3376 decimals = 0;
3377 while (decimals < scale) {
3378 result *= 10;
3379 decimals ++;
3380 }
3381 *res = result;
3382 return 0;
3383}
3384
NeilBrowneae17012005-11-08 21:39:23 -08003385static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003386safe_delay_show(struct mddev *mddev, char *page)
NeilBrown16f17b32006-06-26 00:27:37 -07003387{
3388 int msec = (mddev->safemode_delay*1000)/HZ;
3389 return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
3390}
3391static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003392safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
NeilBrown16f17b32006-06-26 00:27:37 -07003393{
NeilBrown16f17b32006-06-26 00:27:37 -07003394 unsigned long msec;
Dan Williams97ce0a72008-09-24 22:48:19 -07003395
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11003396 if (mddev_is_clustered(mddev)) {
3397 pr_info("md: Safemode is disabled for clustered mode\n");
3398 return -EINVAL;
3399 }
3400
NeilBrown72e02072009-12-14 12:49:55 +11003401 if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
NeilBrown16f17b32006-06-26 00:27:37 -07003402 return -EINVAL;
NeilBrown16f17b32006-06-26 00:27:37 -07003403 if (msec == 0)
3404 mddev->safemode_delay = 0;
3405 else {
NeilBrown19052c02008-08-05 15:54:13 +10003406 unsigned long old_delay = mddev->safemode_delay;
NeilBrown1b30e662014-12-15 12:57:00 +11003407 unsigned long new_delay = (msec*HZ)/1000;
3408
3409 if (new_delay == 0)
3410 new_delay = 1;
3411 mddev->safemode_delay = new_delay;
3412 if (new_delay < old_delay || old_delay == 0)
3413 mod_timer(&mddev->safemode_timer, jiffies+1);
NeilBrown16f17b32006-06-26 00:27:37 -07003414 }
3415 return len;
3416}
3417static struct md_sysfs_entry md_safe_delay =
NeilBrown80ca3a42006-07-10 04:44:18 -07003418__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
NeilBrown16f17b32006-06-26 00:27:37 -07003419
3420static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003421level_show(struct mddev *mddev, char *page)
NeilBrowneae17012005-11-08 21:39:23 -08003422{
NeilBrown36d091f2014-12-15 12:56:58 +11003423 struct md_personality *p;
3424 int ret;
3425 spin_lock(&mddev->lock);
3426 p = mddev->pers;
NeilBrownd9d166c2006-01-06 00:20:51 -08003427 if (p)
NeilBrown36d091f2014-12-15 12:56:58 +11003428 ret = sprintf(page, "%s\n", p->name);
NeilBrownd9d166c2006-01-06 00:20:51 -08003429 else if (mddev->clevel[0])
NeilBrown36d091f2014-12-15 12:56:58 +11003430 ret = sprintf(page, "%s\n", mddev->clevel);
NeilBrownd9d166c2006-01-06 00:20:51 -08003431 else if (mddev->level != LEVEL_NONE)
NeilBrown36d091f2014-12-15 12:56:58 +11003432 ret = sprintf(page, "%d\n", mddev->level);
NeilBrownd9d166c2006-01-06 00:20:51 -08003433 else
NeilBrown36d091f2014-12-15 12:56:58 +11003434 ret = 0;
3435 spin_unlock(&mddev->lock);
3436 return ret;
NeilBrowneae17012005-11-08 21:39:23 -08003437}
3438
NeilBrownd9d166c2006-01-06 00:20:51 -08003439static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003440level_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownd9d166c2006-01-06 00:20:51 -08003441{
Dan Williamsf2859af2010-05-02 10:04:16 -07003442 char clevel[16];
NeilBrown67918752014-12-15 12:57:01 +11003443 ssize_t rv;
3444 size_t slen = len;
NeilBrowndb721d32014-12-15 12:56:58 +11003445 struct md_personality *pers, *oldpers;
Dan Williamsf2859af2010-05-02 10:04:16 -07003446 long level;
NeilBrowndb721d32014-12-15 12:56:58 +11003447 void *priv, *oldpriv;
NeilBrown3cb03002011-10-11 16:45:26 +11003448 struct md_rdev *rdev;
NeilBrown245f46c2009-03-31 14:39:39 +11003449
NeilBrown67918752014-12-15 12:57:01 +11003450 if (slen == 0 || slen >= sizeof(clevel))
3451 return -EINVAL;
3452
3453 rv = mddev_lock(mddev);
3454 if (rv)
NeilBrown245f46c2009-03-31 14:39:39 +11003455 return rv;
NeilBrown67918752014-12-15 12:57:01 +11003456
3457 if (mddev->pers == NULL) {
3458 strncpy(mddev->clevel, buf, slen);
3459 if (mddev->clevel[slen-1] == '\n')
3460 slen--;
3461 mddev->clevel[slen] = 0;
3462 mddev->level = LEVEL_NONE;
3463 rv = len;
3464 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003465 }
NeilBrown67918752014-12-15 12:57:01 +11003466 rv = -EROFS;
NeilBrownbd8839e2014-05-28 13:39:21 +10003467 if (mddev->ro)
NeilBrown67918752014-12-15 12:57:01 +11003468 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003469
3470 /* request to change the personality. Need to ensure:
3471 * - array is not engaged in resync/recovery/reshape
3472 * - old personality can be suspended
3473 * - new personality will access other array.
3474 */
3475
NeilBrown67918752014-12-15 12:57:01 +11003476 rv = -EBUSY;
NeilBrownbb4f1e92010-08-08 21:18:03 +10003477 if (mddev->sync_thread ||
NeilBrownf851b602014-12-11 10:02:10 +11003478 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
NeilBrownbb4f1e92010-08-08 21:18:03 +10003479 mddev->reshape_position != MaxSector ||
3480 mddev->sysfs_active)
NeilBrown67918752014-12-15 12:57:01 +11003481 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003482
NeilBrown67918752014-12-15 12:57:01 +11003483 rv = -EINVAL;
NeilBrown245f46c2009-03-31 14:39:39 +11003484 if (!mddev->pers->quiesce) {
3485 printk(KERN_WARNING "md: %s: %s does not support online personality change\n",
3486 mdname(mddev), mddev->pers->name);
NeilBrown67918752014-12-15 12:57:01 +11003487 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003488 }
3489
3490 /* Now find the new personality */
NeilBrown67918752014-12-15 12:57:01 +11003491 strncpy(clevel, buf, slen);
3492 if (clevel[slen-1] == '\n')
3493 slen--;
3494 clevel[slen] = 0;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09003495 if (kstrtol(clevel, 10, &level))
Dan Williamsf2859af2010-05-02 10:04:16 -07003496 level = LEVEL_NONE;
NeilBrown245f46c2009-03-31 14:39:39 +11003497
Dan Williamsf2859af2010-05-02 10:04:16 -07003498 if (request_module("md-%s", clevel) != 0)
3499 request_module("md-level-%s", clevel);
NeilBrown245f46c2009-03-31 14:39:39 +11003500 spin_lock(&pers_lock);
Dan Williamsf2859af2010-05-02 10:04:16 -07003501 pers = find_pers(level, clevel);
NeilBrown245f46c2009-03-31 14:39:39 +11003502 if (!pers || !try_module_get(pers->owner)) {
3503 spin_unlock(&pers_lock);
Dan Williamsf2859af2010-05-02 10:04:16 -07003504 printk(KERN_WARNING "md: personality %s not loaded\n", clevel);
NeilBrown67918752014-12-15 12:57:01 +11003505 rv = -EINVAL;
3506 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003507 }
3508 spin_unlock(&pers_lock);
3509
3510 if (pers == mddev->pers) {
3511 /* Nothing to do! */
3512 module_put(pers->owner);
NeilBrown67918752014-12-15 12:57:01 +11003513 rv = len;
3514 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003515 }
3516 if (!pers->takeover) {
3517 module_put(pers->owner);
3518 printk(KERN_WARNING "md: %s: %s does not support personality takeover\n",
Dan Williamsf2859af2010-05-02 10:04:16 -07003519 mdname(mddev), clevel);
NeilBrown67918752014-12-15 12:57:01 +11003520 rv = -EINVAL;
3521 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003522 }
3523
NeilBrowndafb20f2012-03-19 12:46:39 +11003524 rdev_for_each(rdev, mddev)
NeilBrowne93f68a2010-06-15 09:36:03 +01003525 rdev->new_raid_disk = rdev->raid_disk;
3526
NeilBrown245f46c2009-03-31 14:39:39 +11003527 /* ->takeover must set new_* and/or delta_disks
3528 * if it succeeds, and may set them when it fails.
3529 */
3530 priv = pers->takeover(mddev);
3531 if (IS_ERR(priv)) {
3532 mddev->new_level = mddev->level;
3533 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10003534 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrown245f46c2009-03-31 14:39:39 +11003535 mddev->raid_disks -= mddev->delta_disks;
3536 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10003537 mddev->reshape_backwards = 0;
NeilBrown245f46c2009-03-31 14:39:39 +11003538 module_put(pers->owner);
3539 printk(KERN_WARNING "md: %s: %s would not accept array\n",
Dan Williamsf2859af2010-05-02 10:04:16 -07003540 mdname(mddev), clevel);
NeilBrown67918752014-12-15 12:57:01 +11003541 rv = PTR_ERR(priv);
3542 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003543 }
3544
3545 /* Looks like we have a winner */
3546 mddev_suspend(mddev);
NeilBrown5aa61f42014-12-15 12:56:57 +11003547 mddev_detach(mddev);
NeilBrown36d091f2014-12-15 12:56:58 +11003548
3549 spin_lock(&mddev->lock);
NeilBrowndb721d32014-12-15 12:56:58 +11003550 oldpers = mddev->pers;
3551 oldpriv = mddev->private;
3552 mddev->pers = pers;
3553 mddev->private = priv;
3554 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3555 mddev->level = mddev->new_level;
3556 mddev->layout = mddev->new_layout;
3557 mddev->chunk_sectors = mddev->new_chunk_sectors;
3558 mddev->delta_disks = 0;
3559 mddev->reshape_backwards = 0;
3560 mddev->degraded = 0;
NeilBrown36d091f2014-12-15 12:56:58 +11003561 spin_unlock(&mddev->lock);
NeilBrownf72ffdd2014-09-30 14:23:59 +10003562
NeilBrowndb721d32014-12-15 12:56:58 +11003563 if (oldpers->sync_request == NULL &&
Trela Maciej54071b32010-03-08 16:02:42 +11003564 mddev->external) {
3565 /* We are converting from a no-redundancy array
3566 * to a redundancy array and metadata is managed
3567 * externally so we need to be sure that writes
3568 * won't block due to a need to transition
3569 * clean->dirty
3570 * until external management is started.
3571 */
3572 mddev->in_sync = 0;
3573 mddev->safemode_delay = 0;
3574 mddev->safemode = 0;
3575 }
3576
NeilBrowndb721d32014-12-15 12:56:58 +11003577 oldpers->free(mddev, oldpriv);
3578
3579 if (oldpers->sync_request == NULL &&
3580 pers->sync_request != NULL) {
3581 /* need to add the md_redundancy_group */
3582 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
3583 printk(KERN_WARNING
3584 "md: cannot register extra attributes for %s\n",
3585 mdname(mddev));
3586 mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
3587 }
3588 if (oldpers->sync_request != NULL &&
3589 pers->sync_request == NULL) {
3590 /* need to remove the md_redundancy_group */
3591 if (mddev->to_remove == NULL)
3592 mddev->to_remove = &md_redundancy_group;
3593 }
3594
Alexey Obitotskiy4cb9da72016-06-23 12:11:01 +02003595 module_put(oldpers->owner);
3596
NeilBrowndafb20f2012-03-19 12:46:39 +11003597 rdev_for_each(rdev, mddev) {
NeilBrowne93f68a2010-06-15 09:36:03 +01003598 if (rdev->raid_disk < 0)
3599 continue;
NeilBrownbf2cb0d2011-01-14 09:14:34 +11003600 if (rdev->new_raid_disk >= mddev->raid_disks)
NeilBrowne93f68a2010-06-15 09:36:03 +01003601 rdev->new_raid_disk = -1;
3602 if (rdev->new_raid_disk == rdev->raid_disk)
3603 continue;
Namhyung Kim36fad852011-07-27 11:00:36 +10003604 sysfs_unlink_rdev(mddev, rdev);
NeilBrowne93f68a2010-06-15 09:36:03 +01003605 }
NeilBrowndafb20f2012-03-19 12:46:39 +11003606 rdev_for_each(rdev, mddev) {
NeilBrowne93f68a2010-06-15 09:36:03 +01003607 if (rdev->raid_disk < 0)
3608 continue;
3609 if (rdev->new_raid_disk == rdev->raid_disk)
3610 continue;
3611 rdev->raid_disk = rdev->new_raid_disk;
3612 if (rdev->raid_disk < 0)
NeilBrown3a981b02009-08-03 10:59:55 +10003613 clear_bit(In_sync, &rdev->flags);
NeilBrowne93f68a2010-06-15 09:36:03 +01003614 else {
Namhyung Kim36fad852011-07-27 11:00:36 +10003615 if (sysfs_link_rdev(mddev, rdev))
3616 printk(KERN_WARNING "md: cannot register rd%d"
3617 " for %s after level change\n",
3618 rdev->raid_disk, mdname(mddev));
NeilBrown3a981b02009-08-03 10:59:55 +10003619 }
NeilBrowne93f68a2010-06-15 09:36:03 +01003620 }
3621
NeilBrowndb721d32014-12-15 12:56:58 +11003622 if (pers->sync_request == NULL) {
Trela, Maciej9af204c2010-03-08 16:02:44 +11003623 /* this is now an array without redundancy, so
3624 * it must always be in_sync
3625 */
3626 mddev->in_sync = 1;
3627 del_timer_sync(&mddev->safemode_timer);
3628 }
NeilBrown02e5f5c2013-11-14 15:16:15 +11003629 blk_set_stacking_limits(&mddev->queue->limits);
NeilBrown245f46c2009-03-31 14:39:39 +11003630 pers->run(mddev);
NeilBrown245f46c2009-03-31 14:39:39 +11003631 set_bit(MD_CHANGE_DEVS, &mddev->flags);
Jonathan Brassow47525e52012-05-22 13:55:29 +10003632 mddev_resume(mddev);
NeilBrown830778a2014-01-14 15:17:03 +11003633 if (!mddev->thread)
3634 md_update_sb(mddev, 1);
Maciej Trela5cac78612010-04-14 17:17:39 +10003635 sysfs_notify(&mddev->kobj, NULL, "level");
Dan Williamsbb7f8d22010-05-01 18:14:57 -07003636 md_new_event(mddev);
NeilBrown67918752014-12-15 12:57:01 +11003637 rv = len;
3638out_unlock:
3639 mddev_unlock(mddev);
NeilBrownd9d166c2006-01-06 00:20:51 -08003640 return rv;
3641}
3642
3643static struct md_sysfs_entry md_level =
NeilBrown80ca3a42006-07-10 04:44:18 -07003644__ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
NeilBrowneae17012005-11-08 21:39:23 -08003645
NeilBrownd4dbd022006-06-26 00:27:59 -07003646static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003647layout_show(struct mddev *mddev, char *page)
NeilBrownd4dbd022006-06-26 00:27:59 -07003648{
3649 /* just a number, not meaningful for all levels */
NeilBrown08a02ec2007-05-09 02:35:38 -07003650 if (mddev->reshape_position != MaxSector &&
3651 mddev->layout != mddev->new_layout)
3652 return sprintf(page, "%d (%d)\n",
3653 mddev->new_layout, mddev->layout);
NeilBrownd4dbd022006-06-26 00:27:59 -07003654 return sprintf(page, "%d\n", mddev->layout);
3655}
3656
3657static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003658layout_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownd4dbd022006-06-26 00:27:59 -07003659{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003660 unsigned int n;
NeilBrown67918752014-12-15 12:57:01 +11003661 int err;
NeilBrownd4dbd022006-06-26 00:27:59 -07003662
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003663 err = kstrtouint(buf, 10, &n);
3664 if (err < 0)
3665 return err;
NeilBrown67918752014-12-15 12:57:01 +11003666 err = mddev_lock(mddev);
3667 if (err)
3668 return err;
NeilBrownd4dbd022006-06-26 00:27:59 -07003669
NeilBrownb3546032009-03-31 14:56:41 +11003670 if (mddev->pers) {
NeilBrown50ac1682009-06-18 08:47:55 +10003671 if (mddev->pers->check_reshape == NULL)
NeilBrown67918752014-12-15 12:57:01 +11003672 err = -EBUSY;
3673 else if (mddev->ro)
3674 err = -EROFS;
3675 else {
3676 mddev->new_layout = n;
3677 err = mddev->pers->check_reshape(mddev);
3678 if (err)
3679 mddev->new_layout = mddev->layout;
NeilBrown597a7112009-06-18 08:47:42 +10003680 }
NeilBrownb3546032009-03-31 14:56:41 +11003681 } else {
NeilBrown08a02ec2007-05-09 02:35:38 -07003682 mddev->new_layout = n;
NeilBrownb3546032009-03-31 14:56:41 +11003683 if (mddev->reshape_position == MaxSector)
3684 mddev->layout = n;
3685 }
NeilBrown67918752014-12-15 12:57:01 +11003686 mddev_unlock(mddev);
3687 return err ?: len;
NeilBrownd4dbd022006-06-26 00:27:59 -07003688}
3689static struct md_sysfs_entry md_layout =
NeilBrown80ca3a42006-07-10 04:44:18 -07003690__ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
NeilBrownd4dbd022006-06-26 00:27:59 -07003691
NeilBrowneae17012005-11-08 21:39:23 -08003692static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003693raid_disks_show(struct mddev *mddev, char *page)
NeilBrowneae17012005-11-08 21:39:23 -08003694{
NeilBrownbb636542005-11-08 21:39:45 -08003695 if (mddev->raid_disks == 0)
3696 return 0;
NeilBrown08a02ec2007-05-09 02:35:38 -07003697 if (mddev->reshape_position != MaxSector &&
3698 mddev->delta_disks != 0)
3699 return sprintf(page, "%d (%d)\n", mddev->raid_disks,
3700 mddev->raid_disks - mddev->delta_disks);
NeilBrowneae17012005-11-08 21:39:23 -08003701 return sprintf(page, "%d\n", mddev->raid_disks);
3702}
3703
NeilBrownfd01b882011-10-11 16:47:53 +11003704static int update_raid_disks(struct mddev *mddev, int raid_disks);
NeilBrownda943b992006-01-06 00:20:54 -08003705
3706static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003707raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownda943b992006-01-06 00:20:54 -08003708{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003709 unsigned int n;
NeilBrown67918752014-12-15 12:57:01 +11003710 int err;
NeilBrownda943b992006-01-06 00:20:54 -08003711
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003712 err = kstrtouint(buf, 10, &n);
3713 if (err < 0)
3714 return err;
NeilBrownda943b992006-01-06 00:20:54 -08003715
NeilBrown67918752014-12-15 12:57:01 +11003716 err = mddev_lock(mddev);
3717 if (err)
3718 return err;
NeilBrownda943b992006-01-06 00:20:54 -08003719 if (mddev->pers)
NeilBrown67918752014-12-15 12:57:01 +11003720 err = update_raid_disks(mddev, n);
NeilBrown08a02ec2007-05-09 02:35:38 -07003721 else if (mddev->reshape_position != MaxSector) {
NeilBrownc6563a82012-05-21 09:27:00 +10003722 struct md_rdev *rdev;
NeilBrown08a02ec2007-05-09 02:35:38 -07003723 int olddisks = mddev->raid_disks - mddev->delta_disks;
NeilBrownc6563a82012-05-21 09:27:00 +10003724
NeilBrown67918752014-12-15 12:57:01 +11003725 err = -EINVAL;
NeilBrownc6563a82012-05-21 09:27:00 +10003726 rdev_for_each(rdev, mddev) {
3727 if (olddisks < n &&
3728 rdev->data_offset < rdev->new_data_offset)
NeilBrown67918752014-12-15 12:57:01 +11003729 goto out_unlock;
NeilBrownc6563a82012-05-21 09:27:00 +10003730 if (olddisks > n &&
3731 rdev->data_offset > rdev->new_data_offset)
NeilBrown67918752014-12-15 12:57:01 +11003732 goto out_unlock;
NeilBrownc6563a82012-05-21 09:27:00 +10003733 }
NeilBrown67918752014-12-15 12:57:01 +11003734 err = 0;
NeilBrown08a02ec2007-05-09 02:35:38 -07003735 mddev->delta_disks = n - olddisks;
3736 mddev->raid_disks = n;
NeilBrown2c810cd2012-05-21 09:27:00 +10003737 mddev->reshape_backwards = (mddev->delta_disks < 0);
NeilBrown08a02ec2007-05-09 02:35:38 -07003738 } else
NeilBrownda943b992006-01-06 00:20:54 -08003739 mddev->raid_disks = n;
NeilBrown67918752014-12-15 12:57:01 +11003740out_unlock:
3741 mddev_unlock(mddev);
3742 return err ? err : len;
NeilBrownda943b992006-01-06 00:20:54 -08003743}
3744static struct md_sysfs_entry md_raid_disks =
NeilBrown80ca3a42006-07-10 04:44:18 -07003745__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
NeilBrowneae17012005-11-08 21:39:23 -08003746
NeilBrown24dd4692005-11-08 21:39:26 -08003747static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003748chunk_size_show(struct mddev *mddev, char *page)
NeilBrown3b343802006-01-06 00:20:47 -08003749{
NeilBrown08a02ec2007-05-09 02:35:38 -07003750 if (mddev->reshape_position != MaxSector &&
Andre Noll664e7c42009-06-18 08:45:27 +10003751 mddev->chunk_sectors != mddev->new_chunk_sectors)
3752 return sprintf(page, "%d (%d)\n",
3753 mddev->new_chunk_sectors << 9,
Andre Noll9d8f0362009-06-18 08:45:01 +10003754 mddev->chunk_sectors << 9);
3755 return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
NeilBrown3b343802006-01-06 00:20:47 -08003756}
3757
3758static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003759chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown3b343802006-01-06 00:20:47 -08003760{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003761 unsigned long n;
NeilBrown67918752014-12-15 12:57:01 +11003762 int err;
NeilBrown3b343802006-01-06 00:20:47 -08003763
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003764 err = kstrtoul(buf, 10, &n);
3765 if (err < 0)
3766 return err;
NeilBrown3b343802006-01-06 00:20:47 -08003767
NeilBrown67918752014-12-15 12:57:01 +11003768 err = mddev_lock(mddev);
3769 if (err)
3770 return err;
NeilBrownb3546032009-03-31 14:56:41 +11003771 if (mddev->pers) {
NeilBrown50ac1682009-06-18 08:47:55 +10003772 if (mddev->pers->check_reshape == NULL)
NeilBrown67918752014-12-15 12:57:01 +11003773 err = -EBUSY;
3774 else if (mddev->ro)
3775 err = -EROFS;
3776 else {
3777 mddev->new_chunk_sectors = n >> 9;
3778 err = mddev->pers->check_reshape(mddev);
3779 if (err)
3780 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrown597a7112009-06-18 08:47:42 +10003781 }
NeilBrownb3546032009-03-31 14:56:41 +11003782 } else {
Andre Noll664e7c42009-06-18 08:45:27 +10003783 mddev->new_chunk_sectors = n >> 9;
NeilBrownb3546032009-03-31 14:56:41 +11003784 if (mddev->reshape_position == MaxSector)
Andre Noll9d8f0362009-06-18 08:45:01 +10003785 mddev->chunk_sectors = n >> 9;
NeilBrownb3546032009-03-31 14:56:41 +11003786 }
NeilBrown67918752014-12-15 12:57:01 +11003787 mddev_unlock(mddev);
3788 return err ?: len;
NeilBrown3b343802006-01-06 00:20:47 -08003789}
3790static struct md_sysfs_entry md_chunk_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07003791__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
NeilBrown3b343802006-01-06 00:20:47 -08003792
NeilBrowna94213b2006-06-26 00:28:00 -07003793static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003794resync_start_show(struct mddev *mddev, char *page)
NeilBrowna94213b2006-06-26 00:28:00 -07003795{
NeilBrownd1a7c502009-03-31 15:24:32 +11003796 if (mddev->recovery_cp == MaxSector)
3797 return sprintf(page, "none\n");
NeilBrowna94213b2006-06-26 00:28:00 -07003798 return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
3799}
3800
3801static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003802resync_start_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowna94213b2006-06-26 00:28:00 -07003803{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003804 unsigned long long n;
NeilBrown67918752014-12-15 12:57:01 +11003805 int err;
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003806
3807 if (cmd_match(buf, "none"))
3808 n = MaxSector;
3809 else {
3810 err = kstrtoull(buf, 10, &n);
3811 if (err < 0)
3812 return err;
3813 if (n != (sector_t)n)
3814 return -EINVAL;
3815 }
NeilBrowna94213b2006-06-26 00:28:00 -07003816
NeilBrown67918752014-12-15 12:57:01 +11003817 err = mddev_lock(mddev);
3818 if (err)
3819 return err;
NeilBrownb0986362011-05-11 15:52:21 +10003820 if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
NeilBrown67918752014-12-15 12:57:01 +11003821 err = -EBUSY;
NeilBrowna94213b2006-06-26 00:28:00 -07003822
NeilBrown67918752014-12-15 12:57:01 +11003823 if (!err) {
3824 mddev->recovery_cp = n;
3825 if (mddev->pers)
3826 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3827 }
3828 mddev_unlock(mddev);
3829 return err ?: len;
NeilBrowna94213b2006-06-26 00:28:00 -07003830}
3831static struct md_sysfs_entry md_resync_start =
NeilBrown750f1992014-09-30 08:53:05 +10003832__ATTR_PREALLOC(resync_start, S_IRUGO|S_IWUSR,
3833 resync_start_show, resync_start_store);
NeilBrowna94213b2006-06-26 00:28:00 -07003834
NeilBrown9e653b62006-06-26 00:27:58 -07003835/*
3836 * The array state can be:
3837 *
3838 * clear
3839 * No devices, no size, no level
3840 * Equivalent to STOP_ARRAY ioctl
3841 * inactive
3842 * May have some settings, but array is not active
3843 * all IO results in error
3844 * When written, doesn't tear down array, but just stops it
3845 * suspended (not supported yet)
3846 * All IO requests will block. The array can be reconfigured.
Andre Noll910d8cb2008-03-25 21:00:53 +01003847 * Writing this, if accepted, will block until array is quiescent
NeilBrown9e653b62006-06-26 00:27:58 -07003848 * readonly
3849 * no resync can happen. no superblocks get written.
3850 * write requests fail
3851 * read-auto
3852 * like readonly, but behaves like 'clean' on a write request.
3853 *
3854 * clean - no pending writes, but otherwise active.
3855 * When written to inactive array, starts without resync
3856 * If a write request arrives then
3857 * if metadata is known, mark 'dirty' and switch to 'active'.
3858 * if not known, block and switch to write-pending
3859 * If written to an active array that has pending writes, then fails.
3860 * active
3861 * fully active: IO and resync can be happening.
3862 * When written to inactive array, starts with resync
3863 *
3864 * write-pending
3865 * clean, but writes are blocked waiting for 'active' to be written.
3866 *
3867 * active-idle
3868 * like active, but no writes have been seen for a while (100msec).
3869 *
3870 */
3871enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
3872 write_pending, active_idle, bad_word};
Adrian Bunk05381952006-06-26 00:28:01 -07003873static char *array_states[] = {
NeilBrown9e653b62006-06-26 00:27:58 -07003874 "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
3875 "write-pending", "active-idle", NULL };
3876
3877static int match_word(const char *word, char **list)
3878{
3879 int n;
3880 for (n=0; list[n]; n++)
3881 if (cmd_match(word, list[n]))
3882 break;
3883 return n;
3884}
3885
3886static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003887array_state_show(struct mddev *mddev, char *page)
NeilBrown9e653b62006-06-26 00:27:58 -07003888{
3889 enum array_state st = inactive;
3890
3891 if (mddev->pers)
3892 switch(mddev->ro) {
3893 case 1:
3894 st = readonly;
3895 break;
3896 case 2:
3897 st = read_auto;
3898 break;
3899 case 0:
Tomasz Majchrzak16f88942016-10-24 12:47:28 +02003900 if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
NeilBrowne6910632008-02-06 01:39:51 -08003901 st = write_pending;
Tomasz Majchrzak16f88942016-10-24 12:47:28 +02003902 else if (mddev->in_sync)
3903 st = clean;
NeilBrown9e653b62006-06-26 00:27:58 -07003904 else if (mddev->safemode)
3905 st = active_idle;
3906 else
3907 st = active;
3908 }
3909 else {
3910 if (list_empty(&mddev->disks) &&
3911 mddev->raid_disks == 0 &&
Andre Noll58c0fed2009-03-31 14:33:13 +11003912 mddev->dev_sectors == 0)
NeilBrown9e653b62006-06-26 00:27:58 -07003913 st = clear;
3914 else
3915 st = inactive;
3916 }
3917 return sprintf(page, "%s\n", array_states[st]);
3918}
3919
NeilBrownf72ffdd2014-09-30 14:23:59 +10003920static int do_md_stop(struct mddev *mddev, int ro, struct block_device *bdev);
3921static int md_set_readonly(struct mddev *mddev, struct block_device *bdev);
3922static int do_md_run(struct mddev *mddev);
NeilBrownfd01b882011-10-11 16:47:53 +11003923static int restart_array(struct mddev *mddev);
NeilBrown9e653b62006-06-26 00:27:58 -07003924
3925static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003926array_state_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown9e653b62006-06-26 00:27:58 -07003927{
NeilBrown67918752014-12-15 12:57:01 +11003928 int err;
NeilBrown9e653b62006-06-26 00:27:58 -07003929 enum array_state st = match_word(buf, array_states);
NeilBrown67918752014-12-15 12:57:01 +11003930
3931 if (mddev->pers && (st == active || st == clean) && mddev->ro != 1) {
3932 /* don't take reconfig_mutex when toggling between
3933 * clean and active
3934 */
3935 spin_lock(&mddev->lock);
3936 if (st == active) {
3937 restart_array(mddev);
3938 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
3939 wake_up(&mddev->sb_wait);
3940 err = 0;
3941 } else /* st == clean */ {
3942 restart_array(mddev);
3943 if (atomic_read(&mddev->writes_pending) == 0) {
3944 if (mddev->in_sync == 0) {
3945 mddev->in_sync = 1;
3946 if (mddev->safemode == 1)
3947 mddev->safemode = 0;
3948 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3949 }
3950 err = 0;
3951 } else
3952 err = -EBUSY;
3953 }
Tomasz Majchrzak573275b2016-06-30 10:47:09 +02003954 if (!err)
3955 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown67918752014-12-15 12:57:01 +11003956 spin_unlock(&mddev->lock);
NeilBrownc008f1d2015-06-12 19:46:44 +10003957 return err ?: len;
NeilBrown67918752014-12-15 12:57:01 +11003958 }
3959 err = mddev_lock(mddev);
3960 if (err)
3961 return err;
3962 err = -EINVAL;
NeilBrown9e653b62006-06-26 00:27:58 -07003963 switch(st) {
3964 case bad_word:
3965 break;
3966 case clear:
3967 /* stopping an active array */
NeilBrowna05b7ea02012-07-19 15:59:18 +10003968 err = do_md_stop(mddev, 0, NULL);
NeilBrown9e653b62006-06-26 00:27:58 -07003969 break;
3970 case inactive:
3971 /* stopping an active array */
NeilBrown90cf1952012-07-31 10:04:55 +10003972 if (mddev->pers)
NeilBrowna05b7ea02012-07-19 15:59:18 +10003973 err = do_md_stop(mddev, 2, NULL);
NeilBrown90cf1952012-07-31 10:04:55 +10003974 else
NeilBrowne6910632008-02-06 01:39:51 -08003975 err = 0; /* already inactive */
NeilBrown9e653b62006-06-26 00:27:58 -07003976 break;
3977 case suspended:
3978 break; /* not supported yet */
3979 case readonly:
3980 if (mddev->pers)
NeilBrowna05b7ea02012-07-19 15:59:18 +10003981 err = md_set_readonly(mddev, NULL);
NeilBrown9e653b62006-06-26 00:27:58 -07003982 else {
3983 mddev->ro = 1;
NeilBrown648b6292008-04-30 00:52:30 -07003984 set_disk_ro(mddev->gendisk, 1);
NeilBrown9e653b62006-06-26 00:27:58 -07003985 err = do_md_run(mddev);
3986 }
3987 break;
3988 case read_auto:
NeilBrown9e653b62006-06-26 00:27:58 -07003989 if (mddev->pers) {
NeilBrown80268ee2008-10-13 11:55:12 +11003990 if (mddev->ro == 0)
NeilBrowna05b7ea02012-07-19 15:59:18 +10003991 err = md_set_readonly(mddev, NULL);
NeilBrown80268ee2008-10-13 11:55:12 +11003992 else if (mddev->ro == 1)
NeilBrown648b6292008-04-30 00:52:30 -07003993 err = restart_array(mddev);
3994 if (err == 0) {
3995 mddev->ro = 2;
3996 set_disk_ro(mddev->gendisk, 0);
3997 }
NeilBrown9e653b62006-06-26 00:27:58 -07003998 } else {
3999 mddev->ro = 2;
4000 err = do_md_run(mddev);
4001 }
4002 break;
4003 case clean:
4004 if (mddev->pers) {
Song Liu339421d2015-10-08 21:54:13 -07004005 err = restart_array(mddev);
4006 if (err)
4007 break;
NeilBrown85572d72014-12-15 12:56:56 +11004008 spin_lock(&mddev->lock);
NeilBrown9e653b62006-06-26 00:27:58 -07004009 if (atomic_read(&mddev->writes_pending) == 0) {
NeilBrowne6910632008-02-06 01:39:51 -08004010 if (mddev->in_sync == 0) {
4011 mddev->in_sync = 1;
NeilBrown31a59e32008-04-30 00:52:30 -07004012 if (mddev->safemode == 1)
4013 mddev->safemode = 0;
NeilBrown070dc6d2010-08-30 17:33:34 +10004014 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrowne6910632008-02-06 01:39:51 -08004015 }
4016 err = 0;
4017 } else
4018 err = -EBUSY;
NeilBrown85572d72014-12-15 12:56:56 +11004019 spin_unlock(&mddev->lock);
NeilBrown5bf29592009-05-07 12:50:57 +10004020 } else
4021 err = -EINVAL;
NeilBrown9e653b62006-06-26 00:27:58 -07004022 break;
4023 case active:
4024 if (mddev->pers) {
Song Liu339421d2015-10-08 21:54:13 -07004025 err = restart_array(mddev);
4026 if (err)
4027 break;
NeilBrown070dc6d2010-08-30 17:33:34 +10004028 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrown9e653b62006-06-26 00:27:58 -07004029 wake_up(&mddev->sb_wait);
4030 err = 0;
4031 } else {
4032 mddev->ro = 0;
NeilBrown648b6292008-04-30 00:52:30 -07004033 set_disk_ro(mddev->gendisk, 0);
NeilBrown9e653b62006-06-26 00:27:58 -07004034 err = do_md_run(mddev);
4035 }
4036 break;
4037 case write_pending:
4038 case active_idle:
4039 /* these cannot be set */
4040 break;
4041 }
NeilBrown67918752014-12-15 12:57:01 +11004042
4043 if (!err) {
NeilBrown1d23f172011-12-08 15:49:12 +11004044 if (mddev->hold_active == UNTIL_IOCTL)
4045 mddev->hold_active = 0;
NeilBrown00bcb4a2010-06-01 19:37:23 +10004046 sysfs_notify_dirent_safe(mddev->sysfs_state);
Neil Brown0fd62b82008-06-28 08:31:36 +10004047 }
NeilBrown67918752014-12-15 12:57:01 +11004048 mddev_unlock(mddev);
4049 return err ?: len;
NeilBrown9e653b62006-06-26 00:27:58 -07004050}
NeilBrown80ca3a42006-07-10 04:44:18 -07004051static struct md_sysfs_entry md_array_state =
NeilBrown750f1992014-09-30 08:53:05 +10004052__ATTR_PREALLOC(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
NeilBrown9e653b62006-06-26 00:27:58 -07004053
NeilBrown6d7ff732006-01-06 00:21:16 -08004054static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004055max_corrected_read_errors_show(struct mddev *mddev, char *page) {
Robert Becker1e509152009-12-14 12:49:58 +11004056 return sprintf(page, "%d\n",
4057 atomic_read(&mddev->max_corr_read_errors));
4058}
4059
4060static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004061max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
Robert Becker1e509152009-12-14 12:49:58 +11004062{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004063 unsigned int n;
4064 int rv;
Robert Becker1e509152009-12-14 12:49:58 +11004065
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004066 rv = kstrtouint(buf, 10, &n);
4067 if (rv < 0)
4068 return rv;
4069 atomic_set(&mddev->max_corr_read_errors, n);
4070 return len;
Robert Becker1e509152009-12-14 12:49:58 +11004071}
4072
4073static struct md_sysfs_entry max_corr_read_errors =
4074__ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
4075 max_corrected_read_errors_store);
4076
4077static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004078null_show(struct mddev *mddev, char *page)
NeilBrown6d7ff732006-01-06 00:21:16 -08004079{
4080 return -EINVAL;
4081}
4082
4083static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004084new_dev_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown6d7ff732006-01-06 00:21:16 -08004085{
4086 /* buf must be %d:%d\n? giving major and minor numbers */
4087 /* The new device is added to the array.
4088 * If the array has a persistent superblock, we read the
4089 * superblock to initialise info and check validity.
4090 * Otherwise, only checking done is that in bind_rdev_to_array,
4091 * which mainly checks size.
4092 */
4093 char *e;
4094 int major = simple_strtoul(buf, &e, 10);
4095 int minor;
4096 dev_t dev;
NeilBrown3cb03002011-10-11 16:45:26 +11004097 struct md_rdev *rdev;
NeilBrown6d7ff732006-01-06 00:21:16 -08004098 int err;
4099
4100 if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
4101 return -EINVAL;
4102 minor = simple_strtoul(e+1, &e, 10);
4103 if (*e && *e != '\n')
4104 return -EINVAL;
4105 dev = MKDEV(major, minor);
4106 if (major != MAJOR(dev) ||
4107 minor != MINOR(dev))
4108 return -EOVERFLOW;
4109
NeilBrown67918752014-12-15 12:57:01 +11004110 flush_workqueue(md_misc_wq);
4111
4112 err = mddev_lock(mddev);
4113 if (err)
4114 return err;
NeilBrown6d7ff732006-01-06 00:21:16 -08004115 if (mddev->persistent) {
4116 rdev = md_import_device(dev, mddev->major_version,
4117 mddev->minor_version);
4118 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
NeilBrown3cb03002011-10-11 16:45:26 +11004119 struct md_rdev *rdev0
4120 = list_entry(mddev->disks.next,
4121 struct md_rdev, same_set);
NeilBrown6d7ff732006-01-06 00:21:16 -08004122 err = super_types[mddev->major_version]
4123 .load_super(rdev, rdev0, mddev->minor_version);
4124 if (err < 0)
4125 goto out;
4126 }
NeilBrownc5d79ad2008-02-06 01:39:54 -08004127 } else if (mddev->external)
4128 rdev = md_import_device(dev, -2, -1);
4129 else
NeilBrown6d7ff732006-01-06 00:21:16 -08004130 rdev = md_import_device(dev, -1, -1);
4131
NeilBrown9a8c0fa2015-06-25 17:06:40 +10004132 if (IS_ERR(rdev)) {
4133 mddev_unlock(mddev);
NeilBrown6d7ff732006-01-06 00:21:16 -08004134 return PTR_ERR(rdev);
NeilBrown9a8c0fa2015-06-25 17:06:40 +10004135 }
NeilBrown6d7ff732006-01-06 00:21:16 -08004136 err = bind_rdev_to_array(rdev, mddev);
4137 out:
4138 if (err)
4139 export_rdev(rdev);
NeilBrown67918752014-12-15 12:57:01 +11004140 mddev_unlock(mddev);
NeilBrown6d7ff732006-01-06 00:21:16 -08004141 return err ? err : len;
4142}
4143
4144static struct md_sysfs_entry md_new_device =
NeilBrown80ca3a42006-07-10 04:44:18 -07004145__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
NeilBrown3b343802006-01-06 00:20:47 -08004146
4147static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004148bitmap_store(struct mddev *mddev, const char *buf, size_t len)
Paul Clements9b1d1da2006-10-03 01:15:49 -07004149{
4150 char *end;
4151 unsigned long chunk, end_chunk;
NeilBrown67918752014-12-15 12:57:01 +11004152 int err;
Paul Clements9b1d1da2006-10-03 01:15:49 -07004153
NeilBrown67918752014-12-15 12:57:01 +11004154 err = mddev_lock(mddev);
4155 if (err)
4156 return err;
Paul Clements9b1d1da2006-10-03 01:15:49 -07004157 if (!mddev->bitmap)
4158 goto out;
4159 /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
4160 while (*buf) {
4161 chunk = end_chunk = simple_strtoul(buf, &end, 0);
4162 if (buf == end) break;
4163 if (*end == '-') { /* range */
4164 buf = end + 1;
4165 end_chunk = simple_strtoul(buf, &end, 0);
4166 if (buf == end) break;
4167 }
4168 if (*end && !isspace(*end)) break;
4169 bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
André Goddard Rosae7d28602009-12-14 18:01:06 -08004170 buf = skip_spaces(end);
Paul Clements9b1d1da2006-10-03 01:15:49 -07004171 }
4172 bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
4173out:
NeilBrown67918752014-12-15 12:57:01 +11004174 mddev_unlock(mddev);
Paul Clements9b1d1da2006-10-03 01:15:49 -07004175 return len;
4176}
4177
4178static struct md_sysfs_entry md_bitmap =
4179__ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
4180
4181static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004182size_show(struct mddev *mddev, char *page)
NeilBrowna35b0d62006-01-06 00:20:49 -08004183{
Andre Noll58c0fed2009-03-31 14:33:13 +11004184 return sprintf(page, "%llu\n",
4185 (unsigned long long)mddev->dev_sectors / 2);
NeilBrowna35b0d62006-01-06 00:20:49 -08004186}
4187
NeilBrownfd01b882011-10-11 16:47:53 +11004188static int update_size(struct mddev *mddev, sector_t num_sectors);
NeilBrowna35b0d62006-01-06 00:20:49 -08004189
4190static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004191size_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowna35b0d62006-01-06 00:20:49 -08004192{
4193 /* If array is inactive, we can reduce the component size, but
4194 * not increase it (except from 0).
4195 * If array is active, we can try an on-line resize
4196 */
Dan Williamsb522adc2009-03-31 15:00:31 +11004197 sector_t sectors;
4198 int err = strict_blocks_to_sectors(buf, &sectors);
NeilBrowna35b0d62006-01-06 00:20:49 -08004199
Andre Noll58c0fed2009-03-31 14:33:13 +11004200 if (err < 0)
4201 return err;
NeilBrown67918752014-12-15 12:57:01 +11004202 err = mddev_lock(mddev);
4203 if (err)
4204 return err;
NeilBrowna35b0d62006-01-06 00:20:49 -08004205 if (mddev->pers) {
Andre Noll58c0fed2009-03-31 14:33:13 +11004206 err = update_size(mddev, sectors);
Xiao Ni4ba1e782016-06-12 17:18:00 +08004207 if (err == 0)
4208 md_update_sb(mddev, 1);
NeilBrowna35b0d62006-01-06 00:20:49 -08004209 } else {
Andre Noll58c0fed2009-03-31 14:33:13 +11004210 if (mddev->dev_sectors == 0 ||
4211 mddev->dev_sectors > sectors)
4212 mddev->dev_sectors = sectors;
NeilBrowna35b0d62006-01-06 00:20:49 -08004213 else
4214 err = -ENOSPC;
4215 }
NeilBrown67918752014-12-15 12:57:01 +11004216 mddev_unlock(mddev);
NeilBrowna35b0d62006-01-06 00:20:49 -08004217 return err ? err : len;
4218}
4219
4220static struct md_sysfs_entry md_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07004221__ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
NeilBrowna35b0d62006-01-06 00:20:49 -08004222
Masanari Iida83f0d772012-10-30 00:18:08 +09004223/* Metadata version.
NeilBrowne6910632008-02-06 01:39:51 -08004224 * This is one of
4225 * 'none' for arrays with no metadata (good luck...)
4226 * 'external' for arrays with externally managed metadata,
NeilBrown8bb93aa2006-01-06 00:20:50 -08004227 * or N.M for internally known formats
4228 */
4229static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004230metadata_show(struct mddev *mddev, char *page)
NeilBrown8bb93aa2006-01-06 00:20:50 -08004231{
4232 if (mddev->persistent)
4233 return sprintf(page, "%d.%d\n",
4234 mddev->major_version, mddev->minor_version);
NeilBrowne6910632008-02-06 01:39:51 -08004235 else if (mddev->external)
4236 return sprintf(page, "external:%s\n", mddev->metadata_type);
NeilBrown8bb93aa2006-01-06 00:20:50 -08004237 else
4238 return sprintf(page, "none\n");
4239}
4240
4241static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004242metadata_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown8bb93aa2006-01-06 00:20:50 -08004243{
4244 int major, minor;
4245 char *e;
NeilBrown67918752014-12-15 12:57:01 +11004246 int err;
NeilBrownea43ddd2008-10-13 11:55:11 +11004247 /* Changing the details of 'external' metadata is
4248 * always permitted. Otherwise there must be
4249 * no devices attached to the array.
4250 */
NeilBrown67918752014-12-15 12:57:01 +11004251
4252 err = mddev_lock(mddev);
4253 if (err)
4254 return err;
4255 err = -EBUSY;
NeilBrownea43ddd2008-10-13 11:55:11 +11004256 if (mddev->external && strncmp(buf, "external:", 9) == 0)
4257 ;
4258 else if (!list_empty(&mddev->disks))
NeilBrown67918752014-12-15 12:57:01 +11004259 goto out_unlock;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004260
NeilBrown67918752014-12-15 12:57:01 +11004261 err = 0;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004262 if (cmd_match(buf, "none")) {
4263 mddev->persistent = 0;
NeilBrowne6910632008-02-06 01:39:51 -08004264 mddev->external = 0;
4265 mddev->major_version = 0;
4266 mddev->minor_version = 90;
NeilBrown67918752014-12-15 12:57:01 +11004267 goto out_unlock;
NeilBrowne6910632008-02-06 01:39:51 -08004268 }
4269 if (strncmp(buf, "external:", 9) == 0) {
NeilBrown20a49ff2008-02-06 01:39:57 -08004270 size_t namelen = len-9;
NeilBrowne6910632008-02-06 01:39:51 -08004271 if (namelen >= sizeof(mddev->metadata_type))
4272 namelen = sizeof(mddev->metadata_type)-1;
4273 strncpy(mddev->metadata_type, buf+9, namelen);
4274 mddev->metadata_type[namelen] = 0;
4275 if (namelen && mddev->metadata_type[namelen-1] == '\n')
4276 mddev->metadata_type[--namelen] = 0;
4277 mddev->persistent = 0;
4278 mddev->external = 1;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004279 mddev->major_version = 0;
4280 mddev->minor_version = 90;
NeilBrown67918752014-12-15 12:57:01 +11004281 goto out_unlock;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004282 }
4283 major = simple_strtoul(buf, &e, 10);
NeilBrown67918752014-12-15 12:57:01 +11004284 err = -EINVAL;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004285 if (e==buf || *e != '.')
NeilBrown67918752014-12-15 12:57:01 +11004286 goto out_unlock;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004287 buf = e+1;
4288 minor = simple_strtoul(buf, &e, 10);
NeilBrown3f9d7b02006-12-22 01:11:41 -08004289 if (e==buf || (*e && *e != '\n') )
NeilBrown67918752014-12-15 12:57:01 +11004290 goto out_unlock;
4291 err = -ENOENT;
Ahmed S. Darwish50511da2007-05-09 02:35:34 -07004292 if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
NeilBrown67918752014-12-15 12:57:01 +11004293 goto out_unlock;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004294 mddev->major_version = major;
4295 mddev->minor_version = minor;
4296 mddev->persistent = 1;
NeilBrowne6910632008-02-06 01:39:51 -08004297 mddev->external = 0;
NeilBrown67918752014-12-15 12:57:01 +11004298 err = 0;
4299out_unlock:
4300 mddev_unlock(mddev);
4301 return err ?: len;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004302}
4303
4304static struct md_sysfs_entry md_metadata =
NeilBrown750f1992014-09-30 08:53:05 +10004305__ATTR_PREALLOC(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
NeilBrown8bb93aa2006-01-06 00:20:50 -08004306
NeilBrowna35b0d62006-01-06 00:20:49 -08004307static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004308action_show(struct mddev *mddev, char *page)
NeilBrown24dd4692005-11-08 21:39:26 -08004309{
NeilBrown7eec3142005-11-08 21:39:44 -08004310 char *type = "idle";
NeilBrownb7b17c92014-12-15 12:56:59 +11004311 unsigned long recovery = mddev->recovery;
4312 if (test_bit(MD_RECOVERY_FROZEN, &recovery))
NeilBrownb6a9ce62009-05-26 09:41:17 +10004313 type = "frozen";
NeilBrownb7b17c92014-12-15 12:56:59 +11004314 else if (test_bit(MD_RECOVERY_RUNNING, &recovery) ||
4315 (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &recovery))) {
4316 if (test_bit(MD_RECOVERY_RESHAPE, &recovery))
NeilBrownccfcc3c2006-03-27 01:18:09 -08004317 type = "reshape";
NeilBrownb7b17c92014-12-15 12:56:59 +11004318 else if (test_bit(MD_RECOVERY_SYNC, &recovery)) {
4319 if (!test_bit(MD_RECOVERY_REQUESTED, &recovery))
NeilBrown24dd4692005-11-08 21:39:26 -08004320 type = "resync";
NeilBrownb7b17c92014-12-15 12:56:59 +11004321 else if (test_bit(MD_RECOVERY_CHECK, &recovery))
NeilBrown24dd4692005-11-08 21:39:26 -08004322 type = "check";
4323 else
4324 type = "repair";
NeilBrownb7b17c92014-12-15 12:56:59 +11004325 } else if (test_bit(MD_RECOVERY_RECOVER, &recovery))
NeilBrown24dd4692005-11-08 21:39:26 -08004326 type = "recover";
NeilBrown985ca972015-07-06 12:26:57 +10004327 else if (mddev->reshape_position != MaxSector)
4328 type = "reshape";
NeilBrown24dd4692005-11-08 21:39:26 -08004329 }
4330 return sprintf(page, "%s\n", type);
4331}
4332
4333static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004334action_store(struct mddev *mddev, const char *page, size_t len)
NeilBrown24dd4692005-11-08 21:39:26 -08004335{
NeilBrown7eec3142005-11-08 21:39:44 -08004336 if (!mddev->pers || !mddev->pers->sync_request)
4337 return -EINVAL;
4338
NeilBrownb6a9ce62009-05-26 09:41:17 +10004339
4340 if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
NeilBrown56ccc112015-05-28 17:53:29 +10004341 if (cmd_match(page, "frozen"))
4342 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4343 else
4344 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown8e8e2512015-06-12 19:51:27 +10004345 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
4346 mddev_lock(mddev) == 0) {
4347 flush_workqueue(md_misc_wq);
4348 if (mddev->sync_thread) {
4349 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrown67918752014-12-15 12:57:01 +11004350 md_reap_sync_thread(mddev);
NeilBrown67918752014-12-15 12:57:01 +11004351 }
NeilBrown8e8e2512015-06-12 19:51:27 +10004352 mddev_unlock(mddev);
NeilBrown7eec3142005-11-08 21:39:44 -08004353 }
NeilBrown312045e2015-12-21 11:01:21 +11004354 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown24dd4692005-11-08 21:39:26 -08004355 return -EBUSY;
Neil Brown72a23c22008-06-28 08:31:41 +10004356 else if (cmd_match(page, "resync"))
NeilBrown56ccc112015-05-28 17:53:29 +10004357 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10004358 else if (cmd_match(page, "recover")) {
NeilBrown56ccc112015-05-28 17:53:29 +10004359 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10004360 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10004361 } else if (cmd_match(page, "reshape")) {
NeilBrown16484bf2006-03-27 01:18:13 -08004362 int err;
4363 if (mddev->pers->start_reshape == NULL)
4364 return -EINVAL;
NeilBrown67918752014-12-15 12:57:01 +11004365 err = mddev_lock(mddev);
4366 if (!err) {
NeilBrown312045e2015-12-21 11:01:21 +11004367 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4368 err = -EBUSY;
4369 else {
4370 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4371 err = mddev->pers->start_reshape(mddev);
4372 }
NeilBrown67918752014-12-15 12:57:01 +11004373 mddev_unlock(mddev);
4374 }
NeilBrown16484bf2006-03-27 01:18:13 -08004375 if (err)
4376 return err;
Neil Browna99ac972008-06-28 08:31:43 +10004377 sysfs_notify(&mddev->kobj, NULL, "degraded");
NeilBrown16484bf2006-03-27 01:18:13 -08004378 } else {
NeilBrownbce74da2006-01-06 00:20:41 -08004379 if (cmd_match(page, "check"))
NeilBrown7eec3142005-11-08 21:39:44 -08004380 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
NeilBrown2adc7d42006-05-20 14:59:57 -07004381 else if (!cmd_match(page, "repair"))
NeilBrown7eec3142005-11-08 21:39:44 -08004382 return -EINVAL;
NeilBrown56ccc112015-05-28 17:53:29 +10004383 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown7eec3142005-11-08 21:39:44 -08004384 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
4385 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
NeilBrown7eec3142005-11-08 21:39:44 -08004386 }
NeilBrown48c26dd2012-10-11 14:19:39 +11004387 if (mddev->ro == 2) {
4388 /* A write to sync_action is enough to justify
4389 * canceling read-auto mode
4390 */
4391 mddev->ro = 0;
4392 md_wakeup_thread(mddev->sync_thread);
4393 }
NeilBrown03c902e2006-01-06 00:20:46 -08004394 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown24dd4692005-11-08 21:39:26 -08004395 md_wakeup_thread(mddev->thread);
NeilBrown00bcb4a2010-06-01 19:37:23 +10004396 sysfs_notify_dirent_safe(mddev->sysfs_action);
NeilBrown24dd4692005-11-08 21:39:26 -08004397 return len;
4398}
4399
Jonathan Brassowc4a39552013-06-25 01:23:59 -05004400static struct md_sysfs_entry md_scan_mode =
NeilBrown750f1992014-09-30 08:53:05 +10004401__ATTR_PREALLOC(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
Jonathan Brassowc4a39552013-06-25 01:23:59 -05004402
4403static ssize_t
4404last_sync_action_show(struct mddev *mddev, char *page)
4405{
4406 return sprintf(page, "%s\n", mddev->last_sync_action);
4407}
4408
4409static struct md_sysfs_entry md_last_scan_mode = __ATTR_RO(last_sync_action);
4410
NeilBrown9d888832005-11-08 21:39:26 -08004411static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004412mismatch_cnt_show(struct mddev *mddev, char *page)
NeilBrown9d888832005-11-08 21:39:26 -08004413{
4414 return sprintf(page, "%llu\n",
Jianpeng Ma7f7583d2012-10-11 14:17:59 +11004415 (unsigned long long)
4416 atomic64_read(&mddev->resync_mismatches));
NeilBrown9d888832005-11-08 21:39:26 -08004417}
4418
NeilBrown80ca3a42006-07-10 04:44:18 -07004419static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
NeilBrown9d888832005-11-08 21:39:26 -08004420
NeilBrown88202a02006-01-06 00:21:36 -08004421static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004422sync_min_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004423{
4424 return sprintf(page, "%d (%s)\n", speed_min(mddev),
4425 mddev->sync_speed_min ? "local": "system");
4426}
4427
4428static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004429sync_min_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown88202a02006-01-06 00:21:36 -08004430{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004431 unsigned int min;
4432 int rv;
4433
NeilBrown88202a02006-01-06 00:21:36 -08004434 if (strncmp(buf, "system", 6)==0) {
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004435 min = 0;
4436 } else {
4437 rv = kstrtouint(buf, 10, &min);
4438 if (rv < 0)
4439 return rv;
4440 if (min == 0)
4441 return -EINVAL;
NeilBrown88202a02006-01-06 00:21:36 -08004442 }
NeilBrown88202a02006-01-06 00:21:36 -08004443 mddev->sync_speed_min = min;
4444 return len;
4445}
4446
4447static struct md_sysfs_entry md_sync_min =
4448__ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
4449
4450static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004451sync_max_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004452{
4453 return sprintf(page, "%d (%s)\n", speed_max(mddev),
4454 mddev->sync_speed_max ? "local": "system");
4455}
4456
4457static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004458sync_max_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown88202a02006-01-06 00:21:36 -08004459{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004460 unsigned int max;
4461 int rv;
4462
NeilBrown88202a02006-01-06 00:21:36 -08004463 if (strncmp(buf, "system", 6)==0) {
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004464 max = 0;
4465 } else {
4466 rv = kstrtouint(buf, 10, &max);
4467 if (rv < 0)
4468 return rv;
4469 if (max == 0)
4470 return -EINVAL;
NeilBrown88202a02006-01-06 00:21:36 -08004471 }
NeilBrown88202a02006-01-06 00:21:36 -08004472 mddev->sync_speed_max = max;
4473 return len;
4474}
4475
4476static struct md_sysfs_entry md_sync_max =
4477__ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
4478
Iustin Popd7f3d292007-10-16 23:30:54 -07004479static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004480degraded_show(struct mddev *mddev, char *page)
Iustin Popd7f3d292007-10-16 23:30:54 -07004481{
4482 return sprintf(page, "%d\n", mddev->degraded);
4483}
4484static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
NeilBrown88202a02006-01-06 00:21:36 -08004485
4486static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004487sync_force_parallel_show(struct mddev *mddev, char *page)
Bernd Schubert90b08712008-05-23 13:04:38 -07004488{
4489 return sprintf(page, "%d\n", mddev->parallel_resync);
4490}
4491
4492static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004493sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
Bernd Schubert90b08712008-05-23 13:04:38 -07004494{
4495 long n;
4496
Jingoo Hanb29bebd2013-06-01 16:15:16 +09004497 if (kstrtol(buf, 10, &n))
Bernd Schubert90b08712008-05-23 13:04:38 -07004498 return -EINVAL;
4499
4500 if (n != 0 && n != 1)
4501 return -EINVAL;
4502
4503 mddev->parallel_resync = n;
4504
4505 if (mddev->sync_thread)
4506 wake_up(&resync_wait);
4507
4508 return len;
4509}
4510
4511/* force parallel resync, even with shared block devices */
4512static struct md_sysfs_entry md_sync_force_parallel =
4513__ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
4514 sync_force_parallel_show, sync_force_parallel_store);
4515
4516static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004517sync_speed_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004518{
4519 unsigned long resync, dt, db;
NeilBrownd1a7c502009-03-31 15:24:32 +11004520 if (mddev->curr_resync == 0)
4521 return sprintf(page, "none\n");
Andre Noll9687a602008-03-25 22:24:09 +01004522 resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
4523 dt = (jiffies - mddev->resync_mark) / HZ;
NeilBrown88202a02006-01-06 00:21:36 -08004524 if (!dt) dt++;
Andre Noll9687a602008-03-25 22:24:09 +01004525 db = resync - mddev->resync_mark_cnt;
4526 return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
NeilBrown88202a02006-01-06 00:21:36 -08004527}
4528
NeilBrown80ca3a42006-07-10 04:44:18 -07004529static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
NeilBrown88202a02006-01-06 00:21:36 -08004530
4531static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004532sync_completed_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004533{
RĂ©mi RĂ©rolle13ae8642011-01-14 09:14:34 +11004534 unsigned long long max_sectors, resync;
NeilBrown88202a02006-01-06 00:21:36 -08004535
NeilBrownacb180b2009-04-14 16:28:34 +10004536 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4537 return sprintf(page, "none\n");
4538
NeilBrown72f36d52012-10-11 14:25:57 +11004539 if (mddev->curr_resync == 1 ||
4540 mddev->curr_resync == 2)
4541 return sprintf(page, "delayed\n");
4542
NeilBrownc804cde2012-05-21 09:28:33 +10004543 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
4544 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
Andre Noll58c0fed2009-03-31 14:33:13 +11004545 max_sectors = mddev->resync_max_sectors;
NeilBrown88202a02006-01-06 00:21:36 -08004546 else
Andre Noll58c0fed2009-03-31 14:33:13 +11004547 max_sectors = mddev->dev_sectors;
NeilBrown88202a02006-01-06 00:21:36 -08004548
NeilBrownacb180b2009-04-14 16:28:34 +10004549 resync = mddev->curr_resync_completed;
RĂ©mi RĂ©rolle13ae8642011-01-14 09:14:34 +11004550 return sprintf(page, "%llu / %llu\n", resync, max_sectors);
NeilBrown88202a02006-01-06 00:21:36 -08004551}
4552
NeilBrown750f1992014-09-30 08:53:05 +10004553static struct md_sysfs_entry md_sync_completed =
4554 __ATTR_PREALLOC(sync_completed, S_IRUGO, sync_completed_show, NULL);
NeilBrown88202a02006-01-06 00:21:36 -08004555
NeilBrowne464eaf2006-03-27 01:18:14 -08004556static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004557min_sync_show(struct mddev *mddev, char *page)
Neil Brown5e96ee62008-06-28 08:31:24 +10004558{
4559 return sprintf(page, "%llu\n",
4560 (unsigned long long)mddev->resync_min);
4561}
4562static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004563min_sync_store(struct mddev *mddev, const char *buf, size_t len)
Neil Brown5e96ee62008-06-28 08:31:24 +10004564{
4565 unsigned long long min;
NeilBrown23da4222014-12-15 12:57:01 +11004566 int err;
NeilBrown23da4222014-12-15 12:57:01 +11004567
Jingoo Hanb29bebd2013-06-01 16:15:16 +09004568 if (kstrtoull(buf, 10, &min))
Neil Brown5e96ee62008-06-28 08:31:24 +10004569 return -EINVAL;
NeilBrown23da4222014-12-15 12:57:01 +11004570
4571 spin_lock(&mddev->lock);
4572 err = -EINVAL;
Neil Brown5e96ee62008-06-28 08:31:24 +10004573 if (min > mddev->resync_max)
NeilBrown23da4222014-12-15 12:57:01 +11004574 goto out_unlock;
4575
4576 err = -EBUSY;
Neil Brown5e96ee62008-06-28 08:31:24 +10004577 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown23da4222014-12-15 12:57:01 +11004578 goto out_unlock;
Neil Brown5e96ee62008-06-28 08:31:24 +10004579
NeilBrown50c37b12015-03-23 17:36:38 +11004580 /* Round down to multiple of 4K for safety */
4581 mddev->resync_min = round_down(min, 8);
NeilBrown23da4222014-12-15 12:57:01 +11004582 err = 0;
Neil Brown5e96ee62008-06-28 08:31:24 +10004583
NeilBrown23da4222014-12-15 12:57:01 +11004584out_unlock:
4585 spin_unlock(&mddev->lock);
4586 return err ?: len;
Neil Brown5e96ee62008-06-28 08:31:24 +10004587}
4588
4589static struct md_sysfs_entry md_min_sync =
4590__ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
4591
4592static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004593max_sync_show(struct mddev *mddev, char *page)
NeilBrownc6207272008-02-06 01:39:52 -08004594{
4595 if (mddev->resync_max == MaxSector)
4596 return sprintf(page, "max\n");
4597 else
4598 return sprintf(page, "%llu\n",
4599 (unsigned long long)mddev->resync_max);
4600}
4601static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004602max_sync_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownc6207272008-02-06 01:39:52 -08004603{
NeilBrown23da4222014-12-15 12:57:01 +11004604 int err;
4605 spin_lock(&mddev->lock);
NeilBrownc6207272008-02-06 01:39:52 -08004606 if (strncmp(buf, "max", 3) == 0)
4607 mddev->resync_max = MaxSector;
4608 else {
Neil Brown5e96ee62008-06-28 08:31:24 +10004609 unsigned long long max;
NeilBrown23da4222014-12-15 12:57:01 +11004610 int chunk;
4611
4612 err = -EINVAL;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09004613 if (kstrtoull(buf, 10, &max))
NeilBrown23da4222014-12-15 12:57:01 +11004614 goto out_unlock;
Neil Brown5e96ee62008-06-28 08:31:24 +10004615 if (max < mddev->resync_min)
NeilBrown23da4222014-12-15 12:57:01 +11004616 goto out_unlock;
4617
4618 err = -EBUSY;
NeilBrownc6207272008-02-06 01:39:52 -08004619 if (max < mddev->resync_max &&
NeilBrown4d484a42009-08-13 10:41:50 +10004620 mddev->ro == 0 &&
NeilBrownc6207272008-02-06 01:39:52 -08004621 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown23da4222014-12-15 12:57:01 +11004622 goto out_unlock;
NeilBrownc6207272008-02-06 01:39:52 -08004623
4624 /* Must be a multiple of chunk_size */
NeilBrown23da4222014-12-15 12:57:01 +11004625 chunk = mddev->chunk_sectors;
4626 if (chunk) {
raz ben yehuda2ac06c32009-06-16 17:01:42 +10004627 sector_t temp = max;
NeilBrown23da4222014-12-15 12:57:01 +11004628
4629 err = -EINVAL;
4630 if (sector_div(temp, chunk))
4631 goto out_unlock;
NeilBrownc6207272008-02-06 01:39:52 -08004632 }
4633 mddev->resync_max = max;
4634 }
4635 wake_up(&mddev->recovery_wait);
NeilBrown23da4222014-12-15 12:57:01 +11004636 err = 0;
4637out_unlock:
4638 spin_unlock(&mddev->lock);
4639 return err ?: len;
NeilBrownc6207272008-02-06 01:39:52 -08004640}
4641
4642static struct md_sysfs_entry md_max_sync =
4643__ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
4644
4645static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004646suspend_lo_show(struct mddev *mddev, char *page)
NeilBrowne464eaf2006-03-27 01:18:14 -08004647{
4648 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
4649}
4650
4651static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004652suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowne464eaf2006-03-27 01:18:14 -08004653{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004654 unsigned long long old, new;
NeilBrown67918752014-12-15 12:57:01 +11004655 int err;
NeilBrowne464eaf2006-03-27 01:18:14 -08004656
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004657 err = kstrtoull(buf, 10, &new);
4658 if (err < 0)
4659 return err;
4660 if (new != (sector_t)new)
NeilBrowne464eaf2006-03-27 01:18:14 -08004661 return -EINVAL;
NeilBrown23ddff32011-01-14 09:14:34 +11004662
NeilBrown67918752014-12-15 12:57:01 +11004663 err = mddev_lock(mddev);
4664 if (err)
4665 return err;
4666 err = -EINVAL;
4667 if (mddev->pers == NULL ||
4668 mddev->pers->quiesce == NULL)
4669 goto unlock;
4670 old = mddev->suspend_lo;
NeilBrown23ddff32011-01-14 09:14:34 +11004671 mddev->suspend_lo = new;
4672 if (new >= old)
4673 /* Shrinking suspended region */
NeilBrowne464eaf2006-03-27 01:18:14 -08004674 mddev->pers->quiesce(mddev, 2);
NeilBrown23ddff32011-01-14 09:14:34 +11004675 else {
4676 /* Expanding suspended region - need to wait */
4677 mddev->pers->quiesce(mddev, 1);
4678 mddev->pers->quiesce(mddev, 0);
4679 }
NeilBrown67918752014-12-15 12:57:01 +11004680 err = 0;
4681unlock:
4682 mddev_unlock(mddev);
4683 return err ?: len;
NeilBrowne464eaf2006-03-27 01:18:14 -08004684}
4685static struct md_sysfs_entry md_suspend_lo =
4686__ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
4687
NeilBrowne464eaf2006-03-27 01:18:14 -08004688static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004689suspend_hi_show(struct mddev *mddev, char *page)
NeilBrowne464eaf2006-03-27 01:18:14 -08004690{
4691 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
4692}
4693
4694static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004695suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowne464eaf2006-03-27 01:18:14 -08004696{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004697 unsigned long long old, new;
NeilBrown67918752014-12-15 12:57:01 +11004698 int err;
NeilBrowne464eaf2006-03-27 01:18:14 -08004699
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004700 err = kstrtoull(buf, 10, &new);
4701 if (err < 0)
4702 return err;
4703 if (new != (sector_t)new)
NeilBrowne464eaf2006-03-27 01:18:14 -08004704 return -EINVAL;
NeilBrown23ddff32011-01-14 09:14:34 +11004705
NeilBrown67918752014-12-15 12:57:01 +11004706 err = mddev_lock(mddev);
4707 if (err)
4708 return err;
4709 err = -EINVAL;
4710 if (mddev->pers == NULL ||
4711 mddev->pers->quiesce == NULL)
4712 goto unlock;
4713 old = mddev->suspend_hi;
NeilBrown23ddff32011-01-14 09:14:34 +11004714 mddev->suspend_hi = new;
4715 if (new <= old)
4716 /* Shrinking suspended region */
4717 mddev->pers->quiesce(mddev, 2);
4718 else {
4719 /* Expanding suspended region - need to wait */
NeilBrowne464eaf2006-03-27 01:18:14 -08004720 mddev->pers->quiesce(mddev, 1);
4721 mddev->pers->quiesce(mddev, 0);
NeilBrown23ddff32011-01-14 09:14:34 +11004722 }
NeilBrown67918752014-12-15 12:57:01 +11004723 err = 0;
4724unlock:
4725 mddev_unlock(mddev);
4726 return err ?: len;
NeilBrowne464eaf2006-03-27 01:18:14 -08004727}
4728static struct md_sysfs_entry md_suspend_hi =
4729__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
4730
NeilBrown08a02ec2007-05-09 02:35:38 -07004731static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004732reshape_position_show(struct mddev *mddev, char *page)
NeilBrown08a02ec2007-05-09 02:35:38 -07004733{
4734 if (mddev->reshape_position != MaxSector)
4735 return sprintf(page, "%llu\n",
4736 (unsigned long long)mddev->reshape_position);
4737 strcpy(page, "none\n");
4738 return 5;
4739}
4740
4741static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004742reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown08a02ec2007-05-09 02:35:38 -07004743{
NeilBrownc6563a82012-05-21 09:27:00 +10004744 struct md_rdev *rdev;
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004745 unsigned long long new;
NeilBrown67918752014-12-15 12:57:01 +11004746 int err;
NeilBrown67918752014-12-15 12:57:01 +11004747
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004748 err = kstrtoull(buf, 10, &new);
4749 if (err < 0)
4750 return err;
4751 if (new != (sector_t)new)
NeilBrown08a02ec2007-05-09 02:35:38 -07004752 return -EINVAL;
NeilBrown67918752014-12-15 12:57:01 +11004753 err = mddev_lock(mddev);
4754 if (err)
4755 return err;
4756 err = -EBUSY;
4757 if (mddev->pers)
4758 goto unlock;
NeilBrown08a02ec2007-05-09 02:35:38 -07004759 mddev->reshape_position = new;
4760 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10004761 mddev->reshape_backwards = 0;
NeilBrown08a02ec2007-05-09 02:35:38 -07004762 mddev->new_level = mddev->level;
4763 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10004764 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownc6563a82012-05-21 09:27:00 +10004765 rdev_for_each(rdev, mddev)
4766 rdev->new_data_offset = rdev->data_offset;
NeilBrown67918752014-12-15 12:57:01 +11004767 err = 0;
4768unlock:
4769 mddev_unlock(mddev);
4770 return err ?: len;
NeilBrown08a02ec2007-05-09 02:35:38 -07004771}
4772
4773static struct md_sysfs_entry md_reshape_position =
4774__ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
4775 reshape_position_store);
4776
Dan Williamsb522adc2009-03-31 15:00:31 +11004777static ssize_t
NeilBrown2c810cd2012-05-21 09:27:00 +10004778reshape_direction_show(struct mddev *mddev, char *page)
4779{
4780 return sprintf(page, "%s\n",
4781 mddev->reshape_backwards ? "backwards" : "forwards");
4782}
4783
4784static ssize_t
4785reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
4786{
4787 int backwards = 0;
NeilBrown67918752014-12-15 12:57:01 +11004788 int err;
4789
NeilBrown2c810cd2012-05-21 09:27:00 +10004790 if (cmd_match(buf, "forwards"))
4791 backwards = 0;
4792 else if (cmd_match(buf, "backwards"))
4793 backwards = 1;
4794 else
4795 return -EINVAL;
4796 if (mddev->reshape_backwards == backwards)
4797 return len;
4798
NeilBrown67918752014-12-15 12:57:01 +11004799 err = mddev_lock(mddev);
4800 if (err)
4801 return err;
NeilBrown2c810cd2012-05-21 09:27:00 +10004802 /* check if we are allowed to change */
4803 if (mddev->delta_disks)
NeilBrown67918752014-12-15 12:57:01 +11004804 err = -EBUSY;
4805 else if (mddev->persistent &&
NeilBrown2c810cd2012-05-21 09:27:00 +10004806 mddev->major_version == 0)
NeilBrown67918752014-12-15 12:57:01 +11004807 err = -EINVAL;
4808 else
4809 mddev->reshape_backwards = backwards;
4810 mddev_unlock(mddev);
4811 return err ?: len;
NeilBrown2c810cd2012-05-21 09:27:00 +10004812}
4813
4814static struct md_sysfs_entry md_reshape_direction =
4815__ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
4816 reshape_direction_store);
4817
4818static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004819array_size_show(struct mddev *mddev, char *page)
Dan Williamsb522adc2009-03-31 15:00:31 +11004820{
4821 if (mddev->external_size)
4822 return sprintf(page, "%llu\n",
4823 (unsigned long long)mddev->array_sectors/2);
4824 else
4825 return sprintf(page, "default\n");
4826}
4827
4828static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004829array_size_store(struct mddev *mddev, const char *buf, size_t len)
Dan Williamsb522adc2009-03-31 15:00:31 +11004830{
4831 sector_t sectors;
NeilBrown67918752014-12-15 12:57:01 +11004832 int err;
4833
4834 err = mddev_lock(mddev);
4835 if (err)
4836 return err;
Dan Williamsb522adc2009-03-31 15:00:31 +11004837
Guoqing Jiangab5a98b2016-05-02 11:33:13 -04004838 /* cluster raid doesn't support change array_sectors */
Zhilong Liu1f8fe982017-04-10 14:15:55 +08004839 if (mddev_is_clustered(mddev)) {
4840 mddev_unlock(mddev);
Guoqing Jiangab5a98b2016-05-02 11:33:13 -04004841 return -EINVAL;
Zhilong Liu1f8fe982017-04-10 14:15:55 +08004842 }
Guoqing Jiangab5a98b2016-05-02 11:33:13 -04004843
Dan Williamsb522adc2009-03-31 15:00:31 +11004844 if (strncmp(buf, "default", 7) == 0) {
4845 if (mddev->pers)
4846 sectors = mddev->pers->size(mddev, 0, 0);
4847 else
4848 sectors = mddev->array_sectors;
4849
4850 mddev->external_size = 0;
4851 } else {
4852 if (strict_blocks_to_sectors(buf, &sectors) < 0)
NeilBrown67918752014-12-15 12:57:01 +11004853 err = -EINVAL;
4854 else if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
4855 err = -E2BIG;
4856 else
4857 mddev->external_size = 1;
Dan Williamsb522adc2009-03-31 15:00:31 +11004858 }
4859
NeilBrown67918752014-12-15 12:57:01 +11004860 if (!err) {
4861 mddev->array_sectors = sectors;
4862 if (mddev->pers) {
4863 set_capacity(mddev->gendisk, mddev->array_sectors);
4864 revalidate_disk(mddev->gendisk);
4865 }
NeilBrowncbe6ef12011-02-16 13:58:38 +11004866 }
NeilBrown67918752014-12-15 12:57:01 +11004867 mddev_unlock(mddev);
4868 return err ?: len;
Dan Williamsb522adc2009-03-31 15:00:31 +11004869}
4870
4871static struct md_sysfs_entry md_array_size =
4872__ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
4873 array_size_store);
NeilBrowne464eaf2006-03-27 01:18:14 -08004874
NeilBrowneae17012005-11-08 21:39:23 -08004875static struct attribute *md_default_attrs[] = {
4876 &md_level.attr,
NeilBrownd4dbd022006-06-26 00:27:59 -07004877 &md_layout.attr,
NeilBrowneae17012005-11-08 21:39:23 -08004878 &md_raid_disks.attr,
NeilBrown3b343802006-01-06 00:20:47 -08004879 &md_chunk_size.attr,
NeilBrowna35b0d62006-01-06 00:20:49 -08004880 &md_size.attr,
NeilBrowna94213b2006-06-26 00:28:00 -07004881 &md_resync_start.attr,
NeilBrown8bb93aa2006-01-06 00:20:50 -08004882 &md_metadata.attr,
NeilBrown6d7ff732006-01-06 00:21:16 -08004883 &md_new_device.attr,
NeilBrown16f17b32006-06-26 00:27:37 -07004884 &md_safe_delay.attr,
NeilBrown9e653b62006-06-26 00:27:58 -07004885 &md_array_state.attr,
NeilBrown08a02ec2007-05-09 02:35:38 -07004886 &md_reshape_position.attr,
NeilBrown2c810cd2012-05-21 09:27:00 +10004887 &md_reshape_direction.attr,
Dan Williamsb522adc2009-03-31 15:00:31 +11004888 &md_array_size.attr,
Robert Becker1e509152009-12-14 12:49:58 +11004889 &max_corr_read_errors.attr,
NeilBrown411036f2005-11-08 21:39:40 -08004890 NULL,
4891};
4892
4893static struct attribute *md_redundancy_attrs[] = {
NeilBrown24dd4692005-11-08 21:39:26 -08004894 &md_scan_mode.attr,
Jonathan Brassowc4a39552013-06-25 01:23:59 -05004895 &md_last_scan_mode.attr,
NeilBrown9d888832005-11-08 21:39:26 -08004896 &md_mismatches.attr,
NeilBrown88202a02006-01-06 00:21:36 -08004897 &md_sync_min.attr,
4898 &md_sync_max.attr,
4899 &md_sync_speed.attr,
Bernd Schubert90b08712008-05-23 13:04:38 -07004900 &md_sync_force_parallel.attr,
NeilBrown88202a02006-01-06 00:21:36 -08004901 &md_sync_completed.attr,
Neil Brown5e96ee62008-06-28 08:31:24 +10004902 &md_min_sync.attr,
NeilBrownc6207272008-02-06 01:39:52 -08004903 &md_max_sync.attr,
NeilBrowne464eaf2006-03-27 01:18:14 -08004904 &md_suspend_lo.attr,
4905 &md_suspend_hi.attr,
Paul Clements9b1d1da2006-10-03 01:15:49 -07004906 &md_bitmap.attr,
Iustin Popd7f3d292007-10-16 23:30:54 -07004907 &md_degraded.attr,
NeilBrowneae17012005-11-08 21:39:23 -08004908 NULL,
4909};
NeilBrown411036f2005-11-08 21:39:40 -08004910static struct attribute_group md_redundancy_group = {
4911 .name = NULL,
4912 .attrs = md_redundancy_attrs,
4913};
4914
NeilBrowneae17012005-11-08 21:39:23 -08004915static ssize_t
4916md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
4917{
4918 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
NeilBrownfd01b882011-10-11 16:47:53 +11004919 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
NeilBrown96de1e62005-11-08 21:39:39 -08004920 ssize_t rv;
NeilBrowneae17012005-11-08 21:39:23 -08004921
4922 if (!entry->show)
4923 return -EIO;
NeilBrownaf8a2432011-12-08 15:49:46 +11004924 spin_lock(&all_mddevs_lock);
4925 if (list_empty(&mddev->all_mddevs)) {
4926 spin_unlock(&all_mddevs_lock);
4927 return -EBUSY;
4928 }
4929 mddev_get(mddev);
4930 spin_unlock(&all_mddevs_lock);
4931
NeilBrownb7b17c92014-12-15 12:56:59 +11004932 rv = entry->show(mddev, page);
NeilBrownaf8a2432011-12-08 15:49:46 +11004933 mddev_put(mddev);
NeilBrown96de1e62005-11-08 21:39:39 -08004934 return rv;
NeilBrowneae17012005-11-08 21:39:23 -08004935}
4936
4937static ssize_t
4938md_attr_store(struct kobject *kobj, struct attribute *attr,
4939 const char *page, size_t length)
4940{
4941 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
NeilBrownfd01b882011-10-11 16:47:53 +11004942 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
NeilBrown96de1e62005-11-08 21:39:39 -08004943 ssize_t rv;
NeilBrowneae17012005-11-08 21:39:23 -08004944
4945 if (!entry->store)
4946 return -EIO;
NeilBrown67463ac2006-07-10 04:44:19 -07004947 if (!capable(CAP_SYS_ADMIN))
4948 return -EACCES;
NeilBrownaf8a2432011-12-08 15:49:46 +11004949 spin_lock(&all_mddevs_lock);
4950 if (list_empty(&mddev->all_mddevs)) {
4951 spin_unlock(&all_mddevs_lock);
4952 return -EBUSY;
4953 }
4954 mddev_get(mddev);
4955 spin_unlock(&all_mddevs_lock);
NeilBrown67918752014-12-15 12:57:01 +11004956 rv = entry->store(mddev, page, length);
NeilBrownaf8a2432011-12-08 15:49:46 +11004957 mddev_put(mddev);
NeilBrown96de1e62005-11-08 21:39:39 -08004958 return rv;
NeilBrowneae17012005-11-08 21:39:23 -08004959}
4960
4961static void md_free(struct kobject *ko)
4962{
NeilBrownfd01b882011-10-11 16:47:53 +11004963 struct mddev *mddev = container_of(ko, struct mddev, kobj);
NeilBrowna21d1502009-01-09 08:31:09 +11004964
4965 if (mddev->sysfs_state)
4966 sysfs_put(mddev->sysfs_state);
4967
NeilBrown6cd18e72015-04-27 14:12:22 +10004968 if (mddev->queue)
4969 blk_cleanup_queue(mddev->queue);
NeilBrowna21d1502009-01-09 08:31:09 +11004970 if (mddev->gendisk) {
4971 del_gendisk(mddev->gendisk);
4972 put_disk(mddev->gendisk);
4973 }
NeilBrowna21d1502009-01-09 08:31:09 +11004974
NeilBrowneae17012005-11-08 21:39:23 -08004975 kfree(mddev);
4976}
4977
Emese Revfy52cf25d2010-01-19 02:58:23 +01004978static const struct sysfs_ops md_sysfs_ops = {
NeilBrowneae17012005-11-08 21:39:23 -08004979 .show = md_attr_show,
4980 .store = md_attr_store,
4981};
4982static struct kobj_type md_ktype = {
4983 .release = md_free,
4984 .sysfs_ops = &md_sysfs_ops,
4985 .default_attrs = md_default_attrs,
4986};
4987
Linus Torvalds1da177e2005-04-16 15:20:36 -07004988int mdp_major = 0;
4989
Dan Williams5fd3a172009-03-04 00:57:25 -07004990static void mddev_delayed_delete(struct work_struct *ws)
4991{
NeilBrownfd01b882011-10-11 16:47:53 +11004992 struct mddev *mddev = container_of(ws, struct mddev, del_work);
Dan Williams5fd3a172009-03-04 00:57:25 -07004993
NeilBrown43a70502009-12-14 12:49:55 +11004994 sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
Dan Williams5fd3a172009-03-04 00:57:25 -07004995 kobject_del(&mddev->kobj);
4996 kobject_put(&mddev->kobj);
4997}
4998
NeilBrownefeb53c2009-01-09 08:31:10 +11004999static int md_alloc(dev_t dev, char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005000{
Arjan van de Ven48c9c272006-03-27 01:18:20 -08005001 static DEFINE_MUTEX(disks_mutex);
NeilBrownfd01b882011-10-11 16:47:53 +11005002 struct mddev *mddev = mddev_find(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005003 struct gendisk *disk;
NeilBrownefeb53c2009-01-09 08:31:10 +11005004 int partitioned;
5005 int shift;
5006 int unit;
Greg Kroah-Hartman3830c622007-12-17 15:54:39 -04005007 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005008
5009 if (!mddev)
NeilBrownefeb53c2009-01-09 08:31:10 +11005010 return -ENODEV;
5011
5012 partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
5013 shift = partitioned ? MdpMinorShift : 0;
5014 unit = MINOR(mddev->unit) >> shift;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005015
Tejun Heoe804ac72010-10-15 15:36:08 +02005016 /* wait for any previous instance of this device to be
5017 * completely removed (mddev_delayed_delete).
NeilBrownd3374822009-01-09 08:31:10 +11005018 */
Tejun Heoe804ac72010-10-15 15:36:08 +02005019 flush_workqueue(md_misc_wq);
NeilBrownd3374822009-01-09 08:31:10 +11005020
Arjan van de Ven48c9c272006-03-27 01:18:20 -08005021 mutex_lock(&disks_mutex);
NeilBrown0909dc42009-07-01 12:27:21 +10005022 error = -EEXIST;
5023 if (mddev->gendisk)
5024 goto abort;
NeilBrownefeb53c2009-01-09 08:31:10 +11005025
5026 if (name) {
5027 /* Need to ensure that 'name' is not a duplicate.
5028 */
NeilBrownfd01b882011-10-11 16:47:53 +11005029 struct mddev *mddev2;
NeilBrownefeb53c2009-01-09 08:31:10 +11005030 spin_lock(&all_mddevs_lock);
5031
5032 list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
5033 if (mddev2->gendisk &&
5034 strcmp(mddev2->gendisk->disk_name, name) == 0) {
5035 spin_unlock(&all_mddevs_lock);
NeilBrown0909dc42009-07-01 12:27:21 +10005036 goto abort;
NeilBrownefeb53c2009-01-09 08:31:10 +11005037 }
5038 spin_unlock(&all_mddevs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005039 }
NeilBrown8b765392009-01-09 08:31:08 +11005040
NeilBrown0909dc42009-07-01 12:27:21 +10005041 error = -ENOMEM;
NeilBrown8b765392009-01-09 08:31:08 +11005042 mddev->queue = blk_alloc_queue(GFP_KERNEL);
NeilBrown0909dc42009-07-01 12:27:21 +10005043 if (!mddev->queue)
5044 goto abort;
NeilBrown409c57f2009-03-31 14:39:39 +11005045 mddev->queue->queuedata = mddev;
5046
NeilBrown409c57f2009-03-31 14:39:39 +11005047 blk_queue_make_request(mddev->queue, md_make_request);
Martin K. Petersenb1bd0552012-01-11 16:27:11 +01005048 blk_set_stacking_limits(&mddev->queue->limits);
NeilBrown8b765392009-01-09 08:31:08 +11005049
Linus Torvalds1da177e2005-04-16 15:20:36 -07005050 disk = alloc_disk(1 << shift);
5051 if (!disk) {
NeilBrown8b765392009-01-09 08:31:08 +11005052 blk_cleanup_queue(mddev->queue);
5053 mddev->queue = NULL;
NeilBrown0909dc42009-07-01 12:27:21 +10005054 goto abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005055 }
NeilBrownefeb53c2009-01-09 08:31:10 +11005056 disk->major = MAJOR(mddev->unit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005057 disk->first_minor = unit << shift;
NeilBrownefeb53c2009-01-09 08:31:10 +11005058 if (name)
5059 strcpy(disk->disk_name, name);
5060 else if (partitioned)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005061 sprintf(disk->disk_name, "md_d%d", unit);
Greg Kroah-Hartmance7b0f42005-06-20 21:15:16 -07005062 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07005063 sprintf(disk->disk_name, "md%d", unit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005064 disk->fops = &md_fops;
5065 disk->private_data = mddev;
5066 disk->queue = mddev->queue;
Jens Axboe56883a72016-03-30 10:16:53 -06005067 blk_queue_write_cache(mddev->queue, true, true);
NeilBrown92850bb2008-10-21 13:25:32 +11005068 /* Allow extended partitions. This makes the
NeilBrownd3374822009-01-09 08:31:10 +11005069 * 'mdp' device redundant, but we can't really
NeilBrown92850bb2008-10-21 13:25:32 +11005070 * remove it now.
5071 */
5072 disk->flags |= GENHD_FL_EXT_DEVT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005073 mddev->gendisk = disk;
NeilBrownb0140892011-05-10 17:49:01 +10005074 /* As soon as we call add_disk(), another thread could get
5075 * through to md_open, so make sure it doesn't get too far
5076 */
5077 mutex_lock(&mddev->open_mutex);
5078 add_disk(disk);
5079
Tejun Heoed9e1982008-08-25 19:56:05 +09005080 error = kobject_init_and_add(&mddev->kobj, &md_ktype,
5081 &disk_to_dev(disk)->kobj, "%s", "md");
NeilBrown0909dc42009-07-01 12:27:21 +10005082 if (error) {
5083 /* This isn't possible, but as kobject_init_and_add is marked
5084 * __must_check, we must do something with the result
5085 */
NeilBrown5e55e2f2007-03-26 21:32:14 -08005086 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
5087 disk->disk_name);
NeilBrown0909dc42009-07-01 12:27:21 +10005088 error = 0;
5089 }
NeilBrown00bcb4a2010-06-01 19:37:23 +10005090 if (mddev->kobj.sd &&
5091 sysfs_create_group(&mddev->kobj, &md_bitmap_group))
NeilBrown43a70502009-12-14 12:49:55 +11005092 printk(KERN_DEBUG "pointless warning\n");
NeilBrownb0140892011-05-10 17:49:01 +10005093 mutex_unlock(&mddev->open_mutex);
NeilBrown0909dc42009-07-01 12:27:21 +10005094 abort:
5095 mutex_unlock(&disks_mutex);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005096 if (!error && mddev->kobj.sd) {
Greg Kroah-Hartman3830c622007-12-17 15:54:39 -04005097 kobject_uevent(&mddev->kobj, KOBJ_ADD);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005098 mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
NeilBrownb62b7592008-10-21 13:25:21 +11005099 }
NeilBrownd3374822009-01-09 08:31:10 +11005100 mddev_put(mddev);
NeilBrown0909dc42009-07-01 12:27:21 +10005101 return error;
NeilBrownefeb53c2009-01-09 08:31:10 +11005102}
5103
5104static struct kobject *md_probe(dev_t dev, int *part, void *data)
5105{
5106 md_alloc(dev, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005107 return NULL;
5108}
5109
Kees Cook24da2c82017-10-17 19:04:42 -07005110static int add_named_array(const char *val, const struct kernel_param *kp)
NeilBrownefeb53c2009-01-09 08:31:10 +11005111{
5112 /* val must be "md_*" where * is not all digits.
5113 * We allocate an array with a large free minor number, and
5114 * set the name to val. val must not already be an active name.
5115 */
5116 int len = strlen(val);
5117 char buf[DISK_NAME_LEN];
5118
5119 while (len && val[len-1] == '\n')
5120 len--;
5121 if (len >= DISK_NAME_LEN)
5122 return -E2BIG;
5123 strlcpy(buf, val, len+1);
5124 if (strncmp(buf, "md_", 3) != 0)
5125 return -EINVAL;
5126 return md_alloc(0, buf);
5127}
5128
Linus Torvalds1da177e2005-04-16 15:20:36 -07005129static void md_safemode_timeout(unsigned long data)
5130{
NeilBrownfd01b882011-10-11 16:47:53 +11005131 struct mddev *mddev = (struct mddev *) data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005132
Neil Brown0fd62b82008-06-28 08:31:36 +10005133 if (!atomic_read(&mddev->writes_pending)) {
5134 mddev->safemode = 1;
5135 if (mddev->external)
NeilBrown00bcb4a2010-06-01 19:37:23 +10005136 sysfs_notify_dirent_safe(mddev->sysfs_state);
Neil Brown0fd62b82008-06-28 08:31:36 +10005137 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005138 md_wakeup_thread(mddev->thread);
5139}
5140
NeilBrown6ff8d8ec2006-01-06 00:20:15 -08005141static int start_dirty_degraded;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005142
NeilBrownfd01b882011-10-11 16:47:53 +11005143int md_run(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005144{
NeilBrown2604b702006-01-06 00:20:36 -08005145 int err;
NeilBrown3cb03002011-10-11 16:45:26 +11005146 struct md_rdev *rdev;
NeilBrown84fc4b52011-10-11 16:49:58 +11005147 struct md_personality *pers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005148
NeilBrowna757e642005-04-16 15:26:42 -07005149 if (list_empty(&mddev->disks))
5150 /* cannot run an array with no devices.. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005151 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005152
5153 if (mddev->pers)
5154 return -EBUSY;
NeilBrownbb4f1e92010-08-08 21:18:03 +10005155 /* Cannot run until previous stop completes properly */
5156 if (mddev->sysfs_active)
5157 return -EBUSY;
NeilBrownb6eb1272010-04-15 10:13:47 +10005158
Linus Torvalds1da177e2005-04-16 15:20:36 -07005159 /*
5160 * Analyze all RAID superblock(s)
5161 */
NeilBrown1ec4a932008-02-06 01:39:53 -08005162 if (!mddev->raid_disks) {
5163 if (!mddev->persistent)
5164 return -EINVAL;
NeilBrowna757e642005-04-16 15:26:42 -07005165 analyze_sbs(mddev);
NeilBrown1ec4a932008-02-06 01:39:53 -08005166 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005167
NeilBrownd9d166c2006-01-06 00:20:51 -08005168 if (mddev->level != LEVEL_NONE)
5169 request_module("md-level-%d", mddev->level);
5170 else if (mddev->clevel[0])
5171 request_module("md-%s", mddev->clevel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005172
5173 /*
5174 * Drop all container device buffers, from now on
5175 * the only valid external interface is through the md
5176 * device.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005177 */
NeilBrowndafb20f2012-03-19 12:46:39 +11005178 rdev_for_each(rdev, mddev) {
NeilBrownb2d444d2005-11-08 21:39:31 -08005179 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005180 continue;
5181 sync_blockdev(rdev->bdev);
Peter Zijlstraf98393a2007-05-06 14:49:54 -07005182 invalidate_bdev(rdev->bdev);
NeilBrownf0d76d72007-07-17 04:06:12 -07005183
5184 /* perform some consistency tests on the device.
5185 * We don't want the data to overlap the metadata,
Andre Noll58c0fed2009-03-31 14:33:13 +11005186 * Internal Bitmap issues have been handled elsewhere.
NeilBrownf0d76d72007-07-17 04:06:12 -07005187 */
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +11005188 if (rdev->meta_bdev) {
5189 /* Nothing to check */;
5190 } else if (rdev->data_offset < rdev->sb_start) {
Andre Noll58c0fed2009-03-31 14:33:13 +11005191 if (mddev->dev_sectors &&
5192 rdev->data_offset + mddev->dev_sectors
Andre Noll0f420352008-07-11 22:02:23 +10005193 > rdev->sb_start) {
NeilBrownf0d76d72007-07-17 04:06:12 -07005194 printk("md: %s: data overlaps metadata\n",
5195 mdname(mddev));
5196 return -EINVAL;
5197 }
5198 } else {
Andre Noll0f420352008-07-11 22:02:23 +10005199 if (rdev->sb_start + rdev->sb_size/512
NeilBrownf0d76d72007-07-17 04:06:12 -07005200 > rdev->data_offset) {
5201 printk("md: %s: metadata overlaps data\n",
5202 mdname(mddev));
5203 return -EINVAL;
5204 }
5205 }
NeilBrown00bcb4a2010-06-01 19:37:23 +10005206 sysfs_notify_dirent_safe(rdev->sysfs_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005207 }
5208
NeilBrowna167f662010-10-26 18:31:13 +11005209 if (mddev->bio_set == NULL)
Kent Overstreet395c72a2012-09-06 15:34:55 -07005210 mddev->bio_set = bioset_create(BIO_POOL_SIZE, 0);
NeilBrowna167f662010-10-26 18:31:13 +11005211
Linus Torvalds1da177e2005-04-16 15:20:36 -07005212 spin_lock(&pers_lock);
NeilBrownd9d166c2006-01-06 00:20:51 -08005213 pers = find_pers(mddev->level, mddev->clevel);
NeilBrown2604b702006-01-06 00:20:36 -08005214 if (!pers || !try_module_get(pers->owner)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005215 spin_unlock(&pers_lock);
NeilBrownd9d166c2006-01-06 00:20:51 -08005216 if (mddev->level != LEVEL_NONE)
5217 printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
5218 mddev->level);
5219 else
5220 printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
5221 mddev->clevel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005222 return -EINVAL;
5223 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005224 spin_unlock(&pers_lock);
NeilBrown34817e82009-03-31 14:39:38 +11005225 if (mddev->level != pers->level) {
5226 mddev->level = pers->level;
5227 mddev->new_level = pers->level;
5228 }
NeilBrownd9d166c2006-01-06 00:20:51 -08005229 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005230
NeilBrownf6705572006-03-27 01:18:11 -08005231 if (mddev->reshape_position != MaxSector &&
NeilBrown63c70c42006-03-27 01:18:13 -08005232 pers->start_reshape == NULL) {
NeilBrownf6705572006-03-27 01:18:11 -08005233 /* This personality cannot handle reshaping... */
NeilBrownf6705572006-03-27 01:18:11 -08005234 module_put(pers->owner);
5235 return -EINVAL;
5236 }
5237
NeilBrown7dd5e7c32007-02-28 20:11:35 -08005238 if (pers->sync_request) {
5239 /* Warn if this is a potentially silly
5240 * configuration.
5241 */
5242 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
NeilBrown3cb03002011-10-11 16:45:26 +11005243 struct md_rdev *rdev2;
NeilBrown7dd5e7c32007-02-28 20:11:35 -08005244 int warned = 0;
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005245
NeilBrowndafb20f2012-03-19 12:46:39 +11005246 rdev_for_each(rdev, mddev)
5247 rdev_for_each(rdev2, mddev) {
NeilBrown7dd5e7c32007-02-28 20:11:35 -08005248 if (rdev < rdev2 &&
5249 rdev->bdev->bd_contains ==
5250 rdev2->bdev->bd_contains) {
5251 printk(KERN_WARNING
5252 "%s: WARNING: %s appears to be"
5253 " on the same physical disk as"
5254 " %s.\n",
5255 mdname(mddev),
5256 bdevname(rdev->bdev,b),
5257 bdevname(rdev2->bdev,b2));
5258 warned = 1;
5259 }
5260 }
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005261
NeilBrown7dd5e7c32007-02-28 20:11:35 -08005262 if (warned)
5263 printk(KERN_WARNING
5264 "True protection against single-disk"
5265 " failure might be compromised.\n");
5266 }
5267
NeilBrown657390d2005-08-26 18:34:16 -07005268 mddev->recovery = 0;
Andre Noll58c0fed2009-03-31 14:33:13 +11005269 /* may be over-ridden by personality */
5270 mddev->resync_max_sectors = mddev->dev_sectors;
5271
NeilBrown6ff8d8ec2006-01-06 00:20:15 -08005272 mddev->ok_start_degraded = start_dirty_degraded;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005273
NeilBrown0f9552b2009-12-30 12:08:50 +11005274 if (start_readonly && mddev->ro == 0)
NeilBrownf91de922005-11-08 21:39:36 -08005275 mddev->ro = 2; /* read-only, but switch on first write */
5276
NeilBrown36d091f2014-12-15 12:56:58 +11005277 err = pers->run(mddev);
Andre Noll13e53df2008-03-26 00:07:03 +01005278 if (err)
5279 printk(KERN_ERR "md: pers->run() failed ...\n");
NeilBrown36d091f2014-12-15 12:56:58 +11005280 else if (pers->size(mddev, 0, 0) < mddev->array_sectors) {
Dan Williamsb522adc2009-03-31 15:00:31 +11005281 WARN_ONCE(!mddev->external_size, "%s: default size too small,"
5282 " but 'external_size' not in effect?\n", __func__);
5283 printk(KERN_ERR
5284 "md: invalid array_size %llu > default size %llu\n",
5285 (unsigned long long)mddev->array_sectors / 2,
NeilBrown36d091f2014-12-15 12:56:58 +11005286 (unsigned long long)pers->size(mddev, 0, 0) / 2);
Dan Williamsb522adc2009-03-31 15:00:31 +11005287 err = -EINVAL;
Dan Williamsb522adc2009-03-31 15:00:31 +11005288 }
NeilBrown36d091f2014-12-15 12:56:58 +11005289 if (err == 0 && pers->sync_request &&
NeilBrownef99bf42012-05-22 13:55:08 +10005290 (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
Goldwyn Rodriguesf9209a32014-06-06 12:43:49 -05005291 struct bitmap *bitmap;
5292
5293 bitmap = bitmap_create(mddev, -1);
5294 if (IS_ERR(bitmap)) {
5295 err = PTR_ERR(bitmap);
NeilBrownb15c2e52006-01-06 00:20:16 -08005296 printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
5297 mdname(mddev), err);
Goldwyn Rodriguesf9209a32014-06-06 12:43:49 -05005298 } else
5299 mddev->bitmap = bitmap;
5300
NeilBrownb15c2e52006-01-06 00:20:16 -08005301 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005302 if (err) {
NeilBrown5aa61f42014-12-15 12:56:57 +11005303 mddev_detach(mddev);
NeilBrown0c35bd42015-03-13 11:51:18 +11005304 if (mddev->private)
5305 pers->free(mddev, mddev->private);
NeilBrownbd691922015-06-25 17:01:40 +10005306 mddev->private = NULL;
NeilBrown36d091f2014-12-15 12:56:58 +11005307 module_put(pers->owner);
NeilBrown32a76272005-06-21 17:17:14 -07005308 bitmap_destroy(mddev);
5309 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005310 }
NeilBrown5c675f82014-12-15 12:56:56 +11005311 if (mddev->queue) {
Shaohua Libb086a82016-09-30 09:45:40 -07005312 bool nonrot = true;
5313
5314 rdev_for_each(rdev, mddev) {
5315 if (rdev->raid_disk >= 0 &&
5316 !blk_queue_nonrot(bdev_get_queue(rdev->bdev))) {
5317 nonrot = false;
5318 break;
5319 }
5320 }
5321 if (mddev->degraded)
5322 nonrot = false;
5323 if (nonrot)
5324 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, mddev->queue);
5325 else
5326 queue_flag_clear_unlocked(QUEUE_FLAG_NONROT, mddev->queue);
Jan Kara1cdb7f92017-02-02 15:56:50 +01005327 mddev->queue->backing_dev_info->congested_data = mddev;
5328 mddev->queue->backing_dev_info->congested_fn = md_congested;
NeilBrown5c675f82014-12-15 12:56:56 +11005329 }
NeilBrown36d091f2014-12-15 12:56:58 +11005330 if (pers->sync_request) {
NeilBrown00bcb4a2010-06-01 19:37:23 +10005331 if (mddev->kobj.sd &&
5332 sysfs_create_group(&mddev->kobj, &md_redundancy_group))
NeilBrown5e55e2f2007-03-26 21:32:14 -08005333 printk(KERN_WARNING
5334 "md: cannot register extra attributes for %s\n",
5335 mdname(mddev));
NeilBrown00bcb4a2010-06-01 19:37:23 +10005336 mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
NeilBrown5e55e2f2007-03-26 21:32:14 -08005337 } else if (mddev->ro == 2) /* auto-readonly not meaningful */
NeilBrownfd9d49c2005-11-08 21:39:42 -08005338 mddev->ro = 0;
5339
NeilBrownf72ffdd2014-09-30 14:23:59 +10005340 atomic_set(&mddev->writes_pending,0);
Robert Becker1e509152009-12-14 12:49:58 +11005341 atomic_set(&mddev->max_corr_read_errors,
5342 MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005343 mddev->safemode = 0;
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11005344 if (mddev_is_clustered(mddev))
5345 mddev->safemode_delay = 0;
5346 else
5347 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005348 mddev->in_sync = 1;
NeilBrown0ca69882011-01-14 09:14:33 +11005349 smp_wmb();
NeilBrown36d091f2014-12-15 12:56:58 +11005350 spin_lock(&mddev->lock);
5351 mddev->pers = pers;
NeilBrown36d091f2014-12-15 12:56:58 +11005352 spin_unlock(&mddev->lock);
NeilBrowndafb20f2012-03-19 12:46:39 +11005353 rdev_for_each(rdev, mddev)
Namhyung Kim36fad852011-07-27 11:00:36 +10005354 if (rdev->raid_disk >= 0)
5355 if (sysfs_link_rdev(mddev, rdev))
NeilBrown00bcb4a2010-06-01 19:37:23 +10005356 /* failure here is OK */;
NeilBrownf72ffdd2014-09-30 14:23:59 +10005357
NeilBrowna4a3d262015-07-17 11:57:30 +10005358 if (mddev->degraded && !mddev->ro)
5359 /* This ensures that recovering status is reported immediately
5360 * via sysfs - until a lack of spares is confirmed.
5361 */
5362 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005363 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrownf72ffdd2014-09-30 14:23:59 +10005364
NeilBrown7a0a5352013-08-27 16:28:23 +10005365 if (mddev->flags & MD_UPDATE_SB_FLAGS)
NeilBrown850b2b42006-10-03 01:15:46 -07005366 md_update_sb(mddev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005367
NeilBrownd7603b72006-01-06 00:20:30 -08005368 md_new_event(mddev);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005369 sysfs_notify_dirent_safe(mddev->sysfs_state);
5370 sysfs_notify_dirent_safe(mddev->sysfs_action);
Neil Browna99ac972008-06-28 08:31:43 +10005371 sysfs_notify(&mddev->kobj, NULL, "degraded");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005372 return 0;
5373}
NeilBrown390ee602010-06-01 19:37:27 +10005374EXPORT_SYMBOL_GPL(md_run);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005375
NeilBrownfd01b882011-10-11 16:47:53 +11005376static int do_md_run(struct mddev *mddev)
NeilBrownfe60b012010-03-29 11:10:42 +11005377{
5378 int err;
5379
5380 err = md_run(mddev);
5381 if (err)
5382 goto out;
NeilBrown69e51b42010-06-01 19:37:35 +10005383 err = bitmap_load(mddev);
5384 if (err) {
5385 bitmap_destroy(mddev);
5386 goto out;
5387 }
Jonathan Brassow0fd018a2011-06-07 17:49:36 -05005388
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11005389 if (mddev_is_clustered(mddev))
5390 md_allow_write(mddev);
5391
Jonathan Brassow0fd018a2011-06-07 17:49:36 -05005392 md_wakeup_thread(mddev->thread);
5393 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
5394
NeilBrownfe60b012010-03-29 11:10:42 +11005395 set_capacity(mddev->gendisk, mddev->array_sectors);
5396 revalidate_disk(mddev->gendisk);
NeilBrownf0b4f7e2011-02-24 17:26:41 +11005397 mddev->changed = 1;
NeilBrownfe60b012010-03-29 11:10:42 +11005398 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
5399out:
5400 return err;
5401}
5402
NeilBrownfd01b882011-10-11 16:47:53 +11005403static int restart_array(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005404{
5405 struct gendisk *disk = mddev->gendisk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005406
Andre Noll80fab1d2008-07-11 22:02:21 +10005407 /* Complain if it has no devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005408 if (list_empty(&mddev->disks))
Andre Noll80fab1d2008-07-11 22:02:21 +10005409 return -ENXIO;
5410 if (!mddev->pers)
5411 return -EINVAL;
5412 if (!mddev->ro)
5413 return -EBUSY;
Song Liu339421d2015-10-08 21:54:13 -07005414 if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {
5415 struct md_rdev *rdev;
5416 bool has_journal = false;
5417
5418 rcu_read_lock();
5419 rdev_for_each_rcu(rdev, mddev) {
5420 if (test_bit(Journal, &rdev->flags) &&
5421 !test_bit(Faulty, &rdev->flags)) {
5422 has_journal = true;
5423 break;
5424 }
5425 }
5426 rcu_read_unlock();
5427
5428 /* Don't restart rw with journal missing/faulty */
5429 if (!has_journal)
5430 return -EINVAL;
5431 }
5432
Andre Noll80fab1d2008-07-11 22:02:21 +10005433 mddev->safemode = 0;
5434 mddev->ro = 0;
5435 set_disk_ro(disk, 0);
5436 printk(KERN_INFO "md: %s switched to read-write mode.\n",
5437 mdname(mddev));
5438 /* Kick recovery or resync if necessary */
5439 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5440 md_wakeup_thread(mddev->thread);
5441 md_wakeup_thread(mddev->sync_thread);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005442 sysfs_notify_dirent_safe(mddev->sysfs_state);
Andre Noll80fab1d2008-07-11 22:02:21 +10005443 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005444}
5445
NeilBrownfd01b882011-10-11 16:47:53 +11005446static void md_clean(struct mddev *mddev)
NeilBrown6177b472010-03-29 11:37:13 +11005447{
5448 mddev->array_sectors = 0;
5449 mddev->external_size = 0;
5450 mddev->dev_sectors = 0;
5451 mddev->raid_disks = 0;
5452 mddev->recovery_cp = 0;
5453 mddev->resync_min = 0;
5454 mddev->resync_max = MaxSector;
5455 mddev->reshape_position = MaxSector;
5456 mddev->external = 0;
5457 mddev->persistent = 0;
5458 mddev->level = LEVEL_NONE;
5459 mddev->clevel[0] = 0;
5460 mddev->flags = 0;
5461 mddev->ro = 0;
5462 mddev->metadata_type[0] = 0;
5463 mddev->chunk_sectors = 0;
5464 mddev->ctime = mddev->utime = 0;
5465 mddev->layout = 0;
5466 mddev->max_disks = 0;
5467 mddev->events = 0;
NeilBrowna8707c02010-05-18 09:28:43 +10005468 mddev->can_decrease_events = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005469 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10005470 mddev->reshape_backwards = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005471 mddev->new_level = LEVEL_NONE;
5472 mddev->new_layout = 0;
5473 mddev->new_chunk_sectors = 0;
5474 mddev->curr_resync = 0;
Jianpeng Ma7f7583d2012-10-11 14:17:59 +11005475 atomic64_set(&mddev->resync_mismatches, 0);
NeilBrown6177b472010-03-29 11:37:13 +11005476 mddev->suspend_lo = mddev->suspend_hi = 0;
5477 mddev->sync_speed_min = mddev->sync_speed_max = 0;
5478 mddev->recovery = 0;
5479 mddev->in_sync = 0;
NeilBrownf0b4f7e2011-02-24 17:26:41 +11005480 mddev->changed = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005481 mddev->degraded = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005482 mddev->safemode = 0;
NeilBrownbd691922015-06-25 17:01:40 +10005483 mddev->private = NULL;
Guoqing Jiangc20c33f2016-08-12 13:42:38 +08005484 mddev->cluster_info = NULL;
NeilBrown6177b472010-03-29 11:37:13 +11005485 mddev->bitmap_info.offset = 0;
5486 mddev->bitmap_info.default_offset = 0;
NeilBrown6409bb02012-05-22 13:55:07 +10005487 mddev->bitmap_info.default_space = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005488 mddev->bitmap_info.chunksize = 0;
5489 mddev->bitmap_info.daemon_sleep = 0;
5490 mddev->bitmap_info.max_write_behind = 0;
Guoqing Jiangc20c33f2016-08-12 13:42:38 +08005491 mddev->bitmap_info.nodes = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005492}
5493
NeilBrownfd01b882011-10-11 16:47:53 +11005494static void __md_stop_writes(struct mddev *mddev)
NeilBrowna047e122010-03-29 12:07:53 +11005495{
NeilBrown6b6204e2013-05-09 09:48:30 +10005496 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11005497 flush_workqueue(md_misc_wq);
NeilBrowna047e122010-03-29 12:07:53 +11005498 if (mddev->sync_thread) {
NeilBrowna047e122010-03-29 12:07:53 +11005499 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10005500 md_reap_sync_thread(mddev);
NeilBrowna047e122010-03-29 12:07:53 +11005501 }
5502
5503 del_timer_sync(&mddev->safemode_timer);
5504
5505 bitmap_flush(mddev);
5506 md_super_wait(mddev);
5507
NeilBrownb6d428c2013-04-24 11:42:42 +10005508 if (mddev->ro == 0 &&
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11005509 ((!mddev->in_sync && !mddev_is_clustered(mddev)) ||
5510 (mddev->flags & MD_UPDATE_SB_FLAGS))) {
NeilBrowna047e122010-03-29 12:07:53 +11005511 /* mark array as shutdown cleanly */
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11005512 if (!mddev_is_clustered(mddev))
5513 mddev->in_sync = 1;
NeilBrowna047e122010-03-29 12:07:53 +11005514 md_update_sb(mddev, 1);
5515 }
5516}
NeilBrowndefad612011-01-14 09:14:33 +11005517
NeilBrownfd01b882011-10-11 16:47:53 +11005518void md_stop_writes(struct mddev *mddev)
NeilBrowndefad612011-01-14 09:14:33 +11005519{
NeilBrown29f097c2013-11-14 17:54:51 +11005520 mddev_lock_nointr(mddev);
NeilBrowndefad612011-01-14 09:14:33 +11005521 __md_stop_writes(mddev);
5522 mddev_unlock(mddev);
5523}
NeilBrown390ee602010-06-01 19:37:27 +10005524EXPORT_SYMBOL_GPL(md_stop_writes);
NeilBrowna047e122010-03-29 12:07:53 +11005525
NeilBrown5aa61f42014-12-15 12:56:57 +11005526static void mddev_detach(struct mddev *mddev)
5527{
5528 struct bitmap *bitmap = mddev->bitmap;
5529 /* wait for behind writes to complete */
5530 if (bitmap && atomic_read(&bitmap->behind_writes) > 0) {
5531 printk(KERN_INFO "md:%s: behind writes in progress - waiting to stop.\n",
5532 mdname(mddev));
5533 /* need to kick something here to make sure I/O goes? */
5534 wait_event(bitmap->behind_wait,
5535 atomic_read(&bitmap->behind_writes) == 0);
5536 }
NeilBrown36d091f2014-12-15 12:56:58 +11005537 if (mddev->pers && mddev->pers->quiesce) {
NeilBrown5aa61f42014-12-15 12:56:57 +11005538 mddev->pers->quiesce(mddev, 1);
5539 mddev->pers->quiesce(mddev, 0);
5540 }
5541 md_unregister_thread(&mddev->thread);
5542 if (mddev->queue)
5543 blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
5544}
5545
NeilBrown5eff3c42012-11-19 10:47:48 +11005546static void __md_stop(struct mddev *mddev)
NeilBrown6177b472010-03-29 11:37:13 +11005547{
NeilBrown36d091f2014-12-15 12:56:58 +11005548 struct md_personality *pers = mddev->pers;
NeilBrown5aa61f42014-12-15 12:56:57 +11005549 mddev_detach(mddev);
NeilBrownee5d0042015-07-22 10:20:07 +10005550 /* Ensure ->event_work is done */
5551 flush_workqueue(md_misc_wq);
NeilBrown36d091f2014-12-15 12:56:58 +11005552 spin_lock(&mddev->lock);
NeilBrown6177b472010-03-29 11:37:13 +11005553 mddev->pers = NULL;
NeilBrown36d091f2014-12-15 12:56:58 +11005554 spin_unlock(&mddev->lock);
5555 pers->free(mddev, mddev->private);
NeilBrownbd691922015-06-25 17:01:40 +10005556 mddev->private = NULL;
NeilBrown36d091f2014-12-15 12:56:58 +11005557 if (pers->sync_request && mddev->to_remove == NULL)
5558 mddev->to_remove = &md_redundancy_group;
5559 module_put(pers->owner);
NeilBrowncca9cf92010-04-01 12:08:16 +11005560 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown6177b472010-03-29 11:37:13 +11005561}
NeilBrown5eff3c42012-11-19 10:47:48 +11005562
5563void md_stop(struct mddev *mddev)
5564{
5565 /* stop the array and free an attached data structures.
5566 * This is called from dm-raid
5567 */
5568 __md_stop(mddev);
5569 bitmap_destroy(mddev);
5570 if (mddev->bio_set)
5571 bioset_free(mddev->bio_set);
5572}
5573
NeilBrown390ee602010-06-01 19:37:27 +10005574EXPORT_SYMBOL_GPL(md_stop);
NeilBrown6177b472010-03-29 11:37:13 +11005575
NeilBrowna05b7ea02012-07-19 15:59:18 +10005576static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
NeilBrowna4bd82d2010-03-29 13:23:10 +11005577{
5578 int err = 0;
NeilBrown30b8feb2013-11-14 15:16:17 +11005579 int did_freeze = 0;
5580
5581 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
5582 did_freeze = 1;
5583 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5584 md_wakeup_thread(mddev->thread);
5585 }
NeilBrownf851b602014-12-11 10:02:10 +11005586 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown30b8feb2013-11-14 15:16:17 +11005587 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11005588 if (mddev->sync_thread)
NeilBrown30b8feb2013-11-14 15:16:17 +11005589 /* Thread might be blocked waiting for metadata update
5590 * which will now never happen */
5591 wake_up_process(mddev->sync_thread->tsk);
NeilBrownf851b602014-12-11 10:02:10 +11005592
NeilBrown88724bf2015-09-24 14:00:51 +10005593 if (mddev->external && test_bit(MD_CHANGE_PENDING, &mddev->flags))
5594 return -EBUSY;
NeilBrown30b8feb2013-11-14 15:16:17 +11005595 mddev_unlock(mddev);
NeilBrownf851b602014-12-11 10:02:10 +11005596 wait_event(resync_wait, !test_bit(MD_RECOVERY_RUNNING,
5597 &mddev->recovery));
NeilBrown88724bf2015-09-24 14:00:51 +10005598 wait_event(mddev->sb_wait,
5599 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
NeilBrown30b8feb2013-11-14 15:16:17 +11005600 mddev_lock_nointr(mddev);
5601
NeilBrowna4bd82d2010-03-29 13:23:10 +11005602 mutex_lock(&mddev->open_mutex);
NeilBrown9ba3b7f2014-09-09 14:00:15 +10005603 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
NeilBrown30b8feb2013-11-14 15:16:17 +11005604 mddev->sync_thread ||
Guoqing Jiangaf8d8e62016-08-12 13:42:37 +08005605 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
NeilBrowna4bd82d2010-03-29 13:23:10 +11005606 printk("md: %s still in use.\n",mdname(mddev));
NeilBrown30b8feb2013-11-14 15:16:17 +11005607 if (did_freeze) {
5608 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown45eaf452014-10-29 08:49:50 +11005609 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown30b8feb2013-11-14 15:16:17 +11005610 md_wakeup_thread(mddev->thread);
5611 }
NeilBrowna4bd82d2010-03-29 13:23:10 +11005612 err = -EBUSY;
5613 goto out;
5614 }
5615 if (mddev->pers) {
NeilBrowndefad612011-01-14 09:14:33 +11005616 __md_stop_writes(mddev);
NeilBrowna4bd82d2010-03-29 13:23:10 +11005617
5618 err = -ENXIO;
5619 if (mddev->ro==1)
5620 goto out;
5621 mddev->ro = 1;
5622 set_disk_ro(mddev->gendisk, 1);
5623 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown45eaf452014-10-29 08:49:50 +11005624 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5625 md_wakeup_thread(mddev->thread);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005626 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown30b8feb2013-11-14 15:16:17 +11005627 err = 0;
NeilBrowna4bd82d2010-03-29 13:23:10 +11005628 }
5629out:
5630 mutex_unlock(&mddev->open_mutex);
5631 return err;
5632}
5633
NeilBrown9e653b62006-06-26 00:27:58 -07005634/* mode:
5635 * 0 - completely stop and dis-assemble array
NeilBrown9e653b62006-06-26 00:27:58 -07005636 * 2 - stop but do not disassemble array
5637 */
NeilBrownf72ffdd2014-09-30 14:23:59 +10005638static int do_md_stop(struct mddev *mddev, int mode,
NeilBrowna05b7ea02012-07-19 15:59:18 +10005639 struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005640{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005641 struct gendisk *disk = mddev->gendisk;
NeilBrown3cb03002011-10-11 16:45:26 +11005642 struct md_rdev *rdev;
NeilBrown30b8feb2013-11-14 15:16:17 +11005643 int did_freeze = 0;
5644
5645 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
5646 did_freeze = 1;
5647 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5648 md_wakeup_thread(mddev->thread);
5649 }
NeilBrownf851b602014-12-11 10:02:10 +11005650 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown30b8feb2013-11-14 15:16:17 +11005651 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11005652 if (mddev->sync_thread)
NeilBrown30b8feb2013-11-14 15:16:17 +11005653 /* Thread might be blocked waiting for metadata update
5654 * which will now never happen */
5655 wake_up_process(mddev->sync_thread->tsk);
NeilBrownf851b602014-12-11 10:02:10 +11005656
NeilBrown30b8feb2013-11-14 15:16:17 +11005657 mddev_unlock(mddev);
NeilBrownf851b602014-12-11 10:02:10 +11005658 wait_event(resync_wait, (mddev->sync_thread == NULL &&
5659 !test_bit(MD_RECOVERY_RUNNING,
5660 &mddev->recovery)));
NeilBrown30b8feb2013-11-14 15:16:17 +11005661 mddev_lock_nointr(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005662
NeilBrownc8c00a62009-08-10 12:50:52 +10005663 mutex_lock(&mddev->open_mutex);
NeilBrown9ba3b7f2014-09-09 14:00:15 +10005664 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
NeilBrown30b8feb2013-11-14 15:16:17 +11005665 mddev->sysfs_active ||
5666 mddev->sync_thread ||
Guoqing Jiangaf8d8e62016-08-12 13:42:37 +08005667 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
Neil Browndf5b20c2008-07-11 22:02:22 +10005668 printk("md: %s still in use.\n",mdname(mddev));
NeilBrown6e17b022010-08-07 21:41:19 +10005669 mutex_unlock(&mddev->open_mutex);
NeilBrown30b8feb2013-11-14 15:16:17 +11005670 if (did_freeze) {
5671 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown45eaf452014-10-29 08:49:50 +11005672 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown30b8feb2013-11-14 15:16:17 +11005673 md_wakeup_thread(mddev->thread);
5674 }
NeilBrown260fa032013-08-27 16:44:13 +10005675 return -EBUSY;
5676 }
NeilBrown6e17b022010-08-07 21:41:19 +10005677 if (mddev->pers) {
NeilBrowna4bd82d2010-03-29 13:23:10 +11005678 if (mddev->ro)
5679 set_disk_ro(disk, 0);
NeilBrown409c57f2009-03-31 14:39:39 +11005680
NeilBrowndefad612011-01-14 09:14:33 +11005681 __md_stop_writes(mddev);
NeilBrown5eff3c42012-11-19 10:47:48 +11005682 __md_stop(mddev);
Jan Kara1cdb7f92017-02-02 15:56:50 +01005683 mddev->queue->backing_dev_info->congested_fn = NULL;
NeilBrown6177b472010-03-29 11:37:13 +11005684
NeilBrowna4bd82d2010-03-29 13:23:10 +11005685 /* tell userspace to handle 'inactive' */
NeilBrown00bcb4a2010-06-01 19:37:23 +10005686 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown0d4ca602006-12-10 02:20:44 -08005687
NeilBrowndafb20f2012-03-19 12:46:39 +11005688 rdev_for_each(rdev, mddev)
Namhyung Kim36fad852011-07-27 11:00:36 +10005689 if (rdev->raid_disk >= 0)
5690 sysfs_unlink_rdev(mddev, rdev);
NeilBrownc4647292009-05-07 12:51:06 +10005691
NeilBrowna4bd82d2010-03-29 13:23:10 +11005692 set_capacity(disk, 0);
NeilBrown6e17b022010-08-07 21:41:19 +10005693 mutex_unlock(&mddev->open_mutex);
NeilBrownf0b4f7e2011-02-24 17:26:41 +11005694 mddev->changed = 1;
NeilBrowna4bd82d2010-03-29 13:23:10 +11005695 revalidate_disk(disk);
NeilBrown0d4ca602006-12-10 02:20:44 -08005696
NeilBrowna4bd82d2010-03-29 13:23:10 +11005697 if (mddev->ro)
5698 mddev->ro = 0;
NeilBrown6e17b022010-08-07 21:41:19 +10005699 } else
5700 mutex_unlock(&mddev->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005701 /*
5702 * Free resources if final stop
5703 */
NeilBrown9e653b62006-06-26 00:27:58 -07005704 if (mode == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005705 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
5706
NeilBrown978f9462006-02-02 14:28:05 -08005707 bitmap_destroy(mddev);
NeilBrownc3d97142009-12-14 12:49:52 +11005708 if (mddev->bitmap_info.file) {
NeilBrown4af1a042014-12-15 12:57:00 +11005709 struct file *f = mddev->bitmap_info.file;
5710 spin_lock(&mddev->lock);
NeilBrownc3d97142009-12-14 12:49:52 +11005711 mddev->bitmap_info.file = NULL;
NeilBrown4af1a042014-12-15 12:57:00 +11005712 spin_unlock(&mddev->lock);
5713 fput(f);
NeilBrown978f9462006-02-02 14:28:05 -08005714 }
NeilBrownc3d97142009-12-14 12:49:52 +11005715 mddev->bitmap_info.offset = 0;
NeilBrown978f9462006-02-02 14:28:05 -08005716
Linus Torvalds1da177e2005-04-16 15:20:36 -07005717 export_array(mddev);
5718
NeilBrown6177b472010-03-29 11:37:13 +11005719 md_clean(mddev);
NeilBrownefeb53c2009-01-09 08:31:10 +11005720 if (mddev->hold_active == UNTIL_STOP)
5721 mddev->hold_active = 0;
NeilBrowna4bd82d2010-03-29 13:23:10 +11005722 }
NeilBrownd7603b72006-01-06 00:20:30 -08005723 md_new_event(mddev);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005724 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown6e17b022010-08-07 21:41:19 +10005725 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005726}
5727
Jeff Garzikfdee8ae2006-12-10 02:20:50 -08005728#ifndef MODULE
NeilBrownfd01b882011-10-11 16:47:53 +11005729static void autorun_array(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005730{
NeilBrown3cb03002011-10-11 16:45:26 +11005731 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005732 int err;
5733
NeilBrowna757e642005-04-16 15:26:42 -07005734 if (list_empty(&mddev->disks))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005735 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005736
5737 printk(KERN_INFO "md: running: ");
5738
NeilBrowndafb20f2012-03-19 12:46:39 +11005739 rdev_for_each(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005740 char b[BDEVNAME_SIZE];
5741 printk("<%s>", bdevname(rdev->bdev,b));
5742 }
5743 printk("\n");
5744
NeilBrownd710e132008-10-13 11:55:12 +11005745 err = do_md_run(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005746 if (err) {
5747 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
NeilBrowna05b7ea02012-07-19 15:59:18 +10005748 do_md_stop(mddev, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005749 }
5750}
5751
5752/*
5753 * lets try to run arrays based on all disks that have arrived
5754 * until now. (those are in pending_raid_disks)
5755 *
5756 * the method: pick the first pending disk, collect all disks with
5757 * the same UUID, remove all from the pending list and put them into
5758 * the 'same_array' list. Then order this list based on superblock
5759 * update time (freshest comes first), kick out 'old' disks and
5760 * compare superblocks. If everything's fine then run it.
5761 *
5762 * If "unit" is allocated, then bump its reference count
5763 */
5764static void autorun_devices(int part)
5765{
NeilBrown3cb03002011-10-11 16:45:26 +11005766 struct md_rdev *rdev0, *rdev, *tmp;
NeilBrownfd01b882011-10-11 16:47:53 +11005767 struct mddev *mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005768 char b[BDEVNAME_SIZE];
5769
5770 printk(KERN_INFO "md: autorun ...\n");
5771 while (!list_empty(&pending_raid_disks)) {
NeilBrowne8703fe2006-10-03 01:15:59 -07005772 int unit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005773 dev_t dev;
NeilBrownad01c9e2006-03-27 01:18:07 -08005774 LIST_HEAD(candidates);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005775 rdev0 = list_entry(pending_raid_disks.next,
NeilBrown3cb03002011-10-11 16:45:26 +11005776 struct md_rdev, same_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005777
5778 printk(KERN_INFO "md: considering %s ...\n",
5779 bdevname(rdev0->bdev,b));
5780 INIT_LIST_HEAD(&candidates);
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005781 rdev_for_each_list(rdev, tmp, &pending_raid_disks)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005782 if (super_90_load(rdev, rdev0, 0) >= 0) {
5783 printk(KERN_INFO "md: adding %s ...\n",
5784 bdevname(rdev->bdev,b));
5785 list_move(&rdev->same_set, &candidates);
5786 }
5787 /*
5788 * now we have a set of devices, with all of them having
5789 * mostly sane superblocks. It's time to allocate the
5790 * mddev.
5791 */
NeilBrowne8703fe2006-10-03 01:15:59 -07005792 if (part) {
5793 dev = MKDEV(mdp_major,
5794 rdev0->preferred_minor << MdpMinorShift);
5795 unit = MINOR(dev) >> MdpMinorShift;
5796 } else {
5797 dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
5798 unit = MINOR(dev);
5799 }
5800 if (rdev0->preferred_minor != unit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005801 printk(KERN_INFO "md: unit number in %s is bad: %d\n",
5802 bdevname(rdev0->bdev, b), rdev0->preferred_minor);
5803 break;
5804 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005805
5806 md_probe(dev, NULL, NULL);
5807 mddev = mddev_find(dev);
Neil Brown9bbbca32008-06-28 08:31:17 +10005808 if (!mddev || !mddev->gendisk) {
5809 if (mddev)
5810 mddev_put(mddev);
5811 printk(KERN_ERR
Linus Torvalds1da177e2005-04-16 15:20:36 -07005812 "md: cannot allocate memory for md drive.\n");
5813 break;
5814 }
NeilBrownf72ffdd2014-09-30 14:23:59 +10005815 if (mddev_lock(mddev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005816 printk(KERN_WARNING "md: %s locked, cannot run\n",
5817 mdname(mddev));
5818 else if (mddev->raid_disks || mddev->major_version
5819 || !list_empty(&mddev->disks)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005820 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005821 "md: %s already running, cannot run %s\n",
5822 mdname(mddev), bdevname(rdev0->bdev,b));
5823 mddev_unlock(mddev);
5824 } else {
5825 printk(KERN_INFO "md: created %s\n", mdname(mddev));
NeilBrown1ec4a932008-02-06 01:39:53 -08005826 mddev->persistent = 1;
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005827 rdev_for_each_list(rdev, tmp, &candidates) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005828 list_del_init(&rdev->same_set);
5829 if (bind_rdev_to_array(rdev, mddev))
5830 export_rdev(rdev);
5831 }
5832 autorun_array(mddev);
5833 mddev_unlock(mddev);
5834 }
5835 /* on success, candidates will be empty, on error
5836 * it won't...
5837 */
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005838 rdev_for_each_list(rdev, tmp, &candidates) {
NeilBrown4b809912008-07-21 17:05:25 +10005839 list_del_init(&rdev->same_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005840 export_rdev(rdev);
NeilBrown4b809912008-07-21 17:05:25 +10005841 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005842 mddev_put(mddev);
5843 }
5844 printk(KERN_INFO "md: ... autorun DONE.\n");
5845}
Jeff Garzikfdee8ae2006-12-10 02:20:50 -08005846#endif /* !MODULE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005847
NeilBrownf72ffdd2014-09-30 14:23:59 +10005848static int get_version(void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005849{
5850 mdu_version_t ver;
5851
5852 ver.major = MD_MAJOR_VERSION;
5853 ver.minor = MD_MINOR_VERSION;
5854 ver.patchlevel = MD_PATCHLEVEL_VERSION;
5855
5856 if (copy_to_user(arg, &ver, sizeof(ver)))
5857 return -EFAULT;
5858
5859 return 0;
5860}
5861
NeilBrownf72ffdd2014-09-30 14:23:59 +10005862static int get_array_info(struct mddev *mddev, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005863{
5864 mdu_array_info_t info;
NeilBrowna9f326e2009-09-23 18:06:41 +10005865 int nr,working,insync,failed,spare;
NeilBrown3cb03002011-10-11 16:45:26 +11005866 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005867
NeilBrown1ca69c42012-10-11 13:37:33 +11005868 nr = working = insync = failed = spare = 0;
5869 rcu_read_lock();
5870 rdev_for_each_rcu(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005871 nr++;
NeilBrownb2d444d2005-11-08 21:39:31 -08005872 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005873 failed++;
5874 else {
5875 working++;
NeilBrownb2d444d2005-11-08 21:39:31 -08005876 if (test_bit(In_sync, &rdev->flags))
NeilBrownf72ffdd2014-09-30 14:23:59 +10005877 insync++;
Song Liub347af82016-08-11 17:14:45 -07005878 else if (test_bit(Journal, &rdev->flags))
5879 /* TODO: add journal count to md_u.h */
5880 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005881 else
5882 spare++;
5883 }
5884 }
NeilBrown1ca69c42012-10-11 13:37:33 +11005885 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005886
5887 info.major_version = mddev->major_version;
5888 info.minor_version = mddev->minor_version;
5889 info.patch_version = MD_PATCHLEVEL_VERSION;
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11005890 info.ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005891 info.level = mddev->level;
Andre Noll58c0fed2009-03-31 14:33:13 +11005892 info.size = mddev->dev_sectors / 2;
5893 if (info.size != mddev->dev_sectors / 2) /* overflow */
NeilBrown284ae7c2006-02-03 03:03:40 -08005894 info.size = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005895 info.nr_disks = nr;
5896 info.raid_disks = mddev->raid_disks;
5897 info.md_minor = mddev->md_minor;
5898 info.not_persistent= !mddev->persistent;
5899
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11005900 info.utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005901 info.state = 0;
5902 if (mddev->in_sync)
5903 info.state = (1<<MD_SB_CLEAN);
NeilBrownc3d97142009-12-14 12:49:52 +11005904 if (mddev->bitmap && mddev->bitmap_info.offset)
NeilBrown9bd35922014-07-02 11:35:06 +10005905 info.state |= (1<<MD_SB_BITMAP_PRESENT);
Goldwyn Rodriguesca8895d2014-11-26 12:22:03 -06005906 if (mddev_is_clustered(mddev))
5907 info.state |= (1<<MD_SB_CLUSTERED);
NeilBrowna9f326e2009-09-23 18:06:41 +10005908 info.active_disks = insync;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005909 info.working_disks = working;
5910 info.failed_disks = failed;
5911 info.spare_disks = spare;
5912
5913 info.layout = mddev->layout;
Andre Noll9d8f0362009-06-18 08:45:01 +10005914 info.chunk_size = mddev->chunk_sectors << 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005915
5916 if (copy_to_user(arg, &info, sizeof(info)))
5917 return -EFAULT;
5918
5919 return 0;
5920}
5921
NeilBrownf72ffdd2014-09-30 14:23:59 +10005922static int get_bitmap_file(struct mddev *mddev, void __user * arg)
NeilBrown32a76272005-06-21 17:17:14 -07005923{
5924 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
NeilBrownf4ad3d32014-12-15 12:57:00 +11005925 char *ptr;
NeilBrown4af1a042014-12-15 12:57:00 +11005926 int err;
NeilBrown32a76272005-06-21 17:17:14 -07005927
Benjamin Randazzob6878d92015-07-25 16:36:50 +02005928 file = kzalloc(sizeof(*file), GFP_NOIO);
NeilBrown32a76272005-06-21 17:17:14 -07005929 if (!file)
NeilBrown4af1a042014-12-15 12:57:00 +11005930 return -ENOMEM;
NeilBrown32a76272005-06-21 17:17:14 -07005931
NeilBrown32a76272005-06-21 17:17:14 -07005932 err = 0;
NeilBrown4af1a042014-12-15 12:57:00 +11005933 spin_lock(&mddev->lock);
Benjamin Randazzo25eafe12015-07-25 16:36:50 +02005934 /* bitmap enabled */
5935 if (mddev->bitmap_info.file) {
5936 ptr = file_path(mddev->bitmap_info.file, file->pathname,
5937 sizeof(file->pathname));
5938 if (IS_ERR(ptr))
5939 err = PTR_ERR(ptr);
5940 else
5941 memmove(file->pathname, ptr,
5942 sizeof(file->pathname)-(ptr-file->pathname));
5943 }
NeilBrown4af1a042014-12-15 12:57:00 +11005944 spin_unlock(&mddev->lock);
5945
5946 if (err == 0 &&
5947 copy_to_user(arg, file, sizeof(*file)))
NeilBrown32a76272005-06-21 17:17:14 -07005948 err = -EFAULT;
NeilBrown4af1a042014-12-15 12:57:00 +11005949
NeilBrown32a76272005-06-21 17:17:14 -07005950 kfree(file);
5951 return err;
5952}
5953
NeilBrownf72ffdd2014-09-30 14:23:59 +10005954static int get_disk_info(struct mddev *mddev, void __user * arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005955{
5956 mdu_disk_info_t info;
NeilBrown3cb03002011-10-11 16:45:26 +11005957 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005958
5959 if (copy_from_user(&info, arg, sizeof(info)))
5960 return -EFAULT;
5961
NeilBrown1ca69c42012-10-11 13:37:33 +11005962 rcu_read_lock();
Goldwyn Rodrigues57d051d2015-04-14 10:43:55 -05005963 rdev = md_find_rdev_nr_rcu(mddev, info.number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005964 if (rdev) {
5965 info.major = MAJOR(rdev->bdev->bd_dev);
5966 info.minor = MINOR(rdev->bdev->bd_dev);
5967 info.raid_disk = rdev->raid_disk;
5968 info.state = 0;
NeilBrownb2d444d2005-11-08 21:39:31 -08005969 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005970 info.state |= (1<<MD_DISK_FAULTY);
NeilBrownb2d444d2005-11-08 21:39:31 -08005971 else if (test_bit(In_sync, &rdev->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005972 info.state |= (1<<MD_DISK_ACTIVE);
5973 info.state |= (1<<MD_DISK_SYNC);
5974 }
Shaohua Li9efdca12015-10-12 16:59:50 -07005975 if (test_bit(Journal, &rdev->flags))
Song Liubac624f2015-08-13 14:31:55 -07005976 info.state |= (1<<MD_DISK_JOURNAL);
NeilBrown8ddf9ef2005-09-09 16:23:45 -07005977 if (test_bit(WriteMostly, &rdev->flags))
5978 info.state |= (1<<MD_DISK_WRITEMOSTLY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005979 } else {
5980 info.major = info.minor = 0;
5981 info.raid_disk = -1;
5982 info.state = (1<<MD_DISK_REMOVED);
5983 }
NeilBrown1ca69c42012-10-11 13:37:33 +11005984 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005985
5986 if (copy_to_user(arg, &info, sizeof(info)))
5987 return -EFAULT;
5988
5989 return 0;
5990}
5991
NeilBrownf72ffdd2014-09-30 14:23:59 +10005992static int add_new_disk(struct mddev *mddev, mdu_disk_info_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005993{
5994 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
NeilBrown3cb03002011-10-11 16:45:26 +11005995 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005996 dev_t dev = MKDEV(info->major,info->minor);
5997
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05005998 if (mddev_is_clustered(mddev) &&
5999 !(info->state & ((1 << MD_DISK_CLUSTER_ADD) | (1 << MD_DISK_CANDIDATE)))) {
Goldwyn Rodriguesfa8259d2015-03-02 10:55:49 -06006000 pr_err("%s: Cannot add to clustered mddev.\n",
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006001 mdname(mddev));
6002 return -EINVAL;
6003 }
6004
Linus Torvalds1da177e2005-04-16 15:20:36 -07006005 if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
6006 return -EOVERFLOW;
6007
6008 if (!mddev->raid_disks) {
6009 int err;
6010 /* expecting a device which has a superblock */
6011 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
6012 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006013 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006014 "md: md_import_device returned %ld\n",
6015 PTR_ERR(rdev));
6016 return PTR_ERR(rdev);
6017 }
6018 if (!list_empty(&mddev->disks)) {
NeilBrown3cb03002011-10-11 16:45:26 +11006019 struct md_rdev *rdev0
6020 = list_entry(mddev->disks.next,
6021 struct md_rdev, same_set);
NeilBrowna9f326e2009-09-23 18:06:41 +10006022 err = super_types[mddev->major_version]
Linus Torvalds1da177e2005-04-16 15:20:36 -07006023 .load_super(rdev, rdev0, mddev->minor_version);
6024 if (err < 0) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006025 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006026 "md: %s has different UUID to %s\n",
NeilBrownf72ffdd2014-09-30 14:23:59 +10006027 bdevname(rdev->bdev,b),
Linus Torvalds1da177e2005-04-16 15:20:36 -07006028 bdevname(rdev0->bdev,b2));
6029 export_rdev(rdev);
6030 return -EINVAL;
6031 }
6032 }
6033 err = bind_rdev_to_array(rdev, mddev);
6034 if (err)
6035 export_rdev(rdev);
6036 return err;
6037 }
6038
6039 /*
6040 * add_new_disk can be used once the array is assembled
6041 * to add "hot spares". They must already have a superblock
6042 * written
6043 */
6044 if (mddev->pers) {
6045 int err;
6046 if (!mddev->pers->hot_add_disk) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006047 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006048 "%s: personality does not support diskops!\n",
6049 mdname(mddev));
6050 return -EINVAL;
6051 }
NeilBrown7b1e35f2005-09-09 16:23:50 -07006052 if (mddev->persistent)
6053 rdev = md_import_device(dev, mddev->major_version,
6054 mddev->minor_version);
6055 else
6056 rdev = md_import_device(dev, -1, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006057 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006058 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006059 "md: md_import_device returned %ld\n",
6060 PTR_ERR(rdev));
6061 return PTR_ERR(rdev);
6062 }
NeilBrown1a855a02010-12-09 16:36:28 +11006063 /* set saved_raid_disk if appropriate */
NeilBrown41158c72005-06-21 17:17:25 -07006064 if (!mddev->persistent) {
6065 if (info->state & (1<<MD_DISK_SYNC) &&
NeilBrownbf572542011-01-12 09:03:35 +11006066 info->raid_disk < mddev->raid_disks) {
NeilBrown41158c72005-06-21 17:17:25 -07006067 rdev->raid_disk = info->raid_disk;
NeilBrownbf572542011-01-12 09:03:35 +11006068 set_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11006069 clear_bit(Bitmap_sync, &rdev->flags);
NeilBrownbf572542011-01-12 09:03:35 +11006070 } else
NeilBrown41158c72005-06-21 17:17:25 -07006071 rdev->raid_disk = -1;
NeilBrownf4667222013-12-09 12:04:56 +11006072 rdev->saved_raid_disk = rdev->raid_disk;
NeilBrown41158c72005-06-21 17:17:25 -07006073 } else
6074 super_types[mddev->major_version].
6075 validate_super(mddev, rdev);
NeilBrownbedd86b2011-05-11 14:26:20 +10006076 if ((info->state & (1<<MD_DISK_SYNC)) &&
NeilBrownf4563092012-07-03 15:59:06 +10006077 rdev->raid_disk != info->raid_disk) {
NeilBrownbedd86b2011-05-11 14:26:20 +10006078 /* This was a hot-add request, but events doesn't
6079 * match, so reject it.
6080 */
6081 export_rdev(rdev);
6082 return -EINVAL;
6083 }
6084
NeilBrownb2d444d2005-11-08 21:39:31 -08006085 clear_bit(In_sync, &rdev->flags); /* just to be sure */
NeilBrown8ddf9ef2005-09-09 16:23:45 -07006086 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
6087 set_bit(WriteMostly, &rdev->flags);
NeilBrown575a80f2009-03-31 14:33:13 +11006088 else
6089 clear_bit(WriteMostly, &rdev->flags);
NeilBrown8ddf9ef2005-09-09 16:23:45 -07006090
Shaohua Lif6b6ec52015-12-21 10:51:02 +11006091 if (info->state & (1<<MD_DISK_JOURNAL)) {
6092 struct md_rdev *rdev2;
6093 bool has_journal = false;
6094
6095 /* make sure no existing journal disk */
6096 rdev_for_each(rdev2, mddev) {
6097 if (test_bit(Journal, &rdev2->flags)) {
6098 has_journal = true;
6099 break;
6100 }
6101 }
6102 if (has_journal) {
6103 export_rdev(rdev);
6104 return -EBUSY;
6105 }
Song Liubac624f2015-08-13 14:31:55 -07006106 set_bit(Journal, &rdev->flags);
Shaohua Lif6b6ec52015-12-21 10:51:02 +11006107 }
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006108 /*
6109 * check whether the device shows up in other nodes
6110 */
6111 if (mddev_is_clustered(mddev)) {
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006112 if (info->state & (1 << MD_DISK_CANDIDATE))
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006113 set_bit(Candidate, &rdev->flags);
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006114 else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) {
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006115 /* --add initiated by this node */
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006116 err = md_cluster_ops->add_new_disk(mddev, rdev);
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006117 if (err) {
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006118 export_rdev(rdev);
6119 return err;
6120 }
6121 }
6122 }
6123
Linus Torvalds1da177e2005-04-16 15:20:36 -07006124 rdev->raid_disk = -1;
6125 err = bind_rdev_to_array(rdev, mddev);
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006126
Linus Torvalds1da177e2005-04-16 15:20:36 -07006127 if (err)
6128 export_rdev(rdev);
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006129
6130 if (mddev_is_clustered(mddev)) {
Guoqing Jiange566aef2016-08-12 13:42:34 +08006131 if (info->state & (1 << MD_DISK_CANDIDATE)) {
6132 if (!err) {
6133 err = md_cluster_ops->new_disk_ack(mddev,
6134 err == 0);
6135 if (err)
6136 md_kick_rdev_from_array(rdev);
6137 }
6138 } else {
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006139 if (err)
6140 md_cluster_ops->add_new_disk_cancel(mddev);
6141 else
6142 err = add_bound_rdev(rdev);
6143 }
6144
6145 } else if (!err)
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05006146 err = add_bound_rdev(rdev);
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006147
Linus Torvalds1da177e2005-04-16 15:20:36 -07006148 return err;
6149 }
6150
6151 /* otherwise, add_new_disk is only allowed
6152 * for major_version==0 superblocks
6153 */
6154 if (mddev->major_version != 0) {
6155 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
6156 mdname(mddev));
6157 return -EINVAL;
6158 }
6159
6160 if (!(info->state & (1<<MD_DISK_FAULTY))) {
6161 int err;
NeilBrownd710e132008-10-13 11:55:12 +11006162 rdev = md_import_device(dev, -1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006163 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006164 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006165 "md: error, md_import_device() returned %ld\n",
6166 PTR_ERR(rdev));
6167 return PTR_ERR(rdev);
6168 }
6169 rdev->desc_nr = info->number;
6170 if (info->raid_disk < mddev->raid_disks)
6171 rdev->raid_disk = info->raid_disk;
6172 else
6173 rdev->raid_disk = -1;
6174
Linus Torvalds1da177e2005-04-16 15:20:36 -07006175 if (rdev->raid_disk < mddev->raid_disks)
NeilBrownb2d444d2005-11-08 21:39:31 -08006176 if (info->state & (1<<MD_DISK_SYNC))
6177 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006178
NeilBrown8ddf9ef2005-09-09 16:23:45 -07006179 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
6180 set_bit(WriteMostly, &rdev->flags);
6181
Linus Torvalds1da177e2005-04-16 15:20:36 -07006182 if (!mddev->persistent) {
6183 printk(KERN_INFO "md: nonpersistent superblock ...\n");
Mike Snitzer77304d22010-11-08 14:39:12 +01006184 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
6185 } else
Jonathan Brassow57b2caa2011-01-14 09:14:33 +11006186 rdev->sb_start = calc_dev_sboffset(rdev);
NeilBrown8190e752009-06-18 08:48:58 +10006187 rdev->sectors = rdev->sb_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006188
NeilBrown2bf071b2006-01-06 00:20:55 -08006189 err = bind_rdev_to_array(rdev, mddev);
6190 if (err) {
6191 export_rdev(rdev);
6192 return err;
6193 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006194 }
6195
6196 return 0;
6197}
6198
NeilBrownf72ffdd2014-09-30 14:23:59 +10006199static int hot_remove_disk(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006200{
6201 char b[BDEVNAME_SIZE];
NeilBrown3cb03002011-10-11 16:45:26 +11006202 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006203
Yufen Yue51f4fc2018-05-04 18:08:10 +08006204 if (!mddev->pers)
6205 return -ENODEV;
6206
Linus Torvalds1da177e2005-04-16 15:20:36 -07006207 rdev = find_rdev(mddev, dev);
6208 if (!rdev)
6209 return -ENXIO;
6210
Goldwyn Rodrigues2910ff12015-09-28 10:27:26 -05006211 if (rdev->raid_disk < 0)
6212 goto kick_rdev;
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006213
NeilBrown3ea8929d2013-04-24 11:42:41 +10006214 clear_bit(Blocked, &rdev->flags);
6215 remove_and_add_spares(mddev, rdev);
6216
Linus Torvalds1da177e2005-04-16 15:20:36 -07006217 if (rdev->raid_disk >= 0)
6218 goto busy;
6219
Goldwyn Rodrigues2910ff12015-09-28 10:27:26 -05006220kick_rdev:
Goldwyn Rodrigues54a88392015-12-21 10:51:00 +11006221 if (mddev_is_clustered(mddev))
Goldwyn Rodrigues88bcfef2015-04-14 10:44:44 -05006222 md_cluster_ops->remove_disk(mddev, rdev);
6223
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05006224 md_kick_rdev_from_array(rdev);
NeilBrown850b2b42006-10-03 01:15:46 -07006225 md_update_sb(mddev, 1);
NeilBrownd7603b72006-01-06 00:20:30 -08006226 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006227
6228 return 0;
6229busy:
Nick Andrewfdefa4d2008-04-21 22:42:58 +00006230 printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07006231 bdevname(rdev->bdev,b), mdname(mddev));
6232 return -EBUSY;
6233}
6234
NeilBrownf72ffdd2014-09-30 14:23:59 +10006235static int hot_add_disk(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006236{
6237 char b[BDEVNAME_SIZE];
6238 int err;
NeilBrown3cb03002011-10-11 16:45:26 +11006239 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006240
6241 if (!mddev->pers)
6242 return -ENODEV;
6243
6244 if (mddev->major_version != 0) {
6245 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
6246 " version-0 superblocks.\n",
6247 mdname(mddev));
6248 return -EINVAL;
6249 }
6250 if (!mddev->pers->hot_add_disk) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006251 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006252 "%s: personality does not support diskops!\n",
6253 mdname(mddev));
6254 return -EINVAL;
6255 }
6256
NeilBrownd710e132008-10-13 11:55:12 +11006257 rdev = md_import_device(dev, -1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006258 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006259 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006260 "md: error, md_import_device() returned %ld\n",
6261 PTR_ERR(rdev));
6262 return -EINVAL;
6263 }
6264
6265 if (mddev->persistent)
Jonathan Brassow57b2caa2011-01-14 09:14:33 +11006266 rdev->sb_start = calc_dev_sboffset(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006267 else
Mike Snitzer77304d22010-11-08 14:39:12 +01006268 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006269
NeilBrown8190e752009-06-18 08:48:58 +10006270 rdev->sectors = rdev->sb_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006271
NeilBrownb2d444d2005-11-08 21:39:31 -08006272 if (test_bit(Faulty, &rdev->flags)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006273 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006274 "md: can not hot-add faulty %s disk to %s!\n",
6275 bdevname(rdev->bdev,b), mdname(mddev));
6276 err = -EINVAL;
6277 goto abort_export;
6278 }
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006279
NeilBrownb2d444d2005-11-08 21:39:31 -08006280 clear_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006281 rdev->desc_nr = -1;
NeilBrown58427302006-10-06 00:44:04 -07006282 rdev->saved_raid_disk = -1;
NeilBrown2bf071b2006-01-06 00:20:55 -08006283 err = bind_rdev_to_array(rdev, mddev);
6284 if (err)
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05006285 goto abort_export;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006286
6287 /*
6288 * The rest should better be atomic, we can have disk failures
6289 * noticed in interrupt contexts ...
6290 */
6291
Linus Torvalds1da177e2005-04-16 15:20:36 -07006292 rdev->raid_disk = -1;
6293
NeilBrown850b2b42006-10-03 01:15:46 -07006294 md_update_sb(mddev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006295 /*
6296 * Kick recovery, maybe this spare has to be added to the
6297 * array immediately.
6298 */
6299 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6300 md_wakeup_thread(mddev->thread);
NeilBrownd7603b72006-01-06 00:20:30 -08006301 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006302 return 0;
6303
Linus Torvalds1da177e2005-04-16 15:20:36 -07006304abort_export:
6305 export_rdev(rdev);
6306 return err;
6307}
6308
NeilBrownfd01b882011-10-11 16:47:53 +11006309static int set_bitmap_file(struct mddev *mddev, int fd)
NeilBrown32a76272005-06-21 17:17:14 -07006310{
NeilBrown035328c2014-04-09 12:25:40 +10006311 int err = 0;
NeilBrown32a76272005-06-21 17:17:14 -07006312
NeilBrown36fa3062005-09-09 16:23:45 -07006313 if (mddev->pers) {
NeilBrownd66b1b32014-08-08 15:40:24 +10006314 if (!mddev->pers->quiesce || !mddev->thread)
NeilBrown36fa3062005-09-09 16:23:45 -07006315 return -EBUSY;
6316 if (mddev->recovery || mddev->sync_thread)
6317 return -EBUSY;
6318 /* we should be able to change the bitmap.. */
NeilBrown32a76272005-06-21 17:17:14 -07006319 }
6320
NeilBrown36fa3062005-09-09 16:23:45 -07006321 if (fd >= 0) {
NeilBrown035328c2014-04-09 12:25:40 +10006322 struct inode *inode;
NeilBrown1e594bb2014-12-15 12:57:00 +11006323 struct file *f;
NeilBrown36fa3062005-09-09 16:23:45 -07006324
NeilBrown1e594bb2014-12-15 12:57:00 +11006325 if (mddev->bitmap || mddev->bitmap_info.file)
6326 return -EEXIST; /* cannot add when bitmap is present */
6327 f = fget(fd);
6328
6329 if (f == NULL) {
NeilBrown36fa3062005-09-09 16:23:45 -07006330 printk(KERN_ERR "%s: error: failed to get bitmap file\n",
6331 mdname(mddev));
6332 return -EBADF;
6333 }
6334
NeilBrown1e594bb2014-12-15 12:57:00 +11006335 inode = f->f_mapping->host;
NeilBrown035328c2014-04-09 12:25:40 +10006336 if (!S_ISREG(inode->i_mode)) {
6337 printk(KERN_ERR "%s: error: bitmap file must be a regular file\n",
6338 mdname(mddev));
6339 err = -EBADF;
NeilBrown1e594bb2014-12-15 12:57:00 +11006340 } else if (!(f->f_mode & FMODE_WRITE)) {
NeilBrown035328c2014-04-09 12:25:40 +10006341 printk(KERN_ERR "%s: error: bitmap file must open for write\n",
6342 mdname(mddev));
6343 err = -EBADF;
6344 } else if (atomic_read(&inode->i_writecount) != 1) {
NeilBrown36fa3062005-09-09 16:23:45 -07006345 printk(KERN_ERR "%s: error: bitmap file is already in use\n",
6346 mdname(mddev));
NeilBrown035328c2014-04-09 12:25:40 +10006347 err = -EBUSY;
6348 }
6349 if (err) {
NeilBrown1e594bb2014-12-15 12:57:00 +11006350 fput(f);
NeilBrown36fa3062005-09-09 16:23:45 -07006351 return err;
6352 }
NeilBrown1e594bb2014-12-15 12:57:00 +11006353 mddev->bitmap_info.file = f;
NeilBrownc3d97142009-12-14 12:49:52 +11006354 mddev->bitmap_info.offset = 0; /* file overrides offset */
NeilBrown36fa3062005-09-09 16:23:45 -07006355 } else if (mddev->bitmap == NULL)
6356 return -ENOENT; /* cannot remove what isn't there */
6357 err = 0;
6358 if (mddev->pers) {
6359 mddev->pers->quiesce(mddev, 1);
NeilBrown69e51b42010-06-01 19:37:35 +10006360 if (fd >= 0) {
Goldwyn Rodriguesf9209a32014-06-06 12:43:49 -05006361 struct bitmap *bitmap;
6362
6363 bitmap = bitmap_create(mddev, -1);
6364 if (!IS_ERR(bitmap)) {
6365 mddev->bitmap = bitmap;
NeilBrown69e51b42010-06-01 19:37:35 +10006366 err = bitmap_load(mddev);
NeilBrownba599ac2015-02-25 11:44:11 +11006367 } else
6368 err = PTR_ERR(bitmap);
NeilBrown69e51b42010-06-01 19:37:35 +10006369 }
NeilBrownd7375ab2006-06-26 00:27:43 -07006370 if (fd < 0 || err) {
NeilBrown36fa3062005-09-09 16:23:45 -07006371 bitmap_destroy(mddev);
NeilBrownd7375ab2006-06-26 00:27:43 -07006372 fd = -1; /* make sure to put the file */
6373 }
NeilBrown36fa3062005-09-09 16:23:45 -07006374 mddev->pers->quiesce(mddev, 0);
NeilBrownd7375ab2006-06-26 00:27:43 -07006375 }
6376 if (fd < 0) {
NeilBrown4af1a042014-12-15 12:57:00 +11006377 struct file *f = mddev->bitmap_info.file;
6378 if (f) {
6379 spin_lock(&mddev->lock);
6380 mddev->bitmap_info.file = NULL;
6381 spin_unlock(&mddev->lock);
6382 fput(f);
6383 }
NeilBrown36fa3062005-09-09 16:23:45 -07006384 }
6385
NeilBrown32a76272005-06-21 17:17:14 -07006386 return err;
6387}
6388
Linus Torvalds1da177e2005-04-16 15:20:36 -07006389/*
6390 * set_array_info is used two different ways
6391 * The original usage is when creating a new array.
6392 * In this usage, raid_disks is > 0 and it together with
6393 * level, size, not_persistent,layout,chunksize determine the
6394 * shape of the array.
6395 * This will always create an array with a type-0.90.0 superblock.
6396 * The newer usage is when assembling an array.
6397 * In this case raid_disks will be 0, and the major_version field is
6398 * use to determine which style super-blocks are to be found on the devices.
6399 * The minor and patch _version numbers are also kept incase the
6400 * super_block handler wishes to interpret them.
6401 */
NeilBrownf72ffdd2014-09-30 14:23:59 +10006402static int set_array_info(struct mddev *mddev, mdu_array_info_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006403{
6404
6405 if (info->raid_disks == 0) {
6406 /* just setting version number for superblock loading */
6407 if (info->major_version < 0 ||
Ahmed S. Darwish50511da2007-05-09 02:35:34 -07006408 info->major_version >= ARRAY_SIZE(super_types) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07006409 super_types[info->major_version].name == NULL) {
6410 /* maybe try to auto-load a module? */
NeilBrownf72ffdd2014-09-30 14:23:59 +10006411 printk(KERN_INFO
Linus Torvalds1da177e2005-04-16 15:20:36 -07006412 "md: superblock version %d not known\n",
6413 info->major_version);
6414 return -EINVAL;
6415 }
6416 mddev->major_version = info->major_version;
6417 mddev->minor_version = info->minor_version;
6418 mddev->patch_version = info->patch_version;
NeilBrown3f9d7b02006-12-22 01:11:41 -08006419 mddev->persistent = !info->not_persistent;
NeilBrowncbd19982009-12-30 12:08:49 +11006420 /* ensure mddev_put doesn't delete this now that there
6421 * is some minimal configuration.
6422 */
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11006423 mddev->ctime = ktime_get_real_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07006424 return 0;
6425 }
6426 mddev->major_version = MD_MAJOR_VERSION;
6427 mddev->minor_version = MD_MINOR_VERSION;
6428 mddev->patch_version = MD_PATCHLEVEL_VERSION;
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11006429 mddev->ctime = ktime_get_real_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07006430
6431 mddev->level = info->level;
NeilBrown17115e02006-01-16 22:14:57 -08006432 mddev->clevel[0] = 0;
Andre Noll58c0fed2009-03-31 14:33:13 +11006433 mddev->dev_sectors = 2 * (sector_t)info->size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006434 mddev->raid_disks = info->raid_disks;
6435 /* don't set md_minor, it is determined by which /dev/md* was
6436 * openned
6437 */
6438 if (info->state & (1<<MD_SB_CLEAN))
6439 mddev->recovery_cp = MaxSector;
6440 else
6441 mddev->recovery_cp = 0;
6442 mddev->persistent = ! info->not_persistent;
NeilBrowne6910632008-02-06 01:39:51 -08006443 mddev->external = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006444
6445 mddev->layout = info->layout;
Andre Noll9d8f0362009-06-18 08:45:01 +10006446 mddev->chunk_sectors = info->chunk_size >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006447
6448 mddev->max_disks = MD_SB_DISKS;
6449
NeilBrowne6910632008-02-06 01:39:51 -08006450 if (mddev->persistent)
6451 mddev->flags = 0;
NeilBrown850b2b42006-10-03 01:15:46 -07006452 set_bit(MD_CHANGE_DEVS, &mddev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006453
NeilBrownc3d97142009-12-14 12:49:52 +11006454 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
NeilBrown6409bb02012-05-22 13:55:07 +10006455 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
NeilBrownc3d97142009-12-14 12:49:52 +11006456 mddev->bitmap_info.offset = 0;
NeilBrownb2a27032005-11-28 13:44:12 -08006457
NeilBrownf6705572006-03-27 01:18:11 -08006458 mddev->reshape_position = MaxSector;
6459
Linus Torvalds1da177e2005-04-16 15:20:36 -07006460 /*
6461 * Generate a 128 bit UUID
6462 */
6463 get_random_bytes(mddev->uuid, 16);
6464
NeilBrownf6705572006-03-27 01:18:11 -08006465 mddev->new_level = mddev->level;
Andre Noll664e7c42009-06-18 08:45:27 +10006466 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownf6705572006-03-27 01:18:11 -08006467 mddev->new_layout = mddev->layout;
6468 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10006469 mddev->reshape_backwards = 0;
NeilBrownf6705572006-03-27 01:18:11 -08006470
Linus Torvalds1da177e2005-04-16 15:20:36 -07006471 return 0;
6472}
6473
NeilBrownfd01b882011-10-11 16:47:53 +11006474void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
Dan Williams1f403622009-03-31 14:59:03 +11006475{
Dan Williamsb522adc2009-03-31 15:00:31 +11006476 WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);
6477
6478 if (mddev->external_size)
6479 return;
6480
Dan Williams1f403622009-03-31 14:59:03 +11006481 mddev->array_sectors = array_sectors;
6482}
6483EXPORT_SYMBOL(md_set_array_sectors);
6484
NeilBrownfd01b882011-10-11 16:47:53 +11006485static int update_size(struct mddev *mddev, sector_t num_sectors)
NeilBrowna35b0d62006-01-06 00:20:49 -08006486{
NeilBrown3cb03002011-10-11 16:45:26 +11006487 struct md_rdev *rdev;
NeilBrowna35b0d62006-01-06 00:20:49 -08006488 int rv;
Andre Nolld71f9f82008-07-11 22:02:22 +10006489 int fit = (num_sectors == 0);
NeilBrowna35b0d62006-01-06 00:20:49 -08006490
Guoqing Jiangab5a98b2016-05-02 11:33:13 -04006491 /* cluster raid doesn't support update size */
6492 if (mddev_is_clustered(mddev))
6493 return -EINVAL;
6494
NeilBrowna35b0d62006-01-06 00:20:49 -08006495 if (mddev->pers->resize == NULL)
6496 return -EINVAL;
Andre Nolld71f9f82008-07-11 22:02:22 +10006497 /* The "num_sectors" is the number of sectors of each device that
6498 * is used. This can only make sense for arrays with redundancy.
6499 * linear and raid0 always use whatever space is available. We can only
6500 * consider changing this number if no resync or reconstruction is
6501 * happening, and if the new size is acceptable. It must fit before the
Andre Noll0f420352008-07-11 22:02:23 +10006502 * sb_start or, if that is <data_offset, it must fit before the size
Andre Nolld71f9f82008-07-11 22:02:22 +10006503 * of each device. If num_sectors is zero, we find the largest size
6504 * that fits.
NeilBrowna35b0d62006-01-06 00:20:49 -08006505 */
NeilBrownf851b602014-12-11 10:02:10 +11006506 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
6507 mddev->sync_thread)
NeilBrowna35b0d62006-01-06 00:20:49 -08006508 return -EBUSY;
NeilBrownbd8839e2014-05-28 13:39:21 +10006509 if (mddev->ro)
6510 return -EROFS;
NeilBrowna4a61252012-05-22 13:55:27 +10006511
NeilBrowndafb20f2012-03-19 12:46:39 +11006512 rdev_for_each(rdev, mddev) {
Andre Nolldd8ac332009-03-31 14:33:13 +11006513 sector_t avail = rdev->sectors;
NeilBrown01ab5662006-10-28 10:38:30 -07006514
Andre Nolld71f9f82008-07-11 22:02:22 +10006515 if (fit && (num_sectors == 0 || num_sectors > avail))
6516 num_sectors = avail;
6517 if (avail < num_sectors)
NeilBrowna35b0d62006-01-06 00:20:49 -08006518 return -ENOSPC;
6519 }
Andre Nolld71f9f82008-07-11 22:02:22 +10006520 rv = mddev->pers->resize(mddev, num_sectors);
NeilBrown449aad32009-08-03 10:59:58 +10006521 if (!rv)
6522 revalidate_disk(mddev->gendisk);
NeilBrowna35b0d62006-01-06 00:20:49 -08006523 return rv;
6524}
6525
NeilBrownfd01b882011-10-11 16:47:53 +11006526static int update_raid_disks(struct mddev *mddev, int raid_disks)
NeilBrownda943b992006-01-06 00:20:54 -08006527{
6528 int rv;
NeilBrownc6563a82012-05-21 09:27:00 +10006529 struct md_rdev *rdev;
NeilBrownda943b992006-01-06 00:20:54 -08006530 /* change the number of raid disks */
NeilBrown63c70c42006-03-27 01:18:13 -08006531 if (mddev->pers->check_reshape == NULL)
NeilBrownda943b992006-01-06 00:20:54 -08006532 return -EINVAL;
NeilBrownbd8839e2014-05-28 13:39:21 +10006533 if (mddev->ro)
6534 return -EROFS;
NeilBrownda943b992006-01-06 00:20:54 -08006535 if (raid_disks <= 0 ||
NeilBrown233fca32010-04-14 17:02:09 +10006536 (mddev->max_disks && raid_disks >= mddev->max_disks))
NeilBrownda943b992006-01-06 00:20:54 -08006537 return -EINVAL;
NeilBrownf851b602014-12-11 10:02:10 +11006538 if (mddev->sync_thread ||
6539 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
6540 mddev->reshape_position != MaxSector)
NeilBrownda943b992006-01-06 00:20:54 -08006541 return -EBUSY;
NeilBrownc6563a82012-05-21 09:27:00 +10006542
6543 rdev_for_each(rdev, mddev) {
6544 if (mddev->raid_disks < raid_disks &&
6545 rdev->data_offset < rdev->new_data_offset)
6546 return -EINVAL;
6547 if (mddev->raid_disks > raid_disks &&
6548 rdev->data_offset > rdev->new_data_offset)
6549 return -EINVAL;
6550 }
6551
NeilBrown63c70c42006-03-27 01:18:13 -08006552 mddev->delta_disks = raid_disks - mddev->raid_disks;
NeilBrown2c810cd2012-05-21 09:27:00 +10006553 if (mddev->delta_disks < 0)
6554 mddev->reshape_backwards = 1;
6555 else if (mddev->delta_disks > 0)
6556 mddev->reshape_backwards = 0;
NeilBrown63c70c42006-03-27 01:18:13 -08006557
6558 rv = mddev->pers->check_reshape(mddev);
NeilBrown2c810cd2012-05-21 09:27:00 +10006559 if (rv < 0) {
NeilBrownde171cb2011-01-31 11:57:42 +11006560 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10006561 mddev->reshape_backwards = 0;
6562 }
NeilBrownda943b992006-01-06 00:20:54 -08006563 return rv;
6564}
6565
Linus Torvalds1da177e2005-04-16 15:20:36 -07006566/*
6567 * update_array_info is used to change the configuration of an
6568 * on-line array.
6569 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
6570 * fields in the info are checked against the array.
6571 * Any differences that cannot be handled will cause an error.
6572 * Normally, only one change can be managed at a time.
6573 */
NeilBrownfd01b882011-10-11 16:47:53 +11006574static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006575{
6576 int rv = 0;
6577 int cnt = 0;
NeilBrown36fa3062005-09-09 16:23:45 -07006578 int state = 0;
6579
6580 /* calculate expected state,ignoring low bits */
NeilBrownc3d97142009-12-14 12:49:52 +11006581 if (mddev->bitmap && mddev->bitmap_info.offset)
NeilBrown36fa3062005-09-09 16:23:45 -07006582 state |= (1 << MD_SB_BITMAP_PRESENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006583
6584 if (mddev->major_version != info->major_version ||
6585 mddev->minor_version != info->minor_version ||
6586/* mddev->patch_version != info->patch_version || */
6587 mddev->ctime != info->ctime ||
6588 mddev->level != info->level ||
6589/* mddev->layout != info->layout || */
Firo Yang4e023612015-06-11 09:41:10 +08006590 mddev->persistent != !info->not_persistent ||
Andre Noll9d8f0362009-06-18 08:45:01 +10006591 mddev->chunk_sectors != info->chunk_size >> 9 ||
NeilBrown36fa3062005-09-09 16:23:45 -07006592 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
6593 ((state^info->state) & 0xfffffe00)
6594 )
Linus Torvalds1da177e2005-04-16 15:20:36 -07006595 return -EINVAL;
6596 /* Check there is only one change */
Andre Noll58c0fed2009-03-31 14:33:13 +11006597 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
6598 cnt++;
6599 if (mddev->raid_disks != info->raid_disks)
6600 cnt++;
6601 if (mddev->layout != info->layout)
6602 cnt++;
6603 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
6604 cnt++;
6605 if (cnt == 0)
6606 return 0;
6607 if (cnt > 1)
6608 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006609
6610 if (mddev->layout != info->layout) {
6611 /* Change layout
6612 * we don't need to do anything at the md level, the
6613 * personality will take care of it all.
6614 */
NeilBrown50ac1682009-06-18 08:47:55 +10006615 if (mddev->pers->check_reshape == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006616 return -EINVAL;
NeilBrown597a7112009-06-18 08:47:42 +10006617 else {
6618 mddev->new_layout = info->layout;
NeilBrown50ac1682009-06-18 08:47:55 +10006619 rv = mddev->pers->check_reshape(mddev);
NeilBrown597a7112009-06-18 08:47:42 +10006620 if (rv)
6621 mddev->new_layout = mddev->layout;
6622 return rv;
6623 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006624 }
Andre Noll58c0fed2009-03-31 14:33:13 +11006625 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
Andre Nolld71f9f82008-07-11 22:02:22 +10006626 rv = update_size(mddev, (sector_t)info->size * 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006627
NeilBrownda943b992006-01-06 00:20:54 -08006628 if (mddev->raid_disks != info->raid_disks)
6629 rv = update_raid_disks(mddev, info->raid_disks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006630
NeilBrown36fa3062005-09-09 16:23:45 -07006631 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006632 if (mddev->pers->quiesce == NULL || mddev->thread == NULL) {
6633 rv = -EINVAL;
6634 goto err;
6635 }
6636 if (mddev->recovery || mddev->sync_thread) {
6637 rv = -EBUSY;
6638 goto err;
6639 }
NeilBrown36fa3062005-09-09 16:23:45 -07006640 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
Goldwyn Rodriguesf9209a32014-06-06 12:43:49 -05006641 struct bitmap *bitmap;
NeilBrown36fa3062005-09-09 16:23:45 -07006642 /* add the bitmap */
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006643 if (mddev->bitmap) {
6644 rv = -EEXIST;
6645 goto err;
6646 }
6647 if (mddev->bitmap_info.default_offset == 0) {
6648 rv = -EINVAL;
6649 goto err;
6650 }
NeilBrownc3d97142009-12-14 12:49:52 +11006651 mddev->bitmap_info.offset =
6652 mddev->bitmap_info.default_offset;
NeilBrown6409bb02012-05-22 13:55:07 +10006653 mddev->bitmap_info.space =
6654 mddev->bitmap_info.default_space;
NeilBrown36fa3062005-09-09 16:23:45 -07006655 mddev->pers->quiesce(mddev, 1);
Goldwyn Rodriguesf9209a32014-06-06 12:43:49 -05006656 bitmap = bitmap_create(mddev, -1);
6657 if (!IS_ERR(bitmap)) {
6658 mddev->bitmap = bitmap;
NeilBrown69e51b42010-06-01 19:37:35 +10006659 rv = bitmap_load(mddev);
NeilBrownba599ac2015-02-25 11:44:11 +11006660 } else
6661 rv = PTR_ERR(bitmap);
NeilBrown36fa3062005-09-09 16:23:45 -07006662 if (rv)
6663 bitmap_destroy(mddev);
6664 mddev->pers->quiesce(mddev, 0);
6665 } else {
6666 /* remove the bitmap */
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006667 if (!mddev->bitmap) {
6668 rv = -ENOENT;
6669 goto err;
6670 }
6671 if (mddev->bitmap->storage.file) {
6672 rv = -EINVAL;
6673 goto err;
6674 }
Guoqing Jiangf6a2dc62015-12-21 10:51:00 +11006675 if (mddev->bitmap_info.nodes) {
6676 /* hold PW on all the bitmap lock */
6677 if (md_cluster_ops->lock_all_bitmaps(mddev) <= 0) {
6678 printk("md: can't change bitmap to none since the"
6679 " array is in use by more than one node\n");
6680 rv = -EPERM;
6681 md_cluster_ops->unlock_all_bitmaps(mddev);
6682 goto err;
6683 }
6684
6685 mddev->bitmap_info.nodes = 0;
6686 md_cluster_ops->leave(mddev);
6687 }
NeilBrown36fa3062005-09-09 16:23:45 -07006688 mddev->pers->quiesce(mddev, 1);
6689 bitmap_destroy(mddev);
6690 mddev->pers->quiesce(mddev, 0);
NeilBrownc3d97142009-12-14 12:49:52 +11006691 mddev->bitmap_info.offset = 0;
NeilBrown36fa3062005-09-09 16:23:45 -07006692 }
6693 }
NeilBrown850b2b42006-10-03 01:15:46 -07006694 md_update_sb(mddev, 1);
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006695 return rv;
6696err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07006697 return rv;
6698}
6699
NeilBrownfd01b882011-10-11 16:47:53 +11006700static int set_disk_faulty(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006701{
NeilBrown3cb03002011-10-11 16:45:26 +11006702 struct md_rdev *rdev;
NeilBrown1ca69c42012-10-11 13:37:33 +11006703 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006704
6705 if (mddev->pers == NULL)
6706 return -ENODEV;
6707
NeilBrown1ca69c42012-10-11 13:37:33 +11006708 rcu_read_lock();
6709 rdev = find_rdev_rcu(mddev, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006710 if (!rdev)
NeilBrown1ca69c42012-10-11 13:37:33 +11006711 err = -ENODEV;
6712 else {
6713 md_error(mddev, rdev);
6714 if (!test_bit(Faulty, &rdev->flags))
6715 err = -EBUSY;
6716 }
6717 rcu_read_unlock();
6718 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006719}
6720
Andre Noll2f9618c2008-04-25 18:57:58 +02006721/*
6722 * We have a problem here : there is no easy way to give a CHS
6723 * virtual geometry. We currently pretend that we have a 2 heads
6724 * 4 sectors (with a BIG number of cylinders...). This drives
6725 * dosfs just mad... ;-)
6726 */
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08006727static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
6728{
NeilBrownfd01b882011-10-11 16:47:53 +11006729 struct mddev *mddev = bdev->bd_disk->private_data;
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08006730
6731 geo->heads = 2;
6732 geo->sectors = 4;
NeilBrown49ce6ce2010-03-29 10:51:42 +11006733 geo->cylinders = mddev->array_sectors / 8;
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08006734 return 0;
6735}
6736
Nicolas Schichancb335f82014-01-15 16:58:52 +01006737static inline bool md_ioctl_valid(unsigned int cmd)
6738{
6739 switch (cmd) {
6740 case ADD_NEW_DISK:
6741 case BLKROSET:
6742 case GET_ARRAY_INFO:
6743 case GET_BITMAP_FILE:
6744 case GET_DISK_INFO:
6745 case HOT_ADD_DISK:
6746 case HOT_REMOVE_DISK:
Nicolas Schichancb335f82014-01-15 16:58:52 +01006747 case RAID_AUTORUN:
6748 case RAID_VERSION:
6749 case RESTART_ARRAY_RW:
6750 case RUN_ARRAY:
6751 case SET_ARRAY_INFO:
6752 case SET_BITMAP_FILE:
6753 case SET_DISK_FAULTY:
6754 case STOP_ARRAY:
6755 case STOP_ARRAY_RO:
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006756 case CLUSTERED_DISK_NACK:
Nicolas Schichancb335f82014-01-15 16:58:52 +01006757 return true;
6758 default:
6759 return false;
6760 }
6761}
6762
Al Viroa39907f2008-03-02 10:31:15 -05006763static int md_ioctl(struct block_device *bdev, fmode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07006764 unsigned int cmd, unsigned long arg)
6765{
6766 int err = 0;
6767 void __user *argp = (void __user *)arg;
NeilBrownfd01b882011-10-11 16:47:53 +11006768 struct mddev *mddev = NULL;
Dan Williamse2218352010-05-12 08:25:37 +10006769 int ro;
NeilBrown7e789782017-04-06 11:16:33 +08006770 bool did_set_md_closing = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006771
Nicolas Schichancb335f82014-01-15 16:58:52 +01006772 if (!md_ioctl_valid(cmd))
6773 return -ENOTTY;
6774
NeilBrown506c9e42011-12-23 10:17:26 +11006775 switch (cmd) {
6776 case RAID_VERSION:
6777 case GET_ARRAY_INFO:
6778 case GET_DISK_INFO:
6779 break;
6780 default:
6781 if (!capable(CAP_SYS_ADMIN))
6782 return -EACCES;
6783 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006784
6785 /*
6786 * Commands dealing with the RAID driver but not any
6787 * particular array:
6788 */
NeilBrownc02c0ae2012-12-11 13:39:21 +11006789 switch (cmd) {
6790 case RAID_VERSION:
6791 err = get_version(argp);
NeilBrown3adc28d2014-09-30 15:46:41 +10006792 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006793
Linus Torvalds1da177e2005-04-16 15:20:36 -07006794#ifndef MODULE
NeilBrownc02c0ae2012-12-11 13:39:21 +11006795 case RAID_AUTORUN:
6796 err = 0;
6797 autostart_arrays(arg);
NeilBrown3adc28d2014-09-30 15:46:41 +10006798 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006799#endif
NeilBrownc02c0ae2012-12-11 13:39:21 +11006800 default:;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006801 }
6802
6803 /*
6804 * Commands creating/starting a new array:
6805 */
6806
Al Viroa39907f2008-03-02 10:31:15 -05006807 mddev = bdev->bd_disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006808
6809 if (!mddev) {
6810 BUG();
NeilBrown3adc28d2014-09-30 15:46:41 +10006811 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006812 }
6813
NeilBrown1ca69c42012-10-11 13:37:33 +11006814 /* Some actions do not requires the mutex */
6815 switch (cmd) {
6816 case GET_ARRAY_INFO:
6817 if (!mddev->raid_disks && !mddev->external)
6818 err = -ENODEV;
6819 else
6820 err = get_array_info(mddev, argp);
NeilBrown3adc28d2014-09-30 15:46:41 +10006821 goto out;
NeilBrown1ca69c42012-10-11 13:37:33 +11006822
6823 case GET_DISK_INFO:
6824 if (!mddev->raid_disks && !mddev->external)
6825 err = -ENODEV;
6826 else
6827 err = get_disk_info(mddev, argp);
NeilBrown3adc28d2014-09-30 15:46:41 +10006828 goto out;
NeilBrown1ca69c42012-10-11 13:37:33 +11006829
6830 case SET_DISK_FAULTY:
6831 err = set_disk_faulty(mddev, new_decode_dev(arg));
NeilBrown3adc28d2014-09-30 15:46:41 +10006832 goto out;
NeilBrown4af1a042014-12-15 12:57:00 +11006833
6834 case GET_BITMAP_FILE:
6835 err = get_bitmap_file(mddev, argp);
6836 goto out;
6837
NeilBrown1ca69c42012-10-11 13:37:33 +11006838 }
6839
NeilBrowna7a3f082012-12-11 13:35:54 +11006840 if (cmd == ADD_NEW_DISK)
6841 /* need to ensure md_delayed_delete() has completed */
6842 flush_workqueue(md_misc_wq);
6843
Hannes Reinecke90f5f7a2013-04-02 08:38:55 +02006844 if (cmd == HOT_REMOVE_DISK)
6845 /* need to ensure recovery thread has run */
6846 wait_event_interruptible_timeout(mddev->sb_wait,
6847 !test_bit(MD_RECOVERY_NEEDED,
Shaohua Li60a931c2016-12-08 15:48:18 -08006848 &mddev->recovery),
Hannes Reinecke90f5f7a2013-04-02 08:38:55 +02006849 msecs_to_jiffies(5000));
NeilBrown260fa032013-08-27 16:44:13 +10006850 if (cmd == STOP_ARRAY || cmd == STOP_ARRAY_RO) {
6851 /* Need to flush page cache, and ensure no-one else opens
6852 * and writes
6853 */
6854 mutex_lock(&mddev->open_mutex);
NeilBrown9ba3b7f2014-09-09 14:00:15 +10006855 if (mddev->pers && atomic_read(&mddev->openers) > 1) {
NeilBrown260fa032013-08-27 16:44:13 +10006856 mutex_unlock(&mddev->open_mutex);
6857 err = -EBUSY;
NeilBrown3adc28d2014-09-30 15:46:41 +10006858 goto out;
NeilBrown260fa032013-08-27 16:44:13 +10006859 }
NeilBrown7e789782017-04-06 11:16:33 +08006860 WARN_ON_ONCE(test_bit(MD_CLOSING, &mddev->flags));
Guoqing Jiangaf8d8e62016-08-12 13:42:37 +08006861 set_bit(MD_CLOSING, &mddev->flags);
NeilBrown7e789782017-04-06 11:16:33 +08006862 did_set_md_closing = true;
NeilBrown260fa032013-08-27 16:44:13 +10006863 mutex_unlock(&mddev->open_mutex);
6864 sync_blockdev(bdev);
6865 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006866 err = mddev_lock(mddev);
6867 if (err) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006868 printk(KERN_INFO
Linus Torvalds1da177e2005-04-16 15:20:36 -07006869 "md: ioctl lock interrupted, reason %d, cmd %d\n",
6870 err, cmd);
NeilBrown3adc28d2014-09-30 15:46:41 +10006871 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006872 }
6873
NeilBrownc02c0ae2012-12-11 13:39:21 +11006874 if (cmd == SET_ARRAY_INFO) {
6875 mdu_array_info_t info;
6876 if (!arg)
6877 memset(&info, 0, sizeof(info));
6878 else if (copy_from_user(&info, argp, sizeof(info))) {
6879 err = -EFAULT;
NeilBrown3adc28d2014-09-30 15:46:41 +10006880 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006881 }
6882 if (mddev->pers) {
6883 err = update_array_info(mddev, &info);
6884 if (err) {
6885 printk(KERN_WARNING "md: couldn't update"
6886 " array info. %d\n", err);
NeilBrown3adc28d2014-09-30 15:46:41 +10006887 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006888 }
NeilBrown3adc28d2014-09-30 15:46:41 +10006889 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006890 }
6891 if (!list_empty(&mddev->disks)) {
6892 printk(KERN_WARNING
6893 "md: array %s already has disks!\n",
6894 mdname(mddev));
6895 err = -EBUSY;
NeilBrown3adc28d2014-09-30 15:46:41 +10006896 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006897 }
6898 if (mddev->raid_disks) {
6899 printk(KERN_WARNING
6900 "md: array %s already initialised!\n",
6901 mdname(mddev));
6902 err = -EBUSY;
NeilBrown3adc28d2014-09-30 15:46:41 +10006903 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006904 }
6905 err = set_array_info(mddev, &info);
6906 if (err) {
6907 printk(KERN_WARNING "md: couldn't set"
6908 " array info. %d\n", err);
NeilBrown3adc28d2014-09-30 15:46:41 +10006909 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006910 }
NeilBrown3adc28d2014-09-30 15:46:41 +10006911 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006912 }
6913
6914 /*
6915 * Commands querying/configuring an existing array:
6916 */
NeilBrown32a76272005-06-21 17:17:14 -07006917 /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
NeilBrown3f9d7b02006-12-22 01:11:41 -08006918 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
NeilBrowna17184a2008-02-06 01:39:55 -08006919 if ((!mddev->raid_disks && !mddev->external)
6920 && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
6921 && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
6922 && cmd != GET_BITMAP_FILE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006923 err = -ENODEV;
NeilBrown3adc28d2014-09-30 15:46:41 +10006924 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006925 }
6926
6927 /*
6928 * Commands even a read-only array can execute:
6929 */
NeilBrownc02c0ae2012-12-11 13:39:21 +11006930 switch (cmd) {
NeilBrownc02c0ae2012-12-11 13:39:21 +11006931 case RESTART_ARRAY_RW:
6932 err = restart_array(mddev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006933 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006934
6935 case STOP_ARRAY:
6936 err = do_md_stop(mddev, 0, bdev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006937 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006938
6939 case STOP_ARRAY_RO:
6940 err = md_set_readonly(mddev, bdev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006941 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006942
NeilBrown3ea8929d2013-04-24 11:42:41 +10006943 case HOT_REMOVE_DISK:
6944 err = hot_remove_disk(mddev, new_decode_dev(arg));
NeilBrown3adc28d2014-09-30 15:46:41 +10006945 goto unlock;
NeilBrown3ea8929d2013-04-24 11:42:41 +10006946
NeilBrown7ceb17e2013-04-24 11:42:42 +10006947 case ADD_NEW_DISK:
6948 /* We can support ADD_NEW_DISK on read-only arrays
Wei Fang466ad292016-03-21 19:19:30 +08006949 * only if we are re-adding a preexisting device.
NeilBrown7ceb17e2013-04-24 11:42:42 +10006950 * So require mddev->pers and MD_DISK_SYNC.
6951 */
6952 if (mddev->pers) {
6953 mdu_disk_info_t info;
6954 if (copy_from_user(&info, argp, sizeof(info)))
6955 err = -EFAULT;
6956 else if (!(info.state & (1<<MD_DISK_SYNC)))
6957 /* Need to clear read-only for this */
6958 break;
6959 else
6960 err = add_new_disk(mddev, &info);
NeilBrown3adc28d2014-09-30 15:46:41 +10006961 goto unlock;
NeilBrown7ceb17e2013-04-24 11:42:42 +10006962 }
6963 break;
6964
NeilBrownc02c0ae2012-12-11 13:39:21 +11006965 case BLKROSET:
6966 if (get_user(ro, (int __user *)(arg))) {
6967 err = -EFAULT;
NeilBrown3adc28d2014-09-30 15:46:41 +10006968 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006969 }
6970 err = -EINVAL;
6971
6972 /* if the bdev is going readonly the value of mddev->ro
6973 * does not matter, no writes are coming
6974 */
6975 if (ro)
NeilBrown3adc28d2014-09-30 15:46:41 +10006976 goto unlock;
NeilBrown32a76272005-06-21 17:17:14 -07006977
NeilBrownc02c0ae2012-12-11 13:39:21 +11006978 /* are we are already prepared for writes? */
6979 if (mddev->ro != 1)
NeilBrown3adc28d2014-09-30 15:46:41 +10006980 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006981
6982 /* transitioning to readauto need only happen for
6983 * arrays that call md_write_start
6984 */
6985 if (mddev->pers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006986 err = restart_array(mddev);
NeilBrownc02c0ae2012-12-11 13:39:21 +11006987 if (err == 0) {
6988 mddev->ro = 2;
6989 set_disk_ro(mddev->gendisk, 0);
Dan Williamse2218352010-05-12 08:25:37 +10006990 }
NeilBrownc02c0ae2012-12-11 13:39:21 +11006991 }
NeilBrown3adc28d2014-09-30 15:46:41 +10006992 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006993 }
6994
6995 /*
6996 * The remaining ioctls are changing the state of the
NeilBrownf91de922005-11-08 21:39:36 -08006997 * superblock, so we do not allow them on read-only arrays.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006998 */
NeilBrown326eb172014-09-30 15:36:28 +10006999 if (mddev->ro && mddev->pers) {
NeilBrownf91de922005-11-08 21:39:36 -08007000 if (mddev->ro == 2) {
7001 mddev->ro = 0;
NeilBrown00bcb4a2010-06-01 19:37:23 +10007002 sysfs_notify_dirent_safe(mddev->sysfs_state);
Neil Brown0fd62b82008-06-28 08:31:36 +10007003 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrownf3378b42013-02-28 11:59:03 +11007004 /* mddev_unlock will wake thread */
7005 /* If a device failed while we were read-only, we
7006 * need to make sure the metadata is updated now.
7007 */
7008 if (test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
7009 mddev_unlock(mddev);
7010 wait_event(mddev->sb_wait,
7011 !test_bit(MD_CHANGE_DEVS, &mddev->flags) &&
7012 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
NeilBrown29f097c2013-11-14 17:54:51 +11007013 mddev_lock_nointr(mddev);
NeilBrownf3378b42013-02-28 11:59:03 +11007014 }
NeilBrownf91de922005-11-08 21:39:36 -08007015 } else {
7016 err = -EROFS;
NeilBrown3adc28d2014-09-30 15:46:41 +10007017 goto unlock;
NeilBrownf91de922005-11-08 21:39:36 -08007018 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007019 }
7020
NeilBrownc02c0ae2012-12-11 13:39:21 +11007021 switch (cmd) {
7022 case ADD_NEW_DISK:
Linus Torvalds1da177e2005-04-16 15:20:36 -07007023 {
NeilBrownc02c0ae2012-12-11 13:39:21 +11007024 mdu_disk_info_t info;
7025 if (copy_from_user(&info, argp, sizeof(info)))
7026 err = -EFAULT;
7027 else
7028 err = add_new_disk(mddev, &info);
NeilBrown3adc28d2014-09-30 15:46:41 +10007029 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11007030 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007031
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05007032 case CLUSTERED_DISK_NACK:
7033 if (mddev_is_clustered(mddev))
7034 md_cluster_ops->new_disk_ack(mddev, false);
7035 else
7036 err = -EINVAL;
7037 goto unlock;
7038
NeilBrownc02c0ae2012-12-11 13:39:21 +11007039 case HOT_ADD_DISK:
7040 err = hot_add_disk(mddev, new_decode_dev(arg));
NeilBrown3adc28d2014-09-30 15:46:41 +10007041 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007042
NeilBrownc02c0ae2012-12-11 13:39:21 +11007043 case RUN_ARRAY:
7044 err = do_md_run(mddev);
NeilBrown3adc28d2014-09-30 15:46:41 +10007045 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007046
NeilBrownc02c0ae2012-12-11 13:39:21 +11007047 case SET_BITMAP_FILE:
7048 err = set_bitmap_file(mddev, (int)arg);
NeilBrown3adc28d2014-09-30 15:46:41 +10007049 goto unlock;
NeilBrown32a76272005-06-21 17:17:14 -07007050
NeilBrownc02c0ae2012-12-11 13:39:21 +11007051 default:
7052 err = -EINVAL;
NeilBrown3adc28d2014-09-30 15:46:41 +10007053 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007054 }
7055
NeilBrown3adc28d2014-09-30 15:46:41 +10007056unlock:
NeilBrownd3374822009-01-09 08:31:10 +11007057 if (mddev->hold_active == UNTIL_IOCTL &&
7058 err != -EINVAL)
7059 mddev->hold_active = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007060 mddev_unlock(mddev);
NeilBrown3adc28d2014-09-30 15:46:41 +10007061out:
NeilBrown7e789782017-04-06 11:16:33 +08007062 if(did_set_md_closing)
7063 clear_bit(MD_CLOSING, &mddev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007064 return err;
7065}
Arnd Bergmannaa98aa32009-12-14 12:50:05 +11007066#ifdef CONFIG_COMPAT
7067static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
7068 unsigned int cmd, unsigned long arg)
7069{
7070 switch (cmd) {
7071 case HOT_REMOVE_DISK:
7072 case HOT_ADD_DISK:
7073 case SET_DISK_FAULTY:
7074 case SET_BITMAP_FILE:
7075 /* These take in integer arg, do not convert */
7076 break;
7077 default:
7078 arg = (unsigned long)compat_ptr(arg);
7079 break;
7080 }
7081
7082 return md_ioctl(bdev, mode, cmd, arg);
7083}
7084#endif /* CONFIG_COMPAT */
Linus Torvalds1da177e2005-04-16 15:20:36 -07007085
Al Viroa39907f2008-03-02 10:31:15 -05007086static int md_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007087{
7088 /*
7089 * Succeed if we can lock the mddev, which confirms that
7090 * it isn't being stopped right now.
7091 */
NeilBrownfd01b882011-10-11 16:47:53 +11007092 struct mddev *mddev = mddev_find(bdev->bd_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007093 int err;
7094
Yuanhan Liu0c098222012-05-22 13:55:32 +10007095 if (!mddev)
7096 return -ENODEV;
7097
NeilBrownd3374822009-01-09 08:31:10 +11007098 if (mddev->gendisk != bdev->bd_disk) {
7099 /* we are racing with mddev_put which is discarding this
7100 * bd_disk.
7101 */
7102 mddev_put(mddev);
7103 /* Wait until bdev->bd_disk is definitely gone */
Tejun Heoe804ac72010-10-15 15:36:08 +02007104 flush_workqueue(md_misc_wq);
NeilBrownd3374822009-01-09 08:31:10 +11007105 /* Then retry the open from the top */
7106 return -ERESTARTSYS;
7107 }
7108 BUG_ON(mddev != bdev->bd_disk->private_data);
7109
NeilBrownc8c00a62009-08-10 12:50:52 +10007110 if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07007111 goto out;
7112
Guoqing Jiangaf8d8e62016-08-12 13:42:37 +08007113 if (test_bit(MD_CLOSING, &mddev->flags)) {
7114 mutex_unlock(&mddev->open_mutex);
NeilBrown5cc85ef2016-12-05 16:40:50 +11007115 err = -ENODEV;
7116 goto out;
Guoqing Jiangaf8d8e62016-08-12 13:42:37 +08007117 }
7118
Linus Torvalds1da177e2005-04-16 15:20:36 -07007119 err = 0;
NeilBrownf2ea68c2008-07-21 17:05:25 +10007120 atomic_inc(&mddev->openers);
NeilBrownc8c00a62009-08-10 12:50:52 +10007121 mutex_unlock(&mddev->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007122
NeilBrownf0b4f7e2011-02-24 17:26:41 +11007123 check_disk_change(bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007124 out:
NeilBrown5cc85ef2016-12-05 16:40:50 +11007125 if (err)
7126 mddev_put(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007127 return err;
7128}
7129
Al Virodb2a1442013-05-05 21:52:57 -04007130static void md_release(struct gendisk *disk, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007131{
NeilBrownf72ffdd2014-09-30 14:23:59 +10007132 struct mddev *mddev = disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007133
Eric Sesterhenn52e5f9d2006-10-03 23:33:23 +02007134 BUG_ON(!mddev);
NeilBrownf2ea68c2008-07-21 17:05:25 +10007135 atomic_dec(&mddev->openers);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007136 mddev_put(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007137}
NeilBrownf0b4f7e2011-02-24 17:26:41 +11007138
7139static int md_media_changed(struct gendisk *disk)
7140{
NeilBrownfd01b882011-10-11 16:47:53 +11007141 struct mddev *mddev = disk->private_data;
NeilBrownf0b4f7e2011-02-24 17:26:41 +11007142
7143 return mddev->changed;
7144}
7145
7146static int md_revalidate(struct gendisk *disk)
7147{
NeilBrownfd01b882011-10-11 16:47:53 +11007148 struct mddev *mddev = disk->private_data;
NeilBrownf0b4f7e2011-02-24 17:26:41 +11007149
7150 mddev->changed = 0;
7151 return 0;
7152}
Alexey Dobriyan83d5cde2009-09-21 17:01:13 -07007153static const struct block_device_operations md_fops =
Linus Torvalds1da177e2005-04-16 15:20:36 -07007154{
7155 .owner = THIS_MODULE,
Al Viroa39907f2008-03-02 10:31:15 -05007156 .open = md_open,
7157 .release = md_release,
NeilBrownb492b852009-05-26 12:57:36 +10007158 .ioctl = md_ioctl,
Arnd Bergmannaa98aa32009-12-14 12:50:05 +11007159#ifdef CONFIG_COMPAT
7160 .compat_ioctl = md_compat_ioctl,
7161#endif
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08007162 .getgeo = md_getgeo,
NeilBrownf0b4f7e2011-02-24 17:26:41 +11007163 .media_changed = md_media_changed,
7164 .revalidate_disk= md_revalidate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07007165};
7166
NeilBrownf72ffdd2014-09-30 14:23:59 +10007167static int md_thread(void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007168{
NeilBrown2b8bf342011-10-11 16:48:23 +11007169 struct md_thread *thread = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007170
Linus Torvalds1da177e2005-04-16 15:20:36 -07007171 /*
7172 * md_thread is a 'system-thread', it's priority should be very
7173 * high. We avoid resource deadlocks individually in each
7174 * raid personality. (RAID5 does preallocation) We also use RR and
7175 * the very same RT priority as kswapd, thus we will never get
7176 * into a priority inversion deadlock.
7177 *
7178 * we definitely have to have equal or higher priority than
7179 * bdflush, otherwise bdflush will deadlock if there are too
7180 * many dirty RAID5 blocks.
7181 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07007182
NeilBrown6985c432005-10-19 21:23:47 -07007183 allow_signal(SIGKILL);
NeilBrowna6fb0932005-09-09 16:23:56 -07007184 while (!kthread_should_stop()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007185
NeilBrown93588e22005-11-15 00:09:12 -08007186 /* We need to wait INTERRUPTIBLE so that
7187 * we don't add to the load-average.
7188 * That means we need to be sure no signals are
7189 * pending
7190 */
7191 if (signal_pending(current))
7192 flush_signals(current);
7193
7194 wait_event_interruptible_timeout
7195 (thread->wqueue,
7196 test_bit(THREAD_WAKEUP, &thread->flags)
7197 || kthread_should_stop(),
7198 thread->timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007199
NeilBrown6c987912011-01-14 09:13:53 +11007200 clear_bit(THREAD_WAKEUP, &thread->flags);
7201 if (!kthread_should_stop())
Shaohua Li4ed87312012-10-11 13:34:00 +11007202 thread->run(thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007203 }
NeilBrowna6fb0932005-09-09 16:23:56 -07007204
Linus Torvalds1da177e2005-04-16 15:20:36 -07007205 return 0;
7206}
7207
NeilBrown2b8bf342011-10-11 16:48:23 +11007208void md_wakeup_thread(struct md_thread *thread)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007209{
7210 if (thread) {
NeilBrown36a4e1f2011-10-07 14:23:17 +11007211 pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007212 set_bit(THREAD_WAKEUP, &thread->flags);
7213 wake_up(&thread->wqueue);
7214 }
7215}
NeilBrown6c144d32014-09-30 16:15:38 +10007216EXPORT_SYMBOL(md_wakeup_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007217
Shaohua Li4ed87312012-10-11 13:34:00 +11007218struct md_thread *md_register_thread(void (*run) (struct md_thread *),
7219 struct mddev *mddev, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007220{
NeilBrown2b8bf342011-10-11 16:48:23 +11007221 struct md_thread *thread;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007222
NeilBrown2b8bf342011-10-11 16:48:23 +11007223 thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007224 if (!thread)
7225 return NULL;
7226
Linus Torvalds1da177e2005-04-16 15:20:36 -07007227 init_waitqueue_head(&thread->wqueue);
7228
Linus Torvalds1da177e2005-04-16 15:20:36 -07007229 thread->run = run;
7230 thread->mddev = mddev;
NeilBrown32a76272005-06-21 17:17:14 -07007231 thread->timeout = MAX_SCHEDULE_TIMEOUT;
NeilBrown0da3c612009-09-23 18:09:45 +10007232 thread->tsk = kthread_run(md_thread, thread,
7233 "%s_%s",
7234 mdname(thread->mddev),
NeilBrown02326052012-07-03 15:56:52 +10007235 name);
NeilBrowna6fb0932005-09-09 16:23:56 -07007236 if (IS_ERR(thread->tsk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007237 kfree(thread);
7238 return NULL;
7239 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007240 return thread;
7241}
NeilBrown6c144d32014-09-30 16:15:38 +10007242EXPORT_SYMBOL(md_register_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007243
NeilBrown2b8bf342011-10-11 16:48:23 +11007244void md_unregister_thread(struct md_thread **threadp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007245{
NeilBrown2b8bf342011-10-11 16:48:23 +11007246 struct md_thread *thread = *threadp;
NeilBrowne0cf8f02009-03-31 14:39:39 +11007247 if (!thread)
7248 return;
NeilBrown36a4e1f2011-10-07 14:23:17 +11007249 pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
NeilBrown01f96c02011-09-21 15:30:20 +10007250 /* Locking ensures that mddev_unlock does not wake_up a
7251 * non-existent thread
7252 */
7253 spin_lock(&pers_lock);
7254 *threadp = NULL;
7255 spin_unlock(&pers_lock);
NeilBrowna6fb0932005-09-09 16:23:56 -07007256
7257 kthread_stop(thread->tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007258 kfree(thread);
7259}
NeilBrown6c144d32014-09-30 16:15:38 +10007260EXPORT_SYMBOL(md_unregister_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007261
NeilBrownfd01b882011-10-11 16:47:53 +11007262void md_error(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007263{
NeilBrownb2d444d2005-11-08 21:39:31 -08007264 if (!rdev || test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07007265 return;
Dan Williams6bfe0b42008-04-30 00:52:32 -07007266
NeilBrownde393cd2011-07-28 11:31:48 +10007267 if (!mddev->pers || !mddev->pers->error_handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007268 return;
7269 mddev->pers->error_handler(mddev,rdev);
Neil Brown72a23c22008-06-28 08:31:41 +10007270 if (mddev->degraded)
7271 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown00bcb4a2010-06-01 19:37:23 +10007272 sysfs_notify_dirent_safe(rdev->sysfs_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007273 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7274 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7275 md_wakeup_thread(mddev->thread);
NeilBrown768a4182010-07-26 11:49:55 +10007276 if (mddev->event_work.func)
Tejun Heoe804ac72010-10-15 15:36:08 +02007277 queue_work(md_misc_wq, &mddev->event_work);
Guoqing Jiangbb9ef712015-12-28 10:46:38 +08007278 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007279}
NeilBrown6c144d32014-09-30 16:15:38 +10007280EXPORT_SYMBOL(md_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007281
7282/* seq_file implementation /proc/mdstat */
7283
7284static void status_unused(struct seq_file *seq)
7285{
7286 int i = 0;
NeilBrown3cb03002011-10-11 16:45:26 +11007287 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007288
7289 seq_printf(seq, "unused devices: ");
7290
Cheng Renquan159ec1f2009-01-09 08:31:08 +11007291 list_for_each_entry(rdev, &pending_raid_disks, same_set) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007292 char b[BDEVNAME_SIZE];
7293 i++;
7294 seq_printf(seq, "%s ",
7295 bdevname(rdev->bdev,b));
7296 }
7297 if (!i)
7298 seq_printf(seq, "<none>");
7299
7300 seq_printf(seq, "\n");
7301}
7302
NeilBrownf7851be2015-07-02 17:12:58 +10007303static int status_resync(struct seq_file *seq, struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007304{
NeilBrowndd71cf62009-05-07 12:49:35 +10007305 sector_t max_sectors, resync, res;
Mariusz Tkaczyk4f734702019-06-13 16:11:41 +02007306 unsigned long dt, db = 0;
7307 sector_t rt, curr_mark_cnt, resync_mark_cnt;
7308 int scale, recovery_active;
NeilBrown4588b422006-03-27 01:18:04 -08007309 unsigned int per_milli;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007310
NeilBrownc804cde2012-05-21 09:28:33 +10007311 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
7312 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
NeilBrowndd71cf62009-05-07 12:49:35 +10007313 max_sectors = mddev->resync_max_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007314 else
NeilBrowndd71cf62009-05-07 12:49:35 +10007315 max_sectors = mddev->dev_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007316
NeilBrownf7851be2015-07-02 17:12:58 +10007317 resync = mddev->curr_resync;
7318 if (resync <= 3) {
7319 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7320 /* Still cleaning up */
7321 resync = max_sectors;
7322 } else
7323 resync -= atomic_read(&mddev->recovery_active);
7324
7325 if (resync == 0) {
7326 if (mddev->recovery_cp < MaxSector) {
7327 seq_printf(seq, "\tresync=PENDING");
7328 return 1;
7329 }
7330 return 0;
7331 }
7332 if (resync < 3) {
7333 seq_printf(seq, "\tresync=DELAYED");
7334 return 1;
7335 }
7336
NeilBrown403df472014-09-30 15:52:29 +10007337 WARN_ON(max_sectors == 0);
NeilBrown4588b422006-03-27 01:18:04 -08007338 /* Pick 'scale' such that (resync>>scale)*1000 will fit
NeilBrowndd71cf62009-05-07 12:49:35 +10007339 * in a sector_t, and (max_sectors>>scale) will fit in a
NeilBrown4588b422006-03-27 01:18:04 -08007340 * u32, as those are the requirements for sector_div.
7341 * Thus 'scale' must be at least 10
7342 */
7343 scale = 10;
7344 if (sizeof(sector_t) > sizeof(unsigned long)) {
NeilBrowndd71cf62009-05-07 12:49:35 +10007345 while ( max_sectors/2 > (1ULL<<(scale+32)))
NeilBrown4588b422006-03-27 01:18:04 -08007346 scale++;
7347 }
7348 res = (resync>>scale)*1000;
NeilBrowndd71cf62009-05-07 12:49:35 +10007349 sector_div(res, (u32)((max_sectors>>scale)+1));
NeilBrown4588b422006-03-27 01:18:04 -08007350
7351 per_milli = res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007352 {
NeilBrown4588b422006-03-27 01:18:04 -08007353 int i, x = per_milli/50, y = 20-x;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007354 seq_printf(seq, "[");
7355 for (i = 0; i < x; i++)
7356 seq_printf(seq, "=");
7357 seq_printf(seq, ">");
7358 for (i = 0; i < y; i++)
7359 seq_printf(seq, ".");
7360 seq_printf(seq, "] ");
7361 }
NeilBrown4588b422006-03-27 01:18:04 -08007362 seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
NeilBrownccfcc3c2006-03-27 01:18:09 -08007363 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
7364 "reshape" :
NeilBrown61df9d92006-10-03 01:15:57 -07007365 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
7366 "check" :
7367 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
7368 "resync" : "recovery"))),
7369 per_milli/10, per_milli % 10,
NeilBrowndd71cf62009-05-07 12:49:35 +10007370 (unsigned long long) resync/2,
7371 (unsigned long long) max_sectors/2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007372
7373 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07007374 * dt: time from mark until now
7375 * db: blocks written from mark until now
7376 * rt: remaining time
NeilBrowndd71cf62009-05-07 12:49:35 +10007377 *
Mariusz Tkaczyk4f734702019-06-13 16:11:41 +02007378 * rt is a sector_t, which is always 64bit now. We are keeping
7379 * the original algorithm, but it is not really necessary.
7380 *
7381 * Original algorithm:
7382 * So we divide before multiply in case it is 32bit and close
7383 * to the limit.
7384 * We scale the divisor (db) by 32 to avoid losing precision
7385 * near the end of resync when the number of remaining sectors
7386 * is close to 'db'.
7387 * We then divide rt by 32 after multiplying by db to compensate.
7388 * The '+1' avoids division by zero if db is very small.
Linus Torvalds1da177e2005-04-16 15:20:36 -07007389 */
7390 dt = ((jiffies - mddev->resync_mark) / HZ);
7391 if (!dt) dt++;
Mariusz Tkaczyk4f734702019-06-13 16:11:41 +02007392
7393 curr_mark_cnt = mddev->curr_mark_cnt;
7394 recovery_active = atomic_read(&mddev->recovery_active);
7395 resync_mark_cnt = mddev->resync_mark_cnt;
7396
7397 if (curr_mark_cnt >= (recovery_active + resync_mark_cnt))
7398 db = curr_mark_cnt - (recovery_active + resync_mark_cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007399
NeilBrowndd71cf62009-05-07 12:49:35 +10007400 rt = max_sectors - resync; /* number of remaining sectors */
Mariusz Tkaczyk4f734702019-06-13 16:11:41 +02007401 rt = div64_u64(rt, db/32+1);
NeilBrowndd71cf62009-05-07 12:49:35 +10007402 rt *= dt;
7403 rt >>= 5;
7404
7405 seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
7406 ((unsigned long)rt % 60)/6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007407
NeilBrownff4e8d92006-07-10 04:44:16 -07007408 seq_printf(seq, " speed=%ldK/sec", db/2/dt);
NeilBrownf7851be2015-07-02 17:12:58 +10007409 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007410}
7411
7412static void *md_seq_start(struct seq_file *seq, loff_t *pos)
7413{
7414 struct list_head *tmp;
7415 loff_t l = *pos;
NeilBrownfd01b882011-10-11 16:47:53 +11007416 struct mddev *mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007417
7418 if (l >= 0x10000)
7419 return NULL;
7420 if (!l--)
7421 /* header */
7422 return (void*)1;
7423
7424 spin_lock(&all_mddevs_lock);
7425 list_for_each(tmp,&all_mddevs)
7426 if (!l--) {
NeilBrownfd01b882011-10-11 16:47:53 +11007427 mddev = list_entry(tmp, struct mddev, all_mddevs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007428 mddev_get(mddev);
7429 spin_unlock(&all_mddevs_lock);
7430 return mddev;
7431 }
7432 spin_unlock(&all_mddevs_lock);
7433 if (!l--)
7434 return (void*)2;/* tail */
7435 return NULL;
7436}
7437
7438static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
7439{
7440 struct list_head *tmp;
NeilBrownfd01b882011-10-11 16:47:53 +11007441 struct mddev *next_mddev, *mddev = v;
NeilBrownf72ffdd2014-09-30 14:23:59 +10007442
Linus Torvalds1da177e2005-04-16 15:20:36 -07007443 ++*pos;
7444 if (v == (void*)2)
7445 return NULL;
7446
7447 spin_lock(&all_mddevs_lock);
7448 if (v == (void*)1)
7449 tmp = all_mddevs.next;
7450 else
7451 tmp = mddev->all_mddevs.next;
7452 if (tmp != &all_mddevs)
NeilBrownfd01b882011-10-11 16:47:53 +11007453 next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
Linus Torvalds1da177e2005-04-16 15:20:36 -07007454 else {
7455 next_mddev = (void*)2;
7456 *pos = 0x10000;
NeilBrownf72ffdd2014-09-30 14:23:59 +10007457 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007458 spin_unlock(&all_mddevs_lock);
7459
7460 if (v != (void*)1)
7461 mddev_put(mddev);
7462 return next_mddev;
7463
7464}
7465
7466static void md_seq_stop(struct seq_file *seq, void *v)
7467{
NeilBrownfd01b882011-10-11 16:47:53 +11007468 struct mddev *mddev = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007469
7470 if (mddev && v != (void*)1 && v != (void*)2)
7471 mddev_put(mddev);
7472}
7473
7474static int md_seq_show(struct seq_file *seq, void *v)
7475{
NeilBrownfd01b882011-10-11 16:47:53 +11007476 struct mddev *mddev = v;
Andre Nolldd8ac332009-03-31 14:33:13 +11007477 sector_t sectors;
NeilBrown3cb03002011-10-11 16:45:26 +11007478 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007479
7480 if (v == (void*)1) {
NeilBrown84fc4b52011-10-11 16:49:58 +11007481 struct md_personality *pers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007482 seq_printf(seq, "Personalities : ");
7483 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08007484 list_for_each_entry(pers, &pers_list, list)
7485 seq_printf(seq, "[%s] ", pers->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007486
7487 spin_unlock(&pers_lock);
7488 seq_printf(seq, "\n");
Kay Sieversf1514632011-07-12 20:48:39 +02007489 seq->poll_event = atomic_read(&md_event_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007490 return 0;
7491 }
7492 if (v == (void*)2) {
7493 status_unused(seq);
7494 return 0;
7495 }
7496
NeilBrown36d091f2014-12-15 12:56:58 +11007497 spin_lock(&mddev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007498 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
7499 seq_printf(seq, "%s : %sactive", mdname(mddev),
7500 mddev->pers ? "" : "in");
7501 if (mddev->pers) {
NeilBrownf91de922005-11-08 21:39:36 -08007502 if (mddev->ro==1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007503 seq_printf(seq, " (read-only)");
NeilBrownf91de922005-11-08 21:39:36 -08007504 if (mddev->ro==2)
NeilBrown52720ae2008-03-10 11:43:47 -07007505 seq_printf(seq, " (auto-read-only)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07007506 seq_printf(seq, " %s", mddev->pers->name);
7507 }
7508
Andre Nolldd8ac332009-03-31 14:33:13 +11007509 sectors = 0;
NeilBrownf97fcad2014-12-15 12:56:59 +11007510 rcu_read_lock();
7511 rdev_for_each_rcu(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007512 char b[BDEVNAME_SIZE];
7513 seq_printf(seq, " %s[%d]",
7514 bdevname(rdev->bdev,b), rdev->desc_nr);
NeilBrown8ddf9ef2005-09-09 16:23:45 -07007515 if (test_bit(WriteMostly, &rdev->flags))
7516 seq_printf(seq, "(W)");
Shaohua Li9efdca12015-10-12 16:59:50 -07007517 if (test_bit(Journal, &rdev->flags))
7518 seq_printf(seq, "(J)");
NeilBrownb2d444d2005-11-08 21:39:31 -08007519 if (test_bit(Faulty, &rdev->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007520 seq_printf(seq, "(F)");
7521 continue;
NeilBrown2d78f8c2011-12-23 10:17:51 +11007522 }
7523 if (rdev->raid_disk < 0)
NeilBrownb325a322005-09-09 16:24:00 -07007524 seq_printf(seq, "(S)"); /* spare */
NeilBrown2d78f8c2011-12-23 10:17:51 +11007525 if (test_bit(Replacement, &rdev->flags))
7526 seq_printf(seq, "(R)");
Andre Nolldd8ac332009-03-31 14:33:13 +11007527 sectors += rdev->sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007528 }
NeilBrownf97fcad2014-12-15 12:56:59 +11007529 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07007530
7531 if (!list_empty(&mddev->disks)) {
7532 if (mddev->pers)
7533 seq_printf(seq, "\n %llu blocks",
Andre Nollf233ea52008-07-21 17:05:22 +10007534 (unsigned long long)
7535 mddev->array_sectors / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007536 else
7537 seq_printf(seq, "\n %llu blocks",
Andre Nolldd8ac332009-03-31 14:33:13 +11007538 (unsigned long long)sectors / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007539 }
NeilBrown1cd6bf12005-09-09 16:24:00 -07007540 if (mddev->persistent) {
7541 if (mddev->major_version != 0 ||
7542 mddev->minor_version != 90) {
7543 seq_printf(seq," super %d.%d",
7544 mddev->major_version,
7545 mddev->minor_version);
7546 }
NeilBrowne6910632008-02-06 01:39:51 -08007547 } else if (mddev->external)
7548 seq_printf(seq, " super external:%s",
7549 mddev->metadata_type);
7550 else
NeilBrown1cd6bf12005-09-09 16:24:00 -07007551 seq_printf(seq, " super non-persistent");
Linus Torvalds1da177e2005-04-16 15:20:36 -07007552
7553 if (mddev->pers) {
NeilBrownd710e132008-10-13 11:55:12 +11007554 mddev->pers->status(seq, mddev);
NeilBrownf72ffdd2014-09-30 14:23:59 +10007555 seq_printf(seq, "\n ");
NeilBrown8e1b39d2005-11-08 21:39:41 -08007556 if (mddev->pers->sync_request) {
NeilBrownf7851be2015-07-02 17:12:58 +10007557 if (status_resync(seq, mddev))
NeilBrown8e1b39d2005-11-08 21:39:41 -08007558 seq_printf(seq, "\n ");
NeilBrown8e1b39d2005-11-08 21:39:41 -08007559 }
NeilBrown32a76272005-06-21 17:17:14 -07007560 } else
7561 seq_printf(seq, "\n ");
7562
NeilBrown57148962012-03-19 12:46:40 +11007563 bitmap_status(seq, mddev->bitmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007564
7565 seq_printf(seq, "\n");
7566 }
NeilBrown36d091f2014-12-15 12:56:58 +11007567 spin_unlock(&mddev->lock);
NeilBrownf72ffdd2014-09-30 14:23:59 +10007568
Linus Torvalds1da177e2005-04-16 15:20:36 -07007569 return 0;
7570}
7571
Jan Engelhardt110518b2009-05-07 12:49:37 +10007572static const struct seq_operations md_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007573 .start = md_seq_start,
7574 .next = md_seq_next,
7575 .stop = md_seq_stop,
7576 .show = md_seq_show,
7577};
7578
7579static int md_seq_open(struct inode *inode, struct file *file)
7580{
Kay Sieversf1514632011-07-12 20:48:39 +02007581 struct seq_file *seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007582 int error;
7583
7584 error = seq_open(file, &md_seq_ops);
NeilBrownd7603b72006-01-06 00:20:30 -08007585 if (error)
Kay Sieversf1514632011-07-12 20:48:39 +02007586 return error;
7587
7588 seq = file->private_data;
7589 seq->poll_event = atomic_read(&md_event_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007590 return error;
7591}
7592
NeilBrowne2f23b62014-04-09 14:33:51 +10007593static int md_unloading;
NeilBrownd7603b72006-01-06 00:20:30 -08007594static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
7595{
Kay Sieversf1514632011-07-12 20:48:39 +02007596 struct seq_file *seq = filp->private_data;
NeilBrownd7603b72006-01-06 00:20:30 -08007597 int mask;
7598
NeilBrowne2f23b62014-04-09 14:33:51 +10007599 if (md_unloading)
kbuild test robot7d7e64f2014-12-03 16:07:59 +11007600 return POLLIN|POLLRDNORM|POLLERR|POLLPRI;
NeilBrownd7603b72006-01-06 00:20:30 -08007601 poll_wait(filp, &md_event_waiters, wait);
7602
7603 /* always allow read */
7604 mask = POLLIN | POLLRDNORM;
7605
Kay Sieversf1514632011-07-12 20:48:39 +02007606 if (seq->poll_event != atomic_read(&md_event_count))
NeilBrownd7603b72006-01-06 00:20:30 -08007607 mask |= POLLERR | POLLPRI;
7608 return mask;
7609}
7610
Arjan van de Venfa027c22007-02-12 00:55:33 -08007611static const struct file_operations md_seq_fops = {
Akinobu Mitae24650c2006-10-17 00:09:38 -07007612 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07007613 .open = md_seq_open,
7614 .read = seq_read,
7615 .llseek = seq_lseek,
Martin Peschkec3f94b402007-05-09 02:35:35 -07007616 .release = seq_release_private,
NeilBrownd7603b72006-01-06 00:20:30 -08007617 .poll = mdstat_poll,
Linus Torvalds1da177e2005-04-16 15:20:36 -07007618};
7619
NeilBrown84fc4b52011-10-11 16:49:58 +11007620int register_md_personality(struct md_personality *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007621{
Chao Yu50bd3772014-09-25 15:28:34 +08007622 printk(KERN_INFO "md: %s personality registered for level %d\n",
7623 p->name, p->level);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007624 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08007625 list_add_tail(&p->list, &pers_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007626 spin_unlock(&pers_lock);
7627 return 0;
7628}
NeilBrown6c144d32014-09-30 16:15:38 +10007629EXPORT_SYMBOL(register_md_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007630
NeilBrown84fc4b52011-10-11 16:49:58 +11007631int unregister_md_personality(struct md_personality *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007632{
NeilBrown2604b702006-01-06 00:20:36 -08007633 printk(KERN_INFO "md: %s personality unregistered\n", p->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007634 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08007635 list_del_init(&p->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007636 spin_unlock(&pers_lock);
7637 return 0;
7638}
NeilBrown6c144d32014-09-30 16:15:38 +10007639EXPORT_SYMBOL(unregister_md_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007640
NeilBrown6022e752015-08-13 12:32:55 +10007641int register_md_cluster_operations(struct md_cluster_operations *ops,
7642 struct module *module)
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007643{
NeilBrown6022e752015-08-13 12:32:55 +10007644 int ret = 0;
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007645 spin_lock(&pers_lock);
NeilBrown6022e752015-08-13 12:32:55 +10007646 if (md_cluster_ops != NULL)
7647 ret = -EALREADY;
7648 else {
7649 md_cluster_ops = ops;
7650 md_cluster_mod = module;
7651 }
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007652 spin_unlock(&pers_lock);
NeilBrown6022e752015-08-13 12:32:55 +10007653 return ret;
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007654}
7655EXPORT_SYMBOL(register_md_cluster_operations);
7656
7657int unregister_md_cluster_operations(void)
7658{
7659 spin_lock(&pers_lock);
7660 md_cluster_ops = NULL;
7661 spin_unlock(&pers_lock);
7662 return 0;
7663}
7664EXPORT_SYMBOL(unregister_md_cluster_operations);
7665
7666int md_setup_cluster(struct mddev *mddev, int nodes)
7667{
Guoqing Jiang47a7b0d2016-09-04 22:17:28 -04007668 if (!md_cluster_ops)
7669 request_module("md-cluster");
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007670 spin_lock(&pers_lock);
Guoqing Jiang47a7b0d2016-09-04 22:17:28 -04007671 /* ensure module won't be unloaded */
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007672 if (!md_cluster_ops || !try_module_get(md_cluster_mod)) {
Guoqing Jiang47a7b0d2016-09-04 22:17:28 -04007673 pr_err("can't find md-cluster module or get it's reference.\n");
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007674 spin_unlock(&pers_lock);
7675 return -ENOENT;
7676 }
7677 spin_unlock(&pers_lock);
7678
Goldwyn Rodriguescf921cc2014-03-30 00:42:49 -05007679 return md_cluster_ops->join(mddev, nodes);
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007680}
7681
7682void md_cluster_stop(struct mddev *mddev)
7683{
Goldwyn Rodriguesc4ce8672014-03-29 10:20:02 -05007684 if (!md_cluster_ops)
7685 return;
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007686 md_cluster_ops->leave(mddev);
7687 module_put(md_cluster_mod);
7688}
7689
NeilBrownfd01b882011-10-11 16:47:53 +11007690static int is_mddev_idle(struct mddev *mddev, int init)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007691{
NeilBrownf72ffdd2014-09-30 14:23:59 +10007692 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007693 int idle;
NeilBrowneea1bf32009-03-31 14:27:02 +11007694 int curr_events;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007695
7696 idle = 1;
NeilBrown4b809912008-07-21 17:05:25 +10007697 rcu_read_lock();
7698 rdev_for_each_rcu(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007699 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
NeilBrowneea1bf32009-03-31 14:27:02 +11007700 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
7701 (int)part_stat_read(&disk->part0, sectors[1]) -
7702 atomic_read(&disk->sync_io);
NeilBrown713f6ab2007-07-17 04:06:12 -07007703 /* sync IO will cause sync_io to increase before the disk_stats
7704 * as sync_io is counted when a request starts, and
7705 * disk_stats is counted when it completes.
7706 * So resync activity will cause curr_events to be smaller than
7707 * when there was no such activity.
7708 * non-sync IO will cause disk_stat to increase without
7709 * increasing sync_io so curr_events will (eventually)
7710 * be larger than it was before. Once it becomes
7711 * substantially larger, the test below will cause
7712 * the array to appear non-idle, and resync will slow
7713 * down.
7714 * If there is a lot of outstanding resync activity when
7715 * we set last_event to curr_events, then all that activity
7716 * completing might cause the array to appear non-idle
7717 * and resync will be slowed down even though there might
7718 * not have been non-resync activity. This will only
7719 * happen once though. 'last_events' will soon reflect
7720 * the state where there is little or no outstanding
7721 * resync requests, and further resync activity will
7722 * always make curr_events less than last_events.
NeilBrownc0e48522005-11-18 01:11:01 -08007723 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07007724 */
NeilBrowneea1bf32009-03-31 14:27:02 +11007725 if (init || curr_events - rdev->last_events > 64) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007726 rdev->last_events = curr_events;
7727 idle = 0;
7728 }
7729 }
NeilBrown4b809912008-07-21 17:05:25 +10007730 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07007731 return idle;
7732}
7733
NeilBrownfd01b882011-10-11 16:47:53 +11007734void md_done_sync(struct mddev *mddev, int blocks, int ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007735{
7736 /* another "blocks" (512byte) blocks have been synced */
7737 atomic_sub(blocks, &mddev->recovery_active);
7738 wake_up(&mddev->recovery_wait);
7739 if (!ok) {
NeilBrowndfc70642008-05-23 13:04:39 -07007740 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
majianpeng0a19caa2012-11-19 19:57:34 +08007741 set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007742 md_wakeup_thread(mddev->thread);
7743 // stop recovery, signal do_sync ....
7744 }
7745}
NeilBrown6c144d32014-09-30 16:15:38 +10007746EXPORT_SYMBOL(md_done_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007747
NeilBrown06d91a52005-06-21 17:17:12 -07007748/* md_write_start(mddev, bi)
7749 * If we need to update some array metadata (e.g. 'active' flag
NeilBrown3d310eb2005-06-21 17:17:26 -07007750 * in superblock) before writing, schedule a superblock update
7751 * and wait for it to complete.
NeilBrown06d91a52005-06-21 17:17:12 -07007752 */
NeilBrownfd01b882011-10-11 16:47:53 +11007753void md_write_start(struct mddev *mddev, struct bio *bi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007754{
Neil Brown0fd62b82008-06-28 08:31:36 +10007755 int did_change = 0;
NeilBrown06d91a52005-06-21 17:17:12 -07007756 if (bio_data_dir(bi) != WRITE)
NeilBrown3d310eb2005-06-21 17:17:26 -07007757 return;
NeilBrown06d91a52005-06-21 17:17:12 -07007758
NeilBrownf91de922005-11-08 21:39:36 -08007759 BUG_ON(mddev->ro == 1);
7760 if (mddev->ro == 2) {
7761 /* need to switch to read/write */
7762 mddev->ro = 0;
7763 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7764 md_wakeup_thread(mddev->thread);
NeilBrown25156192008-03-04 14:29:32 -08007765 md_wakeup_thread(mddev->sync_thread);
Neil Brown0fd62b82008-06-28 08:31:36 +10007766 did_change = 1;
NeilBrownf91de922005-11-08 21:39:36 -08007767 }
NeilBrown06d91a52005-06-21 17:17:12 -07007768 atomic_inc(&mddev->writes_pending);
NeilBrown31a59e32008-04-30 00:52:30 -07007769 if (mddev->safemode == 1)
7770 mddev->safemode = 0;
NeilBrown06d91a52005-06-21 17:17:12 -07007771 if (mddev->in_sync) {
NeilBrown85572d72014-12-15 12:56:56 +11007772 spin_lock(&mddev->lock);
NeilBrown3d310eb2005-06-21 17:17:26 -07007773 if (mddev->in_sync) {
7774 mddev->in_sync = 0;
NeilBrown850b2b42006-10-03 01:15:46 -07007775 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown070dc6d2010-08-30 17:33:34 +10007776 set_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrown3d310eb2005-06-21 17:17:26 -07007777 md_wakeup_thread(mddev->thread);
Neil Brown0fd62b82008-06-28 08:31:36 +10007778 did_change = 1;
NeilBrown3d310eb2005-06-21 17:17:26 -07007779 }
NeilBrown85572d72014-12-15 12:56:56 +11007780 spin_unlock(&mddev->lock);
NeilBrown06d91a52005-06-21 17:17:12 -07007781 }
Neil Brown0fd62b82008-06-28 08:31:36 +10007782 if (did_change)
NeilBrown00bcb4a2010-06-01 19:37:23 +10007783 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown09a44cc2008-05-23 13:04:36 -07007784 wait_event(mddev->sb_wait,
NeilBrown09a44cc2008-05-23 13:04:36 -07007785 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07007786}
NeilBrown6c144d32014-09-30 16:15:38 +10007787EXPORT_SYMBOL(md_write_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007788
NeilBrownfd01b882011-10-11 16:47:53 +11007789void md_write_end(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007790{
7791 if (atomic_dec_and_test(&mddev->writes_pending)) {
7792 if (mddev->safemode == 2)
7793 md_wakeup_thread(mddev->thread);
NeilBrown16f17b32006-06-26 00:27:37 -07007794 else if (mddev->safemode_delay)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007795 mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
7796 }
7797}
NeilBrown6c144d32014-09-30 16:15:38 +10007798EXPORT_SYMBOL(md_write_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007799
NeilBrown2a2275d2007-01-26 00:57:11 -08007800/* md_allow_write(mddev)
7801 * Calling this ensures that the array is marked 'active' so that writes
7802 * may proceed without blocking. It is important to call this before
7803 * attempting a GFP_KERNEL allocation while holding the mddev lock.
7804 * Must be called with mddev_lock held.
Dan Williamsb5470dc2008-06-27 21:44:04 -07007805 *
Guoqing Jiangabf35082015-12-21 10:51:01 +11007806 * In the ->external case MD_CHANGE_PENDING can not be cleared until mddev->lock
Dan Williamsb5470dc2008-06-27 21:44:04 -07007807 * is dropped, so return -EAGAIN after notifying userspace.
NeilBrown2a2275d2007-01-26 00:57:11 -08007808 */
NeilBrownfd01b882011-10-11 16:47:53 +11007809int md_allow_write(struct mddev *mddev)
NeilBrown2a2275d2007-01-26 00:57:11 -08007810{
7811 if (!mddev->pers)
Dan Williamsb5470dc2008-06-27 21:44:04 -07007812 return 0;
NeilBrown2a2275d2007-01-26 00:57:11 -08007813 if (mddev->ro)
Dan Williamsb5470dc2008-06-27 21:44:04 -07007814 return 0;
Neil Brown1a0fd492008-06-28 08:31:27 +10007815 if (!mddev->pers->sync_request)
Dan Williamsb5470dc2008-06-27 21:44:04 -07007816 return 0;
NeilBrown2a2275d2007-01-26 00:57:11 -08007817
NeilBrown85572d72014-12-15 12:56:56 +11007818 spin_lock(&mddev->lock);
NeilBrown2a2275d2007-01-26 00:57:11 -08007819 if (mddev->in_sync) {
7820 mddev->in_sync = 0;
7821 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown070dc6d2010-08-30 17:33:34 +10007822 set_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrown2a2275d2007-01-26 00:57:11 -08007823 if (mddev->safemode_delay &&
7824 mddev->safemode == 0)
7825 mddev->safemode = 1;
NeilBrown85572d72014-12-15 12:56:56 +11007826 spin_unlock(&mddev->lock);
NeilBrown2a2275d2007-01-26 00:57:11 -08007827 md_update_sb(mddev, 0);
NeilBrown00bcb4a2010-06-01 19:37:23 +10007828 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown2a2275d2007-01-26 00:57:11 -08007829 } else
NeilBrown85572d72014-12-15 12:56:56 +11007830 spin_unlock(&mddev->lock);
Dan Williamsb5470dc2008-06-27 21:44:04 -07007831
NeilBrown070dc6d2010-08-30 17:33:34 +10007832 if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
Dan Williamsb5470dc2008-06-27 21:44:04 -07007833 return -EAGAIN;
7834 else
7835 return 0;
NeilBrown2a2275d2007-01-26 00:57:11 -08007836}
7837EXPORT_SYMBOL_GPL(md_allow_write);
7838
Linus Torvalds1da177e2005-04-16 15:20:36 -07007839#define SYNC_MARKS 10
7840#define SYNC_MARK_STEP (3*HZ)
majianpeng54f89342012-10-31 11:59:10 +11007841#define UPDATE_FREQUENCY (5*60*HZ)
Shaohua Li4ed87312012-10-11 13:34:00 +11007842void md_do_sync(struct md_thread *thread)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007843{
Shaohua Li4ed87312012-10-11 13:34:00 +11007844 struct mddev *mddev = thread->mddev;
NeilBrownfd01b882011-10-11 16:47:53 +11007845 struct mddev *mddev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007846 unsigned int currspeed = 0,
7847 window;
Xiao Niac7e50a2014-08-07 09:37:41 -04007848 sector_t max_sectors,j, io_sectors, recovery_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007849 unsigned long mark[SYNC_MARKS];
majianpeng54f89342012-10-31 11:59:10 +11007850 unsigned long update_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007851 sector_t mark_cnt[SYNC_MARKS];
7852 int last_mark,m;
7853 struct list_head *tmp;
7854 sector_t last_check;
NeilBrown57afd892005-06-21 17:17:13 -07007855 int skipped = 0;
NeilBrown3cb03002011-10-11 16:45:26 +11007856 struct md_rdev *rdev;
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007857 char *desc, *action = NULL;
majianpeng7c2c57c2012-07-03 12:12:26 +10007858 struct blk_plug plug;
Guoqing Jiang41a9a0d2016-05-02 11:33:08 -04007859 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007860
7861 /* just incase thread restarts... */
7862 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7863 return;
NeilBrown3991b312014-05-28 13:39:23 +10007864 if (mddev->ro) {/* never try to sync a read-only array */
7865 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007866 return;
NeilBrown3991b312014-05-28 13:39:23 +10007867 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007868
Guoqing Jiang41a9a0d2016-05-02 11:33:08 -04007869 if (mddev_is_clustered(mddev)) {
7870 ret = md_cluster_ops->resync_start(mddev);
7871 if (ret)
7872 goto skip;
7873
Guoqing Jiangbb8bf152016-06-02 23:32:04 -04007874 set_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags);
Guoqing Jiang41a9a0d2016-05-02 11:33:08 -04007875 if (!(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
7876 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ||
7877 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
7878 && ((unsigned long long)mddev->curr_resync_completed
7879 < (unsigned long long)mddev->resync_max_sectors))
7880 goto skip;
7881 }
7882
NeilBrown61df9d92006-10-03 01:15:57 -07007883 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007884 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
NeilBrown61df9d92006-10-03 01:15:57 -07007885 desc = "data-check";
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007886 action = "check";
7887 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
NeilBrown61df9d92006-10-03 01:15:57 -07007888 desc = "requested-resync";
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007889 action = "repair";
7890 } else
NeilBrown61df9d92006-10-03 01:15:57 -07007891 desc = "resync";
7892 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7893 desc = "reshape";
7894 else
7895 desc = "recovery";
7896
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007897 mddev->last_sync_action = action ?: desc;
7898
Linus Torvalds1da177e2005-04-16 15:20:36 -07007899 /* we overload curr_resync somewhat here.
7900 * 0 == not engaged in resync at all
7901 * 2 == checking that there is no conflict with another sync
7902 * 1 == like 2, but have yielded to allow conflicting resync to
7903 * commense
7904 * other == active in resync - this many blocks
7905 *
7906 * Before starting a resync we must have set curr_resync to
7907 * 2, and then checked that every "conflicting" array has curr_resync
7908 * less than ours. When we find one that is the same or higher
7909 * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
7910 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
7911 * This will mean we have to start checking from the beginning again.
7912 *
7913 */
7914
7915 do {
Artur Paszkiewiczc622ca52016-08-16 14:26:08 +02007916 int mddev2_minor = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007917 mddev->curr_resync = 2;
7918
7919 try_again:
NeilBrown404e4b42009-12-30 15:25:23 +11007920 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
Linus Torvalds1da177e2005-04-16 15:20:36 -07007921 goto skip;
NeilBrown29ac4aa2008-02-06 01:39:58 -08007922 for_each_mddev(mddev2, tmp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007923 if (mddev2 == mddev)
7924 continue;
Bernd Schubert90b08712008-05-23 13:04:38 -07007925 if (!mddev->parallel_resync
7926 && mddev2->curr_resync
7927 && match_mddev_units(mddev, mddev2)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007928 DEFINE_WAIT(wq);
7929 if (mddev < mddev2 && mddev->curr_resync == 2) {
7930 /* arbitrarily yield */
7931 mddev->curr_resync = 1;
7932 wake_up(&resync_wait);
7933 }
7934 if (mddev > mddev2 && mddev->curr_resync == 1)
7935 /* no need to wait here, we can wait the next
7936 * time 'round when curr_resync == 2
7937 */
7938 continue;
NeilBrown97441972008-09-19 11:49:54 +10007939 /* We need to wait 'interruptible' so as not to
7940 * contribute to the load average, and not to
7941 * be caught by 'softlockup'
7942 */
7943 prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
NeilBrownc91abf52013-11-19 12:02:01 +11007944 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
NeilBrown8712e552005-10-26 01:58:58 -07007945 mddev2->curr_resync >= mddev->curr_resync) {
Artur Paszkiewiczc622ca52016-08-16 14:26:08 +02007946 if (mddev2_minor != mddev2->md_minor) {
7947 mddev2_minor = mddev2->md_minor;
7948 printk(KERN_INFO "md: delaying %s of %s"
7949 " until %s has finished (they"
7950 " share one or more physical units)\n",
7951 desc, mdname(mddev),
7952 mdname(mddev2));
7953 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007954 mddev_put(mddev2);
NeilBrown97441972008-09-19 11:49:54 +10007955 if (signal_pending(current))
7956 flush_signals(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007957 schedule();
7958 finish_wait(&resync_wait, &wq);
7959 goto try_again;
7960 }
7961 finish_wait(&resync_wait, &wq);
7962 }
7963 }
7964 } while (mddev->curr_resync < 2);
7965
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007966 j = 0;
NeilBrown9d888832005-11-08 21:39:26 -08007967 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007968 /* resync follows the size requested by the personality,
NeilBrown57afd892005-06-21 17:17:13 -07007969 * which defaults to physical size, but can be virtual size
Linus Torvalds1da177e2005-04-16 15:20:36 -07007970 */
7971 max_sectors = mddev->resync_max_sectors;
Jianpeng Ma7f7583d2012-10-11 14:17:59 +11007972 atomic64_set(&mddev->resync_mismatches, 0);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007973 /* we don't use the checkpoint if there's a bitmap */
Neil Brown5e96ee62008-06-28 08:31:24 +10007974 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7975 j = mddev->resync_min;
7976 else if (!mddev->bitmap)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007977 j = mddev->recovery_cp;
Neil Brown5e96ee62008-06-28 08:31:24 +10007978
NeilBrownccfcc3c2006-03-27 01:18:09 -08007979 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
NeilBrownc804cde2012-05-21 09:28:33 +10007980 max_sectors = mddev->resync_max_sectors;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007981 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007982 /* recovery follows the physical size of devices */
Andre Noll58c0fed2009-03-31 14:33:13 +11007983 max_sectors = mddev->dev_sectors;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007984 j = MaxSector;
Dan Williams4e59ca72009-12-12 21:17:06 -07007985 rcu_read_lock();
NeilBrowndafb20f2012-03-19 12:46:39 +11007986 rdev_for_each_rcu(rdev, mddev)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007987 if (rdev->raid_disk >= 0 &&
Shaohua Lif2076e72015-10-08 21:54:12 -07007988 !test_bit(Journal, &rdev->flags) &&
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007989 !test_bit(Faulty, &rdev->flags) &&
7990 !test_bit(In_sync, &rdev->flags) &&
7991 rdev->recovery_offset < j)
7992 j = rdev->recovery_offset;
Dan Williams4e59ca72009-12-12 21:17:06 -07007993 rcu_read_unlock();
NeilBrown133d4522014-07-02 12:04:14 +10007994
7995 /* If there is a bitmap, we need to make sure all
7996 * writes that started before we added a spare
7997 * complete before we start doing a recovery.
7998 * Otherwise the write might complete and (via
7999 * bitmap_endwrite) set a bit in the bitmap after the
8000 * recovery has checked that bit and skipped that
8001 * region.
8002 */
8003 if (mddev->bitmap) {
8004 mddev->pers->quiesce(mddev, 1);
8005 mddev->pers->quiesce(mddev, 0);
8006 }
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008007 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07008008
NeilBrown61df9d92006-10-03 01:15:57 -07008009 printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
8010 printk(KERN_INFO "md: minimum _guaranteed_ speed:"
8011 " %d KB/sec/disk.\n", speed_min(mddev));
Adrian Bunk338cec32005-09-10 00:26:54 -07008012 printk(KERN_INFO "md: using maximum available idle IO bandwidth "
NeilBrown61df9d92006-10-03 01:15:57 -07008013 "(but not more than %d KB/sec) for %s.\n",
8014 speed_max(mddev), desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008015
NeilBrowneea1bf32009-03-31 14:27:02 +11008016 is_mddev_idle(mddev, 1); /* this initializes IO event counters */
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008017
NeilBrown57afd892005-06-21 17:17:13 -07008018 io_sectors = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008019 for (m = 0; m < SYNC_MARKS; m++) {
8020 mark[m] = jiffies;
NeilBrown57afd892005-06-21 17:17:13 -07008021 mark_cnt[m] = io_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008022 }
8023 last_mark = 0;
8024 mddev->resync_mark = mark[last_mark];
8025 mddev->resync_mark_cnt = mark_cnt[last_mark];
8026
8027 /*
8028 * Tune reconstruction:
8029 */
8030 window = 32*(PAGE_SIZE/512);
Jonathan Brassowac424502011-06-07 17:48:35 -05008031 printk(KERN_INFO "md: using %dk window, over a total of %lluk.\n",
8032 window/2, (unsigned long long)max_sectors/2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008033
8034 atomic_set(&mddev->recovery_active, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008035 last_check = 0;
8036
8037 if (j>2) {
NeilBrownc91abf52013-11-19 12:02:01 +11008038 printk(KERN_INFO
NeilBrown61df9d92006-10-03 01:15:57 -07008039 "md: resuming %s of %s from checkpoint.\n",
8040 desc, mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07008041 mddev->curr_resync = j;
NeilBrown72f36d52012-10-11 14:25:57 +11008042 } else
8043 mddev->curr_resync = 3; /* no longer delayed */
NeilBrown75d3da42011-01-14 09:14:34 +11008044 mddev->curr_resync_completed = j;
NeilBrown72f36d52012-10-11 14:25:57 +11008045 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
8046 md_new_event(mddev);
majianpeng54f89342012-10-31 11:59:10 +11008047 update_time = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008048
majianpeng7c2c57c2012-07-03 12:12:26 +10008049 blk_start_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008050 while (j < max_sectors) {
NeilBrown57afd892005-06-21 17:17:13 -07008051 sector_t sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008052
NeilBrown57afd892005-06-21 17:17:13 -07008053 skipped = 0;
NeilBrown97e4f422009-03-31 14:33:13 +11008054
NeilBrown7a91ee12009-05-26 12:57:21 +10008055 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8056 ((mddev->curr_resync > mddev->curr_resync_completed &&
8057 (mddev->curr_resync - mddev->curr_resync_completed)
8058 > (max_sectors >> 4)) ||
majianpeng54f89342012-10-31 11:59:10 +11008059 time_after_eq(jiffies, update_time + UPDATE_FREQUENCY) ||
NeilBrown7a91ee12009-05-26 12:57:21 +10008060 (j - mddev->curr_resync_completed)*2
NeilBrownc5e19d92015-07-17 12:06:02 +10008061 >= mddev->resync_max - mddev->curr_resync_completed ||
8062 mddev->curr_resync_completed > mddev->resync_max
NeilBrown7a91ee12009-05-26 12:57:21 +10008063 )) {
NeilBrown97e4f422009-03-31 14:33:13 +11008064 /* time to update curr_resync_completed */
NeilBrown97e4f422009-03-31 14:33:13 +11008065 wait_event(mddev->recovery_wait,
8066 atomic_read(&mddev->recovery_active) == 0);
NeilBrown75d3da42011-01-14 09:14:34 +11008067 mddev->curr_resync_completed = j;
kernelmail35d78c62012-10-31 11:59:10 +11008068 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
8069 j > mddev->recovery_cp)
8070 mddev->recovery_cp = j;
majianpeng54f89342012-10-31 11:59:10 +11008071 update_time = jiffies;
NeilBrown070dc6d2010-08-30 17:33:34 +10008072 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrownacb180b2009-04-14 16:28:34 +10008073 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
NeilBrown97e4f422009-03-31 14:33:13 +11008074 }
NeilBrownacb180b2009-04-14 16:28:34 +10008075
NeilBrownc91abf52013-11-19 12:02:01 +11008076 while (j >= mddev->resync_max &&
8077 !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
NeilBrowne62e58a2009-07-01 13:15:35 +10008078 /* As this condition is controlled by user-space,
8079 * we can block indefinitely, so use '_interruptible'
8080 * to avoid triggering warnings.
8081 */
8082 flush_signals(current); /* just in case */
8083 wait_event_interruptible(mddev->recovery_wait,
8084 mddev->resync_max > j
NeilBrownc91abf52013-11-19 12:02:01 +11008085 || test_bit(MD_RECOVERY_INTR,
8086 &mddev->recovery));
NeilBrowne62e58a2009-07-01 13:15:35 +10008087 }
NeilBrownacb180b2009-04-14 16:28:34 +10008088
NeilBrownc91abf52013-11-19 12:02:01 +11008089 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8090 break;
NeilBrownacb180b2009-04-14 16:28:34 +10008091
NeilBrown09314792015-02-19 16:04:40 +11008092 sectors = mddev->pers->sync_request(mddev, j, &skipped);
NeilBrown57afd892005-06-21 17:17:13 -07008093 if (sectors == 0) {
NeilBrowndfc70642008-05-23 13:04:39 -07008094 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrownc91abf52013-11-19 12:02:01 +11008095 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008096 }
NeilBrown57afd892005-06-21 17:17:13 -07008097
8098 if (!skipped) { /* actual IO requested */
8099 io_sectors += sectors;
8100 atomic_add(sectors, &mddev->recovery_active);
8101 }
8102
NeilBrowne875ece2011-07-28 11:39:24 +10008103 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8104 break;
8105
Linus Torvalds1da177e2005-04-16 15:20:36 -07008106 j += sectors;
NeilBrown5ed1df22015-07-24 13:27:08 +10008107 if (j > max_sectors)
8108 /* when skipping, extra large numbers can be returned. */
8109 j = max_sectors;
NeilBrown72f36d52012-10-11 14:25:57 +11008110 if (j > 2)
8111 mddev->curr_resync = j;
NeilBrownff4e8d92006-07-10 04:44:16 -07008112 mddev->curr_mark_cnt = io_sectors;
NeilBrownd7603b72006-01-06 00:20:30 -08008113 if (last_check == 0)
NeilBrowne875ece2011-07-28 11:39:24 +10008114 /* this is the earliest that rebuild will be
NeilBrownd7603b72006-01-06 00:20:30 -08008115 * visible in /proc/mdstat
8116 */
8117 md_new_event(mddev);
NeilBrown57afd892005-06-21 17:17:13 -07008118
8119 if (last_check + window > io_sectors || j == max_sectors)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008120 continue;
8121
NeilBrown57afd892005-06-21 17:17:13 -07008122 last_check = io_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008123 repeat:
8124 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
8125 /* step marks */
8126 int next = (last_mark+1) % SYNC_MARKS;
8127
8128 mddev->resync_mark = mark[next];
8129 mddev->resync_mark_cnt = mark_cnt[next];
8130 mark[next] = jiffies;
NeilBrown57afd892005-06-21 17:17:13 -07008131 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008132 last_mark = next;
8133 }
8134
NeilBrownc91abf52013-11-19 12:02:01 +11008135 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8136 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008137
8138 /*
8139 * this loop exits only if either when we are slower than
8140 * the 'hard' speed limit, or the system was IO-idle for
8141 * a jiffy.
8142 * the system might be non-idle CPU-wise, but we only care
8143 * about not overloading the IO subsystem. (things like an
8144 * e2fsck being done on the RAID array should execute fast)
8145 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07008146 cond_resched();
8147
Xiao Niac7e50a2014-08-07 09:37:41 -04008148 recovery_done = io_sectors - atomic_read(&mddev->recovery_active);
8149 currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2
NeilBrown57afd892005-06-21 17:17:13 -07008150 /((jiffies-mddev->resync_mark)/HZ +1) +1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008151
NeilBrown88202a02006-01-06 00:21:36 -08008152 if (currspeed > speed_min(mddev)) {
NeilBrownac8fa412015-02-19 16:55:00 +11008153 if (currspeed > speed_max(mddev)) {
NeilBrownc0e48522005-11-18 01:11:01 -08008154 msleep(500);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008155 goto repeat;
8156 }
NeilBrownac8fa412015-02-19 16:55:00 +11008157 if (!is_mddev_idle(mddev, 0)) {
8158 /*
8159 * Give other IO more of a chance.
8160 * The faster the devices, the less we wait.
8161 */
8162 wait_event(mddev->recovery_wait,
8163 !atomic_read(&mddev->recovery_active));
8164 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07008165 }
8166 }
NeilBrownc91abf52013-11-19 12:02:01 +11008167 printk(KERN_INFO "md: %s: %s %s.\n",mdname(mddev), desc,
8168 test_bit(MD_RECOVERY_INTR, &mddev->recovery)
8169 ? "interrupted" : "done");
Linus Torvalds1da177e2005-04-16 15:20:36 -07008170 /*
8171 * this also signals 'finished resyncing' to md_stop
8172 */
majianpeng7c2c57c2012-07-03 12:12:26 +10008173 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008174 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
8175
NeilBrown5ed1df22015-07-24 13:27:08 +10008176 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8177 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
NeilBrown1217e1d2016-10-28 15:59:41 +11008178 mddev->curr_resync > 3) {
NeilBrown5ed1df22015-07-24 13:27:08 +10008179 mddev->curr_resync_completed = mddev->curr_resync;
8180 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
8181 }
NeilBrown09314792015-02-19 16:04:40 +11008182 mddev->pers->sync_request(mddev, max_sectors, &skipped);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008183
NeilBrowndfc70642008-05-23 13:04:39 -07008184 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
NeilBrown1217e1d2016-10-28 15:59:41 +11008185 mddev->curr_resync > 3) {
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008186 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8187 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8188 if (mddev->curr_resync >= mddev->recovery_cp) {
8189 printk(KERN_INFO
NeilBrown61df9d92006-10-03 01:15:57 -07008190 "md: checkpointing %s of %s.\n",
8191 desc, mdname(mddev));
majianpeng0a19caa2012-11-19 19:57:34 +08008192 if (test_bit(MD_RECOVERY_ERROR,
8193 &mddev->recovery))
8194 mddev->recovery_cp =
8195 mddev->curr_resync_completed;
8196 else
8197 mddev->recovery_cp =
8198 mddev->curr_resync;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008199 }
8200 } else
8201 mddev->recovery_cp = MaxSector;
8202 } else {
8203 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8204 mddev->curr_resync = MaxSector;
Dan Williams4e59ca72009-12-12 21:17:06 -07008205 rcu_read_lock();
NeilBrowndafb20f2012-03-19 12:46:39 +11008206 rdev_for_each_rcu(rdev, mddev)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008207 if (rdev->raid_disk >= 0 &&
NeilBrown70fffd02010-06-16 17:01:25 +10008208 mddev->delta_disks >= 0 &&
Shaohua Lif2076e72015-10-08 21:54:12 -07008209 !test_bit(Journal, &rdev->flags) &&
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008210 !test_bit(Faulty, &rdev->flags) &&
8211 !test_bit(In_sync, &rdev->flags) &&
8212 rdev->recovery_offset < mddev->curr_resync)
8213 rdev->recovery_offset = mddev->curr_resync;
Dan Williams4e59ca72009-12-12 21:17:06 -07008214 rcu_read_unlock();
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008215 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07008216 }
NeilBrowndb91ff52012-02-07 12:01:51 +11008217 skip:
Guoqing Jiangbb8bf152016-06-02 23:32:04 -04008218 /* set CHANGE_PENDING here since maybe another update is needed,
8219 * so other nodes are informed. It should be harmless for normal
8220 * raid */
8221 set_mask_bits(&mddev->flags, 0,
8222 BIT(MD_CHANGE_PENDING) | BIT(MD_CHANGE_DEVS));
Goldwyn Rodriguesc186b122015-09-30 13:20:35 -05008223
BingJing Chang547f11f2018-02-22 13:34:46 +08008224 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8225 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8226 mddev->delta_disks > 0 &&
8227 mddev->pers->finish_reshape &&
8228 mddev->pers->size &&
8229 mddev->queue) {
8230 mddev_lock_nointr(mddev);
8231 md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0));
8232 mddev_unlock(mddev);
8233 set_capacity(mddev->gendisk, mddev->array_sectors);
8234 revalidate_disk(mddev->gendisk);
8235 }
8236
NeilBrown23da4222014-12-15 12:57:01 +11008237 spin_lock(&mddev->lock);
NeilBrownc07b70a2009-12-14 12:49:48 +11008238 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8239 /* We completed so min/max setting can be forgotten if used. */
8240 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8241 mddev->resync_min = 0;
8242 mddev->resync_max = MaxSector;
8243 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8244 mddev->resync_min = mddev->curr_resync_completed;
NeilBrownf7851be2015-07-02 17:12:58 +10008245 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008246 mddev->curr_resync = 0;
NeilBrown23da4222014-12-15 12:57:01 +11008247 spin_unlock(&mddev->lock);
8248
Linus Torvalds1da177e2005-04-16 15:20:36 -07008249 wake_up(&resync_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008250 md_wakeup_thread(mddev->thread);
NeilBrownc6207272008-02-06 01:39:52 -08008251 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008252}
NeilBrown29269552006-03-27 01:18:10 -08008253EXPORT_SYMBOL_GPL(md_do_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008254
NeilBrown746d3202013-04-24 11:42:41 +10008255static int remove_and_add_spares(struct mddev *mddev,
8256 struct md_rdev *this)
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008257{
NeilBrown3cb03002011-10-11 16:45:26 +11008258 struct md_rdev *rdev;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008259 int spares = 0;
NeilBrownf2a371c2012-01-09 00:46:41 +11008260 int removed = 0;
NeilBrownd787be42016-06-02 16:19:53 +10008261 bool remove_some = false;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008262
NeilBrowneb2593f2018-02-03 09:19:30 +11008263 if (this && test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
8264 /* Mustn't remove devices when resync thread is running */
8265 return 0;
8266
NeilBrownd787be42016-06-02 16:19:53 +10008267 rdev_for_each(rdev, mddev) {
NeilBrown746d3202013-04-24 11:42:41 +10008268 if ((this == NULL || rdev == this) &&
8269 rdev->raid_disk >= 0 &&
Dan Williams6bfe0b42008-04-30 00:52:32 -07008270 !test_bit(Blocked, &rdev->flags) &&
NeilBrownd787be42016-06-02 16:19:53 +10008271 test_bit(Faulty, &rdev->flags) &&
8272 atomic_read(&rdev->nr_pending)==0) {
8273 /* Faulty non-Blocked devices with nr_pending == 0
8274 * never get nr_pending incremented,
8275 * never get Faulty cleared, and never get Blocked set.
8276 * So we can synchronize_rcu now rather than once per device
8277 */
8278 remove_some = true;
8279 set_bit(RemoveSynchronized, &rdev->flags);
8280 }
8281 }
8282
8283 if (remove_some)
8284 synchronize_rcu();
8285 rdev_for_each(rdev, mddev) {
8286 if ((this == NULL || rdev == this) &&
8287 rdev->raid_disk >= 0 &&
8288 !test_bit(Blocked, &rdev->flags) &&
8289 ((test_bit(RemoveSynchronized, &rdev->flags) ||
Shaohua Lif2076e72015-10-08 21:54:12 -07008290 (!test_bit(In_sync, &rdev->flags) &&
8291 !test_bit(Journal, &rdev->flags))) &&
NeilBrownd787be42016-06-02 16:19:53 +10008292 atomic_read(&rdev->nr_pending)==0)) {
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008293 if (mddev->pers->hot_remove_disk(
NeilBrownb8321b62011-12-23 10:17:51 +11008294 mddev, rdev) == 0) {
Namhyung Kim36fad852011-07-27 11:00:36 +10008295 sysfs_unlink_rdev(mddev, rdev);
NeilBrown48668482018-04-26 14:46:29 +10008296 rdev->saved_raid_disk = rdev->raid_disk;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008297 rdev->raid_disk = -1;
NeilBrownf2a371c2012-01-09 00:46:41 +11008298 removed++;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008299 }
8300 }
NeilBrownd787be42016-06-02 16:19:53 +10008301 if (remove_some && test_bit(RemoveSynchronized, &rdev->flags))
8302 clear_bit(RemoveSynchronized, &rdev->flags);
8303 }
8304
Jonathan Brassow90584fc2013-03-07 16:24:26 -06008305 if (removed && mddev->kobj.sd)
8306 sysfs_notify(&mddev->kobj, NULL, "degraded");
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008307
Goldwyn Rodrigues2910ff12015-09-28 10:27:26 -05008308 if (this && removed)
NeilBrown746d3202013-04-24 11:42:41 +10008309 goto no_add;
8310
NeilBrowndafb20f2012-03-19 12:46:39 +11008311 rdev_for_each(rdev, mddev) {
Goldwyn Rodrigues2910ff12015-09-28 10:27:26 -05008312 if (this && this != rdev)
8313 continue;
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05008314 if (test_bit(Candidate, &rdev->flags))
8315 continue;
NeilBrown7bfec5f2011-12-23 10:17:53 +11008316 if (rdev->raid_disk >= 0 &&
8317 !test_bit(In_sync, &rdev->flags) &&
Shaohua Lif2076e72015-10-08 21:54:12 -07008318 !test_bit(Journal, &rdev->flags) &&
NeilBrown7bfec5f2011-12-23 10:17:53 +11008319 !test_bit(Faulty, &rdev->flags))
8320 spares++;
NeilBrown7ceb17e2013-04-24 11:42:42 +10008321 if (rdev->raid_disk >= 0)
8322 continue;
8323 if (test_bit(Faulty, &rdev->flags))
8324 continue;
Shaohua Lif6b6ec52015-12-21 10:51:02 +11008325 if (!test_bit(Journal, &rdev->flags)) {
8326 if (mddev->ro &&
8327 ! (rdev->saved_raid_disk >= 0 &&
8328 !test_bit(Bitmap_sync, &rdev->flags)))
8329 continue;
NeilBrown7ceb17e2013-04-24 11:42:42 +10008330
Shaohua Lif6b6ec52015-12-21 10:51:02 +11008331 rdev->recovery_offset = 0;
8332 }
NeilBrown7ceb17e2013-04-24 11:42:42 +10008333 if (mddev->pers->
8334 hot_add_disk(mddev, rdev) == 0) {
8335 if (sysfs_link_rdev(mddev, rdev))
8336 /* failure here is OK */;
Shaohua Lif6b6ec52015-12-21 10:51:02 +11008337 if (!test_bit(Journal, &rdev->flags))
8338 spares++;
NeilBrown7ceb17e2013-04-24 11:42:42 +10008339 md_new_event(mddev);
8340 set_bit(MD_CHANGE_DEVS, &mddev->flags);
NeilBrowndfc70642008-05-23 13:04:39 -07008341 }
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008342 }
NeilBrown746d3202013-04-24 11:42:41 +10008343no_add:
NeilBrown6dafab62012-09-19 12:54:22 +10008344 if (removed)
8345 set_bit(MD_CHANGE_DEVS, &mddev->flags);
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008346 return spares;
8347}
NeilBrown7ebc0be2011-01-14 09:14:33 +11008348
NeilBrownac05f252014-09-30 08:10:42 +10008349static void md_start_sync(struct work_struct *ws)
8350{
8351 struct mddev *mddev = container_of(ws, struct mddev, del_work);
Goldwyn Rodriguesc186b122015-09-30 13:20:35 -05008352
NeilBrownac05f252014-09-30 08:10:42 +10008353 mddev->sync_thread = md_register_thread(md_do_sync,
8354 mddev,
8355 "resync");
8356 if (!mddev->sync_thread) {
Guoqing Jiang207efcd2016-08-12 13:42:40 +08008357 printk(KERN_ERR "%s: could not start resync thread...\n",
8358 mdname(mddev));
NeilBrownac05f252014-09-30 08:10:42 +10008359 /* leave the spares where they are, it shouldn't hurt */
8360 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8361 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8362 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
8363 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8364 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11008365 wake_up(&resync_wait);
NeilBrownac05f252014-09-30 08:10:42 +10008366 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
8367 &mddev->recovery))
8368 if (mddev->sysfs_action)
8369 sysfs_notify_dirent_safe(mddev->sysfs_action);
8370 } else
8371 md_wakeup_thread(mddev->sync_thread);
8372 sysfs_notify_dirent_safe(mddev->sysfs_action);
8373 md_new_event(mddev);
8374}
8375
Linus Torvalds1da177e2005-04-16 15:20:36 -07008376/*
8377 * This routine is regularly called by all per-raid-array threads to
8378 * deal with generic issues like resync and super-block update.
8379 * Raid personalities that don't have a thread (linear/raid0) do not
8380 * need this as they never do any recovery or update the superblock.
8381 *
8382 * It does not do any resync itself, but rather "forks" off other threads
8383 * to do that as needed.
8384 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
8385 * "->recovery" and create a thread at ->sync_thread.
NeilBrowndfc70642008-05-23 13:04:39 -07008386 * When the thread finishes it sets MD_RECOVERY_DONE
Linus Torvalds1da177e2005-04-16 15:20:36 -07008387 * and wakeups up this thread which will reap the thread and finish up.
8388 * This thread also removes any faulty devices (with nr_pending == 0).
8389 *
8390 * The overall approach is:
8391 * 1/ if the superblock needs updating, update it.
8392 * 2/ If a recovery thread is running, don't do anything else.
8393 * 3/ If recovery has finished, clean up, possibly marking spares active.
8394 * 4/ If there are any faulty devices, remove them.
8395 * 5/ If array is degraded, try to add spares devices
8396 * 6/ If array has spares or is not in-sync, start a resync thread.
8397 */
NeilBrownfd01b882011-10-11 16:47:53 +11008398void md_check_recovery(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008399{
Jonathan Brassow68866e42011-06-08 15:10:08 +10008400 if (mddev->suspended)
8401 return;
8402
NeilBrown5f404022005-06-21 17:17:16 -07008403 if (mddev->bitmap)
NeilBrownaa5cbd12009-12-14 12:49:46 +11008404 bitmap_daemon_work(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008405
NeilBrownfca4d842005-06-21 17:17:11 -07008406 if (signal_pending(current)) {
NeilBrown31a59e32008-04-30 00:52:30 -07008407 if (mddev->pers->sync_request && !mddev->external) {
NeilBrownfca4d842005-06-21 17:17:11 -07008408 printk(KERN_INFO "md: %s in immediate safe mode\n",
8409 mdname(mddev));
8410 mddev->safemode = 2;
8411 }
8412 flush_signals(current);
8413 }
8414
NeilBrownc89a8ee2008-08-05 15:54:13 +10008415 if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
8416 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008417 if ( ! (
NeilBrown142d44c2013-11-28 10:34:18 +11008418 (mddev->flags & MD_UPDATE_SB_FLAGS & ~ (1<<MD_CHANGE_PENDING)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07008419 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
NeilBrownfca4d842005-06-21 17:17:11 -07008420 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
Guoqing Jiang15858fa2015-12-21 10:51:00 +11008421 test_bit(MD_RELOAD_SB, &mddev->flags) ||
NeilBrown31a59e32008-04-30 00:52:30 -07008422 (mddev->external == 0 && mddev->safemode == 1) ||
NeilBrownfca4d842005-06-21 17:17:11 -07008423 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
8424 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008425 ))
8426 return;
NeilBrownfca4d842005-06-21 17:17:11 -07008427
NeilBrowndf5b89b2006-03-27 01:18:20 -08008428 if (mddev_trylock(mddev)) {
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008429 int spares = 0;
NeilBrownfca4d842005-06-21 17:17:11 -07008430
NeilBrownc89a8ee2008-08-05 15:54:13 +10008431 if (mddev->ro) {
Neil Brownab16bfc2015-06-17 12:31:46 +10008432 struct md_rdev *rdev;
8433 if (!mddev->external && mddev->in_sync)
8434 /* 'Blocked' flag not needed as failed devices
8435 * will be recorded if array switched to read/write.
8436 * Leaving it set will prevent the device
8437 * from being removed.
8438 */
8439 rdev_for_each(rdev, mddev)
8440 clear_bit(Blocked, &rdev->flags);
NeilBrown7ceb17e2013-04-24 11:42:42 +10008441 /* On a read-only array we can:
8442 * - remove failed devices
8443 * - add already-in_sync devices if the array itself
8444 * is in-sync.
8445 * As we only add devices that are already in-sync,
8446 * we can activate the spares immediately.
NeilBrownc89a8ee2008-08-05 15:54:13 +10008447 */
NeilBrown7ceb17e2013-04-24 11:42:42 +10008448 remove_and_add_spares(mddev, NULL);
NeilBrown8313b8e2013-12-12 10:13:33 +11008449 /* There is no thread, but we need to call
8450 * ->spare_active and clear saved_raid_disk
8451 */
NeilBrown2ac295a2014-05-29 11:40:03 +10008452 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrown8313b8e2013-12-12 10:13:33 +11008453 md_reap_sync_thread(mddev);
NeilBrowna4a3d262015-07-17 11:57:30 +10008454 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown8313b8e2013-12-12 10:13:33 +11008455 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
Shaohua Lid4929ad2015-09-18 10:20:12 -07008456 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrownc89a8ee2008-08-05 15:54:13 +10008457 goto unlock;
8458 }
8459
Guoqing Jiang659b2542015-12-21 10:50:59 +11008460 if (mddev_is_clustered(mddev)) {
8461 struct md_rdev *rdev;
8462 /* kick the device if another node issued a
8463 * remove disk.
8464 */
8465 rdev_for_each(rdev, mddev) {
8466 if (test_and_clear_bit(ClusterRemove, &rdev->flags) &&
8467 rdev->raid_disk < 0)
8468 md_kick_rdev_from_array(rdev);
8469 }
Guoqing Jiang15858fa2015-12-21 10:51:00 +11008470
8471 if (test_and_clear_bit(MD_RELOAD_SB, &mddev->flags))
8472 md_reload_sb(mddev, mddev->good_device_nr);
Guoqing Jiang659b2542015-12-21 10:50:59 +11008473 }
8474
NeilBrown31a59e32008-04-30 00:52:30 -07008475 if (!mddev->external) {
Neil Brown0fd62b82008-06-28 08:31:36 +10008476 int did_change = 0;
NeilBrown85572d72014-12-15 12:56:56 +11008477 spin_lock(&mddev->lock);
NeilBrown31a59e32008-04-30 00:52:30 -07008478 if (mddev->safemode &&
8479 !atomic_read(&mddev->writes_pending) &&
8480 !mddev->in_sync &&
8481 mddev->recovery_cp == MaxSector) {
8482 mddev->in_sync = 1;
Neil Brown0fd62b82008-06-28 08:31:36 +10008483 did_change = 1;
NeilBrown070dc6d2010-08-30 17:33:34 +10008484 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown31a59e32008-04-30 00:52:30 -07008485 }
8486 if (mddev->safemode == 1)
8487 mddev->safemode = 0;
NeilBrown85572d72014-12-15 12:56:56 +11008488 spin_unlock(&mddev->lock);
Neil Brown0fd62b82008-06-28 08:31:36 +10008489 if (did_change)
NeilBrown00bcb4a2010-06-01 19:37:23 +10008490 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrownfca4d842005-06-21 17:17:11 -07008491 }
NeilBrownfca4d842005-06-21 17:17:11 -07008492
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05008493 if (mddev->flags & MD_UPDATE_SB_FLAGS)
NeilBrown850b2b42006-10-03 01:15:46 -07008494 md_update_sb(mddev, 0);
NeilBrown06d91a52005-06-21 17:17:12 -07008495
Linus Torvalds1da177e2005-04-16 15:20:36 -07008496 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
8497 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
8498 /* resync/recovery still happening */
8499 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8500 goto unlock;
8501 }
8502 if (mddev->sync_thread) {
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008503 md_reap_sync_thread(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008504 goto unlock;
8505 }
Neil Brown72a23c22008-06-28 08:31:41 +10008506 /* Set RUNNING before clearing NEEDED to avoid
8507 * any transients in the value of "sync_action".
8508 */
NeilBrown72f36d52012-10-11 14:25:57 +11008509 mddev->curr_resync_completed = 0;
NeilBrown23da4222014-12-15 12:57:01 +11008510 spin_lock(&mddev->lock);
Neil Brown72a23c22008-06-28 08:31:41 +10008511 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrown23da4222014-12-15 12:57:01 +11008512 spin_unlock(&mddev->lock);
NeilBrown24dd4692005-11-08 21:39:26 -08008513 /* Clear some bits that don't mean anything, but
8514 * might be left set
8515 */
NeilBrown24dd4692005-11-08 21:39:26 -08008516 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
8517 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008518
NeilBrowned209582012-04-24 10:23:14 +10008519 if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
8520 test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
NeilBrownac05f252014-09-30 08:10:42 +10008521 goto not_running;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008522 /* no recovery is running.
8523 * remove any failed drives, then
8524 * add spares if possible.
NeilBrown72f36d52012-10-11 14:25:57 +11008525 * Spares are also removed and re-added, to allow
Linus Torvalds1da177e2005-04-16 15:20:36 -07008526 * the personality to fail the re-add.
8527 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07008528
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008529 if (mddev->reshape_position != MaxSector) {
NeilBrown50ac1682009-06-18 08:47:55 +10008530 if (mddev->pers->check_reshape == NULL ||
8531 mddev->pers->check_reshape(mddev) != 0)
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008532 /* Cannot proceed */
NeilBrownac05f252014-09-30 08:10:42 +10008533 goto not_running;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008534 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10008535 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown746d3202013-04-24 11:42:41 +10008536 } else if ((spares = remove_and_add_spares(mddev, NULL))) {
NeilBrown24dd4692005-11-08 21:39:26 -08008537 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8538 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
Dan Williams56ac36d2008-08-07 10:02:47 -07008539 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10008540 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown24dd4692005-11-08 21:39:26 -08008541 } else if (mddev->recovery_cp < MaxSector) {
8542 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10008543 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown24dd4692005-11-08 21:39:26 -08008544 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
8545 /* nothing to be done ... */
NeilBrownac05f252014-09-30 08:10:42 +10008546 goto not_running;
NeilBrown24dd4692005-11-08 21:39:26 -08008547
Linus Torvalds1da177e2005-04-16 15:20:36 -07008548 if (mddev->pers->sync_request) {
NeilBrownef99bf42012-05-22 13:55:08 +10008549 if (spares) {
NeilBrowna654b9d82005-06-21 17:17:27 -07008550 /* We are adding a device or devices to an array
8551 * which has the bitmap stored on all devices.
8552 * So make sure all bitmap pages get written
8553 */
8554 bitmap_write_all(mddev->bitmap);
8555 }
NeilBrownac05f252014-09-30 08:10:42 +10008556 INIT_WORK(&mddev->del_work, md_start_sync);
8557 queue_work(md_misc_wq, &mddev->del_work);
8558 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008559 }
NeilBrownac05f252014-09-30 08:10:42 +10008560 not_running:
Neil Brown72a23c22008-06-28 08:31:41 +10008561 if (!mddev->sync_thread) {
8562 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11008563 wake_up(&resync_wait);
Neil Brown72a23c22008-06-28 08:31:41 +10008564 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
8565 &mddev->recovery))
NeilBrown0c3573f2009-01-09 08:31:05 +11008566 if (mddev->sysfs_action)
NeilBrown00bcb4a2010-06-01 19:37:23 +10008567 sysfs_notify_dirent_safe(mddev->sysfs_action);
Neil Brown72a23c22008-06-28 08:31:41 +10008568 }
NeilBrownac05f252014-09-30 08:10:42 +10008569 unlock:
8570 wake_up(&mddev->sb_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008571 mddev_unlock(mddev);
8572 }
8573}
NeilBrown6c144d32014-09-30 16:15:38 +10008574EXPORT_SYMBOL(md_check_recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008575
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008576void md_reap_sync_thread(struct mddev *mddev)
8577{
8578 struct md_rdev *rdev;
8579
8580 /* resync has finished, collect result */
8581 md_unregister_thread(&mddev->sync_thread);
8582 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
Guoqing Jiangf14b1b32019-07-24 11:09:21 +02008583 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
8584 mddev->degraded != mddev->raid_disks) {
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008585 /* success...*/
8586 /* activate any spares */
8587 if (mddev->pers->spare_active(mddev)) {
8588 sysfs_notify(&mddev->kobj, NULL,
8589 "degraded");
8590 set_bit(MD_CHANGE_DEVS, &mddev->flags);
8591 }
8592 }
8593 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8594 mddev->pers->finish_reshape)
8595 mddev->pers->finish_reshape(mddev);
8596
8597 /* If array is no-longer degraded, then any saved_raid_disk
NeilBrownf4667222013-12-09 12:04:56 +11008598 * information must be scrapped.
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008599 */
NeilBrownf4667222013-12-09 12:04:56 +11008600 if (!mddev->degraded)
8601 rdev_for_each(rdev, mddev)
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008602 rdev->saved_raid_disk = -1;
8603
8604 md_update_sb(mddev, 1);
Guoqing Jiangbb8bf152016-06-02 23:32:04 -04008605 /* MD_CHANGE_PENDING should be cleared by md_update_sb, so we can
8606 * call resync_finish here if MD_CLUSTER_RESYNC_LOCKED is set by
8607 * clustered raid */
8608 if (test_and_clear_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags))
8609 md_cluster_ops->resync_finish(mddev);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008610 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrownea358cd2015-06-12 20:05:04 +10008611 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008612 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8613 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8614 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
8615 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11008616 wake_up(&resync_wait);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008617 /* flag recovery needed just to double check */
8618 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8619 sysfs_notify_dirent_safe(mddev->sysfs_action);
8620 md_new_event(mddev);
8621 if (mddev->event_work.func)
8622 queue_work(md_misc_wq, &mddev->event_work);
8623}
NeilBrown6c144d32014-09-30 16:15:38 +10008624EXPORT_SYMBOL(md_reap_sync_thread);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008625
NeilBrownfd01b882011-10-11 16:47:53 +11008626void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
Dan Williams6bfe0b42008-04-30 00:52:32 -07008627{
NeilBrown00bcb4a2010-06-01 19:37:23 +10008628 sysfs_notify_dirent_safe(rdev->sysfs_state);
Dan Williams6bfe0b42008-04-30 00:52:32 -07008629 wait_event_timeout(rdev->blocked_wait,
NeilBrownde393cd2011-07-28 11:31:48 +10008630 !test_bit(Blocked, &rdev->flags) &&
8631 !test_bit(BlockedBadBlocks, &rdev->flags),
Dan Williams6bfe0b42008-04-30 00:52:32 -07008632 msecs_to_jiffies(5000));
8633 rdev_dec_pending(rdev, mddev);
8634}
8635EXPORT_SYMBOL(md_wait_for_blocked_rdev);
8636
NeilBrownc6563a82012-05-21 09:27:00 +10008637void md_finish_reshape(struct mddev *mddev)
8638{
8639 /* called be personality module when reshape completes. */
8640 struct md_rdev *rdev;
8641
8642 rdev_for_each(rdev, mddev) {
8643 if (rdev->data_offset > rdev->new_data_offset)
8644 rdev->sectors += rdev->data_offset - rdev->new_data_offset;
8645 else
8646 rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
8647 rdev->data_offset = rdev->new_data_offset;
8648 }
8649}
8650EXPORT_SYMBOL(md_finish_reshape);
NeilBrown2230dfe2011-07-28 11:31:46 +10008651
Vishal Vermafc974ee2015-12-24 19:20:34 -07008652/* Bad block management */
NeilBrown2230dfe2011-07-28 11:31:46 +10008653
Vishal Vermafc974ee2015-12-24 19:20:34 -07008654/* Returns 1 on success, 0 on failure */
NeilBrown3cb03002011-10-11 16:45:26 +11008655int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
NeilBrownc6563a82012-05-21 09:27:00 +10008656 int is_new)
NeilBrown2230dfe2011-07-28 11:31:46 +10008657{
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04008658 struct mddev *mddev = rdev->mddev;
NeilBrownc6563a82012-05-21 09:27:00 +10008659 int rv;
8660 if (is_new)
8661 s += rdev->new_data_offset;
8662 else
8663 s += rdev->data_offset;
Vishal Vermafc974ee2015-12-24 19:20:34 -07008664 rv = badblocks_set(&rdev->badblocks, s, sectors, 0);
8665 if (rv == 0) {
NeilBrown2230dfe2011-07-28 11:31:46 +10008666 /* Make sure they get written out promptly */
NeilBrown8bd2f0a2011-12-08 16:26:08 +11008667 sysfs_notify_dirent_safe(rdev->sysfs_state);
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04008668 set_mask_bits(&mddev->flags, 0,
8669 BIT(MD_CHANGE_CLEAN) | BIT(MD_CHANGE_PENDING));
NeilBrown2230dfe2011-07-28 11:31:46 +10008670 md_wakeup_thread(rdev->mddev->thread);
Vishal Vermafc974ee2015-12-24 19:20:34 -07008671 return 1;
8672 } else
8673 return 0;
NeilBrown2230dfe2011-07-28 11:31:46 +10008674}
8675EXPORT_SYMBOL_GPL(rdev_set_badblocks);
8676
NeilBrownc6563a82012-05-21 09:27:00 +10008677int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
8678 int is_new)
NeilBrown2230dfe2011-07-28 11:31:46 +10008679{
NeilBrownc6563a82012-05-21 09:27:00 +10008680 if (is_new)
8681 s += rdev->new_data_offset;
8682 else
8683 s += rdev->data_offset;
Vishal Vermafc974ee2015-12-24 19:20:34 -07008684 return badblocks_clear(&rdev->badblocks,
NeilBrownc6563a82012-05-21 09:27:00 +10008685 s, sectors);
NeilBrown2230dfe2011-07-28 11:31:46 +10008686}
8687EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
8688
Adrian Bunk75c96f82005-05-05 16:16:09 -07008689static int md_notify_reboot(struct notifier_block *this,
8690 unsigned long code, void *x)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008691{
8692 struct list_head *tmp;
NeilBrownfd01b882011-10-11 16:47:53 +11008693 struct mddev *mddev;
Daniel P. Berrange2dba6a92011-09-23 10:40:45 +01008694 int need_delay = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008695
NeilBrownc744a652012-03-19 12:46:37 +11008696 for_each_mddev(mddev, tmp) {
8697 if (mddev_trylock(mddev)) {
NeilBrown30b8aa92012-04-24 10:23:16 +10008698 if (mddev->pers)
8699 __md_stop_writes(mddev);
NeilBrown0f62fb22014-05-06 09:36:08 +10008700 if (mddev->persistent)
8701 mddev->safemode = 2;
NeilBrownc744a652012-03-19 12:46:37 +11008702 mddev_unlock(mddev);
Daniel P. Berrange2dba6a92011-09-23 10:40:45 +01008703 }
NeilBrownc744a652012-03-19 12:46:37 +11008704 need_delay = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008705 }
NeilBrownc744a652012-03-19 12:46:37 +11008706 /*
8707 * certain more exotic SCSI devices are known to be
8708 * volatile wrt too early system reboots. While the
8709 * right place to handle this issue is the given
8710 * driver, we do want to have a safe RAID driver ...
8711 */
8712 if (need_delay)
8713 mdelay(1000*1);
8714
Linus Torvalds1da177e2005-04-16 15:20:36 -07008715 return NOTIFY_DONE;
8716}
8717
Adrian Bunk75c96f82005-05-05 16:16:09 -07008718static struct notifier_block md_notifier = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07008719 .notifier_call = md_notify_reboot,
8720 .next = NULL,
8721 .priority = INT_MAX, /* before any real devices */
8722};
8723
8724static void md_geninit(void)
8725{
NeilBrown36a4e1f2011-10-07 14:23:17 +11008726 pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07008727
Denis V. Lunevc7705f32008-04-29 01:02:35 -07008728 proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008729}
8730
Adrian Bunk75c96f82005-05-05 16:16:09 -07008731static int __init md_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008732{
Tejun Heoe804ac72010-10-15 15:36:08 +02008733 int ret = -ENOMEM;
8734
Tejun Heoada609e2011-01-25 14:35:54 +01008735 md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
Tejun Heoe804ac72010-10-15 15:36:08 +02008736 if (!md_wq)
8737 goto err_wq;
8738
8739 md_misc_wq = alloc_workqueue("md_misc", 0, 0);
8740 if (!md_misc_wq)
8741 goto err_misc_wq;
8742
8743 if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
8744 goto err_md;
8745
8746 if ((ret = register_blkdev(0, "mdp")) < 0)
8747 goto err_mdp;
8748 mdp_major = ret;
8749
NeilBrownaf5628f2014-07-31 13:54:54 +10008750 blk_register_region(MKDEV(MD_MAJOR, 0), 512, THIS_MODULE,
NeilBrowne8703fe2006-10-03 01:15:59 -07008751 md_probe, NULL, NULL);
8752 blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07008753 md_probe, NULL, NULL);
8754
Linus Torvalds1da177e2005-04-16 15:20:36 -07008755 register_reboot_notifier(&md_notifier);
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08008756 raid_table_header = register_sysctl_table(raid_root_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008757
8758 md_geninit();
NeilBrownd710e132008-10-13 11:55:12 +11008759 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008760
Tejun Heoe804ac72010-10-15 15:36:08 +02008761err_mdp:
8762 unregister_blkdev(MD_MAJOR, "md");
8763err_md:
8764 destroy_workqueue(md_misc_wq);
8765err_misc_wq:
8766 destroy_workqueue(md_wq);
8767err_wq:
8768 return ret;
8769}
Linus Torvalds1da177e2005-04-16 15:20:36 -07008770
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008771static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev)
Goldwyn Rodrigues1d7e3e92014-06-07 01:53:00 -05008772{
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008773 struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
8774 struct md_rdev *rdev2;
8775 int role, ret;
8776 char b[BDEVNAME_SIZE];
Goldwyn Rodrigues1d7e3e92014-06-07 01:53:00 -05008777
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008778 /* Check for change of roles in the active devices */
8779 rdev_for_each(rdev2, mddev) {
8780 if (test_bit(Faulty, &rdev2->flags))
8781 continue;
8782
8783 /* Check if the roles changed */
8784 role = le16_to_cpu(sb->dev_roles[rdev2->desc_nr]);
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05008785
8786 if (test_bit(Candidate, &rdev2->flags)) {
8787 if (role == 0xfffe) {
8788 pr_info("md: Removing Candidate device %s because add failed\n", bdevname(rdev2->bdev,b));
8789 md_kick_rdev_from_array(rdev2);
8790 continue;
8791 }
8792 else
8793 clear_bit(Candidate, &rdev2->flags);
8794 }
8795
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008796 if (role != rdev2->raid_disk) {
8797 /* got activated */
8798 if (rdev2->raid_disk == -1 && role != 0xffff) {
8799 rdev2->saved_raid_disk = role;
8800 ret = remove_and_add_spares(mddev, rdev2);
8801 pr_info("Activated spare: %s\n",
8802 bdevname(rdev2->bdev,b));
Guoqing Jianga5781832016-05-02 11:33:14 -04008803 /* wakeup mddev->thread here, so array could
8804 * perform resync with the new activated disk */
8805 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8806 md_wakeup_thread(mddev->thread);
8807
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008808 }
8809 /* device faulty
8810 * We just want to do the minimum to mark the disk
8811 * as faulty. The recovery is performed by the
8812 * one who initiated the error.
8813 */
8814 if ((role == 0xfffe) || (role == 0xfffd)) {
8815 md_error(mddev, rdev2);
8816 clear_bit(Blocked, &rdev2->flags);
8817 }
8818 }
Goldwyn Rodrigues1d7e3e92014-06-07 01:53:00 -05008819 }
8820
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11008821 if (mddev->raid_disks != le32_to_cpu(sb->raid_disks))
8822 update_raid_disks(mddev, le32_to_cpu(sb->raid_disks));
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008823
8824 /* Finally set the event to be up to date */
8825 mddev->events = le64_to_cpu(sb->events);
8826}
8827
8828static int read_rdev(struct mddev *mddev, struct md_rdev *rdev)
8829{
8830 int err;
8831 struct page *swapout = rdev->sb_page;
8832 struct mdp_superblock_1 *sb;
8833
8834 /* Store the sb page of the rdev in the swapout temporary
8835 * variable in case we err in the future
8836 */
8837 rdev->sb_page = NULL;
8838 alloc_disk_sb(rdev);
8839 ClearPageUptodate(rdev->sb_page);
8840 rdev->sb_loaded = 0;
8841 err = super_types[mddev->major_version].load_super(rdev, NULL, mddev->minor_version);
8842
8843 if (err < 0) {
8844 pr_warn("%s: %d Could not reload rdev(%d) err: %d. Restoring old values\n",
8845 __func__, __LINE__, rdev->desc_nr, err);
8846 put_page(rdev->sb_page);
8847 rdev->sb_page = swapout;
8848 rdev->sb_loaded = 1;
8849 return err;
8850 }
8851
8852 sb = page_address(rdev->sb_page);
8853 /* Read the offset unconditionally, even if MD_FEATURE_RECOVERY_OFFSET
8854 * is not set
8855 */
8856
8857 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET))
8858 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
8859
8860 /* The other node finished recovery, call spare_active to set
8861 * device In_sync and mddev->degraded
8862 */
8863 if (rdev->recovery_offset == MaxSector &&
8864 !test_bit(In_sync, &rdev->flags) &&
8865 mddev->pers->spare_active(mddev))
8866 sysfs_notify(&mddev->kobj, NULL, "degraded");
8867
8868 put_page(swapout);
8869 return 0;
8870}
8871
8872void md_reload_sb(struct mddev *mddev, int nr)
8873{
8874 struct md_rdev *rdev;
8875 int err;
8876
8877 /* Find the rdev */
8878 rdev_for_each_rcu(rdev, mddev) {
8879 if (rdev->desc_nr == nr)
8880 break;
8881 }
8882
8883 if (!rdev || rdev->desc_nr != nr) {
8884 pr_warn("%s: %d Could not find rdev with nr %d\n", __func__, __LINE__, nr);
8885 return;
8886 }
8887
8888 err = read_rdev(mddev, rdev);
8889 if (err < 0)
8890 return;
8891
8892 check_sb_changes(mddev, rdev);
8893
8894 /* Read all rdev's to update recovery_offset */
8895 rdev_for_each_rcu(rdev, mddev)
8896 read_rdev(mddev, rdev);
Goldwyn Rodrigues1d7e3e92014-06-07 01:53:00 -05008897}
8898EXPORT_SYMBOL(md_reload_sb);
8899
Linus Torvalds1da177e2005-04-16 15:20:36 -07008900#ifndef MODULE
8901
8902/*
8903 * Searches all registered partitions for autorun RAID arrays
8904 * at boot time.
8905 */
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008906
Cong Wang5b1f5bc32016-06-08 09:20:16 -07008907static DEFINE_MUTEX(detected_devices_mutex);
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008908static LIST_HEAD(all_detected_devices);
8909struct detected_devices_node {
8910 struct list_head list;
8911 dev_t dev;
8912};
Linus Torvalds1da177e2005-04-16 15:20:36 -07008913
8914void md_autodetect_dev(dev_t dev)
8915{
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008916 struct detected_devices_node *node_detected_dev;
8917
8918 node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
8919 if (node_detected_dev) {
8920 node_detected_dev->dev = dev;
Cong Wang5b1f5bc32016-06-08 09:20:16 -07008921 mutex_lock(&detected_devices_mutex);
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008922 list_add_tail(&node_detected_dev->list, &all_detected_devices);
Cong Wang5b1f5bc32016-06-08 09:20:16 -07008923 mutex_unlock(&detected_devices_mutex);
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008924 } else {
8925 printk(KERN_CRIT "md: md_autodetect_dev: kzalloc failed"
8926 ", skipping dev(%d,%d)\n", MAJOR(dev), MINOR(dev));
8927 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07008928}
8929
Linus Torvalds1da177e2005-04-16 15:20:36 -07008930static void autostart_arrays(int part)
8931{
NeilBrown3cb03002011-10-11 16:45:26 +11008932 struct md_rdev *rdev;
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008933 struct detected_devices_node *node_detected_dev;
8934 dev_t dev;
8935 int i_scanned, i_passed;
8936
8937 i_scanned = 0;
8938 i_passed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008939
8940 printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
8941
Cong Wang5b1f5bc32016-06-08 09:20:16 -07008942 mutex_lock(&detected_devices_mutex);
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008943 while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
8944 i_scanned++;
8945 node_detected_dev = list_entry(all_detected_devices.next,
8946 struct detected_devices_node, list);
8947 list_del(&node_detected_dev->list);
8948 dev = node_detected_dev->dev;
8949 kfree(node_detected_dev);
Shaohua Li90bcf1332016-09-14 14:26:54 -07008950 mutex_unlock(&detected_devices_mutex);
NeilBrowndf968c42007-07-17 04:06:11 -07008951 rdev = md_import_device(dev,0, 90);
Shaohua Li90bcf1332016-09-14 14:26:54 -07008952 mutex_lock(&detected_devices_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008953 if (IS_ERR(rdev))
8954 continue;
8955
NeilBrown403df472014-09-30 15:52:29 +10008956 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07008957 continue;
NeilBrown403df472014-09-30 15:52:29 +10008958
NeilBrownd0fae182008-03-04 14:29:31 -08008959 set_bit(AutoDetected, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008960 list_add(&rdev->same_set, &pending_raid_disks);
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008961 i_passed++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008962 }
Cong Wang5b1f5bc32016-06-08 09:20:16 -07008963 mutex_unlock(&detected_devices_mutex);
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008964
8965 printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
8966 i_scanned, i_passed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008967
8968 autorun_devices(part);
8969}
8970
Jeff Garzikfdee8ae2006-12-10 02:20:50 -08008971#endif /* !MODULE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07008972
8973static __exit void md_exit(void)
8974{
NeilBrownfd01b882011-10-11 16:47:53 +11008975 struct mddev *mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008976 struct list_head *tmp;
NeilBrowne2f23b62014-04-09 14:33:51 +10008977 int delay = 1;
Greg Kroah-Hartman8ab5e4c2005-06-20 21:15:16 -07008978
NeilBrownaf5628f2014-07-31 13:54:54 +10008979 blk_unregister_region(MKDEV(MD_MAJOR,0), 512);
NeilBrowne8703fe2006-10-03 01:15:59 -07008980 blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008981
Christoph Hellwig3dbd8c22009-03-31 14:27:02 +11008982 unregister_blkdev(MD_MAJOR,"md");
Linus Torvalds1da177e2005-04-16 15:20:36 -07008983 unregister_blkdev(mdp_major, "mdp");
8984 unregister_reboot_notifier(&md_notifier);
8985 unregister_sysctl_table(raid_table_header);
NeilBrowne2f23b62014-04-09 14:33:51 +10008986
8987 /* We cannot unload the modules while some process is
8988 * waiting for us in select() or poll() - wake them up
8989 */
8990 md_unloading = 1;
8991 while (waitqueue_active(&md_event_waiters)) {
8992 /* not safe to leave yet */
8993 wake_up(&md_event_waiters);
8994 msleep(delay);
8995 delay += delay;
8996 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07008997 remove_proc_entry("mdstat", NULL);
NeilBrowne2f23b62014-04-09 14:33:51 +10008998
NeilBrown29ac4aa2008-02-06 01:39:58 -08008999 for_each_mddev(mddev, tmp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07009000 export_array(mddev);
NeilBrownd3374822009-01-09 08:31:10 +11009001 mddev->hold_active = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07009002 }
Tejun Heoe804ac72010-10-15 15:36:08 +02009003 destroy_workqueue(md_misc_wq);
9004 destroy_workqueue(md_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07009005}
9006
Dan Williams685784a2007-07-09 11:56:42 -07009007subsys_initcall(md_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07009008module_exit(md_exit)
9009
Kees Cook24da2c82017-10-17 19:04:42 -07009010static int get_ro(char *buffer, const struct kernel_param *kp)
NeilBrownf91de922005-11-08 21:39:36 -08009011{
9012 return sprintf(buffer, "%d", start_readonly);
9013}
Kees Cook24da2c82017-10-17 19:04:42 -07009014static int set_ro(const char *val, const struct kernel_param *kp)
NeilBrownf91de922005-11-08 21:39:36 -08009015{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03009016 return kstrtouint(val, 10, (unsigned int *)&start_readonly);
NeilBrownf91de922005-11-08 21:39:36 -08009017}
9018
NeilBrown80ca3a42006-07-10 04:44:18 -07009019module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
9020module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
NeilBrownefeb53c2009-01-09 08:31:10 +11009021module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
NeilBrownf91de922005-11-08 21:39:36 -08009022
Linus Torvalds1da177e2005-04-16 15:20:36 -07009023MODULE_LICENSE("GPL");
NeilBrown0efb9e62009-12-14 12:49:58 +11009024MODULE_DESCRIPTION("MD RAID framework");
NeilBrownaa1595e2005-08-04 12:53:32 -07009025MODULE_ALIAS("md");
NeilBrown72008652005-08-26 18:34:15 -07009026MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);