blob: b97ac9861ab2be03655bc269dc4df0fa1b7e870f [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/sysctl.h>
NeilBrownbff61972009-03-31 14:33:13 +110038#include <linux/seq_file.h>
Al Viroff01bb42011-09-16 02:31:11 -040039#include <linux/fs.h>
NeilBrownd7603b72006-01-06 00:20:30 -080040#include <linux/poll.h>
NeilBrown16f17b32006-06-26 00:27:37 -070041#include <linux/ctype.h>
André Goddard Rosae7d28602009-12-14 18:01:06 -080042#include <linux/string.h>
NeilBrownfb4d8c72008-10-13 11:55:12 +110043#include <linux/hdreg.h>
44#include <linux/proc_fs.h>
45#include <linux/random.h>
Paul Gortmaker056075c2011-07-03 13:58:33 -040046#include <linux/module.h>
NeilBrownfb4d8c72008-10-13 11:55:12 +110047#include <linux/reboot.h>
NeilBrown32a76272005-06-21 17:17:14 -070048#include <linux/file.h>
Arnd Bergmannaa98aa32009-12-14 12:50:05 +110049#include <linux/compat.h>
Stephen Rothwell25570722008-10-15 09:09:21 +110050#include <linux/delay.h>
NeilBrownbff61972009-03-31 14:33:13 +110051#include <linux/raid/md_p.h>
52#include <linux/raid/md_u.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090053#include <linux/slab.h>
NeilBrown43b2e5d2009-03-31 14:33:13 +110054#include "md.h"
Christoph Hellwigef740c32009-03-31 14:27:03 +110055#include "bitmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#ifndef MODULE
NeilBrownd710e132008-10-13 11:55:12 +110058static void autostart_arrays(int part);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#endif
60
NeilBrown01f96c02011-09-21 15:30:20 +100061/* pers_list is a list of registered personalities protected
62 * by pers_lock.
63 * pers_lock does extra service to protect accesses to
64 * mddev->thread when the mutex cannot be held.
65 */
NeilBrown2604b702006-01-06 00:20:36 -080066static LIST_HEAD(pers_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067static DEFINE_SPINLOCK(pers_lock);
68
Bernd Schubert90b08712008-05-23 13:04:38 -070069static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
Tejun Heoe804ac72010-10-15 15:36:08 +020070static struct workqueue_struct *md_wq;
71static struct workqueue_struct *md_misc_wq;
Bernd Schubert90b08712008-05-23 13:04:38 -070072
NeilBrown746d3202013-04-24 11:42:41 +100073static int remove_and_add_spares(struct mddev *mddev,
74 struct md_rdev *this);
75
Linus Torvalds1da177e2005-04-16 15:20:36 -070076/*
Robert Becker1e509152009-12-14 12:49:58 +110077 * Default number of read corrections we'll attempt on an rdev
78 * before ejecting it from the array. We divide the read error
79 * count by 2 for every hour elapsed between read errors.
80 */
81#define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
82/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
84 * is 1000 KB/sec, so the extra system load does not show up that much.
85 * Increase it if you want to have more _guaranteed_ speed. Note that
Adrian Bunk338cec32005-09-10 00:26:54 -070086 * the RAID driver will use the maximum available bandwidth if the IO
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 * subsystem is idle. There is also an 'absolute maximum' reconstruction
88 * speed limit - in case reconstruction slows down your system despite
89 * idle IO detection.
90 *
91 * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
NeilBrown88202a02006-01-06 00:21:36 -080092 * or /sys/block/mdX/md/sync_speed_{min,max}
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 */
94
95static int sysctl_speed_limit_min = 1000;
96static int sysctl_speed_limit_max = 200000;
NeilBrownfd01b882011-10-11 16:47:53 +110097static inline int speed_min(struct mddev *mddev)
NeilBrown88202a02006-01-06 00:21:36 -080098{
99 return mddev->sync_speed_min ?
100 mddev->sync_speed_min : sysctl_speed_limit_min;
101}
102
NeilBrownfd01b882011-10-11 16:47:53 +1100103static inline int speed_max(struct mddev *mddev)
NeilBrown88202a02006-01-06 00:21:36 -0800104{
105 return mddev->sync_speed_max ?
106 mddev->sync_speed_max : sysctl_speed_limit_max;
107}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
109static struct ctl_table_header *raid_table_header;
110
Joe Perches82592c32013-11-14 15:16:18 +1100111static struct ctl_table raid_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 .procname = "speed_limit_min",
114 .data = &sysctl_speed_limit_min,
115 .maxlen = sizeof(int),
NeilBrown80ca3a42006-07-10 04:44:18 -0700116 .mode = S_IRUGO|S_IWUSR,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800117 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 },
119 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 .procname = "speed_limit_max",
121 .data = &sysctl_speed_limit_max,
122 .maxlen = sizeof(int),
NeilBrown80ca3a42006-07-10 04:44:18 -0700123 .mode = S_IRUGO|S_IWUSR,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800124 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 },
Eric W. Biederman894d2492009-11-05 14:34:02 -0800126 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127};
128
Joe Perches82592c32013-11-14 15:16:18 +1100129static struct ctl_table raid_dir_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 .procname = "raid",
132 .maxlen = 0,
NeilBrown80ca3a42006-07-10 04:44:18 -0700133 .mode = S_IRUGO|S_IXUGO,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 .child = raid_table,
135 },
Eric W. Biederman894d2492009-11-05 14:34:02 -0800136 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137};
138
Joe Perches82592c32013-11-14 15:16:18 +1100139static struct ctl_table raid_root_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 .procname = "dev",
142 .maxlen = 0,
143 .mode = 0555,
144 .child = raid_dir_table,
145 },
Eric W. Biederman894d2492009-11-05 14:34:02 -0800146 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147};
148
Alexey Dobriyan83d5cde2009-09-21 17:01:13 -0700149static const struct block_device_operations md_fops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
NeilBrownf91de922005-11-08 21:39:36 -0800151static int start_readonly;
152
NeilBrowna167f662010-10-26 18:31:13 +1100153/* bio_clone_mddev
154 * like bio_clone, but with a local bio set
155 */
156
NeilBrowna167f662010-10-26 18:31:13 +1100157struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
NeilBrownfd01b882011-10-11 16:47:53 +1100158 struct mddev *mddev)
NeilBrowna167f662010-10-26 18:31:13 +1100159{
160 struct bio *b;
NeilBrowna167f662010-10-26 18:31:13 +1100161
162 if (!mddev || !mddev->bio_set)
163 return bio_alloc(gfp_mask, nr_iovecs);
164
Kent Overstreet395c72a2012-09-06 15:34:55 -0700165 b = bio_alloc_bioset(gfp_mask, nr_iovecs, mddev->bio_set);
NeilBrowna167f662010-10-26 18:31:13 +1100166 if (!b)
167 return NULL;
NeilBrowna167f662010-10-26 18:31:13 +1100168 return b;
169}
170EXPORT_SYMBOL_GPL(bio_alloc_mddev);
171
172struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
NeilBrownfd01b882011-10-11 16:47:53 +1100173 struct mddev *mddev)
NeilBrowna167f662010-10-26 18:31:13 +1100174{
NeilBrowna167f662010-10-26 18:31:13 +1100175 if (!mddev || !mddev->bio_set)
176 return bio_clone(bio, gfp_mask);
177
Kent Overstreetbf800ef2012-09-06 15:35:02 -0700178 return bio_clone_bioset(bio, gfp_mask, mddev->bio_set);
NeilBrowna167f662010-10-26 18:31:13 +1100179}
180EXPORT_SYMBOL_GPL(bio_clone_mddev);
181
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182/*
NeilBrownd7603b72006-01-06 00:20:30 -0800183 * We have a system wide 'event count' that is incremented
184 * on any 'interesting' event, and readers of /proc/mdstat
185 * can use 'poll' or 'select' to find out when the event
186 * count increases.
187 *
188 * Events are:
189 * start array, stop array, error, add device, remove device,
190 * start build, activate spare
191 */
NeilBrown2989ddb2006-01-06 00:20:43 -0800192static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
NeilBrownd7603b72006-01-06 00:20:30 -0800193static atomic_t md_event_count;
NeilBrownfd01b882011-10-11 16:47:53 +1100194void md_new_event(struct mddev *mddev)
NeilBrownd7603b72006-01-06 00:20:30 -0800195{
196 atomic_inc(&md_event_count);
197 wake_up(&md_event_waiters);
198}
NeilBrown29269552006-03-27 01:18:10 -0800199EXPORT_SYMBOL_GPL(md_new_event);
NeilBrownd7603b72006-01-06 00:20:30 -0800200
NeilBrownc331eb02006-05-30 21:27:13 -0700201/* Alternate version that can be called from interrupts
202 * when calling sysfs_notify isn't needed.
203 */
NeilBrownfd01b882011-10-11 16:47:53 +1100204static void md_new_event_inintr(struct mddev *mddev)
NeilBrownc331eb02006-05-30 21:27:13 -0700205{
206 atomic_inc(&md_event_count);
207 wake_up(&md_event_waiters);
208}
209
NeilBrownd7603b72006-01-06 00:20:30 -0800210/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 * Enables to iterate over all existing md arrays
212 * all_mddevs_lock protects this list.
213 */
214static LIST_HEAD(all_mddevs);
215static DEFINE_SPINLOCK(all_mddevs_lock);
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217/*
218 * iterates through all used mddevs in the system.
219 * We take care to grab the all_mddevs_lock whenever navigating
220 * the list, and to always hold a refcount when unlocked.
221 * Any code which breaks out of this loop while own
222 * a reference to the current mddev and must mddev_put it.
223 */
NeilBrownfd01b882011-10-11 16:47:53 +1100224#define for_each_mddev(_mddev,_tmp) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 \
NeilBrownf72ffdd2014-09-30 14:23:59 +1000226 for (({ spin_lock(&all_mddevs_lock); \
NeilBrownfd01b882011-10-11 16:47:53 +1100227 _tmp = all_mddevs.next; \
228 _mddev = NULL;}); \
229 ({ if (_tmp != &all_mddevs) \
230 mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 spin_unlock(&all_mddevs_lock); \
NeilBrownfd01b882011-10-11 16:47:53 +1100232 if (_mddev) mddev_put(_mddev); \
233 _mddev = list_entry(_tmp, struct mddev, all_mddevs); \
234 _tmp != &all_mddevs;}); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 ({ spin_lock(&all_mddevs_lock); \
NeilBrownfd01b882011-10-11 16:47:53 +1100236 _tmp = _tmp->next;}) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 )
238
NeilBrown409c57f2009-03-31 14:39:39 +1100239/* Rather than calling directly into the personality make_request function,
240 * IO requests come here first so that we can check if the device is
241 * being suspended pending a reconfiguration.
242 * We hold a refcount over the call to ->make_request. By the time that
243 * call has finished, the bio has been linked into some internal structure
244 * and so is visible to ->quiesce(), so we don't need the refcount any more.
245 */
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200246static void md_make_request(struct request_queue *q, struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
NeilBrown49077322010-03-25 16:20:56 +1100248 const int rw = bio_data_dir(bio);
NeilBrownfd01b882011-10-11 16:47:53 +1100249 struct mddev *mddev = q->queuedata;
NeilBrown49077322010-03-25 16:20:56 +1100250 int cpu;
Chris Masone91ece52011-02-07 19:21:48 -0500251 unsigned int sectors;
NeilBrown49077322010-03-25 16:20:56 +1100252
NeilBrown0ca698862011-01-14 09:14:33 +1100253 if (mddev == NULL || mddev->pers == NULL
254 || !mddev->ready) {
NeilBrown409c57f2009-03-31 14:39:39 +1100255 bio_io_error(bio);
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200256 return;
NeilBrown409c57f2009-03-31 14:39:39 +1100257 }
Sebastian Riemerbbfa57c2013-02-21 13:28:09 +1100258 if (mddev->ro == 1 && unlikely(rw == WRITE)) {
259 bio_endio(bio, bio_sectors(bio) == 0 ? 0 : -EROFS);
260 return;
261 }
NeilBrown0ca698862011-01-14 09:14:33 +1100262 smp_rmb(); /* Ensure implications of 'active' are visible */
NeilBrown409c57f2009-03-31 14:39:39 +1100263 rcu_read_lock();
Tejun Heoe9c74692010-09-03 11:56:18 +0200264 if (mddev->suspended) {
NeilBrown409c57f2009-03-31 14:39:39 +1100265 DEFINE_WAIT(__wait);
266 for (;;) {
267 prepare_to_wait(&mddev->sb_wait, &__wait,
268 TASK_UNINTERRUPTIBLE);
Tejun Heoe9c74692010-09-03 11:56:18 +0200269 if (!mddev->suspended)
NeilBrown409c57f2009-03-31 14:39:39 +1100270 break;
271 rcu_read_unlock();
272 schedule();
273 rcu_read_lock();
274 }
275 finish_wait(&mddev->sb_wait, &__wait);
276 }
277 atomic_inc(&mddev->active_io);
278 rcu_read_unlock();
NeilBrown49077322010-03-25 16:20:56 +1100279
Chris Masone91ece52011-02-07 19:21:48 -0500280 /*
281 * save the sectors now since our bio can
282 * go away inside make_request
283 */
284 sectors = bio_sectors(bio);
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200285 mddev->pers->make_request(mddev, bio);
NeilBrown49077322010-03-25 16:20:56 +1100286
287 cpu = part_stat_lock();
288 part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
Chris Masone91ece52011-02-07 19:21:48 -0500289 part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors);
NeilBrown49077322010-03-25 16:20:56 +1100290 part_stat_unlock();
291
NeilBrown409c57f2009-03-31 14:39:39 +1100292 if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
293 wake_up(&mddev->sb_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294}
295
NeilBrown9e35b992010-04-06 14:23:02 +1000296/* mddev_suspend makes sure no new requests are submitted
297 * to the device, and that any requests that have been submitted
298 * are completely handled.
299 * Once ->stop is called and completes, the module will be completely
300 * unused.
301 */
NeilBrownfd01b882011-10-11 16:47:53 +1100302void mddev_suspend(struct mddev *mddev)
NeilBrown409c57f2009-03-31 14:39:39 +1100303{
304 BUG_ON(mddev->suspended);
305 mddev->suspended = 1;
306 synchronize_rcu();
307 wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
308 mddev->pers->quiesce(mddev, 1);
Jonathan Brassow0d9f4f12012-05-16 04:06:14 -0500309
310 del_timer_sync(&mddev->safemode_timer);
NeilBrown409c57f2009-03-31 14:39:39 +1100311}
NeilBrown390ee602010-06-01 19:37:27 +1000312EXPORT_SYMBOL_GPL(mddev_suspend);
NeilBrown409c57f2009-03-31 14:39:39 +1100313
NeilBrownfd01b882011-10-11 16:47:53 +1100314void mddev_resume(struct mddev *mddev)
NeilBrown409c57f2009-03-31 14:39:39 +1100315{
316 mddev->suspended = 0;
317 wake_up(&mddev->sb_wait);
318 mddev->pers->quiesce(mddev, 0);
Jonathan Brassow0fd018a2011-06-07 17:49:36 -0500319
Jonathan Brassow47525e52012-05-22 13:55:29 +1000320 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
Jonathan Brassow0fd018a2011-06-07 17:49:36 -0500321 md_wakeup_thread(mddev->thread);
322 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
NeilBrown409c57f2009-03-31 14:39:39 +1100323}
NeilBrown390ee602010-06-01 19:37:27 +1000324EXPORT_SYMBOL_GPL(mddev_resume);
NeilBrown409c57f2009-03-31 14:39:39 +1100325
NeilBrownfd01b882011-10-11 16:47:53 +1100326int mddev_congested(struct mddev *mddev, int bits)
NeilBrown3fa841d2009-09-23 18:10:29 +1000327{
328 return mddev->suspended;
329}
330EXPORT_SYMBOL(mddev_congested);
331
NeilBrowna2826aa2009-12-14 12:49:49 +1100332/*
Tejun Heoe9c74692010-09-03 11:56:18 +0200333 * Generic flush handling for md
NeilBrowna2826aa2009-12-14 12:49:49 +1100334 */
335
Tejun Heoe9c74692010-09-03 11:56:18 +0200336static void md_end_flush(struct bio *bio, int err)
NeilBrowna2826aa2009-12-14 12:49:49 +1100337{
NeilBrown3cb03002011-10-11 16:45:26 +1100338 struct md_rdev *rdev = bio->bi_private;
NeilBrownfd01b882011-10-11 16:47:53 +1100339 struct mddev *mddev = rdev->mddev;
NeilBrowna2826aa2009-12-14 12:49:49 +1100340
341 rdev_dec_pending(rdev, mddev);
342
343 if (atomic_dec_and_test(&mddev->flush_pending)) {
Tejun Heoe9c74692010-09-03 11:56:18 +0200344 /* The pre-request flush has finished */
Tejun Heoe804ac72010-10-15 15:36:08 +0200345 queue_work(md_wq, &mddev->flush_work);
NeilBrowna2826aa2009-12-14 12:49:49 +1100346 }
347 bio_put(bio);
348}
349
NeilBrowna7a07e62010-12-09 16:04:25 +1100350static void md_submit_flush_data(struct work_struct *ws);
351
NeilBrowna035fc32010-12-09 16:17:51 +1100352static void submit_flushes(struct work_struct *ws)
NeilBrowna2826aa2009-12-14 12:49:49 +1100353{
NeilBrownfd01b882011-10-11 16:47:53 +1100354 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
NeilBrown3cb03002011-10-11 16:45:26 +1100355 struct md_rdev *rdev;
NeilBrowna2826aa2009-12-14 12:49:49 +1100356
NeilBrowna7a07e62010-12-09 16:04:25 +1100357 INIT_WORK(&mddev->flush_work, md_submit_flush_data);
358 atomic_set(&mddev->flush_pending, 1);
NeilBrowna2826aa2009-12-14 12:49:49 +1100359 rcu_read_lock();
NeilBrowndafb20f2012-03-19 12:46:39 +1100360 rdev_for_each_rcu(rdev, mddev)
NeilBrowna2826aa2009-12-14 12:49:49 +1100361 if (rdev->raid_disk >= 0 &&
362 !test_bit(Faulty, &rdev->flags)) {
363 /* Take two references, one is dropped
364 * when request finishes, one after
365 * we reclaim rcu_read_lock
366 */
367 struct bio *bi;
368 atomic_inc(&rdev->nr_pending);
369 atomic_inc(&rdev->nr_pending);
370 rcu_read_unlock();
Shaohua Lib5e1b8c2012-05-21 09:26:59 +1000371 bi = bio_alloc_mddev(GFP_NOIO, 0, mddev);
Tejun Heoe9c74692010-09-03 11:56:18 +0200372 bi->bi_end_io = md_end_flush;
NeilBrowna2826aa2009-12-14 12:49:49 +1100373 bi->bi_private = rdev;
374 bi->bi_bdev = rdev->bdev;
375 atomic_inc(&mddev->flush_pending);
Tejun Heoe9c74692010-09-03 11:56:18 +0200376 submit_bio(WRITE_FLUSH, bi);
NeilBrowna2826aa2009-12-14 12:49:49 +1100377 rcu_read_lock();
378 rdev_dec_pending(rdev, mddev);
379 }
380 rcu_read_unlock();
NeilBrowna7a07e62010-12-09 16:04:25 +1100381 if (atomic_dec_and_test(&mddev->flush_pending))
382 queue_work(md_wq, &mddev->flush_work);
NeilBrowna2826aa2009-12-14 12:49:49 +1100383}
384
Tejun Heoe9c74692010-09-03 11:56:18 +0200385static void md_submit_flush_data(struct work_struct *ws)
NeilBrowna2826aa2009-12-14 12:49:49 +1100386{
NeilBrownfd01b882011-10-11 16:47:53 +1100387 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
Tejun Heoe9c74692010-09-03 11:56:18 +0200388 struct bio *bio = mddev->flush_bio;
NeilBrowna2826aa2009-12-14 12:49:49 +1100389
Kent Overstreet4f024f32013-10-11 15:44:27 -0700390 if (bio->bi_iter.bi_size == 0)
NeilBrowna2826aa2009-12-14 12:49:49 +1100391 /* an empty barrier - all done */
392 bio_endio(bio, 0);
393 else {
Tejun Heoe9c74692010-09-03 11:56:18 +0200394 bio->bi_rw &= ~REQ_FLUSH;
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200395 mddev->pers->make_request(mddev, bio);
NeilBrowna2826aa2009-12-14 12:49:49 +1100396 }
NeilBrown2b74e122010-12-09 15:59:01 +1100397
398 mddev->flush_bio = NULL;
399 wake_up(&mddev->sb_wait);
NeilBrowna2826aa2009-12-14 12:49:49 +1100400}
401
NeilBrownfd01b882011-10-11 16:47:53 +1100402void md_flush_request(struct mddev *mddev, struct bio *bio)
NeilBrowna2826aa2009-12-14 12:49:49 +1100403{
404 spin_lock_irq(&mddev->write_lock);
405 wait_event_lock_irq(mddev->sb_wait,
Tejun Heoe9c74692010-09-03 11:56:18 +0200406 !mddev->flush_bio,
Lukas Czernereed8c022012-11-30 11:42:40 +0100407 mddev->write_lock);
Tejun Heoe9c74692010-09-03 11:56:18 +0200408 mddev->flush_bio = bio;
NeilBrowna2826aa2009-12-14 12:49:49 +1100409 spin_unlock_irq(&mddev->write_lock);
410
NeilBrowna035fc32010-12-09 16:17:51 +1100411 INIT_WORK(&mddev->flush_work, submit_flushes);
412 queue_work(md_wq, &mddev->flush_work);
NeilBrowna2826aa2009-12-14 12:49:49 +1100413}
Tejun Heoe9c74692010-09-03 11:56:18 +0200414EXPORT_SYMBOL(md_flush_request);
NeilBrown409c57f2009-03-31 14:39:39 +1100415
NeilBrown74018dc2012-07-31 09:08:15 +0200416void md_unplug(struct blk_plug_cb *cb, bool from_schedule)
NeilBrown97658cd2011-04-18 18:25:42 +1000417{
NeilBrown9cbb1752012-07-31 09:08:14 +0200418 struct mddev *mddev = cb->data;
419 md_wakeup_thread(mddev->thread);
420 kfree(cb);
NeilBrown97658cd2011-04-18 18:25:42 +1000421}
NeilBrown9cbb1752012-07-31 09:08:14 +0200422EXPORT_SYMBOL(md_unplug);
NeilBrown2ac87402010-06-01 19:37:29 +1000423
NeilBrownfd01b882011-10-11 16:47:53 +1100424static inline struct mddev *mddev_get(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425{
426 atomic_inc(&mddev->active);
427 return mddev;
428}
429
Dan Williams5fd3a172009-03-04 00:57:25 -0700430static void mddev_delayed_delete(struct work_struct *ws);
NeilBrownd3374822009-01-09 08:31:10 +1100431
NeilBrownfd01b882011-10-11 16:47:53 +1100432static void mddev_put(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433{
NeilBrowna167f662010-10-26 18:31:13 +1100434 struct bio_set *bs = NULL;
435
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
437 return;
NeilBrownd3374822009-01-09 08:31:10 +1100438 if (!mddev->raid_disks && list_empty(&mddev->disks) &&
NeilBrowncbd19982009-12-30 12:08:49 +1100439 mddev->ctime == 0 && !mddev->hold_active) {
440 /* Array is not configured at all, and not held active,
441 * so destroy it */
NeilBrownaf8a2432011-12-08 15:49:46 +1100442 list_del_init(&mddev->all_mddevs);
NeilBrowna167f662010-10-26 18:31:13 +1100443 bs = mddev->bio_set;
444 mddev->bio_set = NULL;
NeilBrownd3374822009-01-09 08:31:10 +1100445 if (mddev->gendisk) {
Tejun Heoe804ac72010-10-15 15:36:08 +0200446 /* We did a probe so need to clean up. Call
447 * queue_work inside the spinlock so that
448 * flush_workqueue() after mddev_find will
449 * succeed in waiting for the work to be done.
NeilBrownd3374822009-01-09 08:31:10 +1100450 */
451 INIT_WORK(&mddev->del_work, mddev_delayed_delete);
Tejun Heoe804ac72010-10-15 15:36:08 +0200452 queue_work(md_misc_wq, &mddev->del_work);
NeilBrownd3374822009-01-09 08:31:10 +1100453 } else
454 kfree(mddev);
455 }
456 spin_unlock(&all_mddevs_lock);
NeilBrowna167f662010-10-26 18:31:13 +1100457 if (bs)
458 bioset_free(bs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459}
460
NeilBrownfd01b882011-10-11 16:47:53 +1100461void mddev_init(struct mddev *mddev)
NeilBrownfafd7fb2010-04-01 15:55:30 +1100462{
463 mutex_init(&mddev->open_mutex);
464 mutex_init(&mddev->reconfig_mutex);
465 mutex_init(&mddev->bitmap_info.mutex);
466 INIT_LIST_HEAD(&mddev->disks);
467 INIT_LIST_HEAD(&mddev->all_mddevs);
468 init_timer(&mddev->safemode_timer);
469 atomic_set(&mddev->active, 1);
470 atomic_set(&mddev->openers, 0);
471 atomic_set(&mddev->active_io, 0);
472 spin_lock_init(&mddev->write_lock);
473 atomic_set(&mddev->flush_pending, 0);
474 init_waitqueue_head(&mddev->sb_wait);
475 init_waitqueue_head(&mddev->recovery_wait);
476 mddev->reshape_position = MaxSector;
NeilBrown2c810cd2012-05-21 09:27:00 +1000477 mddev->reshape_backwards = 0;
Jonathan Brassowc4a39552013-06-25 01:23:59 -0500478 mddev->last_sync_action = "none";
NeilBrownfafd7fb2010-04-01 15:55:30 +1100479 mddev->resync_min = 0;
480 mddev->resync_max = MaxSector;
481 mddev->level = LEVEL_NONE;
482}
NeilBrown390ee602010-06-01 19:37:27 +1000483EXPORT_SYMBOL_GPL(mddev_init);
NeilBrownfafd7fb2010-04-01 15:55:30 +1100484
NeilBrownf72ffdd2014-09-30 14:23:59 +1000485static struct mddev *mddev_find(dev_t unit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486{
NeilBrownfd01b882011-10-11 16:47:53 +1100487 struct mddev *mddev, *new = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
NeilBrown8f5f02c2011-02-16 13:58:51 +1100489 if (unit && MAJOR(unit) != MD_MAJOR)
490 unit &= ~((1<<MdpMinorShift)-1);
491
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 retry:
493 spin_lock(&all_mddevs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
NeilBrownefeb53c2009-01-09 08:31:10 +1100495 if (unit) {
496 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
497 if (mddev->unit == unit) {
498 mddev_get(mddev);
499 spin_unlock(&all_mddevs_lock);
500 kfree(new);
501 return mddev;
502 }
503
504 if (new) {
505 list_add(&new->all_mddevs, &all_mddevs);
506 spin_unlock(&all_mddevs_lock);
507 new->hold_active = UNTIL_IOCTL;
508 return new;
509 }
510 } else if (new) {
511 /* find an unused unit number */
512 static int next_minor = 512;
513 int start = next_minor;
514 int is_free = 0;
515 int dev = 0;
516 while (!is_free) {
517 dev = MKDEV(MD_MAJOR, next_minor);
518 next_minor++;
519 if (next_minor > MINORMASK)
520 next_minor = 0;
521 if (next_minor == start) {
522 /* Oh dear, all in use. */
523 spin_unlock(&all_mddevs_lock);
524 kfree(new);
525 return NULL;
526 }
NeilBrownf72ffdd2014-09-30 14:23:59 +1000527
NeilBrownefeb53c2009-01-09 08:31:10 +1100528 is_free = 1;
529 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
530 if (mddev->unit == dev) {
531 is_free = 0;
532 break;
533 }
534 }
535 new->unit = dev;
536 new->md_minor = MINOR(dev);
537 new->hold_active = UNTIL_STOP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 list_add(&new->all_mddevs, &all_mddevs);
539 spin_unlock(&all_mddevs_lock);
540 return new;
541 }
542 spin_unlock(&all_mddevs_lock);
543
NeilBrown9ffae0c2006-01-06 00:20:32 -0800544 new = kzalloc(sizeof(*new), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 if (!new)
546 return NULL;
547
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 new->unit = unit;
549 if (MAJOR(unit) == MD_MAJOR)
550 new->md_minor = MINOR(unit);
551 else
552 new->md_minor = MINOR(unit) >> MdpMinorShift;
553
NeilBrownfafd7fb2010-04-01 15:55:30 +1100554 mddev_init(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 goto retry;
557}
558
NeilBrownf72ffdd2014-09-30 14:23:59 +1000559static inline int __must_check mddev_lock(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
NeilBrowndf5b89b2006-03-27 01:18:20 -0800561 return mutex_lock_interruptible(&mddev->reconfig_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562}
563
NeilBrown29f097c2013-11-14 17:54:51 +1100564/* Sometimes we need to take the lock in a situation where
565 * failure due to interrupts is not acceptable.
566 */
NeilBrownf72ffdd2014-09-30 14:23:59 +1000567static inline void mddev_lock_nointr(struct mddev *mddev)
NeilBrown29f097c2013-11-14 17:54:51 +1100568{
569 mutex_lock(&mddev->reconfig_mutex);
570}
571
NeilBrownfd01b882011-10-11 16:47:53 +1100572static inline int mddev_is_locked(struct mddev *mddev)
Dan Williamsb522adc2009-03-31 15:00:31 +1100573{
574 return mutex_is_locked(&mddev->reconfig_mutex);
575}
576
NeilBrownf72ffdd2014-09-30 14:23:59 +1000577static inline int mddev_trylock(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578{
NeilBrowndf5b89b2006-03-27 01:18:20 -0800579 return mutex_trylock(&mddev->reconfig_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580}
581
NeilBrownb6eb1272010-04-15 10:13:47 +1000582static struct attribute_group md_redundancy_group;
583
NeilBrownf72ffdd2014-09-30 14:23:59 +1000584static void mddev_unlock(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
NeilBrowna64c8762010-04-14 17:15:37 +1000586 if (mddev->to_remove) {
NeilBrownb6eb1272010-04-15 10:13:47 +1000587 /* These cannot be removed under reconfig_mutex as
588 * an access to the files will try to take reconfig_mutex
589 * while holding the file unremovable, which leads to
590 * a deadlock.
NeilBrownbb4f1e92010-08-08 21:18:03 +1000591 * So hold set sysfs_active while the remove in happeing,
592 * and anything else which might set ->to_remove or my
593 * otherwise change the sysfs namespace will fail with
594 * -EBUSY if sysfs_active is still set.
595 * We set sysfs_active under reconfig_mutex and elsewhere
596 * test it under the same mutex to ensure its correct value
597 * is seen.
NeilBrownb6eb1272010-04-15 10:13:47 +1000598 */
NeilBrowna64c8762010-04-14 17:15:37 +1000599 struct attribute_group *to_remove = mddev->to_remove;
600 mddev->to_remove = NULL;
NeilBrownbb4f1e92010-08-08 21:18:03 +1000601 mddev->sysfs_active = 1;
NeilBrownb6eb1272010-04-15 10:13:47 +1000602 mutex_unlock(&mddev->reconfig_mutex);
603
NeilBrown00bcb4a2010-06-01 19:37:23 +1000604 if (mddev->kobj.sd) {
605 if (to_remove != &md_redundancy_group)
606 sysfs_remove_group(&mddev->kobj, to_remove);
607 if (mddev->pers == NULL ||
608 mddev->pers->sync_request == NULL) {
609 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
610 if (mddev->sysfs_action)
611 sysfs_put(mddev->sysfs_action);
612 mddev->sysfs_action = NULL;
613 }
NeilBrowna64c8762010-04-14 17:15:37 +1000614 }
NeilBrownbb4f1e92010-08-08 21:18:03 +1000615 mddev->sysfs_active = 0;
NeilBrownb6eb1272010-04-15 10:13:47 +1000616 } else
617 mutex_unlock(&mddev->reconfig_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Chris Dunlop751e67c2011-10-19 16:48:26 +1100619 /* As we've dropped the mutex we need a spinlock to
620 * make sure the thread doesn't disappear
NeilBrown01f96c02011-09-21 15:30:20 +1000621 */
622 spin_lock(&pers_lock);
NeilBrown005eca52005-08-22 13:11:08 -0700623 md_wakeup_thread(mddev->thread);
NeilBrown01f96c02011-09-21 15:30:20 +1000624 spin_unlock(&pers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625}
626
NeilBrown1ca69c42012-10-11 13:37:33 +1100627static struct md_rdev *find_rdev_nr_rcu(struct mddev *mddev, int nr)
628{
629 struct md_rdev *rdev;
630
631 rdev_for_each_rcu(rdev, mddev)
632 if (rdev->desc_nr == nr)
633 return rdev;
634
635 return NULL;
636}
637
638static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639{
NeilBrown3cb03002011-10-11 16:45:26 +1100640 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
NeilBrowndafb20f2012-03-19 12:46:39 +1100642 rdev_for_each(rdev, mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 if (rdev->bdev->bd_dev == dev)
644 return rdev;
Cheng Renquan159ec1f2009-01-09 08:31:08 +1100645
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 return NULL;
647}
648
NeilBrown1ca69c42012-10-11 13:37:33 +1100649static struct md_rdev *find_rdev_rcu(struct mddev *mddev, dev_t dev)
650{
651 struct md_rdev *rdev;
652
653 rdev_for_each_rcu(rdev, mddev)
654 if (rdev->bdev->bd_dev == dev)
655 return rdev;
656
657 return NULL;
658}
659
NeilBrown84fc4b52011-10-11 16:49:58 +1100660static struct md_personality *find_pers(int level, char *clevel)
NeilBrown2604b702006-01-06 00:20:36 -0800661{
NeilBrown84fc4b52011-10-11 16:49:58 +1100662 struct md_personality *pers;
NeilBrownd9d166c2006-01-06 00:20:51 -0800663 list_for_each_entry(pers, &pers_list, list) {
664 if (level != LEVEL_NONE && pers->level == level)
NeilBrown2604b702006-01-06 00:20:36 -0800665 return pers;
NeilBrownd9d166c2006-01-06 00:20:51 -0800666 if (strcmp(pers->name, clevel)==0)
667 return pers;
668 }
NeilBrown2604b702006-01-06 00:20:36 -0800669 return NULL;
670}
671
Andre Nollb73df2d2008-07-11 22:02:23 +1000672/* return the offset of the super block in 512byte sectors */
NeilBrown3cb03002011-10-11 16:45:26 +1100673static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674{
Jonathan Brassow57b2caa2011-01-14 09:14:33 +1100675 sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
Andre Nollb73df2d2008-07-11 22:02:23 +1000676 return MD_NEW_SIZE_SECTORS(num_sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677}
678
NeilBrownf72ffdd2014-09-30 14:23:59 +1000679static int alloc_disk_sb(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 rdev->sb_page = alloc_page(GFP_KERNEL);
682 if (!rdev->sb_page) {
683 printk(KERN_ALERT "md: out of memory.\n");
Andre Nollebc24332008-07-11 22:02:20 +1000684 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 }
686
687 return 0;
688}
689
NeilBrown545c8792012-05-22 13:54:30 +1000690void md_rdev_clear(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691{
692 if (rdev->sb_page) {
NeilBrown2d1f3b52006-01-06 00:20:31 -0800693 put_page(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 rdev->sb_loaded = 0;
695 rdev->sb_page = NULL;
Andre Noll0f420352008-07-11 22:02:23 +1000696 rdev->sb_start = 0;
Andre Nolldd8ac332009-03-31 14:33:13 +1100697 rdev->sectors = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 }
NeilBrown2699b672011-07-28 11:31:47 +1000699 if (rdev->bb_page) {
700 put_page(rdev->bb_page);
701 rdev->bb_page = NULL;
702 }
NeilBrown4fa2f322012-05-22 13:55:01 +1000703 kfree(rdev->badblocks.page);
704 rdev->badblocks.page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705}
NeilBrown545c8792012-05-22 13:54:30 +1000706EXPORT_SYMBOL_GPL(md_rdev_clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
NeilBrown6712ecf2007-09-27 12:47:43 +0200708static void super_written(struct bio *bio, int error)
NeilBrown7bfa19f2005-06-21 17:17:28 -0700709{
NeilBrown3cb03002011-10-11 16:45:26 +1100710 struct md_rdev *rdev = bio->bi_private;
NeilBrownfd01b882011-10-11 16:47:53 +1100711 struct mddev *mddev = rdev->mddev;
NeilBrown7bfa19f2005-06-21 17:17:28 -0700712
NeilBrown3a0f5bb2006-10-03 01:16:03 -0700713 if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags)) {
714 printk("md: super_written gets error=%d, uptodate=%d\n",
715 error, test_bit(BIO_UPTODATE, &bio->bi_flags));
716 WARN_ON(test_bit(BIO_UPTODATE, &bio->bi_flags));
NeilBrowna9701a32005-11-08 21:39:34 -0800717 md_error(mddev, rdev);
NeilBrown3a0f5bb2006-10-03 01:16:03 -0700718 }
NeilBrown7bfa19f2005-06-21 17:17:28 -0700719
NeilBrowna9701a32005-11-08 21:39:34 -0800720 if (atomic_dec_and_test(&mddev->pending_writes))
721 wake_up(&mddev->sb_wait);
Neil Brownf8b58ed2005-06-27 22:29:34 -0700722 bio_put(bio);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700723}
724
NeilBrownfd01b882011-10-11 16:47:53 +1100725void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
NeilBrown7bfa19f2005-06-21 17:17:28 -0700726 sector_t sector, int size, struct page *page)
727{
728 /* write first size bytes of page to sector of rdev
729 * Increment mddev->pending_writes before returning
730 * and decrement it on completion, waking up sb_wait
731 * if zero is reached.
732 * If an error occurred, call md_error
733 */
NeilBrowna167f662010-10-26 18:31:13 +1100734 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, mddev);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700735
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100736 bio->bi_bdev = rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev;
Kent Overstreet4f024f32013-10-11 15:44:27 -0700737 bio->bi_iter.bi_sector = sector;
NeilBrown7bfa19f2005-06-21 17:17:28 -0700738 bio_add_page(bio, page, size, 0);
739 bio->bi_private = rdev;
740 bio->bi_end_io = super_written;
NeilBrowna9701a32005-11-08 21:39:34 -0800741
NeilBrown7bfa19f2005-06-21 17:17:28 -0700742 atomic_inc(&mddev->pending_writes);
Namhyung Kima5bf4df2011-08-25 14:43:34 +1000743 submit_bio(WRITE_FLUSH_FUA, bio);
NeilBrowna9701a32005-11-08 21:39:34 -0800744}
745
NeilBrownfd01b882011-10-11 16:47:53 +1100746void md_super_wait(struct mddev *mddev)
NeilBrowna9701a32005-11-08 21:39:34 -0800747{
Tejun Heoe9c74692010-09-03 11:56:18 +0200748 /* wait for all superblock writes that were scheduled to complete */
NeilBrown1967cd52014-09-09 14:20:28 +1000749 wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
NeilBrown7bfa19f2005-06-21 17:17:28 -0700750}
751
NeilBrown3cb03002011-10-11 16:45:26 +1100752int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100753 struct page *page, int rw, bool metadata_op)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754{
NeilBrowna167f662010-10-26 18:31:13 +1100755 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 int ret;
757
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +1100758 bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
759 rdev->meta_bdev : rdev->bdev;
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100760 if (metadata_op)
Kent Overstreet4f024f32013-10-11 15:44:27 -0700761 bio->bi_iter.bi_sector = sector + rdev->sb_start;
NeilBrown1fdd6fc92012-05-21 09:28:32 +1000762 else if (rdev->mddev->reshape_position != MaxSector &&
763 (rdev->mddev->reshape_backwards ==
764 (sector >= rdev->mddev->reshape_position)))
Kent Overstreet4f024f32013-10-11 15:44:27 -0700765 bio->bi_iter.bi_sector = sector + rdev->new_data_offset;
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100766 else
Kent Overstreet4f024f32013-10-11 15:44:27 -0700767 bio->bi_iter.bi_sector = sector + rdev->data_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 bio_add_page(bio, page, size, 0);
Kent Overstreetc170bbb2013-11-24 16:32:22 -0700769 submit_bio_wait(rw, bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
771 ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
772 bio_put(bio);
773 return ret;
774}
NeilBrowna8745db2006-01-06 00:20:34 -0800775EXPORT_SYMBOL_GPL(sync_page_io);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
NeilBrownf72ffdd2014-09-30 14:23:59 +1000777static int read_disk_sb(struct md_rdev *rdev, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778{
779 char b[BDEVNAME_SIZE];
NeilBrown403df472014-09-30 15:52:29 +1000780
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if (rdev->sb_loaded)
782 return 0;
783
Jonathan Brassowccebd4c2011-01-14 09:14:33 +1100784 if (!sync_page_io(rdev, 0, size, rdev->sb_page, READ, true))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 goto fail;
786 rdev->sb_loaded = 1;
787 return 0;
788
789fail:
790 printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
791 bdevname(rdev->bdev,b));
792 return -EINVAL;
793}
794
795static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
796{
NeilBrownf72ffdd2014-09-30 14:23:59 +1000797 return sb1->set_uuid0 == sb2->set_uuid0 &&
Andre Noll05710462008-07-11 22:02:20 +1000798 sb1->set_uuid1 == sb2->set_uuid1 &&
799 sb1->set_uuid2 == sb2->set_uuid2 &&
800 sb1->set_uuid3 == sb2->set_uuid3;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801}
802
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
804{
805 int ret;
806 mdp_super_t *tmp1, *tmp2;
807
808 tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
809 tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
810
811 if (!tmp1 || !tmp2) {
812 ret = 0;
Andre Noll35020f12008-03-23 15:10:33 +0100813 printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 goto abort;
815 }
816
817 *tmp1 = *sb1;
818 *tmp2 = *sb2;
819
820 /*
821 * nr_disks is not constant
822 */
823 tmp1->nr_disks = 0;
824 tmp2->nr_disks = 0;
825
Andre Nollce0c8e02008-07-11 22:02:20 +1000826 ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827abort:
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700828 kfree(tmp1);
829 kfree(tmp2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 return ret;
831}
832
NeilBrown4d167f02007-05-09 02:35:37 -0700833static u32 md_csum_fold(u32 csum)
834{
835 csum = (csum & 0xffff) + (csum >> 16);
836 return (csum & 0xffff) + (csum >> 16);
837}
838
NeilBrownf72ffdd2014-09-30 14:23:59 +1000839static unsigned int calc_sb_csum(mdp_super_t *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840{
NeilBrown4d167f02007-05-09 02:35:37 -0700841 u64 newcsum = 0;
842 u32 *sb32 = (u32*)sb;
843 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 unsigned int disk_csum, csum;
845
846 disk_csum = sb->sb_csum;
847 sb->sb_csum = 0;
NeilBrown4d167f02007-05-09 02:35:37 -0700848
849 for (i = 0; i < MD_SB_BYTES/4 ; i++)
850 newcsum += sb32[i];
851 csum = (newcsum & 0xffffffff) + (newcsum>>32);
852
NeilBrown4d167f02007-05-09 02:35:37 -0700853#ifdef CONFIG_ALPHA
854 /* This used to use csum_partial, which was wrong for several
855 * reasons including that different results are returned on
856 * different architectures. It isn't critical that we get exactly
857 * the same return value as before (we always csum_fold before
858 * testing, and that removes any differences). However as we
859 * know that csum_partial always returned a 16bit value on
860 * alphas, do a fold to maximise conformity to previous behaviour.
861 */
862 sb->sb_csum = md_csum_fold(disk_csum);
863#else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 sb->sb_csum = disk_csum;
NeilBrown4d167f02007-05-09 02:35:37 -0700865#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 return csum;
867}
868
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869/*
870 * Handle superblock details.
871 * We want to be able to handle multiple superblock formats
872 * so we have a common interface to them all, and an array of
873 * different handlers.
874 * We rely on user-space to write the initial superblock, and support
875 * reading and updating of superblocks.
876 * Interface methods are:
NeilBrown3cb03002011-10-11 16:45:26 +1100877 * int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 * loads and validates a superblock on dev.
879 * if refdev != NULL, compare superblocks on both devices
880 * Return:
881 * 0 - dev has a superblock that is compatible with refdev
882 * 1 - dev has a superblock that is compatible and newer than refdev
883 * so dev should be used as the refdev in future
884 * -EINVAL superblock incompatible or invalid
885 * -othererror e.g. -EIO
886 *
NeilBrownfd01b882011-10-11 16:47:53 +1100887 * int validate_super(struct mddev *mddev, struct md_rdev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 * Verify that dev is acceptable into mddev.
889 * The first time, mddev->raid_disks will be 0, and data from
890 * dev should be merged in. Subsequent calls check that dev
891 * is new enough. Return 0 or -EINVAL
892 *
NeilBrownfd01b882011-10-11 16:47:53 +1100893 * void sync_super(struct mddev *mddev, struct md_rdev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 * Update the superblock for rdev with data in mddev
895 * This does not write to disc.
896 *
897 */
898
899struct super_type {
Chris Webb0cd17fe2008-06-28 08:31:46 +1000900 char *name;
901 struct module *owner;
NeilBrownc6563a82012-05-21 09:27:00 +1000902 int (*load_super)(struct md_rdev *rdev,
903 struct md_rdev *refdev,
Chris Webb0cd17fe2008-06-28 08:31:46 +1000904 int minor_version);
NeilBrownc6563a82012-05-21 09:27:00 +1000905 int (*validate_super)(struct mddev *mddev,
906 struct md_rdev *rdev);
907 void (*sync_super)(struct mddev *mddev,
908 struct md_rdev *rdev);
NeilBrown3cb03002011-10-11 16:45:26 +1100909 unsigned long long (*rdev_size_change)(struct md_rdev *rdev,
Andre Noll15f4a5f2008-07-21 14:42:12 +1000910 sector_t num_sectors);
NeilBrownc6563a82012-05-21 09:27:00 +1000911 int (*allow_new_offset)(struct md_rdev *rdev,
912 unsigned long long new_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913};
914
915/*
Andre Noll0894cc32009-06-18 08:49:23 +1000916 * Check that the given mddev has no bitmap.
917 *
918 * This function is called from the run method of all personalities that do not
919 * support bitmaps. It prints an error message and returns non-zero if mddev
920 * has a bitmap. Otherwise, it returns 0.
921 *
922 */
NeilBrownfd01b882011-10-11 16:47:53 +1100923int md_check_no_bitmap(struct mddev *mddev)
Andre Noll0894cc32009-06-18 08:49:23 +1000924{
NeilBrownc3d97142009-12-14 12:49:52 +1100925 if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
Andre Noll0894cc32009-06-18 08:49:23 +1000926 return 0;
927 printk(KERN_ERR "%s: bitmaps are not supported for %s\n",
928 mdname(mddev), mddev->pers->name);
929 return 1;
930}
931EXPORT_SYMBOL(md_check_no_bitmap);
932
933/*
NeilBrownf72ffdd2014-09-30 14:23:59 +1000934 * load_super for 0.90.0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 */
NeilBrown3cb03002011-10-11 16:45:26 +1100936static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937{
938 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
939 mdp_super_t *sb;
940 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941
942 /*
Andre Noll0f420352008-07-11 22:02:23 +1000943 * Calculate the position of the superblock (512byte sectors),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 * it's at the end of the disk.
945 *
946 * It also happens to be a multiple of 4Kb.
947 */
Jonathan Brassow57b2caa2011-01-14 09:14:33 +1100948 rdev->sb_start = calc_dev_sboffset(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
NeilBrown0002b272005-09-09 16:23:53 -0700950 ret = read_disk_sb(rdev, MD_SB_BYTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 if (ret) return ret;
952
953 ret = -EINVAL;
954
955 bdevname(rdev->bdev, b);
Namhyung Kim65a06f062011-07-27 11:00:36 +1000956 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957
958 if (sb->md_magic != MD_SB_MAGIC) {
959 printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
960 b);
961 goto abort;
962 }
963
964 if (sb->major_version != 0 ||
NeilBrownf6705572006-03-27 01:18:11 -0800965 sb->minor_version < 90 ||
966 sb->minor_version > 91) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
968 sb->major_version, sb->minor_version,
969 b);
970 goto abort;
971 }
972
973 if (sb->raid_disks <= 0)
974 goto abort;
975
NeilBrown4d167f02007-05-09 02:35:37 -0700976 if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
978 b);
979 goto abort;
980 }
981
982 rdev->preferred_minor = sb->md_minor;
983 rdev->data_offset = 0;
NeilBrownc6563a82012-05-21 09:27:00 +1000984 rdev->new_data_offset = 0;
NeilBrown0002b272005-09-09 16:23:53 -0700985 rdev->sb_size = MD_SB_BYTES;
NeilBrown9f2f3832011-07-28 11:31:47 +1000986 rdev->badblocks.shift = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987
988 if (sb->level == LEVEL_MULTIPATH)
989 rdev->desc_nr = -1;
990 else
991 rdev->desc_nr = sb->this_disk.number;
992
Harvey Harrison9a7b2b02008-04-28 02:15:49 -0700993 if (!refdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 ret = 1;
Harvey Harrison9a7b2b02008-04-28 02:15:49 -0700995 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 __u64 ev1, ev2;
Namhyung Kim65a06f062011-07-27 11:00:36 +1000997 mdp_super_t *refsb = page_address(refdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 if (!uuid_equal(refsb, sb)) {
999 printk(KERN_WARNING "md: %s has different UUID to %s\n",
1000 b, bdevname(refdev->bdev,b2));
1001 goto abort;
1002 }
1003 if (!sb_equal(refsb, sb)) {
1004 printk(KERN_WARNING "md: %s has same UUID"
1005 " but different superblock to %s\n",
1006 b, bdevname(refdev->bdev, b2));
1007 goto abort;
1008 }
1009 ev1 = md_event(sb);
1010 ev2 = md_event(refsb);
1011 if (ev1 > ev2)
1012 ret = 1;
NeilBrownf72ffdd2014-09-30 14:23:59 +10001013 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 ret = 0;
1015 }
NeilBrown8190e752009-06-18 08:48:58 +10001016 rdev->sectors = rdev->sb_start;
NeilBrown667a5312012-08-16 16:46:12 +10001017 /* Limit to 4TB as metadata cannot record more than that.
1018 * (not needed for Linear and RAID0 as metadata doesn't
1019 * record this size)
1020 */
1021 if (rdev->sectors >= (2ULL << 32) && sb->level >= 1)
NeilBrown27a7b262011-09-10 17:21:28 +10001022 rdev->sectors = (2ULL << 32) - 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023
NeilBrown27a7b262011-09-10 17:21:28 +10001024 if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
NeilBrown2bf071b2006-01-06 00:20:55 -08001025 /* "this cannot possibly happen" ... */
1026 ret = -EINVAL;
1027
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 abort:
1029 return ret;
1030}
1031
1032/*
1033 * validate_super for 0.90.0
1034 */
NeilBrownfd01b882011-10-11 16:47:53 +11001035static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036{
1037 mdp_disk_t *desc;
Namhyung Kim65a06f062011-07-27 11:00:36 +10001038 mdp_super_t *sb = page_address(rdev->sb_page);
NeilBrown07d84d102006-06-26 00:27:56 -07001039 __u64 ev1 = md_event(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040
NeilBrown41158c72005-06-21 17:17:25 -07001041 rdev->raid_disk = -1;
NeilBrownc5d79ad2008-02-06 01:39:54 -08001042 clear_bit(Faulty, &rdev->flags);
1043 clear_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11001044 clear_bit(Bitmap_sync, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001045 clear_bit(WriteMostly, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001046
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 if (mddev->raid_disks == 0) {
1048 mddev->major_version = 0;
1049 mddev->minor_version = sb->minor_version;
1050 mddev->patch_version = sb->patch_version;
NeilBrowne6910632008-02-06 01:39:51 -08001051 mddev->external = 0;
Andre Noll9d8f0362009-06-18 08:45:01 +10001052 mddev->chunk_sectors = sb->chunk_size >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 mddev->ctime = sb->ctime;
1054 mddev->utime = sb->utime;
1055 mddev->level = sb->level;
NeilBrownd9d166c2006-01-06 00:20:51 -08001056 mddev->clevel[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 mddev->layout = sb->layout;
1058 mddev->raid_disks = sb->raid_disks;
NeilBrown27a7b262011-09-10 17:21:28 +10001059 mddev->dev_sectors = ((sector_t)sb->size) * 2;
NeilBrown07d84d102006-06-26 00:27:56 -07001060 mddev->events = ev1;
NeilBrownc3d97142009-12-14 12:49:52 +11001061 mddev->bitmap_info.offset = 0;
NeilBrown6409bb02012-05-22 13:55:07 +10001062 mddev->bitmap_info.space = 0;
1063 /* bitmap can use 60 K after the 4K superblocks */
NeilBrownc3d97142009-12-14 12:49:52 +11001064 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
NeilBrown6409bb02012-05-22 13:55:07 +10001065 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
NeilBrown2c810cd2012-05-21 09:27:00 +10001066 mddev->reshape_backwards = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
NeilBrownf6705572006-03-27 01:18:11 -08001068 if (mddev->minor_version >= 91) {
1069 mddev->reshape_position = sb->reshape_position;
1070 mddev->delta_disks = sb->delta_disks;
1071 mddev->new_level = sb->new_level;
1072 mddev->new_layout = sb->new_layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001073 mddev->new_chunk_sectors = sb->new_chunk >> 9;
NeilBrown2c810cd2012-05-21 09:27:00 +10001074 if (mddev->delta_disks < 0)
1075 mddev->reshape_backwards = 1;
NeilBrownf6705572006-03-27 01:18:11 -08001076 } else {
1077 mddev->reshape_position = MaxSector;
1078 mddev->delta_disks = 0;
1079 mddev->new_level = mddev->level;
1080 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001081 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownf6705572006-03-27 01:18:11 -08001082 }
1083
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 if (sb->state & (1<<MD_SB_CLEAN))
1085 mddev->recovery_cp = MaxSector;
1086 else {
NeilBrownf72ffdd2014-09-30 14:23:59 +10001087 if (sb->events_hi == sb->cp_events_hi &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 sb->events_lo == sb->cp_events_lo) {
1089 mddev->recovery_cp = sb->recovery_cp;
1090 } else
1091 mddev->recovery_cp = 0;
1092 }
1093
1094 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
1095 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
1096 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
1097 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
1098
1099 mddev->max_disks = MD_SB_DISKS;
NeilBrowna654b9d82005-06-21 17:17:27 -07001100
1101 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
NeilBrown6409bb02012-05-22 13:55:07 +10001102 mddev->bitmap_info.file == NULL) {
NeilBrownc3d97142009-12-14 12:49:52 +11001103 mddev->bitmap_info.offset =
1104 mddev->bitmap_info.default_offset;
NeilBrown6409bb02012-05-22 13:55:07 +10001105 mddev->bitmap_info.space =
Dave Jonesc9ad0202013-08-19 22:26:32 -04001106 mddev->bitmap_info.default_space;
NeilBrown6409bb02012-05-22 13:55:07 +10001107 }
NeilBrowna654b9d82005-06-21 17:17:27 -07001108
NeilBrown41158c72005-06-21 17:17:25 -07001109 } else if (mddev->pers == NULL) {
NeilBrownbe6800a2010-05-18 10:17:09 +10001110 /* Insist on good event counter while assembling, except
1111 * for spares (which don't need an event count) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 ++ev1;
NeilBrownbe6800a2010-05-18 10:17:09 +10001113 if (sb->disks[rdev->desc_nr].state & (
1114 (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
NeilBrownf72ffdd2014-09-30 14:23:59 +10001115 if (ev1 < mddev->events)
NeilBrownbe6800a2010-05-18 10:17:09 +10001116 return -EINVAL;
NeilBrown41158c72005-06-21 17:17:25 -07001117 } else if (mddev->bitmap) {
1118 /* if adding to array with a bitmap, then we can accept an
1119 * older device ... but not too old.
1120 */
NeilBrown41158c72005-06-21 17:17:25 -07001121 if (ev1 < mddev->bitmap->events_cleared)
1122 return 0;
NeilBrown8313b8e2013-12-12 10:13:33 +11001123 if (ev1 < mddev->events)
1124 set_bit(Bitmap_sync, &rdev->flags);
NeilBrown07d84d102006-06-26 00:27:56 -07001125 } else {
1126 if (ev1 < mddev->events)
1127 /* just a hot-add of a new device, leave raid_disk at -1 */
1128 return 0;
1129 }
NeilBrown41158c72005-06-21 17:17:25 -07001130
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 if (mddev->level != LEVEL_MULTIPATH) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 desc = sb->disks + rdev->desc_nr;
1133
1134 if (desc->state & (1<<MD_DISK_FAULTY))
NeilBrownb2d444d2005-11-08 21:39:31 -08001135 set_bit(Faulty, &rdev->flags);
NeilBrown7c7546c2006-06-26 00:27:41 -07001136 else if (desc->state & (1<<MD_DISK_SYNC) /* &&
1137 desc->raid_disk < mddev->raid_disks */) {
NeilBrownb2d444d2005-11-08 21:39:31 -08001138 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 rdev->raid_disk = desc->raid_disk;
NeilBrownf4667222013-12-09 12:04:56 +11001140 rdev->saved_raid_disk = desc->raid_disk;
NeilBrown0261cd9f2009-11-13 17:40:48 +11001141 } else if (desc->state & (1<<MD_DISK_ACTIVE)) {
1142 /* active but not in sync implies recovery up to
1143 * reshape position. We don't know exactly where
1144 * that is, so set to zero for now */
1145 if (mddev->minor_version >= 91) {
1146 rdev->recovery_offset = 0;
1147 rdev->raid_disk = desc->raid_disk;
1148 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07001150 if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
1151 set_bit(WriteMostly, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001152 } else /* MULTIPATH are always insync */
NeilBrownb2d444d2005-11-08 21:39:31 -08001153 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 return 0;
1155}
1156
1157/*
1158 * sync_super for 0.90.0
1159 */
NeilBrownfd01b882011-10-11 16:47:53 +11001160static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161{
1162 mdp_super_t *sb;
NeilBrown3cb03002011-10-11 16:45:26 +11001163 struct md_rdev *rdev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 int next_spare = mddev->raid_disks;
NeilBrown19133a42005-11-08 21:39:35 -08001165
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 /* make rdev->sb match mddev data..
1167 *
1168 * 1/ zero out disks
1169 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
1170 * 3/ any empty disks < next_spare become removed
1171 *
1172 * disks[0] gets initialised to REMOVED because
1173 * we cannot be sure from other fields if it has
1174 * been initialised or not.
1175 */
1176 int i;
1177 int active=0, working=0,failed=0,spare=0,nr_disks=0;
1178
NeilBrown61181562005-09-09 16:24:02 -07001179 rdev->sb_size = MD_SB_BYTES;
1180
Namhyung Kim65a06f062011-07-27 11:00:36 +10001181 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
1183 memset(sb, 0, sizeof(*sb));
1184
1185 sb->md_magic = MD_SB_MAGIC;
1186 sb->major_version = mddev->major_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 sb->patch_version = mddev->patch_version;
1188 sb->gvalid_words = 0; /* ignored */
1189 memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
1190 memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
1191 memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
1192 memcpy(&sb->set_uuid3, mddev->uuid+12,4);
1193
1194 sb->ctime = mddev->ctime;
1195 sb->level = mddev->level;
Andre Noll58c0fed2009-03-31 14:33:13 +11001196 sb->size = mddev->dev_sectors / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 sb->raid_disks = mddev->raid_disks;
1198 sb->md_minor = mddev->md_minor;
NeilBrowne6910632008-02-06 01:39:51 -08001199 sb->not_persistent = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 sb->utime = mddev->utime;
1201 sb->state = 0;
1202 sb->events_hi = (mddev->events>>32);
1203 sb->events_lo = (u32)mddev->events;
1204
NeilBrownf6705572006-03-27 01:18:11 -08001205 if (mddev->reshape_position == MaxSector)
1206 sb->minor_version = 90;
1207 else {
1208 sb->minor_version = 91;
1209 sb->reshape_position = mddev->reshape_position;
1210 sb->new_level = mddev->new_level;
1211 sb->delta_disks = mddev->delta_disks;
1212 sb->new_layout = mddev->new_layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001213 sb->new_chunk = mddev->new_chunk_sectors << 9;
NeilBrownf6705572006-03-27 01:18:11 -08001214 }
1215 mddev->minor_version = sb->minor_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 if (mddev->in_sync)
1217 {
1218 sb->recovery_cp = mddev->recovery_cp;
1219 sb->cp_events_hi = (mddev->events>>32);
1220 sb->cp_events_lo = (u32)mddev->events;
1221 if (mddev->recovery_cp == MaxSector)
1222 sb->state = (1<< MD_SB_CLEAN);
1223 } else
1224 sb->recovery_cp = 0;
1225
1226 sb->layout = mddev->layout;
Andre Noll9d8f0362009-06-18 08:45:01 +10001227 sb->chunk_size = mddev->chunk_sectors << 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228
NeilBrownc3d97142009-12-14 12:49:52 +11001229 if (mddev->bitmap && mddev->bitmap_info.file == NULL)
NeilBrowna654b9d82005-06-21 17:17:27 -07001230 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
1231
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 sb->disks[0].state = (1<<MD_DISK_REMOVED);
NeilBrowndafb20f2012-03-19 12:46:39 +11001233 rdev_for_each(rdev2, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 mdp_disk_t *d;
NeilBrown86e6ffd2005-11-08 21:39:24 -08001235 int desc_nr;
NeilBrown0261cd9f2009-11-13 17:40:48 +11001236 int is_active = test_bit(In_sync, &rdev2->flags);
1237
1238 if (rdev2->raid_disk >= 0 &&
1239 sb->minor_version >= 91)
1240 /* we have nowhere to store the recovery_offset,
1241 * but if it is not below the reshape_position,
1242 * we can piggy-back on that.
1243 */
1244 is_active = 1;
1245 if (rdev2->raid_disk < 0 ||
1246 test_bit(Faulty, &rdev2->flags))
1247 is_active = 0;
1248 if (is_active)
NeilBrown86e6ffd2005-11-08 21:39:24 -08001249 desc_nr = rdev2->raid_disk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 else
NeilBrown86e6ffd2005-11-08 21:39:24 -08001251 desc_nr = next_spare++;
NeilBrown19133a42005-11-08 21:39:35 -08001252 rdev2->desc_nr = desc_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 d = &sb->disks[rdev2->desc_nr];
1254 nr_disks++;
1255 d->number = rdev2->desc_nr;
1256 d->major = MAJOR(rdev2->bdev->bd_dev);
1257 d->minor = MINOR(rdev2->bdev->bd_dev);
NeilBrown0261cd9f2009-11-13 17:40:48 +11001258 if (is_active)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 d->raid_disk = rdev2->raid_disk;
1260 else
1261 d->raid_disk = rdev2->desc_nr; /* compatibility */
NeilBrown1be78922006-03-27 01:18:03 -08001262 if (test_bit(Faulty, &rdev2->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 d->state = (1<<MD_DISK_FAULTY);
NeilBrown0261cd9f2009-11-13 17:40:48 +11001264 else if (is_active) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 d->state = (1<<MD_DISK_ACTIVE);
NeilBrown0261cd9f2009-11-13 17:40:48 +11001266 if (test_bit(In_sync, &rdev2->flags))
1267 d->state |= (1<<MD_DISK_SYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 active++;
1269 working++;
1270 } else {
1271 d->state = 0;
1272 spare++;
1273 working++;
1274 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07001275 if (test_bit(WriteMostly, &rdev2->flags))
1276 d->state |= (1<<MD_DISK_WRITEMOSTLY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 /* now set the "removed" and "faulty" bits on any missing devices */
1279 for (i=0 ; i < mddev->raid_disks ; i++) {
1280 mdp_disk_t *d = &sb->disks[i];
1281 if (d->state == 0 && d->number == 0) {
1282 d->number = i;
1283 d->raid_disk = i;
1284 d->state = (1<<MD_DISK_REMOVED);
1285 d->state |= (1<<MD_DISK_FAULTY);
1286 failed++;
1287 }
1288 }
1289 sb->nr_disks = nr_disks;
1290 sb->active_disks = active;
1291 sb->working_disks = working;
1292 sb->failed_disks = failed;
1293 sb->spare_disks = spare;
1294
1295 sb->this_disk = sb->disks[rdev->desc_nr];
1296 sb->sb_csum = calc_sb_csum(sb);
1297}
1298
1299/*
Chris Webb0cd17fe2008-06-28 08:31:46 +10001300 * rdev_size_change for 0.90.0
1301 */
1302static unsigned long long
NeilBrown3cb03002011-10-11 16:45:26 +11001303super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001304{
Andre Noll58c0fed2009-03-31 14:33:13 +11001305 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001306 return 0; /* component must fit device */
NeilBrownc3d97142009-12-14 12:49:52 +11001307 if (rdev->mddev->bitmap_info.offset)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001308 return 0; /* can't move bitmap */
Jonathan Brassow57b2caa2011-01-14 09:14:33 +11001309 rdev->sb_start = calc_dev_sboffset(rdev);
Andre Noll15f4a5f2008-07-21 14:42:12 +10001310 if (!num_sectors || num_sectors > rdev->sb_start)
1311 num_sectors = rdev->sb_start;
NeilBrown27a7b262011-09-10 17:21:28 +10001312 /* Limit to 4TB as metadata cannot record more than that.
1313 * 4TB == 2^32 KB, or 2*2^32 sectors.
1314 */
NeilBrown667a5312012-08-16 16:46:12 +10001315 if (num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1)
NeilBrown27a7b262011-09-10 17:21:28 +10001316 num_sectors = (2ULL << 32) - 2;
Andre Noll0f420352008-07-11 22:02:23 +10001317 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001318 rdev->sb_page);
1319 md_super_wait(rdev->mddev);
Justin Maggardc26a44e2010-11-24 16:36:17 +11001320 return num_sectors;
Chris Webb0cd17fe2008-06-28 08:31:46 +10001321}
1322
NeilBrownc6563a82012-05-21 09:27:00 +10001323static int
1324super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset)
1325{
1326 /* non-zero offset changes not possible with v0.90 */
1327 return new_offset == 0;
1328}
Chris Webb0cd17fe2008-06-28 08:31:46 +10001329
1330/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 * version 1 superblock
1332 */
1333
NeilBrownf72ffdd2014-09-30 14:23:59 +10001334static __le32 calc_sb_1_csum(struct mdp_superblock_1 *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335{
NeilBrown1c05b4b2006-10-21 10:24:08 -07001336 __le32 disk_csum;
1337 u32 csum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 unsigned long long newcsum;
1339 int size = 256 + le32_to_cpu(sb->max_dev)*2;
NeilBrown1c05b4b2006-10-21 10:24:08 -07001340 __le32 *isuper = (__le32*)sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
1342 disk_csum = sb->sb_csum;
1343 sb->sb_csum = 0;
1344 newcsum = 0;
NeilBrown1f3c9902012-12-11 13:09:00 +11001345 for (; size >= 4; size -= 4)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 newcsum += le32_to_cpu(*isuper++);
1347
1348 if (size == 2)
NeilBrown1c05b4b2006-10-21 10:24:08 -07001349 newcsum += le16_to_cpu(*(__le16*) isuper);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350
1351 csum = (newcsum & 0xffffffff) + (newcsum >> 32);
1352 sb->sb_csum = disk_csum;
1353 return cpu_to_le32(csum);
1354}
1355
NeilBrown2699b672011-07-28 11:31:47 +10001356static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
1357 int acknowledged);
NeilBrown3cb03002011-10-11 16:45:26 +11001358static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359{
1360 struct mdp_superblock_1 *sb;
1361 int ret;
Andre Noll0f420352008-07-11 22:02:23 +10001362 sector_t sb_start;
NeilBrownc6563a82012-05-21 09:27:00 +10001363 sector_t sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
NeilBrown0002b272005-09-09 16:23:53 -07001365 int bmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366
1367 /*
Andre Noll0f420352008-07-11 22:02:23 +10001368 * Calculate the position of the superblock in 512byte sectors.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 * It is always aligned to a 4K boundary and
1370 * depeding on minor_version, it can be:
1371 * 0: At least 8K, but less than 12K, from end of device
1372 * 1: At start of device
1373 * 2: 4K from start of device.
1374 */
1375 switch(minor_version) {
1376 case 0:
Mike Snitzer77304d22010-11-08 14:39:12 +01001377 sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;
Andre Noll0f420352008-07-11 22:02:23 +10001378 sb_start -= 8*2;
1379 sb_start &= ~(sector_t)(4*2-1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 break;
1381 case 1:
Andre Noll0f420352008-07-11 22:02:23 +10001382 sb_start = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 break;
1384 case 2:
Andre Noll0f420352008-07-11 22:02:23 +10001385 sb_start = 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 break;
1387 default:
1388 return -EINVAL;
1389 }
Andre Noll0f420352008-07-11 22:02:23 +10001390 rdev->sb_start = sb_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
NeilBrown0002b272005-09-09 16:23:53 -07001392 /* superblock is rarely larger than 1K, but it can be larger,
1393 * and it is safe to read 4k, so we do that
1394 */
1395 ret = read_disk_sb(rdev, 4096);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 if (ret) return ret;
1397
Namhyung Kim65a06f062011-07-27 11:00:36 +10001398 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
1400 if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
1401 sb->major_version != cpu_to_le32(1) ||
1402 le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
Andre Noll0f420352008-07-11 22:02:23 +10001403 le64_to_cpu(sb->super_offset) != rdev->sb_start ||
NeilBrown71c08052005-09-09 16:23:51 -07001404 (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 return -EINVAL;
1406
1407 if (calc_sb_1_csum(sb) != sb->sb_csum) {
1408 printk("md: invalid superblock checksum on %s\n",
1409 bdevname(rdev->bdev,b));
1410 return -EINVAL;
1411 }
1412 if (le64_to_cpu(sb->data_size) < 10) {
1413 printk("md: data_size too small on %s\n",
1414 bdevname(rdev->bdev,b));
1415 return -EINVAL;
1416 }
NeilBrownc6563a82012-05-21 09:27:00 +10001417 if (sb->pad0 ||
1418 sb->pad3[0] ||
1419 memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1])))
1420 /* Some padding is non-zero, might be a new feature */
1421 return -EINVAL;
NeilBrowne11e93f2007-05-09 02:35:36 -07001422
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 rdev->preferred_minor = 0xffff;
1424 rdev->data_offset = le64_to_cpu(sb->data_offset);
NeilBrownc6563a82012-05-21 09:27:00 +10001425 rdev->new_data_offset = rdev->data_offset;
1426 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) &&
1427 (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
1428 rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset);
NeilBrown4dbcdc72006-01-06 00:20:52 -08001429 atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430
NeilBrown0002b272005-09-09 16:23:53 -07001431 rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
Martin K. Petersene1defc42009-05-22 17:17:49 -04001432 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
NeilBrown0002b272005-09-09 16:23:53 -07001433 if (rdev->sb_size & bmask)
NeilBrowna1801f82008-03-04 14:29:31 -08001434 rdev->sb_size = (rdev->sb_size | bmask) + 1;
1435
1436 if (minor_version
Andre Noll0f420352008-07-11 22:02:23 +10001437 && rdev->data_offset < sb_start + (rdev->sb_size/512))
NeilBrowna1801f82008-03-04 14:29:31 -08001438 return -EINVAL;
NeilBrownc6563a82012-05-21 09:27:00 +10001439 if (minor_version
1440 && rdev->new_data_offset < sb_start + (rdev->sb_size/512))
1441 return -EINVAL;
NeilBrown0002b272005-09-09 16:23:53 -07001442
NeilBrown31b65a02006-07-10 04:44:14 -07001443 if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
1444 rdev->desc_nr = -1;
1445 else
1446 rdev->desc_nr = le32_to_cpu(sb->dev_number);
1447
NeilBrown2699b672011-07-28 11:31:47 +10001448 if (!rdev->bb_page) {
1449 rdev->bb_page = alloc_page(GFP_KERNEL);
1450 if (!rdev->bb_page)
1451 return -ENOMEM;
1452 }
1453 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
1454 rdev->badblocks.count == 0) {
1455 /* need to load the bad block list.
1456 * Currently we limit it to one page.
1457 */
1458 s32 offset;
1459 sector_t bb_sector;
1460 u64 *bbp;
1461 int i;
1462 int sectors = le16_to_cpu(sb->bblog_size);
1463 if (sectors > (PAGE_SIZE / 512))
1464 return -EINVAL;
1465 offset = le32_to_cpu(sb->bblog_offset);
1466 if (offset == 0)
1467 return -EINVAL;
1468 bb_sector = (long long)offset;
1469 if (!sync_page_io(rdev, bb_sector, sectors << 9,
1470 rdev->bb_page, READ, true))
1471 return -EIO;
1472 bbp = (u64 *)page_address(rdev->bb_page);
1473 rdev->badblocks.shift = sb->bblog_shift;
1474 for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
1475 u64 bb = le64_to_cpu(*bbp);
1476 int count = bb & (0x3ff);
1477 u64 sector = bb >> 10;
1478 sector <<= sb->bblog_shift;
1479 count <<= sb->bblog_shift;
1480 if (bb + 1 == 0)
1481 break;
1482 if (md_set_badblocks(&rdev->badblocks,
1483 sector, count, 1) == 0)
1484 return -EINVAL;
1485 }
NeilBrown486adf72013-04-24 11:42:44 +10001486 } else if (sb->bblog_offset != 0)
1487 rdev->badblocks.shift = 0;
NeilBrown2699b672011-07-28 11:31:47 +10001488
Harvey Harrison9a7b2b02008-04-28 02:15:49 -07001489 if (!refdev) {
NeilBrown8ed75462006-02-03 03:03:41 -08001490 ret = 1;
Harvey Harrison9a7b2b02008-04-28 02:15:49 -07001491 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 __u64 ev1, ev2;
Namhyung Kim65a06f062011-07-27 11:00:36 +10001493 struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
1495 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1496 sb->level != refsb->level ||
1497 sb->layout != refsb->layout ||
1498 sb->chunksize != refsb->chunksize) {
1499 printk(KERN_WARNING "md: %s has strangely different"
1500 " superblock to %s\n",
1501 bdevname(rdev->bdev,b),
1502 bdevname(refdev->bdev,b2));
1503 return -EINVAL;
1504 }
1505 ev1 = le64_to_cpu(sb->events);
1506 ev2 = le64_to_cpu(refsb->events);
1507
1508 if (ev1 > ev2)
NeilBrown8ed75462006-02-03 03:03:41 -08001509 ret = 1;
1510 else
1511 ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 }
NeilBrownc6563a82012-05-21 09:27:00 +10001513 if (minor_version) {
1514 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9);
1515 sectors -= rdev->data_offset;
1516 } else
1517 sectors = rdev->sb_start;
1518 if (sectors < le64_to_cpu(sb->data_size))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 return -EINVAL;
Andre Nolldd8ac332009-03-31 14:33:13 +11001520 rdev->sectors = le64_to_cpu(sb->data_size);
NeilBrown8ed75462006-02-03 03:03:41 -08001521 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522}
1523
NeilBrownfd01b882011-10-11 16:47:53 +11001524static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525{
Namhyung Kim65a06f062011-07-27 11:00:36 +10001526 struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
NeilBrown07d84d102006-06-26 00:27:56 -07001527 __u64 ev1 = le64_to_cpu(sb->events);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528
NeilBrown41158c72005-06-21 17:17:25 -07001529 rdev->raid_disk = -1;
NeilBrownc5d79ad2008-02-06 01:39:54 -08001530 clear_bit(Faulty, &rdev->flags);
1531 clear_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11001532 clear_bit(Bitmap_sync, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001533 clear_bit(WriteMostly, &rdev->flags);
NeilBrownc5d79ad2008-02-06 01:39:54 -08001534
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 if (mddev->raid_disks == 0) {
1536 mddev->major_version = 1;
1537 mddev->patch_version = 0;
NeilBrowne6910632008-02-06 01:39:51 -08001538 mddev->external = 0;
Andre Noll9d8f0362009-06-18 08:45:01 +10001539 mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
1541 mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
1542 mddev->level = le32_to_cpu(sb->level);
NeilBrownd9d166c2006-01-06 00:20:51 -08001543 mddev->clevel[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 mddev->layout = le32_to_cpu(sb->layout);
1545 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
Andre Noll58c0fed2009-03-31 14:33:13 +11001546 mddev->dev_sectors = le64_to_cpu(sb->size);
NeilBrown07d84d102006-06-26 00:27:56 -07001547 mddev->events = ev1;
NeilBrownc3d97142009-12-14 12:49:52 +11001548 mddev->bitmap_info.offset = 0;
NeilBrown6409bb02012-05-22 13:55:07 +10001549 mddev->bitmap_info.space = 0;
1550 /* Default location for bitmap is 1K after superblock
1551 * using 3K - total of 4K
1552 */
NeilBrownc3d97142009-12-14 12:49:52 +11001553 mddev->bitmap_info.default_offset = 1024 >> 9;
NeilBrown6409bb02012-05-22 13:55:07 +10001554 mddev->bitmap_info.default_space = (4096-1024) >> 9;
NeilBrown2c810cd2012-05-21 09:27:00 +10001555 mddev->reshape_backwards = 0;
1556
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1558 memcpy(mddev->uuid, sb->set_uuid, 16);
1559
1560 mddev->max_disks = (4096-256)/2;
NeilBrowna654b9d82005-06-21 17:17:27 -07001561
NeilBrown71c08052005-09-09 16:23:51 -07001562 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
NeilBrown6409bb02012-05-22 13:55:07 +10001563 mddev->bitmap_info.file == NULL) {
NeilBrownc3d97142009-12-14 12:49:52 +11001564 mddev->bitmap_info.offset =
1565 (__s32)le32_to_cpu(sb->bitmap_offset);
NeilBrown6409bb02012-05-22 13:55:07 +10001566 /* Metadata doesn't record how much space is available.
1567 * For 1.0, we assume we can use up to the superblock
1568 * if before, else to 4K beyond superblock.
1569 * For others, assume no change is possible.
1570 */
1571 if (mddev->minor_version > 0)
1572 mddev->bitmap_info.space = 0;
1573 else if (mddev->bitmap_info.offset > 0)
1574 mddev->bitmap_info.space =
1575 8 - mddev->bitmap_info.offset;
1576 else
1577 mddev->bitmap_info.space =
1578 -mddev->bitmap_info.offset;
1579 }
NeilBrowne11e93f2007-05-09 02:35:36 -07001580
NeilBrownf6705572006-03-27 01:18:11 -08001581 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
1582 mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1583 mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1584 mddev->new_level = le32_to_cpu(sb->new_level);
1585 mddev->new_layout = le32_to_cpu(sb->new_layout);
Andre Noll664e7c42009-06-18 08:45:27 +10001586 mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
NeilBrown2c810cd2012-05-21 09:27:00 +10001587 if (mddev->delta_disks < 0 ||
1588 (mddev->delta_disks == 0 &&
1589 (le32_to_cpu(sb->feature_map)
1590 & MD_FEATURE_RESHAPE_BACKWARDS)))
1591 mddev->reshape_backwards = 1;
NeilBrownf6705572006-03-27 01:18:11 -08001592 } else {
1593 mddev->reshape_position = MaxSector;
1594 mddev->delta_disks = 0;
1595 mddev->new_level = mddev->level;
1596 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10001597 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownf6705572006-03-27 01:18:11 -08001598 }
1599
NeilBrown41158c72005-06-21 17:17:25 -07001600 } else if (mddev->pers == NULL) {
NeilBrownbe6800a2010-05-18 10:17:09 +10001601 /* Insist of good event counter while assembling, except for
1602 * spares (which don't need an event count) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 ++ev1;
NeilBrownbe6800a2010-05-18 10:17:09 +10001604 if (rdev->desc_nr >= 0 &&
1605 rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
1606 le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < 0xfffe)
1607 if (ev1 < mddev->events)
1608 return -EINVAL;
NeilBrown41158c72005-06-21 17:17:25 -07001609 } else if (mddev->bitmap) {
1610 /* If adding to array with a bitmap, then we can accept an
1611 * older device, but not too old.
1612 */
NeilBrown41158c72005-06-21 17:17:25 -07001613 if (ev1 < mddev->bitmap->events_cleared)
1614 return 0;
NeilBrown8313b8e2013-12-12 10:13:33 +11001615 if (ev1 < mddev->events)
1616 set_bit(Bitmap_sync, &rdev->flags);
NeilBrown07d84d102006-06-26 00:27:56 -07001617 } else {
1618 if (ev1 < mddev->events)
1619 /* just a hot-add of a new device, leave raid_disk at -1 */
1620 return 0;
1621 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 if (mddev->level != LEVEL_MULTIPATH) {
1623 int role;
NeilBrown3673f302009-08-03 10:59:56 +10001624 if (rdev->desc_nr < 0 ||
1625 rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
1626 role = 0xffff;
1627 rdev->desc_nr = -1;
1628 } else
1629 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 switch(role) {
1631 case 0xffff: /* spare */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 break;
1633 case 0xfffe: /* faulty */
NeilBrownb2d444d2005-11-08 21:39:31 -08001634 set_bit(Faulty, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 break;
1636 default:
NeilBrownf4667222013-12-09 12:04:56 +11001637 rdev->saved_raid_disk = role;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001638 if ((le32_to_cpu(sb->feature_map) &
NeilBrownf4667222013-12-09 12:04:56 +11001639 MD_FEATURE_RECOVERY_OFFSET)) {
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001640 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
NeilBrownf4667222013-12-09 12:04:56 +11001641 if (!(le32_to_cpu(sb->feature_map) &
1642 MD_FEATURE_RECOVERY_BITMAP))
1643 rdev->saved_raid_disk = -1;
1644 } else
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001645 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 rdev->raid_disk = role;
1647 break;
1648 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07001649 if (sb->devflags & WriteMostly1)
1650 set_bit(WriteMostly, &rdev->flags);
NeilBrown2d78f8c2011-12-23 10:17:51 +11001651 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT)
1652 set_bit(Replacement, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001653 } else /* MULTIPATH are always insync */
NeilBrownb2d444d2005-11-08 21:39:31 -08001654 set_bit(In_sync, &rdev->flags);
NeilBrown41158c72005-06-21 17:17:25 -07001655
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 return 0;
1657}
1658
NeilBrownfd01b882011-10-11 16:47:53 +11001659static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660{
1661 struct mdp_superblock_1 *sb;
NeilBrown3cb03002011-10-11 16:45:26 +11001662 struct md_rdev *rdev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 int max_dev, i;
1664 /* make rdev->sb match mddev and rdev data. */
1665
Namhyung Kim65a06f062011-07-27 11:00:36 +10001666 sb = page_address(rdev->sb_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667
1668 sb->feature_map = 0;
1669 sb->pad0 = 0;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001670 sb->recovery_offset = cpu_to_le64(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 memset(sb->pad3, 0, sizeof(sb->pad3));
1672
1673 sb->utime = cpu_to_le64((__u64)mddev->utime);
1674 sb->events = cpu_to_le64(mddev->events);
1675 if (mddev->in_sync)
1676 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
1677 else
1678 sb->resync_offset = cpu_to_le64(0);
1679
NeilBrown1c05b4b2006-10-21 10:24:08 -07001680 sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
NeilBrown4dbcdc72006-01-06 00:20:52 -08001681
NeilBrownf0ca3402006-02-02 14:28:04 -08001682 sb->raid_disks = cpu_to_le32(mddev->raid_disks);
Andre Noll58c0fed2009-03-31 14:33:13 +11001683 sb->size = cpu_to_le64(mddev->dev_sectors);
Andre Noll9d8f0362009-06-18 08:45:01 +10001684 sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
NeilBrown62e1e382009-05-26 09:40:59 +10001685 sb->level = cpu_to_le32(mddev->level);
1686 sb->layout = cpu_to_le32(mddev->layout);
NeilBrownf0ca3402006-02-02 14:28:04 -08001687
NeilBrownaeb9b212011-08-25 14:43:08 +10001688 if (test_bit(WriteMostly, &rdev->flags))
1689 sb->devflags |= WriteMostly1;
1690 else
1691 sb->devflags &= ~WriteMostly1;
NeilBrownc6563a82012-05-21 09:27:00 +10001692 sb->data_offset = cpu_to_le64(rdev->data_offset);
1693 sb->data_size = cpu_to_le64(rdev->sectors);
NeilBrownaeb9b212011-08-25 14:43:08 +10001694
NeilBrownc3d97142009-12-14 12:49:52 +11001695 if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
1696 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
NeilBrown71c08052005-09-09 16:23:51 -07001697 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
NeilBrowna654b9d82005-06-21 17:17:27 -07001698 }
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001699
1700 if (rdev->raid_disk >= 0 &&
NeilBrown97e4f422009-03-31 14:33:13 +11001701 !test_bit(In_sync, &rdev->flags)) {
NeilBrown93be75f2009-12-14 12:50:06 +11001702 sb->feature_map |=
1703 cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
1704 sb->recovery_offset =
1705 cpu_to_le64(rdev->recovery_offset);
NeilBrownf4667222013-12-09 12:04:56 +11001706 if (rdev->saved_raid_disk >= 0 && mddev->bitmap)
1707 sb->feature_map |=
1708 cpu_to_le32(MD_FEATURE_RECOVERY_BITMAP);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001709 }
NeilBrown2d78f8c2011-12-23 10:17:51 +11001710 if (test_bit(Replacement, &rdev->flags))
1711 sb->feature_map |=
1712 cpu_to_le32(MD_FEATURE_REPLACEMENT);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001713
NeilBrownf6705572006-03-27 01:18:11 -08001714 if (mddev->reshape_position != MaxSector) {
1715 sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
1716 sb->reshape_position = cpu_to_le64(mddev->reshape_position);
1717 sb->new_layout = cpu_to_le32(mddev->new_layout);
1718 sb->delta_disks = cpu_to_le32(mddev->delta_disks);
1719 sb->new_level = cpu_to_le32(mddev->new_level);
Andre Noll664e7c42009-06-18 08:45:27 +10001720 sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
NeilBrown2c810cd2012-05-21 09:27:00 +10001721 if (mddev->delta_disks == 0 &&
1722 mddev->reshape_backwards)
1723 sb->feature_map
1724 |= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
NeilBrownc6563a82012-05-21 09:27:00 +10001725 if (rdev->new_data_offset != rdev->data_offset) {
1726 sb->feature_map
1727 |= cpu_to_le32(MD_FEATURE_NEW_OFFSET);
1728 sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset
1729 - rdev->data_offset));
1730 }
NeilBrownf6705572006-03-27 01:18:11 -08001731 }
NeilBrowna654b9d82005-06-21 17:17:27 -07001732
NeilBrown2699b672011-07-28 11:31:47 +10001733 if (rdev->badblocks.count == 0)
1734 /* Nothing to do for bad blocks*/ ;
1735 else if (sb->bblog_offset == 0)
1736 /* Cannot record bad blocks on this device */
1737 md_error(mddev, rdev);
1738 else {
1739 struct badblocks *bb = &rdev->badblocks;
1740 u64 *bbp = (u64 *)page_address(rdev->bb_page);
1741 u64 *p = bb->page;
1742 sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
1743 if (bb->changed) {
1744 unsigned seq;
1745
1746retry:
1747 seq = read_seqbegin(&bb->lock);
1748
1749 memset(bbp, 0xff, PAGE_SIZE);
1750
1751 for (i = 0 ; i < bb->count ; i++) {
majianpeng35f9ac22012-11-08 08:56:27 +08001752 u64 internal_bb = p[i];
NeilBrown2699b672011-07-28 11:31:47 +10001753 u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
1754 | BB_LEN(internal_bb));
majianpeng35f9ac22012-11-08 08:56:27 +08001755 bbp[i] = cpu_to_le64(store_bb);
NeilBrown2699b672011-07-28 11:31:47 +10001756 }
NeilBrownd0962932012-03-19 12:46:41 +11001757 bb->changed = 0;
NeilBrown2699b672011-07-28 11:31:47 +10001758 if (read_seqretry(&bb->lock, seq))
1759 goto retry;
1760
1761 bb->sector = (rdev->sb_start +
1762 (int)le32_to_cpu(sb->bblog_offset));
1763 bb->size = le16_to_cpu(sb->bblog_size);
NeilBrown2699b672011-07-28 11:31:47 +10001764 }
1765 }
1766
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 max_dev = 0;
NeilBrowndafb20f2012-03-19 12:46:39 +11001768 rdev_for_each(rdev2, mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 if (rdev2->desc_nr+1 > max_dev)
1770 max_dev = rdev2->desc_nr+1;
NeilBrowna778b732007-05-23 13:58:10 -07001771
NeilBrown70471da2009-08-03 10:59:57 +10001772 if (max_dev > le32_to_cpu(sb->max_dev)) {
1773 int bmask;
NeilBrowna778b732007-05-23 13:58:10 -07001774 sb->max_dev = cpu_to_le32(max_dev);
NeilBrown70471da2009-08-03 10:59:57 +10001775 rdev->sb_size = max_dev * 2 + 256;
1776 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1777 if (rdev->sb_size & bmask)
1778 rdev->sb_size = (rdev->sb_size | bmask) + 1;
NeilBrownddcf3522010-09-08 16:48:17 +10001779 } else
1780 max_dev = le32_to_cpu(sb->max_dev);
1781
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 for (i=0; i<max_dev;i++)
1783 sb->dev_roles[i] = cpu_to_le16(0xfffe);
NeilBrownf72ffdd2014-09-30 14:23:59 +10001784
NeilBrowndafb20f2012-03-19 12:46:39 +11001785 rdev_for_each(rdev2, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 i = rdev2->desc_nr;
NeilBrownb2d444d2005-11-08 21:39:31 -08001787 if (test_bit(Faulty, &rdev2->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 sb->dev_roles[i] = cpu_to_le16(0xfffe);
NeilBrownb2d444d2005-11-08 21:39:31 -08001789 else if (test_bit(In_sync, &rdev2->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
NeilBrown93be75f2009-12-14 12:50:06 +11001791 else if (rdev2->raid_disk >= 0)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07001792 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 else
1794 sb->dev_roles[i] = cpu_to_le16(0xffff);
1795 }
1796
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 sb->sb_csum = calc_sb_1_csum(sb);
1798}
1799
Chris Webb0cd17fe2008-06-28 08:31:46 +10001800static unsigned long long
NeilBrown3cb03002011-10-11 16:45:26 +11001801super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001802{
1803 struct mdp_superblock_1 *sb;
Andre Noll15f4a5f2008-07-21 14:42:12 +10001804 sector_t max_sectors;
Andre Noll58c0fed2009-03-31 14:33:13 +11001805 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10001806 return 0; /* component must fit device */
NeilBrownc6563a82012-05-21 09:27:00 +10001807 if (rdev->data_offset != rdev->new_data_offset)
1808 return 0; /* too confusing */
Andre Noll0f420352008-07-11 22:02:23 +10001809 if (rdev->sb_start < rdev->data_offset) {
Chris Webb0cd17fe2008-06-28 08:31:46 +10001810 /* minor versions 1 and 2; superblock before data */
Mike Snitzer77304d22010-11-08 14:39:12 +01001811 max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9;
Andre Noll15f4a5f2008-07-21 14:42:12 +10001812 max_sectors -= rdev->data_offset;
1813 if (!num_sectors || num_sectors > max_sectors)
1814 num_sectors = max_sectors;
NeilBrownc3d97142009-12-14 12:49:52 +11001815 } else if (rdev->mddev->bitmap_info.offset) {
Chris Webb0cd17fe2008-06-28 08:31:46 +10001816 /* minor version 0 with bitmap we can't move */
1817 return 0;
1818 } else {
1819 /* minor version 0; superblock after data */
Andre Noll0f420352008-07-11 22:02:23 +10001820 sector_t sb_start;
Mike Snitzer77304d22010-11-08 14:39:12 +01001821 sb_start = (i_size_read(rdev->bdev->bd_inode) >> 9) - 8*2;
Andre Noll0f420352008-07-11 22:02:23 +10001822 sb_start &= ~(sector_t)(4*2 - 1);
Andre Nolldd8ac332009-03-31 14:33:13 +11001823 max_sectors = rdev->sectors + sb_start - rdev->sb_start;
Andre Noll15f4a5f2008-07-21 14:42:12 +10001824 if (!num_sectors || num_sectors > max_sectors)
1825 num_sectors = max_sectors;
Andre Noll0f420352008-07-11 22:02:23 +10001826 rdev->sb_start = sb_start;
Chris Webb0cd17fe2008-06-28 08:31:46 +10001827 }
Namhyung Kim65a06f062011-07-27 11:00:36 +10001828 sb = page_address(rdev->sb_page);
Andre Noll15f4a5f2008-07-21 14:42:12 +10001829 sb->data_size = cpu_to_le64(num_sectors);
Andre Noll0f420352008-07-11 22:02:23 +10001830 sb->super_offset = rdev->sb_start;
Chris Webb0cd17fe2008-06-28 08:31:46 +10001831 sb->sb_csum = calc_sb_1_csum(sb);
Andre Noll0f420352008-07-11 22:02:23 +10001832 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001833 rdev->sb_page);
1834 md_super_wait(rdev->mddev);
Justin Maggardc26a44e2010-11-24 16:36:17 +11001835 return num_sectors;
NeilBrownc6563a82012-05-21 09:27:00 +10001836
1837}
1838
1839static int
1840super_1_allow_new_offset(struct md_rdev *rdev,
1841 unsigned long long new_offset)
1842{
1843 /* All necessary checks on new >= old have been done */
1844 struct bitmap *bitmap;
1845 if (new_offset >= rdev->data_offset)
1846 return 1;
1847
1848 /* with 1.0 metadata, there is no metadata to tread on
1849 * so we can always move back */
1850 if (rdev->mddev->minor_version == 0)
1851 return 1;
1852
1853 /* otherwise we must be sure not to step on
1854 * any metadata, so stay:
1855 * 36K beyond start of superblock
1856 * beyond end of badblocks
1857 * beyond write-intent bitmap
1858 */
1859 if (rdev->sb_start + (32+4)*2 > new_offset)
1860 return 0;
1861 bitmap = rdev->mddev->bitmap;
1862 if (bitmap && !rdev->mddev->bitmap_info.file &&
1863 rdev->sb_start + rdev->mddev->bitmap_info.offset +
NeilBrown1ec885c2012-05-22 13:55:10 +10001864 bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
NeilBrownc6563a82012-05-21 09:27:00 +10001865 return 0;
1866 if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
1867 return 0;
1868
1869 return 1;
Chris Webb0cd17fe2008-06-28 08:31:46 +10001870}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871
Adrian Bunk75c96f82005-05-05 16:16:09 -07001872static struct super_type super_types[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 [0] = {
1874 .name = "0.90.0",
1875 .owner = THIS_MODULE,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001876 .load_super = super_90_load,
1877 .validate_super = super_90_validate,
1878 .sync_super = super_90_sync,
1879 .rdev_size_change = super_90_rdev_size_change,
NeilBrownc6563a82012-05-21 09:27:00 +10001880 .allow_new_offset = super_90_allow_new_offset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 },
1882 [1] = {
1883 .name = "md-1",
1884 .owner = THIS_MODULE,
Chris Webb0cd17fe2008-06-28 08:31:46 +10001885 .load_super = super_1_load,
1886 .validate_super = super_1_validate,
1887 .sync_super = super_1_sync,
1888 .rdev_size_change = super_1_rdev_size_change,
NeilBrownc6563a82012-05-21 09:27:00 +10001889 .allow_new_offset = super_1_allow_new_offset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 },
1891};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892
NeilBrownfd01b882011-10-11 16:47:53 +11001893static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
Jonathan Brassow076f9682011-06-07 17:51:30 -05001894{
1895 if (mddev->sync_super) {
1896 mddev->sync_super(mddev, rdev);
1897 return;
1898 }
1899
1900 BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));
1901
1902 super_types[mddev->major_version].sync_super(mddev, rdev);
1903}
1904
NeilBrownfd01b882011-10-11 16:47:53 +11001905static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906{
NeilBrown3cb03002011-10-11 16:45:26 +11001907 struct md_rdev *rdev, *rdev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908
NeilBrown4b809912008-07-21 17:05:25 +10001909 rcu_read_lock();
1910 rdev_for_each_rcu(rdev, mddev1)
1911 rdev_for_each_rcu(rdev2, mddev2)
NeilBrown7dd5e7c32007-02-28 20:11:35 -08001912 if (rdev->bdev->bd_contains ==
NeilBrown4b809912008-07-21 17:05:25 +10001913 rdev2->bdev->bd_contains) {
1914 rcu_read_unlock();
NeilBrown7dd5e7c32007-02-28 20:11:35 -08001915 return 1;
NeilBrown4b809912008-07-21 17:05:25 +10001916 }
1917 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 return 0;
1919}
1920
1921static LIST_HEAD(pending_raid_disks);
1922
Andre Nollac5e7112009-08-03 10:59:47 +10001923/*
1924 * Try to register data integrity profile for an mddev
1925 *
1926 * This is called when an array is started and after a disk has been kicked
1927 * from the array. It only succeeds if all working and active component devices
1928 * are integrity capable with matching profiles.
1929 */
NeilBrownfd01b882011-10-11 16:47:53 +11001930int md_integrity_register(struct mddev *mddev)
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11001931{
NeilBrown3cb03002011-10-11 16:45:26 +11001932 struct md_rdev *rdev, *reference = NULL;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11001933
Andre Nollac5e7112009-08-03 10:59:47 +10001934 if (list_empty(&mddev->disks))
1935 return 0; /* nothing to do */
Jonathan Brassow629acb62011-06-08 15:10:08 +10001936 if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
1937 return 0; /* shouldn't register, or already is */
NeilBrowndafb20f2012-03-19 12:46:39 +11001938 rdev_for_each(rdev, mddev) {
Andre Nollac5e7112009-08-03 10:59:47 +10001939 /* skip spares and non-functional disks */
1940 if (test_bit(Faulty, &rdev->flags))
1941 continue;
1942 if (rdev->raid_disk < 0)
1943 continue;
Andre Nollac5e7112009-08-03 10:59:47 +10001944 if (!reference) {
1945 /* Use the first rdev as the reference */
1946 reference = rdev;
1947 continue;
1948 }
1949 /* does this rdev's profile match the reference profile? */
1950 if (blk_integrity_compare(reference->bdev->bd_disk,
1951 rdev->bdev->bd_disk) < 0)
1952 return -EINVAL;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11001953 }
Martin K. Petersen89078d52011-03-28 20:09:12 -04001954 if (!reference || !bdev_get_integrity(reference->bdev))
1955 return 0;
Andre Nollac5e7112009-08-03 10:59:47 +10001956 /*
1957 * All component devices are integrity capable and have matching
1958 * profiles, register the common profile for the md device.
1959 */
1960 if (blk_integrity_register(mddev->gendisk,
1961 bdev_get_integrity(reference->bdev)) != 0) {
1962 printk(KERN_ERR "md: failed to register integrity for %s\n",
1963 mdname(mddev));
1964 return -EINVAL;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11001965 }
Martin K. Petersena91a2782011-03-17 11:11:05 +01001966 printk(KERN_NOTICE "md: data integrity enabled on %s\n", mdname(mddev));
1967 if (bioset_integrity_create(mddev->bio_set, BIO_POOL_SIZE)) {
1968 printk(KERN_ERR "md: failed to create integrity pool for %s\n",
1969 mdname(mddev));
1970 return -EINVAL;
1971 }
Andre Nollac5e7112009-08-03 10:59:47 +10001972 return 0;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11001973}
Andre Nollac5e7112009-08-03 10:59:47 +10001974EXPORT_SYMBOL(md_integrity_register);
1975
1976/* Disable data integrity if non-capable/non-matching disk is being added */
NeilBrownfd01b882011-10-11 16:47:53 +11001977void md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
Andre Nollac5e7112009-08-03 10:59:47 +10001978{
Jonathan Brassow2863b9e2012-10-11 13:38:58 +11001979 struct blk_integrity *bi_rdev;
1980 struct blk_integrity *bi_mddev;
1981
1982 if (!mddev->gendisk)
1983 return;
1984
1985 bi_rdev = bdev_get_integrity(rdev->bdev);
1986 bi_mddev = blk_get_integrity(mddev->gendisk);
Andre Nollac5e7112009-08-03 10:59:47 +10001987
1988 if (!bi_mddev) /* nothing to do */
1989 return;
1990 if (rdev->raid_disk < 0) /* skip spares */
1991 return;
1992 if (bi_rdev && blk_integrity_compare(mddev->gendisk,
1993 rdev->bdev->bd_disk) >= 0)
1994 return;
1995 printk(KERN_NOTICE "disabling data integrity on %s\n", mdname(mddev));
1996 blk_integrity_unregister(mddev->gendisk);
1997}
1998EXPORT_SYMBOL(md_integrity_add_rdev);
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11001999
NeilBrownf72ffdd2014-09-30 14:23:59 +10002000static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001{
NeilBrown7dd5e7c32007-02-28 20:11:35 -08002002 char b[BDEVNAME_SIZE];
NeilBrownf637b9f2005-11-08 21:39:37 -08002003 struct kobject *ko;
Neil Brown1edf80d2006-01-12 01:05:23 -08002004 char *s;
NeilBrown5e55e2f2007-03-26 21:32:14 -08002005 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006
Dan Williams11e2ede2008-04-30 00:52:32 -07002007 /* prevent duplicates */
2008 if (find_rdev(mddev, rdev->bdev->bd_dev))
2009 return -EEXIST;
2010
Andre Nolldd8ac332009-03-31 14:33:13 +11002011 /* make sure rdev->sectors exceeds mddev->dev_sectors */
2012 if (rdev->sectors && (mddev->dev_sectors == 0 ||
2013 rdev->sectors < mddev->dev_sectors)) {
NeilBrowna778b732007-05-23 13:58:10 -07002014 if (mddev->pers) {
2015 /* Cannot change size, so fail
2016 * If mddev->level <= 0, then we don't care
2017 * about aligning sizes (e.g. linear)
2018 */
2019 if (mddev->level > 0)
2020 return -ENOSPC;
2021 } else
Andre Nolldd8ac332009-03-31 14:33:13 +11002022 mddev->dev_sectors = rdev->sectors;
NeilBrown2bf071b2006-01-06 00:20:55 -08002023 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024
2025 /* Verify rdev->desc_nr is unique.
2026 * If it is -1, assign a free number, else
2027 * check number is not in use
2028 */
NeilBrown4878e9e2014-09-25 17:00:11 +10002029 rcu_read_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 if (rdev->desc_nr < 0) {
2031 int choice = 0;
NeilBrown4878e9e2014-09-25 17:00:11 +10002032 if (mddev->pers)
2033 choice = mddev->raid_disks;
2034 while (find_rdev_nr_rcu(mddev, choice))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 choice++;
2036 rdev->desc_nr = choice;
2037 } else {
NeilBrown4878e9e2014-09-25 17:00:11 +10002038 if (find_rdev_nr_rcu(mddev, rdev->desc_nr)) {
2039 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 return -EBUSY;
NeilBrown4878e9e2014-09-25 17:00:11 +10002041 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 }
NeilBrown4878e9e2014-09-25 17:00:11 +10002043 rcu_read_unlock();
NeilBrownde01dfa2009-02-06 18:02:46 +11002044 if (mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
2045 printk(KERN_WARNING "md: %s: array is limited to %d devices\n",
2046 mdname(mddev), mddev->max_disks);
2047 return -EBUSY;
2048 }
NeilBrown19133a42005-11-08 21:39:35 -08002049 bdevname(rdev->bdev,b);
Greg Kroah-Hartman649316b2007-12-17 23:05:35 -07002050 while ( (s=strchr(b, '/')) != NULL)
Neil Brown1edf80d2006-01-12 01:05:23 -08002051 *s = '!';
Greg Kroah-Hartman649316b2007-12-17 23:05:35 -07002052
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 rdev->mddev = mddev;
NeilBrown19133a42005-11-08 21:39:35 -08002054 printk(KERN_INFO "md: bind<%s>\n", b);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002055
Greg Kroah-Hartmanb2d6db52007-12-17 23:05:35 -07002056 if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
NeilBrown5e55e2f2007-03-26 21:32:14 -08002057 goto fail;
NeilBrown86e6ffd2005-11-08 21:39:24 -08002058
Tejun Heo0762b8b2008-08-25 19:56:12 +09002059 ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
NeilBrown00bcb4a2010-06-01 19:37:23 +10002060 if (sysfs_create_link(&rdev->kobj, ko, "block"))
2061 /* failure here is OK */;
2062 rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
NeilBrown3c0ee632008-10-21 13:25:28 +11002063
NeilBrown4b809912008-07-21 17:05:25 +10002064 list_add_rcu(&rdev->same_set, &mddev->disks);
Tejun Heoe09b4572010-11-13 11:55:17 +01002065 bd_link_disk_holder(rdev->bdev, mddev->gendisk);
NeilBrown4044ba52009-01-09 08:31:11 +11002066
2067 /* May as well allow recovery to be retried once */
NeilBrown53890422011-07-27 11:00:36 +10002068 mddev->recovery_disabled++;
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11002069
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 return 0;
NeilBrown5e55e2f2007-03-26 21:32:14 -08002071
2072 fail:
2073 printk(KERN_WARNING "md: failed to register dev-%s for %s\n",
2074 b, mdname(mddev));
2075 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076}
2077
NeilBrown177a99b2008-02-06 01:39:56 -08002078static void md_delayed_delete(struct work_struct *ws)
NeilBrown5792a282007-04-04 19:08:18 -07002079{
NeilBrown3cb03002011-10-11 16:45:26 +11002080 struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
NeilBrown5792a282007-04-04 19:08:18 -07002081 kobject_del(&rdev->kobj);
NeilBrown177a99b2008-02-06 01:39:56 -08002082 kobject_put(&rdev->kobj);
NeilBrown5792a282007-04-04 19:08:18 -07002083}
2084
NeilBrownf72ffdd2014-09-30 14:23:59 +10002085static void unbind_rdev_from_array(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086{
2087 char b[BDEVNAME_SIZE];
NeilBrown403df472014-09-30 15:52:29 +10002088
Tejun Heo49731ba2011-01-14 18:43:57 +01002089 bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
NeilBrown4b809912008-07-21 17:05:25 +10002090 list_del_rcu(&rdev->same_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
2092 rdev->mddev = NULL;
NeilBrown86e6ffd2005-11-08 21:39:24 -08002093 sysfs_remove_link(&rdev->kobj, "block");
NeilBrown3c0ee632008-10-21 13:25:28 +11002094 sysfs_put(rdev->sysfs_state);
2095 rdev->sysfs_state = NULL;
NeilBrown2230dfe2011-07-28 11:31:46 +10002096 rdev->badblocks.count = 0;
NeilBrown5792a282007-04-04 19:08:18 -07002097 /* We need to delay this, otherwise we can deadlock when
NeilBrown4b809912008-07-21 17:05:25 +10002098 * writing to 'remove' to "dev/state". We also need
2099 * to delay it due to rcu usage.
NeilBrown5792a282007-04-04 19:08:18 -07002100 */
NeilBrown4b809912008-07-21 17:05:25 +10002101 synchronize_rcu();
NeilBrown177a99b2008-02-06 01:39:56 -08002102 INIT_WORK(&rdev->del_work, md_delayed_delete);
2103 kobject_get(&rdev->kobj);
Tejun Heoe804ac72010-10-15 15:36:08 +02002104 queue_work(md_misc_wq, &rdev->del_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105}
2106
2107/*
2108 * prevent the device from being mounted, repartitioned or
2109 * otherwise reused by a RAID array (or any other kernel
2110 * subsystem), by bd_claiming the device.
2111 */
NeilBrown3cb03002011-10-11 16:45:26 +11002112static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113{
2114 int err = 0;
2115 struct block_device *bdev;
2116 char b[BDEVNAME_SIZE];
2117
Tejun Heod4d77622010-11-13 11:55:18 +01002118 bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
NeilBrown3cb03002011-10-11 16:45:26 +11002119 shared ? (struct md_rdev *)lock_rdev : rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 if (IS_ERR(bdev)) {
2121 printk(KERN_ERR "md: could not open %s.\n",
2122 __bdevname(dev, b));
2123 return PTR_ERR(bdev);
2124 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 rdev->bdev = bdev;
2126 return err;
2127}
2128
NeilBrown3cb03002011-10-11 16:45:26 +11002129static void unlock_rdev(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130{
2131 struct block_device *bdev = rdev->bdev;
2132 rdev->bdev = NULL;
Tejun Heoe525fd82010-11-13 11:55:17 +01002133 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134}
2135
2136void md_autodetect_dev(dev_t dev);
2137
NeilBrownf72ffdd2014-09-30 14:23:59 +10002138static void export_rdev(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139{
2140 char b[BDEVNAME_SIZE];
NeilBrown403df472014-09-30 15:52:29 +10002141
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 printk(KERN_INFO "md: export_rdev(%s)\n",
2143 bdevname(rdev->bdev,b));
NeilBrown545c8792012-05-22 13:54:30 +10002144 md_rdev_clear(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145#ifndef MODULE
NeilBrownd0fae182008-03-04 14:29:31 -08002146 if (test_bit(AutoDetected, &rdev->flags))
2147 md_autodetect_dev(rdev->bdev->bd_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148#endif
2149 unlock_rdev(rdev);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002150 kobject_put(&rdev->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151}
2152
NeilBrownf72ffdd2014-09-30 14:23:59 +10002153static void kick_rdev_from_array(struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154{
2155 unbind_rdev_from_array(rdev);
2156 export_rdev(rdev);
2157}
2158
NeilBrownfd01b882011-10-11 16:47:53 +11002159static void export_array(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160{
NeilBrown0638bb02014-09-25 17:43:47 +10002161 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162
NeilBrown0638bb02014-09-25 17:43:47 +10002163 while (!list_empty(&mddev->disks)) {
2164 rdev = list_first_entry(&mddev->disks, struct md_rdev,
2165 same_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166 kick_rdev_from_array(rdev);
2167 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 mddev->raid_disks = 0;
2169 mddev->major_version = 0;
2170}
2171
NeilBrownf72ffdd2014-09-30 14:23:59 +10002172static void sync_sbs(struct mddev *mddev, int nospares)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173{
NeilBrown42543762006-06-26 00:27:57 -07002174 /* Update each superblock (in-memory image), but
2175 * if we are allowed to, skip spares which already
2176 * have the right event counter, or have one earlier
2177 * (which would mean they aren't being marked as dirty
2178 * with the rest of the array)
2179 */
NeilBrown3cb03002011-10-11 16:45:26 +11002180 struct md_rdev *rdev;
NeilBrowndafb20f2012-03-19 12:46:39 +11002181 rdev_for_each(rdev, mddev) {
NeilBrown42543762006-06-26 00:27:57 -07002182 if (rdev->sb_events == mddev->events ||
2183 (nospares &&
2184 rdev->raid_disk < 0 &&
NeilBrown42543762006-06-26 00:27:57 -07002185 rdev->sb_events+1 == mddev->events)) {
2186 /* Don't update this superblock */
2187 rdev->sb_loaded = 2;
2188 } else {
Jonathan Brassow076f9682011-06-07 17:51:30 -05002189 sync_super(mddev, rdev);
NeilBrown42543762006-06-26 00:27:57 -07002190 rdev->sb_loaded = 1;
2191 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 }
2193}
2194
NeilBrownf72ffdd2014-09-30 14:23:59 +10002195static void md_update_sb(struct mddev *mddev, int force_change)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196{
NeilBrown3cb03002011-10-11 16:45:26 +11002197 struct md_rdev *rdev;
NeilBrown06d91a52005-06-21 17:17:12 -07002198 int sync_req;
NeilBrown42543762006-06-26 00:27:57 -07002199 int nospares = 0;
NeilBrown2699b672011-07-28 11:31:47 +10002200 int any_badblocks_changed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201
NeilBrownd87f0642013-04-24 11:42:40 +10002202 if (mddev->ro) {
2203 if (force_change)
2204 set_bit(MD_CHANGE_DEVS, &mddev->flags);
2205 return;
2206 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207repeat:
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002208 /* First make sure individual recovery_offsets are correct */
NeilBrowndafb20f2012-03-19 12:46:39 +11002209 rdev_for_each(rdev, mddev) {
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002210 if (rdev->raid_disk >= 0 &&
2211 mddev->delta_disks >= 0 &&
2212 !test_bit(In_sync, &rdev->flags) &&
2213 mddev->curr_resync_completed > rdev->recovery_offset)
2214 rdev->recovery_offset = mddev->curr_resync_completed;
2215
NeilBrownf72ffdd2014-09-30 14:23:59 +10002216 }
Dan Williamsbd52b742010-08-30 17:33:33 +10002217 if (!mddev->persistent) {
NeilBrown070dc6d2010-08-30 17:33:34 +10002218 clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002219 clear_bit(MD_CHANGE_DEVS, &mddev->flags);
NeilBrownde393cd2011-07-28 11:31:48 +10002220 if (!mddev->external) {
NeilBrownd97a41d2010-10-28 17:30:20 +11002221 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrowndafb20f2012-03-19 12:46:39 +11002222 rdev_for_each(rdev, mddev) {
NeilBrownde393cd2011-07-28 11:31:48 +10002223 if (rdev->badblocks.changed) {
NeilBrownd0962932012-03-19 12:46:41 +11002224 rdev->badblocks.changed = 0;
NeilBrownde393cd2011-07-28 11:31:48 +10002225 md_ack_all_badblocks(&rdev->badblocks);
2226 md_error(mddev, rdev);
2227 }
2228 clear_bit(Blocked, &rdev->flags);
2229 clear_bit(BlockedBadBlocks, &rdev->flags);
2230 wake_up(&rdev->blocked_wait);
2231 }
2232 }
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002233 wake_up(&mddev->sb_wait);
2234 return;
2235 }
2236
NeilBrowna9701a32005-11-08 21:39:34 -08002237 spin_lock_irq(&mddev->write_lock);
NeilBrown84692192006-08-27 01:23:49 -07002238
NeilBrown3a3a5dd2010-08-16 18:09:31 +10002239 mddev->utime = get_seconds();
2240
NeilBrown850b2b42006-10-03 01:15:46 -07002241 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
2242 force_change = 1;
2243 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
2244 /* just a clean<-> dirty transition, possibly leave spares alone,
2245 * though if events isn't the right even/odd, we will have to do
2246 * spares after all
2247 */
2248 nospares = 1;
2249 if (force_change)
2250 nospares = 0;
2251 if (mddev->degraded)
NeilBrown84692192006-08-27 01:23:49 -07002252 /* If the array is degraded, then skipping spares is both
2253 * dangerous and fairly pointless.
2254 * Dangerous because a device that was removed from the array
2255 * might have a event_count that still looks up-to-date,
2256 * so it can be re-added without a resync.
2257 * Pointless because if there are any spares to skip,
2258 * then a recovery will happen and soon that array won't
2259 * be degraded any more and the spare can go back to sleep then.
2260 */
NeilBrown850b2b42006-10-03 01:15:46 -07002261 nospares = 0;
NeilBrown84692192006-08-27 01:23:49 -07002262
NeilBrown06d91a52005-06-21 17:17:12 -07002263 sync_req = mddev->in_sync;
NeilBrown42543762006-06-26 00:27:57 -07002264
2265 /* If this is just a dirty<->clean transition, and the array is clean
2266 * and 'events' is odd, we can roll back to the previous clean state */
NeilBrown850b2b42006-10-03 01:15:46 -07002267 if (nospares
NeilBrown42543762006-06-26 00:27:57 -07002268 && (mddev->in_sync && mddev->recovery_cp == MaxSector)
NeilBrowna8707c02010-05-18 09:28:43 +10002269 && mddev->can_decrease_events
2270 && mddev->events != 1) {
NeilBrown42543762006-06-26 00:27:57 -07002271 mddev->events--;
NeilBrowna8707c02010-05-18 09:28:43 +10002272 mddev->can_decrease_events = 0;
2273 } else {
NeilBrown42543762006-06-26 00:27:57 -07002274 /* otherwise we have to go forward and ... */
2275 mddev->events ++;
NeilBrowna8707c02010-05-18 09:28:43 +10002276 mddev->can_decrease_events = nospares;
NeilBrown42543762006-06-26 00:27:57 -07002277 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278
NeilBrown403df472014-09-30 15:52:29 +10002279 /*
2280 * This 64-bit counter should never wrap.
2281 * Either we are in around ~1 trillion A.C., assuming
2282 * 1 reboot per second, or we have a bug...
2283 */
2284 WARN_ON(mddev->events == 0);
NeilBrown2699b672011-07-28 11:31:47 +10002285
NeilBrowndafb20f2012-03-19 12:46:39 +11002286 rdev_for_each(rdev, mddev) {
NeilBrown2699b672011-07-28 11:31:47 +10002287 if (rdev->badblocks.changed)
2288 any_badblocks_changed++;
NeilBrownde393cd2011-07-28 11:31:48 +10002289 if (test_bit(Faulty, &rdev->flags))
2290 set_bit(FaultRecorded, &rdev->flags);
2291 }
NeilBrown2699b672011-07-28 11:31:47 +10002292
NeilBrowne6910632008-02-06 01:39:51 -08002293 sync_sbs(mddev, nospares);
NeilBrowna9701a32005-11-08 21:39:34 -08002294 spin_unlock_irq(&mddev->write_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295
NeilBrown36a4e1f2011-10-07 14:23:17 +11002296 pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
2297 mdname(mddev), mddev->in_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298
NeilBrown4ad13662007-07-17 04:06:13 -07002299 bitmap_update_sb(mddev->bitmap);
NeilBrowndafb20f2012-03-19 12:46:39 +11002300 rdev_for_each(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301 char b[BDEVNAME_SIZE];
NeilBrown36a4e1f2011-10-07 14:23:17 +11002302
NeilBrown42543762006-06-26 00:27:57 -07002303 if (rdev->sb_loaded != 1)
2304 continue; /* no noise on spare devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305
NeilBrownf4667222013-12-09 12:04:56 +11002306 if (!test_bit(Faulty, &rdev->flags)) {
NeilBrown7bfa19f2005-06-21 17:17:28 -07002307 md_super_write(mddev,rdev,
Andre Noll0f420352008-07-11 22:02:23 +10002308 rdev->sb_start, rdev->sb_size,
NeilBrown7bfa19f2005-06-21 17:17:28 -07002309 rdev->sb_page);
NeilBrown36a4e1f2011-10-07 14:23:17 +11002310 pr_debug("md: (write) %s's sb offset: %llu\n",
2311 bdevname(rdev->bdev, b),
2312 (unsigned long long)rdev->sb_start);
NeilBrown42543762006-06-26 00:27:57 -07002313 rdev->sb_events = mddev->events;
NeilBrown2699b672011-07-28 11:31:47 +10002314 if (rdev->badblocks.size) {
2315 md_super_write(mddev, rdev,
2316 rdev->badblocks.sector,
2317 rdev->badblocks.size << 9,
2318 rdev->bb_page);
2319 rdev->badblocks.size = 0;
2320 }
NeilBrown7bfa19f2005-06-21 17:17:28 -07002321
NeilBrownf4667222013-12-09 12:04:56 +11002322 } else
NeilBrown36a4e1f2011-10-07 14:23:17 +11002323 pr_debug("md: %s (skipping faulty)\n",
2324 bdevname(rdev->bdev, b));
Andrei Warkentind70ed2e2011-10-18 12:16:48 +11002325
NeilBrown7bfa19f2005-06-21 17:17:28 -07002326 if (mddev->level == LEVEL_MULTIPATH)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 /* only need to write one superblock... */
2328 break;
2329 }
NeilBrowna9701a32005-11-08 21:39:34 -08002330 md_super_wait(mddev);
NeilBrown850b2b42006-10-03 01:15:46 -07002331 /* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
NeilBrown7bfa19f2005-06-21 17:17:28 -07002332
NeilBrowna9701a32005-11-08 21:39:34 -08002333 spin_lock_irq(&mddev->write_lock);
NeilBrown850b2b42006-10-03 01:15:46 -07002334 if (mddev->in_sync != sync_req ||
2335 test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
NeilBrown06d91a52005-06-21 17:17:12 -07002336 /* have to write it out again */
NeilBrowna9701a32005-11-08 21:39:34 -08002337 spin_unlock_irq(&mddev->write_lock);
NeilBrown06d91a52005-06-21 17:17:12 -07002338 goto repeat;
2339 }
NeilBrown850b2b42006-10-03 01:15:46 -07002340 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrowna9701a32005-11-08 21:39:34 -08002341 spin_unlock_irq(&mddev->write_lock);
NeilBrown3d310eb2005-06-21 17:17:26 -07002342 wake_up(&mddev->sb_wait);
NeilBrownacb180b2009-04-14 16:28:34 +10002343 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2344 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
NeilBrown06d91a52005-06-21 17:17:12 -07002345
NeilBrowndafb20f2012-03-19 12:46:39 +11002346 rdev_for_each(rdev, mddev) {
NeilBrownde393cd2011-07-28 11:31:48 +10002347 if (test_and_clear_bit(FaultRecorded, &rdev->flags))
2348 clear_bit(Blocked, &rdev->flags);
2349
2350 if (any_badblocks_changed)
NeilBrown2699b672011-07-28 11:31:47 +10002351 md_ack_all_badblocks(&rdev->badblocks);
NeilBrownde393cd2011-07-28 11:31:48 +10002352 clear_bit(BlockedBadBlocks, &rdev->flags);
2353 wake_up(&rdev->blocked_wait);
2354 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355}
2356
Andre Noll7f6ce762008-03-23 18:34:54 +01002357/* words written to sysfs files may, or may not, be \n terminated.
NeilBrownbce74da2006-01-06 00:20:41 -08002358 * We want to accept with case. For this we use cmd_match.
2359 */
2360static int cmd_match(const char *cmd, const char *str)
2361{
2362 /* See if cmd, written into a sysfs file, matches
2363 * str. They must either be the same, or cmd can
2364 * have a trailing newline
2365 */
2366 while (*cmd && *str && *cmd == *str) {
2367 cmd++;
2368 str++;
2369 }
2370 if (*cmd == '\n')
2371 cmd++;
2372 if (*str || *cmd)
2373 return 0;
2374 return 1;
2375}
2376
NeilBrown86e6ffd2005-11-08 21:39:24 -08002377struct rdev_sysfs_entry {
2378 struct attribute attr;
NeilBrown3cb03002011-10-11 16:45:26 +11002379 ssize_t (*show)(struct md_rdev *, char *);
2380 ssize_t (*store)(struct md_rdev *, const char *, size_t);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002381};
2382
2383static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002384state_show(struct md_rdev *rdev, char *page)
NeilBrown86e6ffd2005-11-08 21:39:24 -08002385{
2386 char *sep = "";
NeilBrown20a49ff2008-02-06 01:39:57 -08002387 size_t len = 0;
NeilBrown86e6ffd2005-11-08 21:39:24 -08002388
NeilBrownde393cd2011-07-28 11:31:48 +10002389 if (test_bit(Faulty, &rdev->flags) ||
2390 rdev->badblocks.unacked_exist) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08002391 len+= sprintf(page+len, "%sfaulty",sep);
2392 sep = ",";
2393 }
NeilBrownb2d444d2005-11-08 21:39:31 -08002394 if (test_bit(In_sync, &rdev->flags)) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08002395 len += sprintf(page+len, "%sin_sync",sep);
2396 sep = ",";
2397 }
NeilBrownf6556752006-06-26 00:28:01 -07002398 if (test_bit(WriteMostly, &rdev->flags)) {
2399 len += sprintf(page+len, "%swrite_mostly",sep);
2400 sep = ",";
2401 }
NeilBrownde393cd2011-07-28 11:31:48 +10002402 if (test_bit(Blocked, &rdev->flags) ||
NeilBrown52c64152011-12-08 16:22:48 +11002403 (rdev->badblocks.unacked_exist
2404 && !test_bit(Faulty, &rdev->flags))) {
Dan Williams6bfe0b42008-04-30 00:52:32 -07002405 len += sprintf(page+len, "%sblocked", sep);
2406 sep = ",";
2407 }
NeilBrownb2d444d2005-11-08 21:39:31 -08002408 if (!test_bit(Faulty, &rdev->flags) &&
2409 !test_bit(In_sync, &rdev->flags)) {
NeilBrown86e6ffd2005-11-08 21:39:24 -08002410 len += sprintf(page+len, "%sspare", sep);
2411 sep = ",";
2412 }
NeilBrownd7a9d442011-07-28 11:31:48 +10002413 if (test_bit(WriteErrorSeen, &rdev->flags)) {
2414 len += sprintf(page+len, "%swrite_error", sep);
2415 sep = ",";
2416 }
NeilBrown2d78f8c2011-12-23 10:17:51 +11002417 if (test_bit(WantReplacement, &rdev->flags)) {
2418 len += sprintf(page+len, "%swant_replacement", sep);
2419 sep = ",";
2420 }
2421 if (test_bit(Replacement, &rdev->flags)) {
2422 len += sprintf(page+len, "%sreplacement", sep);
2423 sep = ",";
2424 }
2425
NeilBrown86e6ffd2005-11-08 21:39:24 -08002426 return len+sprintf(page+len, "\n");
2427}
2428
NeilBrown45dc2de2006-06-26 00:27:58 -07002429static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002430state_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown45dc2de2006-06-26 00:27:58 -07002431{
2432 /* can write
NeilBrownde393cd2011-07-28 11:31:48 +10002433 * faulty - simulates an error
NeilBrown45dc2de2006-06-26 00:27:58 -07002434 * remove - disconnects the device
NeilBrownf6556752006-06-26 00:28:01 -07002435 * writemostly - sets write_mostly
2436 * -writemostly - clears write_mostly
NeilBrownde393cd2011-07-28 11:31:48 +10002437 * blocked - sets the Blocked flags
2438 * -blocked - clears the Blocked and possibly simulates an error
NeilBrown6d56e272009-04-14 12:01:57 +10002439 * insync - sets Insync providing device isn't active
NeilBrownf4667222013-12-09 12:04:56 +11002440 * -insync - clear Insync for a device with a slot assigned,
2441 * so that it gets rebuilt based on bitmap
NeilBrownd7a9d442011-07-28 11:31:48 +10002442 * write_error - sets WriteErrorSeen
2443 * -write_error - clears WriteErrorSeen
NeilBrown45dc2de2006-06-26 00:27:58 -07002444 */
2445 int err = -EINVAL;
2446 if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2447 md_error(rdev->mddev, rdev);
NeilBrown5ef56c82011-08-25 14:42:51 +10002448 if (test_bit(Faulty, &rdev->flags))
2449 err = 0;
2450 else
2451 err = -EBUSY;
NeilBrown45dc2de2006-06-26 00:27:58 -07002452 } else if (cmd_match(buf, "remove")) {
2453 if (rdev->raid_disk >= 0)
2454 err = -EBUSY;
2455 else {
NeilBrownfd01b882011-10-11 16:47:53 +11002456 struct mddev *mddev = rdev->mddev;
NeilBrown45dc2de2006-06-26 00:27:58 -07002457 kick_rdev_from_array(rdev);
NeilBrown3f9d7b02006-12-22 01:11:41 -08002458 if (mddev->pers)
2459 md_update_sb(mddev, 1);
NeilBrown45dc2de2006-06-26 00:27:58 -07002460 md_new_event(mddev);
2461 err = 0;
2462 }
NeilBrownf6556752006-06-26 00:28:01 -07002463 } else if (cmd_match(buf, "writemostly")) {
2464 set_bit(WriteMostly, &rdev->flags);
2465 err = 0;
2466 } else if (cmd_match(buf, "-writemostly")) {
2467 clear_bit(WriteMostly, &rdev->flags);
2468 err = 0;
Dan Williams6bfe0b42008-04-30 00:52:32 -07002469 } else if (cmd_match(buf, "blocked")) {
2470 set_bit(Blocked, &rdev->flags);
2471 err = 0;
2472 } else if (cmd_match(buf, "-blocked")) {
NeilBrownde393cd2011-07-28 11:31:48 +10002473 if (!test_bit(Faulty, &rdev->flags) &&
NeilBrown7da64a02011-08-30 16:20:17 +10002474 rdev->badblocks.unacked_exist) {
NeilBrownde393cd2011-07-28 11:31:48 +10002475 /* metadata handler doesn't understand badblocks,
2476 * so we need to fail the device
2477 */
2478 md_error(rdev->mddev, rdev);
2479 }
Dan Williams6bfe0b42008-04-30 00:52:32 -07002480 clear_bit(Blocked, &rdev->flags);
NeilBrownde393cd2011-07-28 11:31:48 +10002481 clear_bit(BlockedBadBlocks, &rdev->flags);
Dan Williams6bfe0b42008-04-30 00:52:32 -07002482 wake_up(&rdev->blocked_wait);
2483 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2484 md_wakeup_thread(rdev->mddev->thread);
2485
2486 err = 0;
NeilBrown6d56e272009-04-14 12:01:57 +10002487 } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
2488 set_bit(In_sync, &rdev->flags);
2489 err = 0;
NeilBrownf4667222013-12-09 12:04:56 +11002490 } else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0) {
NeilBrowne1960f82014-09-30 15:24:25 +10002491 if (rdev->mddev->pers == NULL) {
2492 clear_bit(In_sync, &rdev->flags);
2493 rdev->saved_raid_disk = rdev->raid_disk;
2494 rdev->raid_disk = -1;
2495 err = 0;
2496 }
NeilBrownd7a9d442011-07-28 11:31:48 +10002497 } else if (cmd_match(buf, "write_error")) {
2498 set_bit(WriteErrorSeen, &rdev->flags);
2499 err = 0;
2500 } else if (cmd_match(buf, "-write_error")) {
2501 clear_bit(WriteErrorSeen, &rdev->flags);
2502 err = 0;
NeilBrown2d78f8c2011-12-23 10:17:51 +11002503 } else if (cmd_match(buf, "want_replacement")) {
2504 /* Any non-spare device that is not a replacement can
2505 * become want_replacement at any time, but we then need to
2506 * check if recovery is needed.
2507 */
2508 if (rdev->raid_disk >= 0 &&
2509 !test_bit(Replacement, &rdev->flags))
2510 set_bit(WantReplacement, &rdev->flags);
2511 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2512 md_wakeup_thread(rdev->mddev->thread);
2513 err = 0;
2514 } else if (cmd_match(buf, "-want_replacement")) {
2515 /* Clearing 'want_replacement' is always allowed.
2516 * Once replacements starts it is too late though.
2517 */
2518 err = 0;
2519 clear_bit(WantReplacement, &rdev->flags);
2520 } else if (cmd_match(buf, "replacement")) {
2521 /* Can only set a device as a replacement when array has not
2522 * yet been started. Once running, replacement is automatic
2523 * from spares, or by assigning 'slot'.
2524 */
2525 if (rdev->mddev->pers)
2526 err = -EBUSY;
2527 else {
2528 set_bit(Replacement, &rdev->flags);
2529 err = 0;
2530 }
2531 } else if (cmd_match(buf, "-replacement")) {
2532 /* Similarly, can only clear Replacement before start */
2533 if (rdev->mddev->pers)
2534 err = -EBUSY;
2535 else {
2536 clear_bit(Replacement, &rdev->flags);
2537 err = 0;
2538 }
NeilBrown45dc2de2006-06-26 00:27:58 -07002539 }
NeilBrown00bcb4a2010-06-01 19:37:23 +10002540 if (!err)
2541 sysfs_notify_dirent_safe(rdev->sysfs_state);
NeilBrown45dc2de2006-06-26 00:27:58 -07002542 return err ? err : len;
2543}
NeilBrown80ca3a42006-07-10 04:44:18 -07002544static struct rdev_sysfs_entry rdev_state =
2545__ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002546
2547static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002548errors_show(struct md_rdev *rdev, char *page)
NeilBrown4dbcdc72006-01-06 00:20:52 -08002549{
2550 return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
2551}
2552
2553static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002554errors_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown4dbcdc72006-01-06 00:20:52 -08002555{
2556 char *e;
2557 unsigned long n = simple_strtoul(buf, &e, 10);
2558 if (*buf && (*e == 0 || *e == '\n')) {
2559 atomic_set(&rdev->corrected_errors, n);
2560 return len;
2561 }
2562 return -EINVAL;
2563}
2564static struct rdev_sysfs_entry rdev_errors =
NeilBrown80ca3a42006-07-10 04:44:18 -07002565__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
NeilBrown4dbcdc72006-01-06 00:20:52 -08002566
NeilBrown014236d2006-01-06 00:20:55 -08002567static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002568slot_show(struct md_rdev *rdev, char *page)
NeilBrown014236d2006-01-06 00:20:55 -08002569{
2570 if (rdev->raid_disk < 0)
2571 return sprintf(page, "none\n");
2572 else
2573 return sprintf(page, "%d\n", rdev->raid_disk);
2574}
2575
2576static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002577slot_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown014236d2006-01-06 00:20:55 -08002578{
2579 char *e;
NeilBrownc303da62008-02-06 01:39:51 -08002580 int err;
NeilBrown014236d2006-01-06 00:20:55 -08002581 int slot = simple_strtoul(buf, &e, 10);
2582 if (strncmp(buf, "none", 4)==0)
2583 slot = -1;
2584 else if (e==buf || (*e && *e!= '\n'))
2585 return -EINVAL;
Neil Brown6c2fce22008-06-28 08:31:31 +10002586 if (rdev->mddev->pers && slot == -1) {
NeilBrownc303da62008-02-06 01:39:51 -08002587 /* Setting 'slot' on an active array requires also
2588 * updating the 'rd%d' link, and communicating
2589 * with the personality with ->hot_*_disk.
2590 * For now we only support removing
2591 * failed/spare devices. This normally happens automatically,
2592 * but not when the metadata is externally managed.
2593 */
NeilBrownc303da62008-02-06 01:39:51 -08002594 if (rdev->raid_disk == -1)
2595 return -EEXIST;
2596 /* personality does all needed checks */
Namhyung Kim01393f32011-06-09 11:42:54 +10002597 if (rdev->mddev->pers->hot_remove_disk == NULL)
NeilBrownc303da62008-02-06 01:39:51 -08002598 return -EINVAL;
NeilBrown746d3202013-04-24 11:42:41 +10002599 clear_bit(Blocked, &rdev->flags);
2600 remove_and_add_spares(rdev->mddev, rdev);
2601 if (rdev->raid_disk >= 0)
2602 return -EBUSY;
NeilBrownc303da62008-02-06 01:39:51 -08002603 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2604 md_wakeup_thread(rdev->mddev->thread);
Neil Brown6c2fce22008-06-28 08:31:31 +10002605 } else if (rdev->mddev->pers) {
Neil Brown6c2fce22008-06-28 08:31:31 +10002606 /* Activating a spare .. or possibly reactivating
NeilBrown6d56e272009-04-14 12:01:57 +10002607 * if we ever get bitmaps working here.
Neil Brown6c2fce22008-06-28 08:31:31 +10002608 */
2609
2610 if (rdev->raid_disk != -1)
2611 return -EBUSY;
2612
NeilBrownc6751b22011-02-02 11:57:13 +11002613 if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
2614 return -EBUSY;
2615
Neil Brown6c2fce22008-06-28 08:31:31 +10002616 if (rdev->mddev->pers->hot_add_disk == NULL)
2617 return -EINVAL;
2618
NeilBrownba1b41b2011-01-14 09:14:34 +11002619 if (slot >= rdev->mddev->raid_disks &&
2620 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
2621 return -ENOSPC;
2622
Neil Brown6c2fce22008-06-28 08:31:31 +10002623 rdev->raid_disk = slot;
2624 if (test_bit(In_sync, &rdev->flags))
2625 rdev->saved_raid_disk = slot;
2626 else
2627 rdev->saved_raid_disk = -1;
NeilBrownd30519f2011-10-18 12:13:47 +11002628 clear_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11002629 clear_bit(Bitmap_sync, &rdev->flags);
Neil Brown6c2fce22008-06-28 08:31:31 +10002630 err = rdev->mddev->pers->
2631 hot_add_disk(rdev->mddev, rdev);
Neil Brown199050e2008-06-28 08:31:33 +10002632 if (err) {
Neil Brown6c2fce22008-06-28 08:31:31 +10002633 rdev->raid_disk = -1;
Neil Brown6c2fce22008-06-28 08:31:31 +10002634 return err;
Neil Brown52664732008-06-28 08:31:44 +10002635 } else
NeilBrown00bcb4a2010-06-01 19:37:23 +10002636 sysfs_notify_dirent_safe(rdev->sysfs_state);
Namhyung Kim36fad852011-07-27 11:00:36 +10002637 if (sysfs_link_rdev(rdev->mddev, rdev))
NeilBrown00bcb4a2010-06-01 19:37:23 +10002638 /* failure here is OK */;
Neil Brown6c2fce22008-06-28 08:31:31 +10002639 /* don't wakeup anyone, leave that to userspace. */
NeilBrownc303da62008-02-06 01:39:51 -08002640 } else {
NeilBrownba1b41b2011-01-14 09:14:34 +11002641 if (slot >= rdev->mddev->raid_disks &&
2642 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
NeilBrownc303da62008-02-06 01:39:51 -08002643 return -ENOSPC;
2644 rdev->raid_disk = slot;
2645 /* assume it is working */
NeilBrownc5d79ad2008-02-06 01:39:54 -08002646 clear_bit(Faulty, &rdev->flags);
2647 clear_bit(WriteMostly, &rdev->flags);
NeilBrownc303da62008-02-06 01:39:51 -08002648 set_bit(In_sync, &rdev->flags);
NeilBrown00bcb4a2010-06-01 19:37:23 +10002649 sysfs_notify_dirent_safe(rdev->sysfs_state);
NeilBrownc303da62008-02-06 01:39:51 -08002650 }
NeilBrown014236d2006-01-06 00:20:55 -08002651 return len;
2652}
2653
NeilBrown014236d2006-01-06 00:20:55 -08002654static struct rdev_sysfs_entry rdev_slot =
NeilBrown80ca3a42006-07-10 04:44:18 -07002655__ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
NeilBrown014236d2006-01-06 00:20:55 -08002656
NeilBrown93c8cad2006-01-06 00:20:56 -08002657static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002658offset_show(struct md_rdev *rdev, char *page)
NeilBrown93c8cad2006-01-06 00:20:56 -08002659{
Andrew Morton6961ece2006-01-06 00:20:59 -08002660 return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
NeilBrown93c8cad2006-01-06 00:20:56 -08002661}
2662
2663static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002664offset_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown93c8cad2006-01-06 00:20:56 -08002665{
NeilBrownc6563a82012-05-21 09:27:00 +10002666 unsigned long long offset;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002667 if (kstrtoull(buf, 10, &offset) < 0)
NeilBrown93c8cad2006-01-06 00:20:56 -08002668 return -EINVAL;
Neil Brown8ed0a522008-06-28 08:31:29 +10002669 if (rdev->mddev->pers && rdev->raid_disk >= 0)
NeilBrown93c8cad2006-01-06 00:20:56 -08002670 return -EBUSY;
Andre Nolldd8ac332009-03-31 14:33:13 +11002671 if (rdev->sectors && rdev->mddev->external)
NeilBrownc5d79ad2008-02-06 01:39:54 -08002672 /* Must set offset before size, so overlap checks
2673 * can be sane */
2674 return -EBUSY;
NeilBrown93c8cad2006-01-06 00:20:56 -08002675 rdev->data_offset = offset;
NeilBrown25f7fd42012-07-19 15:59:18 +10002676 rdev->new_data_offset = offset;
NeilBrown93c8cad2006-01-06 00:20:56 -08002677 return len;
2678}
2679
2680static struct rdev_sysfs_entry rdev_offset =
NeilBrown80ca3a42006-07-10 04:44:18 -07002681__ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
NeilBrown93c8cad2006-01-06 00:20:56 -08002682
NeilBrownc6563a82012-05-21 09:27:00 +10002683static ssize_t new_offset_show(struct md_rdev *rdev, char *page)
2684{
2685 return sprintf(page, "%llu\n",
2686 (unsigned long long)rdev->new_data_offset);
2687}
2688
2689static ssize_t new_offset_store(struct md_rdev *rdev,
2690 const char *buf, size_t len)
2691{
2692 unsigned long long new_offset;
2693 struct mddev *mddev = rdev->mddev;
2694
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002695 if (kstrtoull(buf, 10, &new_offset) < 0)
NeilBrownc6563a82012-05-21 09:27:00 +10002696 return -EINVAL;
2697
NeilBrownf851b602014-12-11 10:02:10 +11002698 if (mddev->sync_thread ||
2699 test_bit(MD_RECOVERY_RUNNING,&mddev->recovery))
NeilBrownc6563a82012-05-21 09:27:00 +10002700 return -EBUSY;
2701 if (new_offset == rdev->data_offset)
2702 /* reset is always permitted */
2703 ;
2704 else if (new_offset > rdev->data_offset) {
2705 /* must not push array size beyond rdev_sectors */
2706 if (new_offset - rdev->data_offset
2707 + mddev->dev_sectors > rdev->sectors)
2708 return -E2BIG;
2709 }
2710 /* Metadata worries about other space details. */
2711
2712 /* decreasing the offset is inconsistent with a backwards
2713 * reshape.
2714 */
2715 if (new_offset < rdev->data_offset &&
2716 mddev->reshape_backwards)
2717 return -EINVAL;
2718 /* Increasing offset is inconsistent with forwards
2719 * reshape. reshape_direction should be set to
2720 * 'backwards' first.
2721 */
2722 if (new_offset > rdev->data_offset &&
2723 !mddev->reshape_backwards)
2724 return -EINVAL;
2725
2726 if (mddev->pers && mddev->persistent &&
2727 !super_types[mddev->major_version]
2728 .allow_new_offset(rdev, new_offset))
2729 return -E2BIG;
2730 rdev->new_data_offset = new_offset;
2731 if (new_offset > rdev->data_offset)
2732 mddev->reshape_backwards = 1;
2733 else if (new_offset < rdev->data_offset)
2734 mddev->reshape_backwards = 0;
2735
2736 return len;
2737}
2738static struct rdev_sysfs_entry rdev_new_offset =
2739__ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store);
2740
NeilBrown83303b62006-01-06 00:21:06 -08002741static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002742rdev_size_show(struct md_rdev *rdev, char *page)
NeilBrown83303b62006-01-06 00:21:06 -08002743{
Andre Nolldd8ac332009-03-31 14:33:13 +11002744 return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
NeilBrown83303b62006-01-06 00:21:06 -08002745}
2746
NeilBrownc5d79ad2008-02-06 01:39:54 -08002747static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
2748{
2749 /* check if two start/length pairs overlap */
2750 if (s1+l1 <= s2)
2751 return 0;
2752 if (s2+l2 <= s1)
2753 return 0;
2754 return 1;
2755}
2756
Dan Williamsb522adc2009-03-31 15:00:31 +11002757static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
2758{
2759 unsigned long long blocks;
2760 sector_t new;
2761
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002762 if (kstrtoull(buf, 10, &blocks) < 0)
Dan Williamsb522adc2009-03-31 15:00:31 +11002763 return -EINVAL;
2764
2765 if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
2766 return -EINVAL; /* sector conversion overflow */
2767
2768 new = blocks * 2;
2769 if (new != blocks * 2)
2770 return -EINVAL; /* unsigned long long to sector_t overflow */
2771
2772 *sectors = new;
2773 return 0;
2774}
2775
NeilBrown83303b62006-01-06 00:21:06 -08002776static ssize_t
NeilBrown3cb03002011-10-11 16:45:26 +11002777rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
NeilBrown83303b62006-01-06 00:21:06 -08002778{
NeilBrownfd01b882011-10-11 16:47:53 +11002779 struct mddev *my_mddev = rdev->mddev;
Andre Nolldd8ac332009-03-31 14:33:13 +11002780 sector_t oldsectors = rdev->sectors;
Dan Williamsb522adc2009-03-31 15:00:31 +11002781 sector_t sectors;
NeilBrown27c529b2008-03-04 14:29:33 -08002782
Dan Williamsb522adc2009-03-31 15:00:31 +11002783 if (strict_blocks_to_sectors(buf, &sectors) < 0)
Neil Brownd7027452008-07-12 10:37:50 +10002784 return -EINVAL;
NeilBrownc6563a82012-05-21 09:27:00 +10002785 if (rdev->data_offset != rdev->new_data_offset)
2786 return -EINVAL; /* too confusing */
Chris Webb0cd17fe2008-06-28 08:31:46 +10002787 if (my_mddev->pers && rdev->raid_disk >= 0) {
Neil Brownd7027452008-07-12 10:37:50 +10002788 if (my_mddev->persistent) {
Andre Nolldd8ac332009-03-31 14:33:13 +11002789 sectors = super_types[my_mddev->major_version].
2790 rdev_size_change(rdev, sectors);
2791 if (!sectors)
Chris Webb0cd17fe2008-06-28 08:31:46 +10002792 return -EBUSY;
Andre Nolldd8ac332009-03-31 14:33:13 +11002793 } else if (!sectors)
Mike Snitzer77304d22010-11-08 14:39:12 +01002794 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
Andre Nolldd8ac332009-03-31 14:33:13 +11002795 rdev->data_offset;
NeilBrowna6468532013-02-21 14:33:17 +11002796 if (!my_mddev->pers->resize)
2797 /* Cannot change size for RAID0 or Linear etc */
2798 return -EINVAL;
Chris Webb0cd17fe2008-06-28 08:31:46 +10002799 }
Andre Nolldd8ac332009-03-31 14:33:13 +11002800 if (sectors < my_mddev->dev_sectors)
Chris Webb7d3c6f82008-10-13 11:55:11 +11002801 return -EINVAL; /* component must fit device */
Chris Webb0cd17fe2008-06-28 08:31:46 +10002802
Andre Nolldd8ac332009-03-31 14:33:13 +11002803 rdev->sectors = sectors;
2804 if (sectors > oldsectors && my_mddev->external) {
NeilBrown8b1afc32014-09-29 15:33:20 +10002805 /* Need to check that all other rdevs with the same
2806 * ->bdev do not overlap. 'rcu' is sufficient to walk
2807 * the rdev lists safely.
2808 * This check does not provide a hard guarantee, it
2809 * just helps avoid dangerous mistakes.
NeilBrownc5d79ad2008-02-06 01:39:54 -08002810 */
NeilBrownfd01b882011-10-11 16:47:53 +11002811 struct mddev *mddev;
NeilBrownc5d79ad2008-02-06 01:39:54 -08002812 int overlap = 0;
Cheng Renquan159ec1f2009-01-09 08:31:08 +11002813 struct list_head *tmp;
NeilBrownc5d79ad2008-02-06 01:39:54 -08002814
NeilBrown8b1afc32014-09-29 15:33:20 +10002815 rcu_read_lock();
NeilBrown29ac4aa2008-02-06 01:39:58 -08002816 for_each_mddev(mddev, tmp) {
NeilBrown3cb03002011-10-11 16:45:26 +11002817 struct md_rdev *rdev2;
NeilBrownc5d79ad2008-02-06 01:39:54 -08002818
NeilBrowndafb20f2012-03-19 12:46:39 +11002819 rdev_for_each(rdev2, mddev)
NeilBrownf21e9ff2011-01-31 12:10:09 +11002820 if (rdev->bdev == rdev2->bdev &&
2821 rdev != rdev2 &&
2822 overlaps(rdev->data_offset, rdev->sectors,
2823 rdev2->data_offset,
2824 rdev2->sectors)) {
NeilBrownc5d79ad2008-02-06 01:39:54 -08002825 overlap = 1;
2826 break;
2827 }
NeilBrownc5d79ad2008-02-06 01:39:54 -08002828 if (overlap) {
2829 mddev_put(mddev);
2830 break;
2831 }
2832 }
NeilBrown8b1afc32014-09-29 15:33:20 +10002833 rcu_read_unlock();
NeilBrownc5d79ad2008-02-06 01:39:54 -08002834 if (overlap) {
2835 /* Someone else could have slipped in a size
2836 * change here, but doing so is just silly.
Andre Nolldd8ac332009-03-31 14:33:13 +11002837 * We put oldsectors back because we *know* it is
NeilBrownc5d79ad2008-02-06 01:39:54 -08002838 * safe, and trust userspace not to race with
2839 * itself
2840 */
Andre Nolldd8ac332009-03-31 14:33:13 +11002841 rdev->sectors = oldsectors;
NeilBrownc5d79ad2008-02-06 01:39:54 -08002842 return -EBUSY;
2843 }
2844 }
NeilBrown83303b62006-01-06 00:21:06 -08002845 return len;
2846}
2847
2848static struct rdev_sysfs_entry rdev_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07002849__ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
NeilBrown83303b62006-01-06 00:21:06 -08002850
NeilBrown3cb03002011-10-11 16:45:26 +11002851static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
Dan Williams06e3c812009-12-12 21:17:12 -07002852{
2853 unsigned long long recovery_start = rdev->recovery_offset;
2854
2855 if (test_bit(In_sync, &rdev->flags) ||
2856 recovery_start == MaxSector)
2857 return sprintf(page, "none\n");
2858
2859 return sprintf(page, "%llu\n", recovery_start);
2860}
2861
NeilBrown3cb03002011-10-11 16:45:26 +11002862static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
Dan Williams06e3c812009-12-12 21:17:12 -07002863{
2864 unsigned long long recovery_start;
2865
2866 if (cmd_match(buf, "none"))
2867 recovery_start = MaxSector;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09002868 else if (kstrtoull(buf, 10, &recovery_start))
Dan Williams06e3c812009-12-12 21:17:12 -07002869 return -EINVAL;
2870
2871 if (rdev->mddev->pers &&
2872 rdev->raid_disk >= 0)
2873 return -EBUSY;
2874
2875 rdev->recovery_offset = recovery_start;
2876 if (recovery_start == MaxSector)
2877 set_bit(In_sync, &rdev->flags);
2878 else
2879 clear_bit(In_sync, &rdev->flags);
2880 return len;
2881}
2882
2883static struct rdev_sysfs_entry rdev_recovery_start =
2884__ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);
2885
NeilBrown16c791a2011-07-28 11:31:47 +10002886static ssize_t
2887badblocks_show(struct badblocks *bb, char *page, int unack);
2888static ssize_t
2889badblocks_store(struct badblocks *bb, const char *page, size_t len, int unack);
2890
NeilBrown3cb03002011-10-11 16:45:26 +11002891static ssize_t bb_show(struct md_rdev *rdev, char *page)
NeilBrown16c791a2011-07-28 11:31:47 +10002892{
2893 return badblocks_show(&rdev->badblocks, page, 0);
2894}
NeilBrown3cb03002011-10-11 16:45:26 +11002895static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
NeilBrown16c791a2011-07-28 11:31:47 +10002896{
NeilBrownde393cd2011-07-28 11:31:48 +10002897 int rv = badblocks_store(&rdev->badblocks, page, len, 0);
2898 /* Maybe that ack was all we needed */
2899 if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags))
2900 wake_up(&rdev->blocked_wait);
2901 return rv;
NeilBrown16c791a2011-07-28 11:31:47 +10002902}
2903static struct rdev_sysfs_entry rdev_bad_blocks =
2904__ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);
2905
NeilBrown3cb03002011-10-11 16:45:26 +11002906static ssize_t ubb_show(struct md_rdev *rdev, char *page)
NeilBrown16c791a2011-07-28 11:31:47 +10002907{
2908 return badblocks_show(&rdev->badblocks, page, 1);
2909}
NeilBrown3cb03002011-10-11 16:45:26 +11002910static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
NeilBrown16c791a2011-07-28 11:31:47 +10002911{
2912 return badblocks_store(&rdev->badblocks, page, len, 1);
2913}
2914static struct rdev_sysfs_entry rdev_unack_bad_blocks =
2915__ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store);
2916
NeilBrown86e6ffd2005-11-08 21:39:24 -08002917static struct attribute *rdev_default_attrs[] = {
2918 &rdev_state.attr,
NeilBrown4dbcdc72006-01-06 00:20:52 -08002919 &rdev_errors.attr,
NeilBrown014236d2006-01-06 00:20:55 -08002920 &rdev_slot.attr,
NeilBrown93c8cad2006-01-06 00:20:56 -08002921 &rdev_offset.attr,
NeilBrownc6563a82012-05-21 09:27:00 +10002922 &rdev_new_offset.attr,
NeilBrown83303b62006-01-06 00:21:06 -08002923 &rdev_size.attr,
Dan Williams06e3c812009-12-12 21:17:12 -07002924 &rdev_recovery_start.attr,
NeilBrown16c791a2011-07-28 11:31:47 +10002925 &rdev_bad_blocks.attr,
2926 &rdev_unack_bad_blocks.attr,
NeilBrown86e6ffd2005-11-08 21:39:24 -08002927 NULL,
2928};
2929static ssize_t
2930rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
2931{
2932 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
NeilBrown3cb03002011-10-11 16:45:26 +11002933 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
NeilBrownfd01b882011-10-11 16:47:53 +11002934 struct mddev *mddev = rdev->mddev;
NeilBrown27c529b2008-03-04 14:29:33 -08002935 ssize_t rv;
NeilBrown86e6ffd2005-11-08 21:39:24 -08002936
2937 if (!entry->show)
2938 return -EIO;
NeilBrown27c529b2008-03-04 14:29:33 -08002939
2940 rv = mddev ? mddev_lock(mddev) : -EBUSY;
2941 if (!rv) {
2942 if (rdev->mddev == NULL)
2943 rv = -EBUSY;
2944 else
2945 rv = entry->show(rdev, page);
2946 mddev_unlock(mddev);
2947 }
2948 return rv;
NeilBrown86e6ffd2005-11-08 21:39:24 -08002949}
2950
2951static ssize_t
2952rdev_attr_store(struct kobject *kobj, struct attribute *attr,
2953 const char *page, size_t length)
2954{
2955 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
NeilBrown3cb03002011-10-11 16:45:26 +11002956 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
NeilBrown27c529b2008-03-04 14:29:33 -08002957 ssize_t rv;
NeilBrownfd01b882011-10-11 16:47:53 +11002958 struct mddev *mddev = rdev->mddev;
NeilBrown86e6ffd2005-11-08 21:39:24 -08002959
2960 if (!entry->store)
2961 return -EIO;
NeilBrown67463ac2006-07-10 04:44:19 -07002962 if (!capable(CAP_SYS_ADMIN))
2963 return -EACCES;
NeilBrown27c529b2008-03-04 14:29:33 -08002964 rv = mddev ? mddev_lock(mddev): -EBUSY;
NeilBrownca388052008-02-06 01:39:55 -08002965 if (!rv) {
NeilBrown27c529b2008-03-04 14:29:33 -08002966 if (rdev->mddev == NULL)
2967 rv = -EBUSY;
2968 else
2969 rv = entry->store(rdev, page, length);
Dan Williams6a518302008-04-30 00:52:28 -07002970 mddev_unlock(mddev);
NeilBrownca388052008-02-06 01:39:55 -08002971 }
2972 return rv;
NeilBrown86e6ffd2005-11-08 21:39:24 -08002973}
2974
2975static void rdev_free(struct kobject *ko)
2976{
NeilBrown3cb03002011-10-11 16:45:26 +11002977 struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
NeilBrown86e6ffd2005-11-08 21:39:24 -08002978 kfree(rdev);
2979}
Emese Revfy52cf25d2010-01-19 02:58:23 +01002980static const struct sysfs_ops rdev_sysfs_ops = {
NeilBrown86e6ffd2005-11-08 21:39:24 -08002981 .show = rdev_attr_show,
2982 .store = rdev_attr_store,
2983};
2984static struct kobj_type rdev_ktype = {
2985 .release = rdev_free,
2986 .sysfs_ops = &rdev_sysfs_ops,
2987 .default_attrs = rdev_default_attrs,
2988};
2989
NeilBrown3cb03002011-10-11 16:45:26 +11002990int md_rdev_init(struct md_rdev *rdev)
NeilBrowne8bb9a82010-06-01 19:37:26 +10002991{
2992 rdev->desc_nr = -1;
2993 rdev->saved_raid_disk = -1;
2994 rdev->raid_disk = -1;
2995 rdev->flags = 0;
2996 rdev->data_offset = 0;
NeilBrownc6563a82012-05-21 09:27:00 +10002997 rdev->new_data_offset = 0;
NeilBrowne8bb9a82010-06-01 19:37:26 +10002998 rdev->sb_events = 0;
2999 rdev->last_read_error.tv_sec = 0;
3000 rdev->last_read_error.tv_nsec = 0;
NeilBrown2699b672011-07-28 11:31:47 +10003001 rdev->sb_loaded = 0;
3002 rdev->bb_page = NULL;
NeilBrowne8bb9a82010-06-01 19:37:26 +10003003 atomic_set(&rdev->nr_pending, 0);
3004 atomic_set(&rdev->read_errors, 0);
3005 atomic_set(&rdev->corrected_errors, 0);
3006
3007 INIT_LIST_HEAD(&rdev->same_set);
3008 init_waitqueue_head(&rdev->blocked_wait);
NeilBrown2230dfe2011-07-28 11:31:46 +10003009
3010 /* Add space to store bad block list.
3011 * This reserves the space even on arrays where it cannot
3012 * be used - I wonder if that matters
3013 */
3014 rdev->badblocks.count = 0;
NeilBrown486adf72013-04-24 11:42:44 +10003015 rdev->badblocks.shift = -1; /* disabled until explicitly enabled */
NeilBrown2230dfe2011-07-28 11:31:46 +10003016 rdev->badblocks.page = kmalloc(PAGE_SIZE, GFP_KERNEL);
3017 seqlock_init(&rdev->badblocks.lock);
3018 if (rdev->badblocks.page == NULL)
3019 return -ENOMEM;
3020
3021 return 0;
NeilBrowne8bb9a82010-06-01 19:37:26 +10003022}
3023EXPORT_SYMBOL_GPL(md_rdev_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024/*
3025 * Import a device. If 'super_format' >= 0, then sanity check the superblock
3026 *
3027 * mark the device faulty if:
3028 *
3029 * - the device is nonexistent (zero size)
3030 * - the device has no valid superblock
3031 *
3032 * a faulty rdev _never_ has rdev->sb set.
3033 */
NeilBrown3cb03002011-10-11 16:45:26 +11003034static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035{
3036 char b[BDEVNAME_SIZE];
3037 int err;
NeilBrown3cb03002011-10-11 16:45:26 +11003038 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039 sector_t size;
3040
NeilBrown9ffae0c2006-01-06 00:20:32 -08003041 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003042 if (!rdev) {
3043 printk(KERN_ERR "md: could not alloc mem for new device!\n");
3044 return ERR_PTR(-ENOMEM);
3045 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046
NeilBrown2230dfe2011-07-28 11:31:46 +10003047 err = md_rdev_init(rdev);
3048 if (err)
3049 goto abort_free;
3050 err = alloc_disk_sb(rdev);
3051 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 goto abort_free;
3053
NeilBrownc5d79ad2008-02-06 01:39:54 -08003054 err = lock_rdev(rdev, newdev, super_format == -2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003055 if (err)
3056 goto abort_free;
3057
Greg Kroah-Hartmanf9cb0742007-12-17 23:05:35 -07003058 kobject_init(&rdev->kobj, &rdev_ktype);
NeilBrown86e6ffd2005-11-08 21:39:24 -08003059
Mike Snitzer77304d22010-11-08 14:39:12 +01003060 size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003061 if (!size) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10003062 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063 "md: %s has zero or unknown size, marking faulty!\n",
3064 bdevname(rdev->bdev,b));
3065 err = -EINVAL;
3066 goto abort_free;
3067 }
3068
3069 if (super_format >= 0) {
3070 err = super_types[super_format].
3071 load_super(rdev, NULL, super_minor);
3072 if (err == -EINVAL) {
NeilBrowndf968c42007-07-17 04:06:11 -07003073 printk(KERN_WARNING
3074 "md: %s does not have a valid v%d.%d "
3075 "superblock, not importing!\n",
3076 bdevname(rdev->bdev,b),
3077 super_format, super_minor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078 goto abort_free;
3079 }
3080 if (err < 0) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10003081 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07003082 "md: could not read %s's sb, not importing!\n",
3083 bdevname(rdev->bdev,b));
3084 goto abort_free;
3085 }
3086 }
Dan Williams6bfe0b42008-04-30 00:52:32 -07003087
Linus Torvalds1da177e2005-04-16 15:20:36 -07003088 return rdev;
3089
3090abort_free:
NeilBrown2699b672011-07-28 11:31:47 +10003091 if (rdev->bdev)
3092 unlock_rdev(rdev);
NeilBrown545c8792012-05-22 13:54:30 +10003093 md_rdev_clear(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003094 kfree(rdev);
3095 return ERR_PTR(err);
3096}
3097
3098/*
3099 * Check a full RAID array for plausibility
3100 */
3101
NeilBrownf72ffdd2014-09-30 14:23:59 +10003102static void analyze_sbs(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003103{
3104 int i;
NeilBrown3cb03002011-10-11 16:45:26 +11003105 struct md_rdev *rdev, *freshest, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003106 char b[BDEVNAME_SIZE];
3107
3108 freshest = NULL;
NeilBrowndafb20f2012-03-19 12:46:39 +11003109 rdev_for_each_safe(rdev, tmp, mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003110 switch (super_types[mddev->major_version].
3111 load_super(rdev, freshest, mddev->minor_version)) {
3112 case 1:
3113 freshest = rdev;
3114 break;
3115 case 0:
3116 break;
3117 default:
3118 printk( KERN_ERR \
3119 "md: fatal superblock inconsistency in %s"
NeilBrownf72ffdd2014-09-30 14:23:59 +10003120 " -- removing from array\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121 bdevname(rdev->bdev,b));
3122 kick_rdev_from_array(rdev);
3123 }
3124
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125 super_types[mddev->major_version].
3126 validate_super(mddev, freshest);
3127
3128 i = 0;
NeilBrowndafb20f2012-03-19 12:46:39 +11003129 rdev_for_each_safe(rdev, tmp, mddev) {
NeilBrown233fca32010-04-14 17:02:09 +10003130 if (mddev->max_disks &&
3131 (rdev->desc_nr >= mddev->max_disks ||
3132 i > mddev->max_disks)) {
NeilBrownde01dfa2009-02-06 18:02:46 +11003133 printk(KERN_WARNING
3134 "md: %s: %s: only %d devices permitted\n",
3135 mdname(mddev), bdevname(rdev->bdev, b),
3136 mddev->max_disks);
3137 kick_rdev_from_array(rdev);
3138 continue;
3139 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003140 if (rdev != freshest)
3141 if (super_types[mddev->major_version].
3142 validate_super(mddev, rdev)) {
3143 printk(KERN_WARNING "md: kicking non-fresh %s"
3144 " from array!\n",
3145 bdevname(rdev->bdev,b));
3146 kick_rdev_from_array(rdev);
3147 continue;
3148 }
3149 if (mddev->level == LEVEL_MULTIPATH) {
3150 rdev->desc_nr = i++;
3151 rdev->raid_disk = rdev->desc_nr;
NeilBrownb2d444d2005-11-08 21:39:31 -08003152 set_bit(In_sync, &rdev->flags);
NeilBrown5e5e3e72009-10-16 16:35:30 +11003153 } else if (rdev->raid_disk >= (mddev->raid_disks - min(0, mddev->delta_disks))) {
NeilBrowna778b732007-05-23 13:58:10 -07003154 rdev->raid_disk = -1;
3155 clear_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003156 }
3157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158}
3159
NeilBrown72e02072009-12-14 12:49:55 +11003160/* Read a fixed-point number.
3161 * Numbers in sysfs attributes should be in "standard" units where
3162 * possible, so time should be in seconds.
NeilBrownf72ffdd2014-09-30 14:23:59 +10003163 * However we internally use a a much smaller unit such as
NeilBrown72e02072009-12-14 12:49:55 +11003164 * milliseconds or jiffies.
3165 * This function takes a decimal number with a possible fractional
3166 * component, and produces an integer which is the result of
3167 * multiplying that number by 10^'scale'.
3168 * all without any floating-point arithmetic.
3169 */
3170int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
3171{
3172 unsigned long result = 0;
3173 long decimals = -1;
3174 while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
3175 if (*cp == '.')
3176 decimals = 0;
3177 else if (decimals < scale) {
3178 unsigned int value;
3179 value = *cp - '0';
3180 result = result * 10 + value;
3181 if (decimals >= 0)
3182 decimals++;
3183 }
3184 cp++;
3185 }
3186 if (*cp == '\n')
3187 cp++;
3188 if (*cp)
3189 return -EINVAL;
3190 if (decimals < 0)
3191 decimals = 0;
3192 while (decimals < scale) {
3193 result *= 10;
3194 decimals ++;
3195 }
3196 *res = result;
3197 return 0;
3198}
3199
NeilBrown19052c02008-08-05 15:54:13 +10003200static void md_safemode_timeout(unsigned long data);
3201
NeilBrowneae17012005-11-08 21:39:23 -08003202static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003203safe_delay_show(struct mddev *mddev, char *page)
NeilBrown16f17b32006-06-26 00:27:37 -07003204{
3205 int msec = (mddev->safemode_delay*1000)/HZ;
3206 return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
3207}
3208static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003209safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
NeilBrown16f17b32006-06-26 00:27:37 -07003210{
NeilBrown16f17b32006-06-26 00:27:37 -07003211 unsigned long msec;
Dan Williams97ce0a72008-09-24 22:48:19 -07003212
NeilBrown72e02072009-12-14 12:49:55 +11003213 if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
NeilBrown16f17b32006-06-26 00:27:37 -07003214 return -EINVAL;
NeilBrown16f17b32006-06-26 00:27:37 -07003215 if (msec == 0)
3216 mddev->safemode_delay = 0;
3217 else {
NeilBrown19052c02008-08-05 15:54:13 +10003218 unsigned long old_delay = mddev->safemode_delay;
NeilBrown16f17b32006-06-26 00:27:37 -07003219 mddev->safemode_delay = (msec*HZ)/1000;
3220 if (mddev->safemode_delay == 0)
3221 mddev->safemode_delay = 1;
NeilBrown275c51c2013-08-08 09:20:32 +10003222 if (mddev->safemode_delay < old_delay || old_delay == 0)
NeilBrown19052c02008-08-05 15:54:13 +10003223 md_safemode_timeout((unsigned long)mddev);
NeilBrown16f17b32006-06-26 00:27:37 -07003224 }
3225 return len;
3226}
3227static struct md_sysfs_entry md_safe_delay =
NeilBrown80ca3a42006-07-10 04:44:18 -07003228__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
NeilBrown16f17b32006-06-26 00:27:37 -07003229
3230static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003231level_show(struct mddev *mddev, char *page)
NeilBrowneae17012005-11-08 21:39:23 -08003232{
NeilBrown84fc4b52011-10-11 16:49:58 +11003233 struct md_personality *p = mddev->pers;
NeilBrownd9d166c2006-01-06 00:20:51 -08003234 if (p)
NeilBrowneae17012005-11-08 21:39:23 -08003235 return sprintf(page, "%s\n", p->name);
NeilBrownd9d166c2006-01-06 00:20:51 -08003236 else if (mddev->clevel[0])
3237 return sprintf(page, "%s\n", mddev->clevel);
3238 else if (mddev->level != LEVEL_NONE)
3239 return sprintf(page, "%d\n", mddev->level);
3240 else
3241 return 0;
NeilBrowneae17012005-11-08 21:39:23 -08003242}
3243
NeilBrownd9d166c2006-01-06 00:20:51 -08003244static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003245level_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownd9d166c2006-01-06 00:20:51 -08003246{
Dan Williamsf2859af2010-05-02 10:04:16 -07003247 char clevel[16];
NeilBrown20a49ff2008-02-06 01:39:57 -08003248 ssize_t rv = len;
NeilBrown84fc4b52011-10-11 16:49:58 +11003249 struct md_personality *pers;
Dan Williamsf2859af2010-05-02 10:04:16 -07003250 long level;
NeilBrown245f46c2009-03-31 14:39:39 +11003251 void *priv;
NeilBrown3cb03002011-10-11 16:45:26 +11003252 struct md_rdev *rdev;
NeilBrown245f46c2009-03-31 14:39:39 +11003253
3254 if (mddev->pers == NULL) {
3255 if (len == 0)
3256 return 0;
3257 if (len >= sizeof(mddev->clevel))
3258 return -ENOSPC;
3259 strncpy(mddev->clevel, buf, len);
3260 if (mddev->clevel[len-1] == '\n')
3261 len--;
3262 mddev->clevel[len] = 0;
3263 mddev->level = LEVEL_NONE;
3264 return rv;
3265 }
NeilBrownbd8839e2014-05-28 13:39:21 +10003266 if (mddev->ro)
3267 return -EROFS;
NeilBrown245f46c2009-03-31 14:39:39 +11003268
3269 /* request to change the personality. Need to ensure:
3270 * - array is not engaged in resync/recovery/reshape
3271 * - old personality can be suspended
3272 * - new personality will access other array.
3273 */
3274
NeilBrownbb4f1e92010-08-08 21:18:03 +10003275 if (mddev->sync_thread ||
NeilBrownf851b602014-12-11 10:02:10 +11003276 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
NeilBrownbb4f1e92010-08-08 21:18:03 +10003277 mddev->reshape_position != MaxSector ||
3278 mddev->sysfs_active)
NeilBrownd9d166c2006-01-06 00:20:51 -08003279 return -EBUSY;
NeilBrown245f46c2009-03-31 14:39:39 +11003280
3281 if (!mddev->pers->quiesce) {
3282 printk(KERN_WARNING "md: %s: %s does not support online personality change\n",
3283 mdname(mddev), mddev->pers->name);
3284 return -EINVAL;
3285 }
3286
3287 /* Now find the new personality */
Dan Williamsf2859af2010-05-02 10:04:16 -07003288 if (len == 0 || len >= sizeof(clevel))
NeilBrown245f46c2009-03-31 14:39:39 +11003289 return -EINVAL;
Dan Williamsf2859af2010-05-02 10:04:16 -07003290 strncpy(clevel, buf, len);
3291 if (clevel[len-1] == '\n')
NeilBrownd9d166c2006-01-06 00:20:51 -08003292 len--;
Dan Williamsf2859af2010-05-02 10:04:16 -07003293 clevel[len] = 0;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09003294 if (kstrtol(clevel, 10, &level))
Dan Williamsf2859af2010-05-02 10:04:16 -07003295 level = LEVEL_NONE;
NeilBrown245f46c2009-03-31 14:39:39 +11003296
Dan Williamsf2859af2010-05-02 10:04:16 -07003297 if (request_module("md-%s", clevel) != 0)
3298 request_module("md-level-%s", clevel);
NeilBrown245f46c2009-03-31 14:39:39 +11003299 spin_lock(&pers_lock);
Dan Williamsf2859af2010-05-02 10:04:16 -07003300 pers = find_pers(level, clevel);
NeilBrown245f46c2009-03-31 14:39:39 +11003301 if (!pers || !try_module_get(pers->owner)) {
3302 spin_unlock(&pers_lock);
Dan Williamsf2859af2010-05-02 10:04:16 -07003303 printk(KERN_WARNING "md: personality %s not loaded\n", clevel);
NeilBrown245f46c2009-03-31 14:39:39 +11003304 return -EINVAL;
3305 }
3306 spin_unlock(&pers_lock);
3307
3308 if (pers == mddev->pers) {
3309 /* Nothing to do! */
3310 module_put(pers->owner);
3311 return rv;
3312 }
3313 if (!pers->takeover) {
3314 module_put(pers->owner);
3315 printk(KERN_WARNING "md: %s: %s does not support personality takeover\n",
Dan Williamsf2859af2010-05-02 10:04:16 -07003316 mdname(mddev), clevel);
NeilBrown245f46c2009-03-31 14:39:39 +11003317 return -EINVAL;
3318 }
3319
NeilBrowndafb20f2012-03-19 12:46:39 +11003320 rdev_for_each(rdev, mddev)
NeilBrowne93f68a2010-06-15 09:36:03 +01003321 rdev->new_raid_disk = rdev->raid_disk;
3322
NeilBrown245f46c2009-03-31 14:39:39 +11003323 /* ->takeover must set new_* and/or delta_disks
3324 * if it succeeds, and may set them when it fails.
3325 */
3326 priv = pers->takeover(mddev);
3327 if (IS_ERR(priv)) {
3328 mddev->new_level = mddev->level;
3329 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10003330 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrown245f46c2009-03-31 14:39:39 +11003331 mddev->raid_disks -= mddev->delta_disks;
3332 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10003333 mddev->reshape_backwards = 0;
NeilBrown245f46c2009-03-31 14:39:39 +11003334 module_put(pers->owner);
3335 printk(KERN_WARNING "md: %s: %s would not accept array\n",
Dan Williamsf2859af2010-05-02 10:04:16 -07003336 mdname(mddev), clevel);
NeilBrown245f46c2009-03-31 14:39:39 +11003337 return PTR_ERR(priv);
3338 }
3339
3340 /* Looks like we have a winner */
3341 mddev_suspend(mddev);
3342 mddev->pers->stop(mddev);
NeilBrownf72ffdd2014-09-30 14:23:59 +10003343
NeilBrowna64c8762010-04-14 17:15:37 +10003344 if (mddev->pers->sync_request == NULL &&
3345 pers->sync_request != NULL) {
3346 /* need to add the md_redundancy_group */
3347 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
3348 printk(KERN_WARNING
3349 "md: cannot register extra attributes for %s\n",
3350 mdname(mddev));
Tejun Heo388975c2013-09-11 23:19:13 -04003351 mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
NeilBrownf72ffdd2014-09-30 14:23:59 +10003352 }
NeilBrowna64c8762010-04-14 17:15:37 +10003353 if (mddev->pers->sync_request != NULL &&
3354 pers->sync_request == NULL) {
3355 /* need to remove the md_redundancy_group */
3356 if (mddev->to_remove == NULL)
3357 mddev->to_remove = &md_redundancy_group;
3358 }
3359
Trela Maciej54071b32010-03-08 16:02:42 +11003360 if (mddev->pers->sync_request == NULL &&
3361 mddev->external) {
3362 /* We are converting from a no-redundancy array
3363 * to a redundancy array and metadata is managed
3364 * externally so we need to be sure that writes
3365 * won't block due to a need to transition
3366 * clean->dirty
3367 * until external management is started.
3368 */
3369 mddev->in_sync = 0;
3370 mddev->safemode_delay = 0;
3371 mddev->safemode = 0;
3372 }
3373
NeilBrowndafb20f2012-03-19 12:46:39 +11003374 rdev_for_each(rdev, mddev) {
NeilBrowne93f68a2010-06-15 09:36:03 +01003375 if (rdev->raid_disk < 0)
3376 continue;
NeilBrownbf2cb0d2011-01-14 09:14:34 +11003377 if (rdev->new_raid_disk >= mddev->raid_disks)
NeilBrowne93f68a2010-06-15 09:36:03 +01003378 rdev->new_raid_disk = -1;
3379 if (rdev->new_raid_disk == rdev->raid_disk)
3380 continue;
Namhyung Kim36fad852011-07-27 11:00:36 +10003381 sysfs_unlink_rdev(mddev, rdev);
NeilBrowne93f68a2010-06-15 09:36:03 +01003382 }
NeilBrowndafb20f2012-03-19 12:46:39 +11003383 rdev_for_each(rdev, mddev) {
NeilBrowne93f68a2010-06-15 09:36:03 +01003384 if (rdev->raid_disk < 0)
3385 continue;
3386 if (rdev->new_raid_disk == rdev->raid_disk)
3387 continue;
3388 rdev->raid_disk = rdev->new_raid_disk;
3389 if (rdev->raid_disk < 0)
NeilBrown3a981b02009-08-03 10:59:55 +10003390 clear_bit(In_sync, &rdev->flags);
NeilBrowne93f68a2010-06-15 09:36:03 +01003391 else {
Namhyung Kim36fad852011-07-27 11:00:36 +10003392 if (sysfs_link_rdev(mddev, rdev))
3393 printk(KERN_WARNING "md: cannot register rd%d"
3394 " for %s after level change\n",
3395 rdev->raid_disk, mdname(mddev));
NeilBrown3a981b02009-08-03 10:59:55 +10003396 }
NeilBrowne93f68a2010-06-15 09:36:03 +01003397 }
3398
3399 module_put(mddev->pers->owner);
NeilBrown245f46c2009-03-31 14:39:39 +11003400 mddev->pers = pers;
3401 mddev->private = priv;
3402 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3403 mddev->level = mddev->new_level;
3404 mddev->layout = mddev->new_layout;
Andre Noll664e7c42009-06-18 08:45:27 +10003405 mddev->chunk_sectors = mddev->new_chunk_sectors;
NeilBrown245f46c2009-03-31 14:39:39 +11003406 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10003407 mddev->reshape_backwards = 0;
Krzysztof Wojcikfee68722011-04-20 15:39:53 +10003408 mddev->degraded = 0;
Trela, Maciej9af204c2010-03-08 16:02:44 +11003409 if (mddev->pers->sync_request == NULL) {
3410 /* this is now an array without redundancy, so
3411 * it must always be in_sync
3412 */
3413 mddev->in_sync = 1;
3414 del_timer_sync(&mddev->safemode_timer);
3415 }
NeilBrown02e5f5c2013-11-14 15:16:15 +11003416 blk_set_stacking_limits(&mddev->queue->limits);
NeilBrown245f46c2009-03-31 14:39:39 +11003417 pers->run(mddev);
NeilBrown245f46c2009-03-31 14:39:39 +11003418 set_bit(MD_CHANGE_DEVS, &mddev->flags);
Jonathan Brassow47525e52012-05-22 13:55:29 +10003419 mddev_resume(mddev);
NeilBrown830778a2014-01-14 15:17:03 +11003420 if (!mddev->thread)
3421 md_update_sb(mddev, 1);
Maciej Trela5cac78612010-04-14 17:17:39 +10003422 sysfs_notify(&mddev->kobj, NULL, "level");
Dan Williamsbb7f8d22010-05-01 18:14:57 -07003423 md_new_event(mddev);
NeilBrownd9d166c2006-01-06 00:20:51 -08003424 return rv;
3425}
3426
3427static struct md_sysfs_entry md_level =
NeilBrown80ca3a42006-07-10 04:44:18 -07003428__ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
NeilBrowneae17012005-11-08 21:39:23 -08003429
NeilBrownd4dbd022006-06-26 00:27:59 -07003430static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003431layout_show(struct mddev *mddev, char *page)
NeilBrownd4dbd022006-06-26 00:27:59 -07003432{
3433 /* just a number, not meaningful for all levels */
NeilBrown08a02ec2007-05-09 02:35:38 -07003434 if (mddev->reshape_position != MaxSector &&
3435 mddev->layout != mddev->new_layout)
3436 return sprintf(page, "%d (%d)\n",
3437 mddev->new_layout, mddev->layout);
NeilBrownd4dbd022006-06-26 00:27:59 -07003438 return sprintf(page, "%d\n", mddev->layout);
3439}
3440
3441static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003442layout_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownd4dbd022006-06-26 00:27:59 -07003443{
3444 char *e;
3445 unsigned long n = simple_strtoul(buf, &e, 10);
NeilBrownd4dbd022006-06-26 00:27:59 -07003446
3447 if (!*buf || (*e && *e != '\n'))
3448 return -EINVAL;
3449
NeilBrownb3546032009-03-31 14:56:41 +11003450 if (mddev->pers) {
3451 int err;
NeilBrown50ac1682009-06-18 08:47:55 +10003452 if (mddev->pers->check_reshape == NULL)
NeilBrownb3546032009-03-31 14:56:41 +11003453 return -EBUSY;
NeilBrownbd8839e2014-05-28 13:39:21 +10003454 if (mddev->ro)
3455 return -EROFS;
NeilBrown597a7112009-06-18 08:47:42 +10003456 mddev->new_layout = n;
NeilBrown50ac1682009-06-18 08:47:55 +10003457 err = mddev->pers->check_reshape(mddev);
NeilBrown597a7112009-06-18 08:47:42 +10003458 if (err) {
3459 mddev->new_layout = mddev->layout;
NeilBrownb3546032009-03-31 14:56:41 +11003460 return err;
NeilBrown597a7112009-06-18 08:47:42 +10003461 }
NeilBrownb3546032009-03-31 14:56:41 +11003462 } else {
NeilBrown08a02ec2007-05-09 02:35:38 -07003463 mddev->new_layout = n;
NeilBrownb3546032009-03-31 14:56:41 +11003464 if (mddev->reshape_position == MaxSector)
3465 mddev->layout = n;
3466 }
NeilBrownd4dbd022006-06-26 00:27:59 -07003467 return len;
3468}
3469static struct md_sysfs_entry md_layout =
NeilBrown80ca3a42006-07-10 04:44:18 -07003470__ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
NeilBrownd4dbd022006-06-26 00:27:59 -07003471
NeilBrowneae17012005-11-08 21:39:23 -08003472static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003473raid_disks_show(struct mddev *mddev, char *page)
NeilBrowneae17012005-11-08 21:39:23 -08003474{
NeilBrownbb636542005-11-08 21:39:45 -08003475 if (mddev->raid_disks == 0)
3476 return 0;
NeilBrown08a02ec2007-05-09 02:35:38 -07003477 if (mddev->reshape_position != MaxSector &&
3478 mddev->delta_disks != 0)
3479 return sprintf(page, "%d (%d)\n", mddev->raid_disks,
3480 mddev->raid_disks - mddev->delta_disks);
NeilBrowneae17012005-11-08 21:39:23 -08003481 return sprintf(page, "%d\n", mddev->raid_disks);
3482}
3483
NeilBrownfd01b882011-10-11 16:47:53 +11003484static int update_raid_disks(struct mddev *mddev, int raid_disks);
NeilBrownda943b992006-01-06 00:20:54 -08003485
3486static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003487raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownda943b992006-01-06 00:20:54 -08003488{
NeilBrownda943b992006-01-06 00:20:54 -08003489 char *e;
3490 int rv = 0;
3491 unsigned long n = simple_strtoul(buf, &e, 10);
3492
3493 if (!*buf || (*e && *e != '\n'))
3494 return -EINVAL;
3495
3496 if (mddev->pers)
3497 rv = update_raid_disks(mddev, n);
NeilBrown08a02ec2007-05-09 02:35:38 -07003498 else if (mddev->reshape_position != MaxSector) {
NeilBrownc6563a82012-05-21 09:27:00 +10003499 struct md_rdev *rdev;
NeilBrown08a02ec2007-05-09 02:35:38 -07003500 int olddisks = mddev->raid_disks - mddev->delta_disks;
NeilBrownc6563a82012-05-21 09:27:00 +10003501
3502 rdev_for_each(rdev, mddev) {
3503 if (olddisks < n &&
3504 rdev->data_offset < rdev->new_data_offset)
3505 return -EINVAL;
3506 if (olddisks > n &&
3507 rdev->data_offset > rdev->new_data_offset)
3508 return -EINVAL;
3509 }
NeilBrown08a02ec2007-05-09 02:35:38 -07003510 mddev->delta_disks = n - olddisks;
3511 mddev->raid_disks = n;
NeilBrown2c810cd2012-05-21 09:27:00 +10003512 mddev->reshape_backwards = (mddev->delta_disks < 0);
NeilBrown08a02ec2007-05-09 02:35:38 -07003513 } else
NeilBrownda943b992006-01-06 00:20:54 -08003514 mddev->raid_disks = n;
3515 return rv ? rv : len;
3516}
3517static struct md_sysfs_entry md_raid_disks =
NeilBrown80ca3a42006-07-10 04:44:18 -07003518__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
NeilBrowneae17012005-11-08 21:39:23 -08003519
NeilBrown24dd4692005-11-08 21:39:26 -08003520static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003521chunk_size_show(struct mddev *mddev, char *page)
NeilBrown3b343802006-01-06 00:20:47 -08003522{
NeilBrown08a02ec2007-05-09 02:35:38 -07003523 if (mddev->reshape_position != MaxSector &&
Andre Noll664e7c42009-06-18 08:45:27 +10003524 mddev->chunk_sectors != mddev->new_chunk_sectors)
3525 return sprintf(page, "%d (%d)\n",
3526 mddev->new_chunk_sectors << 9,
Andre Noll9d8f0362009-06-18 08:45:01 +10003527 mddev->chunk_sectors << 9);
3528 return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
NeilBrown3b343802006-01-06 00:20:47 -08003529}
3530
3531static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003532chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown3b343802006-01-06 00:20:47 -08003533{
NeilBrown3b343802006-01-06 00:20:47 -08003534 char *e;
3535 unsigned long n = simple_strtoul(buf, &e, 10);
3536
NeilBrown3b343802006-01-06 00:20:47 -08003537 if (!*buf || (*e && *e != '\n'))
3538 return -EINVAL;
3539
NeilBrownb3546032009-03-31 14:56:41 +11003540 if (mddev->pers) {
3541 int err;
NeilBrown50ac1682009-06-18 08:47:55 +10003542 if (mddev->pers->check_reshape == NULL)
NeilBrownb3546032009-03-31 14:56:41 +11003543 return -EBUSY;
NeilBrownbd8839e2014-05-28 13:39:21 +10003544 if (mddev->ro)
3545 return -EROFS;
NeilBrown597a7112009-06-18 08:47:42 +10003546 mddev->new_chunk_sectors = n >> 9;
NeilBrown50ac1682009-06-18 08:47:55 +10003547 err = mddev->pers->check_reshape(mddev);
NeilBrown597a7112009-06-18 08:47:42 +10003548 if (err) {
3549 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownb3546032009-03-31 14:56:41 +11003550 return err;
NeilBrown597a7112009-06-18 08:47:42 +10003551 }
NeilBrownb3546032009-03-31 14:56:41 +11003552 } else {
Andre Noll664e7c42009-06-18 08:45:27 +10003553 mddev->new_chunk_sectors = n >> 9;
NeilBrownb3546032009-03-31 14:56:41 +11003554 if (mddev->reshape_position == MaxSector)
Andre Noll9d8f0362009-06-18 08:45:01 +10003555 mddev->chunk_sectors = n >> 9;
NeilBrownb3546032009-03-31 14:56:41 +11003556 }
NeilBrown3b343802006-01-06 00:20:47 -08003557 return len;
3558}
3559static struct md_sysfs_entry md_chunk_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07003560__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
NeilBrown3b343802006-01-06 00:20:47 -08003561
NeilBrowna94213b2006-06-26 00:28:00 -07003562static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003563resync_start_show(struct mddev *mddev, char *page)
NeilBrowna94213b2006-06-26 00:28:00 -07003564{
NeilBrownd1a7c502009-03-31 15:24:32 +11003565 if (mddev->recovery_cp == MaxSector)
3566 return sprintf(page, "none\n");
NeilBrowna94213b2006-06-26 00:28:00 -07003567 return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
3568}
3569
3570static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003571resync_start_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowna94213b2006-06-26 00:28:00 -07003572{
NeilBrowna94213b2006-06-26 00:28:00 -07003573 char *e;
3574 unsigned long long n = simple_strtoull(buf, &e, 10);
3575
NeilBrownb0986362011-05-11 15:52:21 +10003576 if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
NeilBrowna94213b2006-06-26 00:28:00 -07003577 return -EBUSY;
Dan Williams06e3c812009-12-12 21:17:12 -07003578 if (cmd_match(buf, "none"))
3579 n = MaxSector;
3580 else if (!*buf || (*e && *e != '\n'))
NeilBrowna94213b2006-06-26 00:28:00 -07003581 return -EINVAL;
3582
3583 mddev->recovery_cp = n;
NeilBrowndb07d852012-10-11 14:22:17 +11003584 if (mddev->pers)
3585 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrowna94213b2006-06-26 00:28:00 -07003586 return len;
3587}
3588static struct md_sysfs_entry md_resync_start =
NeilBrown80ca3a42006-07-10 04:44:18 -07003589__ATTR(resync_start, S_IRUGO|S_IWUSR, resync_start_show, resync_start_store);
NeilBrowna94213b2006-06-26 00:28:00 -07003590
NeilBrown9e653b62006-06-26 00:27:58 -07003591/*
3592 * The array state can be:
3593 *
3594 * clear
3595 * No devices, no size, no level
3596 * Equivalent to STOP_ARRAY ioctl
3597 * inactive
3598 * May have some settings, but array is not active
3599 * all IO results in error
3600 * When written, doesn't tear down array, but just stops it
3601 * suspended (not supported yet)
3602 * All IO requests will block. The array can be reconfigured.
Andre Noll910d8cb2008-03-25 21:00:53 +01003603 * Writing this, if accepted, will block until array is quiescent
NeilBrown9e653b62006-06-26 00:27:58 -07003604 * readonly
3605 * no resync can happen. no superblocks get written.
3606 * write requests fail
3607 * read-auto
3608 * like readonly, but behaves like 'clean' on a write request.
3609 *
3610 * clean - no pending writes, but otherwise active.
3611 * When written to inactive array, starts without resync
3612 * If a write request arrives then
3613 * if metadata is known, mark 'dirty' and switch to 'active'.
3614 * if not known, block and switch to write-pending
3615 * If written to an active array that has pending writes, then fails.
3616 * active
3617 * fully active: IO and resync can be happening.
3618 * When written to inactive array, starts with resync
3619 *
3620 * write-pending
3621 * clean, but writes are blocked waiting for 'active' to be written.
3622 *
3623 * active-idle
3624 * like active, but no writes have been seen for a while (100msec).
3625 *
3626 */
3627enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
3628 write_pending, active_idle, bad_word};
Adrian Bunk05381952006-06-26 00:28:01 -07003629static char *array_states[] = {
NeilBrown9e653b62006-06-26 00:27:58 -07003630 "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
3631 "write-pending", "active-idle", NULL };
3632
3633static int match_word(const char *word, char **list)
3634{
3635 int n;
3636 for (n=0; list[n]; n++)
3637 if (cmd_match(word, list[n]))
3638 break;
3639 return n;
3640}
3641
3642static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003643array_state_show(struct mddev *mddev, char *page)
NeilBrown9e653b62006-06-26 00:27:58 -07003644{
3645 enum array_state st = inactive;
3646
3647 if (mddev->pers)
3648 switch(mddev->ro) {
3649 case 1:
3650 st = readonly;
3651 break;
3652 case 2:
3653 st = read_auto;
3654 break;
3655 case 0:
3656 if (mddev->in_sync)
3657 st = clean;
NeilBrown070dc6d2010-08-30 17:33:34 +10003658 else if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
NeilBrowne6910632008-02-06 01:39:51 -08003659 st = write_pending;
NeilBrown9e653b62006-06-26 00:27:58 -07003660 else if (mddev->safemode)
3661 st = active_idle;
3662 else
3663 st = active;
3664 }
3665 else {
3666 if (list_empty(&mddev->disks) &&
3667 mddev->raid_disks == 0 &&
Andre Noll58c0fed2009-03-31 14:33:13 +11003668 mddev->dev_sectors == 0)
NeilBrown9e653b62006-06-26 00:27:58 -07003669 st = clear;
3670 else
3671 st = inactive;
3672 }
3673 return sprintf(page, "%s\n", array_states[st]);
3674}
3675
NeilBrownf72ffdd2014-09-30 14:23:59 +10003676static int do_md_stop(struct mddev *mddev, int ro, struct block_device *bdev);
3677static int md_set_readonly(struct mddev *mddev, struct block_device *bdev);
3678static int do_md_run(struct mddev *mddev);
NeilBrownfd01b882011-10-11 16:47:53 +11003679static int restart_array(struct mddev *mddev);
NeilBrown9e653b62006-06-26 00:27:58 -07003680
3681static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003682array_state_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown9e653b62006-06-26 00:27:58 -07003683{
3684 int err = -EINVAL;
3685 enum array_state st = match_word(buf, array_states);
3686 switch(st) {
3687 case bad_word:
3688 break;
3689 case clear:
3690 /* stopping an active array */
NeilBrowna05b7ea2012-07-19 15:59:18 +10003691 err = do_md_stop(mddev, 0, NULL);
NeilBrown9e653b62006-06-26 00:27:58 -07003692 break;
3693 case inactive:
3694 /* stopping an active array */
NeilBrown90cf1952012-07-31 10:04:55 +10003695 if (mddev->pers)
NeilBrowna05b7ea2012-07-19 15:59:18 +10003696 err = do_md_stop(mddev, 2, NULL);
NeilBrown90cf1952012-07-31 10:04:55 +10003697 else
NeilBrowne6910632008-02-06 01:39:51 -08003698 err = 0; /* already inactive */
NeilBrown9e653b62006-06-26 00:27:58 -07003699 break;
3700 case suspended:
3701 break; /* not supported yet */
3702 case readonly:
3703 if (mddev->pers)
NeilBrowna05b7ea2012-07-19 15:59:18 +10003704 err = md_set_readonly(mddev, NULL);
NeilBrown9e653b62006-06-26 00:27:58 -07003705 else {
3706 mddev->ro = 1;
NeilBrown648b6292008-04-30 00:52:30 -07003707 set_disk_ro(mddev->gendisk, 1);
NeilBrown9e653b62006-06-26 00:27:58 -07003708 err = do_md_run(mddev);
3709 }
3710 break;
3711 case read_auto:
NeilBrown9e653b62006-06-26 00:27:58 -07003712 if (mddev->pers) {
NeilBrown80268ee2008-10-13 11:55:12 +11003713 if (mddev->ro == 0)
NeilBrowna05b7ea2012-07-19 15:59:18 +10003714 err = md_set_readonly(mddev, NULL);
NeilBrown80268ee2008-10-13 11:55:12 +11003715 else if (mddev->ro == 1)
NeilBrown648b6292008-04-30 00:52:30 -07003716 err = restart_array(mddev);
3717 if (err == 0) {
3718 mddev->ro = 2;
3719 set_disk_ro(mddev->gendisk, 0);
3720 }
NeilBrown9e653b62006-06-26 00:27:58 -07003721 } else {
3722 mddev->ro = 2;
3723 err = do_md_run(mddev);
3724 }
3725 break;
3726 case clean:
3727 if (mddev->pers) {
3728 restart_array(mddev);
3729 spin_lock_irq(&mddev->write_lock);
3730 if (atomic_read(&mddev->writes_pending) == 0) {
NeilBrowne6910632008-02-06 01:39:51 -08003731 if (mddev->in_sync == 0) {
3732 mddev->in_sync = 1;
NeilBrown31a59e32008-04-30 00:52:30 -07003733 if (mddev->safemode == 1)
3734 mddev->safemode = 0;
NeilBrown070dc6d2010-08-30 17:33:34 +10003735 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrowne6910632008-02-06 01:39:51 -08003736 }
3737 err = 0;
3738 } else
3739 err = -EBUSY;
NeilBrown9e653b62006-06-26 00:27:58 -07003740 spin_unlock_irq(&mddev->write_lock);
NeilBrown5bf29592009-05-07 12:50:57 +10003741 } else
3742 err = -EINVAL;
NeilBrown9e653b62006-06-26 00:27:58 -07003743 break;
3744 case active:
3745 if (mddev->pers) {
3746 restart_array(mddev);
NeilBrown070dc6d2010-08-30 17:33:34 +10003747 clear_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrown9e653b62006-06-26 00:27:58 -07003748 wake_up(&mddev->sb_wait);
3749 err = 0;
3750 } else {
3751 mddev->ro = 0;
NeilBrown648b6292008-04-30 00:52:30 -07003752 set_disk_ro(mddev->gendisk, 0);
NeilBrown9e653b62006-06-26 00:27:58 -07003753 err = do_md_run(mddev);
3754 }
3755 break;
3756 case write_pending:
3757 case active_idle:
3758 /* these cannot be set */
3759 break;
3760 }
3761 if (err)
3762 return err;
Neil Brown0fd62b82008-06-28 08:31:36 +10003763 else {
NeilBrown1d23f172011-12-08 15:49:12 +11003764 if (mddev->hold_active == UNTIL_IOCTL)
3765 mddev->hold_active = 0;
NeilBrown00bcb4a2010-06-01 19:37:23 +10003766 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown9e653b62006-06-26 00:27:58 -07003767 return len;
Neil Brown0fd62b82008-06-28 08:31:36 +10003768 }
NeilBrown9e653b62006-06-26 00:27:58 -07003769}
NeilBrown80ca3a42006-07-10 04:44:18 -07003770static struct md_sysfs_entry md_array_state =
3771__ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
NeilBrown9e653b62006-06-26 00:27:58 -07003772
NeilBrown6d7ff732006-01-06 00:21:16 -08003773static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003774max_corrected_read_errors_show(struct mddev *mddev, char *page) {
Robert Becker1e509152009-12-14 12:49:58 +11003775 return sprintf(page, "%d\n",
3776 atomic_read(&mddev->max_corr_read_errors));
3777}
3778
3779static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003780max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
Robert Becker1e509152009-12-14 12:49:58 +11003781{
3782 char *e;
3783 unsigned long n = simple_strtoul(buf, &e, 10);
3784
3785 if (*buf && (*e == 0 || *e == '\n')) {
3786 atomic_set(&mddev->max_corr_read_errors, n);
3787 return len;
3788 }
3789 return -EINVAL;
3790}
3791
3792static struct md_sysfs_entry max_corr_read_errors =
3793__ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
3794 max_corrected_read_errors_store);
3795
3796static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003797null_show(struct mddev *mddev, char *page)
NeilBrown6d7ff732006-01-06 00:21:16 -08003798{
3799 return -EINVAL;
3800}
3801
3802static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003803new_dev_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown6d7ff732006-01-06 00:21:16 -08003804{
3805 /* buf must be %d:%d\n? giving major and minor numbers */
3806 /* The new device is added to the array.
3807 * If the array has a persistent superblock, we read the
3808 * superblock to initialise info and check validity.
3809 * Otherwise, only checking done is that in bind_rdev_to_array,
3810 * which mainly checks size.
3811 */
3812 char *e;
3813 int major = simple_strtoul(buf, &e, 10);
3814 int minor;
3815 dev_t dev;
NeilBrown3cb03002011-10-11 16:45:26 +11003816 struct md_rdev *rdev;
NeilBrown6d7ff732006-01-06 00:21:16 -08003817 int err;
3818
3819 if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
3820 return -EINVAL;
3821 minor = simple_strtoul(e+1, &e, 10);
3822 if (*e && *e != '\n')
3823 return -EINVAL;
3824 dev = MKDEV(major, minor);
3825 if (major != MAJOR(dev) ||
3826 minor != MINOR(dev))
3827 return -EOVERFLOW;
3828
NeilBrown6d7ff732006-01-06 00:21:16 -08003829 if (mddev->persistent) {
3830 rdev = md_import_device(dev, mddev->major_version,
3831 mddev->minor_version);
3832 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
NeilBrown3cb03002011-10-11 16:45:26 +11003833 struct md_rdev *rdev0
3834 = list_entry(mddev->disks.next,
3835 struct md_rdev, same_set);
NeilBrown6d7ff732006-01-06 00:21:16 -08003836 err = super_types[mddev->major_version]
3837 .load_super(rdev, rdev0, mddev->minor_version);
3838 if (err < 0)
3839 goto out;
3840 }
NeilBrownc5d79ad2008-02-06 01:39:54 -08003841 } else if (mddev->external)
3842 rdev = md_import_device(dev, -2, -1);
3843 else
NeilBrown6d7ff732006-01-06 00:21:16 -08003844 rdev = md_import_device(dev, -1, -1);
3845
3846 if (IS_ERR(rdev))
3847 return PTR_ERR(rdev);
3848 err = bind_rdev_to_array(rdev, mddev);
3849 out:
3850 if (err)
3851 export_rdev(rdev);
3852 return err ? err : len;
3853}
3854
3855static struct md_sysfs_entry md_new_device =
NeilBrown80ca3a42006-07-10 04:44:18 -07003856__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
NeilBrown3b343802006-01-06 00:20:47 -08003857
3858static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003859bitmap_store(struct mddev *mddev, const char *buf, size_t len)
Paul Clements9b1d1da2006-10-03 01:15:49 -07003860{
3861 char *end;
3862 unsigned long chunk, end_chunk;
3863
3864 if (!mddev->bitmap)
3865 goto out;
3866 /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
3867 while (*buf) {
3868 chunk = end_chunk = simple_strtoul(buf, &end, 0);
3869 if (buf == end) break;
3870 if (*end == '-') { /* range */
3871 buf = end + 1;
3872 end_chunk = simple_strtoul(buf, &end, 0);
3873 if (buf == end) break;
3874 }
3875 if (*end && !isspace(*end)) break;
3876 bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
André Goddard Rosae7d28602009-12-14 18:01:06 -08003877 buf = skip_spaces(end);
Paul Clements9b1d1da2006-10-03 01:15:49 -07003878 }
3879 bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
3880out:
3881 return len;
3882}
3883
3884static struct md_sysfs_entry md_bitmap =
3885__ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
3886
3887static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003888size_show(struct mddev *mddev, char *page)
NeilBrowna35b0d692006-01-06 00:20:49 -08003889{
Andre Noll58c0fed2009-03-31 14:33:13 +11003890 return sprintf(page, "%llu\n",
3891 (unsigned long long)mddev->dev_sectors / 2);
NeilBrowna35b0d692006-01-06 00:20:49 -08003892}
3893
NeilBrownfd01b882011-10-11 16:47:53 +11003894static int update_size(struct mddev *mddev, sector_t num_sectors);
NeilBrowna35b0d692006-01-06 00:20:49 -08003895
3896static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003897size_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowna35b0d692006-01-06 00:20:49 -08003898{
3899 /* If array is inactive, we can reduce the component size, but
3900 * not increase it (except from 0).
3901 * If array is active, we can try an on-line resize
3902 */
Dan Williamsb522adc2009-03-31 15:00:31 +11003903 sector_t sectors;
3904 int err = strict_blocks_to_sectors(buf, &sectors);
NeilBrowna35b0d692006-01-06 00:20:49 -08003905
Andre Noll58c0fed2009-03-31 14:33:13 +11003906 if (err < 0)
3907 return err;
NeilBrowna35b0d692006-01-06 00:20:49 -08003908 if (mddev->pers) {
Andre Noll58c0fed2009-03-31 14:33:13 +11003909 err = update_size(mddev, sectors);
NeilBrown850b2b42006-10-03 01:15:46 -07003910 md_update_sb(mddev, 1);
NeilBrowna35b0d692006-01-06 00:20:49 -08003911 } else {
Andre Noll58c0fed2009-03-31 14:33:13 +11003912 if (mddev->dev_sectors == 0 ||
3913 mddev->dev_sectors > sectors)
3914 mddev->dev_sectors = sectors;
NeilBrowna35b0d692006-01-06 00:20:49 -08003915 else
3916 err = -ENOSPC;
3917 }
3918 return err ? err : len;
3919}
3920
3921static struct md_sysfs_entry md_size =
NeilBrown80ca3a42006-07-10 04:44:18 -07003922__ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
NeilBrowna35b0d692006-01-06 00:20:49 -08003923
Masanari Iida83f0d772012-10-30 00:18:08 +09003924/* Metadata version.
NeilBrowne6910632008-02-06 01:39:51 -08003925 * This is one of
3926 * 'none' for arrays with no metadata (good luck...)
3927 * 'external' for arrays with externally managed metadata,
NeilBrown8bb93aa2006-01-06 00:20:50 -08003928 * or N.M for internally known formats
3929 */
3930static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003931metadata_show(struct mddev *mddev, char *page)
NeilBrown8bb93aa2006-01-06 00:20:50 -08003932{
3933 if (mddev->persistent)
3934 return sprintf(page, "%d.%d\n",
3935 mddev->major_version, mddev->minor_version);
NeilBrowne6910632008-02-06 01:39:51 -08003936 else if (mddev->external)
3937 return sprintf(page, "external:%s\n", mddev->metadata_type);
NeilBrown8bb93aa2006-01-06 00:20:50 -08003938 else
3939 return sprintf(page, "none\n");
3940}
3941
3942static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003943metadata_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown8bb93aa2006-01-06 00:20:50 -08003944{
3945 int major, minor;
3946 char *e;
NeilBrownea43ddd2008-10-13 11:55:11 +11003947 /* Changing the details of 'external' metadata is
3948 * always permitted. Otherwise there must be
3949 * no devices attached to the array.
3950 */
3951 if (mddev->external && strncmp(buf, "external:", 9) == 0)
3952 ;
3953 else if (!list_empty(&mddev->disks))
NeilBrown8bb93aa2006-01-06 00:20:50 -08003954 return -EBUSY;
3955
3956 if (cmd_match(buf, "none")) {
3957 mddev->persistent = 0;
NeilBrowne6910632008-02-06 01:39:51 -08003958 mddev->external = 0;
3959 mddev->major_version = 0;
3960 mddev->minor_version = 90;
3961 return len;
3962 }
3963 if (strncmp(buf, "external:", 9) == 0) {
NeilBrown20a49ff2008-02-06 01:39:57 -08003964 size_t namelen = len-9;
NeilBrowne6910632008-02-06 01:39:51 -08003965 if (namelen >= sizeof(mddev->metadata_type))
3966 namelen = sizeof(mddev->metadata_type)-1;
3967 strncpy(mddev->metadata_type, buf+9, namelen);
3968 mddev->metadata_type[namelen] = 0;
3969 if (namelen && mddev->metadata_type[namelen-1] == '\n')
3970 mddev->metadata_type[--namelen] = 0;
3971 mddev->persistent = 0;
3972 mddev->external = 1;
NeilBrown8bb93aa2006-01-06 00:20:50 -08003973 mddev->major_version = 0;
3974 mddev->minor_version = 90;
3975 return len;
3976 }
3977 major = simple_strtoul(buf, &e, 10);
3978 if (e==buf || *e != '.')
3979 return -EINVAL;
3980 buf = e+1;
3981 minor = simple_strtoul(buf, &e, 10);
NeilBrown3f9d7b02006-12-22 01:11:41 -08003982 if (e==buf || (*e && *e != '\n') )
NeilBrown8bb93aa2006-01-06 00:20:50 -08003983 return -EINVAL;
Ahmed S. Darwish50511da2007-05-09 02:35:34 -07003984 if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
NeilBrown8bb93aa2006-01-06 00:20:50 -08003985 return -ENOENT;
3986 mddev->major_version = major;
3987 mddev->minor_version = minor;
3988 mddev->persistent = 1;
NeilBrowne6910632008-02-06 01:39:51 -08003989 mddev->external = 0;
NeilBrown8bb93aa2006-01-06 00:20:50 -08003990 return len;
3991}
3992
3993static struct md_sysfs_entry md_metadata =
NeilBrown80ca3a42006-07-10 04:44:18 -07003994__ATTR(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
NeilBrown8bb93aa2006-01-06 00:20:50 -08003995
NeilBrowna35b0d692006-01-06 00:20:49 -08003996static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11003997action_show(struct mddev *mddev, char *page)
NeilBrown24dd4692005-11-08 21:39:26 -08003998{
NeilBrown7eec3142005-11-08 21:39:44 -08003999 char *type = "idle";
NeilBrownb6a9ce62009-05-26 09:41:17 +10004000 if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
4001 type = "frozen";
4002 else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
NeilBrown2b12ab62007-10-16 23:30:53 -07004003 (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))) {
NeilBrownccfcc3c2006-03-27 01:18:09 -08004004 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
4005 type = "reshape";
4006 else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
NeilBrown24dd4692005-11-08 21:39:26 -08004007 if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
4008 type = "resync";
4009 else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
4010 type = "check";
4011 else
4012 type = "repair";
Neil Brown72a23c22008-06-28 08:31:41 +10004013 } else if (test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
NeilBrown24dd4692005-11-08 21:39:26 -08004014 type = "recover";
4015 }
4016 return sprintf(page, "%s\n", type);
4017}
4018
4019static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004020action_store(struct mddev *mddev, const char *page, size_t len)
NeilBrown24dd4692005-11-08 21:39:26 -08004021{
NeilBrown7eec3142005-11-08 21:39:44 -08004022 if (!mddev->pers || !mddev->pers->sync_request)
4023 return -EINVAL;
4024
NeilBrownb6a9ce62009-05-26 09:41:17 +10004025 if (cmd_match(page, "frozen"))
4026 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4027 else
4028 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4029
4030 if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
NeilBrownf851b602014-12-11 10:02:10 +11004031 flush_workqueue(md_misc_wq);
NeilBrown7eec3142005-11-08 21:39:44 -08004032 if (mddev->sync_thread) {
4033 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10004034 md_reap_sync_thread(mddev);
NeilBrown7eec3142005-11-08 21:39:44 -08004035 }
NeilBrown03c902e2006-01-06 00:20:46 -08004036 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
4037 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
NeilBrown24dd4692005-11-08 21:39:26 -08004038 return -EBUSY;
Neil Brown72a23c22008-06-28 08:31:41 +10004039 else if (cmd_match(page, "resync"))
NeilBrown7eec3142005-11-08 21:39:44 -08004040 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10004041 else if (cmd_match(page, "recover")) {
4042 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
4043 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4044 } else if (cmd_match(page, "reshape")) {
NeilBrown16484bf2006-03-27 01:18:13 -08004045 int err;
4046 if (mddev->pers->start_reshape == NULL)
4047 return -EINVAL;
4048 err = mddev->pers->start_reshape(mddev);
4049 if (err)
4050 return err;
Neil Browna99ac972008-06-28 08:31:43 +10004051 sysfs_notify(&mddev->kobj, NULL, "degraded");
NeilBrown16484bf2006-03-27 01:18:13 -08004052 } else {
NeilBrownbce74da2006-01-06 00:20:41 -08004053 if (cmd_match(page, "check"))
NeilBrown7eec3142005-11-08 21:39:44 -08004054 set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
NeilBrown2adc7d42006-05-20 14:59:57 -07004055 else if (!cmd_match(page, "repair"))
NeilBrown7eec3142005-11-08 21:39:44 -08004056 return -EINVAL;
4057 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
4058 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
NeilBrown7eec3142005-11-08 21:39:44 -08004059 }
NeilBrown48c26dd2012-10-11 14:19:39 +11004060 if (mddev->ro == 2) {
4061 /* A write to sync_action is enough to justify
4062 * canceling read-auto mode
4063 */
4064 mddev->ro = 0;
4065 md_wakeup_thread(mddev->sync_thread);
4066 }
NeilBrown03c902e2006-01-06 00:20:46 -08004067 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown24dd4692005-11-08 21:39:26 -08004068 md_wakeup_thread(mddev->thread);
NeilBrown00bcb4a2010-06-01 19:37:23 +10004069 sysfs_notify_dirent_safe(mddev->sysfs_action);
NeilBrown24dd4692005-11-08 21:39:26 -08004070 return len;
4071}
4072
Jonathan Brassowc4a39552013-06-25 01:23:59 -05004073static struct md_sysfs_entry md_scan_mode =
4074__ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
4075
4076static ssize_t
4077last_sync_action_show(struct mddev *mddev, char *page)
4078{
4079 return sprintf(page, "%s\n", mddev->last_sync_action);
4080}
4081
4082static struct md_sysfs_entry md_last_scan_mode = __ATTR_RO(last_sync_action);
4083
NeilBrown9d888832005-11-08 21:39:26 -08004084static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004085mismatch_cnt_show(struct mddev *mddev, char *page)
NeilBrown9d888832005-11-08 21:39:26 -08004086{
4087 return sprintf(page, "%llu\n",
Jianpeng Ma7f7583d2012-10-11 14:17:59 +11004088 (unsigned long long)
4089 atomic64_read(&mddev->resync_mismatches));
NeilBrown9d888832005-11-08 21:39:26 -08004090}
4091
NeilBrown80ca3a42006-07-10 04:44:18 -07004092static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
NeilBrown9d888832005-11-08 21:39:26 -08004093
NeilBrown88202a02006-01-06 00:21:36 -08004094static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004095sync_min_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004096{
4097 return sprintf(page, "%d (%s)\n", speed_min(mddev),
4098 mddev->sync_speed_min ? "local": "system");
4099}
4100
4101static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004102sync_min_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown88202a02006-01-06 00:21:36 -08004103{
4104 int min;
4105 char *e;
4106 if (strncmp(buf, "system", 6)==0) {
4107 mddev->sync_speed_min = 0;
4108 return len;
4109 }
4110 min = simple_strtoul(buf, &e, 10);
4111 if (buf == e || (*e && *e != '\n') || min <= 0)
4112 return -EINVAL;
4113 mddev->sync_speed_min = min;
4114 return len;
4115}
4116
4117static struct md_sysfs_entry md_sync_min =
4118__ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
4119
4120static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004121sync_max_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004122{
4123 return sprintf(page, "%d (%s)\n", speed_max(mddev),
4124 mddev->sync_speed_max ? "local": "system");
4125}
4126
4127static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004128sync_max_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown88202a02006-01-06 00:21:36 -08004129{
4130 int max;
4131 char *e;
4132 if (strncmp(buf, "system", 6)==0) {
4133 mddev->sync_speed_max = 0;
4134 return len;
4135 }
4136 max = simple_strtoul(buf, &e, 10);
4137 if (buf == e || (*e && *e != '\n') || max <= 0)
4138 return -EINVAL;
4139 mddev->sync_speed_max = max;
4140 return len;
4141}
4142
4143static struct md_sysfs_entry md_sync_max =
4144__ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
4145
Iustin Popd7f3d292007-10-16 23:30:54 -07004146static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004147degraded_show(struct mddev *mddev, char *page)
Iustin Popd7f3d292007-10-16 23:30:54 -07004148{
4149 return sprintf(page, "%d\n", mddev->degraded);
4150}
4151static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
NeilBrown88202a02006-01-06 00:21:36 -08004152
4153static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004154sync_force_parallel_show(struct mddev *mddev, char *page)
Bernd Schubert90b08712008-05-23 13:04:38 -07004155{
4156 return sprintf(page, "%d\n", mddev->parallel_resync);
4157}
4158
4159static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004160sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
Bernd Schubert90b08712008-05-23 13:04:38 -07004161{
4162 long n;
4163
Jingoo Hanb29bebd2013-06-01 16:15:16 +09004164 if (kstrtol(buf, 10, &n))
Bernd Schubert90b08712008-05-23 13:04:38 -07004165 return -EINVAL;
4166
4167 if (n != 0 && n != 1)
4168 return -EINVAL;
4169
4170 mddev->parallel_resync = n;
4171
4172 if (mddev->sync_thread)
4173 wake_up(&resync_wait);
4174
4175 return len;
4176}
4177
4178/* force parallel resync, even with shared block devices */
4179static struct md_sysfs_entry md_sync_force_parallel =
4180__ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
4181 sync_force_parallel_show, sync_force_parallel_store);
4182
4183static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004184sync_speed_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004185{
4186 unsigned long resync, dt, db;
NeilBrownd1a7c502009-03-31 15:24:32 +11004187 if (mddev->curr_resync == 0)
4188 return sprintf(page, "none\n");
Andre Noll9687a602008-03-25 22:24:09 +01004189 resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
4190 dt = (jiffies - mddev->resync_mark) / HZ;
NeilBrown88202a02006-01-06 00:21:36 -08004191 if (!dt) dt++;
Andre Noll9687a602008-03-25 22:24:09 +01004192 db = resync - mddev->resync_mark_cnt;
4193 return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
NeilBrown88202a02006-01-06 00:21:36 -08004194}
4195
NeilBrown80ca3a42006-07-10 04:44:18 -07004196static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
NeilBrown88202a02006-01-06 00:21:36 -08004197
4198static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004199sync_completed_show(struct mddev *mddev, char *page)
NeilBrown88202a02006-01-06 00:21:36 -08004200{
Rémi Rérolle13ae8642011-01-14 09:14:34 +11004201 unsigned long long max_sectors, resync;
NeilBrown88202a02006-01-06 00:21:36 -08004202
NeilBrownacb180b2009-04-14 16:28:34 +10004203 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4204 return sprintf(page, "none\n");
4205
NeilBrown72f36d52012-10-11 14:25:57 +11004206 if (mddev->curr_resync == 1 ||
4207 mddev->curr_resync == 2)
4208 return sprintf(page, "delayed\n");
4209
NeilBrownc804cde2012-05-21 09:28:33 +10004210 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
4211 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
Andre Noll58c0fed2009-03-31 14:33:13 +11004212 max_sectors = mddev->resync_max_sectors;
NeilBrown88202a02006-01-06 00:21:36 -08004213 else
Andre Noll58c0fed2009-03-31 14:33:13 +11004214 max_sectors = mddev->dev_sectors;
NeilBrown88202a02006-01-06 00:21:36 -08004215
NeilBrownacb180b2009-04-14 16:28:34 +10004216 resync = mddev->curr_resync_completed;
Rémi Rérolle13ae8642011-01-14 09:14:34 +11004217 return sprintf(page, "%llu / %llu\n", resync, max_sectors);
NeilBrown88202a02006-01-06 00:21:36 -08004218}
4219
NeilBrown80ca3a42006-07-10 04:44:18 -07004220static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
NeilBrown88202a02006-01-06 00:21:36 -08004221
NeilBrowne464eaf2006-03-27 01:18:14 -08004222static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004223min_sync_show(struct mddev *mddev, char *page)
Neil Brown5e96ee62008-06-28 08:31:24 +10004224{
4225 return sprintf(page, "%llu\n",
4226 (unsigned long long)mddev->resync_min);
4227}
4228static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004229min_sync_store(struct mddev *mddev, const char *buf, size_t len)
Neil Brown5e96ee62008-06-28 08:31:24 +10004230{
4231 unsigned long long min;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09004232 if (kstrtoull(buf, 10, &min))
Neil Brown5e96ee62008-06-28 08:31:24 +10004233 return -EINVAL;
4234 if (min > mddev->resync_max)
4235 return -EINVAL;
4236 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4237 return -EBUSY;
4238
4239 /* Must be a multiple of chunk_size */
Andre Noll9d8f0362009-06-18 08:45:01 +10004240 if (mddev->chunk_sectors) {
raz ben yehuda2ac06c32009-06-16 17:01:42 +10004241 sector_t temp = min;
Andre Noll9d8f0362009-06-18 08:45:01 +10004242 if (sector_div(temp, mddev->chunk_sectors))
Neil Brown5e96ee62008-06-28 08:31:24 +10004243 return -EINVAL;
4244 }
4245 mddev->resync_min = min;
4246
4247 return len;
4248}
4249
4250static struct md_sysfs_entry md_min_sync =
4251__ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
4252
4253static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004254max_sync_show(struct mddev *mddev, char *page)
NeilBrownc6207272008-02-06 01:39:52 -08004255{
4256 if (mddev->resync_max == MaxSector)
4257 return sprintf(page, "max\n");
4258 else
4259 return sprintf(page, "%llu\n",
4260 (unsigned long long)mddev->resync_max);
4261}
4262static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004263max_sync_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrownc6207272008-02-06 01:39:52 -08004264{
4265 if (strncmp(buf, "max", 3) == 0)
4266 mddev->resync_max = MaxSector;
4267 else {
Neil Brown5e96ee62008-06-28 08:31:24 +10004268 unsigned long long max;
Jingoo Hanb29bebd2013-06-01 16:15:16 +09004269 if (kstrtoull(buf, 10, &max))
Neil Brown5e96ee62008-06-28 08:31:24 +10004270 return -EINVAL;
4271 if (max < mddev->resync_min)
NeilBrownc6207272008-02-06 01:39:52 -08004272 return -EINVAL;
4273 if (max < mddev->resync_max &&
NeilBrown4d484a42009-08-13 10:41:50 +10004274 mddev->ro == 0 &&
NeilBrownc6207272008-02-06 01:39:52 -08004275 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4276 return -EBUSY;
4277
4278 /* Must be a multiple of chunk_size */
Andre Noll9d8f0362009-06-18 08:45:01 +10004279 if (mddev->chunk_sectors) {
raz ben yehuda2ac06c32009-06-16 17:01:42 +10004280 sector_t temp = max;
Andre Noll9d8f0362009-06-18 08:45:01 +10004281 if (sector_div(temp, mddev->chunk_sectors))
NeilBrownc6207272008-02-06 01:39:52 -08004282 return -EINVAL;
4283 }
4284 mddev->resync_max = max;
4285 }
4286 wake_up(&mddev->recovery_wait);
4287 return len;
4288}
4289
4290static struct md_sysfs_entry md_max_sync =
4291__ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
4292
4293static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004294suspend_lo_show(struct mddev *mddev, char *page)
NeilBrowne464eaf2006-03-27 01:18:14 -08004295{
4296 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
4297}
4298
4299static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004300suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowne464eaf2006-03-27 01:18:14 -08004301{
4302 char *e;
4303 unsigned long long new = simple_strtoull(buf, &e, 10);
NeilBrown23ddff32011-01-14 09:14:34 +11004304 unsigned long long old = mddev->suspend_lo;
NeilBrowne464eaf2006-03-27 01:18:14 -08004305
NeilBrownf72ffdd2014-09-30 14:23:59 +10004306 if (mddev->pers == NULL ||
NeilBrownb8d966e2009-07-01 11:14:04 +10004307 mddev->pers->quiesce == NULL)
NeilBrowne464eaf2006-03-27 01:18:14 -08004308 return -EINVAL;
4309 if (buf == e || (*e && *e != '\n'))
4310 return -EINVAL;
NeilBrown23ddff32011-01-14 09:14:34 +11004311
4312 mddev->suspend_lo = new;
4313 if (new >= old)
4314 /* Shrinking suspended region */
NeilBrowne464eaf2006-03-27 01:18:14 -08004315 mddev->pers->quiesce(mddev, 2);
NeilBrown23ddff32011-01-14 09:14:34 +11004316 else {
4317 /* Expanding suspended region - need to wait */
4318 mddev->pers->quiesce(mddev, 1);
4319 mddev->pers->quiesce(mddev, 0);
4320 }
4321 return len;
NeilBrowne464eaf2006-03-27 01:18:14 -08004322}
4323static struct md_sysfs_entry md_suspend_lo =
4324__ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
4325
NeilBrowne464eaf2006-03-27 01:18:14 -08004326static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004327suspend_hi_show(struct mddev *mddev, char *page)
NeilBrowne464eaf2006-03-27 01:18:14 -08004328{
4329 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
4330}
4331
4332static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004333suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrowne464eaf2006-03-27 01:18:14 -08004334{
4335 char *e;
4336 unsigned long long new = simple_strtoull(buf, &e, 10);
NeilBrown23ddff32011-01-14 09:14:34 +11004337 unsigned long long old = mddev->suspend_hi;
NeilBrowne464eaf2006-03-27 01:18:14 -08004338
NeilBrownb8d966e2009-07-01 11:14:04 +10004339 if (mddev->pers == NULL ||
4340 mddev->pers->quiesce == NULL)
NeilBrowne464eaf2006-03-27 01:18:14 -08004341 return -EINVAL;
4342 if (buf == e || (*e && *e != '\n'))
4343 return -EINVAL;
NeilBrown23ddff32011-01-14 09:14:34 +11004344
4345 mddev->suspend_hi = new;
4346 if (new <= old)
4347 /* Shrinking suspended region */
4348 mddev->pers->quiesce(mddev, 2);
4349 else {
4350 /* Expanding suspended region - need to wait */
NeilBrowne464eaf2006-03-27 01:18:14 -08004351 mddev->pers->quiesce(mddev, 1);
4352 mddev->pers->quiesce(mddev, 0);
NeilBrown23ddff32011-01-14 09:14:34 +11004353 }
4354 return len;
NeilBrowne464eaf2006-03-27 01:18:14 -08004355}
4356static struct md_sysfs_entry md_suspend_hi =
4357__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
4358
NeilBrown08a02ec2007-05-09 02:35:38 -07004359static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004360reshape_position_show(struct mddev *mddev, char *page)
NeilBrown08a02ec2007-05-09 02:35:38 -07004361{
4362 if (mddev->reshape_position != MaxSector)
4363 return sprintf(page, "%llu\n",
4364 (unsigned long long)mddev->reshape_position);
4365 strcpy(page, "none\n");
4366 return 5;
4367}
4368
4369static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004370reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
NeilBrown08a02ec2007-05-09 02:35:38 -07004371{
NeilBrownc6563a82012-05-21 09:27:00 +10004372 struct md_rdev *rdev;
NeilBrown08a02ec2007-05-09 02:35:38 -07004373 char *e;
4374 unsigned long long new = simple_strtoull(buf, &e, 10);
4375 if (mddev->pers)
4376 return -EBUSY;
4377 if (buf == e || (*e && *e != '\n'))
4378 return -EINVAL;
4379 mddev->reshape_position = new;
4380 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10004381 mddev->reshape_backwards = 0;
NeilBrown08a02ec2007-05-09 02:35:38 -07004382 mddev->new_level = mddev->level;
4383 mddev->new_layout = mddev->layout;
Andre Noll664e7c42009-06-18 08:45:27 +10004384 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownc6563a82012-05-21 09:27:00 +10004385 rdev_for_each(rdev, mddev)
4386 rdev->new_data_offset = rdev->data_offset;
NeilBrown08a02ec2007-05-09 02:35:38 -07004387 return len;
4388}
4389
4390static struct md_sysfs_entry md_reshape_position =
4391__ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
4392 reshape_position_store);
4393
Dan Williamsb522adc2009-03-31 15:00:31 +11004394static ssize_t
NeilBrown2c810cd2012-05-21 09:27:00 +10004395reshape_direction_show(struct mddev *mddev, char *page)
4396{
4397 return sprintf(page, "%s\n",
4398 mddev->reshape_backwards ? "backwards" : "forwards");
4399}
4400
4401static ssize_t
4402reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
4403{
4404 int backwards = 0;
4405 if (cmd_match(buf, "forwards"))
4406 backwards = 0;
4407 else if (cmd_match(buf, "backwards"))
4408 backwards = 1;
4409 else
4410 return -EINVAL;
4411 if (mddev->reshape_backwards == backwards)
4412 return len;
4413
4414 /* check if we are allowed to change */
4415 if (mddev->delta_disks)
4416 return -EBUSY;
4417
4418 if (mddev->persistent &&
4419 mddev->major_version == 0)
4420 return -EINVAL;
4421
4422 mddev->reshape_backwards = backwards;
4423 return len;
4424}
4425
4426static struct md_sysfs_entry md_reshape_direction =
4427__ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
4428 reshape_direction_store);
4429
4430static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004431array_size_show(struct mddev *mddev, char *page)
Dan Williamsb522adc2009-03-31 15:00:31 +11004432{
4433 if (mddev->external_size)
4434 return sprintf(page, "%llu\n",
4435 (unsigned long long)mddev->array_sectors/2);
4436 else
4437 return sprintf(page, "default\n");
4438}
4439
4440static ssize_t
NeilBrownfd01b882011-10-11 16:47:53 +11004441array_size_store(struct mddev *mddev, const char *buf, size_t len)
Dan Williamsb522adc2009-03-31 15:00:31 +11004442{
4443 sector_t sectors;
4444
4445 if (strncmp(buf, "default", 7) == 0) {
4446 if (mddev->pers)
4447 sectors = mddev->pers->size(mddev, 0, 0);
4448 else
4449 sectors = mddev->array_sectors;
4450
4451 mddev->external_size = 0;
4452 } else {
4453 if (strict_blocks_to_sectors(buf, &sectors) < 0)
4454 return -EINVAL;
4455 if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
NeilBrown2b69c832009-05-26 09:41:17 +10004456 return -E2BIG;
Dan Williamsb522adc2009-03-31 15:00:31 +11004457
4458 mddev->external_size = 1;
4459 }
4460
4461 mddev->array_sectors = sectors;
NeilBrowncbe6ef12011-02-16 13:58:38 +11004462 if (mddev->pers) {
4463 set_capacity(mddev->gendisk, mddev->array_sectors);
NeilBrown449aad32009-08-03 10:59:58 +10004464 revalidate_disk(mddev->gendisk);
NeilBrowncbe6ef12011-02-16 13:58:38 +11004465 }
Dan Williamsb522adc2009-03-31 15:00:31 +11004466 return len;
4467}
4468
4469static struct md_sysfs_entry md_array_size =
4470__ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
4471 array_size_store);
NeilBrowne464eaf2006-03-27 01:18:14 -08004472
NeilBrowneae17012005-11-08 21:39:23 -08004473static struct attribute *md_default_attrs[] = {
4474 &md_level.attr,
NeilBrownd4dbd022006-06-26 00:27:59 -07004475 &md_layout.attr,
NeilBrowneae17012005-11-08 21:39:23 -08004476 &md_raid_disks.attr,
NeilBrown3b343802006-01-06 00:20:47 -08004477 &md_chunk_size.attr,
NeilBrowna35b0d692006-01-06 00:20:49 -08004478 &md_size.attr,
NeilBrowna94213b2006-06-26 00:28:00 -07004479 &md_resync_start.attr,
NeilBrown8bb93aa2006-01-06 00:20:50 -08004480 &md_metadata.attr,
NeilBrown6d7ff732006-01-06 00:21:16 -08004481 &md_new_device.attr,
NeilBrown16f17b32006-06-26 00:27:37 -07004482 &md_safe_delay.attr,
NeilBrown9e653b62006-06-26 00:27:58 -07004483 &md_array_state.attr,
NeilBrown08a02ec2007-05-09 02:35:38 -07004484 &md_reshape_position.attr,
NeilBrown2c810cd2012-05-21 09:27:00 +10004485 &md_reshape_direction.attr,
Dan Williamsb522adc2009-03-31 15:00:31 +11004486 &md_array_size.attr,
Robert Becker1e509152009-12-14 12:49:58 +11004487 &max_corr_read_errors.attr,
NeilBrown411036f2005-11-08 21:39:40 -08004488 NULL,
4489};
4490
4491static struct attribute *md_redundancy_attrs[] = {
NeilBrown24dd4692005-11-08 21:39:26 -08004492 &md_scan_mode.attr,
Jonathan Brassowc4a39552013-06-25 01:23:59 -05004493 &md_last_scan_mode.attr,
NeilBrown9d888832005-11-08 21:39:26 -08004494 &md_mismatches.attr,
NeilBrown88202a02006-01-06 00:21:36 -08004495 &md_sync_min.attr,
4496 &md_sync_max.attr,
4497 &md_sync_speed.attr,
Bernd Schubert90b08712008-05-23 13:04:38 -07004498 &md_sync_force_parallel.attr,
NeilBrown88202a02006-01-06 00:21:36 -08004499 &md_sync_completed.attr,
Neil Brown5e96ee62008-06-28 08:31:24 +10004500 &md_min_sync.attr,
NeilBrownc6207272008-02-06 01:39:52 -08004501 &md_max_sync.attr,
NeilBrowne464eaf2006-03-27 01:18:14 -08004502 &md_suspend_lo.attr,
4503 &md_suspend_hi.attr,
Paul Clements9b1d1da2006-10-03 01:15:49 -07004504 &md_bitmap.attr,
Iustin Popd7f3d292007-10-16 23:30:54 -07004505 &md_degraded.attr,
NeilBrowneae17012005-11-08 21:39:23 -08004506 NULL,
4507};
NeilBrown411036f2005-11-08 21:39:40 -08004508static struct attribute_group md_redundancy_group = {
4509 .name = NULL,
4510 .attrs = md_redundancy_attrs,
4511};
4512
NeilBrowneae17012005-11-08 21:39:23 -08004513static ssize_t
4514md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
4515{
4516 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
NeilBrownfd01b882011-10-11 16:47:53 +11004517 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
NeilBrown96de1e62005-11-08 21:39:39 -08004518 ssize_t rv;
NeilBrowneae17012005-11-08 21:39:23 -08004519
4520 if (!entry->show)
4521 return -EIO;
NeilBrownaf8a2432011-12-08 15:49:46 +11004522 spin_lock(&all_mddevs_lock);
4523 if (list_empty(&mddev->all_mddevs)) {
4524 spin_unlock(&all_mddevs_lock);
4525 return -EBUSY;
4526 }
4527 mddev_get(mddev);
4528 spin_unlock(&all_mddevs_lock);
4529
Ingo Molnar5dc5cf72006-04-20 02:43:23 -07004530 rv = mddev_lock(mddev);
4531 if (!rv) {
4532 rv = entry->show(mddev, page);
4533 mddev_unlock(mddev);
4534 }
NeilBrownaf8a2432011-12-08 15:49:46 +11004535 mddev_put(mddev);
NeilBrown96de1e62005-11-08 21:39:39 -08004536 return rv;
NeilBrowneae17012005-11-08 21:39:23 -08004537}
4538
4539static ssize_t
4540md_attr_store(struct kobject *kobj, struct attribute *attr,
4541 const char *page, size_t length)
4542{
4543 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
NeilBrownfd01b882011-10-11 16:47:53 +11004544 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
NeilBrown96de1e62005-11-08 21:39:39 -08004545 ssize_t rv;
NeilBrowneae17012005-11-08 21:39:23 -08004546
4547 if (!entry->store)
4548 return -EIO;
NeilBrown67463ac2006-07-10 04:44:19 -07004549 if (!capable(CAP_SYS_ADMIN))
4550 return -EACCES;
NeilBrownaf8a2432011-12-08 15:49:46 +11004551 spin_lock(&all_mddevs_lock);
4552 if (list_empty(&mddev->all_mddevs)) {
4553 spin_unlock(&all_mddevs_lock);
4554 return -EBUSY;
4555 }
4556 mddev_get(mddev);
4557 spin_unlock(&all_mddevs_lock);
NeilBrowna7a3f082012-12-11 13:35:54 +11004558 if (entry->store == new_dev_store)
4559 flush_workqueue(md_misc_wq);
Ingo Molnar5dc5cf72006-04-20 02:43:23 -07004560 rv = mddev_lock(mddev);
4561 if (!rv) {
4562 rv = entry->store(mddev, page, length);
4563 mddev_unlock(mddev);
4564 }
NeilBrownaf8a2432011-12-08 15:49:46 +11004565 mddev_put(mddev);
NeilBrown96de1e62005-11-08 21:39:39 -08004566 return rv;
NeilBrowneae17012005-11-08 21:39:23 -08004567}
4568
4569static void md_free(struct kobject *ko)
4570{
NeilBrownfd01b882011-10-11 16:47:53 +11004571 struct mddev *mddev = container_of(ko, struct mddev, kobj);
NeilBrowna21d1502009-01-09 08:31:09 +11004572
4573 if (mddev->sysfs_state)
4574 sysfs_put(mddev->sysfs_state);
4575
4576 if (mddev->gendisk) {
4577 del_gendisk(mddev->gendisk);
4578 put_disk(mddev->gendisk);
4579 }
4580 if (mddev->queue)
4581 blk_cleanup_queue(mddev->queue);
4582
NeilBrowneae17012005-11-08 21:39:23 -08004583 kfree(mddev);
4584}
4585
Emese Revfy52cf25d2010-01-19 02:58:23 +01004586static const struct sysfs_ops md_sysfs_ops = {
NeilBrowneae17012005-11-08 21:39:23 -08004587 .show = md_attr_show,
4588 .store = md_attr_store,
4589};
4590static struct kobj_type md_ktype = {
4591 .release = md_free,
4592 .sysfs_ops = &md_sysfs_ops,
4593 .default_attrs = md_default_attrs,
4594};
4595
Linus Torvalds1da177e2005-04-16 15:20:36 -07004596int mdp_major = 0;
4597
Dan Williams5fd3a172009-03-04 00:57:25 -07004598static void mddev_delayed_delete(struct work_struct *ws)
4599{
NeilBrownfd01b882011-10-11 16:47:53 +11004600 struct mddev *mddev = container_of(ws, struct mddev, del_work);
Dan Williams5fd3a172009-03-04 00:57:25 -07004601
NeilBrown43a70502009-12-14 12:49:55 +11004602 sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
Dan Williams5fd3a172009-03-04 00:57:25 -07004603 kobject_del(&mddev->kobj);
4604 kobject_put(&mddev->kobj);
4605}
4606
NeilBrownefeb53c2009-01-09 08:31:10 +11004607static int md_alloc(dev_t dev, char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004608{
Arjan van de Ven48c9c272006-03-27 01:18:20 -08004609 static DEFINE_MUTEX(disks_mutex);
NeilBrownfd01b882011-10-11 16:47:53 +11004610 struct mddev *mddev = mddev_find(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004611 struct gendisk *disk;
NeilBrownefeb53c2009-01-09 08:31:10 +11004612 int partitioned;
4613 int shift;
4614 int unit;
Greg Kroah-Hartman3830c622007-12-17 15:54:39 -04004615 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004616
4617 if (!mddev)
NeilBrownefeb53c2009-01-09 08:31:10 +11004618 return -ENODEV;
4619
4620 partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
4621 shift = partitioned ? MdpMinorShift : 0;
4622 unit = MINOR(mddev->unit) >> shift;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004623
Tejun Heoe804ac72010-10-15 15:36:08 +02004624 /* wait for any previous instance of this device to be
4625 * completely removed (mddev_delayed_delete).
NeilBrownd3374822009-01-09 08:31:10 +11004626 */
Tejun Heoe804ac72010-10-15 15:36:08 +02004627 flush_workqueue(md_misc_wq);
NeilBrownd3374822009-01-09 08:31:10 +11004628
Arjan van de Ven48c9c272006-03-27 01:18:20 -08004629 mutex_lock(&disks_mutex);
NeilBrown0909dc42009-07-01 12:27:21 +10004630 error = -EEXIST;
4631 if (mddev->gendisk)
4632 goto abort;
NeilBrownefeb53c2009-01-09 08:31:10 +11004633
4634 if (name) {
4635 /* Need to ensure that 'name' is not a duplicate.
4636 */
NeilBrownfd01b882011-10-11 16:47:53 +11004637 struct mddev *mddev2;
NeilBrownefeb53c2009-01-09 08:31:10 +11004638 spin_lock(&all_mddevs_lock);
4639
4640 list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
4641 if (mddev2->gendisk &&
4642 strcmp(mddev2->gendisk->disk_name, name) == 0) {
4643 spin_unlock(&all_mddevs_lock);
NeilBrown0909dc42009-07-01 12:27:21 +10004644 goto abort;
NeilBrownefeb53c2009-01-09 08:31:10 +11004645 }
4646 spin_unlock(&all_mddevs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004647 }
NeilBrown8b765392009-01-09 08:31:08 +11004648
NeilBrown0909dc42009-07-01 12:27:21 +10004649 error = -ENOMEM;
NeilBrown8b765392009-01-09 08:31:08 +11004650 mddev->queue = blk_alloc_queue(GFP_KERNEL);
NeilBrown0909dc42009-07-01 12:27:21 +10004651 if (!mddev->queue)
4652 goto abort;
NeilBrown409c57f2009-03-31 14:39:39 +11004653 mddev->queue->queuedata = mddev;
4654
NeilBrown409c57f2009-03-31 14:39:39 +11004655 blk_queue_make_request(mddev->queue, md_make_request);
Martin K. Petersenb1bd0552012-01-11 16:27:11 +01004656 blk_set_stacking_limits(&mddev->queue->limits);
NeilBrown8b765392009-01-09 08:31:08 +11004657
Linus Torvalds1da177e2005-04-16 15:20:36 -07004658 disk = alloc_disk(1 << shift);
4659 if (!disk) {
NeilBrown8b765392009-01-09 08:31:08 +11004660 blk_cleanup_queue(mddev->queue);
4661 mddev->queue = NULL;
NeilBrown0909dc42009-07-01 12:27:21 +10004662 goto abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004663 }
NeilBrownefeb53c2009-01-09 08:31:10 +11004664 disk->major = MAJOR(mddev->unit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004665 disk->first_minor = unit << shift;
NeilBrownefeb53c2009-01-09 08:31:10 +11004666 if (name)
4667 strcpy(disk->disk_name, name);
4668 else if (partitioned)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004669 sprintf(disk->disk_name, "md_d%d", unit);
Greg Kroah-Hartmance7b0f42005-06-20 21:15:16 -07004670 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07004671 sprintf(disk->disk_name, "md%d", unit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004672 disk->fops = &md_fops;
4673 disk->private_data = mddev;
4674 disk->queue = mddev->queue;
NeilBrownb0140892011-05-10 17:49:01 +10004675 blk_queue_flush(mddev->queue, REQ_FLUSH | REQ_FUA);
NeilBrown92850bb2008-10-21 13:25:32 +11004676 /* Allow extended partitions. This makes the
NeilBrownd3374822009-01-09 08:31:10 +11004677 * 'mdp' device redundant, but we can't really
NeilBrown92850bb2008-10-21 13:25:32 +11004678 * remove it now.
4679 */
4680 disk->flags |= GENHD_FL_EXT_DEVT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004681 mddev->gendisk = disk;
NeilBrownb0140892011-05-10 17:49:01 +10004682 /* As soon as we call add_disk(), another thread could get
4683 * through to md_open, so make sure it doesn't get too far
4684 */
4685 mutex_lock(&mddev->open_mutex);
4686 add_disk(disk);
4687
Tejun Heoed9e1982008-08-25 19:56:05 +09004688 error = kobject_init_and_add(&mddev->kobj, &md_ktype,
4689 &disk_to_dev(disk)->kobj, "%s", "md");
NeilBrown0909dc42009-07-01 12:27:21 +10004690 if (error) {
4691 /* This isn't possible, but as kobject_init_and_add is marked
4692 * __must_check, we must do something with the result
4693 */
NeilBrown5e55e2f2007-03-26 21:32:14 -08004694 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
4695 disk->disk_name);
NeilBrown0909dc42009-07-01 12:27:21 +10004696 error = 0;
4697 }
NeilBrown00bcb4a2010-06-01 19:37:23 +10004698 if (mddev->kobj.sd &&
4699 sysfs_create_group(&mddev->kobj, &md_bitmap_group))
NeilBrown43a70502009-12-14 12:49:55 +11004700 printk(KERN_DEBUG "pointless warning\n");
NeilBrownb0140892011-05-10 17:49:01 +10004701 mutex_unlock(&mddev->open_mutex);
NeilBrown0909dc42009-07-01 12:27:21 +10004702 abort:
4703 mutex_unlock(&disks_mutex);
NeilBrown00bcb4a2010-06-01 19:37:23 +10004704 if (!error && mddev->kobj.sd) {
Greg Kroah-Hartman3830c622007-12-17 15:54:39 -04004705 kobject_uevent(&mddev->kobj, KOBJ_ADD);
NeilBrown00bcb4a2010-06-01 19:37:23 +10004706 mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
NeilBrownb62b7592008-10-21 13:25:21 +11004707 }
NeilBrownd3374822009-01-09 08:31:10 +11004708 mddev_put(mddev);
NeilBrown0909dc42009-07-01 12:27:21 +10004709 return error;
NeilBrownefeb53c2009-01-09 08:31:10 +11004710}
4711
4712static struct kobject *md_probe(dev_t dev, int *part, void *data)
4713{
4714 md_alloc(dev, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004715 return NULL;
4716}
4717
NeilBrownefeb53c2009-01-09 08:31:10 +11004718static int add_named_array(const char *val, struct kernel_param *kp)
4719{
4720 /* val must be "md_*" where * is not all digits.
4721 * We allocate an array with a large free minor number, and
4722 * set the name to val. val must not already be an active name.
4723 */
4724 int len = strlen(val);
4725 char buf[DISK_NAME_LEN];
4726
4727 while (len && val[len-1] == '\n')
4728 len--;
4729 if (len >= DISK_NAME_LEN)
4730 return -E2BIG;
4731 strlcpy(buf, val, len+1);
4732 if (strncmp(buf, "md_", 3) != 0)
4733 return -EINVAL;
4734 return md_alloc(0, buf);
4735}
4736
Linus Torvalds1da177e2005-04-16 15:20:36 -07004737static void md_safemode_timeout(unsigned long data)
4738{
NeilBrownfd01b882011-10-11 16:47:53 +11004739 struct mddev *mddev = (struct mddev *) data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004740
Neil Brown0fd62b82008-06-28 08:31:36 +10004741 if (!atomic_read(&mddev->writes_pending)) {
4742 mddev->safemode = 1;
4743 if (mddev->external)
NeilBrown00bcb4a2010-06-01 19:37:23 +10004744 sysfs_notify_dirent_safe(mddev->sysfs_state);
Neil Brown0fd62b82008-06-28 08:31:36 +10004745 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004746 md_wakeup_thread(mddev->thread);
4747}
4748
NeilBrown6ff8d8ec2006-01-06 00:20:15 -08004749static int start_dirty_degraded;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004750
NeilBrownfd01b882011-10-11 16:47:53 +11004751int md_run(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004752{
NeilBrown2604b702006-01-06 00:20:36 -08004753 int err;
NeilBrown3cb03002011-10-11 16:45:26 +11004754 struct md_rdev *rdev;
NeilBrown84fc4b52011-10-11 16:49:58 +11004755 struct md_personality *pers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004756
NeilBrowna757e642005-04-16 15:26:42 -07004757 if (list_empty(&mddev->disks))
4758 /* cannot run an array with no devices.. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004759 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004760
4761 if (mddev->pers)
4762 return -EBUSY;
NeilBrownbb4f1e92010-08-08 21:18:03 +10004763 /* Cannot run until previous stop completes properly */
4764 if (mddev->sysfs_active)
4765 return -EBUSY;
NeilBrownb6eb1272010-04-15 10:13:47 +10004766
Linus Torvalds1da177e2005-04-16 15:20:36 -07004767 /*
4768 * Analyze all RAID superblock(s)
4769 */
NeilBrown1ec4a932008-02-06 01:39:53 -08004770 if (!mddev->raid_disks) {
4771 if (!mddev->persistent)
4772 return -EINVAL;
NeilBrowna757e642005-04-16 15:26:42 -07004773 analyze_sbs(mddev);
NeilBrown1ec4a932008-02-06 01:39:53 -08004774 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004775
NeilBrownd9d166c2006-01-06 00:20:51 -08004776 if (mddev->level != LEVEL_NONE)
4777 request_module("md-level-%d", mddev->level);
4778 else if (mddev->clevel[0])
4779 request_module("md-%s", mddev->clevel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004780
4781 /*
4782 * Drop all container device buffers, from now on
4783 * the only valid external interface is through the md
4784 * device.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004785 */
NeilBrowndafb20f2012-03-19 12:46:39 +11004786 rdev_for_each(rdev, mddev) {
NeilBrownb2d444d2005-11-08 21:39:31 -08004787 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004788 continue;
4789 sync_blockdev(rdev->bdev);
Peter Zijlstraf98393a2007-05-06 14:49:54 -07004790 invalidate_bdev(rdev->bdev);
NeilBrownf0d76d72007-07-17 04:06:12 -07004791
4792 /* perform some consistency tests on the device.
4793 * We don't want the data to overlap the metadata,
Andre Noll58c0fed2009-03-31 14:33:13 +11004794 * Internal Bitmap issues have been handled elsewhere.
NeilBrownf0d76d72007-07-17 04:06:12 -07004795 */
Jonathan Brassowa6ff7e02011-01-14 09:14:34 +11004796 if (rdev->meta_bdev) {
4797 /* Nothing to check */;
4798 } else if (rdev->data_offset < rdev->sb_start) {
Andre Noll58c0fed2009-03-31 14:33:13 +11004799 if (mddev->dev_sectors &&
4800 rdev->data_offset + mddev->dev_sectors
Andre Noll0f420352008-07-11 22:02:23 +10004801 > rdev->sb_start) {
NeilBrownf0d76d72007-07-17 04:06:12 -07004802 printk("md: %s: data overlaps metadata\n",
4803 mdname(mddev));
4804 return -EINVAL;
4805 }
4806 } else {
Andre Noll0f420352008-07-11 22:02:23 +10004807 if (rdev->sb_start + rdev->sb_size/512
NeilBrownf0d76d72007-07-17 04:06:12 -07004808 > rdev->data_offset) {
4809 printk("md: %s: metadata overlaps data\n",
4810 mdname(mddev));
4811 return -EINVAL;
4812 }
4813 }
NeilBrown00bcb4a2010-06-01 19:37:23 +10004814 sysfs_notify_dirent_safe(rdev->sysfs_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004815 }
4816
NeilBrowna167f662010-10-26 18:31:13 +11004817 if (mddev->bio_set == NULL)
Kent Overstreet395c72a2012-09-06 15:34:55 -07004818 mddev->bio_set = bioset_create(BIO_POOL_SIZE, 0);
NeilBrowna167f662010-10-26 18:31:13 +11004819
Linus Torvalds1da177e2005-04-16 15:20:36 -07004820 spin_lock(&pers_lock);
NeilBrownd9d166c2006-01-06 00:20:51 -08004821 pers = find_pers(mddev->level, mddev->clevel);
NeilBrown2604b702006-01-06 00:20:36 -08004822 if (!pers || !try_module_get(pers->owner)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004823 spin_unlock(&pers_lock);
NeilBrownd9d166c2006-01-06 00:20:51 -08004824 if (mddev->level != LEVEL_NONE)
4825 printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
4826 mddev->level);
4827 else
4828 printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
4829 mddev->clevel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004830 return -EINVAL;
4831 }
NeilBrown2604b702006-01-06 00:20:36 -08004832 mddev->pers = pers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004833 spin_unlock(&pers_lock);
NeilBrown34817e82009-03-31 14:39:38 +11004834 if (mddev->level != pers->level) {
4835 mddev->level = pers->level;
4836 mddev->new_level = pers->level;
4837 }
NeilBrownd9d166c2006-01-06 00:20:51 -08004838 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004839
NeilBrownf6705572006-03-27 01:18:11 -08004840 if (mddev->reshape_position != MaxSector &&
NeilBrown63c70c42006-03-27 01:18:13 -08004841 pers->start_reshape == NULL) {
NeilBrownf6705572006-03-27 01:18:11 -08004842 /* This personality cannot handle reshaping... */
4843 mddev->pers = NULL;
4844 module_put(pers->owner);
4845 return -EINVAL;
4846 }
4847
NeilBrown7dd5e7c32007-02-28 20:11:35 -08004848 if (pers->sync_request) {
4849 /* Warn if this is a potentially silly
4850 * configuration.
4851 */
4852 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
NeilBrown3cb03002011-10-11 16:45:26 +11004853 struct md_rdev *rdev2;
NeilBrown7dd5e7c32007-02-28 20:11:35 -08004854 int warned = 0;
Cheng Renquan159ec1f2009-01-09 08:31:08 +11004855
NeilBrowndafb20f2012-03-19 12:46:39 +11004856 rdev_for_each(rdev, mddev)
4857 rdev_for_each(rdev2, mddev) {
NeilBrown7dd5e7c32007-02-28 20:11:35 -08004858 if (rdev < rdev2 &&
4859 rdev->bdev->bd_contains ==
4860 rdev2->bdev->bd_contains) {
4861 printk(KERN_WARNING
4862 "%s: WARNING: %s appears to be"
4863 " on the same physical disk as"
4864 " %s.\n",
4865 mdname(mddev),
4866 bdevname(rdev->bdev,b),
4867 bdevname(rdev2->bdev,b2));
4868 warned = 1;
4869 }
4870 }
Cheng Renquan159ec1f2009-01-09 08:31:08 +11004871
NeilBrown7dd5e7c32007-02-28 20:11:35 -08004872 if (warned)
4873 printk(KERN_WARNING
4874 "True protection against single-disk"
4875 " failure might be compromised.\n");
4876 }
4877
NeilBrown657390d2005-08-26 18:34:16 -07004878 mddev->recovery = 0;
Andre Noll58c0fed2009-03-31 14:33:13 +11004879 /* may be over-ridden by personality */
4880 mddev->resync_max_sectors = mddev->dev_sectors;
4881
NeilBrown6ff8d8ec2006-01-06 00:20:15 -08004882 mddev->ok_start_degraded = start_dirty_degraded;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004883
NeilBrown0f9552b2009-12-30 12:08:50 +11004884 if (start_readonly && mddev->ro == 0)
NeilBrownf91de922005-11-08 21:39:36 -08004885 mddev->ro = 2; /* read-only, but switch on first write */
4886
NeilBrownb15c2e52006-01-06 00:20:16 -08004887 err = mddev->pers->run(mddev);
Andre Noll13e53df2008-03-26 00:07:03 +01004888 if (err)
4889 printk(KERN_ERR "md: pers->run() failed ...\n");
Dan Williamsb522adc2009-03-31 15:00:31 +11004890 else if (mddev->pers->size(mddev, 0, 0) < mddev->array_sectors) {
4891 WARN_ONCE(!mddev->external_size, "%s: default size too small,"
4892 " but 'external_size' not in effect?\n", __func__);
4893 printk(KERN_ERR
4894 "md: invalid array_size %llu > default size %llu\n",
4895 (unsigned long long)mddev->array_sectors / 2,
4896 (unsigned long long)mddev->pers->size(mddev, 0, 0) / 2);
4897 err = -EINVAL;
4898 mddev->pers->stop(mddev);
4899 }
NeilBrownef99bf42012-05-22 13:55:08 +10004900 if (err == 0 && mddev->pers->sync_request &&
4901 (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
NeilBrownb15c2e52006-01-06 00:20:16 -08004902 err = bitmap_create(mddev);
4903 if (err) {
4904 printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
4905 mdname(mddev), err);
4906 mddev->pers->stop(mddev);
4907 }
4908 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004909 if (err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004910 module_put(mddev->pers->owner);
4911 mddev->pers = NULL;
NeilBrown32a76272005-06-21 17:17:14 -07004912 bitmap_destroy(mddev);
4913 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004914 }
NeilBrown5e55e2f2007-03-26 21:32:14 -08004915 if (mddev->pers->sync_request) {
NeilBrown00bcb4a2010-06-01 19:37:23 +10004916 if (mddev->kobj.sd &&
4917 sysfs_create_group(&mddev->kobj, &md_redundancy_group))
NeilBrown5e55e2f2007-03-26 21:32:14 -08004918 printk(KERN_WARNING
4919 "md: cannot register extra attributes for %s\n",
4920 mdname(mddev));
NeilBrown00bcb4a2010-06-01 19:37:23 +10004921 mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
NeilBrown5e55e2f2007-03-26 21:32:14 -08004922 } else if (mddev->ro == 2) /* auto-readonly not meaningful */
NeilBrownfd9d49c2005-11-08 21:39:42 -08004923 mddev->ro = 0;
4924
NeilBrownf72ffdd2014-09-30 14:23:59 +10004925 atomic_set(&mddev->writes_pending,0);
Robert Becker1e509152009-12-14 12:49:58 +11004926 atomic_set(&mddev->max_corr_read_errors,
4927 MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004928 mddev->safemode = 0;
4929 mddev->safemode_timer.function = md_safemode_timeout;
4930 mddev->safemode_timer.data = (unsigned long) mddev;
NeilBrown16f17b32006-06-26 00:27:37 -07004931 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004932 mddev->in_sync = 1;
NeilBrown0ca698862011-01-14 09:14:33 +11004933 smp_wmb();
4934 mddev->ready = 1;
NeilBrowndafb20f2012-03-19 12:46:39 +11004935 rdev_for_each(rdev, mddev)
Namhyung Kim36fad852011-07-27 11:00:36 +10004936 if (rdev->raid_disk >= 0)
4937 if (sysfs_link_rdev(mddev, rdev))
NeilBrown00bcb4a2010-06-01 19:37:23 +10004938 /* failure here is OK */;
NeilBrownf72ffdd2014-09-30 14:23:59 +10004939
Linus Torvalds1da177e2005-04-16 15:20:36 -07004940 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrownf72ffdd2014-09-30 14:23:59 +10004941
NeilBrown7a0a5352013-08-27 16:28:23 +10004942 if (mddev->flags & MD_UPDATE_SB_FLAGS)
NeilBrown850b2b42006-10-03 01:15:46 -07004943 md_update_sb(mddev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004944
NeilBrownd7603b72006-01-06 00:20:30 -08004945 md_new_event(mddev);
NeilBrown00bcb4a2010-06-01 19:37:23 +10004946 sysfs_notify_dirent_safe(mddev->sysfs_state);
4947 sysfs_notify_dirent_safe(mddev->sysfs_action);
Neil Browna99ac972008-06-28 08:31:43 +10004948 sysfs_notify(&mddev->kobj, NULL, "degraded");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004949 return 0;
4950}
NeilBrown390ee602010-06-01 19:37:27 +10004951EXPORT_SYMBOL_GPL(md_run);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004952
NeilBrownfd01b882011-10-11 16:47:53 +11004953static int do_md_run(struct mddev *mddev)
NeilBrownfe60b012010-03-29 11:10:42 +11004954{
4955 int err;
4956
4957 err = md_run(mddev);
4958 if (err)
4959 goto out;
NeilBrown69e51b42010-06-01 19:37:35 +10004960 err = bitmap_load(mddev);
4961 if (err) {
4962 bitmap_destroy(mddev);
4963 goto out;
4964 }
Jonathan Brassow0fd018a2011-06-07 17:49:36 -05004965
4966 md_wakeup_thread(mddev->thread);
4967 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
4968
NeilBrownfe60b012010-03-29 11:10:42 +11004969 set_capacity(mddev->gendisk, mddev->array_sectors);
4970 revalidate_disk(mddev->gendisk);
NeilBrownf0b4f7e2011-02-24 17:26:41 +11004971 mddev->changed = 1;
NeilBrownfe60b012010-03-29 11:10:42 +11004972 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
4973out:
4974 return err;
4975}
4976
NeilBrownfd01b882011-10-11 16:47:53 +11004977static int restart_array(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004978{
4979 struct gendisk *disk = mddev->gendisk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004980
Andre Noll80fab1d2008-07-11 22:02:21 +10004981 /* Complain if it has no devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004982 if (list_empty(&mddev->disks))
Andre Noll80fab1d2008-07-11 22:02:21 +10004983 return -ENXIO;
4984 if (!mddev->pers)
4985 return -EINVAL;
4986 if (!mddev->ro)
4987 return -EBUSY;
4988 mddev->safemode = 0;
4989 mddev->ro = 0;
4990 set_disk_ro(disk, 0);
4991 printk(KERN_INFO "md: %s switched to read-write mode.\n",
4992 mdname(mddev));
4993 /* Kick recovery or resync if necessary */
4994 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4995 md_wakeup_thread(mddev->thread);
4996 md_wakeup_thread(mddev->sync_thread);
NeilBrown00bcb4a2010-06-01 19:37:23 +10004997 sysfs_notify_dirent_safe(mddev->sysfs_state);
Andre Noll80fab1d2008-07-11 22:02:21 +10004998 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004999}
5000
NeilBrownfd01b882011-10-11 16:47:53 +11005001static void md_clean(struct mddev *mddev)
NeilBrown6177b472010-03-29 11:37:13 +11005002{
5003 mddev->array_sectors = 0;
5004 mddev->external_size = 0;
5005 mddev->dev_sectors = 0;
5006 mddev->raid_disks = 0;
5007 mddev->recovery_cp = 0;
5008 mddev->resync_min = 0;
5009 mddev->resync_max = MaxSector;
5010 mddev->reshape_position = MaxSector;
5011 mddev->external = 0;
5012 mddev->persistent = 0;
5013 mddev->level = LEVEL_NONE;
5014 mddev->clevel[0] = 0;
5015 mddev->flags = 0;
5016 mddev->ro = 0;
5017 mddev->metadata_type[0] = 0;
5018 mddev->chunk_sectors = 0;
5019 mddev->ctime = mddev->utime = 0;
5020 mddev->layout = 0;
5021 mddev->max_disks = 0;
5022 mddev->events = 0;
NeilBrowna8707c02010-05-18 09:28:43 +10005023 mddev->can_decrease_events = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005024 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10005025 mddev->reshape_backwards = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005026 mddev->new_level = LEVEL_NONE;
5027 mddev->new_layout = 0;
5028 mddev->new_chunk_sectors = 0;
5029 mddev->curr_resync = 0;
Jianpeng Ma7f7583d2012-10-11 14:17:59 +11005030 atomic64_set(&mddev->resync_mismatches, 0);
NeilBrown6177b472010-03-29 11:37:13 +11005031 mddev->suspend_lo = mddev->suspend_hi = 0;
5032 mddev->sync_speed_min = mddev->sync_speed_max = 0;
5033 mddev->recovery = 0;
5034 mddev->in_sync = 0;
NeilBrownf0b4f7e2011-02-24 17:26:41 +11005035 mddev->changed = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005036 mddev->degraded = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005037 mddev->safemode = 0;
NeilBrown050b6612012-03-19 12:46:39 +11005038 mddev->merge_check_needed = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005039 mddev->bitmap_info.offset = 0;
5040 mddev->bitmap_info.default_offset = 0;
NeilBrown6409bb02012-05-22 13:55:07 +10005041 mddev->bitmap_info.default_space = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005042 mddev->bitmap_info.chunksize = 0;
5043 mddev->bitmap_info.daemon_sleep = 0;
5044 mddev->bitmap_info.max_write_behind = 0;
5045}
5046
NeilBrownfd01b882011-10-11 16:47:53 +11005047static void __md_stop_writes(struct mddev *mddev)
NeilBrowna047e122010-03-29 12:07:53 +11005048{
NeilBrown6b6204e2013-05-09 09:48:30 +10005049 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11005050 flush_workqueue(md_misc_wq);
NeilBrowna047e122010-03-29 12:07:53 +11005051 if (mddev->sync_thread) {
NeilBrowna047e122010-03-29 12:07:53 +11005052 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10005053 md_reap_sync_thread(mddev);
NeilBrowna047e122010-03-29 12:07:53 +11005054 }
5055
5056 del_timer_sync(&mddev->safemode_timer);
5057
5058 bitmap_flush(mddev);
5059 md_super_wait(mddev);
5060
NeilBrownb6d428c2013-04-24 11:42:42 +10005061 if (mddev->ro == 0 &&
NeilBrown7a0a5352013-08-27 16:28:23 +10005062 (!mddev->in_sync || (mddev->flags & MD_UPDATE_SB_FLAGS))) {
NeilBrowna047e122010-03-29 12:07:53 +11005063 /* mark array as shutdown cleanly */
5064 mddev->in_sync = 1;
5065 md_update_sb(mddev, 1);
5066 }
5067}
NeilBrowndefad612011-01-14 09:14:33 +11005068
NeilBrownfd01b882011-10-11 16:47:53 +11005069void md_stop_writes(struct mddev *mddev)
NeilBrowndefad612011-01-14 09:14:33 +11005070{
NeilBrown29f097c2013-11-14 17:54:51 +11005071 mddev_lock_nointr(mddev);
NeilBrowndefad612011-01-14 09:14:33 +11005072 __md_stop_writes(mddev);
5073 mddev_unlock(mddev);
5074}
NeilBrown390ee602010-06-01 19:37:27 +10005075EXPORT_SYMBOL_GPL(md_stop_writes);
NeilBrowna047e122010-03-29 12:07:53 +11005076
NeilBrown5eff3c42012-11-19 10:47:48 +11005077static void __md_stop(struct mddev *mddev)
NeilBrown6177b472010-03-29 11:37:13 +11005078{
NeilBrown0ca698862011-01-14 09:14:33 +11005079 mddev->ready = 0;
NeilBrown6177b472010-03-29 11:37:13 +11005080 mddev->pers->stop(mddev);
5081 if (mddev->pers->sync_request && mddev->to_remove == NULL)
5082 mddev->to_remove = &md_redundancy_group;
5083 module_put(mddev->pers->owner);
5084 mddev->pers = NULL;
NeilBrowncca9cf92010-04-01 12:08:16 +11005085 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown6177b472010-03-29 11:37:13 +11005086}
NeilBrown5eff3c42012-11-19 10:47:48 +11005087
5088void md_stop(struct mddev *mddev)
5089{
5090 /* stop the array and free an attached data structures.
5091 * This is called from dm-raid
5092 */
5093 __md_stop(mddev);
5094 bitmap_destroy(mddev);
5095 if (mddev->bio_set)
5096 bioset_free(mddev->bio_set);
5097}
5098
NeilBrown390ee602010-06-01 19:37:27 +10005099EXPORT_SYMBOL_GPL(md_stop);
NeilBrown6177b472010-03-29 11:37:13 +11005100
NeilBrowna05b7ea2012-07-19 15:59:18 +10005101static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
NeilBrowna4bd82d2010-03-29 13:23:10 +11005102{
5103 int err = 0;
NeilBrown30b8feb2013-11-14 15:16:17 +11005104 int did_freeze = 0;
5105
5106 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
5107 did_freeze = 1;
5108 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5109 md_wakeup_thread(mddev->thread);
5110 }
NeilBrownf851b602014-12-11 10:02:10 +11005111 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown30b8feb2013-11-14 15:16:17 +11005112 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11005113 if (mddev->sync_thread)
NeilBrown30b8feb2013-11-14 15:16:17 +11005114 /* Thread might be blocked waiting for metadata update
5115 * which will now never happen */
5116 wake_up_process(mddev->sync_thread->tsk);
NeilBrownf851b602014-12-11 10:02:10 +11005117
NeilBrown30b8feb2013-11-14 15:16:17 +11005118 mddev_unlock(mddev);
NeilBrownf851b602014-12-11 10:02:10 +11005119 wait_event(resync_wait, !test_bit(MD_RECOVERY_RUNNING,
5120 &mddev->recovery));
NeilBrown30b8feb2013-11-14 15:16:17 +11005121 mddev_lock_nointr(mddev);
5122
NeilBrowna4bd82d2010-03-29 13:23:10 +11005123 mutex_lock(&mddev->open_mutex);
NeilBrown9ba3b7f2014-09-09 14:00:15 +10005124 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
NeilBrown30b8feb2013-11-14 15:16:17 +11005125 mddev->sync_thread ||
NeilBrownf851b602014-12-11 10:02:10 +11005126 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
NeilBrown30b8feb2013-11-14 15:16:17 +11005127 (bdev && !test_bit(MD_STILL_CLOSED, &mddev->flags))) {
NeilBrowna4bd82d2010-03-29 13:23:10 +11005128 printk("md: %s still in use.\n",mdname(mddev));
NeilBrown30b8feb2013-11-14 15:16:17 +11005129 if (did_freeze) {
5130 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown45eaf452014-10-29 08:49:50 +11005131 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown30b8feb2013-11-14 15:16:17 +11005132 md_wakeup_thread(mddev->thread);
5133 }
NeilBrowna4bd82d2010-03-29 13:23:10 +11005134 err = -EBUSY;
5135 goto out;
5136 }
5137 if (mddev->pers) {
NeilBrowndefad612011-01-14 09:14:33 +11005138 __md_stop_writes(mddev);
NeilBrowna4bd82d2010-03-29 13:23:10 +11005139
5140 err = -ENXIO;
5141 if (mddev->ro==1)
5142 goto out;
5143 mddev->ro = 1;
5144 set_disk_ro(mddev->gendisk, 1);
5145 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown45eaf452014-10-29 08:49:50 +11005146 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5147 md_wakeup_thread(mddev->thread);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005148 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown30b8feb2013-11-14 15:16:17 +11005149 err = 0;
NeilBrowna4bd82d2010-03-29 13:23:10 +11005150 }
5151out:
5152 mutex_unlock(&mddev->open_mutex);
5153 return err;
5154}
5155
NeilBrown9e653b62006-06-26 00:27:58 -07005156/* mode:
5157 * 0 - completely stop and dis-assemble array
NeilBrown9e653b62006-06-26 00:27:58 -07005158 * 2 - stop but do not disassemble array
5159 */
NeilBrownf72ffdd2014-09-30 14:23:59 +10005160static int do_md_stop(struct mddev *mddev, int mode,
NeilBrowna05b7ea2012-07-19 15:59:18 +10005161 struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005162{
Linus Torvalds1da177e2005-04-16 15:20:36 -07005163 struct gendisk *disk = mddev->gendisk;
NeilBrown3cb03002011-10-11 16:45:26 +11005164 struct md_rdev *rdev;
NeilBrown30b8feb2013-11-14 15:16:17 +11005165 int did_freeze = 0;
5166
5167 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
5168 did_freeze = 1;
5169 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5170 md_wakeup_thread(mddev->thread);
5171 }
NeilBrownf851b602014-12-11 10:02:10 +11005172 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
NeilBrown30b8feb2013-11-14 15:16:17 +11005173 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11005174 if (mddev->sync_thread)
NeilBrown30b8feb2013-11-14 15:16:17 +11005175 /* Thread might be blocked waiting for metadata update
5176 * which will now never happen */
5177 wake_up_process(mddev->sync_thread->tsk);
NeilBrownf851b602014-12-11 10:02:10 +11005178
NeilBrown30b8feb2013-11-14 15:16:17 +11005179 mddev_unlock(mddev);
NeilBrownf851b602014-12-11 10:02:10 +11005180 wait_event(resync_wait, (mddev->sync_thread == NULL &&
5181 !test_bit(MD_RECOVERY_RUNNING,
5182 &mddev->recovery)));
NeilBrown30b8feb2013-11-14 15:16:17 +11005183 mddev_lock_nointr(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005184
NeilBrownc8c00a62009-08-10 12:50:52 +10005185 mutex_lock(&mddev->open_mutex);
NeilBrown9ba3b7f2014-09-09 14:00:15 +10005186 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
NeilBrown30b8feb2013-11-14 15:16:17 +11005187 mddev->sysfs_active ||
5188 mddev->sync_thread ||
NeilBrownf851b602014-12-11 10:02:10 +11005189 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
NeilBrown30b8feb2013-11-14 15:16:17 +11005190 (bdev && !test_bit(MD_STILL_CLOSED, &mddev->flags))) {
Neil Browndf5b20c2008-07-11 22:02:22 +10005191 printk("md: %s still in use.\n",mdname(mddev));
NeilBrown6e17b022010-08-07 21:41:19 +10005192 mutex_unlock(&mddev->open_mutex);
NeilBrown30b8feb2013-11-14 15:16:17 +11005193 if (did_freeze) {
5194 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
NeilBrown45eaf452014-10-29 08:49:50 +11005195 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrown30b8feb2013-11-14 15:16:17 +11005196 md_wakeup_thread(mddev->thread);
5197 }
NeilBrown260fa032013-08-27 16:44:13 +10005198 return -EBUSY;
5199 }
NeilBrown6e17b022010-08-07 21:41:19 +10005200 if (mddev->pers) {
NeilBrowna4bd82d2010-03-29 13:23:10 +11005201 if (mddev->ro)
5202 set_disk_ro(disk, 0);
NeilBrown409c57f2009-03-31 14:39:39 +11005203
NeilBrowndefad612011-01-14 09:14:33 +11005204 __md_stop_writes(mddev);
NeilBrown5eff3c42012-11-19 10:47:48 +11005205 __md_stop(mddev);
NeilBrowna4bd82d2010-03-29 13:23:10 +11005206 mddev->queue->merge_bvec_fn = NULL;
NeilBrowna4bd82d2010-03-29 13:23:10 +11005207 mddev->queue->backing_dev_info.congested_fn = NULL;
NeilBrown6177b472010-03-29 11:37:13 +11005208
NeilBrowna4bd82d2010-03-29 13:23:10 +11005209 /* tell userspace to handle 'inactive' */
NeilBrown00bcb4a2010-06-01 19:37:23 +10005210 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown0d4ca602006-12-10 02:20:44 -08005211
NeilBrowndafb20f2012-03-19 12:46:39 +11005212 rdev_for_each(rdev, mddev)
Namhyung Kim36fad852011-07-27 11:00:36 +10005213 if (rdev->raid_disk >= 0)
5214 sysfs_unlink_rdev(mddev, rdev);
NeilBrownc4647292009-05-07 12:51:06 +10005215
NeilBrowna4bd82d2010-03-29 13:23:10 +11005216 set_capacity(disk, 0);
NeilBrown6e17b022010-08-07 21:41:19 +10005217 mutex_unlock(&mddev->open_mutex);
NeilBrownf0b4f7e2011-02-24 17:26:41 +11005218 mddev->changed = 1;
NeilBrowna4bd82d2010-03-29 13:23:10 +11005219 revalidate_disk(disk);
NeilBrown0d4ca602006-12-10 02:20:44 -08005220
NeilBrowna4bd82d2010-03-29 13:23:10 +11005221 if (mddev->ro)
5222 mddev->ro = 0;
NeilBrown6e17b022010-08-07 21:41:19 +10005223 } else
5224 mutex_unlock(&mddev->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005225 /*
5226 * Free resources if final stop
5227 */
NeilBrown9e653b62006-06-26 00:27:58 -07005228 if (mode == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005229 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
5230
NeilBrown978f9462006-02-02 14:28:05 -08005231 bitmap_destroy(mddev);
NeilBrownc3d97142009-12-14 12:49:52 +11005232 if (mddev->bitmap_info.file) {
NeilBrownc3d97142009-12-14 12:49:52 +11005233 fput(mddev->bitmap_info.file);
5234 mddev->bitmap_info.file = NULL;
NeilBrown978f9462006-02-02 14:28:05 -08005235 }
NeilBrownc3d97142009-12-14 12:49:52 +11005236 mddev->bitmap_info.offset = 0;
NeilBrown978f9462006-02-02 14:28:05 -08005237
Linus Torvalds1da177e2005-04-16 15:20:36 -07005238 export_array(mddev);
5239
NeilBrown6177b472010-03-29 11:37:13 +11005240 md_clean(mddev);
NeilBrown934d9c22008-10-28 17:01:23 +11005241 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
NeilBrownefeb53c2009-01-09 08:31:10 +11005242 if (mddev->hold_active == UNTIL_STOP)
5243 mddev->hold_active = 0;
NeilBrowna4bd82d2010-03-29 13:23:10 +11005244 }
Martin K. Petersen3f9d99c2009-03-31 14:27:02 +11005245 blk_integrity_unregister(disk);
NeilBrownd7603b72006-01-06 00:20:30 -08005246 md_new_event(mddev);
NeilBrown00bcb4a2010-06-01 19:37:23 +10005247 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown6e17b022010-08-07 21:41:19 +10005248 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005249}
5250
Jeff Garzikfdee8ae2006-12-10 02:20:50 -08005251#ifndef MODULE
NeilBrownfd01b882011-10-11 16:47:53 +11005252static void autorun_array(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005253{
NeilBrown3cb03002011-10-11 16:45:26 +11005254 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005255 int err;
5256
NeilBrowna757e642005-04-16 15:26:42 -07005257 if (list_empty(&mddev->disks))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005258 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005259
5260 printk(KERN_INFO "md: running: ");
5261
NeilBrowndafb20f2012-03-19 12:46:39 +11005262 rdev_for_each(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005263 char b[BDEVNAME_SIZE];
5264 printk("<%s>", bdevname(rdev->bdev,b));
5265 }
5266 printk("\n");
5267
NeilBrownd710e132008-10-13 11:55:12 +11005268 err = do_md_run(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005269 if (err) {
5270 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
NeilBrowna05b7ea2012-07-19 15:59:18 +10005271 do_md_stop(mddev, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005272 }
5273}
5274
5275/*
5276 * lets try to run arrays based on all disks that have arrived
5277 * until now. (those are in pending_raid_disks)
5278 *
5279 * the method: pick the first pending disk, collect all disks with
5280 * the same UUID, remove all from the pending list and put them into
5281 * the 'same_array' list. Then order this list based on superblock
5282 * update time (freshest comes first), kick out 'old' disks and
5283 * compare superblocks. If everything's fine then run it.
5284 *
5285 * If "unit" is allocated, then bump its reference count
5286 */
5287static void autorun_devices(int part)
5288{
NeilBrown3cb03002011-10-11 16:45:26 +11005289 struct md_rdev *rdev0, *rdev, *tmp;
NeilBrownfd01b882011-10-11 16:47:53 +11005290 struct mddev *mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005291 char b[BDEVNAME_SIZE];
5292
5293 printk(KERN_INFO "md: autorun ...\n");
5294 while (!list_empty(&pending_raid_disks)) {
NeilBrowne8703fe2006-10-03 01:15:59 -07005295 int unit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005296 dev_t dev;
NeilBrownad01c9e2006-03-27 01:18:07 -08005297 LIST_HEAD(candidates);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005298 rdev0 = list_entry(pending_raid_disks.next,
NeilBrown3cb03002011-10-11 16:45:26 +11005299 struct md_rdev, same_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005300
5301 printk(KERN_INFO "md: considering %s ...\n",
5302 bdevname(rdev0->bdev,b));
5303 INIT_LIST_HEAD(&candidates);
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005304 rdev_for_each_list(rdev, tmp, &pending_raid_disks)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005305 if (super_90_load(rdev, rdev0, 0) >= 0) {
5306 printk(KERN_INFO "md: adding %s ...\n",
5307 bdevname(rdev->bdev,b));
5308 list_move(&rdev->same_set, &candidates);
5309 }
5310 /*
5311 * now we have a set of devices, with all of them having
5312 * mostly sane superblocks. It's time to allocate the
5313 * mddev.
5314 */
NeilBrowne8703fe2006-10-03 01:15:59 -07005315 if (part) {
5316 dev = MKDEV(mdp_major,
5317 rdev0->preferred_minor << MdpMinorShift);
5318 unit = MINOR(dev) >> MdpMinorShift;
5319 } else {
5320 dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
5321 unit = MINOR(dev);
5322 }
5323 if (rdev0->preferred_minor != unit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005324 printk(KERN_INFO "md: unit number in %s is bad: %d\n",
5325 bdevname(rdev0->bdev, b), rdev0->preferred_minor);
5326 break;
5327 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005328
5329 md_probe(dev, NULL, NULL);
5330 mddev = mddev_find(dev);
Neil Brown9bbbca32008-06-28 08:31:17 +10005331 if (!mddev || !mddev->gendisk) {
5332 if (mddev)
5333 mddev_put(mddev);
5334 printk(KERN_ERR
Linus Torvalds1da177e2005-04-16 15:20:36 -07005335 "md: cannot allocate memory for md drive.\n");
5336 break;
5337 }
NeilBrownf72ffdd2014-09-30 14:23:59 +10005338 if (mddev_lock(mddev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005339 printk(KERN_WARNING "md: %s locked, cannot run\n",
5340 mdname(mddev));
5341 else if (mddev->raid_disks || mddev->major_version
5342 || !list_empty(&mddev->disks)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005343 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005344 "md: %s already running, cannot run %s\n",
5345 mdname(mddev), bdevname(rdev0->bdev,b));
5346 mddev_unlock(mddev);
5347 } else {
5348 printk(KERN_INFO "md: created %s\n", mdname(mddev));
NeilBrown1ec4a932008-02-06 01:39:53 -08005349 mddev->persistent = 1;
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005350 rdev_for_each_list(rdev, tmp, &candidates) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005351 list_del_init(&rdev->same_set);
5352 if (bind_rdev_to_array(rdev, mddev))
5353 export_rdev(rdev);
5354 }
5355 autorun_array(mddev);
5356 mddev_unlock(mddev);
5357 }
5358 /* on success, candidates will be empty, on error
5359 * it won't...
5360 */
Cheng Renquan159ec1f2009-01-09 08:31:08 +11005361 rdev_for_each_list(rdev, tmp, &candidates) {
NeilBrown4b809912008-07-21 17:05:25 +10005362 list_del_init(&rdev->same_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005363 export_rdev(rdev);
NeilBrown4b809912008-07-21 17:05:25 +10005364 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005365 mddev_put(mddev);
5366 }
5367 printk(KERN_INFO "md: ... autorun DONE.\n");
5368}
Jeff Garzikfdee8ae2006-12-10 02:20:50 -08005369#endif /* !MODULE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005370
NeilBrownf72ffdd2014-09-30 14:23:59 +10005371static int get_version(void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005372{
5373 mdu_version_t ver;
5374
5375 ver.major = MD_MAJOR_VERSION;
5376 ver.minor = MD_MINOR_VERSION;
5377 ver.patchlevel = MD_PATCHLEVEL_VERSION;
5378
5379 if (copy_to_user(arg, &ver, sizeof(ver)))
5380 return -EFAULT;
5381
5382 return 0;
5383}
5384
NeilBrownf72ffdd2014-09-30 14:23:59 +10005385static int get_array_info(struct mddev *mddev, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005386{
5387 mdu_array_info_t info;
NeilBrowna9f326e2009-09-23 18:06:41 +10005388 int nr,working,insync,failed,spare;
NeilBrown3cb03002011-10-11 16:45:26 +11005389 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005390
NeilBrown1ca69c42012-10-11 13:37:33 +11005391 nr = working = insync = failed = spare = 0;
5392 rcu_read_lock();
5393 rdev_for_each_rcu(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005394 nr++;
NeilBrownb2d444d2005-11-08 21:39:31 -08005395 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005396 failed++;
5397 else {
5398 working++;
NeilBrownb2d444d2005-11-08 21:39:31 -08005399 if (test_bit(In_sync, &rdev->flags))
NeilBrownf72ffdd2014-09-30 14:23:59 +10005400 insync++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005401 else
5402 spare++;
5403 }
5404 }
NeilBrown1ca69c42012-10-11 13:37:33 +11005405 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005406
5407 info.major_version = mddev->major_version;
5408 info.minor_version = mddev->minor_version;
5409 info.patch_version = MD_PATCHLEVEL_VERSION;
5410 info.ctime = mddev->ctime;
5411 info.level = mddev->level;
Andre Noll58c0fed2009-03-31 14:33:13 +11005412 info.size = mddev->dev_sectors / 2;
5413 if (info.size != mddev->dev_sectors / 2) /* overflow */
NeilBrown284ae7c2006-02-03 03:03:40 -08005414 info.size = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005415 info.nr_disks = nr;
5416 info.raid_disks = mddev->raid_disks;
5417 info.md_minor = mddev->md_minor;
5418 info.not_persistent= !mddev->persistent;
5419
5420 info.utime = mddev->utime;
5421 info.state = 0;
5422 if (mddev->in_sync)
5423 info.state = (1<<MD_SB_CLEAN);
NeilBrownc3d97142009-12-14 12:49:52 +11005424 if (mddev->bitmap && mddev->bitmap_info.offset)
NeilBrown9bd35922014-07-02 11:35:06 +10005425 info.state |= (1<<MD_SB_BITMAP_PRESENT);
NeilBrowna9f326e2009-09-23 18:06:41 +10005426 info.active_disks = insync;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005427 info.working_disks = working;
5428 info.failed_disks = failed;
5429 info.spare_disks = spare;
5430
5431 info.layout = mddev->layout;
Andre Noll9d8f0362009-06-18 08:45:01 +10005432 info.chunk_size = mddev->chunk_sectors << 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005433
5434 if (copy_to_user(arg, &info, sizeof(info)))
5435 return -EFAULT;
5436
5437 return 0;
5438}
5439
NeilBrownf72ffdd2014-09-30 14:23:59 +10005440static int get_bitmap_file(struct mddev *mddev, void __user * arg)
NeilBrown32a76272005-06-21 17:17:14 -07005441{
5442 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
5443 char *ptr, *buf = NULL;
5444 int err = -ENOMEM;
5445
NeilBrown60559da2013-07-16 16:44:29 +10005446 file = kmalloc(sizeof(*file), GFP_NOIO);
NeilBrown2a2275d2007-01-26 00:57:11 -08005447
NeilBrown32a76272005-06-21 17:17:14 -07005448 if (!file)
5449 goto out;
5450
5451 /* bitmap disabled, zero the first byte and copy out */
NeilBrown1ec885c2012-05-22 13:55:10 +10005452 if (!mddev->bitmap || !mddev->bitmap->storage.file) {
NeilBrown32a76272005-06-21 17:17:14 -07005453 file->pathname[0] = '\0';
5454 goto copy_out;
5455 }
5456
5457 buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
5458 if (!buf)
5459 goto out;
5460
NeilBrown1ec885c2012-05-22 13:55:10 +10005461 ptr = d_path(&mddev->bitmap->storage.file->f_path,
5462 buf, sizeof(file->pathname));
Christoph Hellwig6bcfd602008-05-23 13:04:34 -07005463 if (IS_ERR(ptr))
NeilBrown32a76272005-06-21 17:17:14 -07005464 goto out;
5465
5466 strcpy(file->pathname, ptr);
5467
5468copy_out:
5469 err = 0;
5470 if (copy_to_user(arg, file, sizeof(*file)))
5471 err = -EFAULT;
5472out:
5473 kfree(buf);
5474 kfree(file);
5475 return err;
5476}
5477
NeilBrownf72ffdd2014-09-30 14:23:59 +10005478static int get_disk_info(struct mddev *mddev, void __user * arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005479{
5480 mdu_disk_info_t info;
NeilBrown3cb03002011-10-11 16:45:26 +11005481 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005482
5483 if (copy_from_user(&info, arg, sizeof(info)))
5484 return -EFAULT;
5485
NeilBrown1ca69c42012-10-11 13:37:33 +11005486 rcu_read_lock();
5487 rdev = find_rdev_nr_rcu(mddev, info.number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005488 if (rdev) {
5489 info.major = MAJOR(rdev->bdev->bd_dev);
5490 info.minor = MINOR(rdev->bdev->bd_dev);
5491 info.raid_disk = rdev->raid_disk;
5492 info.state = 0;
NeilBrownb2d444d2005-11-08 21:39:31 -08005493 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005494 info.state |= (1<<MD_DISK_FAULTY);
NeilBrownb2d444d2005-11-08 21:39:31 -08005495 else if (test_bit(In_sync, &rdev->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005496 info.state |= (1<<MD_DISK_ACTIVE);
5497 info.state |= (1<<MD_DISK_SYNC);
5498 }
NeilBrown8ddf9ef2005-09-09 16:23:45 -07005499 if (test_bit(WriteMostly, &rdev->flags))
5500 info.state |= (1<<MD_DISK_WRITEMOSTLY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005501 } else {
5502 info.major = info.minor = 0;
5503 info.raid_disk = -1;
5504 info.state = (1<<MD_DISK_REMOVED);
5505 }
NeilBrown1ca69c42012-10-11 13:37:33 +11005506 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005507
5508 if (copy_to_user(arg, &info, sizeof(info)))
5509 return -EFAULT;
5510
5511 return 0;
5512}
5513
NeilBrownf72ffdd2014-09-30 14:23:59 +10005514static int add_new_disk(struct mddev *mddev, mdu_disk_info_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005515{
5516 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
NeilBrown3cb03002011-10-11 16:45:26 +11005517 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005518 dev_t dev = MKDEV(info->major,info->minor);
5519
5520 if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
5521 return -EOVERFLOW;
5522
5523 if (!mddev->raid_disks) {
5524 int err;
5525 /* expecting a device which has a superblock */
5526 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
5527 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005528 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005529 "md: md_import_device returned %ld\n",
5530 PTR_ERR(rdev));
5531 return PTR_ERR(rdev);
5532 }
5533 if (!list_empty(&mddev->disks)) {
NeilBrown3cb03002011-10-11 16:45:26 +11005534 struct md_rdev *rdev0
5535 = list_entry(mddev->disks.next,
5536 struct md_rdev, same_set);
NeilBrowna9f326e2009-09-23 18:06:41 +10005537 err = super_types[mddev->major_version]
Linus Torvalds1da177e2005-04-16 15:20:36 -07005538 .load_super(rdev, rdev0, mddev->minor_version);
5539 if (err < 0) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005540 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005541 "md: %s has different UUID to %s\n",
NeilBrownf72ffdd2014-09-30 14:23:59 +10005542 bdevname(rdev->bdev,b),
Linus Torvalds1da177e2005-04-16 15:20:36 -07005543 bdevname(rdev0->bdev,b2));
5544 export_rdev(rdev);
5545 return -EINVAL;
5546 }
5547 }
5548 err = bind_rdev_to_array(rdev, mddev);
5549 if (err)
5550 export_rdev(rdev);
5551 return err;
5552 }
5553
5554 /*
5555 * add_new_disk can be used once the array is assembled
5556 * to add "hot spares". They must already have a superblock
5557 * written
5558 */
5559 if (mddev->pers) {
5560 int err;
5561 if (!mddev->pers->hot_add_disk) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005562 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005563 "%s: personality does not support diskops!\n",
5564 mdname(mddev));
5565 return -EINVAL;
5566 }
NeilBrown7b1e35f2005-09-09 16:23:50 -07005567 if (mddev->persistent)
5568 rdev = md_import_device(dev, mddev->major_version,
5569 mddev->minor_version);
5570 else
5571 rdev = md_import_device(dev, -1, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005572 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005573 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005574 "md: md_import_device returned %ld\n",
5575 PTR_ERR(rdev));
5576 return PTR_ERR(rdev);
5577 }
NeilBrown1a855a02010-12-09 16:36:28 +11005578 /* set saved_raid_disk if appropriate */
NeilBrown41158c72005-06-21 17:17:25 -07005579 if (!mddev->persistent) {
5580 if (info->state & (1<<MD_DISK_SYNC) &&
NeilBrownbf572542011-01-12 09:03:35 +11005581 info->raid_disk < mddev->raid_disks) {
NeilBrown41158c72005-06-21 17:17:25 -07005582 rdev->raid_disk = info->raid_disk;
NeilBrownbf572542011-01-12 09:03:35 +11005583 set_bit(In_sync, &rdev->flags);
NeilBrown8313b8e2013-12-12 10:13:33 +11005584 clear_bit(Bitmap_sync, &rdev->flags);
NeilBrownbf572542011-01-12 09:03:35 +11005585 } else
NeilBrown41158c72005-06-21 17:17:25 -07005586 rdev->raid_disk = -1;
NeilBrownf4667222013-12-09 12:04:56 +11005587 rdev->saved_raid_disk = rdev->raid_disk;
NeilBrown41158c72005-06-21 17:17:25 -07005588 } else
5589 super_types[mddev->major_version].
5590 validate_super(mddev, rdev);
NeilBrownbedd86b2011-05-11 14:26:20 +10005591 if ((info->state & (1<<MD_DISK_SYNC)) &&
NeilBrownf4563092012-07-03 15:59:06 +10005592 rdev->raid_disk != info->raid_disk) {
NeilBrownbedd86b2011-05-11 14:26:20 +10005593 /* This was a hot-add request, but events doesn't
5594 * match, so reject it.
5595 */
5596 export_rdev(rdev);
5597 return -EINVAL;
5598 }
5599
NeilBrownb2d444d2005-11-08 21:39:31 -08005600 clear_bit(In_sync, &rdev->flags); /* just to be sure */
NeilBrown8ddf9ef2005-09-09 16:23:45 -07005601 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
5602 set_bit(WriteMostly, &rdev->flags);
NeilBrown575a80f2009-03-31 14:33:13 +11005603 else
5604 clear_bit(WriteMostly, &rdev->flags);
NeilBrown8ddf9ef2005-09-09 16:23:45 -07005605
Linus Torvalds1da177e2005-04-16 15:20:36 -07005606 rdev->raid_disk = -1;
5607 err = bind_rdev_to_array(rdev, mddev);
NeilBrown7c7546c2006-06-26 00:27:41 -07005608 if (!err && !mddev->pers->hot_remove_disk) {
5609 /* If there is hot_add_disk but no hot_remove_disk
5610 * then added disks for geometry changes,
5611 * and should be added immediately.
5612 */
5613 super_types[mddev->major_version].
5614 validate_super(mddev, rdev);
5615 err = mddev->pers->hot_add_disk(mddev, rdev);
5616 if (err)
5617 unbind_rdev_from_array(rdev);
5618 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005619 if (err)
5620 export_rdev(rdev);
Neil Brown52664732008-06-28 08:31:44 +10005621 else
NeilBrown00bcb4a2010-06-01 19:37:23 +10005622 sysfs_notify_dirent_safe(rdev->sysfs_state);
NeilBrownc3617772005-06-21 17:17:10 -07005623
NeilBrown7ceb17e2013-04-24 11:42:42 +10005624 set_bit(MD_CHANGE_DEVS, &mddev->flags);
Neil Brown72a23c22008-06-28 08:31:41 +10005625 if (mddev->degraded)
5626 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrownc3617772005-06-21 17:17:10 -07005627 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
马建朋9864c002011-06-09 11:42:48 +10005628 if (!err)
5629 md_new_event(mddev);
NeilBrown005eca52005-08-22 13:11:08 -07005630 md_wakeup_thread(mddev->thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005631 return err;
5632 }
5633
5634 /* otherwise, add_new_disk is only allowed
5635 * for major_version==0 superblocks
5636 */
5637 if (mddev->major_version != 0) {
5638 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
5639 mdname(mddev));
5640 return -EINVAL;
5641 }
5642
5643 if (!(info->state & (1<<MD_DISK_FAULTY))) {
5644 int err;
NeilBrownd710e132008-10-13 11:55:12 +11005645 rdev = md_import_device(dev, -1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005646 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005647 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005648 "md: error, md_import_device() returned %ld\n",
5649 PTR_ERR(rdev));
5650 return PTR_ERR(rdev);
5651 }
5652 rdev->desc_nr = info->number;
5653 if (info->raid_disk < mddev->raid_disks)
5654 rdev->raid_disk = info->raid_disk;
5655 else
5656 rdev->raid_disk = -1;
5657
Linus Torvalds1da177e2005-04-16 15:20:36 -07005658 if (rdev->raid_disk < mddev->raid_disks)
NeilBrownb2d444d2005-11-08 21:39:31 -08005659 if (info->state & (1<<MD_DISK_SYNC))
5660 set_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005661
NeilBrown8ddf9ef2005-09-09 16:23:45 -07005662 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
5663 set_bit(WriteMostly, &rdev->flags);
5664
Linus Torvalds1da177e2005-04-16 15:20:36 -07005665 if (!mddev->persistent) {
5666 printk(KERN_INFO "md: nonpersistent superblock ...\n");
Mike Snitzer77304d22010-11-08 14:39:12 +01005667 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
5668 } else
Jonathan Brassow57b2caa2011-01-14 09:14:33 +11005669 rdev->sb_start = calc_dev_sboffset(rdev);
NeilBrown8190e752009-06-18 08:48:58 +10005670 rdev->sectors = rdev->sb_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005671
NeilBrown2bf071b2006-01-06 00:20:55 -08005672 err = bind_rdev_to_array(rdev, mddev);
5673 if (err) {
5674 export_rdev(rdev);
5675 return err;
5676 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07005677 }
5678
5679 return 0;
5680}
5681
NeilBrownf72ffdd2014-09-30 14:23:59 +10005682static int hot_remove_disk(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005683{
5684 char b[BDEVNAME_SIZE];
NeilBrown3cb03002011-10-11 16:45:26 +11005685 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005686
Linus Torvalds1da177e2005-04-16 15:20:36 -07005687 rdev = find_rdev(mddev, dev);
5688 if (!rdev)
5689 return -ENXIO;
5690
NeilBrown3ea8929d2013-04-24 11:42:41 +10005691 clear_bit(Blocked, &rdev->flags);
5692 remove_and_add_spares(mddev, rdev);
5693
Linus Torvalds1da177e2005-04-16 15:20:36 -07005694 if (rdev->raid_disk >= 0)
5695 goto busy;
5696
5697 kick_rdev_from_array(rdev);
NeilBrown850b2b42006-10-03 01:15:46 -07005698 md_update_sb(mddev, 1);
NeilBrownd7603b72006-01-06 00:20:30 -08005699 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005700
5701 return 0;
5702busy:
Nick Andrewfdefa4d2008-04-21 22:42:58 +00005703 printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07005704 bdevname(rdev->bdev,b), mdname(mddev));
5705 return -EBUSY;
5706}
5707
NeilBrownf72ffdd2014-09-30 14:23:59 +10005708static int hot_add_disk(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005709{
5710 char b[BDEVNAME_SIZE];
5711 int err;
NeilBrown3cb03002011-10-11 16:45:26 +11005712 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005713
5714 if (!mddev->pers)
5715 return -ENODEV;
5716
5717 if (mddev->major_version != 0) {
5718 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
5719 " version-0 superblocks.\n",
5720 mdname(mddev));
5721 return -EINVAL;
5722 }
5723 if (!mddev->pers->hot_add_disk) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005724 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005725 "%s: personality does not support diskops!\n",
5726 mdname(mddev));
5727 return -EINVAL;
5728 }
5729
NeilBrownd710e132008-10-13 11:55:12 +11005730 rdev = md_import_device(dev, -1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005731 if (IS_ERR(rdev)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005732 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005733 "md: error, md_import_device() returned %ld\n",
5734 PTR_ERR(rdev));
5735 return -EINVAL;
5736 }
5737
5738 if (mddev->persistent)
Jonathan Brassow57b2caa2011-01-14 09:14:33 +11005739 rdev->sb_start = calc_dev_sboffset(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005740 else
Mike Snitzer77304d22010-11-08 14:39:12 +01005741 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005742
NeilBrown8190e752009-06-18 08:48:58 +10005743 rdev->sectors = rdev->sb_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005744
NeilBrownb2d444d2005-11-08 21:39:31 -08005745 if (test_bit(Faulty, &rdev->flags)) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10005746 printk(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07005747 "md: can not hot-add faulty %s disk to %s!\n",
5748 bdevname(rdev->bdev,b), mdname(mddev));
5749 err = -EINVAL;
5750 goto abort_export;
5751 }
NeilBrownb2d444d2005-11-08 21:39:31 -08005752 clear_bit(In_sync, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005753 rdev->desc_nr = -1;
NeilBrown58427302006-10-06 00:44:04 -07005754 rdev->saved_raid_disk = -1;
NeilBrown2bf071b2006-01-06 00:20:55 -08005755 err = bind_rdev_to_array(rdev, mddev);
5756 if (err)
5757 goto abort_export;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005758
5759 /*
5760 * The rest should better be atomic, we can have disk failures
5761 * noticed in interrupt contexts ...
5762 */
5763
Linus Torvalds1da177e2005-04-16 15:20:36 -07005764 rdev->raid_disk = -1;
5765
NeilBrown850b2b42006-10-03 01:15:46 -07005766 md_update_sb(mddev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005767
5768 /*
5769 * Kick recovery, maybe this spare has to be added to the
5770 * array immediately.
5771 */
5772 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5773 md_wakeup_thread(mddev->thread);
NeilBrownd7603b72006-01-06 00:20:30 -08005774 md_new_event(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005775 return 0;
5776
Linus Torvalds1da177e2005-04-16 15:20:36 -07005777abort_export:
5778 export_rdev(rdev);
5779 return err;
5780}
5781
NeilBrownfd01b882011-10-11 16:47:53 +11005782static int set_bitmap_file(struct mddev *mddev, int fd)
NeilBrown32a76272005-06-21 17:17:14 -07005783{
NeilBrown035328c2014-04-09 12:25:40 +10005784 int err = 0;
NeilBrown32a76272005-06-21 17:17:14 -07005785
NeilBrown36fa3062005-09-09 16:23:45 -07005786 if (mddev->pers) {
NeilBrownd66b1b32014-08-08 15:40:24 +10005787 if (!mddev->pers->quiesce || !mddev->thread)
NeilBrown36fa3062005-09-09 16:23:45 -07005788 return -EBUSY;
5789 if (mddev->recovery || mddev->sync_thread)
5790 return -EBUSY;
5791 /* we should be able to change the bitmap.. */
NeilBrown32a76272005-06-21 17:17:14 -07005792 }
5793
NeilBrown36fa3062005-09-09 16:23:45 -07005794 if (fd >= 0) {
NeilBrown035328c2014-04-09 12:25:40 +10005795 struct inode *inode;
NeilBrown36fa3062005-09-09 16:23:45 -07005796 if (mddev->bitmap)
5797 return -EEXIST; /* cannot add when bitmap is present */
NeilBrownc3d97142009-12-14 12:49:52 +11005798 mddev->bitmap_info.file = fget(fd);
NeilBrown36fa3062005-09-09 16:23:45 -07005799
NeilBrownc3d97142009-12-14 12:49:52 +11005800 if (mddev->bitmap_info.file == NULL) {
NeilBrown36fa3062005-09-09 16:23:45 -07005801 printk(KERN_ERR "%s: error: failed to get bitmap file\n",
5802 mdname(mddev));
5803 return -EBADF;
5804 }
5805
NeilBrown035328c2014-04-09 12:25:40 +10005806 inode = mddev->bitmap_info.file->f_mapping->host;
5807 if (!S_ISREG(inode->i_mode)) {
5808 printk(KERN_ERR "%s: error: bitmap file must be a regular file\n",
5809 mdname(mddev));
5810 err = -EBADF;
5811 } else if (!(mddev->bitmap_info.file->f_mode & FMODE_WRITE)) {
5812 printk(KERN_ERR "%s: error: bitmap file must open for write\n",
5813 mdname(mddev));
5814 err = -EBADF;
5815 } else if (atomic_read(&inode->i_writecount) != 1) {
NeilBrown36fa3062005-09-09 16:23:45 -07005816 printk(KERN_ERR "%s: error: bitmap file is already in use\n",
5817 mdname(mddev));
NeilBrown035328c2014-04-09 12:25:40 +10005818 err = -EBUSY;
5819 }
5820 if (err) {
NeilBrownc3d97142009-12-14 12:49:52 +11005821 fput(mddev->bitmap_info.file);
5822 mddev->bitmap_info.file = NULL;
NeilBrown36fa3062005-09-09 16:23:45 -07005823 return err;
5824 }
NeilBrownc3d97142009-12-14 12:49:52 +11005825 mddev->bitmap_info.offset = 0; /* file overrides offset */
NeilBrown36fa3062005-09-09 16:23:45 -07005826 } else if (mddev->bitmap == NULL)
5827 return -ENOENT; /* cannot remove what isn't there */
5828 err = 0;
5829 if (mddev->pers) {
5830 mddev->pers->quiesce(mddev, 1);
NeilBrown69e51b42010-06-01 19:37:35 +10005831 if (fd >= 0) {
NeilBrown36fa3062005-09-09 16:23:45 -07005832 err = bitmap_create(mddev);
NeilBrown69e51b42010-06-01 19:37:35 +10005833 if (!err)
5834 err = bitmap_load(mddev);
5835 }
NeilBrownd7375ab2006-06-26 00:27:43 -07005836 if (fd < 0 || err) {
NeilBrown36fa3062005-09-09 16:23:45 -07005837 bitmap_destroy(mddev);
NeilBrownd7375ab2006-06-26 00:27:43 -07005838 fd = -1; /* make sure to put the file */
5839 }
NeilBrown36fa3062005-09-09 16:23:45 -07005840 mddev->pers->quiesce(mddev, 0);
NeilBrownd7375ab2006-06-26 00:27:43 -07005841 }
5842 if (fd < 0) {
NeilBrown035328c2014-04-09 12:25:40 +10005843 if (mddev->bitmap_info.file)
NeilBrownc3d97142009-12-14 12:49:52 +11005844 fput(mddev->bitmap_info.file);
NeilBrownc3d97142009-12-14 12:49:52 +11005845 mddev->bitmap_info.file = NULL;
NeilBrown36fa3062005-09-09 16:23:45 -07005846 }
5847
NeilBrown32a76272005-06-21 17:17:14 -07005848 return err;
5849}
5850
Linus Torvalds1da177e2005-04-16 15:20:36 -07005851/*
5852 * set_array_info is used two different ways
5853 * The original usage is when creating a new array.
5854 * In this usage, raid_disks is > 0 and it together with
5855 * level, size, not_persistent,layout,chunksize determine the
5856 * shape of the array.
5857 * This will always create an array with a type-0.90.0 superblock.
5858 * The newer usage is when assembling an array.
5859 * In this case raid_disks will be 0, and the major_version field is
5860 * use to determine which style super-blocks are to be found on the devices.
5861 * The minor and patch _version numbers are also kept incase the
5862 * super_block handler wishes to interpret them.
5863 */
NeilBrownf72ffdd2014-09-30 14:23:59 +10005864static int set_array_info(struct mddev *mddev, mdu_array_info_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005865{
5866
5867 if (info->raid_disks == 0) {
5868 /* just setting version number for superblock loading */
5869 if (info->major_version < 0 ||
Ahmed S. Darwish50511da2007-05-09 02:35:34 -07005870 info->major_version >= ARRAY_SIZE(super_types) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07005871 super_types[info->major_version].name == NULL) {
5872 /* maybe try to auto-load a module? */
NeilBrownf72ffdd2014-09-30 14:23:59 +10005873 printk(KERN_INFO
Linus Torvalds1da177e2005-04-16 15:20:36 -07005874 "md: superblock version %d not known\n",
5875 info->major_version);
5876 return -EINVAL;
5877 }
5878 mddev->major_version = info->major_version;
5879 mddev->minor_version = info->minor_version;
5880 mddev->patch_version = info->patch_version;
NeilBrown3f9d7b02006-12-22 01:11:41 -08005881 mddev->persistent = !info->not_persistent;
NeilBrowncbd19982009-12-30 12:08:49 +11005882 /* ensure mddev_put doesn't delete this now that there
5883 * is some minimal configuration.
5884 */
5885 mddev->ctime = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07005886 return 0;
5887 }
5888 mddev->major_version = MD_MAJOR_VERSION;
5889 mddev->minor_version = MD_MINOR_VERSION;
5890 mddev->patch_version = MD_PATCHLEVEL_VERSION;
5891 mddev->ctime = get_seconds();
5892
5893 mddev->level = info->level;
NeilBrown17115e02006-01-16 22:14:57 -08005894 mddev->clevel[0] = 0;
Andre Noll58c0fed2009-03-31 14:33:13 +11005895 mddev->dev_sectors = 2 * (sector_t)info->size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005896 mddev->raid_disks = info->raid_disks;
5897 /* don't set md_minor, it is determined by which /dev/md* was
5898 * openned
5899 */
5900 if (info->state & (1<<MD_SB_CLEAN))
5901 mddev->recovery_cp = MaxSector;
5902 else
5903 mddev->recovery_cp = 0;
5904 mddev->persistent = ! info->not_persistent;
NeilBrowne6910632008-02-06 01:39:51 -08005905 mddev->external = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005906
5907 mddev->layout = info->layout;
Andre Noll9d8f0362009-06-18 08:45:01 +10005908 mddev->chunk_sectors = info->chunk_size >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005909
5910 mddev->max_disks = MD_SB_DISKS;
5911
NeilBrowne6910632008-02-06 01:39:51 -08005912 if (mddev->persistent)
5913 mddev->flags = 0;
NeilBrown850b2b42006-10-03 01:15:46 -07005914 set_bit(MD_CHANGE_DEVS, &mddev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005915
NeilBrownc3d97142009-12-14 12:49:52 +11005916 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
NeilBrown6409bb02012-05-22 13:55:07 +10005917 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
NeilBrownc3d97142009-12-14 12:49:52 +11005918 mddev->bitmap_info.offset = 0;
NeilBrownb2a27032005-11-28 13:44:12 -08005919
NeilBrownf6705572006-03-27 01:18:11 -08005920 mddev->reshape_position = MaxSector;
5921
Linus Torvalds1da177e2005-04-16 15:20:36 -07005922 /*
5923 * Generate a 128 bit UUID
5924 */
5925 get_random_bytes(mddev->uuid, 16);
5926
NeilBrownf6705572006-03-27 01:18:11 -08005927 mddev->new_level = mddev->level;
Andre Noll664e7c42009-06-18 08:45:27 +10005928 mddev->new_chunk_sectors = mddev->chunk_sectors;
NeilBrownf6705572006-03-27 01:18:11 -08005929 mddev->new_layout = mddev->layout;
5930 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10005931 mddev->reshape_backwards = 0;
NeilBrownf6705572006-03-27 01:18:11 -08005932
Linus Torvalds1da177e2005-04-16 15:20:36 -07005933 return 0;
5934}
5935
NeilBrownfd01b882011-10-11 16:47:53 +11005936void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
Dan Williams1f403622009-03-31 14:59:03 +11005937{
Dan Williamsb522adc2009-03-31 15:00:31 +11005938 WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);
5939
5940 if (mddev->external_size)
5941 return;
5942
Dan Williams1f403622009-03-31 14:59:03 +11005943 mddev->array_sectors = array_sectors;
5944}
5945EXPORT_SYMBOL(md_set_array_sectors);
5946
NeilBrownfd01b882011-10-11 16:47:53 +11005947static int update_size(struct mddev *mddev, sector_t num_sectors)
NeilBrowna35b0d692006-01-06 00:20:49 -08005948{
NeilBrown3cb03002011-10-11 16:45:26 +11005949 struct md_rdev *rdev;
NeilBrowna35b0d692006-01-06 00:20:49 -08005950 int rv;
Andre Nolld71f9f82008-07-11 22:02:22 +10005951 int fit = (num_sectors == 0);
NeilBrowna35b0d692006-01-06 00:20:49 -08005952
5953 if (mddev->pers->resize == NULL)
5954 return -EINVAL;
Andre Nolld71f9f82008-07-11 22:02:22 +10005955 /* The "num_sectors" is the number of sectors of each device that
5956 * is used. This can only make sense for arrays with redundancy.
5957 * linear and raid0 always use whatever space is available. We can only
5958 * consider changing this number if no resync or reconstruction is
5959 * happening, and if the new size is acceptable. It must fit before the
Andre Noll0f420352008-07-11 22:02:23 +10005960 * sb_start or, if that is <data_offset, it must fit before the size
Andre Nolld71f9f82008-07-11 22:02:22 +10005961 * of each device. If num_sectors is zero, we find the largest size
5962 * that fits.
NeilBrowna35b0d692006-01-06 00:20:49 -08005963 */
NeilBrownf851b602014-12-11 10:02:10 +11005964 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
5965 mddev->sync_thread)
NeilBrowna35b0d692006-01-06 00:20:49 -08005966 return -EBUSY;
NeilBrownbd8839e2014-05-28 13:39:21 +10005967 if (mddev->ro)
5968 return -EROFS;
NeilBrowna4a61252012-05-22 13:55:27 +10005969
NeilBrowndafb20f2012-03-19 12:46:39 +11005970 rdev_for_each(rdev, mddev) {
Andre Nolldd8ac332009-03-31 14:33:13 +11005971 sector_t avail = rdev->sectors;
NeilBrown01ab5662006-10-28 10:38:30 -07005972
Andre Nolld71f9f82008-07-11 22:02:22 +10005973 if (fit && (num_sectors == 0 || num_sectors > avail))
5974 num_sectors = avail;
5975 if (avail < num_sectors)
NeilBrowna35b0d692006-01-06 00:20:49 -08005976 return -ENOSPC;
5977 }
Andre Nolld71f9f82008-07-11 22:02:22 +10005978 rv = mddev->pers->resize(mddev, num_sectors);
NeilBrown449aad32009-08-03 10:59:58 +10005979 if (!rv)
5980 revalidate_disk(mddev->gendisk);
NeilBrowna35b0d692006-01-06 00:20:49 -08005981 return rv;
5982}
5983
NeilBrownfd01b882011-10-11 16:47:53 +11005984static int update_raid_disks(struct mddev *mddev, int raid_disks)
NeilBrownda943b992006-01-06 00:20:54 -08005985{
5986 int rv;
NeilBrownc6563a82012-05-21 09:27:00 +10005987 struct md_rdev *rdev;
NeilBrownda943b992006-01-06 00:20:54 -08005988 /* change the number of raid disks */
NeilBrown63c70c42006-03-27 01:18:13 -08005989 if (mddev->pers->check_reshape == NULL)
NeilBrownda943b992006-01-06 00:20:54 -08005990 return -EINVAL;
NeilBrownbd8839e2014-05-28 13:39:21 +10005991 if (mddev->ro)
5992 return -EROFS;
NeilBrownda943b992006-01-06 00:20:54 -08005993 if (raid_disks <= 0 ||
NeilBrown233fca32010-04-14 17:02:09 +10005994 (mddev->max_disks && raid_disks >= mddev->max_disks))
NeilBrownda943b992006-01-06 00:20:54 -08005995 return -EINVAL;
NeilBrownf851b602014-12-11 10:02:10 +11005996 if (mddev->sync_thread ||
5997 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
5998 mddev->reshape_position != MaxSector)
NeilBrownda943b992006-01-06 00:20:54 -08005999 return -EBUSY;
NeilBrownc6563a82012-05-21 09:27:00 +10006000
6001 rdev_for_each(rdev, mddev) {
6002 if (mddev->raid_disks < raid_disks &&
6003 rdev->data_offset < rdev->new_data_offset)
6004 return -EINVAL;
6005 if (mddev->raid_disks > raid_disks &&
6006 rdev->data_offset > rdev->new_data_offset)
6007 return -EINVAL;
6008 }
6009
NeilBrown63c70c42006-03-27 01:18:13 -08006010 mddev->delta_disks = raid_disks - mddev->raid_disks;
NeilBrown2c810cd2012-05-21 09:27:00 +10006011 if (mddev->delta_disks < 0)
6012 mddev->reshape_backwards = 1;
6013 else if (mddev->delta_disks > 0)
6014 mddev->reshape_backwards = 0;
NeilBrown63c70c42006-03-27 01:18:13 -08006015
6016 rv = mddev->pers->check_reshape(mddev);
NeilBrown2c810cd2012-05-21 09:27:00 +10006017 if (rv < 0) {
NeilBrownde171cb2011-01-31 11:57:42 +11006018 mddev->delta_disks = 0;
NeilBrown2c810cd2012-05-21 09:27:00 +10006019 mddev->reshape_backwards = 0;
6020 }
NeilBrownda943b992006-01-06 00:20:54 -08006021 return rv;
6022}
6023
Linus Torvalds1da177e2005-04-16 15:20:36 -07006024/*
6025 * update_array_info is used to change the configuration of an
6026 * on-line array.
6027 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
6028 * fields in the info are checked against the array.
6029 * Any differences that cannot be handled will cause an error.
6030 * Normally, only one change can be managed at a time.
6031 */
NeilBrownfd01b882011-10-11 16:47:53 +11006032static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006033{
6034 int rv = 0;
6035 int cnt = 0;
NeilBrown36fa3062005-09-09 16:23:45 -07006036 int state = 0;
6037
6038 /* calculate expected state,ignoring low bits */
NeilBrownc3d97142009-12-14 12:49:52 +11006039 if (mddev->bitmap && mddev->bitmap_info.offset)
NeilBrown36fa3062005-09-09 16:23:45 -07006040 state |= (1 << MD_SB_BITMAP_PRESENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006041
6042 if (mddev->major_version != info->major_version ||
6043 mddev->minor_version != info->minor_version ||
6044/* mddev->patch_version != info->patch_version || */
6045 mddev->ctime != info->ctime ||
6046 mddev->level != info->level ||
6047/* mddev->layout != info->layout || */
6048 !mddev->persistent != info->not_persistent||
Andre Noll9d8f0362009-06-18 08:45:01 +10006049 mddev->chunk_sectors != info->chunk_size >> 9 ||
NeilBrown36fa3062005-09-09 16:23:45 -07006050 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
6051 ((state^info->state) & 0xfffffe00)
6052 )
Linus Torvalds1da177e2005-04-16 15:20:36 -07006053 return -EINVAL;
6054 /* Check there is only one change */
Andre Noll58c0fed2009-03-31 14:33:13 +11006055 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
6056 cnt++;
6057 if (mddev->raid_disks != info->raid_disks)
6058 cnt++;
6059 if (mddev->layout != info->layout)
6060 cnt++;
6061 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
6062 cnt++;
6063 if (cnt == 0)
6064 return 0;
6065 if (cnt > 1)
6066 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006067
6068 if (mddev->layout != info->layout) {
6069 /* Change layout
6070 * we don't need to do anything at the md level, the
6071 * personality will take care of it all.
6072 */
NeilBrown50ac1682009-06-18 08:47:55 +10006073 if (mddev->pers->check_reshape == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006074 return -EINVAL;
NeilBrown597a7112009-06-18 08:47:42 +10006075 else {
6076 mddev->new_layout = info->layout;
NeilBrown50ac1682009-06-18 08:47:55 +10006077 rv = mddev->pers->check_reshape(mddev);
NeilBrown597a7112009-06-18 08:47:42 +10006078 if (rv)
6079 mddev->new_layout = mddev->layout;
6080 return rv;
6081 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006082 }
Andre Noll58c0fed2009-03-31 14:33:13 +11006083 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
Andre Nolld71f9f82008-07-11 22:02:22 +10006084 rv = update_size(mddev, (sector_t)info->size * 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006085
NeilBrownda943b992006-01-06 00:20:54 -08006086 if (mddev->raid_disks != info->raid_disks)
6087 rv = update_raid_disks(mddev, info->raid_disks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006088
NeilBrown36fa3062005-09-09 16:23:45 -07006089 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
NeilBrownd66b1b32014-08-08 15:40:24 +10006090 if (mddev->pers->quiesce == NULL || mddev->thread == NULL)
NeilBrown36fa3062005-09-09 16:23:45 -07006091 return -EINVAL;
6092 if (mddev->recovery || mddev->sync_thread)
6093 return -EBUSY;
6094 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
6095 /* add the bitmap */
6096 if (mddev->bitmap)
6097 return -EEXIST;
NeilBrownc3d97142009-12-14 12:49:52 +11006098 if (mddev->bitmap_info.default_offset == 0)
NeilBrown36fa3062005-09-09 16:23:45 -07006099 return -EINVAL;
NeilBrownc3d97142009-12-14 12:49:52 +11006100 mddev->bitmap_info.offset =
6101 mddev->bitmap_info.default_offset;
NeilBrown6409bb02012-05-22 13:55:07 +10006102 mddev->bitmap_info.space =
6103 mddev->bitmap_info.default_space;
NeilBrown36fa3062005-09-09 16:23:45 -07006104 mddev->pers->quiesce(mddev, 1);
6105 rv = bitmap_create(mddev);
NeilBrown69e51b42010-06-01 19:37:35 +10006106 if (!rv)
6107 rv = bitmap_load(mddev);
NeilBrown36fa3062005-09-09 16:23:45 -07006108 if (rv)
6109 bitmap_destroy(mddev);
6110 mddev->pers->quiesce(mddev, 0);
6111 } else {
6112 /* remove the bitmap */
6113 if (!mddev->bitmap)
6114 return -ENOENT;
NeilBrown1ec885c2012-05-22 13:55:10 +10006115 if (mddev->bitmap->storage.file)
NeilBrown36fa3062005-09-09 16:23:45 -07006116 return -EINVAL;
6117 mddev->pers->quiesce(mddev, 1);
6118 bitmap_destroy(mddev);
6119 mddev->pers->quiesce(mddev, 0);
NeilBrownc3d97142009-12-14 12:49:52 +11006120 mddev->bitmap_info.offset = 0;
NeilBrown36fa3062005-09-09 16:23:45 -07006121 }
6122 }
NeilBrown850b2b42006-10-03 01:15:46 -07006123 md_update_sb(mddev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006124 return rv;
6125}
6126
NeilBrownfd01b882011-10-11 16:47:53 +11006127static int set_disk_faulty(struct mddev *mddev, dev_t dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006128{
NeilBrown3cb03002011-10-11 16:45:26 +11006129 struct md_rdev *rdev;
NeilBrown1ca69c42012-10-11 13:37:33 +11006130 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006131
6132 if (mddev->pers == NULL)
6133 return -ENODEV;
6134
NeilBrown1ca69c42012-10-11 13:37:33 +11006135 rcu_read_lock();
6136 rdev = find_rdev_rcu(mddev, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006137 if (!rdev)
NeilBrown1ca69c42012-10-11 13:37:33 +11006138 err = -ENODEV;
6139 else {
6140 md_error(mddev, rdev);
6141 if (!test_bit(Faulty, &rdev->flags))
6142 err = -EBUSY;
6143 }
6144 rcu_read_unlock();
6145 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006146}
6147
Andre Noll2f9618c2008-04-25 18:57:58 +02006148/*
6149 * We have a problem here : there is no easy way to give a CHS
6150 * virtual geometry. We currently pretend that we have a 2 heads
6151 * 4 sectors (with a BIG number of cylinders...). This drives
6152 * dosfs just mad... ;-)
6153 */
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08006154static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
6155{
NeilBrownfd01b882011-10-11 16:47:53 +11006156 struct mddev *mddev = bdev->bd_disk->private_data;
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08006157
6158 geo->heads = 2;
6159 geo->sectors = 4;
NeilBrown49ce6ce2010-03-29 10:51:42 +11006160 geo->cylinders = mddev->array_sectors / 8;
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08006161 return 0;
6162}
6163
Nicolas Schichancb335f82014-01-15 16:58:52 +01006164static inline bool md_ioctl_valid(unsigned int cmd)
6165{
6166 switch (cmd) {
6167 case ADD_NEW_DISK:
6168 case BLKROSET:
6169 case GET_ARRAY_INFO:
6170 case GET_BITMAP_FILE:
6171 case GET_DISK_INFO:
6172 case HOT_ADD_DISK:
6173 case HOT_REMOVE_DISK:
Nicolas Schichancb335f82014-01-15 16:58:52 +01006174 case RAID_AUTORUN:
6175 case RAID_VERSION:
6176 case RESTART_ARRAY_RW:
6177 case RUN_ARRAY:
6178 case SET_ARRAY_INFO:
6179 case SET_BITMAP_FILE:
6180 case SET_DISK_FAULTY:
6181 case STOP_ARRAY:
6182 case STOP_ARRAY_RO:
6183 return true;
6184 default:
6185 return false;
6186 }
6187}
6188
Al Viroa39907f2008-03-02 10:31:15 -05006189static int md_ioctl(struct block_device *bdev, fmode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07006190 unsigned int cmd, unsigned long arg)
6191{
6192 int err = 0;
6193 void __user *argp = (void __user *)arg;
NeilBrownfd01b882011-10-11 16:47:53 +11006194 struct mddev *mddev = NULL;
Dan Williamse2218352010-05-12 08:25:37 +10006195 int ro;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006196
Nicolas Schichancb335f82014-01-15 16:58:52 +01006197 if (!md_ioctl_valid(cmd))
6198 return -ENOTTY;
6199
NeilBrown506c9e42011-12-23 10:17:26 +11006200 switch (cmd) {
6201 case RAID_VERSION:
6202 case GET_ARRAY_INFO:
6203 case GET_DISK_INFO:
6204 break;
6205 default:
6206 if (!capable(CAP_SYS_ADMIN))
6207 return -EACCES;
6208 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006209
6210 /*
6211 * Commands dealing with the RAID driver but not any
6212 * particular array:
6213 */
NeilBrownc02c0ae2012-12-11 13:39:21 +11006214 switch (cmd) {
6215 case RAID_VERSION:
6216 err = get_version(argp);
NeilBrown3adc28d2014-09-30 15:46:41 +10006217 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006218
Linus Torvalds1da177e2005-04-16 15:20:36 -07006219#ifndef MODULE
NeilBrownc02c0ae2012-12-11 13:39:21 +11006220 case RAID_AUTORUN:
6221 err = 0;
6222 autostart_arrays(arg);
NeilBrown3adc28d2014-09-30 15:46:41 +10006223 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006224#endif
NeilBrownc02c0ae2012-12-11 13:39:21 +11006225 default:;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006226 }
6227
6228 /*
6229 * Commands creating/starting a new array:
6230 */
6231
Al Viroa39907f2008-03-02 10:31:15 -05006232 mddev = bdev->bd_disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006233
6234 if (!mddev) {
6235 BUG();
NeilBrown3adc28d2014-09-30 15:46:41 +10006236 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006237 }
6238
NeilBrown1ca69c42012-10-11 13:37:33 +11006239 /* Some actions do not requires the mutex */
6240 switch (cmd) {
6241 case GET_ARRAY_INFO:
6242 if (!mddev->raid_disks && !mddev->external)
6243 err = -ENODEV;
6244 else
6245 err = get_array_info(mddev, argp);
NeilBrown3adc28d2014-09-30 15:46:41 +10006246 goto out;
NeilBrown1ca69c42012-10-11 13:37:33 +11006247
6248 case GET_DISK_INFO:
6249 if (!mddev->raid_disks && !mddev->external)
6250 err = -ENODEV;
6251 else
6252 err = get_disk_info(mddev, argp);
NeilBrown3adc28d2014-09-30 15:46:41 +10006253 goto out;
NeilBrown1ca69c42012-10-11 13:37:33 +11006254
6255 case SET_DISK_FAULTY:
6256 err = set_disk_faulty(mddev, new_decode_dev(arg));
NeilBrown3adc28d2014-09-30 15:46:41 +10006257 goto out;
NeilBrown1ca69c42012-10-11 13:37:33 +11006258 }
6259
NeilBrowna7a3f082012-12-11 13:35:54 +11006260 if (cmd == ADD_NEW_DISK)
6261 /* need to ensure md_delayed_delete() has completed */
6262 flush_workqueue(md_misc_wq);
6263
Hannes Reinecke90f5f7a2013-04-02 08:38:55 +02006264 if (cmd == HOT_REMOVE_DISK)
6265 /* need to ensure recovery thread has run */
6266 wait_event_interruptible_timeout(mddev->sb_wait,
6267 !test_bit(MD_RECOVERY_NEEDED,
6268 &mddev->flags),
6269 msecs_to_jiffies(5000));
NeilBrown260fa032013-08-27 16:44:13 +10006270 if (cmd == STOP_ARRAY || cmd == STOP_ARRAY_RO) {
6271 /* Need to flush page cache, and ensure no-one else opens
6272 * and writes
6273 */
6274 mutex_lock(&mddev->open_mutex);
NeilBrown9ba3b7f2014-09-09 14:00:15 +10006275 if (mddev->pers && atomic_read(&mddev->openers) > 1) {
NeilBrown260fa032013-08-27 16:44:13 +10006276 mutex_unlock(&mddev->open_mutex);
6277 err = -EBUSY;
NeilBrown3adc28d2014-09-30 15:46:41 +10006278 goto out;
NeilBrown260fa032013-08-27 16:44:13 +10006279 }
6280 set_bit(MD_STILL_CLOSED, &mddev->flags);
6281 mutex_unlock(&mddev->open_mutex);
6282 sync_blockdev(bdev);
6283 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006284 err = mddev_lock(mddev);
6285 if (err) {
NeilBrownf72ffdd2014-09-30 14:23:59 +10006286 printk(KERN_INFO
Linus Torvalds1da177e2005-04-16 15:20:36 -07006287 "md: ioctl lock interrupted, reason %d, cmd %d\n",
6288 err, cmd);
NeilBrown3adc28d2014-09-30 15:46:41 +10006289 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006290 }
6291
NeilBrownc02c0ae2012-12-11 13:39:21 +11006292 if (cmd == SET_ARRAY_INFO) {
6293 mdu_array_info_t info;
6294 if (!arg)
6295 memset(&info, 0, sizeof(info));
6296 else if (copy_from_user(&info, argp, sizeof(info))) {
6297 err = -EFAULT;
NeilBrown3adc28d2014-09-30 15:46:41 +10006298 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006299 }
6300 if (mddev->pers) {
6301 err = update_array_info(mddev, &info);
6302 if (err) {
6303 printk(KERN_WARNING "md: couldn't update"
6304 " array info. %d\n", err);
NeilBrown3adc28d2014-09-30 15:46:41 +10006305 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006306 }
NeilBrown3adc28d2014-09-30 15:46:41 +10006307 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006308 }
6309 if (!list_empty(&mddev->disks)) {
6310 printk(KERN_WARNING
6311 "md: array %s already has disks!\n",
6312 mdname(mddev));
6313 err = -EBUSY;
NeilBrown3adc28d2014-09-30 15:46:41 +10006314 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006315 }
6316 if (mddev->raid_disks) {
6317 printk(KERN_WARNING
6318 "md: array %s already initialised!\n",
6319 mdname(mddev));
6320 err = -EBUSY;
NeilBrown3adc28d2014-09-30 15:46:41 +10006321 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006322 }
6323 err = set_array_info(mddev, &info);
6324 if (err) {
6325 printk(KERN_WARNING "md: couldn't set"
6326 " array info. %d\n", err);
NeilBrown3adc28d2014-09-30 15:46:41 +10006327 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006328 }
NeilBrown3adc28d2014-09-30 15:46:41 +10006329 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006330 }
6331
6332 /*
6333 * Commands querying/configuring an existing array:
6334 */
NeilBrown32a76272005-06-21 17:17:14 -07006335 /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
NeilBrown3f9d7b02006-12-22 01:11:41 -08006336 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
NeilBrowna17184a2008-02-06 01:39:55 -08006337 if ((!mddev->raid_disks && !mddev->external)
6338 && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
6339 && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
6340 && cmd != GET_BITMAP_FILE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006341 err = -ENODEV;
NeilBrown3adc28d2014-09-30 15:46:41 +10006342 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006343 }
6344
6345 /*
6346 * Commands even a read-only array can execute:
6347 */
NeilBrownc02c0ae2012-12-11 13:39:21 +11006348 switch (cmd) {
6349 case GET_BITMAP_FILE:
6350 err = get_bitmap_file(mddev, argp);
NeilBrown3adc28d2014-09-30 15:46:41 +10006351 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006352
6353 case RESTART_ARRAY_RW:
6354 err = restart_array(mddev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006355 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006356
6357 case STOP_ARRAY:
6358 err = do_md_stop(mddev, 0, bdev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006359 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006360
6361 case STOP_ARRAY_RO:
6362 err = md_set_readonly(mddev, bdev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006363 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006364
NeilBrown3ea8929d2013-04-24 11:42:41 +10006365 case HOT_REMOVE_DISK:
6366 err = hot_remove_disk(mddev, new_decode_dev(arg));
NeilBrown3adc28d2014-09-30 15:46:41 +10006367 goto unlock;
NeilBrown3ea8929d2013-04-24 11:42:41 +10006368
NeilBrown7ceb17e2013-04-24 11:42:42 +10006369 case ADD_NEW_DISK:
6370 /* We can support ADD_NEW_DISK on read-only arrays
6371 * on if we are re-adding a preexisting device.
6372 * So require mddev->pers and MD_DISK_SYNC.
6373 */
6374 if (mddev->pers) {
6375 mdu_disk_info_t info;
6376 if (copy_from_user(&info, argp, sizeof(info)))
6377 err = -EFAULT;
6378 else if (!(info.state & (1<<MD_DISK_SYNC)))
6379 /* Need to clear read-only for this */
6380 break;
6381 else
6382 err = add_new_disk(mddev, &info);
NeilBrown3adc28d2014-09-30 15:46:41 +10006383 goto unlock;
NeilBrown7ceb17e2013-04-24 11:42:42 +10006384 }
6385 break;
6386
NeilBrownc02c0ae2012-12-11 13:39:21 +11006387 case BLKROSET:
6388 if (get_user(ro, (int __user *)(arg))) {
6389 err = -EFAULT;
NeilBrown3adc28d2014-09-30 15:46:41 +10006390 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006391 }
6392 err = -EINVAL;
6393
6394 /* if the bdev is going readonly the value of mddev->ro
6395 * does not matter, no writes are coming
6396 */
6397 if (ro)
NeilBrown3adc28d2014-09-30 15:46:41 +10006398 goto unlock;
NeilBrown32a76272005-06-21 17:17:14 -07006399
NeilBrownc02c0ae2012-12-11 13:39:21 +11006400 /* are we are already prepared for writes? */
6401 if (mddev->ro != 1)
NeilBrown3adc28d2014-09-30 15:46:41 +10006402 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006403
6404 /* transitioning to readauto need only happen for
6405 * arrays that call md_write_start
6406 */
6407 if (mddev->pers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006408 err = restart_array(mddev);
NeilBrownc02c0ae2012-12-11 13:39:21 +11006409 if (err == 0) {
6410 mddev->ro = 2;
6411 set_disk_ro(mddev->gendisk, 0);
Dan Williamse2218352010-05-12 08:25:37 +10006412 }
NeilBrownc02c0ae2012-12-11 13:39:21 +11006413 }
NeilBrown3adc28d2014-09-30 15:46:41 +10006414 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006415 }
6416
6417 /*
6418 * The remaining ioctls are changing the state of the
NeilBrownf91de922005-11-08 21:39:36 -08006419 * superblock, so we do not allow them on read-only arrays.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006420 */
NeilBrown326eb172014-09-30 15:36:28 +10006421 if (mddev->ro && mddev->pers) {
NeilBrownf91de922005-11-08 21:39:36 -08006422 if (mddev->ro == 2) {
6423 mddev->ro = 0;
NeilBrown00bcb4a2010-06-01 19:37:23 +10006424 sysfs_notify_dirent_safe(mddev->sysfs_state);
Neil Brown0fd62b82008-06-28 08:31:36 +10006425 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrownf3378b42013-02-28 11:59:03 +11006426 /* mddev_unlock will wake thread */
6427 /* If a device failed while we were read-only, we
6428 * need to make sure the metadata is updated now.
6429 */
6430 if (test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
6431 mddev_unlock(mddev);
6432 wait_event(mddev->sb_wait,
6433 !test_bit(MD_CHANGE_DEVS, &mddev->flags) &&
6434 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
NeilBrown29f097c2013-11-14 17:54:51 +11006435 mddev_lock_nointr(mddev);
NeilBrownf3378b42013-02-28 11:59:03 +11006436 }
NeilBrownf91de922005-11-08 21:39:36 -08006437 } else {
6438 err = -EROFS;
NeilBrown3adc28d2014-09-30 15:46:41 +10006439 goto unlock;
NeilBrownf91de922005-11-08 21:39:36 -08006440 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006441 }
6442
NeilBrownc02c0ae2012-12-11 13:39:21 +11006443 switch (cmd) {
6444 case ADD_NEW_DISK:
Linus Torvalds1da177e2005-04-16 15:20:36 -07006445 {
NeilBrownc02c0ae2012-12-11 13:39:21 +11006446 mdu_disk_info_t info;
6447 if (copy_from_user(&info, argp, sizeof(info)))
6448 err = -EFAULT;
6449 else
6450 err = add_new_disk(mddev, &info);
NeilBrown3adc28d2014-09-30 15:46:41 +10006451 goto unlock;
NeilBrownc02c0ae2012-12-11 13:39:21 +11006452 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006453
NeilBrownc02c0ae2012-12-11 13:39:21 +11006454 case HOT_ADD_DISK:
6455 err = hot_add_disk(mddev, new_decode_dev(arg));
NeilBrown3adc28d2014-09-30 15:46:41 +10006456 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006457
NeilBrownc02c0ae2012-12-11 13:39:21 +11006458 case RUN_ARRAY:
6459 err = do_md_run(mddev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006460 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006461
NeilBrownc02c0ae2012-12-11 13:39:21 +11006462 case SET_BITMAP_FILE:
6463 err = set_bitmap_file(mddev, (int)arg);
NeilBrown3adc28d2014-09-30 15:46:41 +10006464 goto unlock;
NeilBrown32a76272005-06-21 17:17:14 -07006465
NeilBrownc02c0ae2012-12-11 13:39:21 +11006466 default:
6467 err = -EINVAL;
NeilBrown3adc28d2014-09-30 15:46:41 +10006468 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006469 }
6470
NeilBrown3adc28d2014-09-30 15:46:41 +10006471unlock:
NeilBrownd3374822009-01-09 08:31:10 +11006472 if (mddev->hold_active == UNTIL_IOCTL &&
6473 err != -EINVAL)
6474 mddev->hold_active = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006475 mddev_unlock(mddev);
NeilBrown3adc28d2014-09-30 15:46:41 +10006476out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07006477 return err;
6478}
Arnd Bergmannaa98aa32009-12-14 12:50:05 +11006479#ifdef CONFIG_COMPAT
6480static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
6481 unsigned int cmd, unsigned long arg)
6482{
6483 switch (cmd) {
6484 case HOT_REMOVE_DISK:
6485 case HOT_ADD_DISK:
6486 case SET_DISK_FAULTY:
6487 case SET_BITMAP_FILE:
6488 /* These take in integer arg, do not convert */
6489 break;
6490 default:
6491 arg = (unsigned long)compat_ptr(arg);
6492 break;
6493 }
6494
6495 return md_ioctl(bdev, mode, cmd, arg);
6496}
6497#endif /* CONFIG_COMPAT */
Linus Torvalds1da177e2005-04-16 15:20:36 -07006498
Al Viroa39907f2008-03-02 10:31:15 -05006499static int md_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006500{
6501 /*
6502 * Succeed if we can lock the mddev, which confirms that
6503 * it isn't being stopped right now.
6504 */
NeilBrownfd01b882011-10-11 16:47:53 +11006505 struct mddev *mddev = mddev_find(bdev->bd_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006506 int err;
6507
Yuanhan Liu0c098222012-05-22 13:55:32 +10006508 if (!mddev)
6509 return -ENODEV;
6510
NeilBrownd3374822009-01-09 08:31:10 +11006511 if (mddev->gendisk != bdev->bd_disk) {
6512 /* we are racing with mddev_put which is discarding this
6513 * bd_disk.
6514 */
6515 mddev_put(mddev);
6516 /* Wait until bdev->bd_disk is definitely gone */
Tejun Heoe804ac72010-10-15 15:36:08 +02006517 flush_workqueue(md_misc_wq);
NeilBrownd3374822009-01-09 08:31:10 +11006518 /* Then retry the open from the top */
6519 return -ERESTARTSYS;
6520 }
6521 BUG_ON(mddev != bdev->bd_disk->private_data);
6522
NeilBrownc8c00a62009-08-10 12:50:52 +10006523 if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07006524 goto out;
6525
6526 err = 0;
NeilBrownf2ea68c2008-07-21 17:05:25 +10006527 atomic_inc(&mddev->openers);
NeilBrown260fa032013-08-27 16:44:13 +10006528 clear_bit(MD_STILL_CLOSED, &mddev->flags);
NeilBrownc8c00a62009-08-10 12:50:52 +10006529 mutex_unlock(&mddev->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006530
NeilBrownf0b4f7e2011-02-24 17:26:41 +11006531 check_disk_change(bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006532 out:
6533 return err;
6534}
6535
Al Virodb2a1442013-05-05 21:52:57 -04006536static void md_release(struct gendisk *disk, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006537{
NeilBrownf72ffdd2014-09-30 14:23:59 +10006538 struct mddev *mddev = disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006539
Eric Sesterhenn52e5f9d2006-10-03 23:33:23 +02006540 BUG_ON(!mddev);
NeilBrownf2ea68c2008-07-21 17:05:25 +10006541 atomic_dec(&mddev->openers);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006542 mddev_put(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006543}
NeilBrownf0b4f7e2011-02-24 17:26:41 +11006544
6545static int md_media_changed(struct gendisk *disk)
6546{
NeilBrownfd01b882011-10-11 16:47:53 +11006547 struct mddev *mddev = disk->private_data;
NeilBrownf0b4f7e2011-02-24 17:26:41 +11006548
6549 return mddev->changed;
6550}
6551
6552static int md_revalidate(struct gendisk *disk)
6553{
NeilBrownfd01b882011-10-11 16:47:53 +11006554 struct mddev *mddev = disk->private_data;
NeilBrownf0b4f7e2011-02-24 17:26:41 +11006555
6556 mddev->changed = 0;
6557 return 0;
6558}
Alexey Dobriyan83d5cde2009-09-21 17:01:13 -07006559static const struct block_device_operations md_fops =
Linus Torvalds1da177e2005-04-16 15:20:36 -07006560{
6561 .owner = THIS_MODULE,
Al Viroa39907f2008-03-02 10:31:15 -05006562 .open = md_open,
6563 .release = md_release,
NeilBrownb492b852009-05-26 12:57:36 +10006564 .ioctl = md_ioctl,
Arnd Bergmannaa98aa32009-12-14 12:50:05 +11006565#ifdef CONFIG_COMPAT
6566 .compat_ioctl = md_compat_ioctl,
6567#endif
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08006568 .getgeo = md_getgeo,
NeilBrownf0b4f7e2011-02-24 17:26:41 +11006569 .media_changed = md_media_changed,
6570 .revalidate_disk= md_revalidate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07006571};
6572
NeilBrownf72ffdd2014-09-30 14:23:59 +10006573static int md_thread(void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006574{
NeilBrown2b8bf342011-10-11 16:48:23 +11006575 struct md_thread *thread = arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006576
Linus Torvalds1da177e2005-04-16 15:20:36 -07006577 /*
6578 * md_thread is a 'system-thread', it's priority should be very
6579 * high. We avoid resource deadlocks individually in each
6580 * raid personality. (RAID5 does preallocation) We also use RR and
6581 * the very same RT priority as kswapd, thus we will never get
6582 * into a priority inversion deadlock.
6583 *
6584 * we definitely have to have equal or higher priority than
6585 * bdflush, otherwise bdflush will deadlock if there are too
6586 * many dirty RAID5 blocks.
6587 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07006588
NeilBrown6985c432005-10-19 21:23:47 -07006589 allow_signal(SIGKILL);
NeilBrowna6fb0932005-09-09 16:23:56 -07006590 while (!kthread_should_stop()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006591
NeilBrown93588e22005-11-15 00:09:12 -08006592 /* We need to wait INTERRUPTIBLE so that
6593 * we don't add to the load-average.
6594 * That means we need to be sure no signals are
6595 * pending
6596 */
6597 if (signal_pending(current))
6598 flush_signals(current);
6599
6600 wait_event_interruptible_timeout
6601 (thread->wqueue,
6602 test_bit(THREAD_WAKEUP, &thread->flags)
6603 || kthread_should_stop(),
6604 thread->timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006605
NeilBrown6c987912011-01-14 09:13:53 +11006606 clear_bit(THREAD_WAKEUP, &thread->flags);
6607 if (!kthread_should_stop())
Shaohua Li4ed87312012-10-11 13:34:00 +11006608 thread->run(thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006609 }
NeilBrowna6fb0932005-09-09 16:23:56 -07006610
Linus Torvalds1da177e2005-04-16 15:20:36 -07006611 return 0;
6612}
6613
NeilBrown2b8bf342011-10-11 16:48:23 +11006614void md_wakeup_thread(struct md_thread *thread)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006615{
6616 if (thread) {
NeilBrown36a4e1f2011-10-07 14:23:17 +11006617 pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006618 set_bit(THREAD_WAKEUP, &thread->flags);
6619 wake_up(&thread->wqueue);
6620 }
6621}
NeilBrown6c144d32014-09-30 16:15:38 +10006622EXPORT_SYMBOL(md_wakeup_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006623
Shaohua Li4ed87312012-10-11 13:34:00 +11006624struct md_thread *md_register_thread(void (*run) (struct md_thread *),
6625 struct mddev *mddev, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006626{
NeilBrown2b8bf342011-10-11 16:48:23 +11006627 struct md_thread *thread;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006628
NeilBrown2b8bf342011-10-11 16:48:23 +11006629 thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006630 if (!thread)
6631 return NULL;
6632
Linus Torvalds1da177e2005-04-16 15:20:36 -07006633 init_waitqueue_head(&thread->wqueue);
6634
Linus Torvalds1da177e2005-04-16 15:20:36 -07006635 thread->run = run;
6636 thread->mddev = mddev;
NeilBrown32a76272005-06-21 17:17:14 -07006637 thread->timeout = MAX_SCHEDULE_TIMEOUT;
NeilBrown0da3c612009-09-23 18:09:45 +10006638 thread->tsk = kthread_run(md_thread, thread,
6639 "%s_%s",
6640 mdname(thread->mddev),
NeilBrown02326052012-07-03 15:56:52 +10006641 name);
NeilBrowna6fb0932005-09-09 16:23:56 -07006642 if (IS_ERR(thread->tsk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006643 kfree(thread);
6644 return NULL;
6645 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006646 return thread;
6647}
NeilBrown6c144d32014-09-30 16:15:38 +10006648EXPORT_SYMBOL(md_register_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006649
NeilBrown2b8bf342011-10-11 16:48:23 +11006650void md_unregister_thread(struct md_thread **threadp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006651{
NeilBrown2b8bf342011-10-11 16:48:23 +11006652 struct md_thread *thread = *threadp;
NeilBrowne0cf8f02009-03-31 14:39:39 +11006653 if (!thread)
6654 return;
NeilBrown36a4e1f2011-10-07 14:23:17 +11006655 pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
NeilBrown01f96c02011-09-21 15:30:20 +10006656 /* Locking ensures that mddev_unlock does not wake_up a
6657 * non-existent thread
6658 */
6659 spin_lock(&pers_lock);
6660 *threadp = NULL;
6661 spin_unlock(&pers_lock);
NeilBrowna6fb0932005-09-09 16:23:56 -07006662
6663 kthread_stop(thread->tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006664 kfree(thread);
6665}
NeilBrown6c144d32014-09-30 16:15:38 +10006666EXPORT_SYMBOL(md_unregister_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006667
NeilBrownfd01b882011-10-11 16:47:53 +11006668void md_error(struct mddev *mddev, struct md_rdev *rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006669{
NeilBrownb2d444d2005-11-08 21:39:31 -08006670 if (!rdev || test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07006671 return;
Dan Williams6bfe0b42008-04-30 00:52:32 -07006672
NeilBrownde393cd2011-07-28 11:31:48 +10006673 if (!mddev->pers || !mddev->pers->error_handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006674 return;
6675 mddev->pers->error_handler(mddev,rdev);
Neil Brown72a23c22008-06-28 08:31:41 +10006676 if (mddev->degraded)
6677 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown00bcb4a2010-06-01 19:37:23 +10006678 sysfs_notify_dirent_safe(rdev->sysfs_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006679 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6680 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6681 md_wakeup_thread(mddev->thread);
NeilBrown768a4182010-07-26 11:49:55 +10006682 if (mddev->event_work.func)
Tejun Heoe804ac72010-10-15 15:36:08 +02006683 queue_work(md_misc_wq, &mddev->event_work);
NeilBrownc331eb02006-05-30 21:27:13 -07006684 md_new_event_inintr(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006685}
NeilBrown6c144d32014-09-30 16:15:38 +10006686EXPORT_SYMBOL(md_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006687
6688/* seq_file implementation /proc/mdstat */
6689
6690static void status_unused(struct seq_file *seq)
6691{
6692 int i = 0;
NeilBrown3cb03002011-10-11 16:45:26 +11006693 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006694
6695 seq_printf(seq, "unused devices: ");
6696
Cheng Renquan159ec1f2009-01-09 08:31:08 +11006697 list_for_each_entry(rdev, &pending_raid_disks, same_set) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006698 char b[BDEVNAME_SIZE];
6699 i++;
6700 seq_printf(seq, "%s ",
6701 bdevname(rdev->bdev,b));
6702 }
6703 if (!i)
6704 seq_printf(seq, "<none>");
6705
6706 seq_printf(seq, "\n");
6707}
6708
NeilBrownf72ffdd2014-09-30 14:23:59 +10006709static void status_resync(struct seq_file *seq, struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006710{
NeilBrowndd71cf62009-05-07 12:49:35 +10006711 sector_t max_sectors, resync, res;
6712 unsigned long dt, db;
6713 sector_t rt;
NeilBrown4588b422006-03-27 01:18:04 -08006714 int scale;
6715 unsigned int per_milli;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006716
NeilBrown72f36d52012-10-11 14:25:57 +11006717 if (mddev->curr_resync <= 3)
6718 resync = 0;
6719 else
6720 resync = mddev->curr_resync
6721 - atomic_read(&mddev->recovery_active);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006722
NeilBrownc804cde2012-05-21 09:28:33 +10006723 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
6724 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
NeilBrowndd71cf62009-05-07 12:49:35 +10006725 max_sectors = mddev->resync_max_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006726 else
NeilBrowndd71cf62009-05-07 12:49:35 +10006727 max_sectors = mddev->dev_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006728
NeilBrown403df472014-09-30 15:52:29 +10006729 WARN_ON(max_sectors == 0);
NeilBrown4588b422006-03-27 01:18:04 -08006730 /* Pick 'scale' such that (resync>>scale)*1000 will fit
NeilBrowndd71cf62009-05-07 12:49:35 +10006731 * in a sector_t, and (max_sectors>>scale) will fit in a
NeilBrown4588b422006-03-27 01:18:04 -08006732 * u32, as those are the requirements for sector_div.
6733 * Thus 'scale' must be at least 10
6734 */
6735 scale = 10;
6736 if (sizeof(sector_t) > sizeof(unsigned long)) {
NeilBrowndd71cf62009-05-07 12:49:35 +10006737 while ( max_sectors/2 > (1ULL<<(scale+32)))
NeilBrown4588b422006-03-27 01:18:04 -08006738 scale++;
6739 }
6740 res = (resync>>scale)*1000;
NeilBrowndd71cf62009-05-07 12:49:35 +10006741 sector_div(res, (u32)((max_sectors>>scale)+1));
NeilBrown4588b422006-03-27 01:18:04 -08006742
6743 per_milli = res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006744 {
NeilBrown4588b422006-03-27 01:18:04 -08006745 int i, x = per_milli/50, y = 20-x;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006746 seq_printf(seq, "[");
6747 for (i = 0; i < x; i++)
6748 seq_printf(seq, "=");
6749 seq_printf(seq, ">");
6750 for (i = 0; i < y; i++)
6751 seq_printf(seq, ".");
6752 seq_printf(seq, "] ");
6753 }
NeilBrown4588b422006-03-27 01:18:04 -08006754 seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
NeilBrownccfcc3c2006-03-27 01:18:09 -08006755 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
6756 "reshape" :
NeilBrown61df9d92006-10-03 01:15:57 -07006757 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
6758 "check" :
6759 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
6760 "resync" : "recovery"))),
6761 per_milli/10, per_milli % 10,
NeilBrowndd71cf62009-05-07 12:49:35 +10006762 (unsigned long long) resync/2,
6763 (unsigned long long) max_sectors/2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006764
6765 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07006766 * dt: time from mark until now
6767 * db: blocks written from mark until now
6768 * rt: remaining time
NeilBrowndd71cf62009-05-07 12:49:35 +10006769 *
6770 * rt is a sector_t, so could be 32bit or 64bit.
6771 * So we divide before multiply in case it is 32bit and close
6772 * to the limit.
Lucas De Marchi25985ed2011-03-30 22:57:33 -03006773 * We scale the divisor (db) by 32 to avoid losing precision
NeilBrowndd71cf62009-05-07 12:49:35 +10006774 * near the end of resync when the number of remaining sectors
6775 * is close to 'db'.
6776 * We then divide rt by 32 after multiplying by db to compensate.
6777 * The '+1' avoids division by zero if db is very small.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006778 */
6779 dt = ((jiffies - mddev->resync_mark) / HZ);
6780 if (!dt) dt++;
NeilBrownff4e8d92006-07-10 04:44:16 -07006781 db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
6782 - mddev->resync_mark_cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006783
NeilBrowndd71cf62009-05-07 12:49:35 +10006784 rt = max_sectors - resync; /* number of remaining sectors */
6785 sector_div(rt, db/32+1);
6786 rt *= dt;
6787 rt >>= 5;
6788
6789 seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
6790 ((unsigned long)rt % 60)/6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006791
NeilBrownff4e8d92006-07-10 04:44:16 -07006792 seq_printf(seq, " speed=%ldK/sec", db/2/dt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006793}
6794
6795static void *md_seq_start(struct seq_file *seq, loff_t *pos)
6796{
6797 struct list_head *tmp;
6798 loff_t l = *pos;
NeilBrownfd01b882011-10-11 16:47:53 +11006799 struct mddev *mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006800
6801 if (l >= 0x10000)
6802 return NULL;
6803 if (!l--)
6804 /* header */
6805 return (void*)1;
6806
6807 spin_lock(&all_mddevs_lock);
6808 list_for_each(tmp,&all_mddevs)
6809 if (!l--) {
NeilBrownfd01b882011-10-11 16:47:53 +11006810 mddev = list_entry(tmp, struct mddev, all_mddevs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006811 mddev_get(mddev);
6812 spin_unlock(&all_mddevs_lock);
6813 return mddev;
6814 }
6815 spin_unlock(&all_mddevs_lock);
6816 if (!l--)
6817 return (void*)2;/* tail */
6818 return NULL;
6819}
6820
6821static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
6822{
6823 struct list_head *tmp;
NeilBrownfd01b882011-10-11 16:47:53 +11006824 struct mddev *next_mddev, *mddev = v;
NeilBrownf72ffdd2014-09-30 14:23:59 +10006825
Linus Torvalds1da177e2005-04-16 15:20:36 -07006826 ++*pos;
6827 if (v == (void*)2)
6828 return NULL;
6829
6830 spin_lock(&all_mddevs_lock);
6831 if (v == (void*)1)
6832 tmp = all_mddevs.next;
6833 else
6834 tmp = mddev->all_mddevs.next;
6835 if (tmp != &all_mddevs)
NeilBrownfd01b882011-10-11 16:47:53 +11006836 next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
Linus Torvalds1da177e2005-04-16 15:20:36 -07006837 else {
6838 next_mddev = (void*)2;
6839 *pos = 0x10000;
NeilBrownf72ffdd2014-09-30 14:23:59 +10006840 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07006841 spin_unlock(&all_mddevs_lock);
6842
6843 if (v != (void*)1)
6844 mddev_put(mddev);
6845 return next_mddev;
6846
6847}
6848
6849static void md_seq_stop(struct seq_file *seq, void *v)
6850{
NeilBrownfd01b882011-10-11 16:47:53 +11006851 struct mddev *mddev = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006852
6853 if (mddev && v != (void*)1 && v != (void*)2)
6854 mddev_put(mddev);
6855}
6856
6857static int md_seq_show(struct seq_file *seq, void *v)
6858{
NeilBrownfd01b882011-10-11 16:47:53 +11006859 struct mddev *mddev = v;
Andre Nolldd8ac332009-03-31 14:33:13 +11006860 sector_t sectors;
NeilBrown3cb03002011-10-11 16:45:26 +11006861 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006862
6863 if (v == (void*)1) {
NeilBrown84fc4b52011-10-11 16:49:58 +11006864 struct md_personality *pers;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006865 seq_printf(seq, "Personalities : ");
6866 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08006867 list_for_each_entry(pers, &pers_list, list)
6868 seq_printf(seq, "[%s] ", pers->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006869
6870 spin_unlock(&pers_lock);
6871 seq_printf(seq, "\n");
Kay Sieversf1514632011-07-12 20:48:39 +02006872 seq->poll_event = atomic_read(&md_event_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006873 return 0;
6874 }
6875 if (v == (void*)2) {
6876 status_unused(seq);
6877 return 0;
6878 }
6879
Ingo Molnar5dc5cf72006-04-20 02:43:23 -07006880 if (mddev_lock(mddev) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006881 return -EINTR;
Ingo Molnar5dc5cf72006-04-20 02:43:23 -07006882
Linus Torvalds1da177e2005-04-16 15:20:36 -07006883 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
6884 seq_printf(seq, "%s : %sactive", mdname(mddev),
6885 mddev->pers ? "" : "in");
6886 if (mddev->pers) {
NeilBrownf91de922005-11-08 21:39:36 -08006887 if (mddev->ro==1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006888 seq_printf(seq, " (read-only)");
NeilBrownf91de922005-11-08 21:39:36 -08006889 if (mddev->ro==2)
NeilBrown52720ae2008-03-10 11:43:47 -07006890 seq_printf(seq, " (auto-read-only)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07006891 seq_printf(seq, " %s", mddev->pers->name);
6892 }
6893
Andre Nolldd8ac332009-03-31 14:33:13 +11006894 sectors = 0;
NeilBrowndafb20f2012-03-19 12:46:39 +11006895 rdev_for_each(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006896 char b[BDEVNAME_SIZE];
6897 seq_printf(seq, " %s[%d]",
6898 bdevname(rdev->bdev,b), rdev->desc_nr);
NeilBrown8ddf9ef2005-09-09 16:23:45 -07006899 if (test_bit(WriteMostly, &rdev->flags))
6900 seq_printf(seq, "(W)");
NeilBrownb2d444d2005-11-08 21:39:31 -08006901 if (test_bit(Faulty, &rdev->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006902 seq_printf(seq, "(F)");
6903 continue;
NeilBrown2d78f8c2011-12-23 10:17:51 +11006904 }
6905 if (rdev->raid_disk < 0)
NeilBrownb325a322005-09-09 16:24:00 -07006906 seq_printf(seq, "(S)"); /* spare */
NeilBrown2d78f8c2011-12-23 10:17:51 +11006907 if (test_bit(Replacement, &rdev->flags))
6908 seq_printf(seq, "(R)");
Andre Nolldd8ac332009-03-31 14:33:13 +11006909 sectors += rdev->sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006910 }
6911
6912 if (!list_empty(&mddev->disks)) {
6913 if (mddev->pers)
6914 seq_printf(seq, "\n %llu blocks",
Andre Nollf233ea52008-07-21 17:05:22 +10006915 (unsigned long long)
6916 mddev->array_sectors / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006917 else
6918 seq_printf(seq, "\n %llu blocks",
Andre Nolldd8ac332009-03-31 14:33:13 +11006919 (unsigned long long)sectors / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006920 }
NeilBrown1cd6bf12005-09-09 16:24:00 -07006921 if (mddev->persistent) {
6922 if (mddev->major_version != 0 ||
6923 mddev->minor_version != 90) {
6924 seq_printf(seq," super %d.%d",
6925 mddev->major_version,
6926 mddev->minor_version);
6927 }
NeilBrowne6910632008-02-06 01:39:51 -08006928 } else if (mddev->external)
6929 seq_printf(seq, " super external:%s",
6930 mddev->metadata_type);
6931 else
NeilBrown1cd6bf12005-09-09 16:24:00 -07006932 seq_printf(seq, " super non-persistent");
Linus Torvalds1da177e2005-04-16 15:20:36 -07006933
6934 if (mddev->pers) {
NeilBrownd710e132008-10-13 11:55:12 +11006935 mddev->pers->status(seq, mddev);
NeilBrownf72ffdd2014-09-30 14:23:59 +10006936 seq_printf(seq, "\n ");
NeilBrown8e1b39d2005-11-08 21:39:41 -08006937 if (mddev->pers->sync_request) {
6938 if (mddev->curr_resync > 2) {
NeilBrownd710e132008-10-13 11:55:12 +11006939 status_resync(seq, mddev);
NeilBrown8e1b39d2005-11-08 21:39:41 -08006940 seq_printf(seq, "\n ");
NeilBrown72f36d52012-10-11 14:25:57 +11006941 } else if (mddev->curr_resync >= 1)
NeilBrown8e1b39d2005-11-08 21:39:41 -08006942 seq_printf(seq, "\tresync=DELAYED\n ");
6943 else if (mddev->recovery_cp < MaxSector)
6944 seq_printf(seq, "\tresync=PENDING\n ");
6945 }
NeilBrown32a76272005-06-21 17:17:14 -07006946 } else
6947 seq_printf(seq, "\n ");
6948
NeilBrown57148962012-03-19 12:46:40 +11006949 bitmap_status(seq, mddev->bitmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006950
6951 seq_printf(seq, "\n");
6952 }
6953 mddev_unlock(mddev);
NeilBrownf72ffdd2014-09-30 14:23:59 +10006954
Linus Torvalds1da177e2005-04-16 15:20:36 -07006955 return 0;
6956}
6957
Jan Engelhardt110518b2009-05-07 12:49:37 +10006958static const struct seq_operations md_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07006959 .start = md_seq_start,
6960 .next = md_seq_next,
6961 .stop = md_seq_stop,
6962 .show = md_seq_show,
6963};
6964
6965static int md_seq_open(struct inode *inode, struct file *file)
6966{
Kay Sieversf1514632011-07-12 20:48:39 +02006967 struct seq_file *seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006968 int error;
6969
6970 error = seq_open(file, &md_seq_ops);
NeilBrownd7603b72006-01-06 00:20:30 -08006971 if (error)
Kay Sieversf1514632011-07-12 20:48:39 +02006972 return error;
6973
6974 seq = file->private_data;
6975 seq->poll_event = atomic_read(&md_event_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006976 return error;
6977}
6978
NeilBrowne2f23b62014-04-09 14:33:51 +10006979static int md_unloading;
NeilBrownd7603b72006-01-06 00:20:30 -08006980static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
6981{
Kay Sieversf1514632011-07-12 20:48:39 +02006982 struct seq_file *seq = filp->private_data;
NeilBrownd7603b72006-01-06 00:20:30 -08006983 int mask;
6984
NeilBrowne2f23b62014-04-09 14:33:51 +10006985 if (md_unloading)
kbuild test robot7d7e64f2014-12-03 16:07:59 +11006986 return POLLIN|POLLRDNORM|POLLERR|POLLPRI;
NeilBrownd7603b72006-01-06 00:20:30 -08006987 poll_wait(filp, &md_event_waiters, wait);
6988
6989 /* always allow read */
6990 mask = POLLIN | POLLRDNORM;
6991
Kay Sieversf1514632011-07-12 20:48:39 +02006992 if (seq->poll_event != atomic_read(&md_event_count))
NeilBrownd7603b72006-01-06 00:20:30 -08006993 mask |= POLLERR | POLLPRI;
6994 return mask;
6995}
6996
Arjan van de Venfa027c22007-02-12 00:55:33 -08006997static const struct file_operations md_seq_fops = {
Akinobu Mitae24650c2006-10-17 00:09:38 -07006998 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07006999 .open = md_seq_open,
7000 .read = seq_read,
7001 .llseek = seq_lseek,
Martin Peschkec3f94b402007-05-09 02:35:35 -07007002 .release = seq_release_private,
NeilBrownd7603b72006-01-06 00:20:30 -08007003 .poll = mdstat_poll,
Linus Torvalds1da177e2005-04-16 15:20:36 -07007004};
7005
NeilBrown84fc4b52011-10-11 16:49:58 +11007006int register_md_personality(struct md_personality *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007007{
Chao Yu50bd3772014-09-25 15:28:34 +08007008 printk(KERN_INFO "md: %s personality registered for level %d\n",
7009 p->name, p->level);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007010 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08007011 list_add_tail(&p->list, &pers_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007012 spin_unlock(&pers_lock);
7013 return 0;
7014}
NeilBrown6c144d32014-09-30 16:15:38 +10007015EXPORT_SYMBOL(register_md_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007016
NeilBrown84fc4b52011-10-11 16:49:58 +11007017int unregister_md_personality(struct md_personality *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007018{
NeilBrown2604b702006-01-06 00:20:36 -08007019 printk(KERN_INFO "md: %s personality unregistered\n", p->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007020 spin_lock(&pers_lock);
NeilBrown2604b702006-01-06 00:20:36 -08007021 list_del_init(&p->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007022 spin_unlock(&pers_lock);
7023 return 0;
7024}
NeilBrown6c144d32014-09-30 16:15:38 +10007025EXPORT_SYMBOL(unregister_md_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007026
NeilBrownfd01b882011-10-11 16:47:53 +11007027static int is_mddev_idle(struct mddev *mddev, int init)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007028{
NeilBrownf72ffdd2014-09-30 14:23:59 +10007029 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007030 int idle;
NeilBrowneea1bf32009-03-31 14:27:02 +11007031 int curr_events;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007032
7033 idle = 1;
NeilBrown4b809912008-07-21 17:05:25 +10007034 rcu_read_lock();
7035 rdev_for_each_rcu(rdev, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007036 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
NeilBrowneea1bf32009-03-31 14:27:02 +11007037 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
7038 (int)part_stat_read(&disk->part0, sectors[1]) -
7039 atomic_read(&disk->sync_io);
NeilBrown713f6ab2007-07-17 04:06:12 -07007040 /* sync IO will cause sync_io to increase before the disk_stats
7041 * as sync_io is counted when a request starts, and
7042 * disk_stats is counted when it completes.
7043 * So resync activity will cause curr_events to be smaller than
7044 * when there was no such activity.
7045 * non-sync IO will cause disk_stat to increase without
7046 * increasing sync_io so curr_events will (eventually)
7047 * be larger than it was before. Once it becomes
7048 * substantially larger, the test below will cause
7049 * the array to appear non-idle, and resync will slow
7050 * down.
7051 * If there is a lot of outstanding resync activity when
7052 * we set last_event to curr_events, then all that activity
7053 * completing might cause the array to appear non-idle
7054 * and resync will be slowed down even though there might
7055 * not have been non-resync activity. This will only
7056 * happen once though. 'last_events' will soon reflect
7057 * the state where there is little or no outstanding
7058 * resync requests, and further resync activity will
7059 * always make curr_events less than last_events.
NeilBrownc0e48522005-11-18 01:11:01 -08007060 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07007061 */
NeilBrowneea1bf32009-03-31 14:27:02 +11007062 if (init || curr_events - rdev->last_events > 64) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007063 rdev->last_events = curr_events;
7064 idle = 0;
7065 }
7066 }
NeilBrown4b809912008-07-21 17:05:25 +10007067 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07007068 return idle;
7069}
7070
NeilBrownfd01b882011-10-11 16:47:53 +11007071void md_done_sync(struct mddev *mddev, int blocks, int ok)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007072{
7073 /* another "blocks" (512byte) blocks have been synced */
7074 atomic_sub(blocks, &mddev->recovery_active);
7075 wake_up(&mddev->recovery_wait);
7076 if (!ok) {
NeilBrowndfc70642008-05-23 13:04:39 -07007077 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
majianpeng0a19caa2012-11-19 19:57:34 +08007078 set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007079 md_wakeup_thread(mddev->thread);
7080 // stop recovery, signal do_sync ....
7081 }
7082}
NeilBrown6c144d32014-09-30 16:15:38 +10007083EXPORT_SYMBOL(md_done_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007084
NeilBrown06d91a52005-06-21 17:17:12 -07007085/* md_write_start(mddev, bi)
7086 * If we need to update some array metadata (e.g. 'active' flag
NeilBrown3d310eb2005-06-21 17:17:26 -07007087 * in superblock) before writing, schedule a superblock update
7088 * and wait for it to complete.
NeilBrown06d91a52005-06-21 17:17:12 -07007089 */
NeilBrownfd01b882011-10-11 16:47:53 +11007090void md_write_start(struct mddev *mddev, struct bio *bi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007091{
Neil Brown0fd62b82008-06-28 08:31:36 +10007092 int did_change = 0;
NeilBrown06d91a52005-06-21 17:17:12 -07007093 if (bio_data_dir(bi) != WRITE)
NeilBrown3d310eb2005-06-21 17:17:26 -07007094 return;
NeilBrown06d91a52005-06-21 17:17:12 -07007095
NeilBrownf91de922005-11-08 21:39:36 -08007096 BUG_ON(mddev->ro == 1);
7097 if (mddev->ro == 2) {
7098 /* need to switch to read/write */
7099 mddev->ro = 0;
7100 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7101 md_wakeup_thread(mddev->thread);
NeilBrown25156192008-03-04 14:29:32 -08007102 md_wakeup_thread(mddev->sync_thread);
Neil Brown0fd62b82008-06-28 08:31:36 +10007103 did_change = 1;
NeilBrownf91de922005-11-08 21:39:36 -08007104 }
NeilBrown06d91a52005-06-21 17:17:12 -07007105 atomic_inc(&mddev->writes_pending);
NeilBrown31a59e32008-04-30 00:52:30 -07007106 if (mddev->safemode == 1)
7107 mddev->safemode = 0;
NeilBrown06d91a52005-06-21 17:17:12 -07007108 if (mddev->in_sync) {
NeilBrowna9701a32005-11-08 21:39:34 -08007109 spin_lock_irq(&mddev->write_lock);
NeilBrown3d310eb2005-06-21 17:17:26 -07007110 if (mddev->in_sync) {
7111 mddev->in_sync = 0;
NeilBrown850b2b42006-10-03 01:15:46 -07007112 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown070dc6d2010-08-30 17:33:34 +10007113 set_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrown3d310eb2005-06-21 17:17:26 -07007114 md_wakeup_thread(mddev->thread);
Neil Brown0fd62b82008-06-28 08:31:36 +10007115 did_change = 1;
NeilBrown3d310eb2005-06-21 17:17:26 -07007116 }
NeilBrowna9701a32005-11-08 21:39:34 -08007117 spin_unlock_irq(&mddev->write_lock);
NeilBrown06d91a52005-06-21 17:17:12 -07007118 }
Neil Brown0fd62b82008-06-28 08:31:36 +10007119 if (did_change)
NeilBrown00bcb4a2010-06-01 19:37:23 +10007120 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown09a44cc2008-05-23 13:04:36 -07007121 wait_event(mddev->sb_wait,
NeilBrown09a44cc2008-05-23 13:04:36 -07007122 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07007123}
NeilBrown6c144d32014-09-30 16:15:38 +10007124EXPORT_SYMBOL(md_write_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007125
NeilBrownfd01b882011-10-11 16:47:53 +11007126void md_write_end(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007127{
7128 if (atomic_dec_and_test(&mddev->writes_pending)) {
7129 if (mddev->safemode == 2)
7130 md_wakeup_thread(mddev->thread);
NeilBrown16f17b32006-06-26 00:27:37 -07007131 else if (mddev->safemode_delay)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007132 mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
7133 }
7134}
NeilBrown6c144d32014-09-30 16:15:38 +10007135EXPORT_SYMBOL(md_write_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007136
NeilBrown2a2275d2007-01-26 00:57:11 -08007137/* md_allow_write(mddev)
7138 * Calling this ensures that the array is marked 'active' so that writes
7139 * may proceed without blocking. It is important to call this before
7140 * attempting a GFP_KERNEL allocation while holding the mddev lock.
7141 * Must be called with mddev_lock held.
Dan Williamsb5470dc2008-06-27 21:44:04 -07007142 *
7143 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
7144 * is dropped, so return -EAGAIN after notifying userspace.
NeilBrown2a2275d2007-01-26 00:57:11 -08007145 */
NeilBrownfd01b882011-10-11 16:47:53 +11007146int md_allow_write(struct mddev *mddev)
NeilBrown2a2275d2007-01-26 00:57:11 -08007147{
7148 if (!mddev->pers)
Dan Williamsb5470dc2008-06-27 21:44:04 -07007149 return 0;
NeilBrown2a2275d2007-01-26 00:57:11 -08007150 if (mddev->ro)
Dan Williamsb5470dc2008-06-27 21:44:04 -07007151 return 0;
Neil Brown1a0fd492008-06-28 08:31:27 +10007152 if (!mddev->pers->sync_request)
Dan Williamsb5470dc2008-06-27 21:44:04 -07007153 return 0;
NeilBrown2a2275d2007-01-26 00:57:11 -08007154
7155 spin_lock_irq(&mddev->write_lock);
7156 if (mddev->in_sync) {
7157 mddev->in_sync = 0;
7158 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown070dc6d2010-08-30 17:33:34 +10007159 set_bit(MD_CHANGE_PENDING, &mddev->flags);
NeilBrown2a2275d2007-01-26 00:57:11 -08007160 if (mddev->safemode_delay &&
7161 mddev->safemode == 0)
7162 mddev->safemode = 1;
7163 spin_unlock_irq(&mddev->write_lock);
7164 md_update_sb(mddev, 0);
NeilBrown00bcb4a2010-06-01 19:37:23 +10007165 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrown2a2275d2007-01-26 00:57:11 -08007166 } else
7167 spin_unlock_irq(&mddev->write_lock);
Dan Williamsb5470dc2008-06-27 21:44:04 -07007168
NeilBrown070dc6d2010-08-30 17:33:34 +10007169 if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
Dan Williamsb5470dc2008-06-27 21:44:04 -07007170 return -EAGAIN;
7171 else
7172 return 0;
NeilBrown2a2275d2007-01-26 00:57:11 -08007173}
7174EXPORT_SYMBOL_GPL(md_allow_write);
7175
Linus Torvalds1da177e2005-04-16 15:20:36 -07007176#define SYNC_MARKS 10
7177#define SYNC_MARK_STEP (3*HZ)
majianpeng54f89342012-10-31 11:59:10 +11007178#define UPDATE_FREQUENCY (5*60*HZ)
Shaohua Li4ed87312012-10-11 13:34:00 +11007179void md_do_sync(struct md_thread *thread)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007180{
Shaohua Li4ed87312012-10-11 13:34:00 +11007181 struct mddev *mddev = thread->mddev;
NeilBrownfd01b882011-10-11 16:47:53 +11007182 struct mddev *mddev2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007183 unsigned int currspeed = 0,
7184 window;
Xiao Niac7e50a2014-08-07 09:37:41 -04007185 sector_t max_sectors,j, io_sectors, recovery_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007186 unsigned long mark[SYNC_MARKS];
majianpeng54f89342012-10-31 11:59:10 +11007187 unsigned long update_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007188 sector_t mark_cnt[SYNC_MARKS];
7189 int last_mark,m;
7190 struct list_head *tmp;
7191 sector_t last_check;
NeilBrown57afd892005-06-21 17:17:13 -07007192 int skipped = 0;
NeilBrown3cb03002011-10-11 16:45:26 +11007193 struct md_rdev *rdev;
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007194 char *desc, *action = NULL;
majianpeng7c2c57c2012-07-03 12:12:26 +10007195 struct blk_plug plug;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007196
7197 /* just incase thread restarts... */
7198 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7199 return;
NeilBrown3991b312014-05-28 13:39:23 +10007200 if (mddev->ro) {/* never try to sync a read-only array */
7201 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007202 return;
NeilBrown3991b312014-05-28 13:39:23 +10007203 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007204
NeilBrown61df9d92006-10-03 01:15:57 -07007205 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007206 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
NeilBrown61df9d92006-10-03 01:15:57 -07007207 desc = "data-check";
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007208 action = "check";
7209 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
NeilBrown61df9d92006-10-03 01:15:57 -07007210 desc = "requested-resync";
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007211 action = "repair";
7212 } else
NeilBrown61df9d92006-10-03 01:15:57 -07007213 desc = "resync";
7214 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7215 desc = "reshape";
7216 else
7217 desc = "recovery";
7218
Jonathan Brassowc4a39552013-06-25 01:23:59 -05007219 mddev->last_sync_action = action ?: desc;
7220
Linus Torvalds1da177e2005-04-16 15:20:36 -07007221 /* we overload curr_resync somewhat here.
7222 * 0 == not engaged in resync at all
7223 * 2 == checking that there is no conflict with another sync
7224 * 1 == like 2, but have yielded to allow conflicting resync to
7225 * commense
7226 * other == active in resync - this many blocks
7227 *
7228 * Before starting a resync we must have set curr_resync to
7229 * 2, and then checked that every "conflicting" array has curr_resync
7230 * less than ours. When we find one that is the same or higher
7231 * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
7232 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
7233 * This will mean we have to start checking from the beginning again.
7234 *
7235 */
7236
7237 do {
7238 mddev->curr_resync = 2;
7239
7240 try_again:
NeilBrown404e4b42009-12-30 15:25:23 +11007241 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
Linus Torvalds1da177e2005-04-16 15:20:36 -07007242 goto skip;
NeilBrown29ac4aa2008-02-06 01:39:58 -08007243 for_each_mddev(mddev2, tmp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007244 if (mddev2 == mddev)
7245 continue;
Bernd Schubert90b08712008-05-23 13:04:38 -07007246 if (!mddev->parallel_resync
7247 && mddev2->curr_resync
7248 && match_mddev_units(mddev, mddev2)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007249 DEFINE_WAIT(wq);
7250 if (mddev < mddev2 && mddev->curr_resync == 2) {
7251 /* arbitrarily yield */
7252 mddev->curr_resync = 1;
7253 wake_up(&resync_wait);
7254 }
7255 if (mddev > mddev2 && mddev->curr_resync == 1)
7256 /* no need to wait here, we can wait the next
7257 * time 'round when curr_resync == 2
7258 */
7259 continue;
NeilBrown97441972008-09-19 11:49:54 +10007260 /* We need to wait 'interruptible' so as not to
7261 * contribute to the load average, and not to
7262 * be caught by 'softlockup'
7263 */
7264 prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
NeilBrownc91abf52013-11-19 12:02:01 +11007265 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
NeilBrown8712e552005-10-26 01:58:58 -07007266 mddev2->curr_resync >= mddev->curr_resync) {
NeilBrown61df9d92006-10-03 01:15:57 -07007267 printk(KERN_INFO "md: delaying %s of %s"
7268 " until %s has finished (they"
Linus Torvalds1da177e2005-04-16 15:20:36 -07007269 " share one or more physical units)\n",
NeilBrown61df9d92006-10-03 01:15:57 -07007270 desc, mdname(mddev), mdname(mddev2));
Linus Torvalds1da177e2005-04-16 15:20:36 -07007271 mddev_put(mddev2);
NeilBrown97441972008-09-19 11:49:54 +10007272 if (signal_pending(current))
7273 flush_signals(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007274 schedule();
7275 finish_wait(&resync_wait, &wq);
7276 goto try_again;
7277 }
7278 finish_wait(&resync_wait, &wq);
7279 }
7280 }
7281 } while (mddev->curr_resync < 2);
7282
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007283 j = 0;
NeilBrown9d888832005-11-08 21:39:26 -08007284 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007285 /* resync follows the size requested by the personality,
NeilBrown57afd892005-06-21 17:17:13 -07007286 * which defaults to physical size, but can be virtual size
Linus Torvalds1da177e2005-04-16 15:20:36 -07007287 */
7288 max_sectors = mddev->resync_max_sectors;
Jianpeng Ma7f7583d2012-10-11 14:17:59 +11007289 atomic64_set(&mddev->resync_mismatches, 0);
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007290 /* we don't use the checkpoint if there's a bitmap */
Neil Brown5e96ee62008-06-28 08:31:24 +10007291 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7292 j = mddev->resync_min;
7293 else if (!mddev->bitmap)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007294 j = mddev->recovery_cp;
Neil Brown5e96ee62008-06-28 08:31:24 +10007295
NeilBrownccfcc3c2006-03-27 01:18:09 -08007296 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
NeilBrownc804cde2012-05-21 09:28:33 +10007297 max_sectors = mddev->resync_max_sectors;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007298 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07007299 /* recovery follows the physical size of devices */
Andre Noll58c0fed2009-03-31 14:33:13 +11007300 max_sectors = mddev->dev_sectors;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007301 j = MaxSector;
Dan Williams4e59ca72009-12-12 21:17:06 -07007302 rcu_read_lock();
NeilBrowndafb20f2012-03-19 12:46:39 +11007303 rdev_for_each_rcu(rdev, mddev)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007304 if (rdev->raid_disk >= 0 &&
7305 !test_bit(Faulty, &rdev->flags) &&
7306 !test_bit(In_sync, &rdev->flags) &&
7307 rdev->recovery_offset < j)
7308 j = rdev->recovery_offset;
Dan Williams4e59ca72009-12-12 21:17:06 -07007309 rcu_read_unlock();
NeilBrown133d4522014-07-02 12:04:14 +10007310
7311 /* If there is a bitmap, we need to make sure all
7312 * writes that started before we added a spare
7313 * complete before we start doing a recovery.
7314 * Otherwise the write might complete and (via
7315 * bitmap_endwrite) set a bit in the bitmap after the
7316 * recovery has checked that bit and skipped that
7317 * region.
7318 */
7319 if (mddev->bitmap) {
7320 mddev->pers->quiesce(mddev, 1);
7321 mddev->pers->quiesce(mddev, 0);
7322 }
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007323 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007324
NeilBrown61df9d92006-10-03 01:15:57 -07007325 printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
7326 printk(KERN_INFO "md: minimum _guaranteed_ speed:"
7327 " %d KB/sec/disk.\n", speed_min(mddev));
Adrian Bunk338cec32005-09-10 00:26:54 -07007328 printk(KERN_INFO "md: using maximum available idle IO bandwidth "
NeilBrown61df9d92006-10-03 01:15:57 -07007329 "(but not more than %d KB/sec) for %s.\n",
7330 speed_max(mddev), desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007331
NeilBrowneea1bf32009-03-31 14:27:02 +11007332 is_mddev_idle(mddev, 1); /* this initializes IO event counters */
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007333
NeilBrown57afd892005-06-21 17:17:13 -07007334 io_sectors = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007335 for (m = 0; m < SYNC_MARKS; m++) {
7336 mark[m] = jiffies;
NeilBrown57afd892005-06-21 17:17:13 -07007337 mark_cnt[m] = io_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007338 }
7339 last_mark = 0;
7340 mddev->resync_mark = mark[last_mark];
7341 mddev->resync_mark_cnt = mark_cnt[last_mark];
7342
7343 /*
7344 * Tune reconstruction:
7345 */
7346 window = 32*(PAGE_SIZE/512);
Jonathan Brassowac424502011-06-07 17:48:35 -05007347 printk(KERN_INFO "md: using %dk window, over a total of %lluk.\n",
7348 window/2, (unsigned long long)max_sectors/2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007349
7350 atomic_set(&mddev->recovery_active, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007351 last_check = 0;
7352
7353 if (j>2) {
NeilBrownc91abf52013-11-19 12:02:01 +11007354 printk(KERN_INFO
NeilBrown61df9d92006-10-03 01:15:57 -07007355 "md: resuming %s of %s from checkpoint.\n",
7356 desc, mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07007357 mddev->curr_resync = j;
NeilBrown72f36d52012-10-11 14:25:57 +11007358 } else
7359 mddev->curr_resync = 3; /* no longer delayed */
NeilBrown75d3da42011-01-14 09:14:34 +11007360 mddev->curr_resync_completed = j;
NeilBrown72f36d52012-10-11 14:25:57 +11007361 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
7362 md_new_event(mddev);
majianpeng54f89342012-10-31 11:59:10 +11007363 update_time = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007364
majianpeng7c2c57c2012-07-03 12:12:26 +10007365 blk_start_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007366 while (j < max_sectors) {
NeilBrown57afd892005-06-21 17:17:13 -07007367 sector_t sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007368
NeilBrown57afd892005-06-21 17:17:13 -07007369 skipped = 0;
NeilBrown97e4f422009-03-31 14:33:13 +11007370
NeilBrown7a91ee12009-05-26 12:57:21 +10007371 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7372 ((mddev->curr_resync > mddev->curr_resync_completed &&
7373 (mddev->curr_resync - mddev->curr_resync_completed)
7374 > (max_sectors >> 4)) ||
majianpeng54f89342012-10-31 11:59:10 +11007375 time_after_eq(jiffies, update_time + UPDATE_FREQUENCY) ||
NeilBrown7a91ee12009-05-26 12:57:21 +10007376 (j - mddev->curr_resync_completed)*2
7377 >= mddev->resync_max - mddev->curr_resync_completed
7378 )) {
NeilBrown97e4f422009-03-31 14:33:13 +11007379 /* time to update curr_resync_completed */
NeilBrown97e4f422009-03-31 14:33:13 +11007380 wait_event(mddev->recovery_wait,
7381 atomic_read(&mddev->recovery_active) == 0);
NeilBrown75d3da42011-01-14 09:14:34 +11007382 mddev->curr_resync_completed = j;
kernelmail35d78c62012-10-31 11:59:10 +11007383 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
7384 j > mddev->recovery_cp)
7385 mddev->recovery_cp = j;
majianpeng54f89342012-10-31 11:59:10 +11007386 update_time = jiffies;
NeilBrown070dc6d2010-08-30 17:33:34 +10007387 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrownacb180b2009-04-14 16:28:34 +10007388 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
NeilBrown97e4f422009-03-31 14:33:13 +11007389 }
NeilBrownacb180b2009-04-14 16:28:34 +10007390
NeilBrownc91abf52013-11-19 12:02:01 +11007391 while (j >= mddev->resync_max &&
7392 !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
NeilBrowne62e58a2009-07-01 13:15:35 +10007393 /* As this condition is controlled by user-space,
7394 * we can block indefinitely, so use '_interruptible'
7395 * to avoid triggering warnings.
7396 */
7397 flush_signals(current); /* just in case */
7398 wait_event_interruptible(mddev->recovery_wait,
7399 mddev->resync_max > j
NeilBrownc91abf52013-11-19 12:02:01 +11007400 || test_bit(MD_RECOVERY_INTR,
7401 &mddev->recovery));
NeilBrowne62e58a2009-07-01 13:15:35 +10007402 }
NeilBrownacb180b2009-04-14 16:28:34 +10007403
NeilBrownc91abf52013-11-19 12:02:01 +11007404 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7405 break;
NeilBrownacb180b2009-04-14 16:28:34 +10007406
NeilBrown57afd892005-06-21 17:17:13 -07007407 sectors = mddev->pers->sync_request(mddev, j, &skipped,
NeilBrownc6207272008-02-06 01:39:52 -08007408 currspeed < speed_min(mddev));
NeilBrown57afd892005-06-21 17:17:13 -07007409 if (sectors == 0) {
NeilBrowndfc70642008-05-23 13:04:39 -07007410 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrownc91abf52013-11-19 12:02:01 +11007411 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007412 }
NeilBrown57afd892005-06-21 17:17:13 -07007413
7414 if (!skipped) { /* actual IO requested */
7415 io_sectors += sectors;
7416 atomic_add(sectors, &mddev->recovery_active);
7417 }
7418
NeilBrowne875ece2011-07-28 11:39:24 +10007419 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7420 break;
7421
Linus Torvalds1da177e2005-04-16 15:20:36 -07007422 j += sectors;
NeilBrown72f36d52012-10-11 14:25:57 +11007423 if (j > 2)
7424 mddev->curr_resync = j;
NeilBrownff4e8d92006-07-10 04:44:16 -07007425 mddev->curr_mark_cnt = io_sectors;
NeilBrownd7603b72006-01-06 00:20:30 -08007426 if (last_check == 0)
NeilBrowne875ece2011-07-28 11:39:24 +10007427 /* this is the earliest that rebuild will be
NeilBrownd7603b72006-01-06 00:20:30 -08007428 * visible in /proc/mdstat
7429 */
7430 md_new_event(mddev);
NeilBrown57afd892005-06-21 17:17:13 -07007431
7432 if (last_check + window > io_sectors || j == max_sectors)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007433 continue;
7434
NeilBrown57afd892005-06-21 17:17:13 -07007435 last_check = io_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007436 repeat:
7437 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
7438 /* step marks */
7439 int next = (last_mark+1) % SYNC_MARKS;
7440
7441 mddev->resync_mark = mark[next];
7442 mddev->resync_mark_cnt = mark_cnt[next];
7443 mark[next] = jiffies;
NeilBrown57afd892005-06-21 17:17:13 -07007444 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007445 last_mark = next;
7446 }
7447
NeilBrownc91abf52013-11-19 12:02:01 +11007448 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7449 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007450
7451 /*
7452 * this loop exits only if either when we are slower than
7453 * the 'hard' speed limit, or the system was IO-idle for
7454 * a jiffy.
7455 * the system might be non-idle CPU-wise, but we only care
7456 * about not overloading the IO subsystem. (things like an
7457 * e2fsck being done on the RAID array should execute fast)
7458 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07007459 cond_resched();
7460
Xiao Niac7e50a2014-08-07 09:37:41 -04007461 recovery_done = io_sectors - atomic_read(&mddev->recovery_active);
7462 currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2
NeilBrown57afd892005-06-21 17:17:13 -07007463 /((jiffies-mddev->resync_mark)/HZ +1) +1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007464
NeilBrown88202a02006-01-06 00:21:36 -08007465 if (currspeed > speed_min(mddev)) {
7466 if ((currspeed > speed_max(mddev)) ||
NeilBrowneea1bf32009-03-31 14:27:02 +11007467 !is_mddev_idle(mddev, 0)) {
NeilBrownc0e48522005-11-18 01:11:01 -08007468 msleep(500);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007469 goto repeat;
7470 }
7471 }
7472 }
NeilBrownc91abf52013-11-19 12:02:01 +11007473 printk(KERN_INFO "md: %s: %s %s.\n",mdname(mddev), desc,
7474 test_bit(MD_RECOVERY_INTR, &mddev->recovery)
7475 ? "interrupted" : "done");
Linus Torvalds1da177e2005-04-16 15:20:36 -07007476 /*
7477 * this also signals 'finished resyncing' to md_stop
7478 */
majianpeng7c2c57c2012-07-03 12:12:26 +10007479 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007480 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
7481
7482 /* tell personality that we are finished */
NeilBrown57afd892005-06-21 17:17:13 -07007483 mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007484
NeilBrowndfc70642008-05-23 13:04:39 -07007485 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007486 mddev->curr_resync > 2) {
7487 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7488 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
7489 if (mddev->curr_resync >= mddev->recovery_cp) {
7490 printk(KERN_INFO
NeilBrown61df9d92006-10-03 01:15:57 -07007491 "md: checkpointing %s of %s.\n",
7492 desc, mdname(mddev));
majianpeng0a19caa2012-11-19 19:57:34 +08007493 if (test_bit(MD_RECOVERY_ERROR,
7494 &mddev->recovery))
7495 mddev->recovery_cp =
7496 mddev->curr_resync_completed;
7497 else
7498 mddev->recovery_cp =
7499 mddev->curr_resync;
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007500 }
7501 } else
7502 mddev->recovery_cp = MaxSector;
7503 } else {
7504 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7505 mddev->curr_resync = MaxSector;
Dan Williams4e59ca72009-12-12 21:17:06 -07007506 rcu_read_lock();
NeilBrowndafb20f2012-03-19 12:46:39 +11007507 rdev_for_each_rcu(rdev, mddev)
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007508 if (rdev->raid_disk >= 0 &&
NeilBrown70fffd02010-06-16 17:01:25 +10007509 mddev->delta_disks >= 0 &&
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007510 !test_bit(Faulty, &rdev->flags) &&
7511 !test_bit(In_sync, &rdev->flags) &&
7512 rdev->recovery_offset < mddev->curr_resync)
7513 rdev->recovery_offset = mddev->curr_resync;
Dan Williams4e59ca72009-12-12 21:17:06 -07007514 rcu_read_unlock();
NeilBrown5fd6c1d2006-06-26 00:27:40 -07007515 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07007516 }
NeilBrowndb91ff552012-02-07 12:01:51 +11007517 skip:
NeilBrown17571282006-12-10 02:20:52 -08007518 set_bit(MD_CHANGE_DEVS, &mddev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007519
NeilBrownc07b70a2009-12-14 12:49:48 +11007520 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
7521 /* We completed so min/max setting can be forgotten if used. */
7522 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7523 mddev->resync_min = 0;
7524 mddev->resync_max = MaxSector;
7525 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7526 mddev->resync_min = mddev->curr_resync_completed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007527 mddev->curr_resync = 0;
7528 wake_up(&resync_wait);
7529 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
7530 md_wakeup_thread(mddev->thread);
NeilBrownc6207272008-02-06 01:39:52 -08007531 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007532}
NeilBrown29269552006-03-27 01:18:10 -08007533EXPORT_SYMBOL_GPL(md_do_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007534
NeilBrown746d3202013-04-24 11:42:41 +10007535static int remove_and_add_spares(struct mddev *mddev,
7536 struct md_rdev *this)
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007537{
NeilBrown3cb03002011-10-11 16:45:26 +11007538 struct md_rdev *rdev;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007539 int spares = 0;
NeilBrownf2a371c2012-01-09 00:46:41 +11007540 int removed = 0;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007541
NeilBrowndafb20f2012-03-19 12:46:39 +11007542 rdev_for_each(rdev, mddev)
NeilBrown746d3202013-04-24 11:42:41 +10007543 if ((this == NULL || rdev == this) &&
7544 rdev->raid_disk >= 0 &&
Dan Williams6bfe0b42008-04-30 00:52:32 -07007545 !test_bit(Blocked, &rdev->flags) &&
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007546 (test_bit(Faulty, &rdev->flags) ||
7547 ! test_bit(In_sync, &rdev->flags)) &&
7548 atomic_read(&rdev->nr_pending)==0) {
7549 if (mddev->pers->hot_remove_disk(
NeilBrownb8321b62011-12-23 10:17:51 +11007550 mddev, rdev) == 0) {
Namhyung Kim36fad852011-07-27 11:00:36 +10007551 sysfs_unlink_rdev(mddev, rdev);
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007552 rdev->raid_disk = -1;
NeilBrownf2a371c2012-01-09 00:46:41 +11007553 removed++;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007554 }
7555 }
Jonathan Brassow90584fc2013-03-07 16:24:26 -06007556 if (removed && mddev->kobj.sd)
7557 sysfs_notify(&mddev->kobj, NULL, "degraded");
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007558
NeilBrown746d3202013-04-24 11:42:41 +10007559 if (this)
7560 goto no_add;
7561
NeilBrowndafb20f2012-03-19 12:46:39 +11007562 rdev_for_each(rdev, mddev) {
NeilBrown7bfec5f2011-12-23 10:17:53 +11007563 if (rdev->raid_disk >= 0 &&
7564 !test_bit(In_sync, &rdev->flags) &&
7565 !test_bit(Faulty, &rdev->flags))
7566 spares++;
NeilBrown7ceb17e2013-04-24 11:42:42 +10007567 if (rdev->raid_disk >= 0)
7568 continue;
7569 if (test_bit(Faulty, &rdev->flags))
7570 continue;
7571 if (mddev->ro &&
NeilBrown8313b8e2013-12-12 10:13:33 +11007572 ! (rdev->saved_raid_disk >= 0 &&
7573 !test_bit(Bitmap_sync, &rdev->flags)))
NeilBrown7ceb17e2013-04-24 11:42:42 +10007574 continue;
7575
NeilBrown7eb41882014-01-14 15:55:14 +11007576 if (rdev->saved_raid_disk < 0)
7577 rdev->recovery_offset = 0;
NeilBrown7ceb17e2013-04-24 11:42:42 +10007578 if (mddev->pers->
7579 hot_add_disk(mddev, rdev) == 0) {
7580 if (sysfs_link_rdev(mddev, rdev))
7581 /* failure here is OK */;
7582 spares++;
7583 md_new_event(mddev);
7584 set_bit(MD_CHANGE_DEVS, &mddev->flags);
NeilBrowndfc70642008-05-23 13:04:39 -07007585 }
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007586 }
NeilBrown746d3202013-04-24 11:42:41 +10007587no_add:
NeilBrown6dafab62012-09-19 12:54:22 +10007588 if (removed)
7589 set_bit(MD_CHANGE_DEVS, &mddev->flags);
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007590 return spares;
7591}
NeilBrown7ebc0be2011-01-14 09:14:33 +11007592
NeilBrownac05f252014-09-30 08:10:42 +10007593static void md_start_sync(struct work_struct *ws)
7594{
7595 struct mddev *mddev = container_of(ws, struct mddev, del_work);
7596
7597 mddev->sync_thread = md_register_thread(md_do_sync,
7598 mddev,
7599 "resync");
7600 if (!mddev->sync_thread) {
7601 printk(KERN_ERR "%s: could not start resync"
7602 " thread...\n",
7603 mdname(mddev));
7604 /* leave the spares where they are, it shouldn't hurt */
7605 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7606 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7607 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
7608 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
7609 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11007610 wake_up(&resync_wait);
NeilBrownac05f252014-09-30 08:10:42 +10007611 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
7612 &mddev->recovery))
7613 if (mddev->sysfs_action)
7614 sysfs_notify_dirent_safe(mddev->sysfs_action);
7615 } else
7616 md_wakeup_thread(mddev->sync_thread);
7617 sysfs_notify_dirent_safe(mddev->sysfs_action);
7618 md_new_event(mddev);
7619}
7620
Linus Torvalds1da177e2005-04-16 15:20:36 -07007621/*
7622 * This routine is regularly called by all per-raid-array threads to
7623 * deal with generic issues like resync and super-block update.
7624 * Raid personalities that don't have a thread (linear/raid0) do not
7625 * need this as they never do any recovery or update the superblock.
7626 *
7627 * It does not do any resync itself, but rather "forks" off other threads
7628 * to do that as needed.
7629 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
7630 * "->recovery" and create a thread at ->sync_thread.
NeilBrowndfc70642008-05-23 13:04:39 -07007631 * When the thread finishes it sets MD_RECOVERY_DONE
Linus Torvalds1da177e2005-04-16 15:20:36 -07007632 * and wakeups up this thread which will reap the thread and finish up.
7633 * This thread also removes any faulty devices (with nr_pending == 0).
7634 *
7635 * The overall approach is:
7636 * 1/ if the superblock needs updating, update it.
7637 * 2/ If a recovery thread is running, don't do anything else.
7638 * 3/ If recovery has finished, clean up, possibly marking spares active.
7639 * 4/ If there are any faulty devices, remove them.
7640 * 5/ If array is degraded, try to add spares devices
7641 * 6/ If array has spares or is not in-sync, start a resync thread.
7642 */
NeilBrownfd01b882011-10-11 16:47:53 +11007643void md_check_recovery(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007644{
Jonathan Brassow68866e42011-06-08 15:10:08 +10007645 if (mddev->suspended)
7646 return;
7647
NeilBrown5f404022005-06-21 17:17:16 -07007648 if (mddev->bitmap)
NeilBrownaa5cbd12009-12-14 12:49:46 +11007649 bitmap_daemon_work(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007650
NeilBrownfca4d842005-06-21 17:17:11 -07007651 if (signal_pending(current)) {
NeilBrown31a59e32008-04-30 00:52:30 -07007652 if (mddev->pers->sync_request && !mddev->external) {
NeilBrownfca4d842005-06-21 17:17:11 -07007653 printk(KERN_INFO "md: %s in immediate safe mode\n",
7654 mdname(mddev));
7655 mddev->safemode = 2;
7656 }
7657 flush_signals(current);
7658 }
7659
NeilBrownc89a8ee2008-08-05 15:54:13 +10007660 if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
7661 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007662 if ( ! (
NeilBrown142d44c2013-11-28 10:34:18 +11007663 (mddev->flags & MD_UPDATE_SB_FLAGS & ~ (1<<MD_CHANGE_PENDING)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07007664 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
NeilBrownfca4d842005-06-21 17:17:11 -07007665 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
NeilBrown31a59e32008-04-30 00:52:30 -07007666 (mddev->external == 0 && mddev->safemode == 1) ||
NeilBrownfca4d842005-06-21 17:17:11 -07007667 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
7668 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
Linus Torvalds1da177e2005-04-16 15:20:36 -07007669 ))
7670 return;
NeilBrownfca4d842005-06-21 17:17:11 -07007671
NeilBrowndf5b89b2006-03-27 01:18:20 -08007672 if (mddev_trylock(mddev)) {
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007673 int spares = 0;
NeilBrownfca4d842005-06-21 17:17:11 -07007674
NeilBrownc89a8ee2008-08-05 15:54:13 +10007675 if (mddev->ro) {
NeilBrown7ceb17e2013-04-24 11:42:42 +10007676 /* On a read-only array we can:
7677 * - remove failed devices
7678 * - add already-in_sync devices if the array itself
7679 * is in-sync.
7680 * As we only add devices that are already in-sync,
7681 * we can activate the spares immediately.
NeilBrownc89a8ee2008-08-05 15:54:13 +10007682 */
NeilBrown7ceb17e2013-04-24 11:42:42 +10007683 remove_and_add_spares(mddev, NULL);
NeilBrown8313b8e2013-12-12 10:13:33 +11007684 /* There is no thread, but we need to call
7685 * ->spare_active and clear saved_raid_disk
7686 */
NeilBrown2ac295a2014-05-29 11:40:03 +10007687 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
NeilBrown8313b8e2013-12-12 10:13:33 +11007688 md_reap_sync_thread(mddev);
7689 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
NeilBrownc89a8ee2008-08-05 15:54:13 +10007690 goto unlock;
7691 }
7692
NeilBrown31a59e32008-04-30 00:52:30 -07007693 if (!mddev->external) {
Neil Brown0fd62b82008-06-28 08:31:36 +10007694 int did_change = 0;
NeilBrown31a59e32008-04-30 00:52:30 -07007695 spin_lock_irq(&mddev->write_lock);
7696 if (mddev->safemode &&
7697 !atomic_read(&mddev->writes_pending) &&
7698 !mddev->in_sync &&
7699 mddev->recovery_cp == MaxSector) {
7700 mddev->in_sync = 1;
Neil Brown0fd62b82008-06-28 08:31:36 +10007701 did_change = 1;
NeilBrown070dc6d2010-08-30 17:33:34 +10007702 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
NeilBrown31a59e32008-04-30 00:52:30 -07007703 }
7704 if (mddev->safemode == 1)
7705 mddev->safemode = 0;
7706 spin_unlock_irq(&mddev->write_lock);
Neil Brown0fd62b82008-06-28 08:31:36 +10007707 if (did_change)
NeilBrown00bcb4a2010-06-01 19:37:23 +10007708 sysfs_notify_dirent_safe(mddev->sysfs_state);
NeilBrownfca4d842005-06-21 17:17:11 -07007709 }
NeilBrownfca4d842005-06-21 17:17:11 -07007710
NeilBrown7a0a5352013-08-27 16:28:23 +10007711 if (mddev->flags & MD_UPDATE_SB_FLAGS)
NeilBrown850b2b42006-10-03 01:15:46 -07007712 md_update_sb(mddev, 0);
NeilBrown06d91a52005-06-21 17:17:12 -07007713
Linus Torvalds1da177e2005-04-16 15:20:36 -07007714 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
7715 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
7716 /* resync/recovery still happening */
7717 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7718 goto unlock;
7719 }
7720 if (mddev->sync_thread) {
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10007721 md_reap_sync_thread(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007722 goto unlock;
7723 }
Neil Brown72a23c22008-06-28 08:31:41 +10007724 /* Set RUNNING before clearing NEEDED to avoid
7725 * any transients in the value of "sync_action".
7726 */
NeilBrown72f36d52012-10-11 14:25:57 +11007727 mddev->curr_resync_completed = 0;
Neil Brown72a23c22008-06-28 08:31:41 +10007728 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrown24dd4692005-11-08 21:39:26 -08007729 /* Clear some bits that don't mean anything, but
7730 * might be left set
7731 */
NeilBrown24dd4692005-11-08 21:39:26 -08007732 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
7733 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007734
NeilBrowned209582012-04-24 10:23:14 +10007735 if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
7736 test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
NeilBrownac05f252014-09-30 08:10:42 +10007737 goto not_running;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007738 /* no recovery is running.
7739 * remove any failed drives, then
7740 * add spares if possible.
NeilBrown72f36d52012-10-11 14:25:57 +11007741 * Spares are also removed and re-added, to allow
Linus Torvalds1da177e2005-04-16 15:20:36 -07007742 * the personality to fail the re-add.
7743 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07007744
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007745 if (mddev->reshape_position != MaxSector) {
NeilBrown50ac1682009-06-18 08:47:55 +10007746 if (mddev->pers->check_reshape == NULL ||
7747 mddev->pers->check_reshape(mddev) != 0)
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007748 /* Cannot proceed */
NeilBrownac05f252014-09-30 08:10:42 +10007749 goto not_running;
NeilBrownb4c4c7b2007-02-28 20:11:48 -08007750 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10007751 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown746d3202013-04-24 11:42:41 +10007752 } else if ((spares = remove_and_add_spares(mddev, NULL))) {
NeilBrown24dd4692005-11-08 21:39:26 -08007753 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7754 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
Dan Williams56ac36d2008-08-07 10:02:47 -07007755 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10007756 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown24dd4692005-11-08 21:39:26 -08007757 } else if (mddev->recovery_cp < MaxSector) {
7758 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
Neil Brown72a23c22008-06-28 08:31:41 +10007759 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
NeilBrown24dd4692005-11-08 21:39:26 -08007760 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
7761 /* nothing to be done ... */
NeilBrownac05f252014-09-30 08:10:42 +10007762 goto not_running;
NeilBrown24dd4692005-11-08 21:39:26 -08007763
Linus Torvalds1da177e2005-04-16 15:20:36 -07007764 if (mddev->pers->sync_request) {
NeilBrownef99bf42012-05-22 13:55:08 +10007765 if (spares) {
NeilBrowna654b9d82005-06-21 17:17:27 -07007766 /* We are adding a device or devices to an array
7767 * which has the bitmap stored on all devices.
7768 * So make sure all bitmap pages get written
7769 */
7770 bitmap_write_all(mddev->bitmap);
7771 }
NeilBrownac05f252014-09-30 08:10:42 +10007772 INIT_WORK(&mddev->del_work, md_start_sync);
7773 queue_work(md_misc_wq, &mddev->del_work);
7774 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07007775 }
NeilBrownac05f252014-09-30 08:10:42 +10007776 not_running:
Neil Brown72a23c22008-06-28 08:31:41 +10007777 if (!mddev->sync_thread) {
7778 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11007779 wake_up(&resync_wait);
Neil Brown72a23c22008-06-28 08:31:41 +10007780 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
7781 &mddev->recovery))
NeilBrown0c3573f2009-01-09 08:31:05 +11007782 if (mddev->sysfs_action)
NeilBrown00bcb4a2010-06-01 19:37:23 +10007783 sysfs_notify_dirent_safe(mddev->sysfs_action);
Neil Brown72a23c22008-06-28 08:31:41 +10007784 }
NeilBrownac05f252014-09-30 08:10:42 +10007785 unlock:
7786 wake_up(&mddev->sb_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007787 mddev_unlock(mddev);
7788 }
7789}
NeilBrown6c144d32014-09-30 16:15:38 +10007790EXPORT_SYMBOL(md_check_recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07007791
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10007792void md_reap_sync_thread(struct mddev *mddev)
7793{
7794 struct md_rdev *rdev;
7795
7796 /* resync has finished, collect result */
7797 md_unregister_thread(&mddev->sync_thread);
7798 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
7799 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
7800 /* success...*/
7801 /* activate any spares */
7802 if (mddev->pers->spare_active(mddev)) {
7803 sysfs_notify(&mddev->kobj, NULL,
7804 "degraded");
7805 set_bit(MD_CHANGE_DEVS, &mddev->flags);
7806 }
7807 }
7808 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7809 mddev->pers->finish_reshape)
7810 mddev->pers->finish_reshape(mddev);
7811
7812 /* If array is no-longer degraded, then any saved_raid_disk
NeilBrownf4667222013-12-09 12:04:56 +11007813 * information must be scrapped.
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10007814 */
NeilBrownf4667222013-12-09 12:04:56 +11007815 if (!mddev->degraded)
7816 rdev_for_each(rdev, mddev)
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10007817 rdev->saved_raid_disk = -1;
7818
7819 md_update_sb(mddev, 1);
7820 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7821 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7822 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7823 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
7824 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
NeilBrownf851b602014-12-11 10:02:10 +11007825 wake_up(&resync_wait);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10007826 /* flag recovery needed just to double check */
7827 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7828 sysfs_notify_dirent_safe(mddev->sysfs_action);
7829 md_new_event(mddev);
7830 if (mddev->event_work.func)
7831 queue_work(md_misc_wq, &mddev->event_work);
7832}
NeilBrown6c144d32014-09-30 16:15:38 +10007833EXPORT_SYMBOL(md_reap_sync_thread);
Jonathan Brassowa91d5ac2013-04-24 11:42:43 +10007834
NeilBrownfd01b882011-10-11 16:47:53 +11007835void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
Dan Williams6bfe0b42008-04-30 00:52:32 -07007836{
NeilBrown00bcb4a2010-06-01 19:37:23 +10007837 sysfs_notify_dirent_safe(rdev->sysfs_state);
Dan Williams6bfe0b42008-04-30 00:52:32 -07007838 wait_event_timeout(rdev->blocked_wait,
NeilBrownde393cd2011-07-28 11:31:48 +10007839 !test_bit(Blocked, &rdev->flags) &&
7840 !test_bit(BlockedBadBlocks, &rdev->flags),
Dan Williams6bfe0b42008-04-30 00:52:32 -07007841 msecs_to_jiffies(5000));
7842 rdev_dec_pending(rdev, mddev);
7843}
7844EXPORT_SYMBOL(md_wait_for_blocked_rdev);
7845
NeilBrownc6563a82012-05-21 09:27:00 +10007846void md_finish_reshape(struct mddev *mddev)
7847{
7848 /* called be personality module when reshape completes. */
7849 struct md_rdev *rdev;
7850
7851 rdev_for_each(rdev, mddev) {
7852 if (rdev->data_offset > rdev->new_data_offset)
7853 rdev->sectors += rdev->data_offset - rdev->new_data_offset;
7854 else
7855 rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
7856 rdev->data_offset = rdev->new_data_offset;
7857 }
7858}
7859EXPORT_SYMBOL(md_finish_reshape);
NeilBrown2230dfe2011-07-28 11:31:46 +10007860
7861/* Bad block management.
7862 * We can record which blocks on each device are 'bad' and so just
7863 * fail those blocks, or that stripe, rather than the whole device.
7864 * Entries in the bad-block table are 64bits wide. This comprises:
7865 * Length of bad-range, in sectors: 0-511 for lengths 1-512
7866 * Start of bad-range, sector offset, 54 bits (allows 8 exbibytes)
7867 * A 'shift' can be set so that larger blocks are tracked and
7868 * consequently larger devices can be covered.
7869 * 'Acknowledged' flag - 1 bit. - the most significant bit.
7870 *
7871 * Locking of the bad-block table uses a seqlock so md_is_badblock
7872 * might need to retry if it is very unlucky.
7873 * We will sometimes want to check for bad blocks in a bi_end_io function,
7874 * so we use the write_seqlock_irq variant.
7875 *
7876 * When looking for a bad block we specify a range and want to
7877 * know if any block in the range is bad. So we binary-search
7878 * to the last range that starts at-or-before the given endpoint,
7879 * (or "before the sector after the target range")
7880 * then see if it ends after the given start.
7881 * We return
7882 * 0 if there are no known bad blocks in the range
7883 * 1 if there are known bad block which are all acknowledged
7884 * -1 if there are bad blocks which have not yet been acknowledged in metadata.
7885 * plus the start/length of the first bad section we overlap.
7886 */
7887int md_is_badblock(struct badblocks *bb, sector_t s, int sectors,
7888 sector_t *first_bad, int *bad_sectors)
7889{
7890 int hi;
majianpengab056132012-11-06 17:13:44 +08007891 int lo;
NeilBrown2230dfe2011-07-28 11:31:46 +10007892 u64 *p = bb->page;
majianpengab056132012-11-06 17:13:44 +08007893 int rv;
NeilBrown2230dfe2011-07-28 11:31:46 +10007894 sector_t target = s + sectors;
7895 unsigned seq;
7896
7897 if (bb->shift > 0) {
7898 /* round the start down, and the end up */
7899 s >>= bb->shift;
7900 target += (1<<bb->shift) - 1;
7901 target >>= bb->shift;
7902 sectors = target - s;
7903 }
7904 /* 'target' is now the first block after the bad range */
7905
7906retry:
7907 seq = read_seqbegin(&bb->lock);
majianpengab056132012-11-06 17:13:44 +08007908 lo = 0;
7909 rv = 0;
NeilBrown2230dfe2011-07-28 11:31:46 +10007910 hi = bb->count;
7911
7912 /* Binary search between lo and hi for 'target'
7913 * i.e. for the last range that starts before 'target'
7914 */
7915 /* INVARIANT: ranges before 'lo' and at-or-after 'hi'
7916 * are known not to be the last range before target.
7917 * VARIANT: hi-lo is the number of possible
7918 * ranges, and decreases until it reaches 1
7919 */
7920 while (hi - lo > 1) {
7921 int mid = (lo + hi) / 2;
7922 sector_t a = BB_OFFSET(p[mid]);
7923 if (a < target)
7924 /* This could still be the one, earlier ranges
7925 * could not. */
7926 lo = mid;
7927 else
7928 /* This and later ranges are definitely out. */
7929 hi = mid;
7930 }
7931 /* 'lo' might be the last that started before target, but 'hi' isn't */
7932 if (hi > lo) {
7933 /* need to check all range that end after 's' to see if
7934 * any are unacknowledged.
7935 */
7936 while (lo >= 0 &&
7937 BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > s) {
7938 if (BB_OFFSET(p[lo]) < target) {
7939 /* starts before the end, and finishes after
7940 * the start, so they must overlap
7941 */
7942 if (rv != -1 && BB_ACK(p[lo]))
7943 rv = 1;
7944 else
7945 rv = -1;
7946 *first_bad = BB_OFFSET(p[lo]);
7947 *bad_sectors = BB_LEN(p[lo]);
7948 }
7949 lo--;
7950 }
7951 }
7952
7953 if (read_seqretry(&bb->lock, seq))
7954 goto retry;
7955
7956 return rv;
7957}
7958EXPORT_SYMBOL_GPL(md_is_badblock);
7959
7960/*
7961 * Add a range of bad blocks to the table.
7962 * This might extend the table, or might contract it
7963 * if two adjacent ranges can be merged.
7964 * We binary-search to find the 'insertion' point, then
7965 * decide how best to handle it.
7966 */
7967static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
7968 int acknowledged)
7969{
7970 u64 *p;
7971 int lo, hi;
7972 int rv = 1;
Bian Yu905b0292013-10-12 01:10:03 -04007973 unsigned long flags;
NeilBrown2230dfe2011-07-28 11:31:46 +10007974
7975 if (bb->shift < 0)
7976 /* badblocks are disabled */
7977 return 0;
7978
7979 if (bb->shift) {
7980 /* round the start down, and the end up */
7981 sector_t next = s + sectors;
7982 s >>= bb->shift;
7983 next += (1<<bb->shift) - 1;
7984 next >>= bb->shift;
7985 sectors = next - s;
7986 }
7987
Bian Yu905b0292013-10-12 01:10:03 -04007988 write_seqlock_irqsave(&bb->lock, flags);
NeilBrown2230dfe2011-07-28 11:31:46 +10007989
7990 p = bb->page;
7991 lo = 0;
7992 hi = bb->count;
7993 /* Find the last range that starts at-or-before 's' */
7994 while (hi - lo > 1) {
7995 int mid = (lo + hi) / 2;
7996 sector_t a = BB_OFFSET(p[mid]);
7997 if (a <= s)
7998 lo = mid;
7999 else
8000 hi = mid;
8001 }
8002 if (hi > lo && BB_OFFSET(p[lo]) > s)
8003 hi = lo;
8004
8005 if (hi > lo) {
8006 /* we found a range that might merge with the start
8007 * of our new range
8008 */
8009 sector_t a = BB_OFFSET(p[lo]);
8010 sector_t e = a + BB_LEN(p[lo]);
8011 int ack = BB_ACK(p[lo]);
8012 if (e >= s) {
8013 /* Yes, we can merge with a previous range */
8014 if (s == a && s + sectors >= e)
8015 /* new range covers old */
8016 ack = acknowledged;
8017 else
8018 ack = ack && acknowledged;
8019
8020 if (e < s + sectors)
8021 e = s + sectors;
8022 if (e - a <= BB_MAX_LEN) {
8023 p[lo] = BB_MAKE(a, e-a, ack);
8024 s = e;
8025 } else {
8026 /* does not all fit in one range,
8027 * make p[lo] maximal
8028 */
8029 if (BB_LEN(p[lo]) != BB_MAX_LEN)
8030 p[lo] = BB_MAKE(a, BB_MAX_LEN, ack);
8031 s = a + BB_MAX_LEN;
8032 }
8033 sectors = e - s;
8034 }
8035 }
8036 if (sectors && hi < bb->count) {
8037 /* 'hi' points to the first range that starts after 's'.
8038 * Maybe we can merge with the start of that range */
8039 sector_t a = BB_OFFSET(p[hi]);
8040 sector_t e = a + BB_LEN(p[hi]);
8041 int ack = BB_ACK(p[hi]);
8042 if (a <= s + sectors) {
8043 /* merging is possible */
8044 if (e <= s + sectors) {
8045 /* full overlap */
8046 e = s + sectors;
8047 ack = acknowledged;
8048 } else
8049 ack = ack && acknowledged;
8050
8051 a = s;
8052 if (e - a <= BB_MAX_LEN) {
8053 p[hi] = BB_MAKE(a, e-a, ack);
8054 s = e;
8055 } else {
8056 p[hi] = BB_MAKE(a, BB_MAX_LEN, ack);
8057 s = a + BB_MAX_LEN;
8058 }
8059 sectors = e - s;
8060 lo = hi;
8061 hi++;
8062 }
8063 }
8064 if (sectors == 0 && hi < bb->count) {
8065 /* we might be able to combine lo and hi */
8066 /* Note: 's' is at the end of 'lo' */
8067 sector_t a = BB_OFFSET(p[hi]);
8068 int lolen = BB_LEN(p[lo]);
8069 int hilen = BB_LEN(p[hi]);
8070 int newlen = lolen + hilen - (s - a);
8071 if (s >= a && newlen < BB_MAX_LEN) {
8072 /* yes, we can combine them */
8073 int ack = BB_ACK(p[lo]) && BB_ACK(p[hi]);
8074 p[lo] = BB_MAKE(BB_OFFSET(p[lo]), newlen, ack);
8075 memmove(p + hi, p + hi + 1,
8076 (bb->count - hi - 1) * 8);
8077 bb->count--;
8078 }
8079 }
8080 while (sectors) {
8081 /* didn't merge (it all).
8082 * Need to add a range just before 'hi' */
8083 if (bb->count >= MD_MAX_BADBLOCKS) {
8084 /* No room for more */
8085 rv = 0;
8086 break;
8087 } else {
8088 int this_sectors = sectors;
8089 memmove(p + hi + 1, p + hi,
8090 (bb->count - hi) * 8);
8091 bb->count++;
8092
8093 if (this_sectors > BB_MAX_LEN)
8094 this_sectors = BB_MAX_LEN;
8095 p[hi] = BB_MAKE(s, this_sectors, acknowledged);
8096 sectors -= this_sectors;
8097 s += this_sectors;
8098 }
8099 }
8100
8101 bb->changed = 1;
NeilBrownde393cd2011-07-28 11:31:48 +10008102 if (!acknowledged)
8103 bb->unacked_exist = 1;
Bian Yu905b0292013-10-12 01:10:03 -04008104 write_sequnlock_irqrestore(&bb->lock, flags);
NeilBrown2230dfe2011-07-28 11:31:46 +10008105
8106 return rv;
8107}
8108
NeilBrown3cb03002011-10-11 16:45:26 +11008109int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
NeilBrownc6563a82012-05-21 09:27:00 +10008110 int is_new)
NeilBrown2230dfe2011-07-28 11:31:46 +10008111{
NeilBrownc6563a82012-05-21 09:27:00 +10008112 int rv;
8113 if (is_new)
8114 s += rdev->new_data_offset;
8115 else
8116 s += rdev->data_offset;
8117 rv = md_set_badblocks(&rdev->badblocks,
8118 s, sectors, 0);
NeilBrown2230dfe2011-07-28 11:31:46 +10008119 if (rv) {
8120 /* Make sure they get written out promptly */
NeilBrown8bd2f0a2011-12-08 16:26:08 +11008121 sysfs_notify_dirent_safe(rdev->sysfs_state);
NeilBrown2230dfe2011-07-28 11:31:46 +10008122 set_bit(MD_CHANGE_CLEAN, &rdev->mddev->flags);
8123 md_wakeup_thread(rdev->mddev->thread);
8124 }
8125 return rv;
8126}
8127EXPORT_SYMBOL_GPL(rdev_set_badblocks);
8128
8129/*
8130 * Remove a range of bad blocks from the table.
8131 * This may involve extending the table if we spilt a region,
8132 * but it must not fail. So if the table becomes full, we just
8133 * drop the remove request.
8134 */
8135static int md_clear_badblocks(struct badblocks *bb, sector_t s, int sectors)
8136{
8137 u64 *p;
8138 int lo, hi;
8139 sector_t target = s + sectors;
8140 int rv = 0;
8141
8142 if (bb->shift > 0) {
8143 /* When clearing we round the start up and the end down.
8144 * This should not matter as the shift should align with
8145 * the block size and no rounding should ever be needed.
8146 * However it is better the think a block is bad when it
8147 * isn't than to think a block is not bad when it is.
8148 */
8149 s += (1<<bb->shift) - 1;
8150 s >>= bb->shift;
8151 target >>= bb->shift;
8152 sectors = target - s;
8153 }
8154
8155 write_seqlock_irq(&bb->lock);
8156
8157 p = bb->page;
8158 lo = 0;
8159 hi = bb->count;
8160 /* Find the last range that starts before 'target' */
8161 while (hi - lo > 1) {
8162 int mid = (lo + hi) / 2;
8163 sector_t a = BB_OFFSET(p[mid]);
8164 if (a < target)
8165 lo = mid;
8166 else
8167 hi = mid;
8168 }
8169 if (hi > lo) {
8170 /* p[lo] is the last range that could overlap the
8171 * current range. Earlier ranges could also overlap,
8172 * but only this one can overlap the end of the range.
8173 */
8174 if (BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > target) {
8175 /* Partial overlap, leave the tail of this range */
8176 int ack = BB_ACK(p[lo]);
8177 sector_t a = BB_OFFSET(p[lo]);
8178 sector_t end = a + BB_LEN(p[lo]);
8179
8180 if (a < s) {
8181 /* we need to split this range */
8182 if (bb->count >= MD_MAX_BADBLOCKS) {
NeilBrown8b32bf52014-05-28 13:39:22 +10008183 rv = -ENOSPC;
NeilBrown2230dfe2011-07-28 11:31:46 +10008184 goto out;
8185 }
8186 memmove(p+lo+1, p+lo, (bb->count - lo) * 8);
8187 bb->count++;
8188 p[lo] = BB_MAKE(a, s-a, ack);
8189 lo++;
8190 }
8191 p[lo] = BB_MAKE(target, end - target, ack);
8192 /* there is no longer an overlap */
8193 hi = lo;
8194 lo--;
8195 }
8196 while (lo >= 0 &&
8197 BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > s) {
8198 /* This range does overlap */
8199 if (BB_OFFSET(p[lo]) < s) {
8200 /* Keep the early parts of this range. */
8201 int ack = BB_ACK(p[lo]);
8202 sector_t start = BB_OFFSET(p[lo]);
8203 p[lo] = BB_MAKE(start, s - start, ack);
8204 /* now low doesn't overlap, so.. */
8205 break;
8206 }
8207 lo--;
8208 }
8209 /* 'lo' is strictly before, 'hi' is strictly after,
8210 * anything between needs to be discarded
8211 */
8212 if (hi - lo > 1) {
8213 memmove(p+lo+1, p+hi, (bb->count - hi) * 8);
8214 bb->count -= (hi - lo - 1);
8215 }
8216 }
8217
8218 bb->changed = 1;
8219out:
8220 write_sequnlock_irq(&bb->lock);
8221 return rv;
8222}
8223
NeilBrownc6563a82012-05-21 09:27:00 +10008224int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
8225 int is_new)
NeilBrown2230dfe2011-07-28 11:31:46 +10008226{
NeilBrownc6563a82012-05-21 09:27:00 +10008227 if (is_new)
8228 s += rdev->new_data_offset;
8229 else
8230 s += rdev->data_offset;
NeilBrown2230dfe2011-07-28 11:31:46 +10008231 return md_clear_badblocks(&rdev->badblocks,
NeilBrownc6563a82012-05-21 09:27:00 +10008232 s, sectors);
NeilBrown2230dfe2011-07-28 11:31:46 +10008233}
8234EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
8235
8236/*
8237 * Acknowledge all bad blocks in a list.
8238 * This only succeeds if ->changed is clear. It is used by
8239 * in-kernel metadata updates
8240 */
8241void md_ack_all_badblocks(struct badblocks *bb)
8242{
8243 if (bb->page == NULL || bb->changed)
8244 /* no point even trying */
8245 return;
8246 write_seqlock_irq(&bb->lock);
8247
majianpengecb178b2012-03-19 12:46:42 +11008248 if (bb->changed == 0 && bb->unacked_exist) {
NeilBrown2230dfe2011-07-28 11:31:46 +10008249 u64 *p = bb->page;
8250 int i;
8251 for (i = 0; i < bb->count ; i++) {
8252 if (!BB_ACK(p[i])) {
8253 sector_t start = BB_OFFSET(p[i]);
8254 int len = BB_LEN(p[i]);
8255 p[i] = BB_MAKE(start, len, 1);
8256 }
8257 }
NeilBrownde393cd2011-07-28 11:31:48 +10008258 bb->unacked_exist = 0;
NeilBrown2230dfe2011-07-28 11:31:46 +10008259 }
8260 write_sequnlock_irq(&bb->lock);
8261}
8262EXPORT_SYMBOL_GPL(md_ack_all_badblocks);
8263
NeilBrown16c791a2011-07-28 11:31:47 +10008264/* sysfs access to bad-blocks list.
8265 * We present two files.
8266 * 'bad-blocks' lists sector numbers and lengths of ranges that
8267 * are recorded as bad. The list is truncated to fit within
8268 * the one-page limit of sysfs.
8269 * Writing "sector length" to this file adds an acknowledged
8270 * bad block list.
8271 * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
8272 * been acknowledged. Writing to this file adds bad blocks
8273 * without acknowledging them. This is largely for testing.
8274 */
8275
8276static ssize_t
8277badblocks_show(struct badblocks *bb, char *page, int unack)
8278{
8279 size_t len;
8280 int i;
8281 u64 *p = bb->page;
8282 unsigned seq;
8283
8284 if (bb->shift < 0)
8285 return 0;
8286
8287retry:
8288 seq = read_seqbegin(&bb->lock);
8289
8290 len = 0;
8291 i = 0;
8292
8293 while (len < PAGE_SIZE && i < bb->count) {
8294 sector_t s = BB_OFFSET(p[i]);
8295 unsigned int length = BB_LEN(p[i]);
8296 int ack = BB_ACK(p[i]);
8297 i++;
8298
8299 if (unack && ack)
8300 continue;
8301
8302 len += snprintf(page+len, PAGE_SIZE-len, "%llu %u\n",
8303 (unsigned long long)s << bb->shift,
8304 length << bb->shift);
8305 }
NeilBrownde393cd2011-07-28 11:31:48 +10008306 if (unack && len == 0)
8307 bb->unacked_exist = 0;
NeilBrown16c791a2011-07-28 11:31:47 +10008308
8309 if (read_seqretry(&bb->lock, seq))
8310 goto retry;
8311
8312 return len;
8313}
8314
8315#define DO_DEBUG 1
8316
8317static ssize_t
8318badblocks_store(struct badblocks *bb, const char *page, size_t len, int unack)
8319{
8320 unsigned long long sector;
8321 int length;
8322 char newline;
8323#ifdef DO_DEBUG
8324 /* Allow clearing via sysfs *only* for testing/debugging.
8325 * Normally only a successful write may clear a badblock
8326 */
8327 int clear = 0;
8328 if (page[0] == '-') {
8329 clear = 1;
8330 page++;
8331 }
8332#endif /* DO_DEBUG */
8333
8334 switch (sscanf(page, "%llu %d%c", &sector, &length, &newline)) {
8335 case 3:
8336 if (newline != '\n')
8337 return -EINVAL;
8338 case 2:
8339 if (length <= 0)
8340 return -EINVAL;
8341 break;
8342 default:
8343 return -EINVAL;
8344 }
8345
8346#ifdef DO_DEBUG
8347 if (clear) {
8348 md_clear_badblocks(bb, sector, length);
8349 return len;
8350 }
8351#endif /* DO_DEBUG */
8352 if (md_set_badblocks(bb, sector, length, !unack))
8353 return len;
8354 else
8355 return -ENOSPC;
8356}
8357
Adrian Bunk75c96f82005-05-05 16:16:09 -07008358static int md_notify_reboot(struct notifier_block *this,
8359 unsigned long code, void *x)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008360{
8361 struct list_head *tmp;
NeilBrownfd01b882011-10-11 16:47:53 +11008362 struct mddev *mddev;
Daniel P. Berrange2dba6a92011-09-23 10:40:45 +01008363 int need_delay = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008364
NeilBrownc744a652012-03-19 12:46:37 +11008365 for_each_mddev(mddev, tmp) {
8366 if (mddev_trylock(mddev)) {
NeilBrown30b8aa92012-04-24 10:23:16 +10008367 if (mddev->pers)
8368 __md_stop_writes(mddev);
NeilBrown0f62fb22014-05-06 09:36:08 +10008369 if (mddev->persistent)
8370 mddev->safemode = 2;
NeilBrownc744a652012-03-19 12:46:37 +11008371 mddev_unlock(mddev);
Daniel P. Berrange2dba6a92011-09-23 10:40:45 +01008372 }
NeilBrownc744a652012-03-19 12:46:37 +11008373 need_delay = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008374 }
NeilBrownc744a652012-03-19 12:46:37 +11008375 /*
8376 * certain more exotic SCSI devices are known to be
8377 * volatile wrt too early system reboots. While the
8378 * right place to handle this issue is the given
8379 * driver, we do want to have a safe RAID driver ...
8380 */
8381 if (need_delay)
8382 mdelay(1000*1);
8383
Linus Torvalds1da177e2005-04-16 15:20:36 -07008384 return NOTIFY_DONE;
8385}
8386
Adrian Bunk75c96f82005-05-05 16:16:09 -07008387static struct notifier_block md_notifier = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07008388 .notifier_call = md_notify_reboot,
8389 .next = NULL,
8390 .priority = INT_MAX, /* before any real devices */
8391};
8392
8393static void md_geninit(void)
8394{
NeilBrown36a4e1f2011-10-07 14:23:17 +11008395 pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07008396
Denis V. Lunevc7705f3442008-04-29 01:02:35 -07008397 proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008398}
8399
Adrian Bunk75c96f82005-05-05 16:16:09 -07008400static int __init md_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008401{
Tejun Heoe804ac72010-10-15 15:36:08 +02008402 int ret = -ENOMEM;
8403
Tejun Heoada609e2011-01-25 14:35:54 +01008404 md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
Tejun Heoe804ac72010-10-15 15:36:08 +02008405 if (!md_wq)
8406 goto err_wq;
8407
8408 md_misc_wq = alloc_workqueue("md_misc", 0, 0);
8409 if (!md_misc_wq)
8410 goto err_misc_wq;
8411
8412 if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
8413 goto err_md;
8414
8415 if ((ret = register_blkdev(0, "mdp")) < 0)
8416 goto err_mdp;
8417 mdp_major = ret;
8418
NeilBrownaf5628f2014-07-31 13:54:54 +10008419 blk_register_region(MKDEV(MD_MAJOR, 0), 512, THIS_MODULE,
NeilBrowne8703fe2006-10-03 01:15:59 -07008420 md_probe, NULL, NULL);
8421 blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07008422 md_probe, NULL, NULL);
8423
Linus Torvalds1da177e2005-04-16 15:20:36 -07008424 register_reboot_notifier(&md_notifier);
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08008425 raid_table_header = register_sysctl_table(raid_root_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008426
8427 md_geninit();
NeilBrownd710e132008-10-13 11:55:12 +11008428 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008429
Tejun Heoe804ac72010-10-15 15:36:08 +02008430err_mdp:
8431 unregister_blkdev(MD_MAJOR, "md");
8432err_md:
8433 destroy_workqueue(md_misc_wq);
8434err_misc_wq:
8435 destroy_workqueue(md_wq);
8436err_wq:
8437 return ret;
8438}
Linus Torvalds1da177e2005-04-16 15:20:36 -07008439
8440#ifndef MODULE
8441
8442/*
8443 * Searches all registered partitions for autorun RAID arrays
8444 * at boot time.
8445 */
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008446
8447static LIST_HEAD(all_detected_devices);
8448struct detected_devices_node {
8449 struct list_head list;
8450 dev_t dev;
8451};
Linus Torvalds1da177e2005-04-16 15:20:36 -07008452
8453void md_autodetect_dev(dev_t dev)
8454{
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008455 struct detected_devices_node *node_detected_dev;
8456
8457 node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
8458 if (node_detected_dev) {
8459 node_detected_dev->dev = dev;
8460 list_add_tail(&node_detected_dev->list, &all_detected_devices);
8461 } else {
8462 printk(KERN_CRIT "md: md_autodetect_dev: kzalloc failed"
8463 ", skipping dev(%d,%d)\n", MAJOR(dev), MINOR(dev));
8464 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07008465}
8466
Linus Torvalds1da177e2005-04-16 15:20:36 -07008467static void autostart_arrays(int part)
8468{
NeilBrown3cb03002011-10-11 16:45:26 +11008469 struct md_rdev *rdev;
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008470 struct detected_devices_node *node_detected_dev;
8471 dev_t dev;
8472 int i_scanned, i_passed;
8473
8474 i_scanned = 0;
8475 i_passed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008476
8477 printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
8478
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008479 while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
8480 i_scanned++;
8481 node_detected_dev = list_entry(all_detected_devices.next,
8482 struct detected_devices_node, list);
8483 list_del(&node_detected_dev->list);
8484 dev = node_detected_dev->dev;
8485 kfree(node_detected_dev);
NeilBrowndf968c42007-07-17 04:06:11 -07008486 rdev = md_import_device(dev,0, 90);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008487 if (IS_ERR(rdev))
8488 continue;
8489
NeilBrown403df472014-09-30 15:52:29 +10008490 if (test_bit(Faulty, &rdev->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -07008491 continue;
NeilBrown403df472014-09-30 15:52:29 +10008492
NeilBrownd0fae182008-03-04 14:29:31 -08008493 set_bit(AutoDetected, &rdev->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008494 list_add(&rdev->same_set, &pending_raid_disks);
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008495 i_passed++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008496 }
Michael J. Evans4d936ec2007-10-16 23:30:52 -07008497
8498 printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
8499 i_scanned, i_passed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008500
8501 autorun_devices(part);
8502}
8503
Jeff Garzikfdee8ae2006-12-10 02:20:50 -08008504#endif /* !MODULE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07008505
8506static __exit void md_exit(void)
8507{
NeilBrownfd01b882011-10-11 16:47:53 +11008508 struct mddev *mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008509 struct list_head *tmp;
NeilBrowne2f23b62014-04-09 14:33:51 +10008510 int delay = 1;
Greg Kroah-Hartman8ab5e4c2005-06-20 21:15:16 -07008511
NeilBrownaf5628f2014-07-31 13:54:54 +10008512 blk_unregister_region(MKDEV(MD_MAJOR,0), 512);
NeilBrowne8703fe2006-10-03 01:15:59 -07008513 blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008514
Christoph Hellwig3dbd8c22009-03-31 14:27:02 +11008515 unregister_blkdev(MD_MAJOR,"md");
Linus Torvalds1da177e2005-04-16 15:20:36 -07008516 unregister_blkdev(mdp_major, "mdp");
8517 unregister_reboot_notifier(&md_notifier);
8518 unregister_sysctl_table(raid_table_header);
NeilBrowne2f23b62014-04-09 14:33:51 +10008519
8520 /* We cannot unload the modules while some process is
8521 * waiting for us in select() or poll() - wake them up
8522 */
8523 md_unloading = 1;
8524 while (waitqueue_active(&md_event_waiters)) {
8525 /* not safe to leave yet */
8526 wake_up(&md_event_waiters);
8527 msleep(delay);
8528 delay += delay;
8529 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07008530 remove_proc_entry("mdstat", NULL);
NeilBrowne2f23b62014-04-09 14:33:51 +10008531
NeilBrown29ac4aa2008-02-06 01:39:58 -08008532 for_each_mddev(mddev, tmp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07008533 export_array(mddev);
NeilBrownd3374822009-01-09 08:31:10 +11008534 mddev->hold_active = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07008535 }
Tejun Heoe804ac72010-10-15 15:36:08 +02008536 destroy_workqueue(md_misc_wq);
8537 destroy_workqueue(md_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008538}
8539
Dan Williams685784a2007-07-09 11:56:42 -07008540subsys_initcall(md_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07008541module_exit(md_exit)
8542
NeilBrownf91de922005-11-08 21:39:36 -08008543static int get_ro(char *buffer, struct kernel_param *kp)
8544{
8545 return sprintf(buffer, "%d", start_readonly);
8546}
8547static int set_ro(const char *val, struct kernel_param *kp)
8548{
8549 char *e;
8550 int num = simple_strtoul(val, &e, 10);
8551 if (*val && (*e == '\0' || *e == '\n')) {
8552 start_readonly = num;
NeilBrown4dbcdc72006-01-06 00:20:52 -08008553 return 0;
NeilBrownf91de922005-11-08 21:39:36 -08008554 }
8555 return -EINVAL;
8556}
8557
NeilBrown80ca3a42006-07-10 04:44:18 -07008558module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
8559module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
NeilBrownefeb53c2009-01-09 08:31:10 +11008560module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
NeilBrownf91de922005-11-08 21:39:36 -08008561
Linus Torvalds1da177e2005-04-16 15:20:36 -07008562MODULE_LICENSE("GPL");
NeilBrown0efb9e62009-12-14 12:49:58 +11008563MODULE_DESCRIPTION("MD RAID framework");
NeilBrownaa1595e2005-08-04 12:53:32 -07008564MODULE_ALIAS("md");
NeilBrown72008652005-08-26 18:34:15 -07008565MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);