blob: 866825f10b4c933f75eb4cbaff46c624f6267826 [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 */
288 bio->bi_rw &= ~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;
397 atomic_inc(&mddev->flush_pending);
Tejun Heoe9c74692010-09-03 11:56:18 +0200398 submit_bio(WRITE_FLUSH, bi);
NeilBrowna2826aa2009-12-14 12:49:49 +1100399 rcu_read_lock();
400 rdev_dec_pending(rdev, mddev);
401 }
402 rcu_read_unlock();
NeilBrowna7a07e62010-12-09 16:04:25 +1100403 if (atomic_dec_and_test(&mddev->flush_pending))
404 queue_work(md_wq, &mddev->flush_work);
NeilBrowna2826aa2009-12-14 12:49:49 +1100405}
406
Tejun Heoe9c74692010-09-03 11:56:18 +0200407static void md_submit_flush_data(struct work_struct *ws)
NeilBrowna2826aa2009-12-14 12:49:49 +1100408{
NeilBrownfd01b882011-10-11 16:47:53 +1100409 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
Tejun Heoe9c74692010-09-03 11:56:18 +0200410 struct bio *bio = mddev->flush_bio;
NeilBrowna2826aa2009-12-14 12:49:49 +1100411
Kent Overstreet4f024f32013-10-11 15:44:27 -0700412 if (bio->bi_iter.bi_size == 0)
NeilBrowna2826aa2009-12-14 12:49:49 +1100413 /* an empty barrier - all done */
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200414 bio_endio(bio);
NeilBrowna2826aa2009-12-14 12:49:49 +1100415 else {
Tejun Heoe9c74692010-09-03 11:56:18 +0200416 bio->bi_rw &= ~REQ_FLUSH;
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200417 mddev->pers->make_request(mddev, bio);
NeilBrowna2826aa2009-12-14 12:49:49 +1100418 }
NeilBrown2b74e122010-12-09 15:59:01 +1100419
420 mddev->flush_bio = NULL;
421 wake_up(&mddev->sb_wait);
NeilBrowna2826aa2009-12-14 12:49:49 +1100422}
423
NeilBrownfd01b882011-10-11 16:47:53 +1100424void md_flush_request(struct mddev *mddev, struct bio *bio)
NeilBrowna2826aa2009-12-14 12:49:49 +1100425{
NeilBrown85572d72014-12-15 12:56:56 +1100426 spin_lock_irq(&mddev->lock);
NeilBrowna2826aa2009-12-14 12:49:49 +1100427 wait_event_lock_irq(mddev->sb_wait,
Tejun Heoe9c74692010-09-03 11:56:18 +0200428 !mddev->flush_bio,
NeilBrown85572d72014-12-15 12:56:56 +1100429 mddev->lock);
Tejun Heoe9c74692010-09-03 11:56:18 +0200430 mddev->flush_bio = bio;
NeilBrown85572d72014-12-15 12:56:56 +1100431 spin_unlock_irq(&mddev->lock);
NeilBrowna2826aa2009-12-14 12:49:49 +1100432
NeilBrowna035fc32010-12-09 16:17:51 +1100433 INIT_WORK(&mddev->flush_work, submit_flushes);
434 queue_work(md_wq, &mddev->flush_work);
NeilBrowna2826aa2009-12-14 12:49:49 +1100435}
Tejun Heoe9c74692010-09-03 11:56:18 +0200436EXPORT_SYMBOL(md_flush_request);
NeilBrown409c57f2009-03-31 14:39:39 +1100437
NeilBrown74018dc2012-07-31 09:08:15 +0200438void md_unplug(struct blk_plug_cb *cb, bool from_schedule)
NeilBrown97658cd2011-04-18 18:25:42 +1000439{
NeilBrown9cbb1752012-07-31 09:08:14 +0200440 struct mddev *mddev = cb->data;
441 md_wakeup_thread(mddev->thread);
442 kfree(cb);
NeilBrown97658cd2011-04-18 18:25:42 +1000443}
NeilBrown9cbb1752012-07-31 09:08:14 +0200444EXPORT_SYMBOL(md_unplug);
NeilBrown2ac87402010-06-01 19:37:29 +1000445
NeilBrownfd01b882011-10-11 16:47:53 +1100446static inline struct mddev *mddev_get(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447{
448 atomic_inc(&mddev->active);
449 return mddev;
450}
451
Dan Williams5fd3a172009-03-04 00:57:25 -0700452static void mddev_delayed_delete(struct work_struct *ws);
NeilBrownd3374822009-01-09 08:31:10 +1100453
NeilBrownfd01b882011-10-11 16:47:53 +1100454static void mddev_put(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455{
NeilBrowna167f662010-10-26 18:31:13 +1100456 struct bio_set *bs = NULL;
457
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
459 return;
NeilBrownd3374822009-01-09 08:31:10 +1100460 if (!mddev->raid_disks && list_empty(&mddev->disks) &&
NeilBrowncbd19982009-12-30 12:08:49 +1100461 mddev->ctime == 0 && !mddev->hold_active) {
462 /* Array is not configured at all, and not held active,
463 * so destroy it */
NeilBrownaf8a2432011-12-08 15:49:46 +1100464 list_del_init(&mddev->all_mddevs);
NeilBrowna167f662010-10-26 18:31:13 +1100465 bs = mddev->bio_set;
466 mddev->bio_set = NULL;
NeilBrownd3374822009-01-09 08:31:10 +1100467 if (mddev->gendisk) {
Tejun Heoe804ac72010-10-15 15:36:08 +0200468 /* We did a probe so need to clean up. Call
469 * queue_work inside the spinlock so that
470 * flush_workqueue() after mddev_find will
471 * succeed in waiting for the work to be done.
NeilBrownd3374822009-01-09 08:31:10 +1100472 */
473 INIT_WORK(&mddev->del_work, mddev_delayed_delete);
Tejun Heoe804ac72010-10-15 15:36:08 +0200474 queue_work(md_misc_wq, &mddev->del_work);
NeilBrownd3374822009-01-09 08:31:10 +1100475 } else
476 kfree(mddev);
477 }
478 spin_unlock(&all_mddevs_lock);
NeilBrowna167f662010-10-26 18:31:13 +1100479 if (bs)
480 bioset_free(bs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481}
482
Sasha Levin25b2edf2015-07-24 18:19:58 -0400483static void md_safemode_timeout(unsigned long data);
484
NeilBrownfd01b882011-10-11 16:47:53 +1100485void mddev_init(struct mddev *mddev)
NeilBrownfafd7fb2010-04-01 15:55:30 +1100486{
487 mutex_init(&mddev->open_mutex);
488 mutex_init(&mddev->reconfig_mutex);
489 mutex_init(&mddev->bitmap_info.mutex);
490 INIT_LIST_HEAD(&mddev->disks);
491 INIT_LIST_HEAD(&mddev->all_mddevs);
Sasha Levin25b2edf2015-07-24 18:19:58 -0400492 setup_timer(&mddev->safemode_timer, md_safemode_timeout,
493 (unsigned long) mddev);
NeilBrownfafd7fb2010-04-01 15:55:30 +1100494 atomic_set(&mddev->active, 1);
495 atomic_set(&mddev->openers, 0);
496 atomic_set(&mddev->active_io, 0);
NeilBrown85572d72014-12-15 12:56:56 +1100497 spin_lock_init(&mddev->lock);
NeilBrownfafd7fb2010-04-01 15:55:30 +1100498 atomic_set(&mddev->flush_pending, 0);
499 init_waitqueue_head(&mddev->sb_wait);
500 init_waitqueue_head(&mddev->recovery_wait);
501 mddev->reshape_position = MaxSector;
NeilBrown2c810cd2012-05-21 09:27:00 +1000502 mddev->reshape_backwards = 0;
Jonathan Brassowc4a39552013-06-25 01:23:59 -0500503 mddev->last_sync_action = "none";
NeilBrownfafd7fb2010-04-01 15:55:30 +1100504 mddev->resync_min = 0;
505 mddev->resync_max = MaxSector;
506 mddev->level = LEVEL_NONE;
507}
NeilBrown390ee602010-06-01 19:37:27 +1000508EXPORT_SYMBOL_GPL(mddev_init);
NeilBrownfafd7fb2010-04-01 15:55:30 +1100509
NeilBrownf72ffdd2014-09-30 14:23:59 +1000510static struct mddev *mddev_find(dev_t unit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
NeilBrownfd01b882011-10-11 16:47:53 +1100512 struct mddev *mddev, *new = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
NeilBrown8f5f02c2011-02-16 13:58:51 +1100514 if (unit && MAJOR(unit) != MD_MAJOR)
515 unit &= ~((1<<MdpMinorShift)-1);
516
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 retry:
518 spin_lock(&all_mddevs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
NeilBrownefeb53c2009-01-09 08:31:10 +1100520 if (unit) {
521 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
522 if (mddev->unit == unit) {
523 mddev_get(mddev);
524 spin_unlock(&all_mddevs_lock);
525 kfree(new);
526 return mddev;
527 }
528
529 if (new) {
530 list_add(&new->all_mddevs, &all_mddevs);
531 spin_unlock(&all_mddevs_lock);
532 new->hold_active = UNTIL_IOCTL;
533 return new;
534 }
535 } else if (new) {
536 /* find an unused unit number */
537 static int next_minor = 512;
538 int start = next_minor;
539 int is_free = 0;
540 int dev = 0;
541 while (!is_free) {
542 dev = MKDEV(MD_MAJOR, next_minor);
543 next_minor++;
544 if (next_minor > MINORMASK)
545 next_minor = 0;
546 if (next_minor == start) {
547 /* Oh dear, all in use. */
548 spin_unlock(&all_mddevs_lock);
549 kfree(new);
550 return NULL;
551 }
NeilBrownf72ffdd2014-09-30 14:23:59 +1000552
NeilBrownefeb53c2009-01-09 08:31:10 +1100553 is_free = 1;
554 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
555 if (mddev->unit == dev) {
556 is_free = 0;
557 break;
558 }
559 }
560 new->unit = dev;
561 new->md_minor = MINOR(dev);
562 new->hold_active = UNTIL_STOP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 list_add(&new->all_mddevs, &all_mddevs);
564 spin_unlock(&all_mddevs_lock);
565 return new;
566 }
567 spin_unlock(&all_mddevs_lock);
568
NeilBrown9ffae0c2006-01-06 00:20:32 -0800569 new = kzalloc(sizeof(*new), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 if (!new)
571 return NULL;
572
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 new->unit = unit;
574 if (MAJOR(unit) == MD_MAJOR)
575 new->md_minor = MINOR(unit);
576 else
577 new->md_minor = MINOR(unit) >> MdpMinorShift;
578
NeilBrownfafd7fb2010-04-01 15:55:30 +1100579 mddev_init(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 goto retry;
582}
583
NeilBrownb6eb1272010-04-15 10:13:47 +1000584static struct attribute_group md_redundancy_group;
585
NeilBrown5c47daf2014-12-15 12:57:01 +1100586void mddev_unlock(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
NeilBrowna64c8762010-04-14 17:15:37 +1000588 if (mddev->to_remove) {
NeilBrownb6eb1272010-04-15 10:13:47 +1000589 /* These cannot be removed under reconfig_mutex as
590 * an access to the files will try to take reconfig_mutex
591 * while holding the file unremovable, which leads to
592 * a deadlock.
NeilBrownbb4f1e92010-08-08 21:18:03 +1000593 * So hold set sysfs_active while the remove in happeing,
594 * and anything else which might set ->to_remove or my
595 * otherwise change the sysfs namespace will fail with
596 * -EBUSY if sysfs_active is still set.
597 * We set sysfs_active under reconfig_mutex and elsewhere
598 * test it under the same mutex to ensure its correct value
599 * is seen.
NeilBrownb6eb1272010-04-15 10:13:47 +1000600 */
NeilBrowna64c8762010-04-14 17:15:37 +1000601 struct attribute_group *to_remove = mddev->to_remove;
602 mddev->to_remove = NULL;
NeilBrownbb4f1e92010-08-08 21:18:03 +1000603 mddev->sysfs_active = 1;
NeilBrownb6eb1272010-04-15 10:13:47 +1000604 mutex_unlock(&mddev->reconfig_mutex);
605
NeilBrown00bcb4a2010-06-01 19:37:23 +1000606 if (mddev->kobj.sd) {
607 if (to_remove != &md_redundancy_group)
608 sysfs_remove_group(&mddev->kobj, to_remove);
609 if (mddev->pers == NULL ||
610 mddev->pers->sync_request == NULL) {
611 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
612 if (mddev->sysfs_action)
613 sysfs_put(mddev->sysfs_action);
614 mddev->sysfs_action = NULL;
615 }
NeilBrowna64c8762010-04-14 17:15:37 +1000616 }
NeilBrownbb4f1e92010-08-08 21:18:03 +1000617 mddev->sysfs_active = 0;
NeilBrownb6eb1272010-04-15 10:13:47 +1000618 } else
619 mutex_unlock(&mddev->reconfig_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
Chris Dunlop751e67c2011-10-19 16:48:26 +1100621 /* As we've dropped the mutex we need a spinlock to
622 * make sure the thread doesn't disappear
NeilBrown01f96c02011-09-21 15:30:20 +1000623 */
624 spin_lock(&pers_lock);
NeilBrown005eca52005-08-22 13:11:08 -0700625 md_wakeup_thread(mddev->thread);
NeilBrown01f96c02011-09-21 15:30:20 +1000626 spin_unlock(&pers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627}
NeilBrown5c47daf2014-12-15 12:57:01 +1100628EXPORT_SYMBOL_GPL(mddev_unlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
Goldwyn Rodrigues57d051d2015-04-14 10:43:55 -0500630struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr)
NeilBrown1ca69c42012-10-11 13:37:33 +1100631{
632 struct md_rdev *rdev;
633
634 rdev_for_each_rcu(rdev, mddev)
635 if (rdev->desc_nr == nr)
636 return rdev;
637
638 return NULL;
639}
Goldwyn Rodrigues57d051d2015-04-14 10:43:55 -0500640EXPORT_SYMBOL_GPL(md_find_rdev_nr_rcu);
NeilBrown1ca69c42012-10-11 13:37:33 +1100641
642static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643{
NeilBrown3cb03002011-10-11 16:45:26 +1100644 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
NeilBrowndafb20f2012-03-19 12:46:39 +1100646 rdev_for_each(rdev, mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 if (rdev->bdev->bd_dev == dev)
648 return rdev;
Cheng Renquan159ec1f2009-01-09 08:31:08 +1100649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 return NULL;
651}
652
NeilBrown1ca69c42012-10-11 13:37:33 +1100653static struct md_rdev *find_rdev_rcu(struct mddev *mddev, dev_t dev)
654{
655 struct md_rdev *rdev;
656
657 rdev_for_each_rcu(rdev, mddev)
658 if (rdev->bdev->bd_dev == dev)
659 return rdev;
660
661 return NULL;
662}
663
NeilBrown84fc4b52011-10-11 16:49:58 +1100664static struct md_personality *find_pers(int level, char *clevel)
NeilBrown2604b702006-01-06 00:20:36 -0800665{
NeilBrown84fc4b52011-10-11 16:49:58 +1100666 struct md_personality *pers;
NeilBrownd9d166c2006-01-06 00:20:51 -0800667 list_for_each_entry(pers, &pers_list, list) {
668 if (level != LEVEL_NONE && pers->level == level)
NeilBrown2604b702006-01-06 00:20:36 -0800669 return pers;
NeilBrownd9d166c2006-01-06 00:20:51 -0800670 if (strcmp(pers->name, clevel)==0)
671 return pers;
672 }
NeilBrown2604b702006-01-06 00:20:36 -0800673 return NULL;
674}
675
Andre Nollb73df2d2008-07-11 22:02:23 +1000676/* return the offset of the super block in 512byte sectors */
NeilBrown3cb03002011-10-11 16:45:26 +1100677static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678{
Jonathan Brassow57b2caa2011-01-14 09:14:33 +1100679 sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
Andre Nollb73df2d2008-07-11 22:02:23 +1000680 return MD_NEW_SIZE_SECTORS(num_sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681}
682
NeilBrownf72ffdd2014-09-30 14:23:59 +1000683static int alloc_disk_sb(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 rdev->sb_page = alloc_page(GFP_KERNEL);
686 if (!rdev->sb_page) {
687 printk(KERN_ALERT "md: out of memory.\n");
Andre Nollebc24332008-07-11 22:02:20 +1000688 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 }
690
691 return 0;
692}
693
NeilBrown545c8792012-05-22 13:54:30 +1000694void md_rdev_clear(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695{
696 if (rdev->sb_page) {
NeilBrown2d1f3b52006-01-06 00:20:31 -0800697 put_page(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 rdev->sb_loaded = 0;
699 rdev->sb_page = NULL;
Andre Noll0f420352008-07-11 22:02:23 +1000700 rdev->sb_start = 0;
Andre Nolldd8ac332009-03-31 14:33:13 +1100701 rdev->sectors = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 }
NeilBrown2699b672011-07-28 11:31:47 +1000703 if (rdev->bb_page) {
704 put_page(rdev->bb_page);
705 rdev->bb_page = NULL;
706 }
Dan Williamsd3b407f2016-01-06 12:19:22 -0800707 badblocks_exit(&rdev->badblocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708}
NeilBrown545c8792012-05-22 13:54:30 +1000709EXPORT_SYMBOL_GPL(md_rdev_clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200711static void super_written(struct bio *bio)
NeilBrown7bfa19f2005-06-21 17:17:28 -0700712{
NeilBrown3cb03002011-10-11 16:45:26 +1100713 struct md_rdev *rdev = bio->bi_private;
NeilBrownfd01b882011-10-11 16:47:53 +1100714 struct mddev *mddev = rdev->mddev;
NeilBrown7bfa19f2005-06-21 17:17:28 -0700715
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200716 if (bio->bi_error) {
717 printk("md: super_written gets error=%d\n", bio->bi_error);
NeilBrowna9701a32005-11-08 21:39:34 -0800718 md_error(mddev, rdev);
NeilBrown3a0f5bb2006-10-03 01:16:03 -0700719 }
NeilBrown7bfa19f2005-06-21 17:17:28 -0700720
NeilBrowna9701a32005-11-08 21:39:34 -0800721 if (atomic_dec_and_test(&mddev->pending_writes))
722 wake_up(&mddev->sb_wait);
Shaohua Lied3b98c2016-03-29 14:00:19 -0700723 rdev_dec_pending(rdev, mddev);
Neil Brownf8b58ed2005-06-27 22:29:34 -0700724 bio_put(bio);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700725}
726
NeilBrownfd01b882011-10-11 16:47:53 +1100727void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
NeilBrown7bfa19f2005-06-21 17:17:28 -0700728 sector_t sector, int size, struct page *page)
729{
730 /* write first size bytes of page to sector of rdev
731 * Increment mddev->pending_writes before returning
732 * and decrement it on completion, waking up sb_wait
733 * if zero is reached.
734 * If an error occurred, call md_error
735 */
NeilBrowna167f662010-10-26 18:31:13 +1100736 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, mddev);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700737
Shaohua Lied3b98c2016-03-29 14:00:19 -0700738 atomic_inc(&rdev->nr_pending);
739
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100740 bio->bi_bdev = rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev;
Kent Overstreet4f024f32013-10-11 15:44:27 -0700741 bio->bi_iter.bi_sector = sector;
NeilBrown7bfa19f2005-06-21 17:17:28 -0700742 bio_add_page(bio, page, size, 0);
743 bio->bi_private = rdev;
744 bio->bi_end_io = super_written;
NeilBrowna9701a32005-11-08 21:39:34 -0800745
NeilBrown7bfa19f2005-06-21 17:17:28 -0700746 atomic_inc(&mddev->pending_writes);
Namhyung Kima5bf4df2011-08-25 14:43:34 +1000747 submit_bio(WRITE_FLUSH_FUA, bio);
NeilBrowna9701a32005-11-08 21:39:34 -0800748}
749
NeilBrownfd01b882011-10-11 16:47:53 +1100750void md_super_wait(struct mddev *mddev)
NeilBrowna9701a32005-11-08 21:39:34 -0800751{
Tejun Heoe9c74692010-09-03 11:56:18 +0200752 /* wait for all superblock writes that were scheduled to complete */
NeilBrown1967cd52014-09-09 14:20:28 +1000753 wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700754}
755
NeilBrown3cb03002011-10-11 16:45:26 +1100756int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100757 struct page *page, int rw, bool metadata_op)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758{
NeilBrowna167f662010-10-26 18:31:13 +1100759 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 int ret;
761
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100762 bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
763 rdev->meta_bdev : rdev->bdev;
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100764 if (metadata_op)
Kent Overstreet4f024f32013-10-11 15:44:27 -0700765 bio->bi_iter.bi_sector = sector + rdev->sb_start;
NeilBrown1fdd6fc92012-05-21 09:28:32 +1000766 else if (rdev->mddev->reshape_position != MaxSector &&
767 (rdev->mddev->reshape_backwards ==
768 (sector >= rdev->mddev->reshape_position)))
Kent Overstreet4f024f32013-10-11 15:44:27 -0700769 bio->bi_iter.bi_sector = sector + rdev->new_data_offset;
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100770 else
Kent Overstreet4f024f32013-10-11 15:44:27 -0700771 bio->bi_iter.bi_sector = sector + rdev->data_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 bio_add_page(bio, page, size, 0);
Kent Overstreetc170bbb2013-11-24 16:32:22 -0700773 submit_bio_wait(rw, bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200775 ret = !bio->bi_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 bio_put(bio);
777 return ret;
778}
NeilBrowna8745db2006-01-06 00:20:34 -0800779EXPORT_SYMBOL_GPL(sync_page_io);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
NeilBrownf72ffdd2014-09-30 14:23:59 +1000781static int read_disk_sb(struct md_rdev *rdev, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782{
783 char b[BDEVNAME_SIZE];
NeilBrown403df472014-09-30 15:52:29 +1000784
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 if (rdev->sb_loaded)
786 return 0;
787
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100788 if (!sync_page_io(rdev, 0, size, rdev->sb_page, READ, true))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 goto fail;
790 rdev->sb_loaded = 1;
791 return 0;
792
793fail:
794 printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
795 bdevname(rdev->bdev,b));
796 return -EINVAL;
797}
798
799static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
800{
NeilBrownf72ffdd2014-09-30 14:23:59 +1000801 return sb1->set_uuid0 == sb2->set_uuid0 &&
Andre Noll05710462008-07-11 22:02:20 +1000802 sb1->set_uuid1 == sb2->set_uuid1 &&
803 sb1->set_uuid2 == sb2->set_uuid2 &&
804 sb1->set_uuid3 == sb2->set_uuid3;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805}
806
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
808{
809 int ret;
810 mdp_super_t *tmp1, *tmp2;
811
812 tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
813 tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
814
815 if (!tmp1 || !tmp2) {
816 ret = 0;
Andre Noll35020f12008-03-23 15:10:33 +0100817 printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 goto abort;
819 }
820
821 *tmp1 = *sb1;
822 *tmp2 = *sb2;
823
824 /*
825 * nr_disks is not constant
826 */
827 tmp1->nr_disks = 0;
828 tmp2->nr_disks = 0;
829
Andre Nollce0c8e02008-07-11 22:02:20 +1000830 ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831abort:
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700832 kfree(tmp1);
833 kfree(tmp2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 return ret;
835}
836
NeilBrown4d167f02007-05-09 02:35:37 -0700837static u32 md_csum_fold(u32 csum)
838{
839 csum = (csum & 0xffff) + (csum >> 16);
840 return (csum & 0xffff) + (csum >> 16);
841}
842
NeilBrownf72ffdd2014-09-30 14:23:59 +1000843static unsigned int calc_sb_csum(mdp_super_t *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844{
NeilBrown4d167f02007-05-09 02:35:37 -0700845 u64 newcsum = 0;
846 u32 *sb32 = (u32*)sb;
847 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 unsigned int disk_csum, csum;
849
850 disk_csum = sb->sb_csum;
851 sb->sb_csum = 0;
NeilBrown4d167f02007-05-09 02:35:37 -0700852
853 for (i = 0; i < MD_SB_BYTES/4 ; i++)
854 newcsum += sb32[i];
855 csum = (newcsum & 0xffffffff) + (newcsum>>32);
856
NeilBrown4d167f02007-05-09 02:35:37 -0700857#ifdef CONFIG_ALPHA
858 /* This used to use csum_partial, which was wrong for several
859 * reasons including that different results are returned on
860 * different architectures. It isn't critical that we get exactly
861 * the same return value as before (we always csum_fold before
862 * testing, and that removes any differences). However as we
863 * know that csum_partial always returned a 16bit value on
864 * alphas, do a fold to maximise conformity to previous behaviour.
865 */
866 sb->sb_csum = md_csum_fold(disk_csum);
867#else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 sb->sb_csum = disk_csum;
NeilBrown4d167f02007-05-09 02:35:37 -0700869#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 return csum;
871}
872
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873/*
874 * Handle superblock details.
875 * We want to be able to handle multiple superblock formats
876 * so we have a common interface to them all, and an array of
877 * different handlers.
878 * We rely on user-space to write the initial superblock, and support
879 * reading and updating of superblocks.
880 * Interface methods are:
NeilBrown3cb03002011-10-11 16:45:26 +1100881 * int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 * loads and validates a superblock on dev.
883 * if refdev != NULL, compare superblocks on both devices
884 * Return:
885 * 0 - dev has a superblock that is compatible with refdev
886 * 1 - dev has a superblock that is compatible and newer than refdev
887 * so dev should be used as the refdev in future
888 * -EINVAL superblock incompatible or invalid
889 * -othererror e.g. -EIO
890 *
NeilBrownfd01b882011-10-11 16:47:53 +1100891 * int validate_super(struct mddev *mddev, struct md_rdev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 * Verify that dev is acceptable into mddev.
893 * The first time, mddev->raid_disks will be 0, and data from
894 * dev should be merged in. Subsequent calls check that dev
895 * is new enough. Return 0 or -EINVAL
896 *
NeilBrownfd01b882011-10-11 16:47:53 +1100897 * void sync_super(struct mddev *mddev, struct md_rdev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 * Update the superblock for rdev with data in mddev
899 * This does not write to disc.
900 *
901 */
902
903struct super_type {
Chris Webb0cd17fe2008-06-28 08:31:46 +1000904 char *name;
905 struct module *owner;
NeilBrownc6563a82012-05-21 09:27:00 +1000906 int (*load_super)(struct md_rdev *rdev,
907 struct md_rdev *refdev,
Chris Webb0cd17fe2008-06-28 08:31:46 +1000908 int minor_version);
NeilBrownc6563a82012-05-21 09:27:00 +1000909 int (*validate_super)(struct mddev *mddev,
910 struct md_rdev *rdev);
911 void (*sync_super)(struct mddev *mddev,
912 struct md_rdev *rdev);
NeilBrown3cb03002011-10-11 16:45:26 +1100913 unsigned long long (*rdev_size_change)(struct md_rdev *rdev,
Andre Noll15f4a5f2008-07-21 14:42:12 +1000914 sector_t num_sectors);
NeilBrownc6563a82012-05-21 09:27:00 +1000915 int (*allow_new_offset)(struct md_rdev *rdev,
916 unsigned long long new_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917};
918
919/*
Andre Noll0894cc32009-06-18 08:49:23 +1000920 * Check that the given mddev has no bitmap.
921 *
922 * This function is called from the run method of all personalities that do not
923 * support bitmaps. It prints an error message and returns non-zero if mddev
924 * has a bitmap. Otherwise, it returns 0.
925 *
926 */
NeilBrownfd01b882011-10-11 16:47:53 +1100927int md_check_no_bitmap(struct mddev *mddev)
Andre Noll0894cc32009-06-18 08:49:23 +1000928{
NeilBrownc3d97142009-12-14 12:49:52 +1100929 if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
Andre Noll0894cc32009-06-18 08:49:23 +1000930 return 0;
931 printk(KERN_ERR "%s: bitmaps are not supported for %s\n",
932 mdname(mddev), mddev->pers->name);
933 return 1;
934}
935EXPORT_SYMBOL(md_check_no_bitmap);
936
937/*
NeilBrownf72ffdd2014-09-30 14:23:59 +1000938 * load_super for 0.90.0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 */
NeilBrown3cb03002011-10-11 16:45:26 +1100940static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941{
942 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
943 mdp_super_t *sb;
944 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
946 /*
Andre Noll0f420352008-07-11 22:02:23 +1000947 * Calculate the position of the superblock (512byte sectors),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 * it's at the end of the disk.
949 *
950 * It also happens to be a multiple of 4Kb.
951 */
Jonathan Brassow57b2caa2011-01-14 09:14:33 +1100952 rdev->sb_start = calc_dev_sboffset(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
NeilBrown0002b272005-09-09 16:23:53 -0700954 ret = read_disk_sb(rdev, MD_SB_BYTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 if (ret) return ret;
956
957 ret = -EINVAL;
958
959 bdevname(rdev->bdev, b);
Namhyung Kim65a06f062011-07-27 11:00:36 +1000960 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
962 if (sb->md_magic != MD_SB_MAGIC) {
963 printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
964 b);
965 goto abort;
966 }
967
968 if (sb->major_version != 0 ||
NeilBrownf6705572006-03-27 01:18:11 -0800969 sb->minor_version < 90 ||
970 sb->minor_version > 91) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
972 sb->major_version, sb->minor_version,
973 b);
974 goto abort;
975 }
976
977 if (sb->raid_disks <= 0)
978 goto abort;
979
NeilBrown4d167f02007-05-09 02:35:37 -0700980 if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
982 b);
983 goto abort;
984 }
985
986 rdev->preferred_minor = sb->md_minor;
987 rdev->data_offset = 0;
NeilBrownc6563a82012-05-21 09:27:00 +1000988 rdev->new_data_offset = 0;
NeilBrown0002b272005-09-09 16:23:53 -0700989 rdev->sb_size = MD_SB_BYTES;
NeilBrown9f2f3832011-07-28 11:31:47 +1000990 rdev->badblocks.shift = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991
992 if (sb->level == LEVEL_MULTIPATH)
993 rdev->desc_nr = -1;
994 else
995 rdev->desc_nr = sb->this_disk.number;
996
Harvey Harrison9a7b2b02008-04-28 02:15:49 -0700997 if (!refdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 ret = 1;
Harvey Harrison9a7b2b02008-04-28 02:15:49 -0700999 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 __u64 ev1, ev2;
Namhyung Kim65a06f062011-07-27 11:00:36 +10001001 mdp_super_t *refsb = page_address(refdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 if (!uuid_equal(refsb, sb)) {
1003 printk(KERN_WARNING "md: %s has different UUID to %s\n",
1004 b, bdevname(refdev->bdev,b2));
1005 goto abort;
1006 }
1007 if (!sb_equal(refsb, sb)) {
1008 printk(KERN_WARNING "md: %s has same UUID"
1009 " but different superblock to %s\n",
1010 b, bdevname(refdev->bdev, b2));
1011 goto abort;
1012 }
1013 ev1 = md_event(sb);
1014 ev2 = md_event(refsb);
1015 if (ev1 > ev2)
1016 ret = 1;
NeilBrownf72ffdd2014-09-30 14:23:59 +10001017 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 ret = 0;
1019 }
NeilBrown8190e752009-06-18 08:48:58 +10001020 rdev->sectors = rdev->sb_start;
NeilBrown667a5312012-08-16 16:46:12 +10001021 /* Limit to 4TB as metadata cannot record more than that.
1022 * (not needed for Linear and RAID0 as metadata doesn't
1023 * record this size)
1024 */
Arnd Bergmann3312c952015-12-21 10:51:01 +11001025 if (IS_ENABLED(CONFIG_LBDAF) && (u64)rdev->sectors >= (2ULL << 32) &&
1026 sb->level >= 1)
1027 rdev->sectors = (sector_t)(2ULL << 32) - 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028
NeilBrown27a7b262011-09-10 17:21:28 +10001029 if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
NeilBrown2bf071b2006-01-06 00:20:55 -08001030 /* "this cannot possibly happen" ... */
1031 ret = -EINVAL;
1032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 abort:
1034 return ret;
1035}
1036
1037/*
1038 * validate_super for 0.90.0
1039 */
NeilBrownfd01b882011-10-11 16:47:53 +11001040static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041{
1042 mdp_disk_t *desc;
Namhyung Kim65a06f062011-07-27 11:00:36 +10001043 mdp_super_t *sb = page_address(rdev->sb_page);
NeilBrown07d84d102006-06-26 00:27:56 -07001044 __u64 ev1 = md_event(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045
NeilBrown41158c72005-06-21 17:17:25 -07001046 rdev->raid_disk = -1;
NeilBrownc5d79ad2008-02-06 01:39:54 -08001047 clear_bit(Faulty, &rdev->flags);
1048 clear_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11001049 clear_bit(Bitmap_sync, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001050 clear_bit(WriteMostly, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001051
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 if (mddev->raid_disks == 0) {
1053 mddev->major_version = 0;
1054 mddev->minor_version = sb->minor_version;
1055 mddev->patch_version = sb->patch_version;
NeilBrowne6910632008-02-06 01:39:51 -08001056 mddev->external = 0;
Andre Noll9d8f0362009-06-18 08:45:01 +10001057 mddev->chunk_sectors = sb->chunk_size >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 mddev->ctime = sb->ctime;
1059 mddev->utime = sb->utime;
1060 mddev->level = sb->level;
NeilBrownd9d166c2006-01-06 00:20:51 -08001061 mddev->clevel[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 mddev->layout = sb->layout;
1063 mddev->raid_disks = sb->raid_disks;
NeilBrown27a7b262011-09-10 17:21:28 +10001064 mddev->dev_sectors = ((sector_t)sb->size) * 2;
NeilBrown07d84d102006-06-26 00:27:56 -07001065 mddev->events = ev1;
NeilBrownc3d97142009-12-14 12:49:52 +11001066 mddev->bitmap_info.offset = 0;
NeilBrown6409bb02012-05-22 13:55:07 +10001067 mddev->bitmap_info.space = 0;
1068 /* bitmap can use 60 K after the 4K superblocks */
NeilBrownc3d97142009-12-14 12:49:52 +11001069 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
NeilBrown6409bb02012-05-22 13:55:07 +10001070 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
NeilBrown2c810cd2012-05-21 09:27:00 +10001071 mddev->reshape_backwards = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072
NeilBrownf6705572006-03-27 01:18:11 -08001073 if (mddev->minor_version >= 91) {
1074 mddev->reshape_position = sb->reshape_position;
1075 mddev->delta_disks = sb->delta_disks;
1076 mddev->new_level = sb->new_level;
1077 mddev->new_layout = sb->new_layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001078 mddev->new_chunk_sectors = sb->new_chunk >> 9;
NeilBrown2c810cd2012-05-21 09:27:00 +10001079 if (mddev->delta_disks < 0)
1080 mddev->reshape_backwards = 1;
NeilBrownf6705572006-03-27 01:18:11 -08001081 } else {
1082 mddev->reshape_position = MaxSector;
1083 mddev->delta_disks = 0;
1084 mddev->new_level = mddev->level;
1085 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001086 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownf6705572006-03-27 01:18:11 -08001087 }
1088
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 if (sb->state & (1<<MD_SB_CLEAN))
1090 mddev->recovery_cp = MaxSector;
1091 else {
NeilBrownf72ffdd2014-09-30 14:23:59 +10001092 if (sb->events_hi == sb->cp_events_hi &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 sb->events_lo == sb->cp_events_lo) {
1094 mddev->recovery_cp = sb->recovery_cp;
1095 } else
1096 mddev->recovery_cp = 0;
1097 }
1098
1099 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
1100 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
1101 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
1102 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
1103
1104 mddev->max_disks = MD_SB_DISKS;
NeilBrowna654b9d82005-06-21 17:17:27 -07001105
1106 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
NeilBrown6409bb02012-05-22 13:55:07 +10001107 mddev->bitmap_info.file == NULL) {
NeilBrownc3d97142009-12-14 12:49:52 +11001108 mddev->bitmap_info.offset =
1109 mddev->bitmap_info.default_offset;
NeilBrown6409bb02012-05-22 13:55:07 +10001110 mddev->bitmap_info.space =
Dave Jonesc9ad0202013-08-19 22:26:32 -04001111 mddev->bitmap_info.default_space;
NeilBrown6409bb02012-05-22 13:55:07 +10001112 }
NeilBrowna654b9d82005-06-21 17:17:27 -07001113
NeilBrown41158c72005-06-21 17:17:25 -07001114 } else if (mddev->pers == NULL) {
NeilBrownbe6800a2010-05-18 10:17:09 +10001115 /* Insist on good event counter while assembling, except
1116 * for spares (which don't need an event count) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 ++ev1;
NeilBrownbe6800a2010-05-18 10:17:09 +10001118 if (sb->disks[rdev->desc_nr].state & (
1119 (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
NeilBrownf72ffdd2014-09-30 14:23:59 +10001120 if (ev1 < mddev->events)
NeilBrownbe6800a2010-05-18 10:17:09 +10001121 return -EINVAL;
NeilBrown41158c72005-06-21 17:17:25 -07001122 } else if (mddev->bitmap) {
1123 /* if adding to array with a bitmap, then we can accept an
1124 * older device ... but not too old.
1125 */
NeilBrown41158c72005-06-21 17:17:25 -07001126 if (ev1 < mddev->bitmap->events_cleared)
1127 return 0;
NeilBrown8313b8e2013-12-12 10:13:33 +11001128 if (ev1 < mddev->events)
1129 set_bit(Bitmap_sync, &rdev->flags);
NeilBrown07d84d102006-06-26 00:27:56 -07001130 } else {
1131 if (ev1 < mddev->events)
1132 /* just a hot-add of a new device, leave raid_disk at -1 */
1133 return 0;
1134 }
NeilBrown41158c72005-06-21 17:17:25 -07001135
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 if (mddev->level != LEVEL_MULTIPATH) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 desc = sb->disks + rdev->desc_nr;
1138
1139 if (desc->state & (1<<MD_DISK_FAULTY))
NeilBrownb2d444d2005-11-08 21:39:31 -08001140 set_bit(Faulty, &rdev->flags);
NeilBrown7c7546c2006-06-26 00:27:41 -07001141 else if (desc->state & (1<<MD_DISK_SYNC) /* &&
1142 desc->raid_disk < mddev->raid_disks */) {
NeilBrownb2d444d2005-11-08 21:39:31 -08001143 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 rdev->raid_disk = desc->raid_disk;
NeilBrownf4667222013-12-09 12:04:56 +11001145 rdev->saved_raid_disk = desc->raid_disk;
NeilBrown0261cd9f2009-11-13 17:40:48 +11001146 } else if (desc->state & (1<<MD_DISK_ACTIVE)) {
1147 /* active but not in sync implies recovery up to
1148 * reshape position. We don't know exactly where
1149 * that is, so set to zero for now */
1150 if (mddev->minor_version >= 91) {
1151 rdev->recovery_offset = 0;
1152 rdev->raid_disk = desc->raid_disk;
1153 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07001155 if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
1156 set_bit(WriteMostly, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001157 } else /* MULTIPATH are always insync */
NeilBrownb2d444d2005-11-08 21:39:31 -08001158 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 return 0;
1160}
1161
1162/*
1163 * sync_super for 0.90.0
1164 */
NeilBrownfd01b882011-10-11 16:47:53 +11001165static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166{
1167 mdp_super_t *sb;
NeilBrown3cb03002011-10-11 16:45:26 +11001168 struct md_rdev *rdev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 int next_spare = mddev->raid_disks;
NeilBrown19133a42005-11-08 21:39:35 -08001170
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 /* make rdev->sb match mddev data..
1172 *
1173 * 1/ zero out disks
1174 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
1175 * 3/ any empty disks < next_spare become removed
1176 *
1177 * disks[0] gets initialised to REMOVED because
1178 * we cannot be sure from other fields if it has
1179 * been initialised or not.
1180 */
1181 int i;
1182 int active=0, working=0,failed=0,spare=0,nr_disks=0;
1183
NeilBrown61181562005-09-09 16:24:02 -07001184 rdev->sb_size = MD_SB_BYTES;
1185
Namhyung Kim65a06f062011-07-27 11:00:36 +10001186 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187
1188 memset(sb, 0, sizeof(*sb));
1189
1190 sb->md_magic = MD_SB_MAGIC;
1191 sb->major_version = mddev->major_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 sb->patch_version = mddev->patch_version;
1193 sb->gvalid_words = 0; /* ignored */
1194 memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
1195 memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
1196 memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
1197 memcpy(&sb->set_uuid3, mddev->uuid+12,4);
1198
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11001199 sb->ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 sb->level = mddev->level;
Andre Noll58c0fed2009-03-31 14:33:13 +11001201 sb->size = mddev->dev_sectors / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 sb->raid_disks = mddev->raid_disks;
1203 sb->md_minor = mddev->md_minor;
NeilBrowne6910632008-02-06 01:39:51 -08001204 sb->not_persistent = 0;
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11001205 sb->utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 sb->state = 0;
1207 sb->events_hi = (mddev->events>>32);
1208 sb->events_lo = (u32)mddev->events;
1209
NeilBrownf6705572006-03-27 01:18:11 -08001210 if (mddev->reshape_position == MaxSector)
1211 sb->minor_version = 90;
1212 else {
1213 sb->minor_version = 91;
1214 sb->reshape_position = mddev->reshape_position;
1215 sb->new_level = mddev->new_level;
1216 sb->delta_disks = mddev->delta_disks;
1217 sb->new_layout = mddev->new_layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001218 sb->new_chunk = mddev->new_chunk_sectors << 9;
NeilBrownf6705572006-03-27 01:18:11 -08001219 }
1220 mddev->minor_version = sb->minor_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 if (mddev->in_sync)
1222 {
1223 sb->recovery_cp = mddev->recovery_cp;
1224 sb->cp_events_hi = (mddev->events>>32);
1225 sb->cp_events_lo = (u32)mddev->events;
1226 if (mddev->recovery_cp == MaxSector)
1227 sb->state = (1<< MD_SB_CLEAN);
1228 } else
1229 sb->recovery_cp = 0;
1230
1231 sb->layout = mddev->layout;
Andre Noll9d8f0362009-06-18 08:45:01 +10001232 sb->chunk_size = mddev->chunk_sectors << 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233
NeilBrownc3d97142009-12-14 12:49:52 +11001234 if (mddev->bitmap && mddev->bitmap_info.file == NULL)
NeilBrowna654b9d82005-06-21 17:17:27 -07001235 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
1236
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 sb->disks[0].state = (1<<MD_DISK_REMOVED);
NeilBrowndafb20f2012-03-19 12:46:39 +11001238 rdev_for_each(rdev2, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 mdp_disk_t *d;
NeilBrown86e6ffd2005-11-08 21:39:24 -08001240 int desc_nr;
NeilBrown0261cd9f2009-11-13 17:40:48 +11001241 int is_active = test_bit(In_sync, &rdev2->flags);
1242
1243 if (rdev2->raid_disk >= 0 &&
1244 sb->minor_version >= 91)
1245 /* we have nowhere to store the recovery_offset,
1246 * but if it is not below the reshape_position,
1247 * we can piggy-back on that.
1248 */
1249 is_active = 1;
1250 if (rdev2->raid_disk < 0 ||
1251 test_bit(Faulty, &rdev2->flags))
1252 is_active = 0;
1253 if (is_active)
NeilBrown86e6ffd2005-11-08 21:39:24 -08001254 desc_nr = rdev2->raid_disk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 else
NeilBrown86e6ffd2005-11-08 21:39:24 -08001256 desc_nr = next_spare++;
NeilBrown19133a42005-11-08 21:39:35 -08001257 rdev2->desc_nr = desc_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 d = &sb->disks[rdev2->desc_nr];
1259 nr_disks++;
1260 d->number = rdev2->desc_nr;
1261 d->major = MAJOR(rdev2->bdev->bd_dev);
1262 d->minor = MINOR(rdev2->bdev->bd_dev);
NeilBrown0261cd9f2009-11-13 17:40:48 +11001263 if (is_active)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 d->raid_disk = rdev2->raid_disk;
1265 else
1266 d->raid_disk = rdev2->desc_nr; /* compatibility */
NeilBrown1be78922006-03-27 01:18:03 -08001267 if (test_bit(Faulty, &rdev2->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 d->state = (1<<MD_DISK_FAULTY);
NeilBrown0261cd9f2009-11-13 17:40:48 +11001269 else if (is_active) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 d->state = (1<<MD_DISK_ACTIVE);
NeilBrown0261cd9f2009-11-13 17:40:48 +11001271 if (test_bit(In_sync, &rdev2->flags))
1272 d->state |= (1<<MD_DISK_SYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 active++;
1274 working++;
1275 } else {
1276 d->state = 0;
1277 spare++;
1278 working++;
1279 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07001280 if (test_bit(WriteMostly, &rdev2->flags))
1281 d->state |= (1<<MD_DISK_WRITEMOSTLY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 /* now set the "removed" and "faulty" bits on any missing devices */
1284 for (i=0 ; i < mddev->raid_disks ; i++) {
1285 mdp_disk_t *d = &sb->disks[i];
1286 if (d->state == 0 && d->number == 0) {
1287 d->number = i;
1288 d->raid_disk = i;
1289 d->state = (1<<MD_DISK_REMOVED);
1290 d->state |= (1<<MD_DISK_FAULTY);
1291 failed++;
1292 }
1293 }
1294 sb->nr_disks = nr_disks;
1295 sb->active_disks = active;
1296 sb->working_disks = working;
1297 sb->failed_disks = failed;
1298 sb->spare_disks = spare;
1299
1300 sb->this_disk = sb->disks[rdev->desc_nr];
1301 sb->sb_csum = calc_sb_csum(sb);
1302}
1303
1304/*
Chris Webb0cd17fe2008-06-28 08:31:46 +10001305 * rdev_size_change for 0.90.0
1306 */
1307static unsigned long long
NeilBrown3cb03002011-10-11 16:45:26 +11001308super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001309{
Andre Noll58c0fed2009-03-31 14:33:13 +11001310 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001311 return 0; /* component must fit device */
NeilBrownc3d97142009-12-14 12:49:52 +11001312 if (rdev->mddev->bitmap_info.offset)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001313 return 0; /* can't move bitmap */
Jonathan Brassow57b2caa2011-01-14 09:14:33 +11001314 rdev->sb_start = calc_dev_sboffset(rdev);
Andre Noll15f4a5f2008-07-21 14:42:12 +10001315 if (!num_sectors || num_sectors > rdev->sb_start)
1316 num_sectors = rdev->sb_start;
NeilBrown27a7b262011-09-10 17:21:28 +10001317 /* Limit to 4TB as metadata cannot record more than that.
1318 * 4TB == 2^32 KB, or 2*2^32 sectors.
1319 */
Arnd Bergmann3312c952015-12-21 10:51:01 +11001320 if (IS_ENABLED(CONFIG_LBDAF) && (u64)num_sectors >= (2ULL << 32) &&
1321 rdev->mddev->level >= 1)
1322 num_sectors = (sector_t)(2ULL << 32) - 2;
Andre Noll0f420352008-07-11 22:02:23 +10001323 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001324 rdev->sb_page);
1325 md_super_wait(rdev->mddev);
Justin Maggardc26a44e2010-11-24 16:36:17 +11001326 return num_sectors;
Chris Webb0cd17fe2008-06-28 08:31:46 +10001327}
1328
NeilBrownc6563a82012-05-21 09:27:00 +10001329static int
1330super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset)
1331{
1332 /* non-zero offset changes not possible with v0.90 */
1333 return new_offset == 0;
1334}
Chris Webb0cd17fe2008-06-28 08:31:46 +10001335
1336/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 * version 1 superblock
1338 */
1339
NeilBrownf72ffdd2014-09-30 14:23:59 +10001340static __le32 calc_sb_1_csum(struct mdp_superblock_1 *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341{
NeilBrown1c05b4b2006-10-21 10:24:08 -07001342 __le32 disk_csum;
1343 u32 csum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 unsigned long long newcsum;
1345 int size = 256 + le32_to_cpu(sb->max_dev)*2;
NeilBrown1c05b4b2006-10-21 10:24:08 -07001346 __le32 *isuper = (__le32*)sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347
1348 disk_csum = sb->sb_csum;
1349 sb->sb_csum = 0;
1350 newcsum = 0;
NeilBrown1f3c9902012-12-11 13:09:00 +11001351 for (; size >= 4; size -= 4)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 newcsum += le32_to_cpu(*isuper++);
1353
1354 if (size == 2)
NeilBrown1c05b4b2006-10-21 10:24:08 -07001355 newcsum += le16_to_cpu(*(__le16*) isuper);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
1357 csum = (newcsum & 0xffffffff) + (newcsum >> 32);
1358 sb->sb_csum = disk_csum;
1359 return cpu_to_le32(csum);
1360}
1361
NeilBrown3cb03002011-10-11 16:45:26 +11001362static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363{
1364 struct mdp_superblock_1 *sb;
1365 int ret;
Andre Noll0f420352008-07-11 22:02:23 +10001366 sector_t sb_start;
NeilBrownc6563a82012-05-21 09:27:00 +10001367 sector_t sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
NeilBrown0002b272005-09-09 16:23:53 -07001369 int bmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
1371 /*
Andre Noll0f420352008-07-11 22:02:23 +10001372 * Calculate the position of the superblock in 512byte sectors.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 * It is always aligned to a 4K boundary and
1374 * depeding on minor_version, it can be:
1375 * 0: At least 8K, but less than 12K, from end of device
1376 * 1: At start of device
1377 * 2: 4K from start of device.
1378 */
1379 switch(minor_version) {
1380 case 0:
Mike Snitzer77304d22010-11-08 14:39:12 +01001381 sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;
Andre Noll0f420352008-07-11 22:02:23 +10001382 sb_start -= 8*2;
1383 sb_start &= ~(sector_t)(4*2-1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 break;
1385 case 1:
Andre Noll0f420352008-07-11 22:02:23 +10001386 sb_start = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 break;
1388 case 2:
Andre Noll0f420352008-07-11 22:02:23 +10001389 sb_start = 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 break;
1391 default:
1392 return -EINVAL;
1393 }
Andre Noll0f420352008-07-11 22:02:23 +10001394 rdev->sb_start = sb_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395
NeilBrown0002b272005-09-09 16:23:53 -07001396 /* superblock is rarely larger than 1K, but it can be larger,
1397 * and it is safe to read 4k, so we do that
1398 */
1399 ret = read_disk_sb(rdev, 4096);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 if (ret) return ret;
1401
Namhyung Kim65a06f062011-07-27 11:00:36 +10001402 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403
1404 if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
1405 sb->major_version != cpu_to_le32(1) ||
1406 le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
Andre Noll0f420352008-07-11 22:02:23 +10001407 le64_to_cpu(sb->super_offset) != rdev->sb_start ||
NeilBrown71c08052005-09-09 16:23:51 -07001408 (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 return -EINVAL;
1410
1411 if (calc_sb_1_csum(sb) != sb->sb_csum) {
1412 printk("md: invalid superblock checksum on %s\n",
1413 bdevname(rdev->bdev,b));
1414 return -EINVAL;
1415 }
1416 if (le64_to_cpu(sb->data_size) < 10) {
1417 printk("md: data_size too small on %s\n",
1418 bdevname(rdev->bdev,b));
1419 return -EINVAL;
1420 }
NeilBrownc6563a82012-05-21 09:27:00 +10001421 if (sb->pad0 ||
1422 sb->pad3[0] ||
1423 memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1])))
1424 /* Some padding is non-zero, might be a new feature */
1425 return -EINVAL;
NeilBrowne11e93f2007-05-09 02:35:36 -07001426
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 rdev->preferred_minor = 0xffff;
1428 rdev->data_offset = le64_to_cpu(sb->data_offset);
NeilBrownc6563a82012-05-21 09:27:00 +10001429 rdev->new_data_offset = rdev->data_offset;
1430 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) &&
1431 (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
1432 rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset);
NeilBrown4dbcdc72006-01-06 00:20:52 -08001433 atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
NeilBrown0002b272005-09-09 16:23:53 -07001435 rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
Martin K. Petersene1defc42009-05-22 17:17:49 -04001436 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
NeilBrown0002b272005-09-09 16:23:53 -07001437 if (rdev->sb_size & bmask)
NeilBrowna1801f82008-03-04 14:29:31 -08001438 rdev->sb_size = (rdev->sb_size | bmask) + 1;
1439
1440 if (minor_version
Andre Noll0f420352008-07-11 22:02:23 +10001441 && rdev->data_offset < sb_start + (rdev->sb_size/512))
NeilBrowna1801f82008-03-04 14:29:31 -08001442 return -EINVAL;
NeilBrownc6563a82012-05-21 09:27:00 +10001443 if (minor_version
1444 && rdev->new_data_offset < sb_start + (rdev->sb_size/512))
1445 return -EINVAL;
NeilBrown0002b272005-09-09 16:23:53 -07001446
NeilBrown31b65a02006-07-10 04:44:14 -07001447 if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
1448 rdev->desc_nr = -1;
1449 else
1450 rdev->desc_nr = le32_to_cpu(sb->dev_number);
1451
NeilBrown2699b672011-07-28 11:31:47 +10001452 if (!rdev->bb_page) {
1453 rdev->bb_page = alloc_page(GFP_KERNEL);
1454 if (!rdev->bb_page)
1455 return -ENOMEM;
1456 }
1457 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
1458 rdev->badblocks.count == 0) {
1459 /* need to load the bad block list.
1460 * Currently we limit it to one page.
1461 */
1462 s32 offset;
1463 sector_t bb_sector;
1464 u64 *bbp;
1465 int i;
1466 int sectors = le16_to_cpu(sb->bblog_size);
1467 if (sectors > (PAGE_SIZE / 512))
1468 return -EINVAL;
1469 offset = le32_to_cpu(sb->bblog_offset);
1470 if (offset == 0)
1471 return -EINVAL;
1472 bb_sector = (long long)offset;
1473 if (!sync_page_io(rdev, bb_sector, sectors << 9,
1474 rdev->bb_page, READ, true))
1475 return -EIO;
1476 bbp = (u64 *)page_address(rdev->bb_page);
1477 rdev->badblocks.shift = sb->bblog_shift;
1478 for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
1479 u64 bb = le64_to_cpu(*bbp);
1480 int count = bb & (0x3ff);
1481 u64 sector = bb >> 10;
1482 sector <<= sb->bblog_shift;
1483 count <<= sb->bblog_shift;
1484 if (bb + 1 == 0)
1485 break;
Vishal Vermafc974ee2015-12-24 19:20:34 -07001486 if (badblocks_set(&rdev->badblocks, sector, count, 1))
NeilBrown2699b672011-07-28 11:31:47 +10001487 return -EINVAL;
1488 }
NeilBrown486adf72013-04-24 11:42:44 +10001489 } else if (sb->bblog_offset != 0)
1490 rdev->badblocks.shift = 0;
NeilBrown2699b672011-07-28 11:31:47 +10001491
Harvey Harrison9a7b2b02008-04-28 02:15:49 -07001492 if (!refdev) {
NeilBrown8ed75462006-02-03 03:03:41 -08001493 ret = 1;
Harvey Harrison9a7b2b02008-04-28 02:15:49 -07001494 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 __u64 ev1, ev2;
Namhyung Kim65a06f062011-07-27 11:00:36 +10001496 struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
1498 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1499 sb->level != refsb->level ||
1500 sb->layout != refsb->layout ||
1501 sb->chunksize != refsb->chunksize) {
1502 printk(KERN_WARNING "md: %s has strangely different"
1503 " superblock to %s\n",
1504 bdevname(rdev->bdev,b),
1505 bdevname(refdev->bdev,b2));
1506 return -EINVAL;
1507 }
1508 ev1 = le64_to_cpu(sb->events);
1509 ev2 = le64_to_cpu(refsb->events);
1510
1511 if (ev1 > ev2)
NeilBrown8ed75462006-02-03 03:03:41 -08001512 ret = 1;
1513 else
1514 ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 }
NeilBrownc6563a82012-05-21 09:27:00 +10001516 if (minor_version) {
1517 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9);
1518 sectors -= rdev->data_offset;
1519 } else
1520 sectors = rdev->sb_start;
1521 if (sectors < le64_to_cpu(sb->data_size))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 return -EINVAL;
Andre Nolldd8ac332009-03-31 14:33:13 +11001523 rdev->sectors = le64_to_cpu(sb->data_size);
NeilBrown8ed75462006-02-03 03:03:41 -08001524 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525}
1526
NeilBrownfd01b882011-10-11 16:47:53 +11001527static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528{
Namhyung Kim65a06f062011-07-27 11:00:36 +10001529 struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
NeilBrown07d84d102006-06-26 00:27:56 -07001530 __u64 ev1 = le64_to_cpu(sb->events);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
NeilBrown41158c72005-06-21 17:17:25 -07001532 rdev->raid_disk = -1;
NeilBrownc5d79ad2008-02-06 01:39:54 -08001533 clear_bit(Faulty, &rdev->flags);
1534 clear_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11001535 clear_bit(Bitmap_sync, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001536 clear_bit(WriteMostly, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001537
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 if (mddev->raid_disks == 0) {
1539 mddev->major_version = 1;
1540 mddev->patch_version = 0;
NeilBrowne6910632008-02-06 01:39:51 -08001541 mddev->external = 0;
Andre Noll9d8f0362009-06-18 08:45:01 +10001542 mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11001543 mddev->ctime = le64_to_cpu(sb->ctime);
1544 mddev->utime = le64_to_cpu(sb->utime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 mddev->level = le32_to_cpu(sb->level);
NeilBrownd9d166c2006-01-06 00:20:51 -08001546 mddev->clevel[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 mddev->layout = le32_to_cpu(sb->layout);
1548 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
Andre Noll58c0fed2009-03-31 14:33:13 +11001549 mddev->dev_sectors = le64_to_cpu(sb->size);
NeilBrown07d84d102006-06-26 00:27:56 -07001550 mddev->events = ev1;
NeilBrownc3d97142009-12-14 12:49:52 +11001551 mddev->bitmap_info.offset = 0;
NeilBrown6409bb02012-05-22 13:55:07 +10001552 mddev->bitmap_info.space = 0;
1553 /* Default location for bitmap is 1K after superblock
1554 * using 3K - total of 4K
1555 */
NeilBrownc3d97142009-12-14 12:49:52 +11001556 mddev->bitmap_info.default_offset = 1024 >> 9;
NeilBrown6409bb02012-05-22 13:55:07 +10001557 mddev->bitmap_info.default_space = (4096-1024) >> 9;
NeilBrown2c810cd2012-05-21 09:27:00 +10001558 mddev->reshape_backwards = 0;
1559
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1561 memcpy(mddev->uuid, sb->set_uuid, 16);
1562
1563 mddev->max_disks = (4096-256)/2;
NeilBrowna654b9d82005-06-21 17:17:27 -07001564
NeilBrown71c08052005-09-09 16:23:51 -07001565 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
NeilBrown6409bb02012-05-22 13:55:07 +10001566 mddev->bitmap_info.file == NULL) {
NeilBrownc3d97142009-12-14 12:49:52 +11001567 mddev->bitmap_info.offset =
1568 (__s32)le32_to_cpu(sb->bitmap_offset);
NeilBrown6409bb02012-05-22 13:55:07 +10001569 /* Metadata doesn't record how much space is available.
1570 * For 1.0, we assume we can use up to the superblock
1571 * if before, else to 4K beyond superblock.
1572 * For others, assume no change is possible.
1573 */
1574 if (mddev->minor_version > 0)
1575 mddev->bitmap_info.space = 0;
1576 else if (mddev->bitmap_info.offset > 0)
1577 mddev->bitmap_info.space =
1578 8 - mddev->bitmap_info.offset;
1579 else
1580 mddev->bitmap_info.space =
1581 -mddev->bitmap_info.offset;
1582 }
NeilBrowne11e93f2007-05-09 02:35:36 -07001583
NeilBrownf6705572006-03-27 01:18:11 -08001584 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
1585 mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1586 mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1587 mddev->new_level = le32_to_cpu(sb->new_level);
1588 mddev->new_layout = le32_to_cpu(sb->new_layout);
Andre Noll664e7c42009-06-18 08:45:27 +10001589 mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
NeilBrown2c810cd2012-05-21 09:27:00 +10001590 if (mddev->delta_disks < 0 ||
1591 (mddev->delta_disks == 0 &&
1592 (le32_to_cpu(sb->feature_map)
1593 & MD_FEATURE_RESHAPE_BACKWARDS)))
1594 mddev->reshape_backwards = 1;
NeilBrownf6705572006-03-27 01:18:11 -08001595 } else {
1596 mddev->reshape_position = MaxSector;
1597 mddev->delta_disks = 0;
1598 mddev->new_level = mddev->level;
1599 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001600 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownf6705572006-03-27 01:18:11 -08001601 }
1602
Shaohua Lia62ab492016-01-06 14:37:13 -08001603 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL) {
1604 set_bit(MD_HAS_JOURNAL, &mddev->flags);
1605 if (mddev->recovery_cp == MaxSector)
1606 set_bit(MD_JOURNAL_CLEAN, &mddev->flags);
1607 }
NeilBrown41158c72005-06-21 17:17:25 -07001608 } else if (mddev->pers == NULL) {
NeilBrownbe6800a2010-05-18 10:17:09 +10001609 /* Insist of good event counter while assembling, except for
1610 * spares (which don't need an event count) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 ++ev1;
NeilBrownbe6800a2010-05-18 10:17:09 +10001612 if (rdev->desc_nr >= 0 &&
1613 rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
Song Liua3dfbda2015-10-08 21:54:11 -07001614 (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX ||
1615 le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL))
NeilBrownbe6800a2010-05-18 10:17:09 +10001616 if (ev1 < mddev->events)
1617 return -EINVAL;
NeilBrown41158c72005-06-21 17:17:25 -07001618 } else if (mddev->bitmap) {
1619 /* If adding to array with a bitmap, then we can accept an
1620 * older device, but not too old.
1621 */
NeilBrown41158c72005-06-21 17:17:25 -07001622 if (ev1 < mddev->bitmap->events_cleared)
1623 return 0;
NeilBrown8313b8e2013-12-12 10:13:33 +11001624 if (ev1 < mddev->events)
1625 set_bit(Bitmap_sync, &rdev->flags);
NeilBrown07d84d102006-06-26 00:27:56 -07001626 } else {
1627 if (ev1 < mddev->events)
1628 /* just a hot-add of a new device, leave raid_disk at -1 */
1629 return 0;
1630 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 if (mddev->level != LEVEL_MULTIPATH) {
1632 int role;
NeilBrown3673f302009-08-03 10:59:56 +10001633 if (rdev->desc_nr < 0 ||
1634 rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
Song Liuc4d4c912015-08-13 14:31:54 -07001635 role = MD_DISK_ROLE_SPARE;
NeilBrown3673f302009-08-03 10:59:56 +10001636 rdev->desc_nr = -1;
1637 } else
1638 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 switch(role) {
Song Liuc4d4c912015-08-13 14:31:54 -07001640 case MD_DISK_ROLE_SPARE: /* spare */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 break;
Song Liuc4d4c912015-08-13 14:31:54 -07001642 case MD_DISK_ROLE_FAULTY: /* faulty */
NeilBrownb2d444d2005-11-08 21:39:31 -08001643 set_bit(Faulty, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 break;
Song Liubac624f2015-08-13 14:31:55 -07001645 case MD_DISK_ROLE_JOURNAL: /* journal device */
1646 if (!(le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)) {
1647 /* journal device without journal feature */
1648 printk(KERN_WARNING
1649 "md: journal device provided without journal feature, ignoring the device\n");
1650 return -EINVAL;
1651 }
1652 set_bit(Journal, &rdev->flags);
Shaohua Li3069aa82015-08-13 14:31:56 -07001653 rdev->journal_tail = le64_to_cpu(sb->journal_tail);
Shaohua Li9b156032015-12-18 15:19:16 +11001654 rdev->raid_disk = 0;
Song Liubac624f2015-08-13 14:31:55 -07001655 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 default:
NeilBrownf4667222013-12-09 12:04:56 +11001657 rdev->saved_raid_disk = role;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001658 if ((le32_to_cpu(sb->feature_map) &
NeilBrownf4667222013-12-09 12:04:56 +11001659 MD_FEATURE_RECOVERY_OFFSET)) {
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001660 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
NeilBrownf4667222013-12-09 12:04:56 +11001661 if (!(le32_to_cpu(sb->feature_map) &
1662 MD_FEATURE_RECOVERY_BITMAP))
1663 rdev->saved_raid_disk = -1;
1664 } else
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001665 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 rdev->raid_disk = role;
1667 break;
1668 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07001669 if (sb->devflags & WriteMostly1)
1670 set_bit(WriteMostly, &rdev->flags);
NeilBrown2d78f8c2011-12-23 10:17:51 +11001671 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT)
1672 set_bit(Replacement, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001673 } else /* MULTIPATH are always insync */
NeilBrownb2d444d2005-11-08 21:39:31 -08001674 set_bit(In_sync, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001675
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 return 0;
1677}
1678
NeilBrownfd01b882011-10-11 16:47:53 +11001679static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680{
1681 struct mdp_superblock_1 *sb;
NeilBrown3cb03002011-10-11 16:45:26 +11001682 struct md_rdev *rdev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 int max_dev, i;
1684 /* make rdev->sb match mddev and rdev data. */
1685
Namhyung Kim65a06f062011-07-27 11:00:36 +10001686 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687
1688 sb->feature_map = 0;
1689 sb->pad0 = 0;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001690 sb->recovery_offset = cpu_to_le64(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 memset(sb->pad3, 0, sizeof(sb->pad3));
1692
1693 sb->utime = cpu_to_le64((__u64)mddev->utime);
1694 sb->events = cpu_to_le64(mddev->events);
1695 if (mddev->in_sync)
1696 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
Shaohua Libd18f642015-09-02 13:49:50 -07001697 else if (test_bit(MD_JOURNAL_CLEAN, &mddev->flags))
1698 sb->resync_offset = cpu_to_le64(MaxSector);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 else
1700 sb->resync_offset = cpu_to_le64(0);
1701
NeilBrown1c05b4b2006-10-21 10:24:08 -07001702 sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
NeilBrown4dbcdc72006-01-06 00:20:52 -08001703
NeilBrownf0ca3402006-02-02 14:28:04 -08001704 sb->raid_disks = cpu_to_le32(mddev->raid_disks);
Andre Noll58c0fed2009-03-31 14:33:13 +11001705 sb->size = cpu_to_le64(mddev->dev_sectors);
Andre Noll9d8f0362009-06-18 08:45:01 +10001706 sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
NeilBrown62e1e382009-05-26 09:40:59 +10001707 sb->level = cpu_to_le32(mddev->level);
1708 sb->layout = cpu_to_le32(mddev->layout);
NeilBrownf0ca3402006-02-02 14:28:04 -08001709
NeilBrownaeb9b212011-08-25 14:43:08 +10001710 if (test_bit(WriteMostly, &rdev->flags))
1711 sb->devflags |= WriteMostly1;
1712 else
1713 sb->devflags &= ~WriteMostly1;
NeilBrownc6563a82012-05-21 09:27:00 +10001714 sb->data_offset = cpu_to_le64(rdev->data_offset);
1715 sb->data_size = cpu_to_le64(rdev->sectors);
NeilBrownaeb9b212011-08-25 14:43:08 +10001716
NeilBrownc3d97142009-12-14 12:49:52 +11001717 if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
1718 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
NeilBrown71c08052005-09-09 16:23:51 -07001719 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
NeilBrowna654b9d82005-06-21 17:17:27 -07001720 }
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001721
Shaohua Lif2076e72015-10-08 21:54:12 -07001722 if (rdev->raid_disk >= 0 && !test_bit(Journal, &rdev->flags) &&
NeilBrown97e4f422009-03-31 14:33:13 +11001723 !test_bit(In_sync, &rdev->flags)) {
NeilBrown93be75f2009-12-14 12:50:06 +11001724 sb->feature_map |=
1725 cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
1726 sb->recovery_offset =
1727 cpu_to_le64(rdev->recovery_offset);
NeilBrownf4667222013-12-09 12:04:56 +11001728 if (rdev->saved_raid_disk >= 0 && mddev->bitmap)
1729 sb->feature_map |=
1730 cpu_to_le32(MD_FEATURE_RECOVERY_BITMAP);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001731 }
Shaohua Li3069aa82015-08-13 14:31:56 -07001732 /* Note: recovery_offset and journal_tail share space */
1733 if (test_bit(Journal, &rdev->flags))
1734 sb->journal_tail = cpu_to_le64(rdev->journal_tail);
NeilBrown2d78f8c2011-12-23 10:17:51 +11001735 if (test_bit(Replacement, &rdev->flags))
1736 sb->feature_map |=
1737 cpu_to_le32(MD_FEATURE_REPLACEMENT);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001738
NeilBrownf6705572006-03-27 01:18:11 -08001739 if (mddev->reshape_position != MaxSector) {
1740 sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
1741 sb->reshape_position = cpu_to_le64(mddev->reshape_position);
1742 sb->new_layout = cpu_to_le32(mddev->new_layout);
1743 sb->delta_disks = cpu_to_le32(mddev->delta_disks);
1744 sb->new_level = cpu_to_le32(mddev->new_level);
Andre Noll664e7c42009-06-18 08:45:27 +10001745 sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
NeilBrown2c810cd2012-05-21 09:27:00 +10001746 if (mddev->delta_disks == 0 &&
1747 mddev->reshape_backwards)
1748 sb->feature_map
1749 |= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
NeilBrownc6563a82012-05-21 09:27:00 +10001750 if (rdev->new_data_offset != rdev->data_offset) {
1751 sb->feature_map
1752 |= cpu_to_le32(MD_FEATURE_NEW_OFFSET);
1753 sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset
1754 - rdev->data_offset));
1755 }
NeilBrownf6705572006-03-27 01:18:11 -08001756 }
NeilBrowna654b9d82005-06-21 17:17:27 -07001757
Goldwyn Rodrigues3c462c82015-08-19 07:35:54 +10001758 if (mddev_is_clustered(mddev))
1759 sb->feature_map |= cpu_to_le32(MD_FEATURE_CLUSTERED);
1760
NeilBrown2699b672011-07-28 11:31:47 +10001761 if (rdev->badblocks.count == 0)
1762 /* Nothing to do for bad blocks*/ ;
1763 else if (sb->bblog_offset == 0)
1764 /* Cannot record bad blocks on this device */
1765 md_error(mddev, rdev);
1766 else {
1767 struct badblocks *bb = &rdev->badblocks;
1768 u64 *bbp = (u64 *)page_address(rdev->bb_page);
1769 u64 *p = bb->page;
1770 sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
1771 if (bb->changed) {
1772 unsigned seq;
1773
1774retry:
1775 seq = read_seqbegin(&bb->lock);
1776
1777 memset(bbp, 0xff, PAGE_SIZE);
1778
1779 for (i = 0 ; i < bb->count ; i++) {
majianpeng35f9ac22012-11-08 08:56:27 +08001780 u64 internal_bb = p[i];
NeilBrown2699b672011-07-28 11:31:47 +10001781 u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
1782 | BB_LEN(internal_bb));
majianpeng35f9ac22012-11-08 08:56:27 +08001783 bbp[i] = cpu_to_le64(store_bb);
NeilBrown2699b672011-07-28 11:31:47 +10001784 }
NeilBrownd0962932012-03-19 12:46:41 +11001785 bb->changed = 0;
NeilBrown2699b672011-07-28 11:31:47 +10001786 if (read_seqretry(&bb->lock, seq))
1787 goto retry;
1788
1789 bb->sector = (rdev->sb_start +
1790 (int)le32_to_cpu(sb->bblog_offset));
1791 bb->size = le16_to_cpu(sb->bblog_size);
NeilBrown2699b672011-07-28 11:31:47 +10001792 }
1793 }
1794
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 max_dev = 0;
NeilBrowndafb20f2012-03-19 12:46:39 +11001796 rdev_for_each(rdev2, mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 if (rdev2->desc_nr+1 > max_dev)
1798 max_dev = rdev2->desc_nr+1;
NeilBrowna778b732007-05-23 13:58:10 -07001799
NeilBrown70471da2009-08-03 10:59:57 +10001800 if (max_dev > le32_to_cpu(sb->max_dev)) {
1801 int bmask;
NeilBrowna778b732007-05-23 13:58:10 -07001802 sb->max_dev = cpu_to_le32(max_dev);
NeilBrown70471da2009-08-03 10:59:57 +10001803 rdev->sb_size = max_dev * 2 + 256;
1804 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1805 if (rdev->sb_size & bmask)
1806 rdev->sb_size = (rdev->sb_size | bmask) + 1;
NeilBrownddcf3522010-09-08 16:48:17 +10001807 } else
1808 max_dev = le32_to_cpu(sb->max_dev);
1809
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 for (i=0; i<max_dev;i++)
Song Liuc4d4c912015-08-13 14:31:54 -07001811 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_FAULTY);
NeilBrownf72ffdd2014-09-30 14:23:59 +10001812
Song Liua97b7892015-10-08 21:54:09 -07001813 if (test_bit(MD_HAS_JOURNAL, &mddev->flags))
1814 sb->feature_map |= cpu_to_le32(MD_FEATURE_JOURNAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815
NeilBrowndafb20f2012-03-19 12:46:39 +11001816 rdev_for_each(rdev2, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 i = rdev2->desc_nr;
NeilBrownb2d444d2005-11-08 21:39:31 -08001818 if (test_bit(Faulty, &rdev2->flags))
Song Liuc4d4c912015-08-13 14:31:54 -07001819 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_FAULTY);
NeilBrownb2d444d2005-11-08 21:39:31 -08001820 else if (test_bit(In_sync, &rdev2->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
Song Liua97b7892015-10-08 21:54:09 -07001822 else if (test_bit(Journal, &rdev2->flags))
Song Liubac624f2015-08-13 14:31:55 -07001823 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_JOURNAL);
NeilBrown93be75f2009-12-14 12:50:06 +11001824 else if (rdev2->raid_disk >= 0)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001825 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 else
Song Liuc4d4c912015-08-13 14:31:54 -07001827 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 }
1829
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 sb->sb_csum = calc_sb_1_csum(sb);
1831}
1832
Chris Webb0cd17fe2008-06-28 08:31:46 +10001833static unsigned long long
NeilBrown3cb03002011-10-11 16:45:26 +11001834super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001835{
1836 struct mdp_superblock_1 *sb;
Andre Noll15f4a5f2008-07-21 14:42:12 +10001837 sector_t max_sectors;
Andre Noll58c0fed2009-03-31 14:33:13 +11001838 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001839 return 0; /* component must fit device */
NeilBrownc6563a82012-05-21 09:27:00 +10001840 if (rdev->data_offset != rdev->new_data_offset)
1841 return 0; /* too confusing */
Andre Noll0f420352008-07-11 22:02:23 +10001842 if (rdev->sb_start < rdev->data_offset) {
Chris Webb0cd17fe2008-06-28 08:31:46 +10001843 /* minor versions 1 and 2; superblock before data */
Mike Snitzer77304d22010-11-08 14:39:12 +01001844 max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9;
Andre Noll15f4a5f2008-07-21 14:42:12 +10001845 max_sectors -= rdev->data_offset;
1846 if (!num_sectors || num_sectors > max_sectors)
1847 num_sectors = max_sectors;
NeilBrownc3d97142009-12-14 12:49:52 +11001848 } else if (rdev->mddev->bitmap_info.offset) {
Chris Webb0cd17fe2008-06-28 08:31:46 +10001849 /* minor version 0 with bitmap we can't move */
1850 return 0;
1851 } else {
1852 /* minor version 0; superblock after data */
Andre Noll0f420352008-07-11 22:02:23 +10001853 sector_t sb_start;
Mike Snitzer77304d22010-11-08 14:39:12 +01001854 sb_start = (i_size_read(rdev->bdev->bd_inode) >> 9) - 8*2;
Andre Noll0f420352008-07-11 22:02:23 +10001855 sb_start &= ~(sector_t)(4*2 - 1);
Andre Nolldd8ac332009-03-31 14:33:13 +11001856 max_sectors = rdev->sectors + sb_start - rdev->sb_start;
Andre Noll15f4a5f2008-07-21 14:42:12 +10001857 if (!num_sectors || num_sectors > max_sectors)
1858 num_sectors = max_sectors;
Andre Noll0f420352008-07-11 22:02:23 +10001859 rdev->sb_start = sb_start;
Chris Webb0cd17fe2008-06-28 08:31:46 +10001860 }
Namhyung Kim65a06f062011-07-27 11:00:36 +10001861 sb = page_address(rdev->sb_page);
Andre Noll15f4a5f2008-07-21 14:42:12 +10001862 sb->data_size = cpu_to_le64(num_sectors);
Andre Noll0f420352008-07-11 22:02:23 +10001863 sb->super_offset = rdev->sb_start;
Chris Webb0cd17fe2008-06-28 08:31:46 +10001864 sb->sb_csum = calc_sb_1_csum(sb);
Andre Noll0f420352008-07-11 22:02:23 +10001865 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001866 rdev->sb_page);
1867 md_super_wait(rdev->mddev);
Justin Maggardc26a44e2010-11-24 16:36:17 +11001868 return num_sectors;
NeilBrownc6563a82012-05-21 09:27:00 +10001869
1870}
1871
1872static int
1873super_1_allow_new_offset(struct md_rdev *rdev,
1874 unsigned long long new_offset)
1875{
1876 /* All necessary checks on new >= old have been done */
1877 struct bitmap *bitmap;
1878 if (new_offset >= rdev->data_offset)
1879 return 1;
1880
1881 /* with 1.0 metadata, there is no metadata to tread on
1882 * so we can always move back */
1883 if (rdev->mddev->minor_version == 0)
1884 return 1;
1885
1886 /* otherwise we must be sure not to step on
1887 * any metadata, so stay:
1888 * 36K beyond start of superblock
1889 * beyond end of badblocks
1890 * beyond write-intent bitmap
1891 */
1892 if (rdev->sb_start + (32+4)*2 > new_offset)
1893 return 0;
1894 bitmap = rdev->mddev->bitmap;
1895 if (bitmap && !rdev->mddev->bitmap_info.file &&
1896 rdev->sb_start + rdev->mddev->bitmap_info.offset +
NeilBrown1ec885c2012-05-22 13:55:10 +10001897 bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
NeilBrownc6563a82012-05-21 09:27:00 +10001898 return 0;
1899 if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
1900 return 0;
1901
1902 return 1;
Chris Webb0cd17fe2008-06-28 08:31:46 +10001903}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904
Adrian Bunk75c96f82005-05-05 16:16:09 -07001905static struct super_type super_types[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 [0] = {
1907 .name = "0.90.0",
1908 .owner = THIS_MODULE,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001909 .load_super = super_90_load,
1910 .validate_super = super_90_validate,
1911 .sync_super = super_90_sync,
1912 .rdev_size_change = super_90_rdev_size_change,
NeilBrownc6563a82012-05-21 09:27:00 +10001913 .allow_new_offset = super_90_allow_new_offset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 },
1915 [1] = {
1916 .name = "md-1",
1917 .owner = THIS_MODULE,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001918 .load_super = super_1_load,
1919 .validate_super = super_1_validate,
1920 .sync_super = super_1_sync,
1921 .rdev_size_change = super_1_rdev_size_change,
NeilBrownc6563a82012-05-21 09:27:00 +10001922 .allow_new_offset = super_1_allow_new_offset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 },
1924};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925
NeilBrownfd01b882011-10-11 16:47:53 +11001926static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
Jonathan Brassow076f9682011-06-07 17:51:30 -05001927{
1928 if (mddev->sync_super) {
1929 mddev->sync_super(mddev, rdev);
1930 return;
1931 }
1932
1933 BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));
1934
1935 super_types[mddev->major_version].sync_super(mddev, rdev);
1936}
1937
NeilBrownfd01b882011-10-11 16:47:53 +11001938static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939{
NeilBrown3cb03002011-10-11 16:45:26 +11001940 struct md_rdev *rdev, *rdev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941
NeilBrown4b809912008-07-21 17:05:25 +10001942 rcu_read_lock();
Song Liu0b020e82015-09-03 23:00:35 -07001943 rdev_for_each_rcu(rdev, mddev1) {
1944 if (test_bit(Faulty, &rdev->flags) ||
1945 test_bit(Journal, &rdev->flags) ||
1946 rdev->raid_disk == -1)
1947 continue;
1948 rdev_for_each_rcu(rdev2, mddev2) {
1949 if (test_bit(Faulty, &rdev2->flags) ||
1950 test_bit(Journal, &rdev2->flags) ||
1951 rdev2->raid_disk == -1)
1952 continue;
NeilBrown7dd5e7c32007-02-28 20:11:35 -08001953 if (rdev->bdev->bd_contains ==
NeilBrown4b809912008-07-21 17:05:25 +10001954 rdev2->bdev->bd_contains) {
1955 rcu_read_unlock();
NeilBrown7dd5e7c32007-02-28 20:11:35 -08001956 return 1;
NeilBrown4b809912008-07-21 17:05:25 +10001957 }
Song Liu0b020e82015-09-03 23:00:35 -07001958 }
1959 }
NeilBrown4b809912008-07-21 17:05:25 +10001960 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 return 0;
1962}
1963
1964static LIST_HEAD(pending_raid_disks);
1965
Andre Nollac5e7112009-08-03 10:59:47 +10001966/*
1967 * Try to register data integrity profile for an mddev
1968 *
1969 * This is called when an array is started and after a disk has been kicked
1970 * from the array. It only succeeds if all working and active component devices
1971 * are integrity capable with matching profiles.
1972 */
NeilBrownfd01b882011-10-11 16:47:53 +11001973int md_integrity_register(struct mddev *mddev)
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11001974{
NeilBrown3cb03002011-10-11 16:45:26 +11001975 struct md_rdev *rdev, *reference = NULL;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11001976
Andre Nollac5e7112009-08-03 10:59:47 +10001977 if (list_empty(&mddev->disks))
1978 return 0; /* nothing to do */
Jonathan Brassow629acb62011-06-08 15:10:08 +10001979 if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
1980 return 0; /* shouldn't register, or already is */
NeilBrowndafb20f2012-03-19 12:46:39 +11001981 rdev_for_each(rdev, mddev) {
Andre Nollac5e7112009-08-03 10:59:47 +10001982 /* skip spares and non-functional disks */
1983 if (test_bit(Faulty, &rdev->flags))
1984 continue;
1985 if (rdev->raid_disk < 0)
1986 continue;
Andre Nollac5e7112009-08-03 10:59:47 +10001987 if (!reference) {
1988 /* Use the first rdev as the reference */
1989 reference = rdev;
1990 continue;
1991 }
1992 /* does this rdev's profile match the reference profile? */
1993 if (blk_integrity_compare(reference->bdev->bd_disk,
1994 rdev->bdev->bd_disk) < 0)
1995 return -EINVAL;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11001996 }
Martin K. Petersen89078d52011-03-28 20:09:12 -04001997 if (!reference || !bdev_get_integrity(reference->bdev))
1998 return 0;
Andre Nollac5e7112009-08-03 10:59:47 +10001999 /*
2000 * All component devices are integrity capable and have matching
2001 * profiles, register the common profile for the md device.
2002 */
Martin K. Petersen25520d52015-10-21 13:19:49 -04002003 blk_integrity_register(mddev->gendisk,
2004 bdev_get_integrity(reference->bdev));
2005
Martin K. Petersena91a2782011-03-17 11:11:05 +01002006 printk(KERN_NOTICE "md: data integrity enabled on %s\n", mdname(mddev));
2007 if (bioset_integrity_create(mddev->bio_set, BIO_POOL_SIZE)) {
2008 printk(KERN_ERR "md: failed to create integrity pool for %s\n",
2009 mdname(mddev));
2010 return -EINVAL;
2011 }
Andre Nollac5e7112009-08-03 10:59:47 +10002012 return 0;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11002013}
Andre Nollac5e7112009-08-03 10:59:47 +10002014EXPORT_SYMBOL(md_integrity_register);
2015
Dan Williams1501efa2016-01-13 16:00:07 -08002016/*
2017 * Attempt to add an rdev, but only if it is consistent with the current
2018 * integrity profile
2019 */
2020int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
Andre Nollac5e7112009-08-03 10:59:47 +10002021{
Jonathan Brassow2863b9e2012-10-11 13:38:58 +11002022 struct blk_integrity *bi_rdev;
2023 struct blk_integrity *bi_mddev;
Dan Williams1501efa2016-01-13 16:00:07 -08002024 char name[BDEVNAME_SIZE];
Jonathan Brassow2863b9e2012-10-11 13:38:58 +11002025
2026 if (!mddev->gendisk)
Dan Williams1501efa2016-01-13 16:00:07 -08002027 return 0;
Jonathan Brassow2863b9e2012-10-11 13:38:58 +11002028
2029 bi_rdev = bdev_get_integrity(rdev->bdev);
2030 bi_mddev = blk_get_integrity(mddev->gendisk);
Andre Nollac5e7112009-08-03 10:59:47 +10002031
2032 if (!bi_mddev) /* nothing to do */
Dan Williams1501efa2016-01-13 16:00:07 -08002033 return 0;
2034
2035 if (blk_integrity_compare(mddev->gendisk, rdev->bdev->bd_disk) != 0) {
2036 printk(KERN_NOTICE "%s: incompatible integrity profile for %s\n",
2037 mdname(mddev), bdevname(rdev->bdev, name));
2038 return -ENXIO;
2039 }
2040
2041 return 0;
Andre Nollac5e7112009-08-03 10:59:47 +10002042}
2043EXPORT_SYMBOL(md_integrity_add_rdev);
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11002044
NeilBrownf72ffdd2014-09-30 14:23:59 +10002045static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046{
NeilBrown7dd5e7c32007-02-28 20:11:35 -08002047 char b[BDEVNAME_SIZE];
NeilBrownf637b9f2005-11-08 21:39:37 -08002048 struct kobject *ko;
NeilBrown5e55e2f2007-03-26 21:32:14 -08002049 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050
Dan Williams11e2ede2008-04-30 00:52:32 -07002051 /* prevent duplicates */
2052 if (find_rdev(mddev, rdev->bdev->bd_dev))
2053 return -EEXIST;
2054
Andre Nolldd8ac332009-03-31 14:33:13 +11002055 /* make sure rdev->sectors exceeds mddev->dev_sectors */
Shaohua Lif6b6ec52015-12-21 10:51:02 +11002056 if (!test_bit(Journal, &rdev->flags) &&
2057 rdev->sectors &&
2058 (mddev->dev_sectors == 0 || rdev->sectors < mddev->dev_sectors)) {
NeilBrowna778b732007-05-23 13:58:10 -07002059 if (mddev->pers) {
2060 /* Cannot change size, so fail
2061 * If mddev->level <= 0, then we don't care
2062 * about aligning sizes (e.g. linear)
2063 */
2064 if (mddev->level > 0)
2065 return -ENOSPC;
2066 } else
Andre Nolldd8ac332009-03-31 14:33:13 +11002067 mddev->dev_sectors = rdev->sectors;
NeilBrown2bf071b2006-01-06 00:20:55 -08002068 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069
2070 /* Verify rdev->desc_nr is unique.
2071 * If it is -1, assign a free number, else
2072 * check number is not in use
2073 */
NeilBrown4878e9e2014-09-25 17:00:11 +10002074 rcu_read_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075 if (rdev->desc_nr < 0) {
2076 int choice = 0;
NeilBrown4878e9e2014-09-25 17:00:11 +10002077 if (mddev->pers)
2078 choice = mddev->raid_disks;
Goldwyn Rodrigues57d051d2015-04-14 10:43:55 -05002079 while (md_find_rdev_nr_rcu(mddev, choice))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 choice++;
2081 rdev->desc_nr = choice;
2082 } else {
Goldwyn Rodrigues57d051d2015-04-14 10:43:55 -05002083 if (md_find_rdev_nr_rcu(mddev, rdev->desc_nr)) {
NeilBrown4878e9e2014-09-25 17:00:11 +10002084 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 return -EBUSY;
NeilBrown4878e9e2014-09-25 17:00:11 +10002086 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 }
NeilBrown4878e9e2014-09-25 17:00:11 +10002088 rcu_read_unlock();
Shaohua Lif6b6ec52015-12-21 10:51:02 +11002089 if (!test_bit(Journal, &rdev->flags) &&
2090 mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
NeilBrownde01dfa2009-02-06 18:02:46 +11002091 printk(KERN_WARNING "md: %s: array is limited to %d devices\n",
2092 mdname(mddev), mddev->max_disks);
2093 return -EBUSY;
2094 }
NeilBrown19133a42005-11-08 21:39:35 -08002095 bdevname(rdev->bdev,b);
Rasmus Villemoes90a9bef2015-06-25 15:02:36 -07002096 strreplace(b, '/', '!');
Greg Kroah-Hartman649316b2007-12-17 23:05:35 -07002097
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098 rdev->mddev = mddev;
NeilBrown19133a42005-11-08 21:39:35 -08002099 printk(KERN_INFO "md: bind<%s>\n", b);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002100
Greg Kroah-Hartmanb2d6db52007-12-17 23:05:35 -07002101 if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
NeilBrown5e55e2f2007-03-26 21:32:14 -08002102 goto fail;
NeilBrown86e6ffd2005-11-08 21:39:24 -08002103
Tejun Heo0762b8b2008-08-25 19:56:12 +09002104 ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
NeilBrown00bcb4a2010-06-01 19:37:23 +10002105 if (sysfs_create_link(&rdev->kobj, ko, "block"))
2106 /* failure here is OK */;
2107 rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
NeilBrown3c0ee632008-10-21 13:25:28 +11002108
NeilBrown4b809912008-07-21 17:05:25 +10002109 list_add_rcu(&rdev->same_set, &mddev->disks);
Tejun Heoe09b4572010-11-13 11:55:17 +01002110 bd_link_disk_holder(rdev->bdev, mddev->gendisk);
NeilBrown4044ba52009-01-09 08:31:11 +11002111
2112 /* May as well allow recovery to be retried once */
NeilBrown53890422011-07-27 11:00:36 +10002113 mddev->recovery_disabled++;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11002114
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115 return 0;
NeilBrown5e55e2f2007-03-26 21:32:14 -08002116
2117 fail:
2118 printk(KERN_WARNING "md: failed to register dev-%s for %s\n",
2119 b, mdname(mddev));
2120 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121}
2122
NeilBrown177a99b2008-02-06 01:39:56 -08002123static void md_delayed_delete(struct work_struct *ws)
NeilBrown5792a282007-04-04 19:08:18 -07002124{
NeilBrown3cb03002011-10-11 16:45:26 +11002125 struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
NeilBrown5792a282007-04-04 19:08:18 -07002126 kobject_del(&rdev->kobj);
NeilBrown177a99b2008-02-06 01:39:56 -08002127 kobject_put(&rdev->kobj);
NeilBrown5792a282007-04-04 19:08:18 -07002128}
2129
NeilBrownf72ffdd2014-09-30 14:23:59 +10002130static void unbind_rdev_from_array(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131{
2132 char b[BDEVNAME_SIZE];
NeilBrown403df472014-09-30 15:52:29 +10002133
Tejun Heo49731ba2011-01-14 18:43:57 +01002134 bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
NeilBrown4b809912008-07-21 17:05:25 +10002135 list_del_rcu(&rdev->same_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
2137 rdev->mddev = NULL;
NeilBrown86e6ffd2005-11-08 21:39:24 -08002138 sysfs_remove_link(&rdev->kobj, "block");
NeilBrown3c0ee632008-10-21 13:25:28 +11002139 sysfs_put(rdev->sysfs_state);
2140 rdev->sysfs_state = NULL;
NeilBrown2230dfe2011-07-28 11:31:46 +10002141 rdev->badblocks.count = 0;
NeilBrown5792a282007-04-04 19:08:18 -07002142 /* We need to delay this, otherwise we can deadlock when
NeilBrown4b809912008-07-21 17:05:25 +10002143 * writing to 'remove' to "dev/state". We also need
2144 * to delay it due to rcu usage.
NeilBrown5792a282007-04-04 19:08:18 -07002145 */
NeilBrown4b809912008-07-21 17:05:25 +10002146 synchronize_rcu();
NeilBrown177a99b2008-02-06 01:39:56 -08002147 INIT_WORK(&rdev->del_work, md_delayed_delete);
2148 kobject_get(&rdev->kobj);
Tejun Heoe804ac72010-10-15 15:36:08 +02002149 queue_work(md_misc_wq, &rdev->del_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150}
2151
2152/*
2153 * prevent the device from being mounted, repartitioned or
2154 * otherwise reused by a RAID array (or any other kernel
2155 * subsystem), by bd_claiming the device.
2156 */
NeilBrown3cb03002011-10-11 16:45:26 +11002157static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158{
2159 int err = 0;
2160 struct block_device *bdev;
2161 char b[BDEVNAME_SIZE];
2162
Tejun Heod4d77622010-11-13 11:55:18 +01002163 bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
NeilBrown3cb03002011-10-11 16:45:26 +11002164 shared ? (struct md_rdev *)lock_rdev : rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 if (IS_ERR(bdev)) {
2166 printk(KERN_ERR "md: could not open %s.\n",
2167 __bdevname(dev, b));
2168 return PTR_ERR(bdev);
2169 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170 rdev->bdev = bdev;
2171 return err;
2172}
2173
NeilBrown3cb03002011-10-11 16:45:26 +11002174static void unlock_rdev(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175{
2176 struct block_device *bdev = rdev->bdev;
2177 rdev->bdev = NULL;
Tejun Heoe525fd82010-11-13 11:55:17 +01002178 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179}
2180
2181void md_autodetect_dev(dev_t dev);
2182
NeilBrownf72ffdd2014-09-30 14:23:59 +10002183static void export_rdev(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184{
2185 char b[BDEVNAME_SIZE];
NeilBrown403df472014-09-30 15:52:29 +10002186
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187 printk(KERN_INFO "md: export_rdev(%s)\n",
2188 bdevname(rdev->bdev,b));
NeilBrown545c8792012-05-22 13:54:30 +10002189 md_rdev_clear(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190#ifndef MODULE
NeilBrownd0fae182008-03-04 14:29:31 -08002191 if (test_bit(AutoDetected, &rdev->flags))
2192 md_autodetect_dev(rdev->bdev->bd_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193#endif
2194 unlock_rdev(rdev);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002195 kobject_put(&rdev->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196}
2197
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05002198void md_kick_rdev_from_array(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199{
2200 unbind_rdev_from_array(rdev);
2201 export_rdev(rdev);
2202}
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05002203EXPORT_SYMBOL_GPL(md_kick_rdev_from_array);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204
NeilBrownfd01b882011-10-11 16:47:53 +11002205static void export_array(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206{
NeilBrown0638bb02014-09-25 17:43:47 +10002207 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208
NeilBrown0638bb02014-09-25 17:43:47 +10002209 while (!list_empty(&mddev->disks)) {
2210 rdev = list_first_entry(&mddev->disks, struct md_rdev,
2211 same_set);
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05002212 md_kick_rdev_from_array(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214 mddev->raid_disks = 0;
2215 mddev->major_version = 0;
2216}
2217
NeilBrownf72ffdd2014-09-30 14:23:59 +10002218static void sync_sbs(struct mddev *mddev, int nospares)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219{
NeilBrown42543762006-06-26 00:27:57 -07002220 /* Update each superblock (in-memory image), but
2221 * if we are allowed to, skip spares which already
2222 * have the right event counter, or have one earlier
2223 * (which would mean they aren't being marked as dirty
2224 * with the rest of the array)
2225 */
NeilBrown3cb03002011-10-11 16:45:26 +11002226 struct md_rdev *rdev;
NeilBrowndafb20f2012-03-19 12:46:39 +11002227 rdev_for_each(rdev, mddev) {
NeilBrown42543762006-06-26 00:27:57 -07002228 if (rdev->sb_events == mddev->events ||
2229 (nospares &&
2230 rdev->raid_disk < 0 &&
NeilBrown42543762006-06-26 00:27:57 -07002231 rdev->sb_events+1 == mddev->events)) {
2232 /* Don't update this superblock */
2233 rdev->sb_loaded = 2;
2234 } else {
Jonathan Brassow076f9682011-06-07 17:51:30 -05002235 sync_super(mddev, rdev);
NeilBrown42543762006-06-26 00:27:57 -07002236 rdev->sb_loaded = 1;
2237 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 }
2239}
2240
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002241static bool does_sb_need_changing(struct mddev *mddev)
2242{
2243 struct md_rdev *rdev;
2244 struct mdp_superblock_1 *sb;
2245 int role;
2246
2247 /* Find a good rdev */
2248 rdev_for_each(rdev, mddev)
2249 if ((rdev->raid_disk >= 0) && !test_bit(Faulty, &rdev->flags))
2250 break;
2251
2252 /* No good device found. */
2253 if (!rdev)
2254 return false;
2255
2256 sb = page_address(rdev->sb_page);
2257 /* Check if a device has become faulty or a spare become active */
2258 rdev_for_each(rdev, mddev) {
2259 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
2260 /* Device activated? */
2261 if (role == 0xffff && rdev->raid_disk >=0 &&
2262 !test_bit(Faulty, &rdev->flags))
2263 return true;
2264 /* Device turned faulty? */
2265 if (test_bit(Faulty, &rdev->flags) && (role < 0xfffd))
2266 return true;
2267 }
2268
2269 /* Check if any mddev parameters have changed */
2270 if ((mddev->dev_sectors != le64_to_cpu(sb->size)) ||
2271 (mddev->reshape_position != le64_to_cpu(sb->reshape_position)) ||
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002272 (mddev->layout != le64_to_cpu(sb->layout)) ||
2273 (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) ||
2274 (mddev->chunk_sectors != le32_to_cpu(sb->chunksize)))
2275 return true;
2276
2277 return false;
2278}
2279
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05002280void md_update_sb(struct mddev *mddev, int force_change)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281{
NeilBrown3cb03002011-10-11 16:45:26 +11002282 struct md_rdev *rdev;
NeilBrown06d91a52005-06-21 17:17:12 -07002283 int sync_req;
NeilBrown42543762006-06-26 00:27:57 -07002284 int nospares = 0;
NeilBrown2699b672011-07-28 11:31:47 +10002285 int any_badblocks_changed = 0;
Guoqing Jiang23b63f92015-10-12 17:21:30 +08002286 int ret = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287
NeilBrownd87f0642013-04-24 11:42:40 +10002288 if (mddev->ro) {
2289 if (force_change)
2290 set_bit(MD_CHANGE_DEVS, &mddev->flags);
2291 return;
2292 }
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002293
Guoqing Jiang2c97cf12016-05-02 11:33:09 -04002294repeat:
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002295 if (mddev_is_clustered(mddev)) {
2296 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
2297 force_change = 1;
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04002298 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
2299 nospares = 1;
Guoqing Jiang23b63f92015-10-12 17:21:30 +08002300 ret = md_cluster_ops->metadata_update_start(mddev);
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002301 /* Has someone else has updated the sb */
2302 if (!does_sb_need_changing(mddev)) {
Guoqing Jiang23b63f92015-10-12 17:21:30 +08002303 if (ret == 0)
2304 md_cluster_ops->metadata_update_cancel(mddev);
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04002305 bit_clear_unless(&mddev->flags, BIT(MD_CHANGE_PENDING),
2306 BIT(MD_CHANGE_DEVS) |
2307 BIT(MD_CHANGE_CLEAN));
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05002308 return;
2309 }
2310 }
Guoqing Jiang2c97cf12016-05-02 11:33:09 -04002311
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002312 /* First make sure individual recovery_offsets are correct */
NeilBrowndafb20f2012-03-19 12:46:39 +11002313 rdev_for_each(rdev, mddev) {
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002314 if (rdev->raid_disk >= 0 &&
2315 mddev->delta_disks >= 0 &&
Shaohua Lif2076e72015-10-08 21:54:12 -07002316 !test_bit(Journal, &rdev->flags) &&
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002317 !test_bit(In_sync, &rdev->flags) &&
2318 mddev->curr_resync_completed > rdev->recovery_offset)
2319 rdev->recovery_offset = mddev->curr_resync_completed;
2320
NeilBrownf72ffdd2014-09-30 14:23:59 +10002321 }
Dan Williamsbd52b742010-08-30 17:33:33 +10002322 if (!mddev->persistent) {
NeilBrown070dc6d2010-08-30 17:33:34 +10002323 clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002324 clear_bit(MD_CHANGE_DEVS, &mddev->flags);
NeilBrownde393cd2011-07-28 11:31:48 +10002325 if (!mddev->external) {
NeilBrownd97a41d2010-10-28 17:30:20 +11002326 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrowndafb20f2012-03-19 12:46:39 +11002327 rdev_for_each(rdev, mddev) {
NeilBrownde393cd2011-07-28 11:31:48 +10002328 if (rdev->badblocks.changed) {
NeilBrownd0962932012-03-19 12:46:41 +11002329 rdev->badblocks.changed = 0;
Vishal Vermafc974ee2015-12-24 19:20:34 -07002330 ack_all_badblocks(&rdev->badblocks);
NeilBrownde393cd2011-07-28 11:31:48 +10002331 md_error(mddev, rdev);
2332 }
2333 clear_bit(Blocked, &rdev->flags);
2334 clear_bit(BlockedBadBlocks, &rdev->flags);
2335 wake_up(&rdev->blocked_wait);
2336 }
2337 }
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002338 wake_up(&mddev->sb_wait);
2339 return;
2340 }
2341
NeilBrown85572d72014-12-15 12:56:56 +11002342 spin_lock(&mddev->lock);
NeilBrown84692192006-08-27 01:23:49 -07002343
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11002344 mddev->utime = ktime_get_real_seconds();
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002345
NeilBrown850b2b42006-10-03 01:15:46 -07002346 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
2347 force_change = 1;
2348 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
2349 /* just a clean<-> dirty transition, possibly leave spares alone,
2350 * though if events isn't the right even/odd, we will have to do
2351 * spares after all
2352 */
2353 nospares = 1;
2354 if (force_change)
2355 nospares = 0;
2356 if (mddev->degraded)
NeilBrown84692192006-08-27 01:23:49 -07002357 /* If the array is degraded, then skipping spares is both
2358 * dangerous and fairly pointless.
2359 * Dangerous because a device that was removed from the array
2360 * might have a event_count that still looks up-to-date,
2361 * so it can be re-added without a resync.
2362 * Pointless because if there are any spares to skip,
2363 * then a recovery will happen and soon that array won't
2364 * be degraded any more and the spare can go back to sleep then.
2365 */
NeilBrown850b2b42006-10-03 01:15:46 -07002366 nospares = 0;
NeilBrown84692192006-08-27 01:23:49 -07002367
NeilBrown06d91a52005-06-21 17:17:12 -07002368 sync_req = mddev->in_sync;
NeilBrown42543762006-06-26 00:27:57 -07002369
2370 /* If this is just a dirty<->clean transition, and the array is clean
2371 * and 'events' is odd, we can roll back to the previous clean state */
NeilBrown850b2b42006-10-03 01:15:46 -07002372 if (nospares
NeilBrown42543762006-06-26 00:27:57 -07002373 && (mddev->in_sync && mddev->recovery_cp == MaxSector)
NeilBrowna8707c02010-05-18 09:28:43 +10002374 && mddev->can_decrease_events
2375 && mddev->events != 1) {
NeilBrown42543762006-06-26 00:27:57 -07002376 mddev->events--;
NeilBrowna8707c02010-05-18 09:28:43 +10002377 mddev->can_decrease_events = 0;
2378 } else {
NeilBrown42543762006-06-26 00:27:57 -07002379 /* otherwise we have to go forward and ... */
2380 mddev->events ++;
NeilBrowna8707c02010-05-18 09:28:43 +10002381 mddev->can_decrease_events = nospares;
NeilBrown42543762006-06-26 00:27:57 -07002382 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002383
NeilBrown403df472014-09-30 15:52:29 +10002384 /*
2385 * This 64-bit counter should never wrap.
2386 * Either we are in around ~1 trillion A.C., assuming
2387 * 1 reboot per second, or we have a bug...
2388 */
2389 WARN_ON(mddev->events == 0);
NeilBrown2699b672011-07-28 11:31:47 +10002390
NeilBrowndafb20f2012-03-19 12:46:39 +11002391 rdev_for_each(rdev, mddev) {
NeilBrown2699b672011-07-28 11:31:47 +10002392 if (rdev->badblocks.changed)
2393 any_badblocks_changed++;
NeilBrownde393cd2011-07-28 11:31:48 +10002394 if (test_bit(Faulty, &rdev->flags))
2395 set_bit(FaultRecorded, &rdev->flags);
2396 }
NeilBrown2699b672011-07-28 11:31:47 +10002397
NeilBrowne6910632008-02-06 01:39:51 -08002398 sync_sbs(mddev, nospares);
NeilBrown85572d72014-12-15 12:56:56 +11002399 spin_unlock(&mddev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400
NeilBrown36a4e1f2011-10-07 14:23:17 +11002401 pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
2402 mdname(mddev), mddev->in_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403
NeilBrown4ad13662007-07-17 04:06:13 -07002404 bitmap_update_sb(mddev->bitmap);
NeilBrowndafb20f2012-03-19 12:46:39 +11002405 rdev_for_each(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406 char b[BDEVNAME_SIZE];
NeilBrown36a4e1f2011-10-07 14:23:17 +11002407
NeilBrown42543762006-06-26 00:27:57 -07002408 if (rdev->sb_loaded != 1)
2409 continue; /* no noise on spare devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410
NeilBrownf4667222013-12-09 12:04:56 +11002411 if (!test_bit(Faulty, &rdev->flags)) {
NeilBrown7bfa19f2005-06-21 17:17:28 -07002412 md_super_write(mddev,rdev,
Andre Noll0f420352008-07-11 22:02:23 +10002413 rdev->sb_start, rdev->sb_size,
NeilBrown7bfa19f2005-06-21 17:17:28 -07002414 rdev->sb_page);
NeilBrown36a4e1f2011-10-07 14:23:17 +11002415 pr_debug("md: (write) %s's sb offset: %llu\n",
2416 bdevname(rdev->bdev, b),
2417 (unsigned long long)rdev->sb_start);
NeilBrown42543762006-06-26 00:27:57 -07002418 rdev->sb_events = mddev->events;
NeilBrown2699b672011-07-28 11:31:47 +10002419 if (rdev->badblocks.size) {
2420 md_super_write(mddev, rdev,
2421 rdev->badblocks.sector,
2422 rdev->badblocks.size << 9,
2423 rdev->bb_page);
2424 rdev->badblocks.size = 0;
2425 }
NeilBrown7bfa19f2005-06-21 17:17:28 -07002426
NeilBrownf4667222013-12-09 12:04:56 +11002427 } else
NeilBrown36a4e1f2011-10-07 14:23:17 +11002428 pr_debug("md: %s (skipping faulty)\n",
2429 bdevname(rdev->bdev, b));
Andrei Warkentind70ed2e2011-10-18 12:16:48 +11002430
NeilBrown7bfa19f2005-06-21 17:17:28 -07002431 if (mddev->level == LEVEL_MULTIPATH)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432 /* only need to write one superblock... */
2433 break;
2434 }
NeilBrowna9701a32005-11-08 21:39:34 -08002435 md_super_wait(mddev);
NeilBrown850b2b42006-10-03 01:15:46 -07002436 /* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
NeilBrown7bfa19f2005-06-21 17:17:28 -07002437
Guoqing Jiang2c97cf12016-05-02 11:33:09 -04002438 if (mddev_is_clustered(mddev) && ret == 0)
2439 md_cluster_ops->metadata_update_finish(mddev);
2440
NeilBrown850b2b42006-10-03 01:15:46 -07002441 if (mddev->in_sync != sync_req ||
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04002442 !bit_clear_unless(&mddev->flags, BIT(MD_CHANGE_PENDING),
2443 BIT(MD_CHANGE_DEVS) | BIT(MD_CHANGE_CLEAN)))
NeilBrown06d91a52005-06-21 17:17:12 -07002444 /* have to write it out again */
NeilBrown06d91a52005-06-21 17:17:12 -07002445 goto repeat;
NeilBrown3d310eb2005-06-21 17:17:26 -07002446 wake_up(&mddev->sb_wait);
NeilBrownacb180b2009-04-14 16:28:34 +10002447 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2448 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
NeilBrown06d91a52005-06-21 17:17:12 -07002449
NeilBrowndafb20f2012-03-19 12:46:39 +11002450 rdev_for_each(rdev, mddev) {
NeilBrownde393cd2011-07-28 11:31:48 +10002451 if (test_and_clear_bit(FaultRecorded, &rdev->flags))
2452 clear_bit(Blocked, &rdev->flags);
2453
2454 if (any_badblocks_changed)
Vishal Vermafc974ee2015-12-24 19:20:34 -07002455 ack_all_badblocks(&rdev->badblocks);
NeilBrownde393cd2011-07-28 11:31:48 +10002456 clear_bit(BlockedBadBlocks, &rdev->flags);
2457 wake_up(&rdev->blocked_wait);
2458 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459}
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05002460EXPORT_SYMBOL(md_update_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002462static int add_bound_rdev(struct md_rdev *rdev)
2463{
2464 struct mddev *mddev = rdev->mddev;
2465 int err = 0;
Shaohua Li87d4d912016-01-06 14:37:14 -08002466 bool add_journal = test_bit(Journal, &rdev->flags);
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002467
Shaohua Li87d4d912016-01-06 14:37:14 -08002468 if (!mddev->pers->hot_remove_disk || add_journal) {
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002469 /* If there is hot_add_disk but no hot_remove_disk
2470 * then added disks for geometry changes,
2471 * and should be added immediately.
2472 */
2473 super_types[mddev->major_version].
2474 validate_super(mddev, rdev);
Shaohua Li87d4d912016-01-06 14:37:14 -08002475 if (add_journal)
2476 mddev_suspend(mddev);
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002477 err = mddev->pers->hot_add_disk(mddev, rdev);
Shaohua Li87d4d912016-01-06 14:37:14 -08002478 if (add_journal)
2479 mddev_resume(mddev);
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002480 if (err) {
2481 unbind_rdev_from_array(rdev);
2482 export_rdev(rdev);
2483 return err;
2484 }
2485 }
2486 sysfs_notify_dirent_safe(rdev->sysfs_state);
2487
2488 set_bit(MD_CHANGE_DEVS, &mddev->flags);
2489 if (mddev->degraded)
2490 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
2491 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2492 md_new_event(mddev);
2493 md_wakeup_thread(mddev->thread);
2494 return 0;
2495}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496
Andre Noll7f6ce762008-03-23 18:34:54 +01002497/* words written to sysfs files may, or may not, be \n terminated.
NeilBrownbce74da2006-01-06 00:20:41 -08002498 * We want to accept with case. For this we use cmd_match.
2499 */
2500static int cmd_match(const char *cmd, const char *str)
2501{
2502 /* See if cmd, written into a sysfs file, matches
2503 * str. They must either be the same, or cmd can
2504 * have a trailing newline
2505 */
2506 while (*cmd && *str && *cmd == *str) {
2507 cmd++;
2508 str++;
2509 }
2510 if (*cmd == '\n')
2511 cmd++;
2512 if (*str || *cmd)
2513 return 0;
2514 return 1;
2515}
2516
NeilBrown86e6ffd2005-11-08 21:39:24 -08002517struct rdev_sysfs_entry {
2518 struct attribute attr;
NeilBrown3cb03002011-10-11 16:45:26 +11002519 ssize_t (*show)(struct md_rdev *, char *);
2520 ssize_t (*store)(struct md_rdev *, const char *, size_t);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002521};
2522
2523static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002524state_show(struct md_rdev *rdev, char *page)
NeilBrown86e6ffd2005-11-08 21:39:24 -08002525{
2526 char *sep = "";
NeilBrown20a49ff2008-02-06 01:39:57 -08002527 size_t len = 0;
NeilBrown758bfc82014-12-15 12:56:59 +11002528 unsigned long flags = ACCESS_ONCE(rdev->flags);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002529
NeilBrown758bfc82014-12-15 12:56:59 +11002530 if (test_bit(Faulty, &flags) ||
NeilBrownde393cd2011-07-28 11:31:48 +10002531 rdev->badblocks.unacked_exist) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08002532 len+= sprintf(page+len, "%sfaulty",sep);
2533 sep = ",";
2534 }
NeilBrown758bfc82014-12-15 12:56:59 +11002535 if (test_bit(In_sync, &flags)) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08002536 len += sprintf(page+len, "%sin_sync",sep);
2537 sep = ",";
2538 }
Shaohua Liac6096e2015-10-04 09:20:11 -07002539 if (test_bit(Journal, &flags)) {
2540 len += sprintf(page+len, "%sjournal",sep);
2541 sep = ",";
2542 }
NeilBrown758bfc82014-12-15 12:56:59 +11002543 if (test_bit(WriteMostly, &flags)) {
NeilBrownf6556752006-06-26 00:28:01 -07002544 len += sprintf(page+len, "%swrite_mostly",sep);
2545 sep = ",";
2546 }
NeilBrown758bfc82014-12-15 12:56:59 +11002547 if (test_bit(Blocked, &flags) ||
NeilBrown52c64152011-12-08 16:22:48 +11002548 (rdev->badblocks.unacked_exist
NeilBrown758bfc82014-12-15 12:56:59 +11002549 && !test_bit(Faulty, &flags))) {
Dan Williams6bfe0b42008-04-30 00:52:32 -07002550 len += sprintf(page+len, "%sblocked", sep);
2551 sep = ",";
2552 }
NeilBrown758bfc82014-12-15 12:56:59 +11002553 if (!test_bit(Faulty, &flags) &&
Shaohua Lif2076e72015-10-08 21:54:12 -07002554 !test_bit(Journal, &flags) &&
NeilBrown758bfc82014-12-15 12:56:59 +11002555 !test_bit(In_sync, &flags)) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08002556 len += sprintf(page+len, "%sspare", sep);
2557 sep = ",";
2558 }
NeilBrown758bfc82014-12-15 12:56:59 +11002559 if (test_bit(WriteErrorSeen, &flags)) {
NeilBrownd7a9d442011-07-28 11:31:48 +10002560 len += sprintf(page+len, "%swrite_error", sep);
2561 sep = ",";
2562 }
NeilBrown758bfc82014-12-15 12:56:59 +11002563 if (test_bit(WantReplacement, &flags)) {
NeilBrown2d78f8c2011-12-23 10:17:51 +11002564 len += sprintf(page+len, "%swant_replacement", sep);
2565 sep = ",";
2566 }
NeilBrown758bfc82014-12-15 12:56:59 +11002567 if (test_bit(Replacement, &flags)) {
NeilBrown2d78f8c2011-12-23 10:17:51 +11002568 len += sprintf(page+len, "%sreplacement", sep);
2569 sep = ",";
2570 }
2571
NeilBrown86e6ffd2005-11-08 21:39:24 -08002572 return len+sprintf(page+len, "\n");
2573}
2574
NeilBrown45dc2de2006-06-26 00:27:58 -07002575static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002576state_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown45dc2de2006-06-26 00:27:58 -07002577{
2578 /* can write
NeilBrownde393cd2011-07-28 11:31:48 +10002579 * faulty - simulates an error
NeilBrown45dc2de2006-06-26 00:27:58 -07002580 * remove - disconnects the device
NeilBrownf6556752006-06-26 00:28:01 -07002581 * writemostly - sets write_mostly
2582 * -writemostly - clears write_mostly
NeilBrownde393cd2011-07-28 11:31:48 +10002583 * blocked - sets the Blocked flags
2584 * -blocked - clears the Blocked and possibly simulates an error
NeilBrown6d56e272009-04-14 12:01:57 +10002585 * insync - sets Insync providing device isn't active
NeilBrownf4667222013-12-09 12:04:56 +11002586 * -insync - clear Insync for a device with a slot assigned,
2587 * so that it gets rebuilt based on bitmap
NeilBrownd7a9d442011-07-28 11:31:48 +10002588 * write_error - sets WriteErrorSeen
2589 * -write_error - clears WriteErrorSeen
NeilBrown45dc2de2006-06-26 00:27:58 -07002590 */
2591 int err = -EINVAL;
2592 if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2593 md_error(rdev->mddev, rdev);
NeilBrown5ef56c82011-08-25 14:42:51 +10002594 if (test_bit(Faulty, &rdev->flags))
2595 err = 0;
2596 else
2597 err = -EBUSY;
NeilBrown45dc2de2006-06-26 00:27:58 -07002598 } else if (cmd_match(buf, "remove")) {
2599 if (rdev->raid_disk >= 0)
2600 err = -EBUSY;
2601 else {
NeilBrownfd01b882011-10-11 16:47:53 +11002602 struct mddev *mddev = rdev->mddev;
NeilBrown45dc2de2006-06-26 00:27:58 -07002603 err = 0;
Guoqing Jianga9720902015-10-12 17:21:27 +08002604 if (mddev_is_clustered(mddev))
2605 err = md_cluster_ops->remove_disk(mddev, rdev);
2606
2607 if (err == 0) {
2608 md_kick_rdev_from_array(rdev);
2609 if (mddev->pers)
2610 md_update_sb(mddev, 1);
2611 md_new_event(mddev);
2612 }
NeilBrown45dc2de2006-06-26 00:27:58 -07002613 }
NeilBrownf6556752006-06-26 00:28:01 -07002614 } else if (cmd_match(buf, "writemostly")) {
2615 set_bit(WriteMostly, &rdev->flags);
2616 err = 0;
2617 } else if (cmd_match(buf, "-writemostly")) {
2618 clear_bit(WriteMostly, &rdev->flags);
2619 err = 0;
Dan Williams6bfe0b42008-04-30 00:52:32 -07002620 } else if (cmd_match(buf, "blocked")) {
2621 set_bit(Blocked, &rdev->flags);
2622 err = 0;
2623 } else if (cmd_match(buf, "-blocked")) {
NeilBrownde393cd2011-07-28 11:31:48 +10002624 if (!test_bit(Faulty, &rdev->flags) &&
NeilBrown7da64a02011-08-30 16:20:17 +10002625 rdev->badblocks.unacked_exist) {
NeilBrownde393cd2011-07-28 11:31:48 +10002626 /* metadata handler doesn't understand badblocks,
2627 * so we need to fail the device
2628 */
2629 md_error(rdev->mddev, rdev);
2630 }
Dan Williams6bfe0b42008-04-30 00:52:32 -07002631 clear_bit(Blocked, &rdev->flags);
NeilBrownde393cd2011-07-28 11:31:48 +10002632 clear_bit(BlockedBadBlocks, &rdev->flags);
Dan Williams6bfe0b42008-04-30 00:52:32 -07002633 wake_up(&rdev->blocked_wait);
2634 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2635 md_wakeup_thread(rdev->mddev->thread);
2636
2637 err = 0;
NeilBrown6d56e272009-04-14 12:01:57 +10002638 } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
2639 set_bit(In_sync, &rdev->flags);
2640 err = 0;
Shaohua Lif2076e72015-10-08 21:54:12 -07002641 } else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0 &&
2642 !test_bit(Journal, &rdev->flags)) {
NeilBrowne1960f82014-09-30 15:24:25 +10002643 if (rdev->mddev->pers == NULL) {
2644 clear_bit(In_sync, &rdev->flags);
2645 rdev->saved_raid_disk = rdev->raid_disk;
2646 rdev->raid_disk = -1;
2647 err = 0;
2648 }
NeilBrownd7a9d442011-07-28 11:31:48 +10002649 } else if (cmd_match(buf, "write_error")) {
2650 set_bit(WriteErrorSeen, &rdev->flags);
2651 err = 0;
2652 } else if (cmd_match(buf, "-write_error")) {
2653 clear_bit(WriteErrorSeen, &rdev->flags);
2654 err = 0;
NeilBrown2d78f8c2011-12-23 10:17:51 +11002655 } else if (cmd_match(buf, "want_replacement")) {
2656 /* Any non-spare device that is not a replacement can
2657 * become want_replacement at any time, but we then need to
2658 * check if recovery is needed.
2659 */
2660 if (rdev->raid_disk >= 0 &&
Shaohua Lif2076e72015-10-08 21:54:12 -07002661 !test_bit(Journal, &rdev->flags) &&
NeilBrown2d78f8c2011-12-23 10:17:51 +11002662 !test_bit(Replacement, &rdev->flags))
2663 set_bit(WantReplacement, &rdev->flags);
2664 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2665 md_wakeup_thread(rdev->mddev->thread);
2666 err = 0;
2667 } else if (cmd_match(buf, "-want_replacement")) {
2668 /* Clearing 'want_replacement' is always allowed.
2669 * Once replacements starts it is too late though.
2670 */
2671 err = 0;
2672 clear_bit(WantReplacement, &rdev->flags);
2673 } else if (cmd_match(buf, "replacement")) {
2674 /* Can only set a device as a replacement when array has not
2675 * yet been started. Once running, replacement is automatic
2676 * from spares, or by assigning 'slot'.
2677 */
2678 if (rdev->mddev->pers)
2679 err = -EBUSY;
2680 else {
2681 set_bit(Replacement, &rdev->flags);
2682 err = 0;
2683 }
2684 } else if (cmd_match(buf, "-replacement")) {
2685 /* Similarly, can only clear Replacement before start */
2686 if (rdev->mddev->pers)
2687 err = -EBUSY;
2688 else {
2689 clear_bit(Replacement, &rdev->flags);
2690 err = 0;
2691 }
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002692 } else if (cmd_match(buf, "re-add")) {
2693 if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1)) {
Goldwyn Rodrigues97f6cd32015-04-14 10:45:42 -05002694 /* clear_bit is performed _after_ all the devices
2695 * have their local Faulty bit cleared. If any writes
2696 * happen in the meantime in the local node, they
2697 * will land in the local bitmap, which will be synced
2698 * by this node eventually
2699 */
2700 if (!mddev_is_clustered(rdev->mddev) ||
2701 (err = md_cluster_ops->gather_bitmaps(rdev)) == 0) {
2702 clear_bit(Faulty, &rdev->flags);
2703 err = add_bound_rdev(rdev);
2704 }
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05002705 } else
2706 err = -EBUSY;
NeilBrown45dc2de2006-06-26 00:27:58 -07002707 }
NeilBrown00bcb4a2010-06-01 19:37:23 +10002708 if (!err)
2709 sysfs_notify_dirent_safe(rdev->sysfs_state);
NeilBrown45dc2de2006-06-26 00:27:58 -07002710 return err ? err : len;
2711}
NeilBrown80ca3a42006-07-10 04:44:18 -07002712static struct rdev_sysfs_entry rdev_state =
NeilBrown750f1992014-09-30 08:53:05 +10002713__ATTR_PREALLOC(state, S_IRUGO|S_IWUSR, state_show, state_store);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002714
2715static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002716errors_show(struct md_rdev *rdev, char *page)
NeilBrown4dbcdc72006-01-06 00:20:52 -08002717{
2718 return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
2719}
2720
2721static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002722errors_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown4dbcdc72006-01-06 00:20:52 -08002723{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03002724 unsigned int n;
2725 int rv;
2726
2727 rv = kstrtouint(buf, 10, &n);
2728 if (rv < 0)
2729 return rv;
2730 atomic_set(&rdev->corrected_errors, n);
2731 return len;
NeilBrown4dbcdc72006-01-06 00:20:52 -08002732}
2733static struct rdev_sysfs_entry rdev_errors =
NeilBrown80ca3a42006-07-10 04:44:18 -07002734__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
NeilBrown4dbcdc72006-01-06 00:20:52 -08002735
NeilBrown014236d2006-01-06 00:20:55 -08002736static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002737slot_show(struct md_rdev *rdev, char *page)
NeilBrown014236d2006-01-06 00:20:55 -08002738{
Shaohua Lif2076e72015-10-08 21:54:12 -07002739 if (test_bit(Journal, &rdev->flags))
2740 return sprintf(page, "journal\n");
2741 else if (rdev->raid_disk < 0)
NeilBrown014236d2006-01-06 00:20:55 -08002742 return sprintf(page, "none\n");
2743 else
2744 return sprintf(page, "%d\n", rdev->raid_disk);
2745}
2746
2747static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002748slot_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown014236d2006-01-06 00:20:55 -08002749{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03002750 int slot;
NeilBrownc303da62008-02-06 01:39:51 -08002751 int err;
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03002752
Shaohua Lif2076e72015-10-08 21:54:12 -07002753 if (test_bit(Journal, &rdev->flags))
2754 return -EBUSY;
NeilBrown014236d2006-01-06 00:20:55 -08002755 if (strncmp(buf, "none", 4)==0)
2756 slot = -1;
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03002757 else {
2758 err = kstrtouint(buf, 10, (unsigned int *)&slot);
2759 if (err < 0)
2760 return err;
2761 }
Neil Brown6c2fce22008-06-28 08:31:31 +10002762 if (rdev->mddev->pers && slot == -1) {
NeilBrownc303da62008-02-06 01:39:51 -08002763 /* Setting 'slot' on an active array requires also
2764 * updating the 'rd%d' link, and communicating
2765 * with the personality with ->hot_*_disk.
2766 * For now we only support removing
2767 * failed/spare devices. This normally happens automatically,
2768 * but not when the metadata is externally managed.
2769 */
NeilBrownc303da62008-02-06 01:39:51 -08002770 if (rdev->raid_disk == -1)
2771 return -EEXIST;
2772 /* personality does all needed checks */
Namhyung Kim01393f32011-06-09 11:42:54 +10002773 if (rdev->mddev->pers->hot_remove_disk == NULL)
NeilBrownc303da62008-02-06 01:39:51 -08002774 return -EINVAL;
NeilBrown746d3202013-04-24 11:42:41 +10002775 clear_bit(Blocked, &rdev->flags);
2776 remove_and_add_spares(rdev->mddev, rdev);
2777 if (rdev->raid_disk >= 0)
2778 return -EBUSY;
NeilBrownc303da62008-02-06 01:39:51 -08002779 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2780 md_wakeup_thread(rdev->mddev->thread);
Neil Brown6c2fce22008-06-28 08:31:31 +10002781 } else if (rdev->mddev->pers) {
Neil Brown6c2fce22008-06-28 08:31:31 +10002782 /* Activating a spare .. or possibly reactivating
NeilBrown6d56e272009-04-14 12:01:57 +10002783 * if we ever get bitmaps working here.
Neil Brown6c2fce22008-06-28 08:31:31 +10002784 */
Goldwyn Rodriguescb01c542015-12-18 15:19:16 +11002785 int err;
Neil Brown6c2fce22008-06-28 08:31:31 +10002786
2787 if (rdev->raid_disk != -1)
2788 return -EBUSY;
2789
NeilBrownc6751b22011-02-02 11:57:13 +11002790 if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
2791 return -EBUSY;
2792
Neil Brown6c2fce22008-06-28 08:31:31 +10002793 if (rdev->mddev->pers->hot_add_disk == NULL)
2794 return -EINVAL;
2795
NeilBrownba1b41b2011-01-14 09:14:34 +11002796 if (slot >= rdev->mddev->raid_disks &&
2797 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
2798 return -ENOSPC;
2799
Neil Brown6c2fce22008-06-28 08:31:31 +10002800 rdev->raid_disk = slot;
2801 if (test_bit(In_sync, &rdev->flags))
2802 rdev->saved_raid_disk = slot;
2803 else
2804 rdev->saved_raid_disk = -1;
NeilBrownd30519f2011-10-18 12:13:47 +11002805 clear_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11002806 clear_bit(Bitmap_sync, &rdev->flags);
Goldwyn Rodriguescb01c542015-12-18 15:19:16 +11002807 err = rdev->mddev->pers->
2808 hot_add_disk(rdev->mddev, rdev);
2809 if (err) {
2810 rdev->raid_disk = -1;
2811 return err;
2812 } else
2813 sysfs_notify_dirent_safe(rdev->sysfs_state);
2814 if (sysfs_link_rdev(rdev->mddev, rdev))
2815 /* failure here is OK */;
Neil Brown6c2fce22008-06-28 08:31:31 +10002816 /* don't wakeup anyone, leave that to userspace. */
NeilBrownc303da62008-02-06 01:39:51 -08002817 } else {
NeilBrownba1b41b2011-01-14 09:14:34 +11002818 if (slot >= rdev->mddev->raid_disks &&
2819 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
NeilBrownc303da62008-02-06 01:39:51 -08002820 return -ENOSPC;
2821 rdev->raid_disk = slot;
2822 /* assume it is working */
NeilBrownc5d79ad2008-02-06 01:39:54 -08002823 clear_bit(Faulty, &rdev->flags);
2824 clear_bit(WriteMostly, &rdev->flags);
NeilBrownc303da62008-02-06 01:39:51 -08002825 set_bit(In_sync, &rdev->flags);
NeilBrown00bcb4a2010-06-01 19:37:23 +10002826 sysfs_notify_dirent_safe(rdev->sysfs_state);
NeilBrownc303da62008-02-06 01:39:51 -08002827 }
NeilBrown014236d2006-01-06 00:20:55 -08002828 return len;
2829}
2830
NeilBrown014236d2006-01-06 00:20:55 -08002831static struct rdev_sysfs_entry rdev_slot =
NeilBrown80ca3a42006-07-10 04:44:18 -07002832__ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
NeilBrown014236d2006-01-06 00:20:55 -08002833
NeilBrown93c8cad2006-01-06 00:20:56 -08002834static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002835offset_show(struct md_rdev *rdev, char *page)
NeilBrown93c8cad2006-01-06 00:20:56 -08002836{
Andrew Morton6961ece2006-01-06 00:20:59 -08002837 return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
NeilBrown93c8cad2006-01-06 00:20:56 -08002838}
2839
2840static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002841offset_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown93c8cad2006-01-06 00:20:56 -08002842{
NeilBrownc6563a82012-05-21 09:27:00 +10002843 unsigned long long offset;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002844 if (kstrtoull(buf, 10, &offset) < 0)
NeilBrown93c8cad2006-01-06 00:20:56 -08002845 return -EINVAL;
Neil Brown8ed0a522008-06-28 08:31:29 +10002846 if (rdev->mddev->pers && rdev->raid_disk >= 0)
NeilBrown93c8cad2006-01-06 00:20:56 -08002847 return -EBUSY;
Andre Nolldd8ac332009-03-31 14:33:13 +11002848 if (rdev->sectors && rdev->mddev->external)
NeilBrownc5d79ad2008-02-06 01:39:54 -08002849 /* Must set offset before size, so overlap checks
2850 * can be sane */
2851 return -EBUSY;
NeilBrown93c8cad2006-01-06 00:20:56 -08002852 rdev->data_offset = offset;
NeilBrown25f7fd42012-07-19 15:59:18 +10002853 rdev->new_data_offset = offset;
NeilBrown93c8cad2006-01-06 00:20:56 -08002854 return len;
2855}
2856
2857static struct rdev_sysfs_entry rdev_offset =
NeilBrown80ca3a42006-07-10 04:44:18 -07002858__ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
NeilBrown93c8cad2006-01-06 00:20:56 -08002859
NeilBrownc6563a82012-05-21 09:27:00 +10002860static ssize_t new_offset_show(struct md_rdev *rdev, char *page)
2861{
2862 return sprintf(page, "%llu\n",
2863 (unsigned long long)rdev->new_data_offset);
2864}
2865
2866static ssize_t new_offset_store(struct md_rdev *rdev,
2867 const char *buf, size_t len)
2868{
2869 unsigned long long new_offset;
2870 struct mddev *mddev = rdev->mddev;
2871
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002872 if (kstrtoull(buf, 10, &new_offset) < 0)
NeilBrownc6563a82012-05-21 09:27:00 +10002873 return -EINVAL;
2874
NeilBrownf851b602014-12-11 10:02:10 +11002875 if (mddev->sync_thread ||
2876 test_bit(MD_RECOVERY_RUNNING,&mddev->recovery))
NeilBrownc6563a82012-05-21 09:27:00 +10002877 return -EBUSY;
2878 if (new_offset == rdev->data_offset)
2879 /* reset is always permitted */
2880 ;
2881 else if (new_offset > rdev->data_offset) {
2882 /* must not push array size beyond rdev_sectors */
2883 if (new_offset - rdev->data_offset
2884 + mddev->dev_sectors > rdev->sectors)
2885 return -E2BIG;
2886 }
2887 /* Metadata worries about other space details. */
2888
2889 /* decreasing the offset is inconsistent with a backwards
2890 * reshape.
2891 */
2892 if (new_offset < rdev->data_offset &&
2893 mddev->reshape_backwards)
2894 return -EINVAL;
2895 /* Increasing offset is inconsistent with forwards
2896 * reshape. reshape_direction should be set to
2897 * 'backwards' first.
2898 */
2899 if (new_offset > rdev->data_offset &&
2900 !mddev->reshape_backwards)
2901 return -EINVAL;
2902
2903 if (mddev->pers && mddev->persistent &&
2904 !super_types[mddev->major_version]
2905 .allow_new_offset(rdev, new_offset))
2906 return -E2BIG;
2907 rdev->new_data_offset = new_offset;
2908 if (new_offset > rdev->data_offset)
2909 mddev->reshape_backwards = 1;
2910 else if (new_offset < rdev->data_offset)
2911 mddev->reshape_backwards = 0;
2912
2913 return len;
2914}
2915static struct rdev_sysfs_entry rdev_new_offset =
2916__ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store);
2917
NeilBrown83303b62006-01-06 00:21:06 -08002918static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002919rdev_size_show(struct md_rdev *rdev, char *page)
NeilBrown83303b62006-01-06 00:21:06 -08002920{
Andre Nolldd8ac332009-03-31 14:33:13 +11002921 return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
NeilBrown83303b62006-01-06 00:21:06 -08002922}
2923
NeilBrownc5d79ad2008-02-06 01:39:54 -08002924static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
2925{
2926 /* check if two start/length pairs overlap */
2927 if (s1+l1 <= s2)
2928 return 0;
2929 if (s2+l2 <= s1)
2930 return 0;
2931 return 1;
2932}
2933
Dan Williamsb522adc2009-03-31 15:00:31 +11002934static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
2935{
2936 unsigned long long blocks;
2937 sector_t new;
2938
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002939 if (kstrtoull(buf, 10, &blocks) < 0)
Dan Williamsb522adc2009-03-31 15:00:31 +11002940 return -EINVAL;
2941
2942 if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
2943 return -EINVAL; /* sector conversion overflow */
2944
2945 new = blocks * 2;
2946 if (new != blocks * 2)
2947 return -EINVAL; /* unsigned long long to sector_t overflow */
2948
2949 *sectors = new;
2950 return 0;
2951}
2952
NeilBrown83303b62006-01-06 00:21:06 -08002953static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002954rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown83303b62006-01-06 00:21:06 -08002955{
NeilBrownfd01b882011-10-11 16:47:53 +11002956 struct mddev *my_mddev = rdev->mddev;
Andre Nolldd8ac332009-03-31 14:33:13 +11002957 sector_t oldsectors = rdev->sectors;
Dan Williamsb522adc2009-03-31 15:00:31 +11002958 sector_t sectors;
NeilBrown27c529b2008-03-04 14:29:33 -08002959
Shaohua Lif2076e72015-10-08 21:54:12 -07002960 if (test_bit(Journal, &rdev->flags))
2961 return -EBUSY;
Dan Williamsb522adc2009-03-31 15:00:31 +11002962 if (strict_blocks_to_sectors(buf, &sectors) < 0)
Neil Brownd7027452008-07-12 10:37:50 +10002963 return -EINVAL;
NeilBrownc6563a82012-05-21 09:27:00 +10002964 if (rdev->data_offset != rdev->new_data_offset)
2965 return -EINVAL; /* too confusing */
Chris Webb0cd17fe2008-06-28 08:31:46 +10002966 if (my_mddev->pers && rdev->raid_disk >= 0) {
Neil Brownd7027452008-07-12 10:37:50 +10002967 if (my_mddev->persistent) {
Andre Nolldd8ac332009-03-31 14:33:13 +11002968 sectors = super_types[my_mddev->major_version].
2969 rdev_size_change(rdev, sectors);
2970 if (!sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10002971 return -EBUSY;
Andre Nolldd8ac332009-03-31 14:33:13 +11002972 } else if (!sectors)
Mike Snitzer77304d22010-11-08 14:39:12 +01002973 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
Andre Nolldd8ac332009-03-31 14:33:13 +11002974 rdev->data_offset;
NeilBrowna6468532013-02-21 14:33:17 +11002975 if (!my_mddev->pers->resize)
2976 /* Cannot change size for RAID0 or Linear etc */
2977 return -EINVAL;
Chris Webb0cd17fe2008-06-28 08:31:46 +10002978 }
Andre Nolldd8ac332009-03-31 14:33:13 +11002979 if (sectors < my_mddev->dev_sectors)
Chris Webb7d3c6f82008-10-13 11:55:11 +11002980 return -EINVAL; /* component must fit device */
Chris Webb0cd17fe2008-06-28 08:31:46 +10002981
Andre Nolldd8ac332009-03-31 14:33:13 +11002982 rdev->sectors = sectors;
2983 if (sectors > oldsectors && my_mddev->external) {
NeilBrown8b1afc32014-09-29 15:33:20 +10002984 /* Need to check that all other rdevs with the same
2985 * ->bdev do not overlap. 'rcu' is sufficient to walk
2986 * the rdev lists safely.
2987 * This check does not provide a hard guarantee, it
2988 * just helps avoid dangerous mistakes.
NeilBrownc5d79ad2008-02-06 01:39:54 -08002989 */
NeilBrownfd01b882011-10-11 16:47:53 +11002990 struct mddev *mddev;
NeilBrownc5d79ad2008-02-06 01:39:54 -08002991 int overlap = 0;
Cheng Renquan159ec1f2009-01-09 08:31:08 +11002992 struct list_head *tmp;
NeilBrownc5d79ad2008-02-06 01:39:54 -08002993
NeilBrown8b1afc32014-09-29 15:33:20 +10002994 rcu_read_lock();
NeilBrown29ac4aa2008-02-06 01:39:58 -08002995 for_each_mddev(mddev, tmp) {
NeilBrown3cb03002011-10-11 16:45:26 +11002996 struct md_rdev *rdev2;
NeilBrownc5d79ad2008-02-06 01:39:54 -08002997
NeilBrowndafb20f2012-03-19 12:46:39 +11002998 rdev_for_each(rdev2, mddev)
NeilBrownf21e9ff2011-01-31 12:10:09 +11002999 if (rdev->bdev == rdev2->bdev &&
3000 rdev != rdev2 &&
3001 overlaps(rdev->data_offset, rdev->sectors,
3002 rdev2->data_offset,
3003 rdev2->sectors)) {
NeilBrownc5d79ad2008-02-06 01:39:54 -08003004 overlap = 1;
3005 break;
3006 }
NeilBrownc5d79ad2008-02-06 01:39:54 -08003007 if (overlap) {
3008 mddev_put(mddev);
3009 break;
3010 }
3011 }
NeilBrown8b1afc32014-09-29 15:33:20 +10003012 rcu_read_unlock();
NeilBrownc5d79ad2008-02-06 01:39:54 -08003013 if (overlap) {
3014 /* Someone else could have slipped in a size
3015 * change here, but doing so is just silly.
Andre Nolldd8ac332009-03-31 14:33:13 +11003016 * We put oldsectors back because we *know* it is
NeilBrownc5d79ad2008-02-06 01:39:54 -08003017 * safe, and trust userspace not to race with
3018 * itself
3019 */
Andre Nolldd8ac332009-03-31 14:33:13 +11003020 rdev->sectors = oldsectors;
NeilBrownc5d79ad2008-02-06 01:39:54 -08003021 return -EBUSY;
3022 }
3023 }
NeilBrown83303b62006-01-06 00:21:06 -08003024 return len;
3025}
3026
3027static struct rdev_sysfs_entry rdev_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07003028__ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
NeilBrown83303b62006-01-06 00:21:06 -08003029
NeilBrown3cb03002011-10-11 16:45:26 +11003030static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
Dan Williams06e3c812009-12-12 21:17:12 -07003031{
3032 unsigned long long recovery_start = rdev->recovery_offset;
3033
3034 if (test_bit(In_sync, &rdev->flags) ||
3035 recovery_start == MaxSector)
3036 return sprintf(page, "none\n");
3037
3038 return sprintf(page, "%llu\n", recovery_start);
3039}
3040
NeilBrown3cb03002011-10-11 16:45:26 +11003041static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
Dan Williams06e3c812009-12-12 21:17:12 -07003042{
3043 unsigned long long recovery_start;
3044
3045 if (cmd_match(buf, "none"))
3046 recovery_start = MaxSector;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09003047 else if (kstrtoull(buf, 10, &recovery_start))
Dan Williams06e3c812009-12-12 21:17:12 -07003048 return -EINVAL;
3049
3050 if (rdev->mddev->pers &&
3051 rdev->raid_disk >= 0)
3052 return -EBUSY;
3053
3054 rdev->recovery_offset = recovery_start;
3055 if (recovery_start == MaxSector)
3056 set_bit(In_sync, &rdev->flags);
3057 else
3058 clear_bit(In_sync, &rdev->flags);
3059 return len;
3060}
3061
3062static struct rdev_sysfs_entry rdev_recovery_start =
3063__ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);
3064
Vishal Vermafc974ee2015-12-24 19:20:34 -07003065/* sysfs access to bad-blocks list.
3066 * We present two files.
3067 * 'bad-blocks' lists sector numbers and lengths of ranges that
3068 * are recorded as bad. The list is truncated to fit within
3069 * the one-page limit of sysfs.
3070 * Writing "sector length" to this file adds an acknowledged
3071 * bad block list.
3072 * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
3073 * been acknowledged. Writing to this file adds bad blocks
3074 * without acknowledging them. This is largely for testing.
3075 */
NeilBrown3cb03002011-10-11 16:45:26 +11003076static ssize_t bb_show(struct md_rdev *rdev, char *page)
NeilBrown16c791a2011-07-28 11:31:47 +10003077{
3078 return badblocks_show(&rdev->badblocks, page, 0);
3079}
NeilBrown3cb03002011-10-11 16:45:26 +11003080static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
NeilBrown16c791a2011-07-28 11:31:47 +10003081{
NeilBrownde393cd2011-07-28 11:31:48 +10003082 int rv = badblocks_store(&rdev->badblocks, page, len, 0);
3083 /* Maybe that ack was all we needed */
3084 if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags))
3085 wake_up(&rdev->blocked_wait);
3086 return rv;
NeilBrown16c791a2011-07-28 11:31:47 +10003087}
3088static struct rdev_sysfs_entry rdev_bad_blocks =
3089__ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);
3090
NeilBrown3cb03002011-10-11 16:45:26 +11003091static ssize_t ubb_show(struct md_rdev *rdev, char *page)
NeilBrown16c791a2011-07-28 11:31:47 +10003092{
3093 return badblocks_show(&rdev->badblocks, page, 1);
3094}
NeilBrown3cb03002011-10-11 16:45:26 +11003095static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
NeilBrown16c791a2011-07-28 11:31:47 +10003096{
3097 return badblocks_store(&rdev->badblocks, page, len, 1);
3098}
3099static struct rdev_sysfs_entry rdev_unack_bad_blocks =
3100__ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store);
3101
NeilBrown86e6ffd2005-11-08 21:39:24 -08003102static struct attribute *rdev_default_attrs[] = {
3103 &rdev_state.attr,
NeilBrown4dbcdc72006-01-06 00:20:52 -08003104 &rdev_errors.attr,
NeilBrown014236d2006-01-06 00:20:55 -08003105 &rdev_slot.attr,
NeilBrown93c8cad2006-01-06 00:20:56 -08003106 &rdev_offset.attr,
NeilBrownc6563a82012-05-21 09:27:00 +10003107 &rdev_new_offset.attr,
NeilBrown83303b62006-01-06 00:21:06 -08003108 &rdev_size.attr,
Dan Williams06e3c812009-12-12 21:17:12 -07003109 &rdev_recovery_start.attr,
NeilBrown16c791a2011-07-28 11:31:47 +10003110 &rdev_bad_blocks.attr,
3111 &rdev_unack_bad_blocks.attr,
NeilBrown86e6ffd2005-11-08 21:39:24 -08003112 NULL,
3113};
3114static ssize_t
3115rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
3116{
3117 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
NeilBrown3cb03002011-10-11 16:45:26 +11003118 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
NeilBrown86e6ffd2005-11-08 21:39:24 -08003119
3120 if (!entry->show)
3121 return -EIO;
NeilBrown758bfc82014-12-15 12:56:59 +11003122 if (!rdev->mddev)
3123 return -EBUSY;
3124 return entry->show(rdev, page);
NeilBrown86e6ffd2005-11-08 21:39:24 -08003125}
3126
3127static ssize_t
3128rdev_attr_store(struct kobject *kobj, struct attribute *attr,
3129 const char *page, size_t length)
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);
NeilBrown27c529b2008-03-04 14:29:33 -08003133 ssize_t rv;
NeilBrownfd01b882011-10-11 16:47:53 +11003134 struct mddev *mddev = rdev->mddev;
NeilBrown86e6ffd2005-11-08 21:39:24 -08003135
3136 if (!entry->store)
3137 return -EIO;
NeilBrown67463ac2006-07-10 04:44:19 -07003138 if (!capable(CAP_SYS_ADMIN))
3139 return -EACCES;
NeilBrown27c529b2008-03-04 14:29:33 -08003140 rv = mddev ? mddev_lock(mddev): -EBUSY;
NeilBrownca388052008-02-06 01:39:55 -08003141 if (!rv) {
NeilBrown27c529b2008-03-04 14:29:33 -08003142 if (rdev->mddev == NULL)
3143 rv = -EBUSY;
3144 else
3145 rv = entry->store(rdev, page, length);
Dan Williams6a518302008-04-30 00:52:28 -07003146 mddev_unlock(mddev);
NeilBrownca388052008-02-06 01:39:55 -08003147 }
3148 return rv;
NeilBrown86e6ffd2005-11-08 21:39:24 -08003149}
3150
3151static void rdev_free(struct kobject *ko)
3152{
NeilBrown3cb03002011-10-11 16:45:26 +11003153 struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
NeilBrown86e6ffd2005-11-08 21:39:24 -08003154 kfree(rdev);
3155}
Emese Revfy52cf25d2010-01-19 02:58:23 +01003156static const struct sysfs_ops rdev_sysfs_ops = {
NeilBrown86e6ffd2005-11-08 21:39:24 -08003157 .show = rdev_attr_show,
3158 .store = rdev_attr_store,
3159};
3160static struct kobj_type rdev_ktype = {
3161 .release = rdev_free,
3162 .sysfs_ops = &rdev_sysfs_ops,
3163 .default_attrs = rdev_default_attrs,
3164};
3165
NeilBrown3cb03002011-10-11 16:45:26 +11003166int md_rdev_init(struct md_rdev *rdev)
NeilBrowne8bb9a82010-06-01 19:37:26 +10003167{
3168 rdev->desc_nr = -1;
3169 rdev->saved_raid_disk = -1;
3170 rdev->raid_disk = -1;
3171 rdev->flags = 0;
3172 rdev->data_offset = 0;
NeilBrownc6563a82012-05-21 09:27:00 +10003173 rdev->new_data_offset = 0;
NeilBrowne8bb9a82010-06-01 19:37:26 +10003174 rdev->sb_events = 0;
3175 rdev->last_read_error.tv_sec = 0;
3176 rdev->last_read_error.tv_nsec = 0;
NeilBrown2699b672011-07-28 11:31:47 +10003177 rdev->sb_loaded = 0;
3178 rdev->bb_page = NULL;
NeilBrowne8bb9a82010-06-01 19:37:26 +10003179 atomic_set(&rdev->nr_pending, 0);
3180 atomic_set(&rdev->read_errors, 0);
3181 atomic_set(&rdev->corrected_errors, 0);
3182
3183 INIT_LIST_HEAD(&rdev->same_set);
3184 init_waitqueue_head(&rdev->blocked_wait);
NeilBrown2230dfe2011-07-28 11:31:46 +10003185
3186 /* Add space to store bad block list.
3187 * This reserves the space even on arrays where it cannot
3188 * be used - I wonder if that matters
3189 */
Vishal Vermafc974ee2015-12-24 19:20:34 -07003190 return badblocks_init(&rdev->badblocks, 0);
NeilBrowne8bb9a82010-06-01 19:37:26 +10003191}
3192EXPORT_SYMBOL_GPL(md_rdev_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003193/*
3194 * Import a device. If 'super_format' >= 0, then sanity check the superblock
3195 *
3196 * mark the device faulty if:
3197 *
3198 * - the device is nonexistent (zero size)
3199 * - the device has no valid superblock
3200 *
3201 * a faulty rdev _never_ has rdev->sb set.
3202 */
NeilBrown3cb03002011-10-11 16:45:26 +11003203static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204{
3205 char b[BDEVNAME_SIZE];
3206 int err;
NeilBrown3cb03002011-10-11 16:45:26 +11003207 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003208 sector_t size;
3209
NeilBrown9ffae0c2006-01-06 00:20:32 -08003210 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003211 if (!rdev) {
3212 printk(KERN_ERR "md: could not alloc mem for new device!\n");
3213 return ERR_PTR(-ENOMEM);
3214 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003215
NeilBrown2230dfe2011-07-28 11:31:46 +10003216 err = md_rdev_init(rdev);
3217 if (err)
3218 goto abort_free;
3219 err = alloc_disk_sb(rdev);
3220 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221 goto abort_free;
3222
NeilBrownc5d79ad2008-02-06 01:39:54 -08003223 err = lock_rdev(rdev, newdev, super_format == -2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003224 if (err)
3225 goto abort_free;
3226
Greg Kroah-Hartmanf9cb0742007-12-17 23:05:35 -07003227 kobject_init(&rdev->kobj, &rdev_ktype);
NeilBrown86e6ffd2005-11-08 21:39:24 -08003228
Mike Snitzer77304d22010-11-08 14:39:12 +01003229 size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003230 if (!size) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10003231 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07003232 "md: %s has zero or unknown size, marking faulty!\n",
3233 bdevname(rdev->bdev,b));
3234 err = -EINVAL;
3235 goto abort_free;
3236 }
3237
3238 if (super_format >= 0) {
3239 err = super_types[super_format].
3240 load_super(rdev, NULL, super_minor);
3241 if (err == -EINVAL) {
NeilBrowndf968c42007-07-17 04:06:11 -07003242 printk(KERN_WARNING
3243 "md: %s does not have a valid v%d.%d "
3244 "superblock, not importing!\n",
3245 bdevname(rdev->bdev,b),
3246 super_format, super_minor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247 goto abort_free;
3248 }
3249 if (err < 0) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10003250 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07003251 "md: could not read %s's sb, not importing!\n",
3252 bdevname(rdev->bdev,b));
3253 goto abort_free;
3254 }
3255 }
Dan Williams6bfe0b42008-04-30 00:52:32 -07003256
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257 return rdev;
3258
3259abort_free:
NeilBrown2699b672011-07-28 11:31:47 +10003260 if (rdev->bdev)
3261 unlock_rdev(rdev);
NeilBrown545c8792012-05-22 13:54:30 +10003262 md_rdev_clear(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003263 kfree(rdev);
3264 return ERR_PTR(err);
3265}
3266
3267/*
3268 * Check a full RAID array for plausibility
3269 */
3270
NeilBrownf72ffdd2014-09-30 14:23:59 +10003271static void analyze_sbs(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272{
3273 int i;
NeilBrown3cb03002011-10-11 16:45:26 +11003274 struct md_rdev *rdev, *freshest, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003275 char b[BDEVNAME_SIZE];
3276
3277 freshest = NULL;
NeilBrowndafb20f2012-03-19 12:46:39 +11003278 rdev_for_each_safe(rdev, tmp, mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279 switch (super_types[mddev->major_version].
3280 load_super(rdev, freshest, mddev->minor_version)) {
3281 case 1:
3282 freshest = rdev;
3283 break;
3284 case 0:
3285 break;
3286 default:
3287 printk( KERN_ERR \
3288 "md: fatal superblock inconsistency in %s"
NeilBrownf72ffdd2014-09-30 14:23:59 +10003289 " -- removing from array\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003290 bdevname(rdev->bdev,b));
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05003291 md_kick_rdev_from_array(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003292 }
3293
Linus Torvalds1da177e2005-04-16 15:20:36 -07003294 super_types[mddev->major_version].
3295 validate_super(mddev, freshest);
3296
3297 i = 0;
NeilBrowndafb20f2012-03-19 12:46:39 +11003298 rdev_for_each_safe(rdev, tmp, mddev) {
NeilBrown233fca32010-04-14 17:02:09 +10003299 if (mddev->max_disks &&
3300 (rdev->desc_nr >= mddev->max_disks ||
3301 i > mddev->max_disks)) {
NeilBrownde01dfa2009-02-06 18:02:46 +11003302 printk(KERN_WARNING
3303 "md: %s: %s: only %d devices permitted\n",
3304 mdname(mddev), bdevname(rdev->bdev, b),
3305 mddev->max_disks);
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05003306 md_kick_rdev_from_array(rdev);
NeilBrownde01dfa2009-02-06 18:02:46 +11003307 continue;
3308 }
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05003309 if (rdev != freshest) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310 if (super_types[mddev->major_version].
3311 validate_super(mddev, rdev)) {
3312 printk(KERN_WARNING "md: kicking non-fresh %s"
3313 " from array!\n",
3314 bdevname(rdev->bdev,b));
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05003315 md_kick_rdev_from_array(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003316 continue;
3317 }
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05003318 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319 if (mddev->level == LEVEL_MULTIPATH) {
3320 rdev->desc_nr = i++;
3321 rdev->raid_disk = rdev->desc_nr;
NeilBrownb2d444d2005-11-08 21:39:31 -08003322 set_bit(In_sync, &rdev->flags);
Shaohua Lif2076e72015-10-08 21:54:12 -07003323 } else if (rdev->raid_disk >=
3324 (mddev->raid_disks - min(0, mddev->delta_disks)) &&
3325 !test_bit(Journal, &rdev->flags)) {
NeilBrowna778b732007-05-23 13:58:10 -07003326 rdev->raid_disk = -1;
3327 clear_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003328 }
3329 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003330}
3331
NeilBrown72e02072009-12-14 12:49:55 +11003332/* Read a fixed-point number.
3333 * Numbers in sysfs attributes should be in "standard" units where
3334 * possible, so time should be in seconds.
NeilBrownf72ffdd2014-09-30 14:23:59 +10003335 * However we internally use a a much smaller unit such as
NeilBrown72e02072009-12-14 12:49:55 +11003336 * milliseconds or jiffies.
3337 * This function takes a decimal number with a possible fractional
3338 * component, and produces an integer which is the result of
3339 * multiplying that number by 10^'scale'.
3340 * all without any floating-point arithmetic.
3341 */
3342int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
3343{
3344 unsigned long result = 0;
3345 long decimals = -1;
3346 while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
3347 if (*cp == '.')
3348 decimals = 0;
3349 else if (decimals < scale) {
3350 unsigned int value;
3351 value = *cp - '0';
3352 result = result * 10 + value;
3353 if (decimals >= 0)
3354 decimals++;
3355 }
3356 cp++;
3357 }
3358 if (*cp == '\n')
3359 cp++;
3360 if (*cp)
3361 return -EINVAL;
3362 if (decimals < 0)
3363 decimals = 0;
3364 while (decimals < scale) {
3365 result *= 10;
3366 decimals ++;
3367 }
3368 *res = result;
3369 return 0;
3370}
3371
NeilBrowneae17012005-11-08 21:39:23 -08003372static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003373safe_delay_show(struct mddev *mddev, char *page)
NeilBrown16f17b32006-06-26 00:27:37 -07003374{
3375 int msec = (mddev->safemode_delay*1000)/HZ;
3376 return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
3377}
3378static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003379safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
NeilBrown16f17b32006-06-26 00:27:37 -07003380{
NeilBrown16f17b32006-06-26 00:27:37 -07003381 unsigned long msec;
Dan Williams97ce0a72008-09-24 22:48:19 -07003382
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11003383 if (mddev_is_clustered(mddev)) {
3384 pr_info("md: Safemode is disabled for clustered mode\n");
3385 return -EINVAL;
3386 }
3387
NeilBrown72e02072009-12-14 12:49:55 +11003388 if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
NeilBrown16f17b32006-06-26 00:27:37 -07003389 return -EINVAL;
NeilBrown16f17b32006-06-26 00:27:37 -07003390 if (msec == 0)
3391 mddev->safemode_delay = 0;
3392 else {
NeilBrown19052c02008-08-05 15:54:13 +10003393 unsigned long old_delay = mddev->safemode_delay;
NeilBrown1b30e662014-12-15 12:57:00 +11003394 unsigned long new_delay = (msec*HZ)/1000;
3395
3396 if (new_delay == 0)
3397 new_delay = 1;
3398 mddev->safemode_delay = new_delay;
3399 if (new_delay < old_delay || old_delay == 0)
3400 mod_timer(&mddev->safemode_timer, jiffies+1);
NeilBrown16f17b32006-06-26 00:27:37 -07003401 }
3402 return len;
3403}
3404static struct md_sysfs_entry md_safe_delay =
NeilBrown80ca3a42006-07-10 04:44:18 -07003405__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
NeilBrown16f17b32006-06-26 00:27:37 -07003406
3407static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003408level_show(struct mddev *mddev, char *page)
NeilBrowneae17012005-11-08 21:39:23 -08003409{
NeilBrown36d091f2014-12-15 12:56:58 +11003410 struct md_personality *p;
3411 int ret;
3412 spin_lock(&mddev->lock);
3413 p = mddev->pers;
NeilBrownd9d166c2006-01-06 00:20:51 -08003414 if (p)
NeilBrown36d091f2014-12-15 12:56:58 +11003415 ret = sprintf(page, "%s\n", p->name);
NeilBrownd9d166c2006-01-06 00:20:51 -08003416 else if (mddev->clevel[0])
NeilBrown36d091f2014-12-15 12:56:58 +11003417 ret = sprintf(page, "%s\n", mddev->clevel);
NeilBrownd9d166c2006-01-06 00:20:51 -08003418 else if (mddev->level != LEVEL_NONE)
NeilBrown36d091f2014-12-15 12:56:58 +11003419 ret = sprintf(page, "%d\n", mddev->level);
NeilBrownd9d166c2006-01-06 00:20:51 -08003420 else
NeilBrown36d091f2014-12-15 12:56:58 +11003421 ret = 0;
3422 spin_unlock(&mddev->lock);
3423 return ret;
NeilBrowneae17012005-11-08 21:39:23 -08003424}
3425
NeilBrownd9d166c2006-01-06 00:20:51 -08003426static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003427level_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownd9d166c2006-01-06 00:20:51 -08003428{
Dan Williamsf2859af2010-05-02 10:04:16 -07003429 char clevel[16];
NeilBrown67918752014-12-15 12:57:01 +11003430 ssize_t rv;
3431 size_t slen = len;
NeilBrowndb721d32014-12-15 12:56:58 +11003432 struct md_personality *pers, *oldpers;
Dan Williamsf2859af2010-05-02 10:04:16 -07003433 long level;
NeilBrowndb721d32014-12-15 12:56:58 +11003434 void *priv, *oldpriv;
NeilBrown3cb03002011-10-11 16:45:26 +11003435 struct md_rdev *rdev;
NeilBrown245f46c2009-03-31 14:39:39 +11003436
NeilBrown67918752014-12-15 12:57:01 +11003437 if (slen == 0 || slen >= sizeof(clevel))
3438 return -EINVAL;
3439
3440 rv = mddev_lock(mddev);
3441 if (rv)
NeilBrown245f46c2009-03-31 14:39:39 +11003442 return rv;
NeilBrown67918752014-12-15 12:57:01 +11003443
3444 if (mddev->pers == NULL) {
3445 strncpy(mddev->clevel, buf, slen);
3446 if (mddev->clevel[slen-1] == '\n')
3447 slen--;
3448 mddev->clevel[slen] = 0;
3449 mddev->level = LEVEL_NONE;
3450 rv = len;
3451 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003452 }
NeilBrown67918752014-12-15 12:57:01 +11003453 rv = -EROFS;
NeilBrownbd8839e2014-05-28 13:39:21 +10003454 if (mddev->ro)
NeilBrown67918752014-12-15 12:57:01 +11003455 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003456
3457 /* request to change the personality. Need to ensure:
3458 * - array is not engaged in resync/recovery/reshape
3459 * - old personality can be suspended
3460 * - new personality will access other array.
3461 */
3462
NeilBrown67918752014-12-15 12:57:01 +11003463 rv = -EBUSY;
NeilBrownbb4f1e92010-08-08 21:18:03 +10003464 if (mddev->sync_thread ||
NeilBrownf851b602014-12-11 10:02:10 +11003465 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
NeilBrownbb4f1e92010-08-08 21:18:03 +10003466 mddev->reshape_position != MaxSector ||
3467 mddev->sysfs_active)
NeilBrown67918752014-12-15 12:57:01 +11003468 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003469
NeilBrown67918752014-12-15 12:57:01 +11003470 rv = -EINVAL;
NeilBrown245f46c2009-03-31 14:39:39 +11003471 if (!mddev->pers->quiesce) {
3472 printk(KERN_WARNING "md: %s: %s does not support online personality change\n",
3473 mdname(mddev), mddev->pers->name);
NeilBrown67918752014-12-15 12:57:01 +11003474 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003475 }
3476
3477 /* Now find the new personality */
NeilBrown67918752014-12-15 12:57:01 +11003478 strncpy(clevel, buf, slen);
3479 if (clevel[slen-1] == '\n')
3480 slen--;
3481 clevel[slen] = 0;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09003482 if (kstrtol(clevel, 10, &level))
Dan Williamsf2859af2010-05-02 10:04:16 -07003483 level = LEVEL_NONE;
NeilBrown245f46c2009-03-31 14:39:39 +11003484
Dan Williamsf2859af2010-05-02 10:04:16 -07003485 if (request_module("md-%s", clevel) != 0)
3486 request_module("md-level-%s", clevel);
NeilBrown245f46c2009-03-31 14:39:39 +11003487 spin_lock(&pers_lock);
Dan Williamsf2859af2010-05-02 10:04:16 -07003488 pers = find_pers(level, clevel);
NeilBrown245f46c2009-03-31 14:39:39 +11003489 if (!pers || !try_module_get(pers->owner)) {
3490 spin_unlock(&pers_lock);
Dan Williamsf2859af2010-05-02 10:04:16 -07003491 printk(KERN_WARNING "md: personality %s not loaded\n", clevel);
NeilBrown67918752014-12-15 12:57:01 +11003492 rv = -EINVAL;
3493 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003494 }
3495 spin_unlock(&pers_lock);
3496
3497 if (pers == mddev->pers) {
3498 /* Nothing to do! */
3499 module_put(pers->owner);
NeilBrown67918752014-12-15 12:57:01 +11003500 rv = len;
3501 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003502 }
3503 if (!pers->takeover) {
3504 module_put(pers->owner);
3505 printk(KERN_WARNING "md: %s: %s does not support personality takeover\n",
Dan Williamsf2859af2010-05-02 10:04:16 -07003506 mdname(mddev), clevel);
NeilBrown67918752014-12-15 12:57:01 +11003507 rv = -EINVAL;
3508 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003509 }
3510
NeilBrowndafb20f2012-03-19 12:46:39 +11003511 rdev_for_each(rdev, mddev)
NeilBrowne93f68a2010-06-15 09:36:03 +01003512 rdev->new_raid_disk = rdev->raid_disk;
3513
NeilBrown245f46c2009-03-31 14:39:39 +11003514 /* ->takeover must set new_* and/or delta_disks
3515 * if it succeeds, and may set them when it fails.
3516 */
3517 priv = pers->takeover(mddev);
3518 if (IS_ERR(priv)) {
3519 mddev->new_level = mddev->level;
3520 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10003521 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrown245f46c2009-03-31 14:39:39 +11003522 mddev->raid_disks -= mddev->delta_disks;
3523 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10003524 mddev->reshape_backwards = 0;
NeilBrown245f46c2009-03-31 14:39:39 +11003525 module_put(pers->owner);
3526 printk(KERN_WARNING "md: %s: %s would not accept array\n",
Dan Williamsf2859af2010-05-02 10:04:16 -07003527 mdname(mddev), clevel);
NeilBrown67918752014-12-15 12:57:01 +11003528 rv = PTR_ERR(priv);
3529 goto out_unlock;
NeilBrown245f46c2009-03-31 14:39:39 +11003530 }
3531
3532 /* Looks like we have a winner */
3533 mddev_suspend(mddev);
NeilBrown5aa61f42014-12-15 12:56:57 +11003534 mddev_detach(mddev);
NeilBrown36d091f2014-12-15 12:56:58 +11003535
3536 spin_lock(&mddev->lock);
NeilBrowndb721d32014-12-15 12:56:58 +11003537 oldpers = mddev->pers;
3538 oldpriv = mddev->private;
3539 mddev->pers = pers;
3540 mddev->private = priv;
3541 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3542 mddev->level = mddev->new_level;
3543 mddev->layout = mddev->new_layout;
3544 mddev->chunk_sectors = mddev->new_chunk_sectors;
3545 mddev->delta_disks = 0;
3546 mddev->reshape_backwards = 0;
3547 mddev->degraded = 0;
NeilBrown36d091f2014-12-15 12:56:58 +11003548 spin_unlock(&mddev->lock);
NeilBrownf72ffdd2014-09-30 14:23:59 +10003549
NeilBrowndb721d32014-12-15 12:56:58 +11003550 if (oldpers->sync_request == NULL &&
Trela Maciej54071b32010-03-08 16:02:42 +11003551 mddev->external) {
3552 /* We are converting from a no-redundancy array
3553 * to a redundancy array and metadata is managed
3554 * externally so we need to be sure that writes
3555 * won't block due to a need to transition
3556 * clean->dirty
3557 * until external management is started.
3558 */
3559 mddev->in_sync = 0;
3560 mddev->safemode_delay = 0;
3561 mddev->safemode = 0;
3562 }
3563
NeilBrowndb721d32014-12-15 12:56:58 +11003564 oldpers->free(mddev, oldpriv);
3565
3566 if (oldpers->sync_request == NULL &&
3567 pers->sync_request != NULL) {
3568 /* need to add the md_redundancy_group */
3569 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
3570 printk(KERN_WARNING
3571 "md: cannot register extra attributes for %s\n",
3572 mdname(mddev));
3573 mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
3574 }
3575 if (oldpers->sync_request != NULL &&
3576 pers->sync_request == NULL) {
3577 /* need to remove the md_redundancy_group */
3578 if (mddev->to_remove == NULL)
3579 mddev->to_remove = &md_redundancy_group;
3580 }
3581
NeilBrowndafb20f2012-03-19 12:46:39 +11003582 rdev_for_each(rdev, mddev) {
NeilBrowne93f68a2010-06-15 09:36:03 +01003583 if (rdev->raid_disk < 0)
3584 continue;
NeilBrownbf2cb0d2011-01-14 09:14:34 +11003585 if (rdev->new_raid_disk >= mddev->raid_disks)
NeilBrowne93f68a2010-06-15 09:36:03 +01003586 rdev->new_raid_disk = -1;
3587 if (rdev->new_raid_disk == rdev->raid_disk)
3588 continue;
Namhyung Kim36fad852011-07-27 11:00:36 +10003589 sysfs_unlink_rdev(mddev, rdev);
NeilBrowne93f68a2010-06-15 09:36:03 +01003590 }
NeilBrowndafb20f2012-03-19 12:46:39 +11003591 rdev_for_each(rdev, mddev) {
NeilBrowne93f68a2010-06-15 09:36:03 +01003592 if (rdev->raid_disk < 0)
3593 continue;
3594 if (rdev->new_raid_disk == rdev->raid_disk)
3595 continue;
3596 rdev->raid_disk = rdev->new_raid_disk;
3597 if (rdev->raid_disk < 0)
NeilBrown3a981b02009-08-03 10:59:55 +10003598 clear_bit(In_sync, &rdev->flags);
NeilBrowne93f68a2010-06-15 09:36:03 +01003599 else {
Namhyung Kim36fad852011-07-27 11:00:36 +10003600 if (sysfs_link_rdev(mddev, rdev))
3601 printk(KERN_WARNING "md: cannot register rd%d"
3602 " for %s after level change\n",
3603 rdev->raid_disk, mdname(mddev));
NeilBrown3a981b02009-08-03 10:59:55 +10003604 }
NeilBrowne93f68a2010-06-15 09:36:03 +01003605 }
3606
NeilBrowndb721d32014-12-15 12:56:58 +11003607 if (pers->sync_request == NULL) {
Trela, Maciej9af204c2010-03-08 16:02:44 +11003608 /* this is now an array without redundancy, so
3609 * it must always be in_sync
3610 */
3611 mddev->in_sync = 1;
3612 del_timer_sync(&mddev->safemode_timer);
3613 }
NeilBrown02e5f5c2013-11-14 15:16:15 +11003614 blk_set_stacking_limits(&mddev->queue->limits);
NeilBrown245f46c2009-03-31 14:39:39 +11003615 pers->run(mddev);
NeilBrown245f46c2009-03-31 14:39:39 +11003616 set_bit(MD_CHANGE_DEVS, &mddev->flags);
Jonathan Brassow47525e52012-05-22 13:55:29 +10003617 mddev_resume(mddev);
NeilBrown830778a2014-01-14 15:17:03 +11003618 if (!mddev->thread)
3619 md_update_sb(mddev, 1);
Maciej Trela5cac78612010-04-14 17:17:39 +10003620 sysfs_notify(&mddev->kobj, NULL, "level");
Dan Williamsbb7f8d22010-05-01 18:14:57 -07003621 md_new_event(mddev);
NeilBrown67918752014-12-15 12:57:01 +11003622 rv = len;
3623out_unlock:
3624 mddev_unlock(mddev);
NeilBrownd9d166c2006-01-06 00:20:51 -08003625 return rv;
3626}
3627
3628static struct md_sysfs_entry md_level =
NeilBrown80ca3a42006-07-10 04:44:18 -07003629__ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
NeilBrowneae17012005-11-08 21:39:23 -08003630
NeilBrownd4dbd022006-06-26 00:27:59 -07003631static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003632layout_show(struct mddev *mddev, char *page)
NeilBrownd4dbd022006-06-26 00:27:59 -07003633{
3634 /* just a number, not meaningful for all levels */
NeilBrown08a02ec2007-05-09 02:35:38 -07003635 if (mddev->reshape_position != MaxSector &&
3636 mddev->layout != mddev->new_layout)
3637 return sprintf(page, "%d (%d)\n",
3638 mddev->new_layout, mddev->layout);
NeilBrownd4dbd022006-06-26 00:27:59 -07003639 return sprintf(page, "%d\n", mddev->layout);
3640}
3641
3642static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003643layout_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownd4dbd022006-06-26 00:27:59 -07003644{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003645 unsigned int n;
NeilBrown67918752014-12-15 12:57:01 +11003646 int err;
NeilBrownd4dbd022006-06-26 00:27:59 -07003647
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003648 err = kstrtouint(buf, 10, &n);
3649 if (err < 0)
3650 return err;
NeilBrown67918752014-12-15 12:57:01 +11003651 err = mddev_lock(mddev);
3652 if (err)
3653 return err;
NeilBrownd4dbd022006-06-26 00:27:59 -07003654
NeilBrownb3546032009-03-31 14:56:41 +11003655 if (mddev->pers) {
NeilBrown50ac1682009-06-18 08:47:55 +10003656 if (mddev->pers->check_reshape == NULL)
NeilBrown67918752014-12-15 12:57:01 +11003657 err = -EBUSY;
3658 else if (mddev->ro)
3659 err = -EROFS;
3660 else {
3661 mddev->new_layout = n;
3662 err = mddev->pers->check_reshape(mddev);
3663 if (err)
3664 mddev->new_layout = mddev->layout;
NeilBrown597a7112009-06-18 08:47:42 +10003665 }
NeilBrownb3546032009-03-31 14:56:41 +11003666 } else {
NeilBrown08a02ec2007-05-09 02:35:38 -07003667 mddev->new_layout = n;
NeilBrownb3546032009-03-31 14:56:41 +11003668 if (mddev->reshape_position == MaxSector)
3669 mddev->layout = n;
3670 }
NeilBrown67918752014-12-15 12:57:01 +11003671 mddev_unlock(mddev);
3672 return err ?: len;
NeilBrownd4dbd022006-06-26 00:27:59 -07003673}
3674static struct md_sysfs_entry md_layout =
NeilBrown80ca3a42006-07-10 04:44:18 -07003675__ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
NeilBrownd4dbd022006-06-26 00:27:59 -07003676
NeilBrowneae17012005-11-08 21:39:23 -08003677static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003678raid_disks_show(struct mddev *mddev, char *page)
NeilBrowneae17012005-11-08 21:39:23 -08003679{
NeilBrownbb636542005-11-08 21:39:45 -08003680 if (mddev->raid_disks == 0)
3681 return 0;
NeilBrown08a02ec2007-05-09 02:35:38 -07003682 if (mddev->reshape_position != MaxSector &&
3683 mddev->delta_disks != 0)
3684 return sprintf(page, "%d (%d)\n", mddev->raid_disks,
3685 mddev->raid_disks - mddev->delta_disks);
NeilBrowneae17012005-11-08 21:39:23 -08003686 return sprintf(page, "%d\n", mddev->raid_disks);
3687}
3688
NeilBrownfd01b882011-10-11 16:47:53 +11003689static int update_raid_disks(struct mddev *mddev, int raid_disks);
NeilBrownda943b992006-01-06 00:20:54 -08003690
3691static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003692raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownda943b992006-01-06 00:20:54 -08003693{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003694 unsigned int n;
NeilBrown67918752014-12-15 12:57:01 +11003695 int err;
NeilBrownda943b992006-01-06 00:20:54 -08003696
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003697 err = kstrtouint(buf, 10, &n);
3698 if (err < 0)
3699 return err;
NeilBrownda943b992006-01-06 00:20:54 -08003700
NeilBrown67918752014-12-15 12:57:01 +11003701 err = mddev_lock(mddev);
3702 if (err)
3703 return err;
NeilBrownda943b992006-01-06 00:20:54 -08003704 if (mddev->pers)
NeilBrown67918752014-12-15 12:57:01 +11003705 err = update_raid_disks(mddev, n);
NeilBrown08a02ec2007-05-09 02:35:38 -07003706 else if (mddev->reshape_position != MaxSector) {
NeilBrownc6563a82012-05-21 09:27:00 +10003707 struct md_rdev *rdev;
NeilBrown08a02ec2007-05-09 02:35:38 -07003708 int olddisks = mddev->raid_disks - mddev->delta_disks;
NeilBrownc6563a82012-05-21 09:27:00 +10003709
NeilBrown67918752014-12-15 12:57:01 +11003710 err = -EINVAL;
NeilBrownc6563a82012-05-21 09:27:00 +10003711 rdev_for_each(rdev, mddev) {
3712 if (olddisks < n &&
3713 rdev->data_offset < rdev->new_data_offset)
NeilBrown67918752014-12-15 12:57:01 +11003714 goto out_unlock;
NeilBrownc6563a82012-05-21 09:27:00 +10003715 if (olddisks > n &&
3716 rdev->data_offset > rdev->new_data_offset)
NeilBrown67918752014-12-15 12:57:01 +11003717 goto out_unlock;
NeilBrownc6563a82012-05-21 09:27:00 +10003718 }
NeilBrown67918752014-12-15 12:57:01 +11003719 err = 0;
NeilBrown08a02ec2007-05-09 02:35:38 -07003720 mddev->delta_disks = n - olddisks;
3721 mddev->raid_disks = n;
NeilBrown2c810cd2012-05-21 09:27:00 +10003722 mddev->reshape_backwards = (mddev->delta_disks < 0);
NeilBrown08a02ec2007-05-09 02:35:38 -07003723 } else
NeilBrownda943b992006-01-06 00:20:54 -08003724 mddev->raid_disks = n;
NeilBrown67918752014-12-15 12:57:01 +11003725out_unlock:
3726 mddev_unlock(mddev);
3727 return err ? err : len;
NeilBrownda943b992006-01-06 00:20:54 -08003728}
3729static struct md_sysfs_entry md_raid_disks =
NeilBrown80ca3a42006-07-10 04:44:18 -07003730__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
NeilBrowneae17012005-11-08 21:39:23 -08003731
NeilBrown24dd4692005-11-08 21:39:26 -08003732static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003733chunk_size_show(struct mddev *mddev, char *page)
NeilBrown3b343802006-01-06 00:20:47 -08003734{
NeilBrown08a02ec2007-05-09 02:35:38 -07003735 if (mddev->reshape_position != MaxSector &&
Andre Noll664e7c42009-06-18 08:45:27 +10003736 mddev->chunk_sectors != mddev->new_chunk_sectors)
3737 return sprintf(page, "%d (%d)\n",
3738 mddev->new_chunk_sectors << 9,
Andre Noll9d8f0362009-06-18 08:45:01 +10003739 mddev->chunk_sectors << 9);
3740 return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
NeilBrown3b343802006-01-06 00:20:47 -08003741}
3742
3743static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003744chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown3b343802006-01-06 00:20:47 -08003745{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003746 unsigned long n;
NeilBrown67918752014-12-15 12:57:01 +11003747 int err;
NeilBrown3b343802006-01-06 00:20:47 -08003748
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003749 err = kstrtoul(buf, 10, &n);
3750 if (err < 0)
3751 return err;
NeilBrown3b343802006-01-06 00:20:47 -08003752
NeilBrown67918752014-12-15 12:57:01 +11003753 err = mddev_lock(mddev);
3754 if (err)
3755 return err;
NeilBrownb3546032009-03-31 14:56:41 +11003756 if (mddev->pers) {
NeilBrown50ac1682009-06-18 08:47:55 +10003757 if (mddev->pers->check_reshape == NULL)
NeilBrown67918752014-12-15 12:57:01 +11003758 err = -EBUSY;
3759 else if (mddev->ro)
3760 err = -EROFS;
3761 else {
3762 mddev->new_chunk_sectors = n >> 9;
3763 err = mddev->pers->check_reshape(mddev);
3764 if (err)
3765 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrown597a7112009-06-18 08:47:42 +10003766 }
NeilBrownb3546032009-03-31 14:56:41 +11003767 } else {
Andre Noll664e7c42009-06-18 08:45:27 +10003768 mddev->new_chunk_sectors = n >> 9;
NeilBrownb3546032009-03-31 14:56:41 +11003769 if (mddev->reshape_position == MaxSector)
Andre Noll9d8f0362009-06-18 08:45:01 +10003770 mddev->chunk_sectors = n >> 9;
NeilBrownb3546032009-03-31 14:56:41 +11003771 }
NeilBrown67918752014-12-15 12:57:01 +11003772 mddev_unlock(mddev);
3773 return err ?: len;
NeilBrown3b343802006-01-06 00:20:47 -08003774}
3775static struct md_sysfs_entry md_chunk_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07003776__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
NeilBrown3b343802006-01-06 00:20:47 -08003777
NeilBrowna94213b2006-06-26 00:28:00 -07003778static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003779resync_start_show(struct mddev *mddev, char *page)
NeilBrowna94213b2006-06-26 00:28:00 -07003780{
NeilBrownd1a7c502009-03-31 15:24:32 +11003781 if (mddev->recovery_cp == MaxSector)
3782 return sprintf(page, "none\n");
NeilBrowna94213b2006-06-26 00:28:00 -07003783 return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
3784}
3785
3786static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003787resync_start_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowna94213b2006-06-26 00:28:00 -07003788{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003789 unsigned long long n;
NeilBrown67918752014-12-15 12:57:01 +11003790 int err;
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03003791
3792 if (cmd_match(buf, "none"))
3793 n = MaxSector;
3794 else {
3795 err = kstrtoull(buf, 10, &n);
3796 if (err < 0)
3797 return err;
3798 if (n != (sector_t)n)
3799 return -EINVAL;
3800 }
NeilBrowna94213b2006-06-26 00:28:00 -07003801
NeilBrown67918752014-12-15 12:57:01 +11003802 err = mddev_lock(mddev);
3803 if (err)
3804 return err;
NeilBrownb0986362011-05-11 15:52:21 +10003805 if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
NeilBrown67918752014-12-15 12:57:01 +11003806 err = -EBUSY;
NeilBrowna94213b2006-06-26 00:28:00 -07003807
NeilBrown67918752014-12-15 12:57:01 +11003808 if (!err) {
3809 mddev->recovery_cp = n;
3810 if (mddev->pers)
3811 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3812 }
3813 mddev_unlock(mddev);
3814 return err ?: len;
NeilBrowna94213b2006-06-26 00:28:00 -07003815}
3816static struct md_sysfs_entry md_resync_start =
NeilBrown750f1992014-09-30 08:53:05 +10003817__ATTR_PREALLOC(resync_start, S_IRUGO|S_IWUSR,
3818 resync_start_show, resync_start_store);
NeilBrowna94213b2006-06-26 00:28:00 -07003819
NeilBrown9e653b62006-06-26 00:27:58 -07003820/*
3821 * The array state can be:
3822 *
3823 * clear
3824 * No devices, no size, no level
3825 * Equivalent to STOP_ARRAY ioctl
3826 * inactive
3827 * May have some settings, but array is not active
3828 * all IO results in error
3829 * When written, doesn't tear down array, but just stops it
3830 * suspended (not supported yet)
3831 * All IO requests will block. The array can be reconfigured.
Andre Noll910d8cb2008-03-25 21:00:53 +01003832 * Writing this, if accepted, will block until array is quiescent
NeilBrown9e653b62006-06-26 00:27:58 -07003833 * readonly
3834 * no resync can happen. no superblocks get written.
3835 * write requests fail
3836 * read-auto
3837 * like readonly, but behaves like 'clean' on a write request.
3838 *
3839 * clean - no pending writes, but otherwise active.
3840 * When written to inactive array, starts without resync
3841 * If a write request arrives then
3842 * if metadata is known, mark 'dirty' and switch to 'active'.
3843 * if not known, block and switch to write-pending
3844 * If written to an active array that has pending writes, then fails.
3845 * active
3846 * fully active: IO and resync can be happening.
3847 * When written to inactive array, starts with resync
3848 *
3849 * write-pending
3850 * clean, but writes are blocked waiting for 'active' to be written.
3851 *
3852 * active-idle
3853 * like active, but no writes have been seen for a while (100msec).
3854 *
3855 */
3856enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
3857 write_pending, active_idle, bad_word};
Adrian Bunk05381952006-06-26 00:28:01 -07003858static char *array_states[] = {
NeilBrown9e653b62006-06-26 00:27:58 -07003859 "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
3860 "write-pending", "active-idle", NULL };
3861
3862static int match_word(const char *word, char **list)
3863{
3864 int n;
3865 for (n=0; list[n]; n++)
3866 if (cmd_match(word, list[n]))
3867 break;
3868 return n;
3869}
3870
3871static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003872array_state_show(struct mddev *mddev, char *page)
NeilBrown9e653b62006-06-26 00:27:58 -07003873{
3874 enum array_state st = inactive;
3875
3876 if (mddev->pers)
3877 switch(mddev->ro) {
3878 case 1:
3879 st = readonly;
3880 break;
3881 case 2:
3882 st = read_auto;
3883 break;
3884 case 0:
3885 if (mddev->in_sync)
3886 st = clean;
NeilBrown070dc6d2010-08-30 17:33:34 +10003887 else if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
NeilBrowne6910632008-02-06 01:39:51 -08003888 st = write_pending;
NeilBrown9e653b62006-06-26 00:27:58 -07003889 else if (mddev->safemode)
3890 st = active_idle;
3891 else
3892 st = active;
3893 }
3894 else {
3895 if (list_empty(&mddev->disks) &&
3896 mddev->raid_disks == 0 &&
Andre Noll58c0fed2009-03-31 14:33:13 +11003897 mddev->dev_sectors == 0)
NeilBrown9e653b62006-06-26 00:27:58 -07003898 st = clear;
3899 else
3900 st = inactive;
3901 }
3902 return sprintf(page, "%s\n", array_states[st]);
3903}
3904
NeilBrownf72ffdd2014-09-30 14:23:59 +10003905static int do_md_stop(struct mddev *mddev, int ro, struct block_device *bdev);
3906static int md_set_readonly(struct mddev *mddev, struct block_device *bdev);
3907static int do_md_run(struct mddev *mddev);
NeilBrownfd01b882011-10-11 16:47:53 +11003908static int restart_array(struct mddev *mddev);
NeilBrown9e653b62006-06-26 00:27:58 -07003909
3910static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003911array_state_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown9e653b62006-06-26 00:27:58 -07003912{
NeilBrown67918752014-12-15 12:57:01 +11003913 int err;
NeilBrown9e653b62006-06-26 00:27:58 -07003914 enum array_state st = match_word(buf, array_states);
NeilBrown67918752014-12-15 12:57:01 +11003915
3916 if (mddev->pers && (st == active || st == clean) && mddev->ro != 1) {
3917 /* don't take reconfig_mutex when toggling between
3918 * clean and active
3919 */
3920 spin_lock(&mddev->lock);
3921 if (st == active) {
3922 restart_array(mddev);
3923 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
3924 wake_up(&mddev->sb_wait);
3925 err = 0;
3926 } else /* st == clean */ {
3927 restart_array(mddev);
3928 if (atomic_read(&mddev->writes_pending) == 0) {
3929 if (mddev->in_sync == 0) {
3930 mddev->in_sync = 1;
3931 if (mddev->safemode == 1)
3932 mddev->safemode = 0;
3933 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3934 }
3935 err = 0;
3936 } else
3937 err = -EBUSY;
3938 }
3939 spin_unlock(&mddev->lock);
NeilBrownc008f1d2015-06-12 19:46:44 +10003940 return err ?: len;
NeilBrown67918752014-12-15 12:57:01 +11003941 }
3942 err = mddev_lock(mddev);
3943 if (err)
3944 return err;
3945 err = -EINVAL;
NeilBrown9e653b62006-06-26 00:27:58 -07003946 switch(st) {
3947 case bad_word:
3948 break;
3949 case clear:
3950 /* stopping an active array */
NeilBrowna05b7ea02012-07-19 15:59:18 +10003951 err = do_md_stop(mddev, 0, NULL);
NeilBrown9e653b62006-06-26 00:27:58 -07003952 break;
3953 case inactive:
3954 /* stopping an active array */
NeilBrown90cf1952012-07-31 10:04:55 +10003955 if (mddev->pers)
NeilBrowna05b7ea02012-07-19 15:59:18 +10003956 err = do_md_stop(mddev, 2, NULL);
NeilBrown90cf1952012-07-31 10:04:55 +10003957 else
NeilBrowne6910632008-02-06 01:39:51 -08003958 err = 0; /* already inactive */
NeilBrown9e653b62006-06-26 00:27:58 -07003959 break;
3960 case suspended:
3961 break; /* not supported yet */
3962 case readonly:
3963 if (mddev->pers)
NeilBrowna05b7ea02012-07-19 15:59:18 +10003964 err = md_set_readonly(mddev, NULL);
NeilBrown9e653b62006-06-26 00:27:58 -07003965 else {
3966 mddev->ro = 1;
NeilBrown648b6292008-04-30 00:52:30 -07003967 set_disk_ro(mddev->gendisk, 1);
NeilBrown9e653b62006-06-26 00:27:58 -07003968 err = do_md_run(mddev);
3969 }
3970 break;
3971 case read_auto:
NeilBrown9e653b62006-06-26 00:27:58 -07003972 if (mddev->pers) {
NeilBrown80268ee2008-10-13 11:55:12 +11003973 if (mddev->ro == 0)
NeilBrowna05b7ea02012-07-19 15:59:18 +10003974 err = md_set_readonly(mddev, NULL);
NeilBrown80268ee2008-10-13 11:55:12 +11003975 else if (mddev->ro == 1)
NeilBrown648b6292008-04-30 00:52:30 -07003976 err = restart_array(mddev);
3977 if (err == 0) {
3978 mddev->ro = 2;
3979 set_disk_ro(mddev->gendisk, 0);
3980 }
NeilBrown9e653b62006-06-26 00:27:58 -07003981 } else {
3982 mddev->ro = 2;
3983 err = do_md_run(mddev);
3984 }
3985 break;
3986 case clean:
3987 if (mddev->pers) {
Song Liu339421d2015-10-08 21:54:13 -07003988 err = restart_array(mddev);
3989 if (err)
3990 break;
NeilBrown85572d72014-12-15 12:56:56 +11003991 spin_lock(&mddev->lock);
NeilBrown9e653b62006-06-26 00:27:58 -07003992 if (atomic_read(&mddev->writes_pending) == 0) {
NeilBrowne6910632008-02-06 01:39:51 -08003993 if (mddev->in_sync == 0) {
3994 mddev->in_sync = 1;
NeilBrown31a59e32008-04-30 00:52:30 -07003995 if (mddev->safemode == 1)
3996 mddev->safemode = 0;
NeilBrown070dc6d2010-08-30 17:33:34 +10003997 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrowne6910632008-02-06 01:39:51 -08003998 }
3999 err = 0;
4000 } else
4001 err = -EBUSY;
NeilBrown85572d72014-12-15 12:56:56 +11004002 spin_unlock(&mddev->lock);
NeilBrown5bf29592009-05-07 12:50:57 +10004003 } else
4004 err = -EINVAL;
NeilBrown9e653b62006-06-26 00:27:58 -07004005 break;
4006 case active:
4007 if (mddev->pers) {
Song Liu339421d2015-10-08 21:54:13 -07004008 err = restart_array(mddev);
4009 if (err)
4010 break;
NeilBrown070dc6d2010-08-30 17:33:34 +10004011 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrown9e653b62006-06-26 00:27:58 -07004012 wake_up(&mddev->sb_wait);
4013 err = 0;
4014 } else {
4015 mddev->ro = 0;
NeilBrown648b6292008-04-30 00:52:30 -07004016 set_disk_ro(mddev->gendisk, 0);
NeilBrown9e653b62006-06-26 00:27:58 -07004017 err = do_md_run(mddev);
4018 }
4019 break;
4020 case write_pending:
4021 case active_idle:
4022 /* these cannot be set */
4023 break;
4024 }
NeilBrown67918752014-12-15 12:57:01 +11004025
4026 if (!err) {
NeilBrown1d23f172011-12-08 15:49:12 +11004027 if (mddev->hold_active == UNTIL_IOCTL)
4028 mddev->hold_active = 0;
NeilBrown00bcb4a2010-06-01 19:37:23 +10004029 sysfs_notify_dirent_safe(mddev->sysfs_state);
Neil Brown0fd62b82008-06-28 08:31:36 +10004030 }
NeilBrown67918752014-12-15 12:57:01 +11004031 mddev_unlock(mddev);
4032 return err ?: len;
NeilBrown9e653b62006-06-26 00:27:58 -07004033}
NeilBrown80ca3a42006-07-10 04:44:18 -07004034static struct md_sysfs_entry md_array_state =
NeilBrown750f1992014-09-30 08:53:05 +10004035__ATTR_PREALLOC(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
NeilBrown9e653b62006-06-26 00:27:58 -07004036
NeilBrown6d7ff732006-01-06 00:21:16 -08004037static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004038max_corrected_read_errors_show(struct mddev *mddev, char *page) {
Robert Becker1e509152009-12-14 12:49:58 +11004039 return sprintf(page, "%d\n",
4040 atomic_read(&mddev->max_corr_read_errors));
4041}
4042
4043static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004044max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
Robert Becker1e509152009-12-14 12:49:58 +11004045{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004046 unsigned int n;
4047 int rv;
Robert Becker1e509152009-12-14 12:49:58 +11004048
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004049 rv = kstrtouint(buf, 10, &n);
4050 if (rv < 0)
4051 return rv;
4052 atomic_set(&mddev->max_corr_read_errors, n);
4053 return len;
Robert Becker1e509152009-12-14 12:49:58 +11004054}
4055
4056static struct md_sysfs_entry max_corr_read_errors =
4057__ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
4058 max_corrected_read_errors_store);
4059
4060static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004061null_show(struct mddev *mddev, char *page)
NeilBrown6d7ff732006-01-06 00:21:16 -08004062{
4063 return -EINVAL;
4064}
4065
4066static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004067new_dev_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown6d7ff732006-01-06 00:21:16 -08004068{
4069 /* buf must be %d:%d\n? giving major and minor numbers */
4070 /* The new device is added to the array.
4071 * If the array has a persistent superblock, we read the
4072 * superblock to initialise info and check validity.
4073 * Otherwise, only checking done is that in bind_rdev_to_array,
4074 * which mainly checks size.
4075 */
4076 char *e;
4077 int major = simple_strtoul(buf, &e, 10);
4078 int minor;
4079 dev_t dev;
NeilBrown3cb03002011-10-11 16:45:26 +11004080 struct md_rdev *rdev;
NeilBrown6d7ff732006-01-06 00:21:16 -08004081 int err;
4082
4083 if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
4084 return -EINVAL;
4085 minor = simple_strtoul(e+1, &e, 10);
4086 if (*e && *e != '\n')
4087 return -EINVAL;
4088 dev = MKDEV(major, minor);
4089 if (major != MAJOR(dev) ||
4090 minor != MINOR(dev))
4091 return -EOVERFLOW;
4092
NeilBrown67918752014-12-15 12:57:01 +11004093 flush_workqueue(md_misc_wq);
4094
4095 err = mddev_lock(mddev);
4096 if (err)
4097 return err;
NeilBrown6d7ff732006-01-06 00:21:16 -08004098 if (mddev->persistent) {
4099 rdev = md_import_device(dev, mddev->major_version,
4100 mddev->minor_version);
4101 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
NeilBrown3cb03002011-10-11 16:45:26 +11004102 struct md_rdev *rdev0
4103 = list_entry(mddev->disks.next,
4104 struct md_rdev, same_set);
NeilBrown6d7ff732006-01-06 00:21:16 -08004105 err = super_types[mddev->major_version]
4106 .load_super(rdev, rdev0, mddev->minor_version);
4107 if (err < 0)
4108 goto out;
4109 }
NeilBrownc5d79ad2008-02-06 01:39:54 -08004110 } else if (mddev->external)
4111 rdev = md_import_device(dev, -2, -1);
4112 else
NeilBrown6d7ff732006-01-06 00:21:16 -08004113 rdev = md_import_device(dev, -1, -1);
4114
NeilBrown9a8c0fa2015-06-25 17:06:40 +10004115 if (IS_ERR(rdev)) {
4116 mddev_unlock(mddev);
NeilBrown6d7ff732006-01-06 00:21:16 -08004117 return PTR_ERR(rdev);
NeilBrown9a8c0fa2015-06-25 17:06:40 +10004118 }
NeilBrown6d7ff732006-01-06 00:21:16 -08004119 err = bind_rdev_to_array(rdev, mddev);
4120 out:
4121 if (err)
4122 export_rdev(rdev);
NeilBrown67918752014-12-15 12:57:01 +11004123 mddev_unlock(mddev);
NeilBrown6d7ff732006-01-06 00:21:16 -08004124 return err ? err : len;
4125}
4126
4127static struct md_sysfs_entry md_new_device =
NeilBrown80ca3a42006-07-10 04:44:18 -07004128__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
NeilBrown3b343802006-01-06 00:20:47 -08004129
4130static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004131bitmap_store(struct mddev *mddev, const char *buf, size_t len)
Paul Clements9b1d1da2006-10-03 01:15:49 -07004132{
4133 char *end;
4134 unsigned long chunk, end_chunk;
NeilBrown67918752014-12-15 12:57:01 +11004135 int err;
Paul Clements9b1d1da2006-10-03 01:15:49 -07004136
NeilBrown67918752014-12-15 12:57:01 +11004137 err = mddev_lock(mddev);
4138 if (err)
4139 return err;
Paul Clements9b1d1da2006-10-03 01:15:49 -07004140 if (!mddev->bitmap)
4141 goto out;
4142 /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
4143 while (*buf) {
4144 chunk = end_chunk = simple_strtoul(buf, &end, 0);
4145 if (buf == end) break;
4146 if (*end == '-') { /* range */
4147 buf = end + 1;
4148 end_chunk = simple_strtoul(buf, &end, 0);
4149 if (buf == end) break;
4150 }
4151 if (*end && !isspace(*end)) break;
4152 bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
André Goddard Rosae7d28602009-12-14 18:01:06 -08004153 buf = skip_spaces(end);
Paul Clements9b1d1da2006-10-03 01:15:49 -07004154 }
4155 bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
4156out:
NeilBrown67918752014-12-15 12:57:01 +11004157 mddev_unlock(mddev);
Paul Clements9b1d1da2006-10-03 01:15:49 -07004158 return len;
4159}
4160
4161static struct md_sysfs_entry md_bitmap =
4162__ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
4163
4164static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004165size_show(struct mddev *mddev, char *page)
NeilBrowna35b0d62006-01-06 00:20:49 -08004166{
Andre Noll58c0fed2009-03-31 14:33:13 +11004167 return sprintf(page, "%llu\n",
4168 (unsigned long long)mddev->dev_sectors / 2);
NeilBrowna35b0d62006-01-06 00:20:49 -08004169}
4170
NeilBrownfd01b882011-10-11 16:47:53 +11004171static int update_size(struct mddev *mddev, sector_t num_sectors);
NeilBrowna35b0d62006-01-06 00:20:49 -08004172
4173static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004174size_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowna35b0d62006-01-06 00:20:49 -08004175{
4176 /* If array is inactive, we can reduce the component size, but
4177 * not increase it (except from 0).
4178 * If array is active, we can try an on-line resize
4179 */
Dan Williamsb522adc2009-03-31 15:00:31 +11004180 sector_t sectors;
4181 int err = strict_blocks_to_sectors(buf, &sectors);
NeilBrowna35b0d62006-01-06 00:20:49 -08004182
Andre Noll58c0fed2009-03-31 14:33:13 +11004183 if (err < 0)
4184 return err;
NeilBrown67918752014-12-15 12:57:01 +11004185 err = mddev_lock(mddev);
4186 if (err)
4187 return err;
NeilBrowna35b0d62006-01-06 00:20:49 -08004188 if (mddev->pers) {
Andre Noll58c0fed2009-03-31 14:33:13 +11004189 err = update_size(mddev, sectors);
NeilBrown850b2b42006-10-03 01:15:46 -07004190 md_update_sb(mddev, 1);
NeilBrowna35b0d62006-01-06 00:20:49 -08004191 } else {
Andre Noll58c0fed2009-03-31 14:33:13 +11004192 if (mddev->dev_sectors == 0 ||
4193 mddev->dev_sectors > sectors)
4194 mddev->dev_sectors = sectors;
NeilBrowna35b0d62006-01-06 00:20:49 -08004195 else
4196 err = -ENOSPC;
4197 }
NeilBrown67918752014-12-15 12:57:01 +11004198 mddev_unlock(mddev);
NeilBrowna35b0d62006-01-06 00:20:49 -08004199 return err ? err : len;
4200}
4201
4202static struct md_sysfs_entry md_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07004203__ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
NeilBrowna35b0d62006-01-06 00:20:49 -08004204
Masanari Iida83f0d772012-10-30 00:18:08 +09004205/* Metadata version.
NeilBrowne6910632008-02-06 01:39:51 -08004206 * This is one of
4207 * 'none' for arrays with no metadata (good luck...)
4208 * 'external' for arrays with externally managed metadata,
NeilBrown8bb93aa2006-01-06 00:20:50 -08004209 * or N.M for internally known formats
4210 */
4211static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004212metadata_show(struct mddev *mddev, char *page)
NeilBrown8bb93aa2006-01-06 00:20:50 -08004213{
4214 if (mddev->persistent)
4215 return sprintf(page, "%d.%d\n",
4216 mddev->major_version, mddev->minor_version);
NeilBrowne6910632008-02-06 01:39:51 -08004217 else if (mddev->external)
4218 return sprintf(page, "external:%s\n", mddev->metadata_type);
NeilBrown8bb93aa2006-01-06 00:20:50 -08004219 else
4220 return sprintf(page, "none\n");
4221}
4222
4223static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004224metadata_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown8bb93aa2006-01-06 00:20:50 -08004225{
4226 int major, minor;
4227 char *e;
NeilBrown67918752014-12-15 12:57:01 +11004228 int err;
NeilBrownea43ddd2008-10-13 11:55:11 +11004229 /* Changing the details of 'external' metadata is
4230 * always permitted. Otherwise there must be
4231 * no devices attached to the array.
4232 */
NeilBrown67918752014-12-15 12:57:01 +11004233
4234 err = mddev_lock(mddev);
4235 if (err)
4236 return err;
4237 err = -EBUSY;
NeilBrownea43ddd2008-10-13 11:55:11 +11004238 if (mddev->external && strncmp(buf, "external:", 9) == 0)
4239 ;
4240 else if (!list_empty(&mddev->disks))
NeilBrown67918752014-12-15 12:57:01 +11004241 goto out_unlock;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004242
NeilBrown67918752014-12-15 12:57:01 +11004243 err = 0;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004244 if (cmd_match(buf, "none")) {
4245 mddev->persistent = 0;
NeilBrowne6910632008-02-06 01:39:51 -08004246 mddev->external = 0;
4247 mddev->major_version = 0;
4248 mddev->minor_version = 90;
NeilBrown67918752014-12-15 12:57:01 +11004249 goto out_unlock;
NeilBrowne6910632008-02-06 01:39:51 -08004250 }
4251 if (strncmp(buf, "external:", 9) == 0) {
NeilBrown20a49ff2008-02-06 01:39:57 -08004252 size_t namelen = len-9;
NeilBrowne6910632008-02-06 01:39:51 -08004253 if (namelen >= sizeof(mddev->metadata_type))
4254 namelen = sizeof(mddev->metadata_type)-1;
4255 strncpy(mddev->metadata_type, buf+9, namelen);
4256 mddev->metadata_type[namelen] = 0;
4257 if (namelen && mddev->metadata_type[namelen-1] == '\n')
4258 mddev->metadata_type[--namelen] = 0;
4259 mddev->persistent = 0;
4260 mddev->external = 1;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004261 mddev->major_version = 0;
4262 mddev->minor_version = 90;
NeilBrown67918752014-12-15 12:57:01 +11004263 goto out_unlock;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004264 }
4265 major = simple_strtoul(buf, &e, 10);
NeilBrown67918752014-12-15 12:57:01 +11004266 err = -EINVAL;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004267 if (e==buf || *e != '.')
NeilBrown67918752014-12-15 12:57:01 +11004268 goto out_unlock;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004269 buf = e+1;
4270 minor = simple_strtoul(buf, &e, 10);
NeilBrown3f9d7b02006-12-22 01:11:41 -08004271 if (e==buf || (*e && *e != '\n') )
NeilBrown67918752014-12-15 12:57:01 +11004272 goto out_unlock;
4273 err = -ENOENT;
Ahmed S. Darwish50511da2007-05-09 02:35:34 -07004274 if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
NeilBrown67918752014-12-15 12:57:01 +11004275 goto out_unlock;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004276 mddev->major_version = major;
4277 mddev->minor_version = minor;
4278 mddev->persistent = 1;
NeilBrowne6910632008-02-06 01:39:51 -08004279 mddev->external = 0;
NeilBrown67918752014-12-15 12:57:01 +11004280 err = 0;
4281out_unlock:
4282 mddev_unlock(mddev);
4283 return err ?: len;
NeilBrown8bb93aa2006-01-06 00:20:50 -08004284}
4285
4286static struct md_sysfs_entry md_metadata =
NeilBrown750f1992014-09-30 08:53:05 +10004287__ATTR_PREALLOC(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
NeilBrown8bb93aa2006-01-06 00:20:50 -08004288
NeilBrowna35b0d62006-01-06 00:20:49 -08004289static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004290action_show(struct mddev *mddev, char *page)
NeilBrown24dd4692005-11-08 21:39:26 -08004291{
NeilBrown7eec3142005-11-08 21:39:44 -08004292 char *type = "idle";
NeilBrownb7b17c92014-12-15 12:56:59 +11004293 unsigned long recovery = mddev->recovery;
4294 if (test_bit(MD_RECOVERY_FROZEN, &recovery))
NeilBrownb6a9ce62009-05-26 09:41:17 +10004295 type = "frozen";
NeilBrownb7b17c92014-12-15 12:56:59 +11004296 else if (test_bit(MD_RECOVERY_RUNNING, &recovery) ||
4297 (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &recovery))) {
4298 if (test_bit(MD_RECOVERY_RESHAPE, &recovery))
NeilBrownccfcc3c2006-03-27 01:18:09 -08004299 type = "reshape";
NeilBrownb7b17c92014-12-15 12:56:59 +11004300 else if (test_bit(MD_RECOVERY_SYNC, &recovery)) {
4301 if (!test_bit(MD_RECOVERY_REQUESTED, &recovery))
NeilBrown24dd4692005-11-08 21:39:26 -08004302 type = "resync";
NeilBrownb7b17c92014-12-15 12:56:59 +11004303 else if (test_bit(MD_RECOVERY_CHECK, &recovery))
NeilBrown24dd4692005-11-08 21:39:26 -08004304 type = "check";
4305 else
4306 type = "repair";
NeilBrownb7b17c92014-12-15 12:56:59 +11004307 } else if (test_bit(MD_RECOVERY_RECOVER, &recovery))
NeilBrown24dd4692005-11-08 21:39:26 -08004308 type = "recover";
NeilBrown985ca972015-07-06 12:26:57 +10004309 else if (mddev->reshape_position != MaxSector)
4310 type = "reshape";
NeilBrown24dd4692005-11-08 21:39:26 -08004311 }
4312 return sprintf(page, "%s\n", type);
4313}
4314
4315static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004316action_store(struct mddev *mddev, const char *page, size_t len)
NeilBrown24dd4692005-11-08 21:39:26 -08004317{
NeilBrown7eec3142005-11-08 21:39:44 -08004318 if (!mddev->pers || !mddev->pers->sync_request)
4319 return -EINVAL;
4320
NeilBrownb6a9ce62009-05-26 09:41:17 +10004321
4322 if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
NeilBrown56ccc112015-05-28 17:53:29 +10004323 if (cmd_match(page, "frozen"))
4324 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4325 else
4326 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown8e8e2512015-06-12 19:51:27 +10004327 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
4328 mddev_lock(mddev) == 0) {
4329 flush_workqueue(md_misc_wq);
4330 if (mddev->sync_thread) {
4331 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrown67918752014-12-15 12:57:01 +11004332 md_reap_sync_thread(mddev);
NeilBrown67918752014-12-15 12:57:01 +11004333 }
NeilBrown8e8e2512015-06-12 19:51:27 +10004334 mddev_unlock(mddev);
NeilBrown7eec3142005-11-08 21:39:44 -08004335 }
NeilBrown312045e2015-12-21 11:01:21 +11004336 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown24dd4692005-11-08 21:39:26 -08004337 return -EBUSY;
Neil Brown72a23c22008-06-28 08:31:41 +10004338 else if (cmd_match(page, "resync"))
NeilBrown56ccc112015-05-28 17:53:29 +10004339 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10004340 else if (cmd_match(page, "recover")) {
NeilBrown56ccc112015-05-28 17:53:29 +10004341 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10004342 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10004343 } else if (cmd_match(page, "reshape")) {
NeilBrown16484bf2006-03-27 01:18:13 -08004344 int err;
4345 if (mddev->pers->start_reshape == NULL)
4346 return -EINVAL;
NeilBrown67918752014-12-15 12:57:01 +11004347 err = mddev_lock(mddev);
4348 if (!err) {
NeilBrown312045e2015-12-21 11:01:21 +11004349 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4350 err = -EBUSY;
4351 else {
4352 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4353 err = mddev->pers->start_reshape(mddev);
4354 }
NeilBrown67918752014-12-15 12:57:01 +11004355 mddev_unlock(mddev);
4356 }
NeilBrown16484bf2006-03-27 01:18:13 -08004357 if (err)
4358 return err;
Neil Browna99ac972008-06-28 08:31:43 +10004359 sysfs_notify(&mddev->kobj, NULL, "degraded");
NeilBrown16484bf2006-03-27 01:18:13 -08004360 } else {
NeilBrownbce74da2006-01-06 00:20:41 -08004361 if (cmd_match(page, "check"))
NeilBrown7eec3142005-11-08 21:39:44 -08004362 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
NeilBrown2adc7d42006-05-20 14:59:57 -07004363 else if (!cmd_match(page, "repair"))
NeilBrown7eec3142005-11-08 21:39:44 -08004364 return -EINVAL;
NeilBrown56ccc112015-05-28 17:53:29 +10004365 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown7eec3142005-11-08 21:39:44 -08004366 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
4367 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
NeilBrown7eec3142005-11-08 21:39:44 -08004368 }
NeilBrown48c26dd2012-10-11 14:19:39 +11004369 if (mddev->ro == 2) {
4370 /* A write to sync_action is enough to justify
4371 * canceling read-auto mode
4372 */
4373 mddev->ro = 0;
4374 md_wakeup_thread(mddev->sync_thread);
4375 }
NeilBrown03c902e2006-01-06 00:20:46 -08004376 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown24dd4692005-11-08 21:39:26 -08004377 md_wakeup_thread(mddev->thread);
NeilBrown00bcb4a2010-06-01 19:37:23 +10004378 sysfs_notify_dirent_safe(mddev->sysfs_action);
NeilBrown24dd4692005-11-08 21:39:26 -08004379 return len;
4380}
4381
Jonathan Brassowc4a39552013-06-25 01:23:59 -05004382static struct md_sysfs_entry md_scan_mode =
NeilBrown750f1992014-09-30 08:53:05 +10004383__ATTR_PREALLOC(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
Jonathan Brassowc4a39552013-06-25 01:23:59 -05004384
4385static ssize_t
4386last_sync_action_show(struct mddev *mddev, char *page)
4387{
4388 return sprintf(page, "%s\n", mddev->last_sync_action);
4389}
4390
4391static struct md_sysfs_entry md_last_scan_mode = __ATTR_RO(last_sync_action);
4392
NeilBrown9d888832005-11-08 21:39:26 -08004393static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004394mismatch_cnt_show(struct mddev *mddev, char *page)
NeilBrown9d888832005-11-08 21:39:26 -08004395{
4396 return sprintf(page, "%llu\n",
Jianpeng Ma7f7583d2012-10-11 14:17:59 +11004397 (unsigned long long)
4398 atomic64_read(&mddev->resync_mismatches));
NeilBrown9d888832005-11-08 21:39:26 -08004399}
4400
NeilBrown80ca3a42006-07-10 04:44:18 -07004401static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
NeilBrown9d888832005-11-08 21:39:26 -08004402
NeilBrown88202a02006-01-06 00:21:36 -08004403static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004404sync_min_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004405{
4406 return sprintf(page, "%d (%s)\n", speed_min(mddev),
4407 mddev->sync_speed_min ? "local": "system");
4408}
4409
4410static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004411sync_min_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown88202a02006-01-06 00:21:36 -08004412{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004413 unsigned int min;
4414 int rv;
4415
NeilBrown88202a02006-01-06 00:21:36 -08004416 if (strncmp(buf, "system", 6)==0) {
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004417 min = 0;
4418 } else {
4419 rv = kstrtouint(buf, 10, &min);
4420 if (rv < 0)
4421 return rv;
4422 if (min == 0)
4423 return -EINVAL;
NeilBrown88202a02006-01-06 00:21:36 -08004424 }
NeilBrown88202a02006-01-06 00:21:36 -08004425 mddev->sync_speed_min = min;
4426 return len;
4427}
4428
4429static struct md_sysfs_entry md_sync_min =
4430__ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
4431
4432static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004433sync_max_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004434{
4435 return sprintf(page, "%d (%s)\n", speed_max(mddev),
4436 mddev->sync_speed_max ? "local": "system");
4437}
4438
4439static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004440sync_max_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown88202a02006-01-06 00:21:36 -08004441{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004442 unsigned int max;
4443 int rv;
4444
NeilBrown88202a02006-01-06 00:21:36 -08004445 if (strncmp(buf, "system", 6)==0) {
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004446 max = 0;
4447 } else {
4448 rv = kstrtouint(buf, 10, &max);
4449 if (rv < 0)
4450 return rv;
4451 if (max == 0)
4452 return -EINVAL;
NeilBrown88202a02006-01-06 00:21:36 -08004453 }
NeilBrown88202a02006-01-06 00:21:36 -08004454 mddev->sync_speed_max = max;
4455 return len;
4456}
4457
4458static struct md_sysfs_entry md_sync_max =
4459__ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
4460
Iustin Popd7f3d292007-10-16 23:30:54 -07004461static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004462degraded_show(struct mddev *mddev, char *page)
Iustin Popd7f3d292007-10-16 23:30:54 -07004463{
4464 return sprintf(page, "%d\n", mddev->degraded);
4465}
4466static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
NeilBrown88202a02006-01-06 00:21:36 -08004467
4468static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004469sync_force_parallel_show(struct mddev *mddev, char *page)
Bernd Schubert90b08712008-05-23 13:04:38 -07004470{
4471 return sprintf(page, "%d\n", mddev->parallel_resync);
4472}
4473
4474static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004475sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
Bernd Schubert90b08712008-05-23 13:04:38 -07004476{
4477 long n;
4478
Jingoo Hanb29bebd2013-06-01 16:15:16 +09004479 if (kstrtol(buf, 10, &n))
Bernd Schubert90b08712008-05-23 13:04:38 -07004480 return -EINVAL;
4481
4482 if (n != 0 && n != 1)
4483 return -EINVAL;
4484
4485 mddev->parallel_resync = n;
4486
4487 if (mddev->sync_thread)
4488 wake_up(&resync_wait);
4489
4490 return len;
4491}
4492
4493/* force parallel resync, even with shared block devices */
4494static struct md_sysfs_entry md_sync_force_parallel =
4495__ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
4496 sync_force_parallel_show, sync_force_parallel_store);
4497
4498static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004499sync_speed_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004500{
4501 unsigned long resync, dt, db;
NeilBrownd1a7c502009-03-31 15:24:32 +11004502 if (mddev->curr_resync == 0)
4503 return sprintf(page, "none\n");
Andre Noll9687a602008-03-25 22:24:09 +01004504 resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
4505 dt = (jiffies - mddev->resync_mark) / HZ;
NeilBrown88202a02006-01-06 00:21:36 -08004506 if (!dt) dt++;
Andre Noll9687a602008-03-25 22:24:09 +01004507 db = resync - mddev->resync_mark_cnt;
4508 return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
NeilBrown88202a02006-01-06 00:21:36 -08004509}
4510
NeilBrown80ca3a42006-07-10 04:44:18 -07004511static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
NeilBrown88202a02006-01-06 00:21:36 -08004512
4513static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004514sync_completed_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004515{
RĂ©mi RĂ©rolle13ae8642011-01-14 09:14:34 +11004516 unsigned long long max_sectors, resync;
NeilBrown88202a02006-01-06 00:21:36 -08004517
NeilBrownacb180b2009-04-14 16:28:34 +10004518 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4519 return sprintf(page, "none\n");
4520
NeilBrown72f36d52012-10-11 14:25:57 +11004521 if (mddev->curr_resync == 1 ||
4522 mddev->curr_resync == 2)
4523 return sprintf(page, "delayed\n");
4524
NeilBrownc804cde2012-05-21 09:28:33 +10004525 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
4526 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
Andre Noll58c0fed2009-03-31 14:33:13 +11004527 max_sectors = mddev->resync_max_sectors;
NeilBrown88202a02006-01-06 00:21:36 -08004528 else
Andre Noll58c0fed2009-03-31 14:33:13 +11004529 max_sectors = mddev->dev_sectors;
NeilBrown88202a02006-01-06 00:21:36 -08004530
NeilBrownacb180b2009-04-14 16:28:34 +10004531 resync = mddev->curr_resync_completed;
RĂ©mi RĂ©rolle13ae8642011-01-14 09:14:34 +11004532 return sprintf(page, "%llu / %llu\n", resync, max_sectors);
NeilBrown88202a02006-01-06 00:21:36 -08004533}
4534
NeilBrown750f1992014-09-30 08:53:05 +10004535static struct md_sysfs_entry md_sync_completed =
4536 __ATTR_PREALLOC(sync_completed, S_IRUGO, sync_completed_show, NULL);
NeilBrown88202a02006-01-06 00:21:36 -08004537
NeilBrowne464eaf2006-03-27 01:18:14 -08004538static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004539min_sync_show(struct mddev *mddev, char *page)
Neil Brown5e96ee62008-06-28 08:31:24 +10004540{
4541 return sprintf(page, "%llu\n",
4542 (unsigned long long)mddev->resync_min);
4543}
4544static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004545min_sync_store(struct mddev *mddev, const char *buf, size_t len)
Neil Brown5e96ee62008-06-28 08:31:24 +10004546{
4547 unsigned long long min;
NeilBrown23da4222014-12-15 12:57:01 +11004548 int err;
NeilBrown23da4222014-12-15 12:57:01 +11004549
Jingoo Hanb29bebd2013-06-01 16:15:16 +09004550 if (kstrtoull(buf, 10, &min))
Neil Brown5e96ee62008-06-28 08:31:24 +10004551 return -EINVAL;
NeilBrown23da4222014-12-15 12:57:01 +11004552
4553 spin_lock(&mddev->lock);
4554 err = -EINVAL;
Neil Brown5e96ee62008-06-28 08:31:24 +10004555 if (min > mddev->resync_max)
NeilBrown23da4222014-12-15 12:57:01 +11004556 goto out_unlock;
4557
4558 err = -EBUSY;
Neil Brown5e96ee62008-06-28 08:31:24 +10004559 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown23da4222014-12-15 12:57:01 +11004560 goto out_unlock;
Neil Brown5e96ee62008-06-28 08:31:24 +10004561
NeilBrown50c37b12015-03-23 17:36:38 +11004562 /* Round down to multiple of 4K for safety */
4563 mddev->resync_min = round_down(min, 8);
NeilBrown23da4222014-12-15 12:57:01 +11004564 err = 0;
Neil Brown5e96ee62008-06-28 08:31:24 +10004565
NeilBrown23da4222014-12-15 12:57:01 +11004566out_unlock:
4567 spin_unlock(&mddev->lock);
4568 return err ?: len;
Neil Brown5e96ee62008-06-28 08:31:24 +10004569}
4570
4571static struct md_sysfs_entry md_min_sync =
4572__ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
4573
4574static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004575max_sync_show(struct mddev *mddev, char *page)
NeilBrownc6207272008-02-06 01:39:52 -08004576{
4577 if (mddev->resync_max == MaxSector)
4578 return sprintf(page, "max\n");
4579 else
4580 return sprintf(page, "%llu\n",
4581 (unsigned long long)mddev->resync_max);
4582}
4583static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004584max_sync_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownc6207272008-02-06 01:39:52 -08004585{
NeilBrown23da4222014-12-15 12:57:01 +11004586 int err;
4587 spin_lock(&mddev->lock);
NeilBrownc6207272008-02-06 01:39:52 -08004588 if (strncmp(buf, "max", 3) == 0)
4589 mddev->resync_max = MaxSector;
4590 else {
Neil Brown5e96ee62008-06-28 08:31:24 +10004591 unsigned long long max;
NeilBrown23da4222014-12-15 12:57:01 +11004592 int chunk;
4593
4594 err = -EINVAL;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09004595 if (kstrtoull(buf, 10, &max))
NeilBrown23da4222014-12-15 12:57:01 +11004596 goto out_unlock;
Neil Brown5e96ee62008-06-28 08:31:24 +10004597 if (max < mddev->resync_min)
NeilBrown23da4222014-12-15 12:57:01 +11004598 goto out_unlock;
4599
4600 err = -EBUSY;
NeilBrownc6207272008-02-06 01:39:52 -08004601 if (max < mddev->resync_max &&
NeilBrown4d484a42009-08-13 10:41:50 +10004602 mddev->ro == 0 &&
NeilBrownc6207272008-02-06 01:39:52 -08004603 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown23da4222014-12-15 12:57:01 +11004604 goto out_unlock;
NeilBrownc6207272008-02-06 01:39:52 -08004605
4606 /* Must be a multiple of chunk_size */
NeilBrown23da4222014-12-15 12:57:01 +11004607 chunk = mddev->chunk_sectors;
4608 if (chunk) {
raz ben yehuda2ac06c32009-06-16 17:01:42 +10004609 sector_t temp = max;
NeilBrown23da4222014-12-15 12:57:01 +11004610
4611 err = -EINVAL;
4612 if (sector_div(temp, chunk))
4613 goto out_unlock;
NeilBrownc6207272008-02-06 01:39:52 -08004614 }
4615 mddev->resync_max = max;
4616 }
4617 wake_up(&mddev->recovery_wait);
NeilBrown23da4222014-12-15 12:57:01 +11004618 err = 0;
4619out_unlock:
4620 spin_unlock(&mddev->lock);
4621 return err ?: len;
NeilBrownc6207272008-02-06 01:39:52 -08004622}
4623
4624static struct md_sysfs_entry md_max_sync =
4625__ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
4626
4627static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004628suspend_lo_show(struct mddev *mddev, char *page)
NeilBrowne464eaf2006-03-27 01:18:14 -08004629{
4630 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
4631}
4632
4633static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004634suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowne464eaf2006-03-27 01:18:14 -08004635{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004636 unsigned long long old, new;
NeilBrown67918752014-12-15 12:57:01 +11004637 int err;
NeilBrowne464eaf2006-03-27 01:18:14 -08004638
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004639 err = kstrtoull(buf, 10, &new);
4640 if (err < 0)
4641 return err;
4642 if (new != (sector_t)new)
NeilBrowne464eaf2006-03-27 01:18:14 -08004643 return -EINVAL;
NeilBrown23ddff32011-01-14 09:14:34 +11004644
NeilBrown67918752014-12-15 12:57:01 +11004645 err = mddev_lock(mddev);
4646 if (err)
4647 return err;
4648 err = -EINVAL;
4649 if (mddev->pers == NULL ||
4650 mddev->pers->quiesce == NULL)
4651 goto unlock;
4652 old = mddev->suspend_lo;
NeilBrown23ddff32011-01-14 09:14:34 +11004653 mddev->suspend_lo = new;
4654 if (new >= old)
4655 /* Shrinking suspended region */
NeilBrowne464eaf2006-03-27 01:18:14 -08004656 mddev->pers->quiesce(mddev, 2);
NeilBrown23ddff32011-01-14 09:14:34 +11004657 else {
4658 /* Expanding suspended region - need to wait */
4659 mddev->pers->quiesce(mddev, 1);
4660 mddev->pers->quiesce(mddev, 0);
4661 }
NeilBrown67918752014-12-15 12:57:01 +11004662 err = 0;
4663unlock:
4664 mddev_unlock(mddev);
4665 return err ?: len;
NeilBrowne464eaf2006-03-27 01:18:14 -08004666}
4667static struct md_sysfs_entry md_suspend_lo =
4668__ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
4669
NeilBrowne464eaf2006-03-27 01:18:14 -08004670static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004671suspend_hi_show(struct mddev *mddev, char *page)
NeilBrowne464eaf2006-03-27 01:18:14 -08004672{
4673 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
4674}
4675
4676static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004677suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowne464eaf2006-03-27 01:18:14 -08004678{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004679 unsigned long long old, new;
NeilBrown67918752014-12-15 12:57:01 +11004680 int err;
NeilBrowne464eaf2006-03-27 01:18:14 -08004681
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004682 err = kstrtoull(buf, 10, &new);
4683 if (err < 0)
4684 return err;
4685 if (new != (sector_t)new)
NeilBrowne464eaf2006-03-27 01:18:14 -08004686 return -EINVAL;
NeilBrown23ddff32011-01-14 09:14:34 +11004687
NeilBrown67918752014-12-15 12:57:01 +11004688 err = mddev_lock(mddev);
4689 if (err)
4690 return err;
4691 err = -EINVAL;
4692 if (mddev->pers == NULL ||
4693 mddev->pers->quiesce == NULL)
4694 goto unlock;
4695 old = mddev->suspend_hi;
NeilBrown23ddff32011-01-14 09:14:34 +11004696 mddev->suspend_hi = new;
4697 if (new <= old)
4698 /* Shrinking suspended region */
4699 mddev->pers->quiesce(mddev, 2);
4700 else {
4701 /* Expanding suspended region - need to wait */
NeilBrowne464eaf2006-03-27 01:18:14 -08004702 mddev->pers->quiesce(mddev, 1);
4703 mddev->pers->quiesce(mddev, 0);
NeilBrown23ddff32011-01-14 09:14:34 +11004704 }
NeilBrown67918752014-12-15 12:57:01 +11004705 err = 0;
4706unlock:
4707 mddev_unlock(mddev);
4708 return err ?: len;
NeilBrowne464eaf2006-03-27 01:18:14 -08004709}
4710static struct md_sysfs_entry md_suspend_hi =
4711__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
4712
NeilBrown08a02ec2007-05-09 02:35:38 -07004713static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004714reshape_position_show(struct mddev *mddev, char *page)
NeilBrown08a02ec2007-05-09 02:35:38 -07004715{
4716 if (mddev->reshape_position != MaxSector)
4717 return sprintf(page, "%llu\n",
4718 (unsigned long long)mddev->reshape_position);
4719 strcpy(page, "none\n");
4720 return 5;
4721}
4722
4723static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004724reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown08a02ec2007-05-09 02:35:38 -07004725{
NeilBrownc6563a82012-05-21 09:27:00 +10004726 struct md_rdev *rdev;
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004727 unsigned long long new;
NeilBrown67918752014-12-15 12:57:01 +11004728 int err;
NeilBrown67918752014-12-15 12:57:01 +11004729
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03004730 err = kstrtoull(buf, 10, &new);
4731 if (err < 0)
4732 return err;
4733 if (new != (sector_t)new)
NeilBrown08a02ec2007-05-09 02:35:38 -07004734 return -EINVAL;
NeilBrown67918752014-12-15 12:57:01 +11004735 err = mddev_lock(mddev);
4736 if (err)
4737 return err;
4738 err = -EBUSY;
4739 if (mddev->pers)
4740 goto unlock;
NeilBrown08a02ec2007-05-09 02:35:38 -07004741 mddev->reshape_position = new;
4742 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10004743 mddev->reshape_backwards = 0;
NeilBrown08a02ec2007-05-09 02:35:38 -07004744 mddev->new_level = mddev->level;
4745 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10004746 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownc6563a82012-05-21 09:27:00 +10004747 rdev_for_each(rdev, mddev)
4748 rdev->new_data_offset = rdev->data_offset;
NeilBrown67918752014-12-15 12:57:01 +11004749 err = 0;
4750unlock:
4751 mddev_unlock(mddev);
4752 return err ?: len;
NeilBrown08a02ec2007-05-09 02:35:38 -07004753}
4754
4755static struct md_sysfs_entry md_reshape_position =
4756__ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
4757 reshape_position_store);
4758
Dan Williamsb522adc2009-03-31 15:00:31 +11004759static ssize_t
NeilBrown2c810cd2012-05-21 09:27:00 +10004760reshape_direction_show(struct mddev *mddev, char *page)
4761{
4762 return sprintf(page, "%s\n",
4763 mddev->reshape_backwards ? "backwards" : "forwards");
4764}
4765
4766static ssize_t
4767reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
4768{
4769 int backwards = 0;
NeilBrown67918752014-12-15 12:57:01 +11004770 int err;
4771
NeilBrown2c810cd2012-05-21 09:27:00 +10004772 if (cmd_match(buf, "forwards"))
4773 backwards = 0;
4774 else if (cmd_match(buf, "backwards"))
4775 backwards = 1;
4776 else
4777 return -EINVAL;
4778 if (mddev->reshape_backwards == backwards)
4779 return len;
4780
NeilBrown67918752014-12-15 12:57:01 +11004781 err = mddev_lock(mddev);
4782 if (err)
4783 return err;
NeilBrown2c810cd2012-05-21 09:27:00 +10004784 /* check if we are allowed to change */
4785 if (mddev->delta_disks)
NeilBrown67918752014-12-15 12:57:01 +11004786 err = -EBUSY;
4787 else if (mddev->persistent &&
NeilBrown2c810cd2012-05-21 09:27:00 +10004788 mddev->major_version == 0)
NeilBrown67918752014-12-15 12:57:01 +11004789 err = -EINVAL;
4790 else
4791 mddev->reshape_backwards = backwards;
4792 mddev_unlock(mddev);
4793 return err ?: len;
NeilBrown2c810cd2012-05-21 09:27:00 +10004794}
4795
4796static struct md_sysfs_entry md_reshape_direction =
4797__ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
4798 reshape_direction_store);
4799
4800static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004801array_size_show(struct mddev *mddev, char *page)
Dan Williamsb522adc2009-03-31 15:00:31 +11004802{
4803 if (mddev->external_size)
4804 return sprintf(page, "%llu\n",
4805 (unsigned long long)mddev->array_sectors/2);
4806 else
4807 return sprintf(page, "default\n");
4808}
4809
4810static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004811array_size_store(struct mddev *mddev, const char *buf, size_t len)
Dan Williamsb522adc2009-03-31 15:00:31 +11004812{
4813 sector_t sectors;
NeilBrown67918752014-12-15 12:57:01 +11004814 int err;
4815
4816 err = mddev_lock(mddev);
4817 if (err)
4818 return err;
Dan Williamsb522adc2009-03-31 15:00:31 +11004819
Guoqing Jiangab5a98b2016-05-02 11:33:13 -04004820 /* cluster raid doesn't support change array_sectors */
4821 if (mddev_is_clustered(mddev))
4822 return -EINVAL;
4823
Dan Williamsb522adc2009-03-31 15:00:31 +11004824 if (strncmp(buf, "default", 7) == 0) {
4825 if (mddev->pers)
4826 sectors = mddev->pers->size(mddev, 0, 0);
4827 else
4828 sectors = mddev->array_sectors;
4829
4830 mddev->external_size = 0;
4831 } else {
4832 if (strict_blocks_to_sectors(buf, &sectors) < 0)
NeilBrown67918752014-12-15 12:57:01 +11004833 err = -EINVAL;
4834 else if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
4835 err = -E2BIG;
4836 else
4837 mddev->external_size = 1;
Dan Williamsb522adc2009-03-31 15:00:31 +11004838 }
4839
NeilBrown67918752014-12-15 12:57:01 +11004840 if (!err) {
4841 mddev->array_sectors = sectors;
4842 if (mddev->pers) {
4843 set_capacity(mddev->gendisk, mddev->array_sectors);
4844 revalidate_disk(mddev->gendisk);
4845 }
NeilBrowncbe6ef12011-02-16 13:58:38 +11004846 }
NeilBrown67918752014-12-15 12:57:01 +11004847 mddev_unlock(mddev);
4848 return err ?: len;
Dan Williamsb522adc2009-03-31 15:00:31 +11004849}
4850
4851static struct md_sysfs_entry md_array_size =
4852__ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
4853 array_size_store);
NeilBrowne464eaf2006-03-27 01:18:14 -08004854
NeilBrowneae17012005-11-08 21:39:23 -08004855static struct attribute *md_default_attrs[] = {
4856 &md_level.attr,
NeilBrownd4dbd022006-06-26 00:27:59 -07004857 &md_layout.attr,
NeilBrowneae17012005-11-08 21:39:23 -08004858 &md_raid_disks.attr,
NeilBrown3b343802006-01-06 00:20:47 -08004859 &md_chunk_size.attr,
NeilBrowna35b0d62006-01-06 00:20:49 -08004860 &md_size.attr,
NeilBrowna94213b2006-06-26 00:28:00 -07004861 &md_resync_start.attr,
NeilBrown8bb93aa2006-01-06 00:20:50 -08004862 &md_metadata.attr,
NeilBrown6d7ff732006-01-06 00:21:16 -08004863 &md_new_device.attr,
NeilBrown16f17b32006-06-26 00:27:37 -07004864 &md_safe_delay.attr,
NeilBrown9e653b62006-06-26 00:27:58 -07004865 &md_array_state.attr,
NeilBrown08a02ec2007-05-09 02:35:38 -07004866 &md_reshape_position.attr,
NeilBrown2c810cd2012-05-21 09:27:00 +10004867 &md_reshape_direction.attr,
Dan Williamsb522adc2009-03-31 15:00:31 +11004868 &md_array_size.attr,
Robert Becker1e509152009-12-14 12:49:58 +11004869 &max_corr_read_errors.attr,
NeilBrown411036f2005-11-08 21:39:40 -08004870 NULL,
4871};
4872
4873static struct attribute *md_redundancy_attrs[] = {
NeilBrown24dd4692005-11-08 21:39:26 -08004874 &md_scan_mode.attr,
Jonathan Brassowc4a39552013-06-25 01:23:59 -05004875 &md_last_scan_mode.attr,
NeilBrown9d888832005-11-08 21:39:26 -08004876 &md_mismatches.attr,
NeilBrown88202a02006-01-06 00:21:36 -08004877 &md_sync_min.attr,
4878 &md_sync_max.attr,
4879 &md_sync_speed.attr,
Bernd Schubert90b08712008-05-23 13:04:38 -07004880 &md_sync_force_parallel.attr,
NeilBrown88202a02006-01-06 00:21:36 -08004881 &md_sync_completed.attr,
Neil Brown5e96ee62008-06-28 08:31:24 +10004882 &md_min_sync.attr,
NeilBrownc6207272008-02-06 01:39:52 -08004883 &md_max_sync.attr,
NeilBrowne464eaf2006-03-27 01:18:14 -08004884 &md_suspend_lo.attr,
4885 &md_suspend_hi.attr,
Paul Clements9b1d1da2006-10-03 01:15:49 -07004886 &md_bitmap.attr,
Iustin Popd7f3d292007-10-16 23:30:54 -07004887 &md_degraded.attr,
NeilBrowneae17012005-11-08 21:39:23 -08004888 NULL,
4889};
NeilBrown411036f2005-11-08 21:39:40 -08004890static struct attribute_group md_redundancy_group = {
4891 .name = NULL,
4892 .attrs = md_redundancy_attrs,
4893};
4894
NeilBrowneae17012005-11-08 21:39:23 -08004895static ssize_t
4896md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
4897{
4898 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
NeilBrownfd01b882011-10-11 16:47:53 +11004899 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
NeilBrown96de1e62005-11-08 21:39:39 -08004900 ssize_t rv;
NeilBrowneae17012005-11-08 21:39:23 -08004901
4902 if (!entry->show)
4903 return -EIO;
NeilBrownaf8a2432011-12-08 15:49:46 +11004904 spin_lock(&all_mddevs_lock);
4905 if (list_empty(&mddev->all_mddevs)) {
4906 spin_unlock(&all_mddevs_lock);
4907 return -EBUSY;
4908 }
4909 mddev_get(mddev);
4910 spin_unlock(&all_mddevs_lock);
4911
NeilBrownb7b17c92014-12-15 12:56:59 +11004912 rv = entry->show(mddev, page);
NeilBrownaf8a2432011-12-08 15:49:46 +11004913 mddev_put(mddev);
NeilBrown96de1e62005-11-08 21:39:39 -08004914 return rv;
NeilBrowneae17012005-11-08 21:39:23 -08004915}
4916
4917static ssize_t
4918md_attr_store(struct kobject *kobj, struct attribute *attr,
4919 const char *page, size_t length)
4920{
4921 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
NeilBrownfd01b882011-10-11 16:47:53 +11004922 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
NeilBrown96de1e62005-11-08 21:39:39 -08004923 ssize_t rv;
NeilBrowneae17012005-11-08 21:39:23 -08004924
4925 if (!entry->store)
4926 return -EIO;
NeilBrown67463ac2006-07-10 04:44:19 -07004927 if (!capable(CAP_SYS_ADMIN))
4928 return -EACCES;
NeilBrownaf8a2432011-12-08 15:49:46 +11004929 spin_lock(&all_mddevs_lock);
4930 if (list_empty(&mddev->all_mddevs)) {
4931 spin_unlock(&all_mddevs_lock);
4932 return -EBUSY;
4933 }
4934 mddev_get(mddev);
4935 spin_unlock(&all_mddevs_lock);
NeilBrown67918752014-12-15 12:57:01 +11004936 rv = entry->store(mddev, page, length);
NeilBrownaf8a2432011-12-08 15:49:46 +11004937 mddev_put(mddev);
NeilBrown96de1e62005-11-08 21:39:39 -08004938 return rv;
NeilBrowneae17012005-11-08 21:39:23 -08004939}
4940
4941static void md_free(struct kobject *ko)
4942{
NeilBrownfd01b882011-10-11 16:47:53 +11004943 struct mddev *mddev = container_of(ko, struct mddev, kobj);
NeilBrowna21d1502009-01-09 08:31:09 +11004944
4945 if (mddev->sysfs_state)
4946 sysfs_put(mddev->sysfs_state);
4947
NeilBrown6cd18e72015-04-27 14:12:22 +10004948 if (mddev->queue)
4949 blk_cleanup_queue(mddev->queue);
NeilBrowna21d1502009-01-09 08:31:09 +11004950 if (mddev->gendisk) {
4951 del_gendisk(mddev->gendisk);
4952 put_disk(mddev->gendisk);
4953 }
NeilBrowna21d1502009-01-09 08:31:09 +11004954
NeilBrowneae17012005-11-08 21:39:23 -08004955 kfree(mddev);
4956}
4957
Emese Revfy52cf25d2010-01-19 02:58:23 +01004958static const struct sysfs_ops md_sysfs_ops = {
NeilBrowneae17012005-11-08 21:39:23 -08004959 .show = md_attr_show,
4960 .store = md_attr_store,
4961};
4962static struct kobj_type md_ktype = {
4963 .release = md_free,
4964 .sysfs_ops = &md_sysfs_ops,
4965 .default_attrs = md_default_attrs,
4966};
4967
Linus Torvalds1da177e2005-04-16 15:20:36 -07004968int mdp_major = 0;
4969
Dan Williams5fd3a172009-03-04 00:57:25 -07004970static void mddev_delayed_delete(struct work_struct *ws)
4971{
NeilBrownfd01b882011-10-11 16:47:53 +11004972 struct mddev *mddev = container_of(ws, struct mddev, del_work);
Dan Williams5fd3a172009-03-04 00:57:25 -07004973
NeilBrown43a70502009-12-14 12:49:55 +11004974 sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
Dan Williams5fd3a172009-03-04 00:57:25 -07004975 kobject_del(&mddev->kobj);
4976 kobject_put(&mddev->kobj);
4977}
4978
NeilBrownefeb53c2009-01-09 08:31:10 +11004979static int md_alloc(dev_t dev, char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004980{
Arjan van de Ven48c9c272006-03-27 01:18:20 -08004981 static DEFINE_MUTEX(disks_mutex);
NeilBrownfd01b882011-10-11 16:47:53 +11004982 struct mddev *mddev = mddev_find(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004983 struct gendisk *disk;
NeilBrownefeb53c2009-01-09 08:31:10 +11004984 int partitioned;
4985 int shift;
4986 int unit;
Greg Kroah-Hartman3830c622007-12-17 15:54:39 -04004987 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004988
4989 if (!mddev)
NeilBrownefeb53c2009-01-09 08:31:10 +11004990 return -ENODEV;
4991
4992 partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
4993 shift = partitioned ? MdpMinorShift : 0;
4994 unit = MINOR(mddev->unit) >> shift;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004995
Tejun Heoe804ac72010-10-15 15:36:08 +02004996 /* wait for any previous instance of this device to be
4997 * completely removed (mddev_delayed_delete).
NeilBrownd3374822009-01-09 08:31:10 +11004998 */
Tejun Heoe804ac72010-10-15 15:36:08 +02004999 flush_workqueue(md_misc_wq);
NeilBrownd3374822009-01-09 08:31:10 +11005000
Arjan van de Ven48c9c272006-03-27 01:18:20 -08005001 mutex_lock(&disks_mutex);
NeilBrown0909dc42009-07-01 12:27:21 +10005002 error = -EEXIST;
5003 if (mddev->gendisk)
5004 goto abort;
NeilBrownefeb53c2009-01-09 08:31:10 +11005005
5006 if (name) {
5007 /* Need to ensure that 'name' is not a duplicate.
5008 */
NeilBrownfd01b882011-10-11 16:47:53 +11005009 struct mddev *mddev2;
NeilBrownefeb53c2009-01-09 08:31:10 +11005010 spin_lock(&all_mddevs_lock);
5011
5012 list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
5013 if (mddev2->gendisk &&
5014 strcmp(mddev2->gendisk->disk_name, name) == 0) {
5015 spin_unlock(&all_mddevs_lock);
NeilBrown0909dc42009-07-01 12:27:21 +10005016 goto abort;
NeilBrownefeb53c2009-01-09 08:31:10 +11005017 }
5018 spin_unlock(&all_mddevs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005019 }
NeilBrown8b765392009-01-09 08:31:08 +11005020
NeilBrown0909dc42009-07-01 12:27:21 +10005021 error = -ENOMEM;
NeilBrown8b765392009-01-09 08:31:08 +11005022 mddev->queue = blk_alloc_queue(GFP_KERNEL);
NeilBrown0909dc42009-07-01 12:27:21 +10005023 if (!mddev->queue)
5024 goto abort;
NeilBrown409c57f2009-03-31 14:39:39 +11005025 mddev->queue->queuedata = mddev;
5026
NeilBrown409c57f2009-03-31 14:39:39 +11005027 blk_queue_make_request(mddev->queue, md_make_request);
Martin K. Petersenb1bd0552012-01-11 16:27:11 +01005028 blk_set_stacking_limits(&mddev->queue->limits);
NeilBrown8b765392009-01-09 08:31:08 +11005029
Linus Torvalds1da177e2005-04-16 15:20:36 -07005030 disk = alloc_disk(1 << shift);
5031 if (!disk) {
NeilBrown8b765392009-01-09 08:31:08 +11005032 blk_cleanup_queue(mddev->queue);
5033 mddev->queue = NULL;
NeilBrown0909dc42009-07-01 12:27:21 +10005034 goto abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005035 }
NeilBrownefeb53c2009-01-09 08:31:10 +11005036 disk->major = MAJOR(mddev->unit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005037 disk->first_minor = unit << shift;
NeilBrownefeb53c2009-01-09 08:31:10 +11005038 if (name)
5039 strcpy(disk->disk_name, name);
5040 else if (partitioned)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005041 sprintf(disk->disk_name, "md_d%d", unit);
Greg Kroah-Hartmance7b0f42005-06-20 21:15:16 -07005042 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07005043 sprintf(disk->disk_name, "md%d", unit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005044 disk->fops = &md_fops;
5045 disk->private_data = mddev;
5046 disk->queue = mddev->queue;
Jens Axboe56883a72016-03-30 10:16:53 -06005047 blk_queue_write_cache(mddev->queue, true, true);
NeilBrown92850bb2008-10-21 13:25:32 +11005048 /* Allow extended partitions. This makes the
NeilBrownd3374822009-01-09 08:31:10 +11005049 * 'mdp' device redundant, but we can't really
NeilBrown92850bb2008-10-21 13:25:32 +11005050 * remove it now.
5051 */
5052 disk->flags |= GENHD_FL_EXT_DEVT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005053 mddev->gendisk = disk;
NeilBrownb0140892011-05-10 17:49:01 +10005054 /* As soon as we call add_disk(), another thread could get
5055 * through to md_open, so make sure it doesn't get too far
5056 */
5057 mutex_lock(&mddev->open_mutex);
5058 add_disk(disk);
5059
Tejun Heoed9e1982008-08-25 19:56:05 +09005060 error = kobject_init_and_add(&mddev->kobj, &md_ktype,
5061 &disk_to_dev(disk)->kobj, "%s", "md");
NeilBrown0909dc42009-07-01 12:27:21 +10005062 if (error) {
5063 /* This isn't possible, but as kobject_init_and_add is marked
5064 * __must_check, we must do something with the result
5065 */
NeilBrown5e55e2f2007-03-26 21:32:14 -08005066 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
5067 disk->disk_name);
NeilBrown0909dc42009-07-01 12:27:21 +10005068 error = 0;
5069 }
NeilBrown00bcb4a2010-06-01 19:37:23 +10005070 if (mddev->kobj.sd &&
5071 sysfs_create_group(&mddev->kobj, &md_bitmap_group))
NeilBrown43a70502009-12-14 12:49:55 +11005072 printk(KERN_DEBUG "pointless warning\n");
NeilBrownb0140892011-05-10 17:49:01 +10005073 mutex_unlock(&mddev->open_mutex);
NeilBrown0909dc42009-07-01 12:27:21 +10005074 abort:
5075 mutex_unlock(&disks_mutex);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005076 if (!error && mddev->kobj.sd) {
Greg Kroah-Hartman3830c622007-12-17 15:54:39 -04005077 kobject_uevent(&mddev->kobj, KOBJ_ADD);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005078 mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
NeilBrownb62b7592008-10-21 13:25:21 +11005079 }
NeilBrownd3374822009-01-09 08:31:10 +11005080 mddev_put(mddev);
NeilBrown0909dc42009-07-01 12:27:21 +10005081 return error;
NeilBrownefeb53c2009-01-09 08:31:10 +11005082}
5083
5084static struct kobject *md_probe(dev_t dev, int *part, void *data)
5085{
5086 md_alloc(dev, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005087 return NULL;
5088}
5089
NeilBrownefeb53c2009-01-09 08:31:10 +11005090static int add_named_array(const char *val, struct kernel_param *kp)
5091{
5092 /* val must be "md_*" where * is not all digits.
5093 * We allocate an array with a large free minor number, and
5094 * set the name to val. val must not already be an active name.
5095 */
5096 int len = strlen(val);
5097 char buf[DISK_NAME_LEN];
5098
5099 while (len && val[len-1] == '\n')
5100 len--;
5101 if (len >= DISK_NAME_LEN)
5102 return -E2BIG;
5103 strlcpy(buf, val, len+1);
5104 if (strncmp(buf, "md_", 3) != 0)
5105 return -EINVAL;
5106 return md_alloc(0, buf);
5107}
5108
Linus Torvalds1da177e2005-04-16 15:20:36 -07005109static void md_safemode_timeout(unsigned long data)
5110{
NeilBrownfd01b882011-10-11 16:47:53 +11005111 struct mddev *mddev = (struct mddev *) data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005112
Neil Brown0fd62b82008-06-28 08:31:36 +10005113 if (!atomic_read(&mddev->writes_pending)) {
5114 mddev->safemode = 1;
5115 if (mddev->external)
NeilBrown00bcb4a2010-06-01 19:37:23 +10005116 sysfs_notify_dirent_safe(mddev->sysfs_state);
Neil Brown0fd62b82008-06-28 08:31:36 +10005117 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005118 md_wakeup_thread(mddev->thread);
5119}
5120
NeilBrown6ff8d8ec2006-01-06 00:20:15 -08005121static int start_dirty_degraded;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005122
NeilBrownfd01b882011-10-11 16:47:53 +11005123int md_run(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005124{
NeilBrown2604b702006-01-06 00:20:36 -08005125 int err;
NeilBrown3cb03002011-10-11 16:45:26 +11005126 struct md_rdev *rdev;
NeilBrown84fc4b52011-10-11 16:49:58 +11005127 struct md_personality *pers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005128
NeilBrowna757e642005-04-16 15:26:42 -07005129 if (list_empty(&mddev->disks))
5130 /* cannot run an array with no devices.. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005131 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005132
5133 if (mddev->pers)
5134 return -EBUSY;
NeilBrownbb4f1e92010-08-08 21:18:03 +10005135 /* Cannot run until previous stop completes properly */
5136 if (mddev->sysfs_active)
5137 return -EBUSY;
NeilBrownb6eb1272010-04-15 10:13:47 +10005138
Linus Torvalds1da177e2005-04-16 15:20:36 -07005139 /*
5140 * Analyze all RAID superblock(s)
5141 */
NeilBrown1ec4a932008-02-06 01:39:53 -08005142 if (!mddev->raid_disks) {
5143 if (!mddev->persistent)
5144 return -EINVAL;
NeilBrowna757e642005-04-16 15:26:42 -07005145 analyze_sbs(mddev);
NeilBrown1ec4a932008-02-06 01:39:53 -08005146 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005147
NeilBrownd9d166c2006-01-06 00:20:51 -08005148 if (mddev->level != LEVEL_NONE)
5149 request_module("md-level-%d", mddev->level);
5150 else if (mddev->clevel[0])
5151 request_module("md-%s", mddev->clevel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005152
5153 /*
5154 * Drop all container device buffers, from now on
5155 * the only valid external interface is through the md
5156 * device.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005157 */
NeilBrowndafb20f2012-03-19 12:46:39 +11005158 rdev_for_each(rdev, mddev) {
NeilBrownb2d444d2005-11-08 21:39:31 -08005159 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005160 continue;
5161 sync_blockdev(rdev->bdev);
Peter Zijlstraf98393a2007-05-06 14:49:54 -07005162 invalidate_bdev(rdev->bdev);
NeilBrownf0d76d72007-07-17 04:06:12 -07005163
5164 /* perform some consistency tests on the device.
5165 * We don't want the data to overlap the metadata,
Andre Noll58c0fed2009-03-31 14:33:13 +11005166 * Internal Bitmap issues have been handled elsewhere.
NeilBrownf0d76d72007-07-17 04:06:12 -07005167 */
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +11005168 if (rdev->meta_bdev) {
5169 /* Nothing to check */;
5170 } else if (rdev->data_offset < rdev->sb_start) {
Andre Noll58c0fed2009-03-31 14:33:13 +11005171 if (mddev->dev_sectors &&
5172 rdev->data_offset + mddev->dev_sectors
Andre Noll0f420352008-07-11 22:02:23 +10005173 > rdev->sb_start) {
NeilBrownf0d76d72007-07-17 04:06:12 -07005174 printk("md: %s: data overlaps metadata\n",
5175 mdname(mddev));
5176 return -EINVAL;
5177 }
5178 } else {
Andre Noll0f420352008-07-11 22:02:23 +10005179 if (rdev->sb_start + rdev->sb_size/512
NeilBrownf0d76d72007-07-17 04:06:12 -07005180 > rdev->data_offset) {
5181 printk("md: %s: metadata overlaps data\n",
5182 mdname(mddev));
5183 return -EINVAL;
5184 }
5185 }
NeilBrown00bcb4a2010-06-01 19:37:23 +10005186 sysfs_notify_dirent_safe(rdev->sysfs_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005187 }
5188
NeilBrowna167f662010-10-26 18:31:13 +11005189 if (mddev->bio_set == NULL)
Kent Overstreet395c72a2012-09-06 15:34:55 -07005190 mddev->bio_set = bioset_create(BIO_POOL_SIZE, 0);
NeilBrowna167f662010-10-26 18:31:13 +11005191
Linus Torvalds1da177e2005-04-16 15:20:36 -07005192 spin_lock(&pers_lock);
NeilBrownd9d166c2006-01-06 00:20:51 -08005193 pers = find_pers(mddev->level, mddev->clevel);
NeilBrown2604b702006-01-06 00:20:36 -08005194 if (!pers || !try_module_get(pers->owner)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005195 spin_unlock(&pers_lock);
NeilBrownd9d166c2006-01-06 00:20:51 -08005196 if (mddev->level != LEVEL_NONE)
5197 printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
5198 mddev->level);
5199 else
5200 printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
5201 mddev->clevel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005202 return -EINVAL;
5203 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005204 spin_unlock(&pers_lock);
NeilBrown34817e82009-03-31 14:39:38 +11005205 if (mddev->level != pers->level) {
5206 mddev->level = pers->level;
5207 mddev->new_level = pers->level;
5208 }
NeilBrownd9d166c2006-01-06 00:20:51 -08005209 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005210
NeilBrownf6705572006-03-27 01:18:11 -08005211 if (mddev->reshape_position != MaxSector &&
NeilBrown63c70c42006-03-27 01:18:13 -08005212 pers->start_reshape == NULL) {
NeilBrownf6705572006-03-27 01:18:11 -08005213 /* This personality cannot handle reshaping... */
NeilBrownf6705572006-03-27 01:18:11 -08005214 module_put(pers->owner);
5215 return -EINVAL;
5216 }
5217
NeilBrown7dd5e7c32007-02-28 20:11:35 -08005218 if (pers->sync_request) {
5219 /* Warn if this is a potentially silly
5220 * configuration.
5221 */
5222 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
NeilBrown3cb03002011-10-11 16:45:26 +11005223 struct md_rdev *rdev2;
NeilBrown7dd5e7c32007-02-28 20:11:35 -08005224 int warned = 0;
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005225
NeilBrowndafb20f2012-03-19 12:46:39 +11005226 rdev_for_each(rdev, mddev)
5227 rdev_for_each(rdev2, mddev) {
NeilBrown7dd5e7c32007-02-28 20:11:35 -08005228 if (rdev < rdev2 &&
5229 rdev->bdev->bd_contains ==
5230 rdev2->bdev->bd_contains) {
5231 printk(KERN_WARNING
5232 "%s: WARNING: %s appears to be"
5233 " on the same physical disk as"
5234 " %s.\n",
5235 mdname(mddev),
5236 bdevname(rdev->bdev,b),
5237 bdevname(rdev2->bdev,b2));
5238 warned = 1;
5239 }
5240 }
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005241
NeilBrown7dd5e7c32007-02-28 20:11:35 -08005242 if (warned)
5243 printk(KERN_WARNING
5244 "True protection against single-disk"
5245 " failure might be compromised.\n");
5246 }
5247
NeilBrown657390d2005-08-26 18:34:16 -07005248 mddev->recovery = 0;
Andre Noll58c0fed2009-03-31 14:33:13 +11005249 /* may be over-ridden by personality */
5250 mddev->resync_max_sectors = mddev->dev_sectors;
5251
NeilBrown6ff8d8ec2006-01-06 00:20:15 -08005252 mddev->ok_start_degraded = start_dirty_degraded;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005253
NeilBrown0f9552b2009-12-30 12:08:50 +11005254 if (start_readonly && mddev->ro == 0)
NeilBrownf91de922005-11-08 21:39:36 -08005255 mddev->ro = 2; /* read-only, but switch on first write */
5256
NeilBrown36d091f2014-12-15 12:56:58 +11005257 err = pers->run(mddev);
Andre Noll13e53df2008-03-26 00:07:03 +01005258 if (err)
5259 printk(KERN_ERR "md: pers->run() failed ...\n");
NeilBrown36d091f2014-12-15 12:56:58 +11005260 else if (pers->size(mddev, 0, 0) < mddev->array_sectors) {
Dan Williamsb522adc2009-03-31 15:00:31 +11005261 WARN_ONCE(!mddev->external_size, "%s: default size too small,"
5262 " but 'external_size' not in effect?\n", __func__);
5263 printk(KERN_ERR
5264 "md: invalid array_size %llu > default size %llu\n",
5265 (unsigned long long)mddev->array_sectors / 2,
NeilBrown36d091f2014-12-15 12:56:58 +11005266 (unsigned long long)pers->size(mddev, 0, 0) / 2);
Dan Williamsb522adc2009-03-31 15:00:31 +11005267 err = -EINVAL;
Dan Williamsb522adc2009-03-31 15:00:31 +11005268 }
NeilBrown36d091f2014-12-15 12:56:58 +11005269 if (err == 0 && pers->sync_request &&
NeilBrownef99bf42012-05-22 13:55:08 +10005270 (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
Goldwyn Rodriguesf9209a32014-06-06 12:43:49 -05005271 struct bitmap *bitmap;
5272
5273 bitmap = bitmap_create(mddev, -1);
5274 if (IS_ERR(bitmap)) {
5275 err = PTR_ERR(bitmap);
NeilBrownb15c2e52006-01-06 00:20:16 -08005276 printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
5277 mdname(mddev), err);
Goldwyn Rodriguesf9209a32014-06-06 12:43:49 -05005278 } else
5279 mddev->bitmap = bitmap;
5280
NeilBrownb15c2e52006-01-06 00:20:16 -08005281 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005282 if (err) {
NeilBrown5aa61f42014-12-15 12:56:57 +11005283 mddev_detach(mddev);
NeilBrown0c35bd42015-03-13 11:51:18 +11005284 if (mddev->private)
5285 pers->free(mddev, mddev->private);
NeilBrownbd691922015-06-25 17:01:40 +10005286 mddev->private = NULL;
NeilBrown36d091f2014-12-15 12:56:58 +11005287 module_put(pers->owner);
NeilBrown32a76272005-06-21 17:17:14 -07005288 bitmap_destroy(mddev);
5289 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005290 }
NeilBrown5c675f82014-12-15 12:56:56 +11005291 if (mddev->queue) {
5292 mddev->queue->backing_dev_info.congested_data = mddev;
5293 mddev->queue->backing_dev_info.congested_fn = md_congested;
5294 }
NeilBrown36d091f2014-12-15 12:56:58 +11005295 if (pers->sync_request) {
NeilBrown00bcb4a2010-06-01 19:37:23 +10005296 if (mddev->kobj.sd &&
5297 sysfs_create_group(&mddev->kobj, &md_redundancy_group))
NeilBrown5e55e2f2007-03-26 21:32:14 -08005298 printk(KERN_WARNING
5299 "md: cannot register extra attributes for %s\n",
5300 mdname(mddev));
NeilBrown00bcb4a2010-06-01 19:37:23 +10005301 mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
NeilBrown5e55e2f2007-03-26 21:32:14 -08005302 } else if (mddev->ro == 2) /* auto-readonly not meaningful */
NeilBrownfd9d49c2005-11-08 21:39:42 -08005303 mddev->ro = 0;
5304
NeilBrownf72ffdd2014-09-30 14:23:59 +10005305 atomic_set(&mddev->writes_pending,0);
Robert Becker1e509152009-12-14 12:49:58 +11005306 atomic_set(&mddev->max_corr_read_errors,
5307 MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005308 mddev->safemode = 0;
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11005309 if (mddev_is_clustered(mddev))
5310 mddev->safemode_delay = 0;
5311 else
5312 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005313 mddev->in_sync = 1;
NeilBrown0ca69882011-01-14 09:14:33 +11005314 smp_wmb();
NeilBrown36d091f2014-12-15 12:56:58 +11005315 spin_lock(&mddev->lock);
5316 mddev->pers = pers;
NeilBrown36d091f2014-12-15 12:56:58 +11005317 spin_unlock(&mddev->lock);
NeilBrowndafb20f2012-03-19 12:46:39 +11005318 rdev_for_each(rdev, mddev)
Namhyung Kim36fad852011-07-27 11:00:36 +10005319 if (rdev->raid_disk >= 0)
5320 if (sysfs_link_rdev(mddev, rdev))
NeilBrown00bcb4a2010-06-01 19:37:23 +10005321 /* failure here is OK */;
NeilBrownf72ffdd2014-09-30 14:23:59 +10005322
NeilBrowna4a3d262015-07-17 11:57:30 +10005323 if (mddev->degraded && !mddev->ro)
5324 /* This ensures that recovering status is reported immediately
5325 * via sysfs - until a lack of spares is confirmed.
5326 */
5327 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005328 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrownf72ffdd2014-09-30 14:23:59 +10005329
NeilBrown7a0a5352013-08-27 16:28:23 +10005330 if (mddev->flags & MD_UPDATE_SB_FLAGS)
NeilBrown850b2b42006-10-03 01:15:46 -07005331 md_update_sb(mddev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005332
NeilBrownd7603b72006-01-06 00:20:30 -08005333 md_new_event(mddev);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005334 sysfs_notify_dirent_safe(mddev->sysfs_state);
5335 sysfs_notify_dirent_safe(mddev->sysfs_action);
Neil Browna99ac972008-06-28 08:31:43 +10005336 sysfs_notify(&mddev->kobj, NULL, "degraded");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005337 return 0;
5338}
NeilBrown390ee602010-06-01 19:37:27 +10005339EXPORT_SYMBOL_GPL(md_run);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005340
NeilBrownfd01b882011-10-11 16:47:53 +11005341static int do_md_run(struct mddev *mddev)
NeilBrownfe60b012010-03-29 11:10:42 +11005342{
5343 int err;
5344
5345 err = md_run(mddev);
5346 if (err)
5347 goto out;
NeilBrown69e51b42010-06-01 19:37:35 +10005348 err = bitmap_load(mddev);
5349 if (err) {
5350 bitmap_destroy(mddev);
5351 goto out;
5352 }
Jonathan Brassow0fd018a2011-06-07 17:49:36 -05005353
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11005354 if (mddev_is_clustered(mddev))
5355 md_allow_write(mddev);
5356
Jonathan Brassow0fd018a2011-06-07 17:49:36 -05005357 md_wakeup_thread(mddev->thread);
5358 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
5359
NeilBrownfe60b012010-03-29 11:10:42 +11005360 set_capacity(mddev->gendisk, mddev->array_sectors);
5361 revalidate_disk(mddev->gendisk);
NeilBrownf0b4f7e2011-02-24 17:26:41 +11005362 mddev->changed = 1;
NeilBrownfe60b012010-03-29 11:10:42 +11005363 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
5364out:
5365 return err;
5366}
5367
NeilBrownfd01b882011-10-11 16:47:53 +11005368static int restart_array(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005369{
5370 struct gendisk *disk = mddev->gendisk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005371
Andre Noll80fab1d2008-07-11 22:02:21 +10005372 /* Complain if it has no devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005373 if (list_empty(&mddev->disks))
Andre Noll80fab1d2008-07-11 22:02:21 +10005374 return -ENXIO;
5375 if (!mddev->pers)
5376 return -EINVAL;
5377 if (!mddev->ro)
5378 return -EBUSY;
Song Liu339421d2015-10-08 21:54:13 -07005379 if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {
5380 struct md_rdev *rdev;
5381 bool has_journal = false;
5382
5383 rcu_read_lock();
5384 rdev_for_each_rcu(rdev, mddev) {
5385 if (test_bit(Journal, &rdev->flags) &&
5386 !test_bit(Faulty, &rdev->flags)) {
5387 has_journal = true;
5388 break;
5389 }
5390 }
5391 rcu_read_unlock();
5392
5393 /* Don't restart rw with journal missing/faulty */
5394 if (!has_journal)
5395 return -EINVAL;
5396 }
5397
Andre Noll80fab1d2008-07-11 22:02:21 +10005398 mddev->safemode = 0;
5399 mddev->ro = 0;
5400 set_disk_ro(disk, 0);
5401 printk(KERN_INFO "md: %s switched to read-write mode.\n",
5402 mdname(mddev));
5403 /* Kick recovery or resync if necessary */
5404 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5405 md_wakeup_thread(mddev->thread);
5406 md_wakeup_thread(mddev->sync_thread);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005407 sysfs_notify_dirent_safe(mddev->sysfs_state);
Andre Noll80fab1d2008-07-11 22:02:21 +10005408 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005409}
5410
NeilBrownfd01b882011-10-11 16:47:53 +11005411static void md_clean(struct mddev *mddev)
NeilBrown6177b472010-03-29 11:37:13 +11005412{
5413 mddev->array_sectors = 0;
5414 mddev->external_size = 0;
5415 mddev->dev_sectors = 0;
5416 mddev->raid_disks = 0;
5417 mddev->recovery_cp = 0;
5418 mddev->resync_min = 0;
5419 mddev->resync_max = MaxSector;
5420 mddev->reshape_position = MaxSector;
5421 mddev->external = 0;
5422 mddev->persistent = 0;
5423 mddev->level = LEVEL_NONE;
5424 mddev->clevel[0] = 0;
5425 mddev->flags = 0;
5426 mddev->ro = 0;
5427 mddev->metadata_type[0] = 0;
5428 mddev->chunk_sectors = 0;
5429 mddev->ctime = mddev->utime = 0;
5430 mddev->layout = 0;
5431 mddev->max_disks = 0;
5432 mddev->events = 0;
NeilBrowna8707c02010-05-18 09:28:43 +10005433 mddev->can_decrease_events = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005434 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10005435 mddev->reshape_backwards = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005436 mddev->new_level = LEVEL_NONE;
5437 mddev->new_layout = 0;
5438 mddev->new_chunk_sectors = 0;
5439 mddev->curr_resync = 0;
Jianpeng Ma7f7583d2012-10-11 14:17:59 +11005440 atomic64_set(&mddev->resync_mismatches, 0);
NeilBrown6177b472010-03-29 11:37:13 +11005441 mddev->suspend_lo = mddev->suspend_hi = 0;
5442 mddev->sync_speed_min = mddev->sync_speed_max = 0;
5443 mddev->recovery = 0;
5444 mddev->in_sync = 0;
NeilBrownf0b4f7e2011-02-24 17:26:41 +11005445 mddev->changed = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005446 mddev->degraded = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005447 mddev->safemode = 0;
NeilBrownbd691922015-06-25 17:01:40 +10005448 mddev->private = NULL;
NeilBrown6177b472010-03-29 11:37:13 +11005449 mddev->bitmap_info.offset = 0;
5450 mddev->bitmap_info.default_offset = 0;
NeilBrown6409bb02012-05-22 13:55:07 +10005451 mddev->bitmap_info.default_space = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005452 mddev->bitmap_info.chunksize = 0;
5453 mddev->bitmap_info.daemon_sleep = 0;
5454 mddev->bitmap_info.max_write_behind = 0;
5455}
5456
NeilBrownfd01b882011-10-11 16:47:53 +11005457static void __md_stop_writes(struct mddev *mddev)
NeilBrowna047e122010-03-29 12:07:53 +11005458{
NeilBrown6b6204e2013-05-09 09:48:30 +10005459 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11005460 flush_workqueue(md_misc_wq);
NeilBrowna047e122010-03-29 12:07:53 +11005461 if (mddev->sync_thread) {
NeilBrowna047e122010-03-29 12:07:53 +11005462 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10005463 md_reap_sync_thread(mddev);
NeilBrowna047e122010-03-29 12:07:53 +11005464 }
5465
5466 del_timer_sync(&mddev->safemode_timer);
5467
5468 bitmap_flush(mddev);
5469 md_super_wait(mddev);
5470
NeilBrownb6d428c2013-04-24 11:42:42 +10005471 if (mddev->ro == 0 &&
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11005472 ((!mddev->in_sync && !mddev_is_clustered(mddev)) ||
5473 (mddev->flags & MD_UPDATE_SB_FLAGS))) {
NeilBrowna047e122010-03-29 12:07:53 +11005474 /* mark array as shutdown cleanly */
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11005475 if (!mddev_is_clustered(mddev))
5476 mddev->in_sync = 1;
NeilBrowna047e122010-03-29 12:07:53 +11005477 md_update_sb(mddev, 1);
5478 }
5479}
NeilBrowndefad612011-01-14 09:14:33 +11005480
NeilBrownfd01b882011-10-11 16:47:53 +11005481void md_stop_writes(struct mddev *mddev)
NeilBrowndefad612011-01-14 09:14:33 +11005482{
NeilBrown29f097c2013-11-14 17:54:51 +11005483 mddev_lock_nointr(mddev);
NeilBrowndefad612011-01-14 09:14:33 +11005484 __md_stop_writes(mddev);
5485 mddev_unlock(mddev);
5486}
NeilBrown390ee602010-06-01 19:37:27 +10005487EXPORT_SYMBOL_GPL(md_stop_writes);
NeilBrowna047e122010-03-29 12:07:53 +11005488
NeilBrown5aa61f42014-12-15 12:56:57 +11005489static void mddev_detach(struct mddev *mddev)
5490{
5491 struct bitmap *bitmap = mddev->bitmap;
5492 /* wait for behind writes to complete */
5493 if (bitmap && atomic_read(&bitmap->behind_writes) > 0) {
5494 printk(KERN_INFO "md:%s: behind writes in progress - waiting to stop.\n",
5495 mdname(mddev));
5496 /* need to kick something here to make sure I/O goes? */
5497 wait_event(bitmap->behind_wait,
5498 atomic_read(&bitmap->behind_writes) == 0);
5499 }
NeilBrown36d091f2014-12-15 12:56:58 +11005500 if (mddev->pers && mddev->pers->quiesce) {
NeilBrown5aa61f42014-12-15 12:56:57 +11005501 mddev->pers->quiesce(mddev, 1);
5502 mddev->pers->quiesce(mddev, 0);
5503 }
5504 md_unregister_thread(&mddev->thread);
5505 if (mddev->queue)
5506 blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
5507}
5508
NeilBrown5eff3c42012-11-19 10:47:48 +11005509static void __md_stop(struct mddev *mddev)
NeilBrown6177b472010-03-29 11:37:13 +11005510{
NeilBrown36d091f2014-12-15 12:56:58 +11005511 struct md_personality *pers = mddev->pers;
NeilBrown5aa61f42014-12-15 12:56:57 +11005512 mddev_detach(mddev);
NeilBrownee5d0042015-07-22 10:20:07 +10005513 /* Ensure ->event_work is done */
5514 flush_workqueue(md_misc_wq);
NeilBrown36d091f2014-12-15 12:56:58 +11005515 spin_lock(&mddev->lock);
NeilBrown6177b472010-03-29 11:37:13 +11005516 mddev->pers = NULL;
NeilBrown36d091f2014-12-15 12:56:58 +11005517 spin_unlock(&mddev->lock);
5518 pers->free(mddev, mddev->private);
NeilBrownbd691922015-06-25 17:01:40 +10005519 mddev->private = NULL;
NeilBrown36d091f2014-12-15 12:56:58 +11005520 if (pers->sync_request && mddev->to_remove == NULL)
5521 mddev->to_remove = &md_redundancy_group;
5522 module_put(pers->owner);
NeilBrowncca9cf92010-04-01 12:08:16 +11005523 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown6177b472010-03-29 11:37:13 +11005524}
NeilBrown5eff3c42012-11-19 10:47:48 +11005525
5526void md_stop(struct mddev *mddev)
5527{
5528 /* stop the array and free an attached data structures.
5529 * This is called from dm-raid
5530 */
5531 __md_stop(mddev);
5532 bitmap_destroy(mddev);
5533 if (mddev->bio_set)
5534 bioset_free(mddev->bio_set);
5535}
5536
NeilBrown390ee602010-06-01 19:37:27 +10005537EXPORT_SYMBOL_GPL(md_stop);
NeilBrown6177b472010-03-29 11:37:13 +11005538
NeilBrowna05b7ea02012-07-19 15:59:18 +10005539static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
NeilBrowna4bd82d2010-03-29 13:23:10 +11005540{
5541 int err = 0;
NeilBrown30b8feb2013-11-14 15:16:17 +11005542 int did_freeze = 0;
5543
5544 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
5545 did_freeze = 1;
5546 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5547 md_wakeup_thread(mddev->thread);
5548 }
NeilBrownf851b602014-12-11 10:02:10 +11005549 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown30b8feb2013-11-14 15:16:17 +11005550 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11005551 if (mddev->sync_thread)
NeilBrown30b8feb2013-11-14 15:16:17 +11005552 /* Thread might be blocked waiting for metadata update
5553 * which will now never happen */
5554 wake_up_process(mddev->sync_thread->tsk);
NeilBrownf851b602014-12-11 10:02:10 +11005555
NeilBrown88724bf2015-09-24 14:00:51 +10005556 if (mddev->external && test_bit(MD_CHANGE_PENDING, &mddev->flags))
5557 return -EBUSY;
NeilBrown30b8feb2013-11-14 15:16:17 +11005558 mddev_unlock(mddev);
NeilBrownf851b602014-12-11 10:02:10 +11005559 wait_event(resync_wait, !test_bit(MD_RECOVERY_RUNNING,
5560 &mddev->recovery));
NeilBrown88724bf2015-09-24 14:00:51 +10005561 wait_event(mddev->sb_wait,
5562 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
NeilBrown30b8feb2013-11-14 15:16:17 +11005563 mddev_lock_nointr(mddev);
5564
NeilBrowna4bd82d2010-03-29 13:23:10 +11005565 mutex_lock(&mddev->open_mutex);
NeilBrown9ba3b7f2014-09-09 14:00:15 +10005566 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
NeilBrown30b8feb2013-11-14 15:16:17 +11005567 mddev->sync_thread ||
NeilBrownf851b602014-12-11 10:02:10 +11005568 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
NeilBrown30b8feb2013-11-14 15:16:17 +11005569 (bdev && !test_bit(MD_STILL_CLOSED, &mddev->flags))) {
NeilBrowna4bd82d2010-03-29 13:23:10 +11005570 printk("md: %s still in use.\n",mdname(mddev));
NeilBrown30b8feb2013-11-14 15:16:17 +11005571 if (did_freeze) {
5572 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown45eaf452014-10-29 08:49:50 +11005573 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown30b8feb2013-11-14 15:16:17 +11005574 md_wakeup_thread(mddev->thread);
5575 }
NeilBrowna4bd82d2010-03-29 13:23:10 +11005576 err = -EBUSY;
5577 goto out;
5578 }
5579 if (mddev->pers) {
NeilBrowndefad612011-01-14 09:14:33 +11005580 __md_stop_writes(mddev);
NeilBrowna4bd82d2010-03-29 13:23:10 +11005581
5582 err = -ENXIO;
5583 if (mddev->ro==1)
5584 goto out;
5585 mddev->ro = 1;
5586 set_disk_ro(mddev->gendisk, 1);
5587 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown45eaf452014-10-29 08:49:50 +11005588 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5589 md_wakeup_thread(mddev->thread);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005590 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown30b8feb2013-11-14 15:16:17 +11005591 err = 0;
NeilBrowna4bd82d2010-03-29 13:23:10 +11005592 }
5593out:
5594 mutex_unlock(&mddev->open_mutex);
5595 return err;
5596}
5597
NeilBrown9e653b62006-06-26 00:27:58 -07005598/* mode:
5599 * 0 - completely stop and dis-assemble array
NeilBrown9e653b62006-06-26 00:27:58 -07005600 * 2 - stop but do not disassemble array
5601 */
NeilBrownf72ffdd2014-09-30 14:23:59 +10005602static int do_md_stop(struct mddev *mddev, int mode,
NeilBrowna05b7ea02012-07-19 15:59:18 +10005603 struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005604{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005605 struct gendisk *disk = mddev->gendisk;
NeilBrown3cb03002011-10-11 16:45:26 +11005606 struct md_rdev *rdev;
NeilBrown30b8feb2013-11-14 15:16:17 +11005607 int did_freeze = 0;
5608
5609 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
5610 did_freeze = 1;
5611 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5612 md_wakeup_thread(mddev->thread);
5613 }
NeilBrownf851b602014-12-11 10:02:10 +11005614 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown30b8feb2013-11-14 15:16:17 +11005615 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11005616 if (mddev->sync_thread)
NeilBrown30b8feb2013-11-14 15:16:17 +11005617 /* Thread might be blocked waiting for metadata update
5618 * which will now never happen */
5619 wake_up_process(mddev->sync_thread->tsk);
NeilBrownf851b602014-12-11 10:02:10 +11005620
NeilBrown30b8feb2013-11-14 15:16:17 +11005621 mddev_unlock(mddev);
NeilBrownf851b602014-12-11 10:02:10 +11005622 wait_event(resync_wait, (mddev->sync_thread == NULL &&
5623 !test_bit(MD_RECOVERY_RUNNING,
5624 &mddev->recovery)));
NeilBrown30b8feb2013-11-14 15:16:17 +11005625 mddev_lock_nointr(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005626
NeilBrownc8c00a62009-08-10 12:50:52 +10005627 mutex_lock(&mddev->open_mutex);
NeilBrown9ba3b7f2014-09-09 14:00:15 +10005628 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
NeilBrown30b8feb2013-11-14 15:16:17 +11005629 mddev->sysfs_active ||
5630 mddev->sync_thread ||
NeilBrownf851b602014-12-11 10:02:10 +11005631 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
NeilBrown30b8feb2013-11-14 15:16:17 +11005632 (bdev && !test_bit(MD_STILL_CLOSED, &mddev->flags))) {
Neil Browndf5b20c2008-07-11 22:02:22 +10005633 printk("md: %s still in use.\n",mdname(mddev));
NeilBrown6e17b022010-08-07 21:41:19 +10005634 mutex_unlock(&mddev->open_mutex);
NeilBrown30b8feb2013-11-14 15:16:17 +11005635 if (did_freeze) {
5636 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown45eaf452014-10-29 08:49:50 +11005637 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown30b8feb2013-11-14 15:16:17 +11005638 md_wakeup_thread(mddev->thread);
5639 }
NeilBrown260fa032013-08-27 16:44:13 +10005640 return -EBUSY;
5641 }
NeilBrown6e17b022010-08-07 21:41:19 +10005642 if (mddev->pers) {
NeilBrowna4bd82d2010-03-29 13:23:10 +11005643 if (mddev->ro)
5644 set_disk_ro(disk, 0);
NeilBrown409c57f2009-03-31 14:39:39 +11005645
NeilBrowndefad612011-01-14 09:14:33 +11005646 __md_stop_writes(mddev);
NeilBrown5eff3c42012-11-19 10:47:48 +11005647 __md_stop(mddev);
NeilBrowna4bd82d2010-03-29 13:23:10 +11005648 mddev->queue->backing_dev_info.congested_fn = NULL;
NeilBrown6177b472010-03-29 11:37:13 +11005649
NeilBrowna4bd82d2010-03-29 13:23:10 +11005650 /* tell userspace to handle 'inactive' */
NeilBrown00bcb4a2010-06-01 19:37:23 +10005651 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown0d4ca602006-12-10 02:20:44 -08005652
NeilBrowndafb20f2012-03-19 12:46:39 +11005653 rdev_for_each(rdev, mddev)
Namhyung Kim36fad852011-07-27 11:00:36 +10005654 if (rdev->raid_disk >= 0)
5655 sysfs_unlink_rdev(mddev, rdev);
NeilBrownc4647292009-05-07 12:51:06 +10005656
NeilBrowna4bd82d2010-03-29 13:23:10 +11005657 set_capacity(disk, 0);
NeilBrown6e17b022010-08-07 21:41:19 +10005658 mutex_unlock(&mddev->open_mutex);
NeilBrownf0b4f7e2011-02-24 17:26:41 +11005659 mddev->changed = 1;
NeilBrowna4bd82d2010-03-29 13:23:10 +11005660 revalidate_disk(disk);
NeilBrown0d4ca602006-12-10 02:20:44 -08005661
NeilBrowna4bd82d2010-03-29 13:23:10 +11005662 if (mddev->ro)
5663 mddev->ro = 0;
NeilBrown6e17b022010-08-07 21:41:19 +10005664 } else
5665 mutex_unlock(&mddev->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005666 /*
5667 * Free resources if final stop
5668 */
NeilBrown9e653b62006-06-26 00:27:58 -07005669 if (mode == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005670 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
5671
NeilBrown978f9462006-02-02 14:28:05 -08005672 bitmap_destroy(mddev);
NeilBrownc3d97142009-12-14 12:49:52 +11005673 if (mddev->bitmap_info.file) {
NeilBrown4af1a042014-12-15 12:57:00 +11005674 struct file *f = mddev->bitmap_info.file;
5675 spin_lock(&mddev->lock);
NeilBrownc3d97142009-12-14 12:49:52 +11005676 mddev->bitmap_info.file = NULL;
NeilBrown4af1a042014-12-15 12:57:00 +11005677 spin_unlock(&mddev->lock);
5678 fput(f);
NeilBrown978f9462006-02-02 14:28:05 -08005679 }
NeilBrownc3d97142009-12-14 12:49:52 +11005680 mddev->bitmap_info.offset = 0;
NeilBrown978f9462006-02-02 14:28:05 -08005681
Linus Torvalds1da177e2005-04-16 15:20:36 -07005682 export_array(mddev);
5683
NeilBrown6177b472010-03-29 11:37:13 +11005684 md_clean(mddev);
NeilBrownefeb53c2009-01-09 08:31:10 +11005685 if (mddev->hold_active == UNTIL_STOP)
5686 mddev->hold_active = 0;
NeilBrowna4bd82d2010-03-29 13:23:10 +11005687 }
NeilBrownd7603b72006-01-06 00:20:30 -08005688 md_new_event(mddev);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005689 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown6e17b022010-08-07 21:41:19 +10005690 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005691}
5692
Jeff Garzikfdee8ae2006-12-10 02:20:50 -08005693#ifndef MODULE
NeilBrownfd01b882011-10-11 16:47:53 +11005694static void autorun_array(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005695{
NeilBrown3cb03002011-10-11 16:45:26 +11005696 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005697 int err;
5698
NeilBrowna757e642005-04-16 15:26:42 -07005699 if (list_empty(&mddev->disks))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005700 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005701
5702 printk(KERN_INFO "md: running: ");
5703
NeilBrowndafb20f2012-03-19 12:46:39 +11005704 rdev_for_each(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005705 char b[BDEVNAME_SIZE];
5706 printk("<%s>", bdevname(rdev->bdev,b));
5707 }
5708 printk("\n");
5709
NeilBrownd710e132008-10-13 11:55:12 +11005710 err = do_md_run(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005711 if (err) {
5712 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
NeilBrowna05b7ea02012-07-19 15:59:18 +10005713 do_md_stop(mddev, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005714 }
5715}
5716
5717/*
5718 * lets try to run arrays based on all disks that have arrived
5719 * until now. (those are in pending_raid_disks)
5720 *
5721 * the method: pick the first pending disk, collect all disks with
5722 * the same UUID, remove all from the pending list and put them into
5723 * the 'same_array' list. Then order this list based on superblock
5724 * update time (freshest comes first), kick out 'old' disks and
5725 * compare superblocks. If everything's fine then run it.
5726 *
5727 * If "unit" is allocated, then bump its reference count
5728 */
5729static void autorun_devices(int part)
5730{
NeilBrown3cb03002011-10-11 16:45:26 +11005731 struct md_rdev *rdev0, *rdev, *tmp;
NeilBrownfd01b882011-10-11 16:47:53 +11005732 struct mddev *mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005733 char b[BDEVNAME_SIZE];
5734
5735 printk(KERN_INFO "md: autorun ...\n");
5736 while (!list_empty(&pending_raid_disks)) {
NeilBrowne8703fe2006-10-03 01:15:59 -07005737 int unit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005738 dev_t dev;
NeilBrownad01c9e2006-03-27 01:18:07 -08005739 LIST_HEAD(candidates);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005740 rdev0 = list_entry(pending_raid_disks.next,
NeilBrown3cb03002011-10-11 16:45:26 +11005741 struct md_rdev, same_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005742
5743 printk(KERN_INFO "md: considering %s ...\n",
5744 bdevname(rdev0->bdev,b));
5745 INIT_LIST_HEAD(&candidates);
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005746 rdev_for_each_list(rdev, tmp, &pending_raid_disks)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005747 if (super_90_load(rdev, rdev0, 0) >= 0) {
5748 printk(KERN_INFO "md: adding %s ...\n",
5749 bdevname(rdev->bdev,b));
5750 list_move(&rdev->same_set, &candidates);
5751 }
5752 /*
5753 * now we have a set of devices, with all of them having
5754 * mostly sane superblocks. It's time to allocate the
5755 * mddev.
5756 */
NeilBrowne8703fe2006-10-03 01:15:59 -07005757 if (part) {
5758 dev = MKDEV(mdp_major,
5759 rdev0->preferred_minor << MdpMinorShift);
5760 unit = MINOR(dev) >> MdpMinorShift;
5761 } else {
5762 dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
5763 unit = MINOR(dev);
5764 }
5765 if (rdev0->preferred_minor != unit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005766 printk(KERN_INFO "md: unit number in %s is bad: %d\n",
5767 bdevname(rdev0->bdev, b), rdev0->preferred_minor);
5768 break;
5769 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005770
5771 md_probe(dev, NULL, NULL);
5772 mddev = mddev_find(dev);
Neil Brown9bbbca32008-06-28 08:31:17 +10005773 if (!mddev || !mddev->gendisk) {
5774 if (mddev)
5775 mddev_put(mddev);
5776 printk(KERN_ERR
Linus Torvalds1da177e2005-04-16 15:20:36 -07005777 "md: cannot allocate memory for md drive.\n");
5778 break;
5779 }
NeilBrownf72ffdd2014-09-30 14:23:59 +10005780 if (mddev_lock(mddev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005781 printk(KERN_WARNING "md: %s locked, cannot run\n",
5782 mdname(mddev));
5783 else if (mddev->raid_disks || mddev->major_version
5784 || !list_empty(&mddev->disks)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005785 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005786 "md: %s already running, cannot run %s\n",
5787 mdname(mddev), bdevname(rdev0->bdev,b));
5788 mddev_unlock(mddev);
5789 } else {
5790 printk(KERN_INFO "md: created %s\n", mdname(mddev));
NeilBrown1ec4a932008-02-06 01:39:53 -08005791 mddev->persistent = 1;
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005792 rdev_for_each_list(rdev, tmp, &candidates) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005793 list_del_init(&rdev->same_set);
5794 if (bind_rdev_to_array(rdev, mddev))
5795 export_rdev(rdev);
5796 }
5797 autorun_array(mddev);
5798 mddev_unlock(mddev);
5799 }
5800 /* on success, candidates will be empty, on error
5801 * it won't...
5802 */
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005803 rdev_for_each_list(rdev, tmp, &candidates) {
NeilBrown4b809912008-07-21 17:05:25 +10005804 list_del_init(&rdev->same_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005805 export_rdev(rdev);
NeilBrown4b809912008-07-21 17:05:25 +10005806 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005807 mddev_put(mddev);
5808 }
5809 printk(KERN_INFO "md: ... autorun DONE.\n");
5810}
Jeff Garzikfdee8ae2006-12-10 02:20:50 -08005811#endif /* !MODULE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005812
NeilBrownf72ffdd2014-09-30 14:23:59 +10005813static int get_version(void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005814{
5815 mdu_version_t ver;
5816
5817 ver.major = MD_MAJOR_VERSION;
5818 ver.minor = MD_MINOR_VERSION;
5819 ver.patchlevel = MD_PATCHLEVEL_VERSION;
5820
5821 if (copy_to_user(arg, &ver, sizeof(ver)))
5822 return -EFAULT;
5823
5824 return 0;
5825}
5826
NeilBrownf72ffdd2014-09-30 14:23:59 +10005827static int get_array_info(struct mddev *mddev, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005828{
5829 mdu_array_info_t info;
NeilBrowna9f326e2009-09-23 18:06:41 +10005830 int nr,working,insync,failed,spare;
NeilBrown3cb03002011-10-11 16:45:26 +11005831 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005832
NeilBrown1ca69c42012-10-11 13:37:33 +11005833 nr = working = insync = failed = spare = 0;
5834 rcu_read_lock();
5835 rdev_for_each_rcu(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005836 nr++;
NeilBrownb2d444d2005-11-08 21:39:31 -08005837 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005838 failed++;
5839 else {
5840 working++;
NeilBrownb2d444d2005-11-08 21:39:31 -08005841 if (test_bit(In_sync, &rdev->flags))
NeilBrownf72ffdd2014-09-30 14:23:59 +10005842 insync++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005843 else
5844 spare++;
5845 }
5846 }
NeilBrown1ca69c42012-10-11 13:37:33 +11005847 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005848
5849 info.major_version = mddev->major_version;
5850 info.minor_version = mddev->minor_version;
5851 info.patch_version = MD_PATCHLEVEL_VERSION;
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11005852 info.ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005853 info.level = mddev->level;
Andre Noll58c0fed2009-03-31 14:33:13 +11005854 info.size = mddev->dev_sectors / 2;
5855 if (info.size != mddev->dev_sectors / 2) /* overflow */
NeilBrown284ae7c2006-02-03 03:03:40 -08005856 info.size = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005857 info.nr_disks = nr;
5858 info.raid_disks = mddev->raid_disks;
5859 info.md_minor = mddev->md_minor;
5860 info.not_persistent= !mddev->persistent;
5861
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11005862 info.utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005863 info.state = 0;
5864 if (mddev->in_sync)
5865 info.state = (1<<MD_SB_CLEAN);
NeilBrownc3d97142009-12-14 12:49:52 +11005866 if (mddev->bitmap && mddev->bitmap_info.offset)
NeilBrown9bd35922014-07-02 11:35:06 +10005867 info.state |= (1<<MD_SB_BITMAP_PRESENT);
Goldwyn Rodriguesca8895d2014-11-26 12:22:03 -06005868 if (mddev_is_clustered(mddev))
5869 info.state |= (1<<MD_SB_CLUSTERED);
NeilBrowna9f326e2009-09-23 18:06:41 +10005870 info.active_disks = insync;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005871 info.working_disks = working;
5872 info.failed_disks = failed;
5873 info.spare_disks = spare;
5874
5875 info.layout = mddev->layout;
Andre Noll9d8f0362009-06-18 08:45:01 +10005876 info.chunk_size = mddev->chunk_sectors << 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005877
5878 if (copy_to_user(arg, &info, sizeof(info)))
5879 return -EFAULT;
5880
5881 return 0;
5882}
5883
NeilBrownf72ffdd2014-09-30 14:23:59 +10005884static int get_bitmap_file(struct mddev *mddev, void __user * arg)
NeilBrown32a76272005-06-21 17:17:14 -07005885{
5886 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
NeilBrownf4ad3d32014-12-15 12:57:00 +11005887 char *ptr;
NeilBrown4af1a042014-12-15 12:57:00 +11005888 int err;
NeilBrown32a76272005-06-21 17:17:14 -07005889
Benjamin Randazzob6878d92015-07-25 16:36:50 +02005890 file = kzalloc(sizeof(*file), GFP_NOIO);
NeilBrown32a76272005-06-21 17:17:14 -07005891 if (!file)
NeilBrown4af1a042014-12-15 12:57:00 +11005892 return -ENOMEM;
NeilBrown32a76272005-06-21 17:17:14 -07005893
NeilBrown32a76272005-06-21 17:17:14 -07005894 err = 0;
NeilBrown4af1a042014-12-15 12:57:00 +11005895 spin_lock(&mddev->lock);
Benjamin Randazzo25eafe12015-07-25 16:36:50 +02005896 /* bitmap enabled */
5897 if (mddev->bitmap_info.file) {
5898 ptr = file_path(mddev->bitmap_info.file, file->pathname,
5899 sizeof(file->pathname));
5900 if (IS_ERR(ptr))
5901 err = PTR_ERR(ptr);
5902 else
5903 memmove(file->pathname, ptr,
5904 sizeof(file->pathname)-(ptr-file->pathname));
5905 }
NeilBrown4af1a042014-12-15 12:57:00 +11005906 spin_unlock(&mddev->lock);
5907
5908 if (err == 0 &&
5909 copy_to_user(arg, file, sizeof(*file)))
NeilBrown32a76272005-06-21 17:17:14 -07005910 err = -EFAULT;
NeilBrown4af1a042014-12-15 12:57:00 +11005911
NeilBrown32a76272005-06-21 17:17:14 -07005912 kfree(file);
5913 return err;
5914}
5915
NeilBrownf72ffdd2014-09-30 14:23:59 +10005916static int get_disk_info(struct mddev *mddev, void __user * arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005917{
5918 mdu_disk_info_t info;
NeilBrown3cb03002011-10-11 16:45:26 +11005919 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005920
5921 if (copy_from_user(&info, arg, sizeof(info)))
5922 return -EFAULT;
5923
NeilBrown1ca69c42012-10-11 13:37:33 +11005924 rcu_read_lock();
Goldwyn Rodrigues57d051d2015-04-14 10:43:55 -05005925 rdev = md_find_rdev_nr_rcu(mddev, info.number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005926 if (rdev) {
5927 info.major = MAJOR(rdev->bdev->bd_dev);
5928 info.minor = MINOR(rdev->bdev->bd_dev);
5929 info.raid_disk = rdev->raid_disk;
5930 info.state = 0;
NeilBrownb2d444d2005-11-08 21:39:31 -08005931 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005932 info.state |= (1<<MD_DISK_FAULTY);
NeilBrownb2d444d2005-11-08 21:39:31 -08005933 else if (test_bit(In_sync, &rdev->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005934 info.state |= (1<<MD_DISK_ACTIVE);
5935 info.state |= (1<<MD_DISK_SYNC);
5936 }
Shaohua Li9efdca12015-10-12 16:59:50 -07005937 if (test_bit(Journal, &rdev->flags))
Song Liubac624f2015-08-13 14:31:55 -07005938 info.state |= (1<<MD_DISK_JOURNAL);
NeilBrown8ddf9ef2005-09-09 16:23:45 -07005939 if (test_bit(WriteMostly, &rdev->flags))
5940 info.state |= (1<<MD_DISK_WRITEMOSTLY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005941 } else {
5942 info.major = info.minor = 0;
5943 info.raid_disk = -1;
5944 info.state = (1<<MD_DISK_REMOVED);
5945 }
NeilBrown1ca69c42012-10-11 13:37:33 +11005946 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005947
5948 if (copy_to_user(arg, &info, sizeof(info)))
5949 return -EFAULT;
5950
5951 return 0;
5952}
5953
NeilBrownf72ffdd2014-09-30 14:23:59 +10005954static int add_new_disk(struct mddev *mddev, mdu_disk_info_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005955{
5956 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
NeilBrown3cb03002011-10-11 16:45:26 +11005957 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005958 dev_t dev = MKDEV(info->major,info->minor);
5959
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05005960 if (mddev_is_clustered(mddev) &&
5961 !(info->state & ((1 << MD_DISK_CLUSTER_ADD) | (1 << MD_DISK_CANDIDATE)))) {
Goldwyn Rodriguesfa8259d2015-03-02 10:55:49 -06005962 pr_err("%s: Cannot add to clustered mddev.\n",
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05005963 mdname(mddev));
5964 return -EINVAL;
5965 }
5966
Linus Torvalds1da177e2005-04-16 15:20:36 -07005967 if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
5968 return -EOVERFLOW;
5969
5970 if (!mddev->raid_disks) {
5971 int err;
5972 /* expecting a device which has a superblock */
5973 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
5974 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005975 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005976 "md: md_import_device returned %ld\n",
5977 PTR_ERR(rdev));
5978 return PTR_ERR(rdev);
5979 }
5980 if (!list_empty(&mddev->disks)) {
NeilBrown3cb03002011-10-11 16:45:26 +11005981 struct md_rdev *rdev0
5982 = list_entry(mddev->disks.next,
5983 struct md_rdev, same_set);
NeilBrowna9f326e2009-09-23 18:06:41 +10005984 err = super_types[mddev->major_version]
Linus Torvalds1da177e2005-04-16 15:20:36 -07005985 .load_super(rdev, rdev0, mddev->minor_version);
5986 if (err < 0) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005987 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005988 "md: %s has different UUID to %s\n",
NeilBrownf72ffdd2014-09-30 14:23:59 +10005989 bdevname(rdev->bdev,b),
Linus Torvalds1da177e2005-04-16 15:20:36 -07005990 bdevname(rdev0->bdev,b2));
5991 export_rdev(rdev);
5992 return -EINVAL;
5993 }
5994 }
5995 err = bind_rdev_to_array(rdev, mddev);
5996 if (err)
5997 export_rdev(rdev);
5998 return err;
5999 }
6000
6001 /*
6002 * add_new_disk can be used once the array is assembled
6003 * to add "hot spares". They must already have a superblock
6004 * written
6005 */
6006 if (mddev->pers) {
6007 int err;
6008 if (!mddev->pers->hot_add_disk) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006009 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006010 "%s: personality does not support diskops!\n",
6011 mdname(mddev));
6012 return -EINVAL;
6013 }
NeilBrown7b1e35f2005-09-09 16:23:50 -07006014 if (mddev->persistent)
6015 rdev = md_import_device(dev, mddev->major_version,
6016 mddev->minor_version);
6017 else
6018 rdev = md_import_device(dev, -1, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006019 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006020 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006021 "md: md_import_device returned %ld\n",
6022 PTR_ERR(rdev));
6023 return PTR_ERR(rdev);
6024 }
NeilBrown1a855a02010-12-09 16:36:28 +11006025 /* set saved_raid_disk if appropriate */
NeilBrown41158c72005-06-21 17:17:25 -07006026 if (!mddev->persistent) {
6027 if (info->state & (1<<MD_DISK_SYNC) &&
NeilBrownbf572542011-01-12 09:03:35 +11006028 info->raid_disk < mddev->raid_disks) {
NeilBrown41158c72005-06-21 17:17:25 -07006029 rdev->raid_disk = info->raid_disk;
NeilBrownbf572542011-01-12 09:03:35 +11006030 set_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11006031 clear_bit(Bitmap_sync, &rdev->flags);
NeilBrownbf572542011-01-12 09:03:35 +11006032 } else
NeilBrown41158c72005-06-21 17:17:25 -07006033 rdev->raid_disk = -1;
NeilBrownf4667222013-12-09 12:04:56 +11006034 rdev->saved_raid_disk = rdev->raid_disk;
NeilBrown41158c72005-06-21 17:17:25 -07006035 } else
6036 super_types[mddev->major_version].
6037 validate_super(mddev, rdev);
NeilBrownbedd86b2011-05-11 14:26:20 +10006038 if ((info->state & (1<<MD_DISK_SYNC)) &&
NeilBrownf4563092012-07-03 15:59:06 +10006039 rdev->raid_disk != info->raid_disk) {
NeilBrownbedd86b2011-05-11 14:26:20 +10006040 /* This was a hot-add request, but events doesn't
6041 * match, so reject it.
6042 */
6043 export_rdev(rdev);
6044 return -EINVAL;
6045 }
6046
NeilBrownb2d444d2005-11-08 21:39:31 -08006047 clear_bit(In_sync, &rdev->flags); /* just to be sure */
NeilBrown8ddf9ef2005-09-09 16:23:45 -07006048 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
6049 set_bit(WriteMostly, &rdev->flags);
NeilBrown575a80f2009-03-31 14:33:13 +11006050 else
6051 clear_bit(WriteMostly, &rdev->flags);
NeilBrown8ddf9ef2005-09-09 16:23:45 -07006052
Shaohua Lif6b6ec52015-12-21 10:51:02 +11006053 if (info->state & (1<<MD_DISK_JOURNAL)) {
6054 struct md_rdev *rdev2;
6055 bool has_journal = false;
6056
6057 /* make sure no existing journal disk */
6058 rdev_for_each(rdev2, mddev) {
6059 if (test_bit(Journal, &rdev2->flags)) {
6060 has_journal = true;
6061 break;
6062 }
6063 }
6064 if (has_journal) {
6065 export_rdev(rdev);
6066 return -EBUSY;
6067 }
Song Liubac624f2015-08-13 14:31:55 -07006068 set_bit(Journal, &rdev->flags);
Shaohua Lif6b6ec52015-12-21 10:51:02 +11006069 }
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006070 /*
6071 * check whether the device shows up in other nodes
6072 */
6073 if (mddev_is_clustered(mddev)) {
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006074 if (info->state & (1 << MD_DISK_CANDIDATE))
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006075 set_bit(Candidate, &rdev->flags);
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006076 else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) {
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006077 /* --add initiated by this node */
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006078 err = md_cluster_ops->add_new_disk(mddev, rdev);
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006079 if (err) {
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006080 export_rdev(rdev);
6081 return err;
6082 }
6083 }
6084 }
6085
Linus Torvalds1da177e2005-04-16 15:20:36 -07006086 rdev->raid_disk = -1;
6087 err = bind_rdev_to_array(rdev, mddev);
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006088
Linus Torvalds1da177e2005-04-16 15:20:36 -07006089 if (err)
6090 export_rdev(rdev);
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006091
6092 if (mddev_is_clustered(mddev)) {
6093 if (info->state & (1 << MD_DISK_CANDIDATE))
6094 md_cluster_ops->new_disk_ack(mddev, (err == 0));
6095 else {
6096 if (err)
6097 md_cluster_ops->add_new_disk_cancel(mddev);
6098 else
6099 err = add_bound_rdev(rdev);
6100 }
6101
6102 } else if (!err)
Goldwyn Rodriguesa6da4ef2015-04-14 10:45:22 -05006103 err = add_bound_rdev(rdev);
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05006104
Linus Torvalds1da177e2005-04-16 15:20:36 -07006105 return err;
6106 }
6107
6108 /* otherwise, add_new_disk is only allowed
6109 * for major_version==0 superblocks
6110 */
6111 if (mddev->major_version != 0) {
6112 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
6113 mdname(mddev));
6114 return -EINVAL;
6115 }
6116
6117 if (!(info->state & (1<<MD_DISK_FAULTY))) {
6118 int err;
NeilBrownd710e132008-10-13 11:55:12 +11006119 rdev = md_import_device(dev, -1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006120 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006121 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006122 "md: error, md_import_device() returned %ld\n",
6123 PTR_ERR(rdev));
6124 return PTR_ERR(rdev);
6125 }
6126 rdev->desc_nr = info->number;
6127 if (info->raid_disk < mddev->raid_disks)
6128 rdev->raid_disk = info->raid_disk;
6129 else
6130 rdev->raid_disk = -1;
6131
Linus Torvalds1da177e2005-04-16 15:20:36 -07006132 if (rdev->raid_disk < mddev->raid_disks)
NeilBrownb2d444d2005-11-08 21:39:31 -08006133 if (info->state & (1<<MD_DISK_SYNC))
6134 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006135
NeilBrown8ddf9ef2005-09-09 16:23:45 -07006136 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
6137 set_bit(WriteMostly, &rdev->flags);
6138
Linus Torvalds1da177e2005-04-16 15:20:36 -07006139 if (!mddev->persistent) {
6140 printk(KERN_INFO "md: nonpersistent superblock ...\n");
Mike Snitzer77304d22010-11-08 14:39:12 +01006141 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
6142 } else
Jonathan Brassow57b2caa2011-01-14 09:14:33 +11006143 rdev->sb_start = calc_dev_sboffset(rdev);
NeilBrown8190e752009-06-18 08:48:58 +10006144 rdev->sectors = rdev->sb_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006145
NeilBrown2bf071b2006-01-06 00:20:55 -08006146 err = bind_rdev_to_array(rdev, mddev);
6147 if (err) {
6148 export_rdev(rdev);
6149 return err;
6150 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006151 }
6152
6153 return 0;
6154}
6155
NeilBrownf72ffdd2014-09-30 14:23:59 +10006156static int hot_remove_disk(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006157{
6158 char b[BDEVNAME_SIZE];
NeilBrown3cb03002011-10-11 16:45:26 +11006159 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006160
Linus Torvalds1da177e2005-04-16 15:20:36 -07006161 rdev = find_rdev(mddev, dev);
6162 if (!rdev)
6163 return -ENXIO;
6164
Goldwyn Rodrigues2910ff12015-09-28 10:27:26 -05006165 if (rdev->raid_disk < 0)
6166 goto kick_rdev;
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006167
NeilBrown3ea8929d2013-04-24 11:42:41 +10006168 clear_bit(Blocked, &rdev->flags);
6169 remove_and_add_spares(mddev, rdev);
6170
Linus Torvalds1da177e2005-04-16 15:20:36 -07006171 if (rdev->raid_disk >= 0)
6172 goto busy;
6173
Goldwyn Rodrigues2910ff12015-09-28 10:27:26 -05006174kick_rdev:
Goldwyn Rodrigues54a88392015-12-21 10:51:00 +11006175 if (mddev_is_clustered(mddev))
Goldwyn Rodrigues88bcfef2015-04-14 10:44:44 -05006176 md_cluster_ops->remove_disk(mddev, rdev);
6177
Goldwyn Rodriguesfb56dfe2015-04-14 10:43:24 -05006178 md_kick_rdev_from_array(rdev);
NeilBrown850b2b42006-10-03 01:15:46 -07006179 md_update_sb(mddev, 1);
NeilBrownd7603b72006-01-06 00:20:30 -08006180 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006181
6182 return 0;
6183busy:
Nick Andrewfdefa4d2008-04-21 22:42:58 +00006184 printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07006185 bdevname(rdev->bdev,b), mdname(mddev));
6186 return -EBUSY;
6187}
6188
NeilBrownf72ffdd2014-09-30 14:23:59 +10006189static int hot_add_disk(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006190{
6191 char b[BDEVNAME_SIZE];
6192 int err;
NeilBrown3cb03002011-10-11 16:45:26 +11006193 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006194
6195 if (!mddev->pers)
6196 return -ENODEV;
6197
6198 if (mddev->major_version != 0) {
6199 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
6200 " version-0 superblocks.\n",
6201 mdname(mddev));
6202 return -EINVAL;
6203 }
6204 if (!mddev->pers->hot_add_disk) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006205 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006206 "%s: personality does not support diskops!\n",
6207 mdname(mddev));
6208 return -EINVAL;
6209 }
6210
NeilBrownd710e132008-10-13 11:55:12 +11006211 rdev = md_import_device(dev, -1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006212 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006213 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006214 "md: error, md_import_device() returned %ld\n",
6215 PTR_ERR(rdev));
6216 return -EINVAL;
6217 }
6218
6219 if (mddev->persistent)
Jonathan Brassow57b2caa2011-01-14 09:14:33 +11006220 rdev->sb_start = calc_dev_sboffset(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006221 else
Mike Snitzer77304d22010-11-08 14:39:12 +01006222 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006223
NeilBrown8190e752009-06-18 08:48:58 +10006224 rdev->sectors = rdev->sb_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006225
NeilBrownb2d444d2005-11-08 21:39:31 -08006226 if (test_bit(Faulty, &rdev->flags)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006227 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07006228 "md: can not hot-add faulty %s disk to %s!\n",
6229 bdevname(rdev->bdev,b), mdname(mddev));
6230 err = -EINVAL;
6231 goto abort_export;
6232 }
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006233
NeilBrownb2d444d2005-11-08 21:39:31 -08006234 clear_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006235 rdev->desc_nr = -1;
NeilBrown58427302006-10-06 00:44:04 -07006236 rdev->saved_raid_disk = -1;
NeilBrown2bf071b2006-01-06 00:20:55 -08006237 err = bind_rdev_to_array(rdev, mddev);
6238 if (err)
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05006239 goto abort_export;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006240
6241 /*
6242 * The rest should better be atomic, we can have disk failures
6243 * noticed in interrupt contexts ...
6244 */
6245
Linus Torvalds1da177e2005-04-16 15:20:36 -07006246 rdev->raid_disk = -1;
6247
NeilBrown850b2b42006-10-03 01:15:46 -07006248 md_update_sb(mddev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006249 /*
6250 * Kick recovery, maybe this spare has to be added to the
6251 * array immediately.
6252 */
6253 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6254 md_wakeup_thread(mddev->thread);
NeilBrownd7603b72006-01-06 00:20:30 -08006255 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006256 return 0;
6257
Linus Torvalds1da177e2005-04-16 15:20:36 -07006258abort_export:
6259 export_rdev(rdev);
6260 return err;
6261}
6262
NeilBrownfd01b882011-10-11 16:47:53 +11006263static int set_bitmap_file(struct mddev *mddev, int fd)
NeilBrown32a76272005-06-21 17:17:14 -07006264{
NeilBrown035328c2014-04-09 12:25:40 +10006265 int err = 0;
NeilBrown32a76272005-06-21 17:17:14 -07006266
NeilBrown36fa3062005-09-09 16:23:45 -07006267 if (mddev->pers) {
NeilBrownd66b1b32014-08-08 15:40:24 +10006268 if (!mddev->pers->quiesce || !mddev->thread)
NeilBrown36fa3062005-09-09 16:23:45 -07006269 return -EBUSY;
6270 if (mddev->recovery || mddev->sync_thread)
6271 return -EBUSY;
6272 /* we should be able to change the bitmap.. */
NeilBrown32a76272005-06-21 17:17:14 -07006273 }
6274
NeilBrown36fa3062005-09-09 16:23:45 -07006275 if (fd >= 0) {
NeilBrown035328c2014-04-09 12:25:40 +10006276 struct inode *inode;
NeilBrown1e594bb2014-12-15 12:57:00 +11006277 struct file *f;
NeilBrown36fa3062005-09-09 16:23:45 -07006278
NeilBrown1e594bb2014-12-15 12:57:00 +11006279 if (mddev->bitmap || mddev->bitmap_info.file)
6280 return -EEXIST; /* cannot add when bitmap is present */
6281 f = fget(fd);
6282
6283 if (f == NULL) {
NeilBrown36fa3062005-09-09 16:23:45 -07006284 printk(KERN_ERR "%s: error: failed to get bitmap file\n",
6285 mdname(mddev));
6286 return -EBADF;
6287 }
6288
NeilBrown1e594bb2014-12-15 12:57:00 +11006289 inode = f->f_mapping->host;
NeilBrown035328c2014-04-09 12:25:40 +10006290 if (!S_ISREG(inode->i_mode)) {
6291 printk(KERN_ERR "%s: error: bitmap file must be a regular file\n",
6292 mdname(mddev));
6293 err = -EBADF;
NeilBrown1e594bb2014-12-15 12:57:00 +11006294 } else if (!(f->f_mode & FMODE_WRITE)) {
NeilBrown035328c2014-04-09 12:25:40 +10006295 printk(KERN_ERR "%s: error: bitmap file must open for write\n",
6296 mdname(mddev));
6297 err = -EBADF;
6298 } else if (atomic_read(&inode->i_writecount) != 1) {
NeilBrown36fa3062005-09-09 16:23:45 -07006299 printk(KERN_ERR "%s: error: bitmap file is already in use\n",
6300 mdname(mddev));
NeilBrown035328c2014-04-09 12:25:40 +10006301 err = -EBUSY;
6302 }
6303 if (err) {
NeilBrown1e594bb2014-12-15 12:57:00 +11006304 fput(f);
NeilBrown36fa3062005-09-09 16:23:45 -07006305 return err;
6306 }
NeilBrown1e594bb2014-12-15 12:57:00 +11006307 mddev->bitmap_info.file = f;
NeilBrownc3d97142009-12-14 12:49:52 +11006308 mddev->bitmap_info.offset = 0; /* file overrides offset */
NeilBrown36fa3062005-09-09 16:23:45 -07006309 } else if (mddev->bitmap == NULL)
6310 return -ENOENT; /* cannot remove what isn't there */
6311 err = 0;
6312 if (mddev->pers) {
6313 mddev->pers->quiesce(mddev, 1);
NeilBrown69e51b42010-06-01 19:37:35 +10006314 if (fd >= 0) {
Goldwyn Rodriguesf9209a32014-06-06 12:43:49 -05006315 struct bitmap *bitmap;
6316
6317 bitmap = bitmap_create(mddev, -1);
6318 if (!IS_ERR(bitmap)) {
6319 mddev->bitmap = bitmap;
NeilBrown69e51b42010-06-01 19:37:35 +10006320 err = bitmap_load(mddev);
NeilBrownba599ac2015-02-25 11:44:11 +11006321 } else
6322 err = PTR_ERR(bitmap);
NeilBrown69e51b42010-06-01 19:37:35 +10006323 }
NeilBrownd7375ab2006-06-26 00:27:43 -07006324 if (fd < 0 || err) {
NeilBrown36fa3062005-09-09 16:23:45 -07006325 bitmap_destroy(mddev);
NeilBrownd7375ab2006-06-26 00:27:43 -07006326 fd = -1; /* make sure to put the file */
6327 }
NeilBrown36fa3062005-09-09 16:23:45 -07006328 mddev->pers->quiesce(mddev, 0);
NeilBrownd7375ab2006-06-26 00:27:43 -07006329 }
6330 if (fd < 0) {
NeilBrown4af1a042014-12-15 12:57:00 +11006331 struct file *f = mddev->bitmap_info.file;
6332 if (f) {
6333 spin_lock(&mddev->lock);
6334 mddev->bitmap_info.file = NULL;
6335 spin_unlock(&mddev->lock);
6336 fput(f);
6337 }
NeilBrown36fa3062005-09-09 16:23:45 -07006338 }
6339
NeilBrown32a76272005-06-21 17:17:14 -07006340 return err;
6341}
6342
Linus Torvalds1da177e2005-04-16 15:20:36 -07006343/*
6344 * set_array_info is used two different ways
6345 * The original usage is when creating a new array.
6346 * In this usage, raid_disks is > 0 and it together with
6347 * level, size, not_persistent,layout,chunksize determine the
6348 * shape of the array.
6349 * This will always create an array with a type-0.90.0 superblock.
6350 * The newer usage is when assembling an array.
6351 * In this case raid_disks will be 0, and the major_version field is
6352 * use to determine which style super-blocks are to be found on the devices.
6353 * The minor and patch _version numbers are also kept incase the
6354 * super_block handler wishes to interpret them.
6355 */
NeilBrownf72ffdd2014-09-30 14:23:59 +10006356static int set_array_info(struct mddev *mddev, mdu_array_info_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006357{
6358
6359 if (info->raid_disks == 0) {
6360 /* just setting version number for superblock loading */
6361 if (info->major_version < 0 ||
Ahmed S. Darwish50511da2007-05-09 02:35:34 -07006362 info->major_version >= ARRAY_SIZE(super_types) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07006363 super_types[info->major_version].name == NULL) {
6364 /* maybe try to auto-load a module? */
NeilBrownf72ffdd2014-09-30 14:23:59 +10006365 printk(KERN_INFO
Linus Torvalds1da177e2005-04-16 15:20:36 -07006366 "md: superblock version %d not known\n",
6367 info->major_version);
6368 return -EINVAL;
6369 }
6370 mddev->major_version = info->major_version;
6371 mddev->minor_version = info->minor_version;
6372 mddev->patch_version = info->patch_version;
NeilBrown3f9d7b02006-12-22 01:11:41 -08006373 mddev->persistent = !info->not_persistent;
NeilBrowncbd19982009-12-30 12:08:49 +11006374 /* ensure mddev_put doesn't delete this now that there
6375 * is some minimal configuration.
6376 */
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11006377 mddev->ctime = ktime_get_real_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07006378 return 0;
6379 }
6380 mddev->major_version = MD_MAJOR_VERSION;
6381 mddev->minor_version = MD_MINOR_VERSION;
6382 mddev->patch_version = MD_PATCHLEVEL_VERSION;
Deepa Dinamani9ebc6ef2015-12-21 10:51:01 +11006383 mddev->ctime = ktime_get_real_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07006384
6385 mddev->level = info->level;
NeilBrown17115e02006-01-16 22:14:57 -08006386 mddev->clevel[0] = 0;
Andre Noll58c0fed2009-03-31 14:33:13 +11006387 mddev->dev_sectors = 2 * (sector_t)info->size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006388 mddev->raid_disks = info->raid_disks;
6389 /* don't set md_minor, it is determined by which /dev/md* was
6390 * openned
6391 */
6392 if (info->state & (1<<MD_SB_CLEAN))
6393 mddev->recovery_cp = MaxSector;
6394 else
6395 mddev->recovery_cp = 0;
6396 mddev->persistent = ! info->not_persistent;
NeilBrowne6910632008-02-06 01:39:51 -08006397 mddev->external = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006398
6399 mddev->layout = info->layout;
Andre Noll9d8f0362009-06-18 08:45:01 +10006400 mddev->chunk_sectors = info->chunk_size >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006401
6402 mddev->max_disks = MD_SB_DISKS;
6403
NeilBrowne6910632008-02-06 01:39:51 -08006404 if (mddev->persistent)
6405 mddev->flags = 0;
NeilBrown850b2b42006-10-03 01:15:46 -07006406 set_bit(MD_CHANGE_DEVS, &mddev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006407
NeilBrownc3d97142009-12-14 12:49:52 +11006408 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
NeilBrown6409bb02012-05-22 13:55:07 +10006409 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
NeilBrownc3d97142009-12-14 12:49:52 +11006410 mddev->bitmap_info.offset = 0;
NeilBrownb2a27032005-11-28 13:44:12 -08006411
NeilBrownf6705572006-03-27 01:18:11 -08006412 mddev->reshape_position = MaxSector;
6413
Linus Torvalds1da177e2005-04-16 15:20:36 -07006414 /*
6415 * Generate a 128 bit UUID
6416 */
6417 get_random_bytes(mddev->uuid, 16);
6418
NeilBrownf6705572006-03-27 01:18:11 -08006419 mddev->new_level = mddev->level;
Andre Noll664e7c42009-06-18 08:45:27 +10006420 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownf6705572006-03-27 01:18:11 -08006421 mddev->new_layout = mddev->layout;
6422 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10006423 mddev->reshape_backwards = 0;
NeilBrownf6705572006-03-27 01:18:11 -08006424
Linus Torvalds1da177e2005-04-16 15:20:36 -07006425 return 0;
6426}
6427
NeilBrownfd01b882011-10-11 16:47:53 +11006428void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
Dan Williams1f403622009-03-31 14:59:03 +11006429{
Dan Williamsb522adc2009-03-31 15:00:31 +11006430 WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);
6431
6432 if (mddev->external_size)
6433 return;
6434
Dan Williams1f403622009-03-31 14:59:03 +11006435 mddev->array_sectors = array_sectors;
6436}
6437EXPORT_SYMBOL(md_set_array_sectors);
6438
NeilBrownfd01b882011-10-11 16:47:53 +11006439static int update_size(struct mddev *mddev, sector_t num_sectors)
NeilBrowna35b0d62006-01-06 00:20:49 -08006440{
NeilBrown3cb03002011-10-11 16:45:26 +11006441 struct md_rdev *rdev;
NeilBrowna35b0d62006-01-06 00:20:49 -08006442 int rv;
Andre Nolld71f9f82008-07-11 22:02:22 +10006443 int fit = (num_sectors == 0);
NeilBrowna35b0d62006-01-06 00:20:49 -08006444
Guoqing Jiangab5a98b2016-05-02 11:33:13 -04006445 /* cluster raid doesn't support update size */
6446 if (mddev_is_clustered(mddev))
6447 return -EINVAL;
6448
NeilBrowna35b0d62006-01-06 00:20:49 -08006449 if (mddev->pers->resize == NULL)
6450 return -EINVAL;
Andre Nolld71f9f82008-07-11 22:02:22 +10006451 /* The "num_sectors" is the number of sectors of each device that
6452 * is used. This can only make sense for arrays with redundancy.
6453 * linear and raid0 always use whatever space is available. We can only
6454 * consider changing this number if no resync or reconstruction is
6455 * happening, and if the new size is acceptable. It must fit before the
Andre Noll0f420352008-07-11 22:02:23 +10006456 * sb_start or, if that is <data_offset, it must fit before the size
Andre Nolld71f9f82008-07-11 22:02:22 +10006457 * of each device. If num_sectors is zero, we find the largest size
6458 * that fits.
NeilBrowna35b0d62006-01-06 00:20:49 -08006459 */
NeilBrownf851b602014-12-11 10:02:10 +11006460 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
6461 mddev->sync_thread)
NeilBrowna35b0d62006-01-06 00:20:49 -08006462 return -EBUSY;
NeilBrownbd8839e2014-05-28 13:39:21 +10006463 if (mddev->ro)
6464 return -EROFS;
NeilBrowna4a61252012-05-22 13:55:27 +10006465
NeilBrowndafb20f2012-03-19 12:46:39 +11006466 rdev_for_each(rdev, mddev) {
Andre Nolldd8ac332009-03-31 14:33:13 +11006467 sector_t avail = rdev->sectors;
NeilBrown01ab5662006-10-28 10:38:30 -07006468
Andre Nolld71f9f82008-07-11 22:02:22 +10006469 if (fit && (num_sectors == 0 || num_sectors > avail))
6470 num_sectors = avail;
6471 if (avail < num_sectors)
NeilBrowna35b0d62006-01-06 00:20:49 -08006472 return -ENOSPC;
6473 }
Andre Nolld71f9f82008-07-11 22:02:22 +10006474 rv = mddev->pers->resize(mddev, num_sectors);
NeilBrown449aad32009-08-03 10:59:58 +10006475 if (!rv)
6476 revalidate_disk(mddev->gendisk);
NeilBrowna35b0d62006-01-06 00:20:49 -08006477 return rv;
6478}
6479
NeilBrownfd01b882011-10-11 16:47:53 +11006480static int update_raid_disks(struct mddev *mddev, int raid_disks)
NeilBrownda943b992006-01-06 00:20:54 -08006481{
6482 int rv;
NeilBrownc6563a82012-05-21 09:27:00 +10006483 struct md_rdev *rdev;
NeilBrownda943b992006-01-06 00:20:54 -08006484 /* change the number of raid disks */
NeilBrown63c70c42006-03-27 01:18:13 -08006485 if (mddev->pers->check_reshape == NULL)
NeilBrownda943b992006-01-06 00:20:54 -08006486 return -EINVAL;
NeilBrownbd8839e2014-05-28 13:39:21 +10006487 if (mddev->ro)
6488 return -EROFS;
NeilBrownda943b992006-01-06 00:20:54 -08006489 if (raid_disks <= 0 ||
NeilBrown233fca32010-04-14 17:02:09 +10006490 (mddev->max_disks && raid_disks >= mddev->max_disks))
NeilBrownda943b992006-01-06 00:20:54 -08006491 return -EINVAL;
NeilBrownf851b602014-12-11 10:02:10 +11006492 if (mddev->sync_thread ||
6493 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
6494 mddev->reshape_position != MaxSector)
NeilBrownda943b992006-01-06 00:20:54 -08006495 return -EBUSY;
NeilBrownc6563a82012-05-21 09:27:00 +10006496
6497 rdev_for_each(rdev, mddev) {
6498 if (mddev->raid_disks < raid_disks &&
6499 rdev->data_offset < rdev->new_data_offset)
6500 return -EINVAL;
6501 if (mddev->raid_disks > raid_disks &&
6502 rdev->data_offset > rdev->new_data_offset)
6503 return -EINVAL;
6504 }
6505
NeilBrown63c70c42006-03-27 01:18:13 -08006506 mddev->delta_disks = raid_disks - mddev->raid_disks;
NeilBrown2c810cd2012-05-21 09:27:00 +10006507 if (mddev->delta_disks < 0)
6508 mddev->reshape_backwards = 1;
6509 else if (mddev->delta_disks > 0)
6510 mddev->reshape_backwards = 0;
NeilBrown63c70c42006-03-27 01:18:13 -08006511
6512 rv = mddev->pers->check_reshape(mddev);
NeilBrown2c810cd2012-05-21 09:27:00 +10006513 if (rv < 0) {
NeilBrownde171cb2011-01-31 11:57:42 +11006514 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10006515 mddev->reshape_backwards = 0;
6516 }
NeilBrownda943b992006-01-06 00:20:54 -08006517 return rv;
6518}
6519
Linus Torvalds1da177e2005-04-16 15:20:36 -07006520/*
6521 * update_array_info is used to change the configuration of an
6522 * on-line array.
6523 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
6524 * fields in the info are checked against the array.
6525 * Any differences that cannot be handled will cause an error.
6526 * Normally, only one change can be managed at a time.
6527 */
NeilBrownfd01b882011-10-11 16:47:53 +11006528static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006529{
6530 int rv = 0;
6531 int cnt = 0;
NeilBrown36fa3062005-09-09 16:23:45 -07006532 int state = 0;
6533
6534 /* calculate expected state,ignoring low bits */
NeilBrownc3d97142009-12-14 12:49:52 +11006535 if (mddev->bitmap && mddev->bitmap_info.offset)
NeilBrown36fa3062005-09-09 16:23:45 -07006536 state |= (1 << MD_SB_BITMAP_PRESENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006537
6538 if (mddev->major_version != info->major_version ||
6539 mddev->minor_version != info->minor_version ||
6540/* mddev->patch_version != info->patch_version || */
6541 mddev->ctime != info->ctime ||
6542 mddev->level != info->level ||
6543/* mddev->layout != info->layout || */
Firo Yang4e023612015-06-11 09:41:10 +08006544 mddev->persistent != !info->not_persistent ||
Andre Noll9d8f0362009-06-18 08:45:01 +10006545 mddev->chunk_sectors != info->chunk_size >> 9 ||
NeilBrown36fa3062005-09-09 16:23:45 -07006546 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
6547 ((state^info->state) & 0xfffffe00)
6548 )
Linus Torvalds1da177e2005-04-16 15:20:36 -07006549 return -EINVAL;
6550 /* Check there is only one change */
Andre Noll58c0fed2009-03-31 14:33:13 +11006551 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
6552 cnt++;
6553 if (mddev->raid_disks != info->raid_disks)
6554 cnt++;
6555 if (mddev->layout != info->layout)
6556 cnt++;
6557 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
6558 cnt++;
6559 if (cnt == 0)
6560 return 0;
6561 if (cnt > 1)
6562 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006563
6564 if (mddev->layout != info->layout) {
6565 /* Change layout
6566 * we don't need to do anything at the md level, the
6567 * personality will take care of it all.
6568 */
NeilBrown50ac1682009-06-18 08:47:55 +10006569 if (mddev->pers->check_reshape == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006570 return -EINVAL;
NeilBrown597a7112009-06-18 08:47:42 +10006571 else {
6572 mddev->new_layout = info->layout;
NeilBrown50ac1682009-06-18 08:47:55 +10006573 rv = mddev->pers->check_reshape(mddev);
NeilBrown597a7112009-06-18 08:47:42 +10006574 if (rv)
6575 mddev->new_layout = mddev->layout;
6576 return rv;
6577 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006578 }
Andre Noll58c0fed2009-03-31 14:33:13 +11006579 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
Andre Nolld71f9f82008-07-11 22:02:22 +10006580 rv = update_size(mddev, (sector_t)info->size * 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006581
NeilBrownda943b992006-01-06 00:20:54 -08006582 if (mddev->raid_disks != info->raid_disks)
6583 rv = update_raid_disks(mddev, info->raid_disks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006584
NeilBrown36fa3062005-09-09 16:23:45 -07006585 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006586 if (mddev->pers->quiesce == NULL || mddev->thread == NULL) {
6587 rv = -EINVAL;
6588 goto err;
6589 }
6590 if (mddev->recovery || mddev->sync_thread) {
6591 rv = -EBUSY;
6592 goto err;
6593 }
NeilBrown36fa3062005-09-09 16:23:45 -07006594 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
Goldwyn Rodriguesf9209a32014-06-06 12:43:49 -05006595 struct bitmap *bitmap;
NeilBrown36fa3062005-09-09 16:23:45 -07006596 /* add the bitmap */
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006597 if (mddev->bitmap) {
6598 rv = -EEXIST;
6599 goto err;
6600 }
6601 if (mddev->bitmap_info.default_offset == 0) {
6602 rv = -EINVAL;
6603 goto err;
6604 }
NeilBrownc3d97142009-12-14 12:49:52 +11006605 mddev->bitmap_info.offset =
6606 mddev->bitmap_info.default_offset;
NeilBrown6409bb02012-05-22 13:55:07 +10006607 mddev->bitmap_info.space =
6608 mddev->bitmap_info.default_space;
NeilBrown36fa3062005-09-09 16:23:45 -07006609 mddev->pers->quiesce(mddev, 1);
Goldwyn Rodriguesf9209a32014-06-06 12:43:49 -05006610 bitmap = bitmap_create(mddev, -1);
6611 if (!IS_ERR(bitmap)) {
6612 mddev->bitmap = bitmap;
NeilBrown69e51b42010-06-01 19:37:35 +10006613 rv = bitmap_load(mddev);
NeilBrownba599ac2015-02-25 11:44:11 +11006614 } else
6615 rv = PTR_ERR(bitmap);
NeilBrown36fa3062005-09-09 16:23:45 -07006616 if (rv)
6617 bitmap_destroy(mddev);
6618 mddev->pers->quiesce(mddev, 0);
6619 } else {
6620 /* remove the bitmap */
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006621 if (!mddev->bitmap) {
6622 rv = -ENOENT;
6623 goto err;
6624 }
6625 if (mddev->bitmap->storage.file) {
6626 rv = -EINVAL;
6627 goto err;
6628 }
Guoqing Jiangf6a2dc62015-12-21 10:51:00 +11006629 if (mddev->bitmap_info.nodes) {
6630 /* hold PW on all the bitmap lock */
6631 if (md_cluster_ops->lock_all_bitmaps(mddev) <= 0) {
6632 printk("md: can't change bitmap to none since the"
6633 " array is in use by more than one node\n");
6634 rv = -EPERM;
6635 md_cluster_ops->unlock_all_bitmaps(mddev);
6636 goto err;
6637 }
6638
6639 mddev->bitmap_info.nodes = 0;
6640 md_cluster_ops->leave(mddev);
6641 }
NeilBrown36fa3062005-09-09 16:23:45 -07006642 mddev->pers->quiesce(mddev, 1);
6643 bitmap_destroy(mddev);
6644 mddev->pers->quiesce(mddev, 0);
NeilBrownc3d97142009-12-14 12:49:52 +11006645 mddev->bitmap_info.offset = 0;
NeilBrown36fa3062005-09-09 16:23:45 -07006646 }
6647 }
NeilBrown850b2b42006-10-03 01:15:46 -07006648 md_update_sb(mddev, 1);
Goldwyn Rodrigues293467a2014-06-07 01:44:51 -05006649 return rv;
6650err:
Linus Torvalds1da177e2005-04-16 15:20:36 -07006651 return rv;
6652}
6653
NeilBrownfd01b882011-10-11 16:47:53 +11006654static int set_disk_faulty(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006655{
NeilBrown3cb03002011-10-11 16:45:26 +11006656 struct md_rdev *rdev;
NeilBrown1ca69c42012-10-11 13:37:33 +11006657 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006658
6659 if (mddev->pers == NULL)
6660 return -ENODEV;
6661
NeilBrown1ca69c42012-10-11 13:37:33 +11006662 rcu_read_lock();
6663 rdev = find_rdev_rcu(mddev, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006664 if (!rdev)
NeilBrown1ca69c42012-10-11 13:37:33 +11006665 err = -ENODEV;
6666 else {
6667 md_error(mddev, rdev);
6668 if (!test_bit(Faulty, &rdev->flags))
6669 err = -EBUSY;
6670 }
6671 rcu_read_unlock();
6672 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006673}
6674
Andre Noll2f9618c2008-04-25 18:57:58 +02006675/*
6676 * We have a problem here : there is no easy way to give a CHS
6677 * virtual geometry. We currently pretend that we have a 2 heads
6678 * 4 sectors (with a BIG number of cylinders...). This drives
6679 * dosfs just mad... ;-)
6680 */
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08006681static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
6682{
NeilBrownfd01b882011-10-11 16:47:53 +11006683 struct mddev *mddev = bdev->bd_disk->private_data;
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08006684
6685 geo->heads = 2;
6686 geo->sectors = 4;
NeilBrown49ce6ce2010-03-29 10:51:42 +11006687 geo->cylinders = mddev->array_sectors / 8;
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08006688 return 0;
6689}
6690
Nicolas Schichancb335f82014-01-15 16:58:52 +01006691static inline bool md_ioctl_valid(unsigned int cmd)
6692{
6693 switch (cmd) {
6694 case ADD_NEW_DISK:
6695 case BLKROSET:
6696 case GET_ARRAY_INFO:
6697 case GET_BITMAP_FILE:
6698 case GET_DISK_INFO:
6699 case HOT_ADD_DISK:
6700 case HOT_REMOVE_DISK:
Nicolas Schichancb335f82014-01-15 16:58:52 +01006701 case RAID_AUTORUN:
6702 case RAID_VERSION:
6703 case RESTART_ARRAY_RW:
6704 case RUN_ARRAY:
6705 case SET_ARRAY_INFO:
6706 case SET_BITMAP_FILE:
6707 case SET_DISK_FAULTY:
6708 case STOP_ARRAY:
6709 case STOP_ARRAY_RO:
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006710 case CLUSTERED_DISK_NACK:
Nicolas Schichancb335f82014-01-15 16:58:52 +01006711 return true;
6712 default:
6713 return false;
6714 }
6715}
6716
Al Viroa39907f2008-03-02 10:31:15 -05006717static int md_ioctl(struct block_device *bdev, fmode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07006718 unsigned int cmd, unsigned long arg)
6719{
6720 int err = 0;
6721 void __user *argp = (void __user *)arg;
NeilBrownfd01b882011-10-11 16:47:53 +11006722 struct mddev *mddev = NULL;
Dan Williamse2218352010-05-12 08:25:37 +10006723 int ro;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006724
Nicolas Schichancb335f82014-01-15 16:58:52 +01006725 if (!md_ioctl_valid(cmd))
6726 return -ENOTTY;
6727
NeilBrown506c9e42011-12-23 10:17:26 +11006728 switch (cmd) {
6729 case RAID_VERSION:
6730 case GET_ARRAY_INFO:
6731 case GET_DISK_INFO:
6732 break;
6733 default:
6734 if (!capable(CAP_SYS_ADMIN))
6735 return -EACCES;
6736 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006737
6738 /*
6739 * Commands dealing with the RAID driver but not any
6740 * particular array:
6741 */
NeilBrownc02c0ae2012-12-11 13:39:21 +11006742 switch (cmd) {
6743 case RAID_VERSION:
6744 err = get_version(argp);
NeilBrown3adc28d2014-09-30 15:46:41 +10006745 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006746
Linus Torvalds1da177e2005-04-16 15:20:36 -07006747#ifndef MODULE
NeilBrownc02c0ae2012-12-11 13:39:21 +11006748 case RAID_AUTORUN:
6749 err = 0;
6750 autostart_arrays(arg);
NeilBrown3adc28d2014-09-30 15:46:41 +10006751 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006752#endif
NeilBrownc02c0ae2012-12-11 13:39:21 +11006753 default:;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006754 }
6755
6756 /*
6757 * Commands creating/starting a new array:
6758 */
6759
Al Viroa39907f2008-03-02 10:31:15 -05006760 mddev = bdev->bd_disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006761
6762 if (!mddev) {
6763 BUG();
NeilBrown3adc28d2014-09-30 15:46:41 +10006764 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006765 }
6766
NeilBrown1ca69c42012-10-11 13:37:33 +11006767 /* Some actions do not requires the mutex */
6768 switch (cmd) {
6769 case GET_ARRAY_INFO:
6770 if (!mddev->raid_disks && !mddev->external)
6771 err = -ENODEV;
6772 else
6773 err = get_array_info(mddev, argp);
NeilBrown3adc28d2014-09-30 15:46:41 +10006774 goto out;
NeilBrown1ca69c42012-10-11 13:37:33 +11006775
6776 case GET_DISK_INFO:
6777 if (!mddev->raid_disks && !mddev->external)
6778 err = -ENODEV;
6779 else
6780 err = get_disk_info(mddev, argp);
NeilBrown3adc28d2014-09-30 15:46:41 +10006781 goto out;
NeilBrown1ca69c42012-10-11 13:37:33 +11006782
6783 case SET_DISK_FAULTY:
6784 err = set_disk_faulty(mddev, new_decode_dev(arg));
NeilBrown3adc28d2014-09-30 15:46:41 +10006785 goto out;
NeilBrown4af1a042014-12-15 12:57:00 +11006786
6787 case GET_BITMAP_FILE:
6788 err = get_bitmap_file(mddev, argp);
6789 goto out;
6790
NeilBrown1ca69c42012-10-11 13:37:33 +11006791 }
6792
NeilBrowna7a3f082012-12-11 13:35:54 +11006793 if (cmd == ADD_NEW_DISK)
6794 /* need to ensure md_delayed_delete() has completed */
6795 flush_workqueue(md_misc_wq);
6796
Hannes Reinecke90f5f7a2013-04-02 08:38:55 +02006797 if (cmd == HOT_REMOVE_DISK)
6798 /* need to ensure recovery thread has run */
6799 wait_event_interruptible_timeout(mddev->sb_wait,
6800 !test_bit(MD_RECOVERY_NEEDED,
6801 &mddev->flags),
6802 msecs_to_jiffies(5000));
NeilBrown260fa032013-08-27 16:44:13 +10006803 if (cmd == STOP_ARRAY || cmd == STOP_ARRAY_RO) {
6804 /* Need to flush page cache, and ensure no-one else opens
6805 * and writes
6806 */
6807 mutex_lock(&mddev->open_mutex);
NeilBrown9ba3b7f2014-09-09 14:00:15 +10006808 if (mddev->pers && atomic_read(&mddev->openers) > 1) {
NeilBrown260fa032013-08-27 16:44:13 +10006809 mutex_unlock(&mddev->open_mutex);
6810 err = -EBUSY;
NeilBrown3adc28d2014-09-30 15:46:41 +10006811 goto out;
NeilBrown260fa032013-08-27 16:44:13 +10006812 }
6813 set_bit(MD_STILL_CLOSED, &mddev->flags);
6814 mutex_unlock(&mddev->open_mutex);
6815 sync_blockdev(bdev);
6816 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006817 err = mddev_lock(mddev);
6818 if (err) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006819 printk(KERN_INFO
Linus Torvalds1da177e2005-04-16 15:20:36 -07006820 "md: ioctl lock interrupted, reason %d, cmd %d\n",
6821 err, cmd);
NeilBrown3adc28d2014-09-30 15:46:41 +10006822 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006823 }
6824
NeilBrownc02c0ae2012-12-11 13:39:21 +11006825 if (cmd == SET_ARRAY_INFO) {
6826 mdu_array_info_t info;
6827 if (!arg)
6828 memset(&info, 0, sizeof(info));
6829 else if (copy_from_user(&info, argp, sizeof(info))) {
6830 err = -EFAULT;
NeilBrown3adc28d2014-09-30 15:46:41 +10006831 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006832 }
6833 if (mddev->pers) {
6834 err = update_array_info(mddev, &info);
6835 if (err) {
6836 printk(KERN_WARNING "md: couldn't update"
6837 " array info. %d\n", err);
NeilBrown3adc28d2014-09-30 15:46:41 +10006838 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006839 }
NeilBrown3adc28d2014-09-30 15:46:41 +10006840 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006841 }
6842 if (!list_empty(&mddev->disks)) {
6843 printk(KERN_WARNING
6844 "md: array %s already has disks!\n",
6845 mdname(mddev));
6846 err = -EBUSY;
NeilBrown3adc28d2014-09-30 15:46:41 +10006847 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006848 }
6849 if (mddev->raid_disks) {
6850 printk(KERN_WARNING
6851 "md: array %s already initialised!\n",
6852 mdname(mddev));
6853 err = -EBUSY;
NeilBrown3adc28d2014-09-30 15:46:41 +10006854 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006855 }
6856 err = set_array_info(mddev, &info);
6857 if (err) {
6858 printk(KERN_WARNING "md: couldn't set"
6859 " array info. %d\n", err);
NeilBrown3adc28d2014-09-30 15:46:41 +10006860 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006861 }
NeilBrown3adc28d2014-09-30 15:46:41 +10006862 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006863 }
6864
6865 /*
6866 * Commands querying/configuring an existing array:
6867 */
NeilBrown32a76272005-06-21 17:17:14 -07006868 /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
NeilBrown3f9d7b02006-12-22 01:11:41 -08006869 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
NeilBrowna17184a2008-02-06 01:39:55 -08006870 if ((!mddev->raid_disks && !mddev->external)
6871 && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
6872 && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
6873 && cmd != GET_BITMAP_FILE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006874 err = -ENODEV;
NeilBrown3adc28d2014-09-30 15:46:41 +10006875 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006876 }
6877
6878 /*
6879 * Commands even a read-only array can execute:
6880 */
NeilBrownc02c0ae2012-12-11 13:39:21 +11006881 switch (cmd) {
NeilBrownc02c0ae2012-12-11 13:39:21 +11006882 case RESTART_ARRAY_RW:
6883 err = restart_array(mddev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006884 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006885
6886 case STOP_ARRAY:
6887 err = do_md_stop(mddev, 0, bdev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006888 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006889
6890 case STOP_ARRAY_RO:
6891 err = md_set_readonly(mddev, bdev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006892 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006893
NeilBrown3ea8929d2013-04-24 11:42:41 +10006894 case HOT_REMOVE_DISK:
6895 err = hot_remove_disk(mddev, new_decode_dev(arg));
NeilBrown3adc28d2014-09-30 15:46:41 +10006896 goto unlock;
NeilBrown3ea8929d2013-04-24 11:42:41 +10006897
NeilBrown7ceb17e2013-04-24 11:42:42 +10006898 case ADD_NEW_DISK:
6899 /* We can support ADD_NEW_DISK on read-only arrays
Wei Fang466ad292016-03-21 19:19:30 +08006900 * only if we are re-adding a preexisting device.
NeilBrown7ceb17e2013-04-24 11:42:42 +10006901 * So require mddev->pers and MD_DISK_SYNC.
6902 */
6903 if (mddev->pers) {
6904 mdu_disk_info_t info;
6905 if (copy_from_user(&info, argp, sizeof(info)))
6906 err = -EFAULT;
6907 else if (!(info.state & (1<<MD_DISK_SYNC)))
6908 /* Need to clear read-only for this */
6909 break;
6910 else
6911 err = add_new_disk(mddev, &info);
NeilBrown3adc28d2014-09-30 15:46:41 +10006912 goto unlock;
NeilBrown7ceb17e2013-04-24 11:42:42 +10006913 }
6914 break;
6915
NeilBrownc02c0ae2012-12-11 13:39:21 +11006916 case BLKROSET:
6917 if (get_user(ro, (int __user *)(arg))) {
6918 err = -EFAULT;
NeilBrown3adc28d2014-09-30 15:46:41 +10006919 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006920 }
6921 err = -EINVAL;
6922
6923 /* if the bdev is going readonly the value of mddev->ro
6924 * does not matter, no writes are coming
6925 */
6926 if (ro)
NeilBrown3adc28d2014-09-30 15:46:41 +10006927 goto unlock;
NeilBrown32a76272005-06-21 17:17:14 -07006928
NeilBrownc02c0ae2012-12-11 13:39:21 +11006929 /* are we are already prepared for writes? */
6930 if (mddev->ro != 1)
NeilBrown3adc28d2014-09-30 15:46:41 +10006931 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006932
6933 /* transitioning to readauto need only happen for
6934 * arrays that call md_write_start
6935 */
6936 if (mddev->pers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006937 err = restart_array(mddev);
NeilBrownc02c0ae2012-12-11 13:39:21 +11006938 if (err == 0) {
6939 mddev->ro = 2;
6940 set_disk_ro(mddev->gendisk, 0);
Dan Williamse2218352010-05-12 08:25:37 +10006941 }
NeilBrownc02c0ae2012-12-11 13:39:21 +11006942 }
NeilBrown3adc28d2014-09-30 15:46:41 +10006943 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006944 }
6945
6946 /*
6947 * The remaining ioctls are changing the state of the
NeilBrownf91de922005-11-08 21:39:36 -08006948 * superblock, so we do not allow them on read-only arrays.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006949 */
NeilBrown326eb172014-09-30 15:36:28 +10006950 if (mddev->ro && mddev->pers) {
NeilBrownf91de922005-11-08 21:39:36 -08006951 if (mddev->ro == 2) {
6952 mddev->ro = 0;
NeilBrown00bcb4a2010-06-01 19:37:23 +10006953 sysfs_notify_dirent_safe(mddev->sysfs_state);
Neil Brown0fd62b82008-06-28 08:31:36 +10006954 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrownf3378b42013-02-28 11:59:03 +11006955 /* mddev_unlock will wake thread */
6956 /* If a device failed while we were read-only, we
6957 * need to make sure the metadata is updated now.
6958 */
6959 if (test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
6960 mddev_unlock(mddev);
6961 wait_event(mddev->sb_wait,
6962 !test_bit(MD_CHANGE_DEVS, &mddev->flags) &&
6963 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
NeilBrown29f097c2013-11-14 17:54:51 +11006964 mddev_lock_nointr(mddev);
NeilBrownf3378b42013-02-28 11:59:03 +11006965 }
NeilBrownf91de922005-11-08 21:39:36 -08006966 } else {
6967 err = -EROFS;
NeilBrown3adc28d2014-09-30 15:46:41 +10006968 goto unlock;
NeilBrownf91de922005-11-08 21:39:36 -08006969 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006970 }
6971
NeilBrownc02c0ae2012-12-11 13:39:21 +11006972 switch (cmd) {
6973 case ADD_NEW_DISK:
Linus Torvalds1da177e2005-04-16 15:20:36 -07006974 {
NeilBrownc02c0ae2012-12-11 13:39:21 +11006975 mdu_disk_info_t info;
6976 if (copy_from_user(&info, argp, sizeof(info)))
6977 err = -EFAULT;
6978 else
6979 err = add_new_disk(mddev, &info);
NeilBrown3adc28d2014-09-30 15:46:41 +10006980 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006981 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006982
Goldwyn Rodrigues1aee41f2014-10-29 18:51:31 -05006983 case CLUSTERED_DISK_NACK:
6984 if (mddev_is_clustered(mddev))
6985 md_cluster_ops->new_disk_ack(mddev, false);
6986 else
6987 err = -EINVAL;
6988 goto unlock;
6989
NeilBrownc02c0ae2012-12-11 13:39:21 +11006990 case HOT_ADD_DISK:
6991 err = hot_add_disk(mddev, new_decode_dev(arg));
NeilBrown3adc28d2014-09-30 15:46:41 +10006992 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006993
NeilBrownc02c0ae2012-12-11 13:39:21 +11006994 case RUN_ARRAY:
6995 err = do_md_run(mddev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006996 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006997
NeilBrownc02c0ae2012-12-11 13:39:21 +11006998 case SET_BITMAP_FILE:
6999 err = set_bitmap_file(mddev, (int)arg);
NeilBrown3adc28d2014-09-30 15:46:41 +10007000 goto unlock;
NeilBrown32a76272005-06-21 17:17:14 -07007001
NeilBrownc02c0ae2012-12-11 13:39:21 +11007002 default:
7003 err = -EINVAL;
NeilBrown3adc28d2014-09-30 15:46:41 +10007004 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007005 }
7006
NeilBrown3adc28d2014-09-30 15:46:41 +10007007unlock:
NeilBrownd3374822009-01-09 08:31:10 +11007008 if (mddev->hold_active == UNTIL_IOCTL &&
7009 err != -EINVAL)
7010 mddev->hold_active = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007011 mddev_unlock(mddev);
NeilBrown3adc28d2014-09-30 15:46:41 +10007012out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07007013 return err;
7014}
Arnd Bergmannaa98aa32009-12-14 12:50:05 +11007015#ifdef CONFIG_COMPAT
7016static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
7017 unsigned int cmd, unsigned long arg)
7018{
7019 switch (cmd) {
7020 case HOT_REMOVE_DISK:
7021 case HOT_ADD_DISK:
7022 case SET_DISK_FAULTY:
7023 case SET_BITMAP_FILE:
7024 /* These take in integer arg, do not convert */
7025 break;
7026 default:
7027 arg = (unsigned long)compat_ptr(arg);
7028 break;
7029 }
7030
7031 return md_ioctl(bdev, mode, cmd, arg);
7032}
7033#endif /* CONFIG_COMPAT */
Linus Torvalds1da177e2005-04-16 15:20:36 -07007034
Al Viroa39907f2008-03-02 10:31:15 -05007035static int md_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007036{
7037 /*
7038 * Succeed if we can lock the mddev, which confirms that
7039 * it isn't being stopped right now.
7040 */
NeilBrownfd01b882011-10-11 16:47:53 +11007041 struct mddev *mddev = mddev_find(bdev->bd_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007042 int err;
7043
Yuanhan Liu0c098222012-05-22 13:55:32 +10007044 if (!mddev)
7045 return -ENODEV;
7046
NeilBrownd3374822009-01-09 08:31:10 +11007047 if (mddev->gendisk != bdev->bd_disk) {
7048 /* we are racing with mddev_put which is discarding this
7049 * bd_disk.
7050 */
7051 mddev_put(mddev);
7052 /* Wait until bdev->bd_disk is definitely gone */
Tejun Heoe804ac72010-10-15 15:36:08 +02007053 flush_workqueue(md_misc_wq);
NeilBrownd3374822009-01-09 08:31:10 +11007054 /* Then retry the open from the top */
7055 return -ERESTARTSYS;
7056 }
7057 BUG_ON(mddev != bdev->bd_disk->private_data);
7058
NeilBrownc8c00a62009-08-10 12:50:52 +10007059 if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07007060 goto out;
7061
7062 err = 0;
NeilBrownf2ea68c2008-07-21 17:05:25 +10007063 atomic_inc(&mddev->openers);
NeilBrown260fa032013-08-27 16:44:13 +10007064 clear_bit(MD_STILL_CLOSED, &mddev->flags);
NeilBrownc8c00a62009-08-10 12:50:52 +10007065 mutex_unlock(&mddev->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007066
NeilBrownf0b4f7e2011-02-24 17:26:41 +11007067 check_disk_change(bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007068 out:
7069 return err;
7070}
7071
Al Virodb2a1442013-05-05 21:52:57 -04007072static void md_release(struct gendisk *disk, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007073{
NeilBrownf72ffdd2014-09-30 14:23:59 +10007074 struct mddev *mddev = disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007075
Eric Sesterhenn52e5f9d2006-10-03 23:33:23 +02007076 BUG_ON(!mddev);
NeilBrownf2ea68c2008-07-21 17:05:25 +10007077 atomic_dec(&mddev->openers);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007078 mddev_put(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007079}
NeilBrownf0b4f7e2011-02-24 17:26:41 +11007080
7081static int md_media_changed(struct gendisk *disk)
7082{
NeilBrownfd01b882011-10-11 16:47:53 +11007083 struct mddev *mddev = disk->private_data;
NeilBrownf0b4f7e2011-02-24 17:26:41 +11007084
7085 return mddev->changed;
7086}
7087
7088static int md_revalidate(struct gendisk *disk)
7089{
NeilBrownfd01b882011-10-11 16:47:53 +11007090 struct mddev *mddev = disk->private_data;
NeilBrownf0b4f7e2011-02-24 17:26:41 +11007091
7092 mddev->changed = 0;
7093 return 0;
7094}
Alexey Dobriyan83d5cde2009-09-21 17:01:13 -07007095static const struct block_device_operations md_fops =
Linus Torvalds1da177e2005-04-16 15:20:36 -07007096{
7097 .owner = THIS_MODULE,
Al Viroa39907f2008-03-02 10:31:15 -05007098 .open = md_open,
7099 .release = md_release,
NeilBrownb492b852009-05-26 12:57:36 +10007100 .ioctl = md_ioctl,
Arnd Bergmannaa98aa32009-12-14 12:50:05 +11007101#ifdef CONFIG_COMPAT
7102 .compat_ioctl = md_compat_ioctl,
7103#endif
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08007104 .getgeo = md_getgeo,
NeilBrownf0b4f7e2011-02-24 17:26:41 +11007105 .media_changed = md_media_changed,
7106 .revalidate_disk= md_revalidate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07007107};
7108
NeilBrownf72ffdd2014-09-30 14:23:59 +10007109static int md_thread(void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007110{
NeilBrown2b8bf342011-10-11 16:48:23 +11007111 struct md_thread *thread = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007112
Linus Torvalds1da177e2005-04-16 15:20:36 -07007113 /*
7114 * md_thread is a 'system-thread', it's priority should be very
7115 * high. We avoid resource deadlocks individually in each
7116 * raid personality. (RAID5 does preallocation) We also use RR and
7117 * the very same RT priority as kswapd, thus we will never get
7118 * into a priority inversion deadlock.
7119 *
7120 * we definitely have to have equal or higher priority than
7121 * bdflush, otherwise bdflush will deadlock if there are too
7122 * many dirty RAID5 blocks.
7123 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07007124
NeilBrown6985c432005-10-19 21:23:47 -07007125 allow_signal(SIGKILL);
NeilBrowna6fb0932005-09-09 16:23:56 -07007126 while (!kthread_should_stop()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007127
NeilBrown93588e22005-11-15 00:09:12 -08007128 /* We need to wait INTERRUPTIBLE so that
7129 * we don't add to the load-average.
7130 * That means we need to be sure no signals are
7131 * pending
7132 */
7133 if (signal_pending(current))
7134 flush_signals(current);
7135
7136 wait_event_interruptible_timeout
7137 (thread->wqueue,
7138 test_bit(THREAD_WAKEUP, &thread->flags)
7139 || kthread_should_stop(),
7140 thread->timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007141
NeilBrown6c987912011-01-14 09:13:53 +11007142 clear_bit(THREAD_WAKEUP, &thread->flags);
7143 if (!kthread_should_stop())
Shaohua Li4ed87312012-10-11 13:34:00 +11007144 thread->run(thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007145 }
NeilBrowna6fb0932005-09-09 16:23:56 -07007146
Linus Torvalds1da177e2005-04-16 15:20:36 -07007147 return 0;
7148}
7149
NeilBrown2b8bf342011-10-11 16:48:23 +11007150void md_wakeup_thread(struct md_thread *thread)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007151{
7152 if (thread) {
NeilBrown36a4e1f2011-10-07 14:23:17 +11007153 pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007154 set_bit(THREAD_WAKEUP, &thread->flags);
7155 wake_up(&thread->wqueue);
7156 }
7157}
NeilBrown6c144d32014-09-30 16:15:38 +10007158EXPORT_SYMBOL(md_wakeup_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007159
Shaohua Li4ed87312012-10-11 13:34:00 +11007160struct md_thread *md_register_thread(void (*run) (struct md_thread *),
7161 struct mddev *mddev, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007162{
NeilBrown2b8bf342011-10-11 16:48:23 +11007163 struct md_thread *thread;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007164
NeilBrown2b8bf342011-10-11 16:48:23 +11007165 thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007166 if (!thread)
7167 return NULL;
7168
Linus Torvalds1da177e2005-04-16 15:20:36 -07007169 init_waitqueue_head(&thread->wqueue);
7170
Linus Torvalds1da177e2005-04-16 15:20:36 -07007171 thread->run = run;
7172 thread->mddev = mddev;
NeilBrown32a76272005-06-21 17:17:14 -07007173 thread->timeout = MAX_SCHEDULE_TIMEOUT;
NeilBrown0da3c612009-09-23 18:09:45 +10007174 thread->tsk = kthread_run(md_thread, thread,
7175 "%s_%s",
7176 mdname(thread->mddev),
NeilBrown02326052012-07-03 15:56:52 +10007177 name);
NeilBrowna6fb0932005-09-09 16:23:56 -07007178 if (IS_ERR(thread->tsk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007179 kfree(thread);
7180 return NULL;
7181 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007182 return thread;
7183}
NeilBrown6c144d32014-09-30 16:15:38 +10007184EXPORT_SYMBOL(md_register_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007185
NeilBrown2b8bf342011-10-11 16:48:23 +11007186void md_unregister_thread(struct md_thread **threadp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007187{
NeilBrown2b8bf342011-10-11 16:48:23 +11007188 struct md_thread *thread = *threadp;
NeilBrowne0cf8f02009-03-31 14:39:39 +11007189 if (!thread)
7190 return;
NeilBrown36a4e1f2011-10-07 14:23:17 +11007191 pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
NeilBrown01f96c02011-09-21 15:30:20 +10007192 /* Locking ensures that mddev_unlock does not wake_up a
7193 * non-existent thread
7194 */
7195 spin_lock(&pers_lock);
7196 *threadp = NULL;
7197 spin_unlock(&pers_lock);
NeilBrowna6fb0932005-09-09 16:23:56 -07007198
7199 kthread_stop(thread->tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007200 kfree(thread);
7201}
NeilBrown6c144d32014-09-30 16:15:38 +10007202EXPORT_SYMBOL(md_unregister_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007203
NeilBrownfd01b882011-10-11 16:47:53 +11007204void md_error(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007205{
NeilBrownb2d444d2005-11-08 21:39:31 -08007206 if (!rdev || test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07007207 return;
Dan Williams6bfe0b42008-04-30 00:52:32 -07007208
NeilBrownde393cd2011-07-28 11:31:48 +10007209 if (!mddev->pers || !mddev->pers->error_handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007210 return;
7211 mddev->pers->error_handler(mddev,rdev);
Neil Brown72a23c22008-06-28 08:31:41 +10007212 if (mddev->degraded)
7213 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown00bcb4a2010-06-01 19:37:23 +10007214 sysfs_notify_dirent_safe(rdev->sysfs_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007215 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7216 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7217 md_wakeup_thread(mddev->thread);
NeilBrown768a4182010-07-26 11:49:55 +10007218 if (mddev->event_work.func)
Tejun Heoe804ac72010-10-15 15:36:08 +02007219 queue_work(md_misc_wq, &mddev->event_work);
Guoqing Jiangbb9ef712015-12-28 10:46:38 +08007220 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007221}
NeilBrown6c144d32014-09-30 16:15:38 +10007222EXPORT_SYMBOL(md_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007223
7224/* seq_file implementation /proc/mdstat */
7225
7226static void status_unused(struct seq_file *seq)
7227{
7228 int i = 0;
NeilBrown3cb03002011-10-11 16:45:26 +11007229 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007230
7231 seq_printf(seq, "unused devices: ");
7232
Cheng Renquan159ec1f2009-01-09 08:31:08 +11007233 list_for_each_entry(rdev, &pending_raid_disks, same_set) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007234 char b[BDEVNAME_SIZE];
7235 i++;
7236 seq_printf(seq, "%s ",
7237 bdevname(rdev->bdev,b));
7238 }
7239 if (!i)
7240 seq_printf(seq, "<none>");
7241
7242 seq_printf(seq, "\n");
7243}
7244
NeilBrownf7851be2015-07-02 17:12:58 +10007245static int status_resync(struct seq_file *seq, struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007246{
NeilBrowndd71cf62009-05-07 12:49:35 +10007247 sector_t max_sectors, resync, res;
7248 unsigned long dt, db;
7249 sector_t rt;
NeilBrown4588b422006-03-27 01:18:04 -08007250 int scale;
7251 unsigned int per_milli;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007252
NeilBrownc804cde2012-05-21 09:28:33 +10007253 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
7254 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
NeilBrowndd71cf62009-05-07 12:49:35 +10007255 max_sectors = mddev->resync_max_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007256 else
NeilBrowndd71cf62009-05-07 12:49:35 +10007257 max_sectors = mddev->dev_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007258
NeilBrownf7851be2015-07-02 17:12:58 +10007259 resync = mddev->curr_resync;
7260 if (resync <= 3) {
7261 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7262 /* Still cleaning up */
7263 resync = max_sectors;
7264 } else
7265 resync -= atomic_read(&mddev->recovery_active);
7266
7267 if (resync == 0) {
7268 if (mddev->recovery_cp < MaxSector) {
7269 seq_printf(seq, "\tresync=PENDING");
7270 return 1;
7271 }
7272 return 0;
7273 }
7274 if (resync < 3) {
7275 seq_printf(seq, "\tresync=DELAYED");
7276 return 1;
7277 }
7278
NeilBrown403df472014-09-30 15:52:29 +10007279 WARN_ON(max_sectors == 0);
NeilBrown4588b422006-03-27 01:18:04 -08007280 /* Pick 'scale' such that (resync>>scale)*1000 will fit
NeilBrowndd71cf62009-05-07 12:49:35 +10007281 * in a sector_t, and (max_sectors>>scale) will fit in a
NeilBrown4588b422006-03-27 01:18:04 -08007282 * u32, as those are the requirements for sector_div.
7283 * Thus 'scale' must be at least 10
7284 */
7285 scale = 10;
7286 if (sizeof(sector_t) > sizeof(unsigned long)) {
NeilBrowndd71cf62009-05-07 12:49:35 +10007287 while ( max_sectors/2 > (1ULL<<(scale+32)))
NeilBrown4588b422006-03-27 01:18:04 -08007288 scale++;
7289 }
7290 res = (resync>>scale)*1000;
NeilBrowndd71cf62009-05-07 12:49:35 +10007291 sector_div(res, (u32)((max_sectors>>scale)+1));
NeilBrown4588b422006-03-27 01:18:04 -08007292
7293 per_milli = res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007294 {
NeilBrown4588b422006-03-27 01:18:04 -08007295 int i, x = per_milli/50, y = 20-x;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007296 seq_printf(seq, "[");
7297 for (i = 0; i < x; i++)
7298 seq_printf(seq, "=");
7299 seq_printf(seq, ">");
7300 for (i = 0; i < y; i++)
7301 seq_printf(seq, ".");
7302 seq_printf(seq, "] ");
7303 }
NeilBrown4588b422006-03-27 01:18:04 -08007304 seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
NeilBrownccfcc3c2006-03-27 01:18:09 -08007305 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
7306 "reshape" :
NeilBrown61df9d92006-10-03 01:15:57 -07007307 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
7308 "check" :
7309 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
7310 "resync" : "recovery"))),
7311 per_milli/10, per_milli % 10,
NeilBrowndd71cf62009-05-07 12:49:35 +10007312 (unsigned long long) resync/2,
7313 (unsigned long long) max_sectors/2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007314
7315 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07007316 * dt: time from mark until now
7317 * db: blocks written from mark until now
7318 * rt: remaining time
NeilBrowndd71cf62009-05-07 12:49:35 +10007319 *
7320 * rt is a sector_t, so could be 32bit or 64bit.
7321 * So we divide before multiply in case it is 32bit and close
7322 * to the limit.
Lucas De Marchi25985ed2011-03-30 22:57:33 -03007323 * We scale the divisor (db) by 32 to avoid losing precision
NeilBrowndd71cf62009-05-07 12:49:35 +10007324 * near the end of resync when the number of remaining sectors
7325 * is close to 'db'.
7326 * We then divide rt by 32 after multiplying by db to compensate.
7327 * The '+1' avoids division by zero if db is very small.
Linus Torvalds1da177e2005-04-16 15:20:36 -07007328 */
7329 dt = ((jiffies - mddev->resync_mark) / HZ);
7330 if (!dt) dt++;
NeilBrownff4e8d92006-07-10 04:44:16 -07007331 db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
7332 - mddev->resync_mark_cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007333
NeilBrowndd71cf62009-05-07 12:49:35 +10007334 rt = max_sectors - resync; /* number of remaining sectors */
7335 sector_div(rt, db/32+1);
7336 rt *= dt;
7337 rt >>= 5;
7338
7339 seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
7340 ((unsigned long)rt % 60)/6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007341
NeilBrownff4e8d92006-07-10 04:44:16 -07007342 seq_printf(seq, " speed=%ldK/sec", db/2/dt);
NeilBrownf7851be2015-07-02 17:12:58 +10007343 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007344}
7345
7346static void *md_seq_start(struct seq_file *seq, loff_t *pos)
7347{
7348 struct list_head *tmp;
7349 loff_t l = *pos;
NeilBrownfd01b882011-10-11 16:47:53 +11007350 struct mddev *mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007351
7352 if (l >= 0x10000)
7353 return NULL;
7354 if (!l--)
7355 /* header */
7356 return (void*)1;
7357
7358 spin_lock(&all_mddevs_lock);
7359 list_for_each(tmp,&all_mddevs)
7360 if (!l--) {
NeilBrownfd01b882011-10-11 16:47:53 +11007361 mddev = list_entry(tmp, struct mddev, all_mddevs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007362 mddev_get(mddev);
7363 spin_unlock(&all_mddevs_lock);
7364 return mddev;
7365 }
7366 spin_unlock(&all_mddevs_lock);
7367 if (!l--)
7368 return (void*)2;/* tail */
7369 return NULL;
7370}
7371
7372static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
7373{
7374 struct list_head *tmp;
NeilBrownfd01b882011-10-11 16:47:53 +11007375 struct mddev *next_mddev, *mddev = v;
NeilBrownf72ffdd2014-09-30 14:23:59 +10007376
Linus Torvalds1da177e2005-04-16 15:20:36 -07007377 ++*pos;
7378 if (v == (void*)2)
7379 return NULL;
7380
7381 spin_lock(&all_mddevs_lock);
7382 if (v == (void*)1)
7383 tmp = all_mddevs.next;
7384 else
7385 tmp = mddev->all_mddevs.next;
7386 if (tmp != &all_mddevs)
NeilBrownfd01b882011-10-11 16:47:53 +11007387 next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
Linus Torvalds1da177e2005-04-16 15:20:36 -07007388 else {
7389 next_mddev = (void*)2;
7390 *pos = 0x10000;
NeilBrownf72ffdd2014-09-30 14:23:59 +10007391 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007392 spin_unlock(&all_mddevs_lock);
7393
7394 if (v != (void*)1)
7395 mddev_put(mddev);
7396 return next_mddev;
7397
7398}
7399
7400static void md_seq_stop(struct seq_file *seq, void *v)
7401{
NeilBrownfd01b882011-10-11 16:47:53 +11007402 struct mddev *mddev = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007403
7404 if (mddev && v != (void*)1 && v != (void*)2)
7405 mddev_put(mddev);
7406}
7407
7408static int md_seq_show(struct seq_file *seq, void *v)
7409{
NeilBrownfd01b882011-10-11 16:47:53 +11007410 struct mddev *mddev = v;
Andre Nolldd8ac332009-03-31 14:33:13 +11007411 sector_t sectors;
NeilBrown3cb03002011-10-11 16:45:26 +11007412 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007413
7414 if (v == (void*)1) {
NeilBrown84fc4b52011-10-11 16:49:58 +11007415 struct md_personality *pers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007416 seq_printf(seq, "Personalities : ");
7417 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08007418 list_for_each_entry(pers, &pers_list, list)
7419 seq_printf(seq, "[%s] ", pers->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007420
7421 spin_unlock(&pers_lock);
7422 seq_printf(seq, "\n");
Kay Sieversf1514632011-07-12 20:48:39 +02007423 seq->poll_event = atomic_read(&md_event_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007424 return 0;
7425 }
7426 if (v == (void*)2) {
7427 status_unused(seq);
7428 return 0;
7429 }
7430
NeilBrown36d091f2014-12-15 12:56:58 +11007431 spin_lock(&mddev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007432 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
7433 seq_printf(seq, "%s : %sactive", mdname(mddev),
7434 mddev->pers ? "" : "in");
7435 if (mddev->pers) {
NeilBrownf91de922005-11-08 21:39:36 -08007436 if (mddev->ro==1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007437 seq_printf(seq, " (read-only)");
NeilBrownf91de922005-11-08 21:39:36 -08007438 if (mddev->ro==2)
NeilBrown52720ae2008-03-10 11:43:47 -07007439 seq_printf(seq, " (auto-read-only)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07007440 seq_printf(seq, " %s", mddev->pers->name);
7441 }
7442
Andre Nolldd8ac332009-03-31 14:33:13 +11007443 sectors = 0;
NeilBrownf97fcad2014-12-15 12:56:59 +11007444 rcu_read_lock();
7445 rdev_for_each_rcu(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007446 char b[BDEVNAME_SIZE];
7447 seq_printf(seq, " %s[%d]",
7448 bdevname(rdev->bdev,b), rdev->desc_nr);
NeilBrown8ddf9ef2005-09-09 16:23:45 -07007449 if (test_bit(WriteMostly, &rdev->flags))
7450 seq_printf(seq, "(W)");
Shaohua Li9efdca12015-10-12 16:59:50 -07007451 if (test_bit(Journal, &rdev->flags))
7452 seq_printf(seq, "(J)");
NeilBrownb2d444d2005-11-08 21:39:31 -08007453 if (test_bit(Faulty, &rdev->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007454 seq_printf(seq, "(F)");
7455 continue;
NeilBrown2d78f8c2011-12-23 10:17:51 +11007456 }
7457 if (rdev->raid_disk < 0)
NeilBrownb325a322005-09-09 16:24:00 -07007458 seq_printf(seq, "(S)"); /* spare */
NeilBrown2d78f8c2011-12-23 10:17:51 +11007459 if (test_bit(Replacement, &rdev->flags))
7460 seq_printf(seq, "(R)");
Andre Nolldd8ac332009-03-31 14:33:13 +11007461 sectors += rdev->sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007462 }
NeilBrownf97fcad2014-12-15 12:56:59 +11007463 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07007464
7465 if (!list_empty(&mddev->disks)) {
7466 if (mddev->pers)
7467 seq_printf(seq, "\n %llu blocks",
Andre Nollf233ea52008-07-21 17:05:22 +10007468 (unsigned long long)
7469 mddev->array_sectors / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007470 else
7471 seq_printf(seq, "\n %llu blocks",
Andre Nolldd8ac332009-03-31 14:33:13 +11007472 (unsigned long long)sectors / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007473 }
NeilBrown1cd6bf12005-09-09 16:24:00 -07007474 if (mddev->persistent) {
7475 if (mddev->major_version != 0 ||
7476 mddev->minor_version != 90) {
7477 seq_printf(seq," super %d.%d",
7478 mddev->major_version,
7479 mddev->minor_version);
7480 }
NeilBrowne6910632008-02-06 01:39:51 -08007481 } else if (mddev->external)
7482 seq_printf(seq, " super external:%s",
7483 mddev->metadata_type);
7484 else
NeilBrown1cd6bf12005-09-09 16:24:00 -07007485 seq_printf(seq, " super non-persistent");
Linus Torvalds1da177e2005-04-16 15:20:36 -07007486
7487 if (mddev->pers) {
NeilBrownd710e132008-10-13 11:55:12 +11007488 mddev->pers->status(seq, mddev);
NeilBrownf72ffdd2014-09-30 14:23:59 +10007489 seq_printf(seq, "\n ");
NeilBrown8e1b39d2005-11-08 21:39:41 -08007490 if (mddev->pers->sync_request) {
NeilBrownf7851be2015-07-02 17:12:58 +10007491 if (status_resync(seq, mddev))
NeilBrown8e1b39d2005-11-08 21:39:41 -08007492 seq_printf(seq, "\n ");
NeilBrown8e1b39d2005-11-08 21:39:41 -08007493 }
NeilBrown32a76272005-06-21 17:17:14 -07007494 } else
7495 seq_printf(seq, "\n ");
7496
NeilBrown57148962012-03-19 12:46:40 +11007497 bitmap_status(seq, mddev->bitmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007498
7499 seq_printf(seq, "\n");
7500 }
NeilBrown36d091f2014-12-15 12:56:58 +11007501 spin_unlock(&mddev->lock);
NeilBrownf72ffdd2014-09-30 14:23:59 +10007502
Linus Torvalds1da177e2005-04-16 15:20:36 -07007503 return 0;
7504}
7505
Jan Engelhardt110518b2009-05-07 12:49:37 +10007506static const struct seq_operations md_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007507 .start = md_seq_start,
7508 .next = md_seq_next,
7509 .stop = md_seq_stop,
7510 .show = md_seq_show,
7511};
7512
7513static int md_seq_open(struct inode *inode, struct file *file)
7514{
Kay Sieversf1514632011-07-12 20:48:39 +02007515 struct seq_file *seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007516 int error;
7517
7518 error = seq_open(file, &md_seq_ops);
NeilBrownd7603b72006-01-06 00:20:30 -08007519 if (error)
Kay Sieversf1514632011-07-12 20:48:39 +02007520 return error;
7521
7522 seq = file->private_data;
7523 seq->poll_event = atomic_read(&md_event_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007524 return error;
7525}
7526
NeilBrowne2f23b62014-04-09 14:33:51 +10007527static int md_unloading;
NeilBrownd7603b72006-01-06 00:20:30 -08007528static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
7529{
Kay Sieversf1514632011-07-12 20:48:39 +02007530 struct seq_file *seq = filp->private_data;
NeilBrownd7603b72006-01-06 00:20:30 -08007531 int mask;
7532
NeilBrowne2f23b62014-04-09 14:33:51 +10007533 if (md_unloading)
kbuild test robot7d7e64f2014-12-03 16:07:59 +11007534 return POLLIN|POLLRDNORM|POLLERR|POLLPRI;
NeilBrownd7603b72006-01-06 00:20:30 -08007535 poll_wait(filp, &md_event_waiters, wait);
7536
7537 /* always allow read */
7538 mask = POLLIN | POLLRDNORM;
7539
Kay Sieversf1514632011-07-12 20:48:39 +02007540 if (seq->poll_event != atomic_read(&md_event_count))
NeilBrownd7603b72006-01-06 00:20:30 -08007541 mask |= POLLERR | POLLPRI;
7542 return mask;
7543}
7544
Arjan van de Venfa027c22007-02-12 00:55:33 -08007545static const struct file_operations md_seq_fops = {
Akinobu Mitae24650c2006-10-17 00:09:38 -07007546 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07007547 .open = md_seq_open,
7548 .read = seq_read,
7549 .llseek = seq_lseek,
Martin Peschkec3f94b402007-05-09 02:35:35 -07007550 .release = seq_release_private,
NeilBrownd7603b72006-01-06 00:20:30 -08007551 .poll = mdstat_poll,
Linus Torvalds1da177e2005-04-16 15:20:36 -07007552};
7553
NeilBrown84fc4b52011-10-11 16:49:58 +11007554int register_md_personality(struct md_personality *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007555{
Chao Yu50bd3772014-09-25 15:28:34 +08007556 printk(KERN_INFO "md: %s personality registered for level %d\n",
7557 p->name, p->level);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007558 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08007559 list_add_tail(&p->list, &pers_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007560 spin_unlock(&pers_lock);
7561 return 0;
7562}
NeilBrown6c144d32014-09-30 16:15:38 +10007563EXPORT_SYMBOL(register_md_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007564
NeilBrown84fc4b52011-10-11 16:49:58 +11007565int unregister_md_personality(struct md_personality *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007566{
NeilBrown2604b702006-01-06 00:20:36 -08007567 printk(KERN_INFO "md: %s personality unregistered\n", p->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007568 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08007569 list_del_init(&p->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007570 spin_unlock(&pers_lock);
7571 return 0;
7572}
NeilBrown6c144d32014-09-30 16:15:38 +10007573EXPORT_SYMBOL(unregister_md_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007574
NeilBrown6022e752015-08-13 12:32:55 +10007575int register_md_cluster_operations(struct md_cluster_operations *ops,
7576 struct module *module)
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007577{
NeilBrown6022e752015-08-13 12:32:55 +10007578 int ret = 0;
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007579 spin_lock(&pers_lock);
NeilBrown6022e752015-08-13 12:32:55 +10007580 if (md_cluster_ops != NULL)
7581 ret = -EALREADY;
7582 else {
7583 md_cluster_ops = ops;
7584 md_cluster_mod = module;
7585 }
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007586 spin_unlock(&pers_lock);
NeilBrown6022e752015-08-13 12:32:55 +10007587 return ret;
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007588}
7589EXPORT_SYMBOL(register_md_cluster_operations);
7590
7591int unregister_md_cluster_operations(void)
7592{
7593 spin_lock(&pers_lock);
7594 md_cluster_ops = NULL;
7595 spin_unlock(&pers_lock);
7596 return 0;
7597}
7598EXPORT_SYMBOL(unregister_md_cluster_operations);
7599
7600int md_setup_cluster(struct mddev *mddev, int nodes)
7601{
7602 int err;
7603
7604 err = request_module("md-cluster");
7605 if (err) {
7606 pr_err("md-cluster module not found.\n");
Goldwyn Rodriguesb0c26a72015-07-22 12:09:15 -05007607 return -ENOENT;
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007608 }
7609
7610 spin_lock(&pers_lock);
7611 if (!md_cluster_ops || !try_module_get(md_cluster_mod)) {
7612 spin_unlock(&pers_lock);
7613 return -ENOENT;
7614 }
7615 spin_unlock(&pers_lock);
7616
Goldwyn Rodriguescf921cc2014-03-30 00:42:49 -05007617 return md_cluster_ops->join(mddev, nodes);
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007618}
7619
7620void md_cluster_stop(struct mddev *mddev)
7621{
Goldwyn Rodriguesc4ce8672014-03-29 10:20:02 -05007622 if (!md_cluster_ops)
7623 return;
Goldwyn Rodriguesedb39c92014-03-29 10:01:53 -05007624 md_cluster_ops->leave(mddev);
7625 module_put(md_cluster_mod);
7626}
7627
NeilBrownfd01b882011-10-11 16:47:53 +11007628static int is_mddev_idle(struct mddev *mddev, int init)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007629{
NeilBrownf72ffdd2014-09-30 14:23:59 +10007630 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007631 int idle;
NeilBrowneea1bf32009-03-31 14:27:02 +11007632 int curr_events;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007633
7634 idle = 1;
NeilBrown4b809912008-07-21 17:05:25 +10007635 rcu_read_lock();
7636 rdev_for_each_rcu(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007637 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
NeilBrowneea1bf32009-03-31 14:27:02 +11007638 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
7639 (int)part_stat_read(&disk->part0, sectors[1]) -
7640 atomic_read(&disk->sync_io);
NeilBrown713f6ab2007-07-17 04:06:12 -07007641 /* sync IO will cause sync_io to increase before the disk_stats
7642 * as sync_io is counted when a request starts, and
7643 * disk_stats is counted when it completes.
7644 * So resync activity will cause curr_events to be smaller than
7645 * when there was no such activity.
7646 * non-sync IO will cause disk_stat to increase without
7647 * increasing sync_io so curr_events will (eventually)
7648 * be larger than it was before. Once it becomes
7649 * substantially larger, the test below will cause
7650 * the array to appear non-idle, and resync will slow
7651 * down.
7652 * If there is a lot of outstanding resync activity when
7653 * we set last_event to curr_events, then all that activity
7654 * completing might cause the array to appear non-idle
7655 * and resync will be slowed down even though there might
7656 * not have been non-resync activity. This will only
7657 * happen once though. 'last_events' will soon reflect
7658 * the state where there is little or no outstanding
7659 * resync requests, and further resync activity will
7660 * always make curr_events less than last_events.
NeilBrownc0e48522005-11-18 01:11:01 -08007661 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07007662 */
NeilBrowneea1bf32009-03-31 14:27:02 +11007663 if (init || curr_events - rdev->last_events > 64) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007664 rdev->last_events = curr_events;
7665 idle = 0;
7666 }
7667 }
NeilBrown4b809912008-07-21 17:05:25 +10007668 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07007669 return idle;
7670}
7671
NeilBrownfd01b882011-10-11 16:47:53 +11007672void md_done_sync(struct mddev *mddev, int blocks, int ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007673{
7674 /* another "blocks" (512byte) blocks have been synced */
7675 atomic_sub(blocks, &mddev->recovery_active);
7676 wake_up(&mddev->recovery_wait);
7677 if (!ok) {
NeilBrowndfc70642008-05-23 13:04:39 -07007678 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
majianpeng0a19caa2012-11-19 19:57:34 +08007679 set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007680 md_wakeup_thread(mddev->thread);
7681 // stop recovery, signal do_sync ....
7682 }
7683}
NeilBrown6c144d32014-09-30 16:15:38 +10007684EXPORT_SYMBOL(md_done_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007685
NeilBrown06d91a52005-06-21 17:17:12 -07007686/* md_write_start(mddev, bi)
7687 * If we need to update some array metadata (e.g. 'active' flag
NeilBrown3d310eb2005-06-21 17:17:26 -07007688 * in superblock) before writing, schedule a superblock update
7689 * and wait for it to complete.
NeilBrown06d91a52005-06-21 17:17:12 -07007690 */
NeilBrownfd01b882011-10-11 16:47:53 +11007691void md_write_start(struct mddev *mddev, struct bio *bi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007692{
Neil Brown0fd62b82008-06-28 08:31:36 +10007693 int did_change = 0;
NeilBrown06d91a52005-06-21 17:17:12 -07007694 if (bio_data_dir(bi) != WRITE)
NeilBrown3d310eb2005-06-21 17:17:26 -07007695 return;
NeilBrown06d91a52005-06-21 17:17:12 -07007696
NeilBrownf91de922005-11-08 21:39:36 -08007697 BUG_ON(mddev->ro == 1);
7698 if (mddev->ro == 2) {
7699 /* need to switch to read/write */
7700 mddev->ro = 0;
7701 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7702 md_wakeup_thread(mddev->thread);
NeilBrown25156192008-03-04 14:29:32 -08007703 md_wakeup_thread(mddev->sync_thread);
Neil Brown0fd62b82008-06-28 08:31:36 +10007704 did_change = 1;
NeilBrownf91de922005-11-08 21:39:36 -08007705 }
NeilBrown06d91a52005-06-21 17:17:12 -07007706 atomic_inc(&mddev->writes_pending);
NeilBrown31a59e32008-04-30 00:52:30 -07007707 if (mddev->safemode == 1)
7708 mddev->safemode = 0;
NeilBrown06d91a52005-06-21 17:17:12 -07007709 if (mddev->in_sync) {
NeilBrown85572d72014-12-15 12:56:56 +11007710 spin_lock(&mddev->lock);
NeilBrown3d310eb2005-06-21 17:17:26 -07007711 if (mddev->in_sync) {
7712 mddev->in_sync = 0;
NeilBrown850b2b42006-10-03 01:15:46 -07007713 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown070dc6d2010-08-30 17:33:34 +10007714 set_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrown3d310eb2005-06-21 17:17:26 -07007715 md_wakeup_thread(mddev->thread);
Neil Brown0fd62b82008-06-28 08:31:36 +10007716 did_change = 1;
NeilBrown3d310eb2005-06-21 17:17:26 -07007717 }
NeilBrown85572d72014-12-15 12:56:56 +11007718 spin_unlock(&mddev->lock);
NeilBrown06d91a52005-06-21 17:17:12 -07007719 }
Neil Brown0fd62b82008-06-28 08:31:36 +10007720 if (did_change)
NeilBrown00bcb4a2010-06-01 19:37:23 +10007721 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown09a44cc2008-05-23 13:04:36 -07007722 wait_event(mddev->sb_wait,
NeilBrown09a44cc2008-05-23 13:04:36 -07007723 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07007724}
NeilBrown6c144d32014-09-30 16:15:38 +10007725EXPORT_SYMBOL(md_write_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007726
NeilBrownfd01b882011-10-11 16:47:53 +11007727void md_write_end(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007728{
7729 if (atomic_dec_and_test(&mddev->writes_pending)) {
7730 if (mddev->safemode == 2)
7731 md_wakeup_thread(mddev->thread);
NeilBrown16f17b32006-06-26 00:27:37 -07007732 else if (mddev->safemode_delay)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007733 mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
7734 }
7735}
NeilBrown6c144d32014-09-30 16:15:38 +10007736EXPORT_SYMBOL(md_write_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007737
NeilBrown2a2275d2007-01-26 00:57:11 -08007738/* md_allow_write(mddev)
7739 * Calling this ensures that the array is marked 'active' so that writes
7740 * may proceed without blocking. It is important to call this before
7741 * attempting a GFP_KERNEL allocation while holding the mddev lock.
7742 * Must be called with mddev_lock held.
Dan Williamsb5470dc2008-06-27 21:44:04 -07007743 *
Guoqing Jiangabf35082015-12-21 10:51:01 +11007744 * In the ->external case MD_CHANGE_PENDING can not be cleared until mddev->lock
Dan Williamsb5470dc2008-06-27 21:44:04 -07007745 * is dropped, so return -EAGAIN after notifying userspace.
NeilBrown2a2275d2007-01-26 00:57:11 -08007746 */
NeilBrownfd01b882011-10-11 16:47:53 +11007747int md_allow_write(struct mddev *mddev)
NeilBrown2a2275d2007-01-26 00:57:11 -08007748{
7749 if (!mddev->pers)
Dan Williamsb5470dc2008-06-27 21:44:04 -07007750 return 0;
NeilBrown2a2275d2007-01-26 00:57:11 -08007751 if (mddev->ro)
Dan Williamsb5470dc2008-06-27 21:44:04 -07007752 return 0;
Neil Brown1a0fd492008-06-28 08:31:27 +10007753 if (!mddev->pers->sync_request)
Dan Williamsb5470dc2008-06-27 21:44:04 -07007754 return 0;
NeilBrown2a2275d2007-01-26 00:57:11 -08007755
NeilBrown85572d72014-12-15 12:56:56 +11007756 spin_lock(&mddev->lock);
NeilBrown2a2275d2007-01-26 00:57:11 -08007757 if (mddev->in_sync) {
7758 mddev->in_sync = 0;
7759 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown070dc6d2010-08-30 17:33:34 +10007760 set_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrown2a2275d2007-01-26 00:57:11 -08007761 if (mddev->safemode_delay &&
7762 mddev->safemode == 0)
7763 mddev->safemode = 1;
NeilBrown85572d72014-12-15 12:56:56 +11007764 spin_unlock(&mddev->lock);
NeilBrown2a2275d2007-01-26 00:57:11 -08007765 md_update_sb(mddev, 0);
NeilBrown00bcb4a2010-06-01 19:37:23 +10007766 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown2a2275d2007-01-26 00:57:11 -08007767 } else
NeilBrown85572d72014-12-15 12:56:56 +11007768 spin_unlock(&mddev->lock);
Dan Williamsb5470dc2008-06-27 21:44:04 -07007769
NeilBrown070dc6d2010-08-30 17:33:34 +10007770 if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
Dan Williamsb5470dc2008-06-27 21:44:04 -07007771 return -EAGAIN;
7772 else
7773 return 0;
NeilBrown2a2275d2007-01-26 00:57:11 -08007774}
7775EXPORT_SYMBOL_GPL(md_allow_write);
7776
Linus Torvalds1da177e2005-04-16 15:20:36 -07007777#define SYNC_MARKS 10
7778#define SYNC_MARK_STEP (3*HZ)
majianpeng54f89342012-10-31 11:59:10 +11007779#define UPDATE_FREQUENCY (5*60*HZ)
Shaohua Li4ed87312012-10-11 13:34:00 +11007780void md_do_sync(struct md_thread *thread)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007781{
Shaohua Li4ed87312012-10-11 13:34:00 +11007782 struct mddev *mddev = thread->mddev;
NeilBrownfd01b882011-10-11 16:47:53 +11007783 struct mddev *mddev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007784 unsigned int currspeed = 0,
7785 window;
Xiao Niac7e50a2014-08-07 09:37:41 -04007786 sector_t max_sectors,j, io_sectors, recovery_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007787 unsigned long mark[SYNC_MARKS];
majianpeng54f89342012-10-31 11:59:10 +11007788 unsigned long update_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007789 sector_t mark_cnt[SYNC_MARKS];
7790 int last_mark,m;
7791 struct list_head *tmp;
7792 sector_t last_check;
NeilBrown57afd892005-06-21 17:17:13 -07007793 int skipped = 0;
NeilBrown3cb03002011-10-11 16:45:26 +11007794 struct md_rdev *rdev;
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007795 char *desc, *action = NULL;
majianpeng7c2c57c2012-07-03 12:12:26 +10007796 struct blk_plug plug;
Guoqing Jiang41a9a0d2016-05-02 11:33:08 -04007797 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007798
7799 /* just incase thread restarts... */
7800 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7801 return;
NeilBrown3991b312014-05-28 13:39:23 +10007802 if (mddev->ro) {/* never try to sync a read-only array */
7803 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007804 return;
NeilBrown3991b312014-05-28 13:39:23 +10007805 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007806
Guoqing Jiang41a9a0d2016-05-02 11:33:08 -04007807 if (mddev_is_clustered(mddev)) {
7808 ret = md_cluster_ops->resync_start(mddev);
7809 if (ret)
7810 goto skip;
7811
7812 if (!(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
7813 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ||
7814 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
7815 && ((unsigned long long)mddev->curr_resync_completed
7816 < (unsigned long long)mddev->resync_max_sectors))
7817 goto skip;
7818 }
7819
NeilBrown61df9d92006-10-03 01:15:57 -07007820 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007821 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
NeilBrown61df9d92006-10-03 01:15:57 -07007822 desc = "data-check";
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007823 action = "check";
7824 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
NeilBrown61df9d92006-10-03 01:15:57 -07007825 desc = "requested-resync";
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007826 action = "repair";
7827 } else
NeilBrown61df9d92006-10-03 01:15:57 -07007828 desc = "resync";
7829 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7830 desc = "reshape";
7831 else
7832 desc = "recovery";
7833
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007834 mddev->last_sync_action = action ?: desc;
7835
Linus Torvalds1da177e2005-04-16 15:20:36 -07007836 /* we overload curr_resync somewhat here.
7837 * 0 == not engaged in resync at all
7838 * 2 == checking that there is no conflict with another sync
7839 * 1 == like 2, but have yielded to allow conflicting resync to
7840 * commense
7841 * other == active in resync - this many blocks
7842 *
7843 * Before starting a resync we must have set curr_resync to
7844 * 2, and then checked that every "conflicting" array has curr_resync
7845 * less than ours. When we find one that is the same or higher
7846 * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
7847 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
7848 * This will mean we have to start checking from the beginning again.
7849 *
7850 */
7851
7852 do {
7853 mddev->curr_resync = 2;
7854
7855 try_again:
NeilBrown404e4b42009-12-30 15:25:23 +11007856 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
Linus Torvalds1da177e2005-04-16 15:20:36 -07007857 goto skip;
NeilBrown29ac4aa2008-02-06 01:39:58 -08007858 for_each_mddev(mddev2, tmp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007859 if (mddev2 == mddev)
7860 continue;
Bernd Schubert90b08712008-05-23 13:04:38 -07007861 if (!mddev->parallel_resync
7862 && mddev2->curr_resync
7863 && match_mddev_units(mddev, mddev2)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007864 DEFINE_WAIT(wq);
7865 if (mddev < mddev2 && mddev->curr_resync == 2) {
7866 /* arbitrarily yield */
7867 mddev->curr_resync = 1;
7868 wake_up(&resync_wait);
7869 }
7870 if (mddev > mddev2 && mddev->curr_resync == 1)
7871 /* no need to wait here, we can wait the next
7872 * time 'round when curr_resync == 2
7873 */
7874 continue;
NeilBrown97441972008-09-19 11:49:54 +10007875 /* We need to wait 'interruptible' so as not to
7876 * contribute to the load average, and not to
7877 * be caught by 'softlockup'
7878 */
7879 prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
NeilBrownc91abf52013-11-19 12:02:01 +11007880 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
NeilBrown8712e552005-10-26 01:58:58 -07007881 mddev2->curr_resync >= mddev->curr_resync) {
NeilBrown61df9d92006-10-03 01:15:57 -07007882 printk(KERN_INFO "md: delaying %s of %s"
7883 " until %s has finished (they"
Linus Torvalds1da177e2005-04-16 15:20:36 -07007884 " share one or more physical units)\n",
NeilBrown61df9d92006-10-03 01:15:57 -07007885 desc, mdname(mddev), mdname(mddev2));
Linus Torvalds1da177e2005-04-16 15:20:36 -07007886 mddev_put(mddev2);
NeilBrown97441972008-09-19 11:49:54 +10007887 if (signal_pending(current))
7888 flush_signals(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007889 schedule();
7890 finish_wait(&resync_wait, &wq);
7891 goto try_again;
7892 }
7893 finish_wait(&resync_wait, &wq);
7894 }
7895 }
7896 } while (mddev->curr_resync < 2);
7897
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007898 j = 0;
NeilBrown9d888832005-11-08 21:39:26 -08007899 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007900 /* resync follows the size requested by the personality,
NeilBrown57afd892005-06-21 17:17:13 -07007901 * which defaults to physical size, but can be virtual size
Linus Torvalds1da177e2005-04-16 15:20:36 -07007902 */
7903 max_sectors = mddev->resync_max_sectors;
Jianpeng Ma7f7583d2012-10-11 14:17:59 +11007904 atomic64_set(&mddev->resync_mismatches, 0);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007905 /* we don't use the checkpoint if there's a bitmap */
Neil Brown5e96ee62008-06-28 08:31:24 +10007906 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7907 j = mddev->resync_min;
7908 else if (!mddev->bitmap)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007909 j = mddev->recovery_cp;
Neil Brown5e96ee62008-06-28 08:31:24 +10007910
NeilBrownccfcc3c2006-03-27 01:18:09 -08007911 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
NeilBrownc804cde2012-05-21 09:28:33 +10007912 max_sectors = mddev->resync_max_sectors;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007913 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007914 /* recovery follows the physical size of devices */
Andre Noll58c0fed2009-03-31 14:33:13 +11007915 max_sectors = mddev->dev_sectors;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007916 j = MaxSector;
Dan Williams4e59ca72009-12-12 21:17:06 -07007917 rcu_read_lock();
NeilBrowndafb20f2012-03-19 12:46:39 +11007918 rdev_for_each_rcu(rdev, mddev)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007919 if (rdev->raid_disk >= 0 &&
Shaohua Lif2076e72015-10-08 21:54:12 -07007920 !test_bit(Journal, &rdev->flags) &&
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007921 !test_bit(Faulty, &rdev->flags) &&
7922 !test_bit(In_sync, &rdev->flags) &&
7923 rdev->recovery_offset < j)
7924 j = rdev->recovery_offset;
Dan Williams4e59ca72009-12-12 21:17:06 -07007925 rcu_read_unlock();
NeilBrown133d4522014-07-02 12:04:14 +10007926
7927 /* If there is a bitmap, we need to make sure all
7928 * writes that started before we added a spare
7929 * complete before we start doing a recovery.
7930 * Otherwise the write might complete and (via
7931 * bitmap_endwrite) set a bit in the bitmap after the
7932 * recovery has checked that bit and skipped that
7933 * region.
7934 */
7935 if (mddev->bitmap) {
7936 mddev->pers->quiesce(mddev, 1);
7937 mddev->pers->quiesce(mddev, 0);
7938 }
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007939 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007940
NeilBrown61df9d92006-10-03 01:15:57 -07007941 printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
7942 printk(KERN_INFO "md: minimum _guaranteed_ speed:"
7943 " %d KB/sec/disk.\n", speed_min(mddev));
Adrian Bunk338cec32005-09-10 00:26:54 -07007944 printk(KERN_INFO "md: using maximum available idle IO bandwidth "
NeilBrown61df9d92006-10-03 01:15:57 -07007945 "(but not more than %d KB/sec) for %s.\n",
7946 speed_max(mddev), desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007947
NeilBrowneea1bf32009-03-31 14:27:02 +11007948 is_mddev_idle(mddev, 1); /* this initializes IO event counters */
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007949
NeilBrown57afd892005-06-21 17:17:13 -07007950 io_sectors = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007951 for (m = 0; m < SYNC_MARKS; m++) {
7952 mark[m] = jiffies;
NeilBrown57afd892005-06-21 17:17:13 -07007953 mark_cnt[m] = io_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007954 }
7955 last_mark = 0;
7956 mddev->resync_mark = mark[last_mark];
7957 mddev->resync_mark_cnt = mark_cnt[last_mark];
7958
7959 /*
7960 * Tune reconstruction:
7961 */
7962 window = 32*(PAGE_SIZE/512);
Jonathan Brassowac424502011-06-07 17:48:35 -05007963 printk(KERN_INFO "md: using %dk window, over a total of %lluk.\n",
7964 window/2, (unsigned long long)max_sectors/2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007965
7966 atomic_set(&mddev->recovery_active, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007967 last_check = 0;
7968
7969 if (j>2) {
NeilBrownc91abf52013-11-19 12:02:01 +11007970 printk(KERN_INFO
NeilBrown61df9d92006-10-03 01:15:57 -07007971 "md: resuming %s of %s from checkpoint.\n",
7972 desc, mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07007973 mddev->curr_resync = j;
NeilBrown72f36d52012-10-11 14:25:57 +11007974 } else
7975 mddev->curr_resync = 3; /* no longer delayed */
NeilBrown75d3da42011-01-14 09:14:34 +11007976 mddev->curr_resync_completed = j;
NeilBrown72f36d52012-10-11 14:25:57 +11007977 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
7978 md_new_event(mddev);
majianpeng54f89342012-10-31 11:59:10 +11007979 update_time = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007980
majianpeng7c2c57c2012-07-03 12:12:26 +10007981 blk_start_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007982 while (j < max_sectors) {
NeilBrown57afd892005-06-21 17:17:13 -07007983 sector_t sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007984
NeilBrown57afd892005-06-21 17:17:13 -07007985 skipped = 0;
NeilBrown97e4f422009-03-31 14:33:13 +11007986
NeilBrown7a91ee12009-05-26 12:57:21 +10007987 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7988 ((mddev->curr_resync > mddev->curr_resync_completed &&
7989 (mddev->curr_resync - mddev->curr_resync_completed)
7990 > (max_sectors >> 4)) ||
majianpeng54f89342012-10-31 11:59:10 +11007991 time_after_eq(jiffies, update_time + UPDATE_FREQUENCY) ||
NeilBrown7a91ee12009-05-26 12:57:21 +10007992 (j - mddev->curr_resync_completed)*2
NeilBrownc5e19d92015-07-17 12:06:02 +10007993 >= mddev->resync_max - mddev->curr_resync_completed ||
7994 mddev->curr_resync_completed > mddev->resync_max
NeilBrown7a91ee12009-05-26 12:57:21 +10007995 )) {
NeilBrown97e4f422009-03-31 14:33:13 +11007996 /* time to update curr_resync_completed */
NeilBrown97e4f422009-03-31 14:33:13 +11007997 wait_event(mddev->recovery_wait,
7998 atomic_read(&mddev->recovery_active) == 0);
NeilBrown75d3da42011-01-14 09:14:34 +11007999 mddev->curr_resync_completed = j;
kernelmail35d78c62012-10-31 11:59:10 +11008000 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
8001 j > mddev->recovery_cp)
8002 mddev->recovery_cp = j;
majianpeng54f89342012-10-31 11:59:10 +11008003 update_time = jiffies;
NeilBrown070dc6d2010-08-30 17:33:34 +10008004 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrownacb180b2009-04-14 16:28:34 +10008005 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
NeilBrown97e4f422009-03-31 14:33:13 +11008006 }
NeilBrownacb180b2009-04-14 16:28:34 +10008007
NeilBrownc91abf52013-11-19 12:02:01 +11008008 while (j >= mddev->resync_max &&
8009 !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
NeilBrowne62e58a2009-07-01 13:15:35 +10008010 /* As this condition is controlled by user-space,
8011 * we can block indefinitely, so use '_interruptible'
8012 * to avoid triggering warnings.
8013 */
8014 flush_signals(current); /* just in case */
8015 wait_event_interruptible(mddev->recovery_wait,
8016 mddev->resync_max > j
NeilBrownc91abf52013-11-19 12:02:01 +11008017 || test_bit(MD_RECOVERY_INTR,
8018 &mddev->recovery));
NeilBrowne62e58a2009-07-01 13:15:35 +10008019 }
NeilBrownacb180b2009-04-14 16:28:34 +10008020
NeilBrownc91abf52013-11-19 12:02:01 +11008021 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8022 break;
NeilBrownacb180b2009-04-14 16:28:34 +10008023
NeilBrown09314792015-02-19 16:04:40 +11008024 sectors = mddev->pers->sync_request(mddev, j, &skipped);
NeilBrown57afd892005-06-21 17:17:13 -07008025 if (sectors == 0) {
NeilBrowndfc70642008-05-23 13:04:39 -07008026 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrownc91abf52013-11-19 12:02:01 +11008027 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008028 }
NeilBrown57afd892005-06-21 17:17:13 -07008029
8030 if (!skipped) { /* actual IO requested */
8031 io_sectors += sectors;
8032 atomic_add(sectors, &mddev->recovery_active);
8033 }
8034
NeilBrowne875ece2011-07-28 11:39:24 +10008035 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8036 break;
8037
Linus Torvalds1da177e2005-04-16 15:20:36 -07008038 j += sectors;
NeilBrown5ed1df22015-07-24 13:27:08 +10008039 if (j > max_sectors)
8040 /* when skipping, extra large numbers can be returned. */
8041 j = max_sectors;
NeilBrown72f36d52012-10-11 14:25:57 +11008042 if (j > 2)
8043 mddev->curr_resync = j;
NeilBrownff4e8d92006-07-10 04:44:16 -07008044 mddev->curr_mark_cnt = io_sectors;
NeilBrownd7603b72006-01-06 00:20:30 -08008045 if (last_check == 0)
NeilBrowne875ece2011-07-28 11:39:24 +10008046 /* this is the earliest that rebuild will be
NeilBrownd7603b72006-01-06 00:20:30 -08008047 * visible in /proc/mdstat
8048 */
8049 md_new_event(mddev);
NeilBrown57afd892005-06-21 17:17:13 -07008050
8051 if (last_check + window > io_sectors || j == max_sectors)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008052 continue;
8053
NeilBrown57afd892005-06-21 17:17:13 -07008054 last_check = io_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008055 repeat:
8056 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
8057 /* step marks */
8058 int next = (last_mark+1) % SYNC_MARKS;
8059
8060 mddev->resync_mark = mark[next];
8061 mddev->resync_mark_cnt = mark_cnt[next];
8062 mark[next] = jiffies;
NeilBrown57afd892005-06-21 17:17:13 -07008063 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008064 last_mark = next;
8065 }
8066
NeilBrownc91abf52013-11-19 12:02:01 +11008067 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8068 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008069
8070 /*
8071 * this loop exits only if either when we are slower than
8072 * the 'hard' speed limit, or the system was IO-idle for
8073 * a jiffy.
8074 * the system might be non-idle CPU-wise, but we only care
8075 * about not overloading the IO subsystem. (things like an
8076 * e2fsck being done on the RAID array should execute fast)
8077 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07008078 cond_resched();
8079
Xiao Niac7e50a2014-08-07 09:37:41 -04008080 recovery_done = io_sectors - atomic_read(&mddev->recovery_active);
8081 currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2
NeilBrown57afd892005-06-21 17:17:13 -07008082 /((jiffies-mddev->resync_mark)/HZ +1) +1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008083
NeilBrown88202a02006-01-06 00:21:36 -08008084 if (currspeed > speed_min(mddev)) {
NeilBrownac8fa412015-02-19 16:55:00 +11008085 if (currspeed > speed_max(mddev)) {
NeilBrownc0e48522005-11-18 01:11:01 -08008086 msleep(500);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008087 goto repeat;
8088 }
NeilBrownac8fa412015-02-19 16:55:00 +11008089 if (!is_mddev_idle(mddev, 0)) {
8090 /*
8091 * Give other IO more of a chance.
8092 * The faster the devices, the less we wait.
8093 */
8094 wait_event(mddev->recovery_wait,
8095 !atomic_read(&mddev->recovery_active));
8096 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07008097 }
8098 }
NeilBrownc91abf52013-11-19 12:02:01 +11008099 printk(KERN_INFO "md: %s: %s %s.\n",mdname(mddev), desc,
8100 test_bit(MD_RECOVERY_INTR, &mddev->recovery)
8101 ? "interrupted" : "done");
Linus Torvalds1da177e2005-04-16 15:20:36 -07008102 /*
8103 * this also signals 'finished resyncing' to md_stop
8104 */
majianpeng7c2c57c2012-07-03 12:12:26 +10008105 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008106 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
8107
NeilBrown5ed1df22015-07-24 13:27:08 +10008108 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8109 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8110 mddev->curr_resync > 2) {
8111 mddev->curr_resync_completed = mddev->curr_resync;
8112 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
8113 }
NeilBrown09314792015-02-19 16:04:40 +11008114 mddev->pers->sync_request(mddev, max_sectors, &skipped);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008115
NeilBrowndfc70642008-05-23 13:04:39 -07008116 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008117 mddev->curr_resync > 2) {
8118 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8119 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8120 if (mddev->curr_resync >= mddev->recovery_cp) {
8121 printk(KERN_INFO
NeilBrown61df9d92006-10-03 01:15:57 -07008122 "md: checkpointing %s of %s.\n",
8123 desc, mdname(mddev));
majianpeng0a19caa2012-11-19 19:57:34 +08008124 if (test_bit(MD_RECOVERY_ERROR,
8125 &mddev->recovery))
8126 mddev->recovery_cp =
8127 mddev->curr_resync_completed;
8128 else
8129 mddev->recovery_cp =
8130 mddev->curr_resync;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008131 }
8132 } else
8133 mddev->recovery_cp = MaxSector;
8134 } else {
8135 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8136 mddev->curr_resync = MaxSector;
Dan Williams4e59ca72009-12-12 21:17:06 -07008137 rcu_read_lock();
NeilBrowndafb20f2012-03-19 12:46:39 +11008138 rdev_for_each_rcu(rdev, mddev)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008139 if (rdev->raid_disk >= 0 &&
NeilBrown70fffd02010-06-16 17:01:25 +10008140 mddev->delta_disks >= 0 &&
Shaohua Lif2076e72015-10-08 21:54:12 -07008141 !test_bit(Journal, &rdev->flags) &&
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008142 !test_bit(Faulty, &rdev->flags) &&
8143 !test_bit(In_sync, &rdev->flags) &&
8144 rdev->recovery_offset < mddev->curr_resync)
8145 rdev->recovery_offset = mddev->curr_resync;
Dan Williams4e59ca72009-12-12 21:17:06 -07008146 rcu_read_unlock();
NeilBrown5fd6c1d2006-06-26 00:27:40 -07008147 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07008148 }
NeilBrowndb91ff52012-02-07 12:01:51 +11008149 skip:
Goldwyn Rodriguesc186b122015-09-30 13:20:35 -05008150 if (mddev_is_clustered(mddev) &&
Guoqing Jiang2c97cf12016-05-02 11:33:09 -04008151 ret == 0) {
8152 /* set CHANGE_PENDING here since maybe another
8153 * update is needed, so other nodes are informed */
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04008154 set_mask_bits(&mddev->flags, 0,
8155 BIT(MD_CHANGE_PENDING) | BIT(MD_CHANGE_DEVS));
Guoqing Jiang2c97cf12016-05-02 11:33:09 -04008156 md_wakeup_thread(mddev->thread);
8157 wait_event(mddev->sb_wait,
8158 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
Goldwyn Rodriguesc186b122015-09-30 13:20:35 -05008159 md_cluster_ops->resync_finish(mddev);
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04008160 } else
8161 set_bit(MD_CHANGE_DEVS, &mddev->flags);
Goldwyn Rodriguesc186b122015-09-30 13:20:35 -05008162
NeilBrown23da4222014-12-15 12:57:01 +11008163 spin_lock(&mddev->lock);
NeilBrownc07b70a2009-12-14 12:49:48 +11008164 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8165 /* We completed so min/max setting can be forgotten if used. */
8166 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8167 mddev->resync_min = 0;
8168 mddev->resync_max = MaxSector;
8169 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8170 mddev->resync_min = mddev->curr_resync_completed;
NeilBrownf7851be2015-07-02 17:12:58 +10008171 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008172 mddev->curr_resync = 0;
NeilBrown23da4222014-12-15 12:57:01 +11008173 spin_unlock(&mddev->lock);
8174
Linus Torvalds1da177e2005-04-16 15:20:36 -07008175 wake_up(&resync_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008176 md_wakeup_thread(mddev->thread);
NeilBrownc6207272008-02-06 01:39:52 -08008177 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008178}
NeilBrown29269552006-03-27 01:18:10 -08008179EXPORT_SYMBOL_GPL(md_do_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008180
NeilBrown746d3202013-04-24 11:42:41 +10008181static int remove_and_add_spares(struct mddev *mddev,
8182 struct md_rdev *this)
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008183{
NeilBrown3cb03002011-10-11 16:45:26 +11008184 struct md_rdev *rdev;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008185 int spares = 0;
NeilBrownf2a371c2012-01-09 00:46:41 +11008186 int removed = 0;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008187
NeilBrowndafb20f2012-03-19 12:46:39 +11008188 rdev_for_each(rdev, mddev)
NeilBrown746d3202013-04-24 11:42:41 +10008189 if ((this == NULL || rdev == this) &&
8190 rdev->raid_disk >= 0 &&
Dan Williams6bfe0b42008-04-30 00:52:32 -07008191 !test_bit(Blocked, &rdev->flags) &&
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008192 (test_bit(Faulty, &rdev->flags) ||
Shaohua Lif2076e72015-10-08 21:54:12 -07008193 (!test_bit(In_sync, &rdev->flags) &&
8194 !test_bit(Journal, &rdev->flags))) &&
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008195 atomic_read(&rdev->nr_pending)==0) {
8196 if (mddev->pers->hot_remove_disk(
NeilBrownb8321b62011-12-23 10:17:51 +11008197 mddev, rdev) == 0) {
Namhyung Kim36fad852011-07-27 11:00:36 +10008198 sysfs_unlink_rdev(mddev, rdev);
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008199 rdev->raid_disk = -1;
NeilBrownf2a371c2012-01-09 00:46:41 +11008200 removed++;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008201 }
8202 }
Jonathan Brassow90584fc2013-03-07 16:24:26 -06008203 if (removed && mddev->kobj.sd)
8204 sysfs_notify(&mddev->kobj, NULL, "degraded");
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008205
Goldwyn Rodrigues2910ff12015-09-28 10:27:26 -05008206 if (this && removed)
NeilBrown746d3202013-04-24 11:42:41 +10008207 goto no_add;
8208
NeilBrowndafb20f2012-03-19 12:46:39 +11008209 rdev_for_each(rdev, mddev) {
Goldwyn Rodrigues2910ff12015-09-28 10:27:26 -05008210 if (this && this != rdev)
8211 continue;
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05008212 if (test_bit(Candidate, &rdev->flags))
8213 continue;
NeilBrown7bfec5f2011-12-23 10:17:53 +11008214 if (rdev->raid_disk >= 0 &&
8215 !test_bit(In_sync, &rdev->flags) &&
Shaohua Lif2076e72015-10-08 21:54:12 -07008216 !test_bit(Journal, &rdev->flags) &&
NeilBrown7bfec5f2011-12-23 10:17:53 +11008217 !test_bit(Faulty, &rdev->flags))
8218 spares++;
NeilBrown7ceb17e2013-04-24 11:42:42 +10008219 if (rdev->raid_disk >= 0)
8220 continue;
8221 if (test_bit(Faulty, &rdev->flags))
8222 continue;
Shaohua Lif6b6ec52015-12-21 10:51:02 +11008223 if (!test_bit(Journal, &rdev->flags)) {
8224 if (mddev->ro &&
8225 ! (rdev->saved_raid_disk >= 0 &&
8226 !test_bit(Bitmap_sync, &rdev->flags)))
8227 continue;
NeilBrown7ceb17e2013-04-24 11:42:42 +10008228
Shaohua Lif6b6ec52015-12-21 10:51:02 +11008229 rdev->recovery_offset = 0;
8230 }
NeilBrown7ceb17e2013-04-24 11:42:42 +10008231 if (mddev->pers->
8232 hot_add_disk(mddev, rdev) == 0) {
8233 if (sysfs_link_rdev(mddev, rdev))
8234 /* failure here is OK */;
Shaohua Lif6b6ec52015-12-21 10:51:02 +11008235 if (!test_bit(Journal, &rdev->flags))
8236 spares++;
NeilBrown7ceb17e2013-04-24 11:42:42 +10008237 md_new_event(mddev);
8238 set_bit(MD_CHANGE_DEVS, &mddev->flags);
NeilBrowndfc70642008-05-23 13:04:39 -07008239 }
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008240 }
NeilBrown746d3202013-04-24 11:42:41 +10008241no_add:
NeilBrown6dafab62012-09-19 12:54:22 +10008242 if (removed)
8243 set_bit(MD_CHANGE_DEVS, &mddev->flags);
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008244 return spares;
8245}
NeilBrown7ebc0be2011-01-14 09:14:33 +11008246
NeilBrownac05f252014-09-30 08:10:42 +10008247static void md_start_sync(struct work_struct *ws)
8248{
8249 struct mddev *mddev = container_of(ws, struct mddev, del_work);
Goldwyn Rodriguesc186b122015-09-30 13:20:35 -05008250 int ret = 0;
8251
NeilBrownac05f252014-09-30 08:10:42 +10008252 mddev->sync_thread = md_register_thread(md_do_sync,
8253 mddev,
8254 "resync");
8255 if (!mddev->sync_thread) {
Goldwyn Rodriguesc186b122015-09-30 13:20:35 -05008256 if (!(mddev_is_clustered(mddev) && ret == -EAGAIN))
8257 printk(KERN_ERR "%s: could not start resync"
8258 " thread...\n",
8259 mdname(mddev));
NeilBrownac05f252014-09-30 08:10:42 +10008260 /* leave the spares where they are, it shouldn't hurt */
8261 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8262 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8263 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
8264 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8265 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11008266 wake_up(&resync_wait);
NeilBrownac05f252014-09-30 08:10:42 +10008267 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
8268 &mddev->recovery))
8269 if (mddev->sysfs_action)
8270 sysfs_notify_dirent_safe(mddev->sysfs_action);
8271 } else
8272 md_wakeup_thread(mddev->sync_thread);
8273 sysfs_notify_dirent_safe(mddev->sysfs_action);
8274 md_new_event(mddev);
8275}
8276
Linus Torvalds1da177e2005-04-16 15:20:36 -07008277/*
8278 * This routine is regularly called by all per-raid-array threads to
8279 * deal with generic issues like resync and super-block update.
8280 * Raid personalities that don't have a thread (linear/raid0) do not
8281 * need this as they never do any recovery or update the superblock.
8282 *
8283 * It does not do any resync itself, but rather "forks" off other threads
8284 * to do that as needed.
8285 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
8286 * "->recovery" and create a thread at ->sync_thread.
NeilBrowndfc70642008-05-23 13:04:39 -07008287 * When the thread finishes it sets MD_RECOVERY_DONE
Linus Torvalds1da177e2005-04-16 15:20:36 -07008288 * and wakeups up this thread which will reap the thread and finish up.
8289 * This thread also removes any faulty devices (with nr_pending == 0).
8290 *
8291 * The overall approach is:
8292 * 1/ if the superblock needs updating, update it.
8293 * 2/ If a recovery thread is running, don't do anything else.
8294 * 3/ If recovery has finished, clean up, possibly marking spares active.
8295 * 4/ If there are any faulty devices, remove them.
8296 * 5/ If array is degraded, try to add spares devices
8297 * 6/ If array has spares or is not in-sync, start a resync thread.
8298 */
NeilBrownfd01b882011-10-11 16:47:53 +11008299void md_check_recovery(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008300{
Jonathan Brassow68866e42011-06-08 15:10:08 +10008301 if (mddev->suspended)
8302 return;
8303
NeilBrown5f404022005-06-21 17:17:16 -07008304 if (mddev->bitmap)
NeilBrownaa5cbd12009-12-14 12:49:46 +11008305 bitmap_daemon_work(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008306
NeilBrownfca4d842005-06-21 17:17:11 -07008307 if (signal_pending(current)) {
NeilBrown31a59e32008-04-30 00:52:30 -07008308 if (mddev->pers->sync_request && !mddev->external) {
NeilBrownfca4d842005-06-21 17:17:11 -07008309 printk(KERN_INFO "md: %s in immediate safe mode\n",
8310 mdname(mddev));
8311 mddev->safemode = 2;
8312 }
8313 flush_signals(current);
8314 }
8315
NeilBrownc89a8ee2008-08-05 15:54:13 +10008316 if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
8317 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008318 if ( ! (
NeilBrown142d44c2013-11-28 10:34:18 +11008319 (mddev->flags & MD_UPDATE_SB_FLAGS & ~ (1<<MD_CHANGE_PENDING)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07008320 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
NeilBrownfca4d842005-06-21 17:17:11 -07008321 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
Guoqing Jiang15858fa2015-12-21 10:51:00 +11008322 test_bit(MD_RELOAD_SB, &mddev->flags) ||
NeilBrown31a59e32008-04-30 00:52:30 -07008323 (mddev->external == 0 && mddev->safemode == 1) ||
NeilBrownfca4d842005-06-21 17:17:11 -07008324 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
8325 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008326 ))
8327 return;
NeilBrownfca4d842005-06-21 17:17:11 -07008328
NeilBrowndf5b89b2006-03-27 01:18:20 -08008329 if (mddev_trylock(mddev)) {
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008330 int spares = 0;
NeilBrownfca4d842005-06-21 17:17:11 -07008331
NeilBrownc89a8ee2008-08-05 15:54:13 +10008332 if (mddev->ro) {
Neil Brownab16bfc2015-06-17 12:31:46 +10008333 struct md_rdev *rdev;
8334 if (!mddev->external && mddev->in_sync)
8335 /* 'Blocked' flag not needed as failed devices
8336 * will be recorded if array switched to read/write.
8337 * Leaving it set will prevent the device
8338 * from being removed.
8339 */
8340 rdev_for_each(rdev, mddev)
8341 clear_bit(Blocked, &rdev->flags);
NeilBrown7ceb17e2013-04-24 11:42:42 +10008342 /* On a read-only array we can:
8343 * - remove failed devices
8344 * - add already-in_sync devices if the array itself
8345 * is in-sync.
8346 * As we only add devices that are already in-sync,
8347 * we can activate the spares immediately.
NeilBrownc89a8ee2008-08-05 15:54:13 +10008348 */
NeilBrown7ceb17e2013-04-24 11:42:42 +10008349 remove_and_add_spares(mddev, NULL);
NeilBrown8313b8e2013-12-12 10:13:33 +11008350 /* There is no thread, but we need to call
8351 * ->spare_active and clear saved_raid_disk
8352 */
NeilBrown2ac295a2014-05-29 11:40:03 +10008353 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrown8313b8e2013-12-12 10:13:33 +11008354 md_reap_sync_thread(mddev);
NeilBrowna4a3d262015-07-17 11:57:30 +10008355 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown8313b8e2013-12-12 10:13:33 +11008356 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
Shaohua Lid4929ad2015-09-18 10:20:12 -07008357 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrownc89a8ee2008-08-05 15:54:13 +10008358 goto unlock;
8359 }
8360
Guoqing Jiang659b2542015-12-21 10:50:59 +11008361 if (mddev_is_clustered(mddev)) {
8362 struct md_rdev *rdev;
8363 /* kick the device if another node issued a
8364 * remove disk.
8365 */
8366 rdev_for_each(rdev, mddev) {
8367 if (test_and_clear_bit(ClusterRemove, &rdev->flags) &&
8368 rdev->raid_disk < 0)
8369 md_kick_rdev_from_array(rdev);
8370 }
Guoqing Jiang15858fa2015-12-21 10:51:00 +11008371
8372 if (test_and_clear_bit(MD_RELOAD_SB, &mddev->flags))
8373 md_reload_sb(mddev, mddev->good_device_nr);
Guoqing Jiang659b2542015-12-21 10:50:59 +11008374 }
8375
NeilBrown31a59e32008-04-30 00:52:30 -07008376 if (!mddev->external) {
Neil Brown0fd62b82008-06-28 08:31:36 +10008377 int did_change = 0;
NeilBrown85572d72014-12-15 12:56:56 +11008378 spin_lock(&mddev->lock);
NeilBrown31a59e32008-04-30 00:52:30 -07008379 if (mddev->safemode &&
8380 !atomic_read(&mddev->writes_pending) &&
8381 !mddev->in_sync &&
8382 mddev->recovery_cp == MaxSector) {
8383 mddev->in_sync = 1;
Neil Brown0fd62b82008-06-28 08:31:36 +10008384 did_change = 1;
NeilBrown070dc6d2010-08-30 17:33:34 +10008385 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown31a59e32008-04-30 00:52:30 -07008386 }
8387 if (mddev->safemode == 1)
8388 mddev->safemode = 0;
NeilBrown85572d72014-12-15 12:56:56 +11008389 spin_unlock(&mddev->lock);
Neil Brown0fd62b82008-06-28 08:31:36 +10008390 if (did_change)
NeilBrown00bcb4a2010-06-01 19:37:23 +10008391 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrownfca4d842005-06-21 17:17:11 -07008392 }
NeilBrownfca4d842005-06-21 17:17:11 -07008393
Goldwyn Rodrigues2aa82192015-09-28 19:21:35 -05008394 if (mddev->flags & MD_UPDATE_SB_FLAGS)
NeilBrown850b2b42006-10-03 01:15:46 -07008395 md_update_sb(mddev, 0);
NeilBrown06d91a52005-06-21 17:17:12 -07008396
Linus Torvalds1da177e2005-04-16 15:20:36 -07008397 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
8398 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
8399 /* resync/recovery still happening */
8400 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8401 goto unlock;
8402 }
8403 if (mddev->sync_thread) {
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008404 md_reap_sync_thread(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008405 goto unlock;
8406 }
Neil Brown72a23c22008-06-28 08:31:41 +10008407 /* Set RUNNING before clearing NEEDED to avoid
8408 * any transients in the value of "sync_action".
8409 */
NeilBrown72f36d52012-10-11 14:25:57 +11008410 mddev->curr_resync_completed = 0;
NeilBrown23da4222014-12-15 12:57:01 +11008411 spin_lock(&mddev->lock);
Neil Brown72a23c22008-06-28 08:31:41 +10008412 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrown23da4222014-12-15 12:57:01 +11008413 spin_unlock(&mddev->lock);
NeilBrown24dd4692005-11-08 21:39:26 -08008414 /* Clear some bits that don't mean anything, but
8415 * might be left set
8416 */
NeilBrown24dd4692005-11-08 21:39:26 -08008417 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
8418 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008419
NeilBrowned209582012-04-24 10:23:14 +10008420 if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
8421 test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
NeilBrownac05f252014-09-30 08:10:42 +10008422 goto not_running;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008423 /* no recovery is running.
8424 * remove any failed drives, then
8425 * add spares if possible.
NeilBrown72f36d52012-10-11 14:25:57 +11008426 * Spares are also removed and re-added, to allow
Linus Torvalds1da177e2005-04-16 15:20:36 -07008427 * the personality to fail the re-add.
8428 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07008429
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008430 if (mddev->reshape_position != MaxSector) {
NeilBrown50ac1682009-06-18 08:47:55 +10008431 if (mddev->pers->check_reshape == NULL ||
8432 mddev->pers->check_reshape(mddev) != 0)
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008433 /* Cannot proceed */
NeilBrownac05f252014-09-30 08:10:42 +10008434 goto not_running;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08008435 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10008436 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown746d3202013-04-24 11:42:41 +10008437 } else if ((spares = remove_and_add_spares(mddev, NULL))) {
NeilBrown24dd4692005-11-08 21:39:26 -08008438 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8439 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
Dan Williams56ac36d2008-08-07 10:02:47 -07008440 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10008441 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown24dd4692005-11-08 21:39:26 -08008442 } else if (mddev->recovery_cp < MaxSector) {
8443 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10008444 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown24dd4692005-11-08 21:39:26 -08008445 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
8446 /* nothing to be done ... */
NeilBrownac05f252014-09-30 08:10:42 +10008447 goto not_running;
NeilBrown24dd4692005-11-08 21:39:26 -08008448
Linus Torvalds1da177e2005-04-16 15:20:36 -07008449 if (mddev->pers->sync_request) {
NeilBrownef99bf42012-05-22 13:55:08 +10008450 if (spares) {
NeilBrowna654b9d82005-06-21 17:17:27 -07008451 /* We are adding a device or devices to an array
8452 * which has the bitmap stored on all devices.
8453 * So make sure all bitmap pages get written
8454 */
8455 bitmap_write_all(mddev->bitmap);
8456 }
NeilBrownac05f252014-09-30 08:10:42 +10008457 INIT_WORK(&mddev->del_work, md_start_sync);
8458 queue_work(md_misc_wq, &mddev->del_work);
8459 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008460 }
NeilBrownac05f252014-09-30 08:10:42 +10008461 not_running:
Neil Brown72a23c22008-06-28 08:31:41 +10008462 if (!mddev->sync_thread) {
8463 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11008464 wake_up(&resync_wait);
Neil Brown72a23c22008-06-28 08:31:41 +10008465 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
8466 &mddev->recovery))
NeilBrown0c3573f2009-01-09 08:31:05 +11008467 if (mddev->sysfs_action)
NeilBrown00bcb4a2010-06-01 19:37:23 +10008468 sysfs_notify_dirent_safe(mddev->sysfs_action);
Neil Brown72a23c22008-06-28 08:31:41 +10008469 }
NeilBrownac05f252014-09-30 08:10:42 +10008470 unlock:
8471 wake_up(&mddev->sb_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008472 mddev_unlock(mddev);
8473 }
8474}
NeilBrown6c144d32014-09-30 16:15:38 +10008475EXPORT_SYMBOL(md_check_recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008476
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008477void md_reap_sync_thread(struct mddev *mddev)
8478{
8479 struct md_rdev *rdev;
8480
8481 /* resync has finished, collect result */
8482 md_unregister_thread(&mddev->sync_thread);
8483 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8484 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
8485 /* success...*/
8486 /* activate any spares */
8487 if (mddev->pers->spare_active(mddev)) {
8488 sysfs_notify(&mddev->kobj, NULL,
8489 "degraded");
8490 set_bit(MD_CHANGE_DEVS, &mddev->flags);
8491 }
8492 }
8493 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8494 mddev->pers->finish_reshape)
8495 mddev->pers->finish_reshape(mddev);
8496
8497 /* If array is no-longer degraded, then any saved_raid_disk
NeilBrownf4667222013-12-09 12:04:56 +11008498 * information must be scrapped.
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008499 */
NeilBrownf4667222013-12-09 12:04:56 +11008500 if (!mddev->degraded)
8501 rdev_for_each(rdev, mddev)
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008502 rdev->saved_raid_disk = -1;
8503
8504 md_update_sb(mddev, 1);
8505 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrownea358cd2015-06-12 20:05:04 +10008506 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008507 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8508 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8509 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
8510 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11008511 wake_up(&resync_wait);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008512 /* flag recovery needed just to double check */
8513 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8514 sysfs_notify_dirent_safe(mddev->sysfs_action);
8515 md_new_event(mddev);
8516 if (mddev->event_work.func)
8517 queue_work(md_misc_wq, &mddev->event_work);
8518}
NeilBrown6c144d32014-09-30 16:15:38 +10008519EXPORT_SYMBOL(md_reap_sync_thread);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10008520
NeilBrownfd01b882011-10-11 16:47:53 +11008521void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
Dan Williams6bfe0b42008-04-30 00:52:32 -07008522{
NeilBrown00bcb4a2010-06-01 19:37:23 +10008523 sysfs_notify_dirent_safe(rdev->sysfs_state);
Dan Williams6bfe0b42008-04-30 00:52:32 -07008524 wait_event_timeout(rdev->blocked_wait,
NeilBrownde393cd2011-07-28 11:31:48 +10008525 !test_bit(Blocked, &rdev->flags) &&
8526 !test_bit(BlockedBadBlocks, &rdev->flags),
Dan Williams6bfe0b42008-04-30 00:52:32 -07008527 msecs_to_jiffies(5000));
8528 rdev_dec_pending(rdev, mddev);
8529}
8530EXPORT_SYMBOL(md_wait_for_blocked_rdev);
8531
NeilBrownc6563a82012-05-21 09:27:00 +10008532void md_finish_reshape(struct mddev *mddev)
8533{
8534 /* called be personality module when reshape completes. */
8535 struct md_rdev *rdev;
8536
8537 rdev_for_each(rdev, mddev) {
8538 if (rdev->data_offset > rdev->new_data_offset)
8539 rdev->sectors += rdev->data_offset - rdev->new_data_offset;
8540 else
8541 rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
8542 rdev->data_offset = rdev->new_data_offset;
8543 }
8544}
8545EXPORT_SYMBOL(md_finish_reshape);
NeilBrown2230dfe2011-07-28 11:31:46 +10008546
Vishal Vermafc974ee2015-12-24 19:20:34 -07008547/* Bad block management */
NeilBrown2230dfe2011-07-28 11:31:46 +10008548
Vishal Vermafc974ee2015-12-24 19:20:34 -07008549/* Returns 1 on success, 0 on failure */
NeilBrown3cb03002011-10-11 16:45:26 +11008550int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
NeilBrownc6563a82012-05-21 09:27:00 +10008551 int is_new)
NeilBrown2230dfe2011-07-28 11:31:46 +10008552{
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04008553 struct mddev *mddev = rdev->mddev;
NeilBrownc6563a82012-05-21 09:27:00 +10008554 int rv;
8555 if (is_new)
8556 s += rdev->new_data_offset;
8557 else
8558 s += rdev->data_offset;
Vishal Vermafc974ee2015-12-24 19:20:34 -07008559 rv = badblocks_set(&rdev->badblocks, s, sectors, 0);
8560 if (rv == 0) {
NeilBrown2230dfe2011-07-28 11:31:46 +10008561 /* Make sure they get written out promptly */
NeilBrown8bd2f0a2011-12-08 16:26:08 +11008562 sysfs_notify_dirent_safe(rdev->sysfs_state);
Guoqing Jiang85ad1d12016-05-03 22:22:13 -04008563 set_mask_bits(&mddev->flags, 0,
8564 BIT(MD_CHANGE_CLEAN) | BIT(MD_CHANGE_PENDING));
NeilBrown2230dfe2011-07-28 11:31:46 +10008565 md_wakeup_thread(rdev->mddev->thread);
Vishal Vermafc974ee2015-12-24 19:20:34 -07008566 return 1;
8567 } else
8568 return 0;
NeilBrown2230dfe2011-07-28 11:31:46 +10008569}
8570EXPORT_SYMBOL_GPL(rdev_set_badblocks);
8571
NeilBrownc6563a82012-05-21 09:27:00 +10008572int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
8573 int is_new)
NeilBrown2230dfe2011-07-28 11:31:46 +10008574{
NeilBrownc6563a82012-05-21 09:27:00 +10008575 if (is_new)
8576 s += rdev->new_data_offset;
8577 else
8578 s += rdev->data_offset;
Vishal Vermafc974ee2015-12-24 19:20:34 -07008579 return badblocks_clear(&rdev->badblocks,
NeilBrownc6563a82012-05-21 09:27:00 +10008580 s, sectors);
NeilBrown2230dfe2011-07-28 11:31:46 +10008581}
8582EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
8583
Adrian Bunk75c96f82005-05-05 16:16:09 -07008584static int md_notify_reboot(struct notifier_block *this,
8585 unsigned long code, void *x)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008586{
8587 struct list_head *tmp;
NeilBrownfd01b882011-10-11 16:47:53 +11008588 struct mddev *mddev;
Daniel P. Berrange2dba6a92011-09-23 10:40:45 +01008589 int need_delay = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008590
NeilBrownc744a652012-03-19 12:46:37 +11008591 for_each_mddev(mddev, tmp) {
8592 if (mddev_trylock(mddev)) {
NeilBrown30b8aa92012-04-24 10:23:16 +10008593 if (mddev->pers)
8594 __md_stop_writes(mddev);
NeilBrown0f62fb22014-05-06 09:36:08 +10008595 if (mddev->persistent)
8596 mddev->safemode = 2;
NeilBrownc744a652012-03-19 12:46:37 +11008597 mddev_unlock(mddev);
Daniel P. Berrange2dba6a92011-09-23 10:40:45 +01008598 }
NeilBrownc744a652012-03-19 12:46:37 +11008599 need_delay = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008600 }
NeilBrownc744a652012-03-19 12:46:37 +11008601 /*
8602 * certain more exotic SCSI devices are known to be
8603 * volatile wrt too early system reboots. While the
8604 * right place to handle this issue is the given
8605 * driver, we do want to have a safe RAID driver ...
8606 */
8607 if (need_delay)
8608 mdelay(1000*1);
8609
Linus Torvalds1da177e2005-04-16 15:20:36 -07008610 return NOTIFY_DONE;
8611}
8612
Adrian Bunk75c96f82005-05-05 16:16:09 -07008613static struct notifier_block md_notifier = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07008614 .notifier_call = md_notify_reboot,
8615 .next = NULL,
8616 .priority = INT_MAX, /* before any real devices */
8617};
8618
8619static void md_geninit(void)
8620{
NeilBrown36a4e1f2011-10-07 14:23:17 +11008621 pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07008622
Denis V. Lunevc7705f32008-04-29 01:02:35 -07008623 proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008624}
8625
Adrian Bunk75c96f82005-05-05 16:16:09 -07008626static int __init md_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008627{
Tejun Heoe804ac72010-10-15 15:36:08 +02008628 int ret = -ENOMEM;
8629
Tejun Heoada609e2011-01-25 14:35:54 +01008630 md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
Tejun Heoe804ac72010-10-15 15:36:08 +02008631 if (!md_wq)
8632 goto err_wq;
8633
8634 md_misc_wq = alloc_workqueue("md_misc", 0, 0);
8635 if (!md_misc_wq)
8636 goto err_misc_wq;
8637
8638 if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
8639 goto err_md;
8640
8641 if ((ret = register_blkdev(0, "mdp")) < 0)
8642 goto err_mdp;
8643 mdp_major = ret;
8644
NeilBrownaf5628f2014-07-31 13:54:54 +10008645 blk_register_region(MKDEV(MD_MAJOR, 0), 512, THIS_MODULE,
NeilBrowne8703fe2006-10-03 01:15:59 -07008646 md_probe, NULL, NULL);
8647 blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07008648 md_probe, NULL, NULL);
8649
Linus Torvalds1da177e2005-04-16 15:20:36 -07008650 register_reboot_notifier(&md_notifier);
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08008651 raid_table_header = register_sysctl_table(raid_root_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008652
8653 md_geninit();
NeilBrownd710e132008-10-13 11:55:12 +11008654 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008655
Tejun Heoe804ac72010-10-15 15:36:08 +02008656err_mdp:
8657 unregister_blkdev(MD_MAJOR, "md");
8658err_md:
8659 destroy_workqueue(md_misc_wq);
8660err_misc_wq:
8661 destroy_workqueue(md_wq);
8662err_wq:
8663 return ret;
8664}
Linus Torvalds1da177e2005-04-16 15:20:36 -07008665
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008666static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev)
Goldwyn Rodrigues1d7e3e92014-06-07 01:53:00 -05008667{
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008668 struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
8669 struct md_rdev *rdev2;
8670 int role, ret;
8671 char b[BDEVNAME_SIZE];
Goldwyn Rodrigues1d7e3e92014-06-07 01:53:00 -05008672
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008673 /* Check for change of roles in the active devices */
8674 rdev_for_each(rdev2, mddev) {
8675 if (test_bit(Faulty, &rdev2->flags))
8676 continue;
8677
8678 /* Check if the roles changed */
8679 role = le16_to_cpu(sb->dev_roles[rdev2->desc_nr]);
Goldwyn Rodriguesdbb64f82015-10-01 13:20:27 -05008680
8681 if (test_bit(Candidate, &rdev2->flags)) {
8682 if (role == 0xfffe) {
8683 pr_info("md: Removing Candidate device %s because add failed\n", bdevname(rdev2->bdev,b));
8684 md_kick_rdev_from_array(rdev2);
8685 continue;
8686 }
8687 else
8688 clear_bit(Candidate, &rdev2->flags);
8689 }
8690
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008691 if (role != rdev2->raid_disk) {
8692 /* got activated */
8693 if (rdev2->raid_disk == -1 && role != 0xffff) {
8694 rdev2->saved_raid_disk = role;
8695 ret = remove_and_add_spares(mddev, rdev2);
8696 pr_info("Activated spare: %s\n",
8697 bdevname(rdev2->bdev,b));
Guoqing Jianga5781832016-05-02 11:33:14 -04008698 /* wakeup mddev->thread here, so array could
8699 * perform resync with the new activated disk */
8700 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8701 md_wakeup_thread(mddev->thread);
8702
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008703 }
8704 /* device faulty
8705 * We just want to do the minimum to mark the disk
8706 * as faulty. The recovery is performed by the
8707 * one who initiated the error.
8708 */
8709 if ((role == 0xfffe) || (role == 0xfffd)) {
8710 md_error(mddev, rdev2);
8711 clear_bit(Blocked, &rdev2->flags);
8712 }
8713 }
Goldwyn Rodrigues1d7e3e92014-06-07 01:53:00 -05008714 }
8715
Goldwyn Rodrigues28c1b9f2015-10-22 16:01:25 +11008716 if (mddev->raid_disks != le32_to_cpu(sb->raid_disks))
8717 update_raid_disks(mddev, le32_to_cpu(sb->raid_disks));
Goldwyn Rodrigues70bcecd2015-08-21 10:33:39 -05008718
8719 /* Finally set the event to be up to date */
8720 mddev->events = le64_to_cpu(sb->events);
8721}
8722
8723static int read_rdev(struct mddev *mddev, struct md_rdev *rdev)
8724{
8725 int err;
8726 struct page *swapout = rdev->sb_page;
8727 struct mdp_superblock_1 *sb;
8728
8729 /* Store the sb page of the rdev in the swapout temporary
8730 * variable in case we err in the future
8731 */
8732 rdev->sb_page = NULL;
8733 alloc_disk_sb(rdev);
8734 ClearPageUptodate(rdev->sb_page);
8735 rdev->sb_loaded = 0;
8736 err = super_types[mddev->major_version].load_super(rdev, NULL, mddev->minor_version);
8737
8738 if (err < 0) {
8739 pr_warn("%s: %d Could not reload rdev(%d) err: %d. Restoring old values\n",
8740 __func__, __LINE__, rdev->desc_nr, err);
8741 put_page(rdev->sb_page);
8742 rdev->sb_page = swapout;
8743 rdev->sb_loaded = 1;
8744 return err;
8745 }
8746
8747 sb = page_address(rdev->sb_page);
8748 /* Read the offset unconditionally, even if MD_FEATURE_RECOVERY_OFFSET
8749 * is not set
8750 */
8751
8752 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET))
8753 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
8754
8755 /* The other node finished recovery, call spare_active to set
8756 * device In_sync and mddev->degraded
8757 */
8758 if (rdev->recovery_offset == MaxSector &&
8759 !test_bit(In_sync, &rdev->flags) &&
8760 mddev->pers->spare_active(mddev))
8761 sysfs_notify(&mddev->kobj, NULL, "degraded");
8762
8763 put_page(swapout);
8764 return 0;
8765}
8766
8767void md_reload_sb(struct mddev *mddev, int nr)
8768{
8769 struct md_rdev *rdev;
8770 int err;
8771
8772 /* Find the rdev */
8773 rdev_for_each_rcu(rdev, mddev) {
8774 if (rdev->desc_nr == nr)
8775 break;
8776 }
8777
8778 if (!rdev || rdev->desc_nr != nr) {
8779 pr_warn("%s: %d Could not find rdev with nr %d\n", __func__, __LINE__, nr);
8780 return;
8781 }
8782
8783 err = read_rdev(mddev, rdev);
8784 if (err < 0)
8785 return;
8786
8787 check_sb_changes(mddev, rdev);
8788
8789 /* Read all rdev's to update recovery_offset */
8790 rdev_for_each_rcu(rdev, mddev)
8791 read_rdev(mddev, rdev);
Goldwyn Rodrigues1d7e3e92014-06-07 01:53:00 -05008792}
8793EXPORT_SYMBOL(md_reload_sb);
8794
Linus Torvalds1da177e2005-04-16 15:20:36 -07008795#ifndef MODULE
8796
8797/*
8798 * Searches all registered partitions for autorun RAID arrays
8799 * at boot time.
8800 */
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008801
8802static LIST_HEAD(all_detected_devices);
8803struct detected_devices_node {
8804 struct list_head list;
8805 dev_t dev;
8806};
Linus Torvalds1da177e2005-04-16 15:20:36 -07008807
8808void md_autodetect_dev(dev_t dev)
8809{
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008810 struct detected_devices_node *node_detected_dev;
8811
8812 node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
8813 if (node_detected_dev) {
8814 node_detected_dev->dev = dev;
8815 list_add_tail(&node_detected_dev->list, &all_detected_devices);
8816 } else {
8817 printk(KERN_CRIT "md: md_autodetect_dev: kzalloc failed"
8818 ", skipping dev(%d,%d)\n", MAJOR(dev), MINOR(dev));
8819 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07008820}
8821
Linus Torvalds1da177e2005-04-16 15:20:36 -07008822static void autostart_arrays(int part)
8823{
NeilBrown3cb03002011-10-11 16:45:26 +11008824 struct md_rdev *rdev;
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008825 struct detected_devices_node *node_detected_dev;
8826 dev_t dev;
8827 int i_scanned, i_passed;
8828
8829 i_scanned = 0;
8830 i_passed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008831
8832 printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
8833
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008834 while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
8835 i_scanned++;
8836 node_detected_dev = list_entry(all_detected_devices.next,
8837 struct detected_devices_node, list);
8838 list_del(&node_detected_dev->list);
8839 dev = node_detected_dev->dev;
8840 kfree(node_detected_dev);
NeilBrowndf968c42007-07-17 04:06:11 -07008841 rdev = md_import_device(dev,0, 90);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008842 if (IS_ERR(rdev))
8843 continue;
8844
NeilBrown403df472014-09-30 15:52:29 +10008845 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07008846 continue;
NeilBrown403df472014-09-30 15:52:29 +10008847
NeilBrownd0fae182008-03-04 14:29:31 -08008848 set_bit(AutoDetected, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008849 list_add(&rdev->same_set, &pending_raid_disks);
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008850 i_passed++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008851 }
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008852
8853 printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
8854 i_scanned, i_passed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008855
8856 autorun_devices(part);
8857}
8858
Jeff Garzikfdee8ae2006-12-10 02:20:50 -08008859#endif /* !MODULE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07008860
8861static __exit void md_exit(void)
8862{
NeilBrownfd01b882011-10-11 16:47:53 +11008863 struct mddev *mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008864 struct list_head *tmp;
NeilBrowne2f23b62014-04-09 14:33:51 +10008865 int delay = 1;
Greg Kroah-Hartman8ab5e4c2005-06-20 21:15:16 -07008866
NeilBrownaf5628f2014-07-31 13:54:54 +10008867 blk_unregister_region(MKDEV(MD_MAJOR,0), 512);
NeilBrowne8703fe2006-10-03 01:15:59 -07008868 blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008869
Christoph Hellwig3dbd8c22009-03-31 14:27:02 +11008870 unregister_blkdev(MD_MAJOR,"md");
Linus Torvalds1da177e2005-04-16 15:20:36 -07008871 unregister_blkdev(mdp_major, "mdp");
8872 unregister_reboot_notifier(&md_notifier);
8873 unregister_sysctl_table(raid_table_header);
NeilBrowne2f23b62014-04-09 14:33:51 +10008874
8875 /* We cannot unload the modules while some process is
8876 * waiting for us in select() or poll() - wake them up
8877 */
8878 md_unloading = 1;
8879 while (waitqueue_active(&md_event_waiters)) {
8880 /* not safe to leave yet */
8881 wake_up(&md_event_waiters);
8882 msleep(delay);
8883 delay += delay;
8884 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07008885 remove_proc_entry("mdstat", NULL);
NeilBrowne2f23b62014-04-09 14:33:51 +10008886
NeilBrown29ac4aa2008-02-06 01:39:58 -08008887 for_each_mddev(mddev, tmp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07008888 export_array(mddev);
NeilBrownd3374822009-01-09 08:31:10 +11008889 mddev->hold_active = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008890 }
Tejun Heoe804ac72010-10-15 15:36:08 +02008891 destroy_workqueue(md_misc_wq);
8892 destroy_workqueue(md_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008893}
8894
Dan Williams685784a2007-07-09 11:56:42 -07008895subsys_initcall(md_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008896module_exit(md_exit)
8897
NeilBrownf91de922005-11-08 21:39:36 -08008898static int get_ro(char *buffer, struct kernel_param *kp)
8899{
8900 return sprintf(buffer, "%d", start_readonly);
8901}
8902static int set_ro(const char *val, struct kernel_param *kp)
8903{
Alexey Dobriyan4c9309c2015-05-16 14:02:38 +03008904 return kstrtouint(val, 10, (unsigned int *)&start_readonly);
NeilBrownf91de922005-11-08 21:39:36 -08008905}
8906
NeilBrown80ca3a42006-07-10 04:44:18 -07008907module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
8908module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
NeilBrownefeb53c2009-01-09 08:31:10 +11008909module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
NeilBrownf91de922005-11-08 21:39:36 -08008910
Linus Torvalds1da177e2005-04-16 15:20:36 -07008911MODULE_LICENSE("GPL");
NeilBrown0efb9e62009-12-14 12:49:58 +11008912MODULE_DESCRIPTION("MD RAID framework");
NeilBrownaa1595e2005-08-04 12:53:32 -07008913MODULE_ALIAS("md");
NeilBrown72008652005-08-26 18:34:15 -07008914MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);