md.c 233.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
   md.c : Multiple Devices driver for Linux
3
     Copyright (C) 1998, 1999, 2000 Ingo Molnar
L
Linus Torvalds 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

     completely rewritten, based on the MD driver code from Marc Zyngier

   Changes:

   - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
   - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
   - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
   - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
   - kmod support by: Cyrus Durgin
   - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
   - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>

   - lots of fixes and improvements to the RAID1/RAID5 and generic
     RAID code (such as request based resynchronization):

     Neil Brown <neilb@cse.unsw.edu.au>.

22 23 24
   - persistent bitmap code
     Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.

L
Linus Torvalds 已提交
25 26 27 28 29 30 31 32 33 34
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   You should have received a copy of the GNU General Public License
   (for example /usr/src/linux/COPYING); if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

35
#include <linux/kthread.h>
36
#include <linux/blkdev.h>
L
Linus Torvalds 已提交
37
#include <linux/sysctl.h>
38
#include <linux/seq_file.h>
A
Al Viro 已提交
39
#include <linux/fs.h>
40
#include <linux/poll.h>
41
#include <linux/ctype.h>
42
#include <linux/string.h>
43 44 45
#include <linux/hdreg.h>
#include <linux/proc_fs.h>
#include <linux/random.h>
46
#include <linux/module.h>
47
#include <linux/reboot.h>
48
#include <linux/file.h>
49
#include <linux/compat.h>
50
#include <linux/delay.h>
51 52
#include <linux/raid/md_p.h>
#include <linux/raid/md_u.h>
53
#include <linux/slab.h>
54
#include "md.h"
55
#include "bitmap.h"
56
#include "md-cluster.h"
L
Linus Torvalds 已提交
57 58

#ifndef MODULE
59
static void autostart_arrays(int part);
L
Linus Torvalds 已提交
60 61
#endif

62 63 64 65 66
/* pers_list is a list of registered personalities protected
 * by pers_lock.
 * pers_lock does extra service to protect accesses to
 * mddev->thread when the mutex cannot be held.
 */
67
static LIST_HEAD(pers_list);
L
Linus Torvalds 已提交
68 69
static DEFINE_SPINLOCK(pers_lock);

70
struct md_cluster_operations *md_cluster_ops;
71
EXPORT_SYMBOL(md_cluster_ops);
72 73 74
struct module *md_cluster_mod;
EXPORT_SYMBOL(md_cluster_mod);

75
static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
T
Tejun Heo 已提交
76 77
static struct workqueue_struct *md_wq;
static struct workqueue_struct *md_misc_wq;
78

79 80
static int remove_and_add_spares(struct mddev *mddev,
				 struct md_rdev *this);
81
static void mddev_detach(struct mddev *mddev);
82

83 84 85 86 87 88
/*
 * Default number of read corrections we'll attempt on an rdev
 * before ejecting it from the array. We divide the read error
 * count by 2 for every hour elapsed between read errors.
 */
#define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
L
Linus Torvalds 已提交
89 90 91 92
/*
 * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
 * is 1000 KB/sec, so the extra system load does not show up that much.
 * Increase it if you want to have more _guaranteed_ speed. Note that
93
 * the RAID driver will use the maximum available bandwidth if the IO
L
Linus Torvalds 已提交
94 95 96 97 98
 * subsystem is idle. There is also an 'absolute maximum' reconstruction
 * speed limit - in case reconstruction slows down your system despite
 * idle IO detection.
 *
 * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
99
 * or /sys/block/mdX/md/sync_speed_{min,max}
L
Linus Torvalds 已提交
100 101 102 103
 */

static int sysctl_speed_limit_min = 1000;
static int sysctl_speed_limit_max = 200000;
104
static inline int speed_min(struct mddev *mddev)
105 106 107 108 109
{
	return mddev->sync_speed_min ?
		mddev->sync_speed_min : sysctl_speed_limit_min;
}

110
static inline int speed_max(struct mddev *mddev)
111 112 113 114
{
	return mddev->sync_speed_max ?
		mddev->sync_speed_max : sysctl_speed_limit_max;
}
L
Linus Torvalds 已提交
115 116 117

static struct ctl_table_header *raid_table_header;

118
static struct ctl_table raid_table[] = {
L
Linus Torvalds 已提交
119 120 121 122
	{
		.procname	= "speed_limit_min",
		.data		= &sysctl_speed_limit_min,
		.maxlen		= sizeof(int),
123
		.mode		= S_IRUGO|S_IWUSR,
124
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
125 126 127 128 129
	},
	{
		.procname	= "speed_limit_max",
		.data		= &sysctl_speed_limit_max,
		.maxlen		= sizeof(int),
130
		.mode		= S_IRUGO|S_IWUSR,
131
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
132
	},
133
	{ }
L
Linus Torvalds 已提交
134 135
};

136
static struct ctl_table raid_dir_table[] = {
L
Linus Torvalds 已提交
137 138 139
	{
		.procname	= "raid",
		.maxlen		= 0,
140
		.mode		= S_IRUGO|S_IXUGO,
L
Linus Torvalds 已提交
141 142
		.child		= raid_table,
	},
143
	{ }
L
Linus Torvalds 已提交
144 145
};

146
static struct ctl_table raid_root_table[] = {
L
Linus Torvalds 已提交
147 148 149 150 151 152
	{
		.procname	= "dev",
		.maxlen		= 0,
		.mode		= 0555,
		.child		= raid_dir_table,
	},
153
	{  }
L
Linus Torvalds 已提交
154 155
};

156
static const struct block_device_operations md_fops;
L
Linus Torvalds 已提交
157

158 159
static int start_readonly;

160 161 162 163 164
/* bio_clone_mddev
 * like bio_clone, but with a local bio set
 */

struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
165
			    struct mddev *mddev)
166 167 168 169 170 171
{
	struct bio *b;

	if (!mddev || !mddev->bio_set)
		return bio_alloc(gfp_mask, nr_iovecs);

172
	b = bio_alloc_bioset(gfp_mask, nr_iovecs, mddev->bio_set);
173 174 175 176 177 178 179
	if (!b)
		return NULL;
	return b;
}
EXPORT_SYMBOL_GPL(bio_alloc_mddev);

struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
180
			    struct mddev *mddev)
181 182 183 184
{
	if (!mddev || !mddev->bio_set)
		return bio_clone(bio, gfp_mask);

185
	return bio_clone_bioset(bio, gfp_mask, mddev->bio_set);
186 187 188
}
EXPORT_SYMBOL_GPL(bio_clone_mddev);

189 190 191 192 193 194 195 196 197 198
/*
 * We have a system wide 'event count' that is incremented
 * on any 'interesting' event, and readers of /proc/mdstat
 * can use 'poll' or 'select' to find out when the event
 * count increases.
 *
 * Events are:
 *  start array, stop array, error, add device, remove device,
 *  start build, activate spare
 */
199
static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
200
static atomic_t md_event_count;
201
void md_new_event(struct mddev *mddev)
202 203 204 205
{
	atomic_inc(&md_event_count);
	wake_up(&md_event_waiters);
}
206
EXPORT_SYMBOL_GPL(md_new_event);
207

208 209 210
/* Alternate version that can be called from interrupts
 * when calling sysfs_notify isn't needed.
 */
211
static void md_new_event_inintr(struct mddev *mddev)
212 213 214 215 216
{
	atomic_inc(&md_event_count);
	wake_up(&md_event_waiters);
}

L
Linus Torvalds 已提交
217 218 219 220 221 222 223 224 225 226 227 228 229 230
/*
 * Enables to iterate over all existing md arrays
 * all_mddevs_lock protects this list.
 */
static LIST_HEAD(all_mddevs);
static DEFINE_SPINLOCK(all_mddevs_lock);

/*
 * iterates through all used mddevs in the system.
 * We take care to grab the all_mddevs_lock whenever navigating
 * the list, and to always hold a refcount when unlocked.
 * Any code which breaks out of this loop while own
 * a reference to the current mddev and must mddev_put it.
 */
231
#define for_each_mddev(_mddev,_tmp)					\
L
Linus Torvalds 已提交
232
									\
233
	for (({ spin_lock(&all_mddevs_lock);				\
234 235 236 237
		_tmp = all_mddevs.next;					\
		_mddev = NULL;});					\
	     ({ if (_tmp != &all_mddevs)				\
			mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\
L
Linus Torvalds 已提交
238
		spin_unlock(&all_mddevs_lock);				\
239 240 241
		if (_mddev) mddev_put(_mddev);				\
		_mddev = list_entry(_tmp, struct mddev, all_mddevs);	\
		_tmp != &all_mddevs;});					\
L
Linus Torvalds 已提交
242
	     ({ spin_lock(&all_mddevs_lock);				\
243
		_tmp = _tmp->next;})					\
L
Linus Torvalds 已提交
244 245
		)

246 247 248 249 250 251 252
/* Rather than calling directly into the personality make_request function,
 * IO requests come here first so that we can check if the device is
 * being suspended pending a reconfiguration.
 * We hold a refcount over the call to ->make_request.  By the time that
 * call has finished, the bio has been linked into some internal structure
 * and so is visible to ->quiesce(), so we don't need the refcount any more.
 */
253
static void md_make_request(struct request_queue *q, struct bio *bio)
L
Linus Torvalds 已提交
254
{
255
	const int rw = bio_data_dir(bio);
256
	struct mddev *mddev = q->queuedata;
257
	unsigned int sectors;
G
Gu Zheng 已提交
258
	int cpu;
259

260 261
	blk_queue_split(q, &bio, q->bio_split);

262 263
	if (mddev == NULL || mddev->pers == NULL
	    || !mddev->ready) {
264
		bio_io_error(bio);
265
		return;
266
	}
267
	if (mddev->ro == 1 && unlikely(rw == WRITE)) {
268 269 270
		if (bio_sectors(bio) != 0)
			bio->bi_error = -EROFS;
		bio_endio(bio);
271 272
		return;
	}
273
	smp_rmb(); /* Ensure implications of  'active' are visible */
274
	rcu_read_lock();
T
Tejun Heo 已提交
275
	if (mddev->suspended) {
276 277 278 279
		DEFINE_WAIT(__wait);
		for (;;) {
			prepare_to_wait(&mddev->sb_wait, &__wait,
					TASK_UNINTERRUPTIBLE);
T
Tejun Heo 已提交
280
			if (!mddev->suspended)
281 282 283 284 285 286 287 288 289
				break;
			rcu_read_unlock();
			schedule();
			rcu_read_lock();
		}
		finish_wait(&mddev->sb_wait, &__wait);
	}
	atomic_inc(&mddev->active_io);
	rcu_read_unlock();
290

291 292 293 294 295
	/*
	 * save the sectors now since our bio can
	 * go away inside make_request
	 */
	sectors = bio_sectors(bio);
296
	mddev->pers->make_request(mddev, bio);
297

G
Gu Zheng 已提交
298 299 300 301
	cpu = part_stat_lock();
	part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
	part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors);
	part_stat_unlock();
302

303 304 305 306
	if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
		wake_up(&mddev->sb_wait);
}

307 308 309
/* mddev_suspend makes sure no new requests are submitted
 * to the device, and that any requests that have been submitted
 * are completely handled.
N
NeilBrown 已提交
310 311
 * Once mddev_detach() is called and completes, the module will be
 * completely unused.
312
 */
313
void mddev_suspend(struct mddev *mddev)
314 315 316 317 318 319
{
	BUG_ON(mddev->suspended);
	mddev->suspended = 1;
	synchronize_rcu();
	wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
	mddev->pers->quiesce(mddev, 1);
320 321

	del_timer_sync(&mddev->safemode_timer);
322
}
323
EXPORT_SYMBOL_GPL(mddev_suspend);
324

325
void mddev_resume(struct mddev *mddev)
326 327 328 329
{
	mddev->suspended = 0;
	wake_up(&mddev->sb_wait);
	mddev->pers->quiesce(mddev, 0);
330

331
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
332 333
	md_wakeup_thread(mddev->thread);
	md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
L
Linus Torvalds 已提交
334
}
335
EXPORT_SYMBOL_GPL(mddev_resume);
L
Linus Torvalds 已提交
336

337
int mddev_congested(struct mddev *mddev, int bits)
338
{
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
	struct md_personality *pers = mddev->pers;
	int ret = 0;

	rcu_read_lock();
	if (mddev->suspended)
		ret = 1;
	else if (pers && pers->congested)
		ret = pers->congested(mddev, bits);
	rcu_read_unlock();
	return ret;
}
EXPORT_SYMBOL_GPL(mddev_congested);
static int md_congested(void *data, int bits)
{
	struct mddev *mddev = data;
	return mddev_congested(mddev, bits);
355 356
}

357
/*
T
Tejun Heo 已提交
358
 * Generic flush handling for md
359 360
 */

361
static void md_end_flush(struct bio *bio)
362
{
363
	struct md_rdev *rdev = bio->bi_private;
364
	struct mddev *mddev = rdev->mddev;
365 366 367 368

	rdev_dec_pending(rdev, mddev);

	if (atomic_dec_and_test(&mddev->flush_pending)) {
T
Tejun Heo 已提交
369
		/* The pre-request flush has finished */
T
Tejun Heo 已提交
370
		queue_work(md_wq, &mddev->flush_work);
371 372 373 374
	}
	bio_put(bio);
}

N
NeilBrown 已提交
375 376
static void md_submit_flush_data(struct work_struct *ws);

377
static void submit_flushes(struct work_struct *ws)
378
{
379
	struct mddev *mddev = container_of(ws, struct mddev, flush_work);
380
	struct md_rdev *rdev;
381

N
NeilBrown 已提交
382 383
	INIT_WORK(&mddev->flush_work, md_submit_flush_data);
	atomic_set(&mddev->flush_pending, 1);
384
	rcu_read_lock();
N
NeilBrown 已提交
385
	rdev_for_each_rcu(rdev, mddev)
386 387 388 389 390 391 392 393 394 395
		if (rdev->raid_disk >= 0 &&
		    !test_bit(Faulty, &rdev->flags)) {
			/* Take two references, one is dropped
			 * when request finishes, one after
			 * we reclaim rcu_read_lock
			 */
			struct bio *bi;
			atomic_inc(&rdev->nr_pending);
			atomic_inc(&rdev->nr_pending);
			rcu_read_unlock();
396
			bi = bio_alloc_mddev(GFP_NOIO, 0, mddev);
T
Tejun Heo 已提交
397
			bi->bi_end_io = md_end_flush;
398 399 400
			bi->bi_private = rdev;
			bi->bi_bdev = rdev->bdev;
			atomic_inc(&mddev->flush_pending);
T
Tejun Heo 已提交
401
			submit_bio(WRITE_FLUSH, bi);
402 403 404 405
			rcu_read_lock();
			rdev_dec_pending(rdev, mddev);
		}
	rcu_read_unlock();
N
NeilBrown 已提交
406 407
	if (atomic_dec_and_test(&mddev->flush_pending))
		queue_work(md_wq, &mddev->flush_work);
408 409
}

T
Tejun Heo 已提交
410
static void md_submit_flush_data(struct work_struct *ws)
411
{
412
	struct mddev *mddev = container_of(ws, struct mddev, flush_work);
T
Tejun Heo 已提交
413
	struct bio *bio = mddev->flush_bio;
414

415
	if (bio->bi_iter.bi_size == 0)
416
		/* an empty barrier - all done */
417
		bio_endio(bio);
418
	else {
T
Tejun Heo 已提交
419
		bio->bi_rw &= ~REQ_FLUSH;
420
		mddev->pers->make_request(mddev, bio);
421
	}
422 423 424

	mddev->flush_bio = NULL;
	wake_up(&mddev->sb_wait);
425 426
}

427
void md_flush_request(struct mddev *mddev, struct bio *bio)
428
{
429
	spin_lock_irq(&mddev->lock);
430
	wait_event_lock_irq(mddev->sb_wait,
T
Tejun Heo 已提交
431
			    !mddev->flush_bio,
432
			    mddev->lock);
T
Tejun Heo 已提交
433
	mddev->flush_bio = bio;
434
	spin_unlock_irq(&mddev->lock);
435

436 437
	INIT_WORK(&mddev->flush_work, submit_flushes);
	queue_work(md_wq, &mddev->flush_work);
438
}
T
Tejun Heo 已提交
439
EXPORT_SYMBOL(md_flush_request);
440

441
void md_unplug(struct blk_plug_cb *cb, bool from_schedule)
442
{
443 444 445
	struct mddev *mddev = cb->data;
	md_wakeup_thread(mddev->thread);
	kfree(cb);
446
}
447
EXPORT_SYMBOL(md_unplug);
448

449
static inline struct mddev *mddev_get(struct mddev *mddev)
L
Linus Torvalds 已提交
450 451 452 453 454
{
	atomic_inc(&mddev->active);
	return mddev;
}

455
static void mddev_delayed_delete(struct work_struct *ws);
456

457
static void mddev_put(struct mddev *mddev)
L
Linus Torvalds 已提交
458
{
459 460
	struct bio_set *bs = NULL;

L
Linus Torvalds 已提交
461 462
	if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
		return;
463
	if (!mddev->raid_disks && list_empty(&mddev->disks) &&
464 465 466
	    mddev->ctime == 0 && !mddev->hold_active) {
		/* Array is not configured at all, and not held active,
		 * so destroy it */
467
		list_del_init(&mddev->all_mddevs);
468 469
		bs = mddev->bio_set;
		mddev->bio_set = NULL;
470
		if (mddev->gendisk) {
T
Tejun Heo 已提交
471 472 473 474
			/* We did a probe so need to clean up.  Call
			 * queue_work inside the spinlock so that
			 * flush_workqueue() after mddev_find will
			 * succeed in waiting for the work to be done.
475 476
			 */
			INIT_WORK(&mddev->del_work, mddev_delayed_delete);
T
Tejun Heo 已提交
477
			queue_work(md_misc_wq, &mddev->del_work);
478 479 480 481
		} else
			kfree(mddev);
	}
	spin_unlock(&all_mddevs_lock);
482 483
	if (bs)
		bioset_free(bs);
L
Linus Torvalds 已提交
484 485
}

486 487
static void md_safemode_timeout(unsigned long data);

488
void mddev_init(struct mddev *mddev)
489 490 491 492 493 494
{
	mutex_init(&mddev->open_mutex);
	mutex_init(&mddev->reconfig_mutex);
	mutex_init(&mddev->bitmap_info.mutex);
	INIT_LIST_HEAD(&mddev->disks);
	INIT_LIST_HEAD(&mddev->all_mddevs);
495 496
	setup_timer(&mddev->safemode_timer, md_safemode_timeout,
		    (unsigned long) mddev);
497 498 499
	atomic_set(&mddev->active, 1);
	atomic_set(&mddev->openers, 0);
	atomic_set(&mddev->active_io, 0);
500
	spin_lock_init(&mddev->lock);
501 502 503 504
	atomic_set(&mddev->flush_pending, 0);
	init_waitqueue_head(&mddev->sb_wait);
	init_waitqueue_head(&mddev->recovery_wait);
	mddev->reshape_position = MaxSector;
505
	mddev->reshape_backwards = 0;
506
	mddev->last_sync_action = "none";
507 508 509 510
	mddev->resync_min = 0;
	mddev->resync_max = MaxSector;
	mddev->level = LEVEL_NONE;
}
511
EXPORT_SYMBOL_GPL(mddev_init);
512

513
static struct mddev *mddev_find(dev_t unit)
L
Linus Torvalds 已提交
514
{
515
	struct mddev *mddev, *new = NULL;
L
Linus Torvalds 已提交
516

517 518 519
	if (unit && MAJOR(unit) != MD_MAJOR)
		unit &= ~((1<<MdpMinorShift)-1);

L
Linus Torvalds 已提交
520 521
 retry:
	spin_lock(&all_mddevs_lock);
522 523 524 525 526 527 528 529 530 531 532 533

	if (unit) {
		list_for_each_entry(mddev, &all_mddevs, all_mddevs)
			if (mddev->unit == unit) {
				mddev_get(mddev);
				spin_unlock(&all_mddevs_lock);
				kfree(new);
				return mddev;
			}

		if (new) {
			list_add(&new->all_mddevs, &all_mddevs);
L
Linus Torvalds 已提交
534
			spin_unlock(&all_mddevs_lock);
535 536
			new->hold_active = UNTIL_IOCTL;
			return new;
L
Linus Torvalds 已提交
537
		}
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
	} else if (new) {
		/* find an unused unit number */
		static int next_minor = 512;
		int start = next_minor;
		int is_free = 0;
		int dev = 0;
		while (!is_free) {
			dev = MKDEV(MD_MAJOR, next_minor);
			next_minor++;
			if (next_minor > MINORMASK)
				next_minor = 0;
			if (next_minor == start) {
				/* Oh dear, all in use. */
				spin_unlock(&all_mddevs_lock);
				kfree(new);
				return NULL;
			}
555

556 557 558 559 560 561 562 563 564 565
			is_free = 1;
			list_for_each_entry(mddev, &all_mddevs, all_mddevs)
				if (mddev->unit == dev) {
					is_free = 0;
					break;
				}
		}
		new->unit = dev;
		new->md_minor = MINOR(dev);
		new->hold_active = UNTIL_STOP;
L
Linus Torvalds 已提交
566 567 568 569 570 571
		list_add(&new->all_mddevs, &all_mddevs);
		spin_unlock(&all_mddevs_lock);
		return new;
	}
	spin_unlock(&all_mddevs_lock);

572
	new = kzalloc(sizeof(*new), GFP_KERNEL);
L
Linus Torvalds 已提交
573 574 575 576 577 578 579 580 581
	if (!new)
		return NULL;

	new->unit = unit;
	if (MAJOR(unit) == MD_MAJOR)
		new->md_minor = MINOR(unit);
	else
		new->md_minor = MINOR(unit) >> MdpMinorShift;

582
	mddev_init(new);
L
Linus Torvalds 已提交
583 584 585 586

	goto retry;
}

587 588
static struct attribute_group md_redundancy_group;

589
void mddev_unlock(struct mddev *mddev)
L
Linus Torvalds 已提交
590
{
591
	if (mddev->to_remove) {
592 593 594 595
		/* These cannot be removed under reconfig_mutex as
		 * an access to the files will try to take reconfig_mutex
		 * while holding the file unremovable, which leads to
		 * a deadlock.
596 597 598 599 600 601 602
		 * So hold set sysfs_active while the remove in happeing,
		 * and anything else which might set ->to_remove or my
		 * otherwise change the sysfs namespace will fail with
		 * -EBUSY if sysfs_active is still set.
		 * We set sysfs_active under reconfig_mutex and elsewhere
		 * test it under the same mutex to ensure its correct value
		 * is seen.
603
		 */
604 605
		struct attribute_group *to_remove = mddev->to_remove;
		mddev->to_remove = NULL;
606
		mddev->sysfs_active = 1;
607 608
		mutex_unlock(&mddev->reconfig_mutex);

N
NeilBrown 已提交
609 610 611 612 613 614 615 616 617 618
		if (mddev->kobj.sd) {
			if (to_remove != &md_redundancy_group)
				sysfs_remove_group(&mddev->kobj, to_remove);
			if (mddev->pers == NULL ||
			    mddev->pers->sync_request == NULL) {
				sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
				if (mddev->sysfs_action)
					sysfs_put(mddev->sysfs_action);
				mddev->sysfs_action = NULL;
			}
619
		}
620
		mddev->sysfs_active = 0;
621 622
	} else
		mutex_unlock(&mddev->reconfig_mutex);
L
Linus Torvalds 已提交
623

C
Chris Dunlop 已提交
624 625
	/* As we've dropped the mutex we need a spinlock to
	 * make sure the thread doesn't disappear
626 627
	 */
	spin_lock(&pers_lock);
628
	md_wakeup_thread(mddev->thread);
629
	spin_unlock(&pers_lock);
L
Linus Torvalds 已提交
630
}
631
EXPORT_SYMBOL_GPL(mddev_unlock);
L
Linus Torvalds 已提交
632

633
struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr)
634 635 636 637 638 639 640 641 642
{
	struct md_rdev *rdev;

	rdev_for_each_rcu(rdev, mddev)
		if (rdev->desc_nr == nr)
			return rdev;

	return NULL;
}
643
EXPORT_SYMBOL_GPL(md_find_rdev_nr_rcu);
644 645

static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)
L
Linus Torvalds 已提交
646
{
647
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
648

N
NeilBrown 已提交
649
	rdev_for_each(rdev, mddev)
L
Linus Torvalds 已提交
650 651
		if (rdev->bdev->bd_dev == dev)
			return rdev;
652

L
Linus Torvalds 已提交
653 654 655
	return NULL;
}

656 657 658 659 660 661 662 663 664 665 666
static struct md_rdev *find_rdev_rcu(struct mddev *mddev, dev_t dev)
{
	struct md_rdev *rdev;

	rdev_for_each_rcu(rdev, mddev)
		if (rdev->bdev->bd_dev == dev)
			return rdev;

	return NULL;
}

667
static struct md_personality *find_pers(int level, char *clevel)
668
{
669
	struct md_personality *pers;
670 671
	list_for_each_entry(pers, &pers_list, list) {
		if (level != LEVEL_NONE && pers->level == level)
672
			return pers;
673 674 675
		if (strcmp(pers->name, clevel)==0)
			return pers;
	}
676 677 678
	return NULL;
}

679
/* return the offset of the super block in 512byte sectors */
680
static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
L
Linus Torvalds 已提交
681
{
682
	sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
683
	return MD_NEW_SIZE_SECTORS(num_sectors);
L
Linus Torvalds 已提交
684 685
}

686
static int alloc_disk_sb(struct md_rdev *rdev)
L
Linus Torvalds 已提交
687 688 689 690
{
	rdev->sb_page = alloc_page(GFP_KERNEL);
	if (!rdev->sb_page) {
		printk(KERN_ALERT "md: out of memory.\n");
691
		return -ENOMEM;
L
Linus Torvalds 已提交
692 693 694 695 696
	}

	return 0;
}

697
void md_rdev_clear(struct md_rdev *rdev)
L
Linus Torvalds 已提交
698 699
{
	if (rdev->sb_page) {
700
		put_page(rdev->sb_page);
L
Linus Torvalds 已提交
701 702
		rdev->sb_loaded = 0;
		rdev->sb_page = NULL;
703
		rdev->sb_start = 0;
704
		rdev->sectors = 0;
L
Linus Torvalds 已提交
705
	}
706 707 708 709
	if (rdev->bb_page) {
		put_page(rdev->bb_page);
		rdev->bb_page = NULL;
	}
710 711
	kfree(rdev->badblocks.page);
	rdev->badblocks.page = NULL;
L
Linus Torvalds 已提交
712
}
713
EXPORT_SYMBOL_GPL(md_rdev_clear);
L
Linus Torvalds 已提交
714

715
static void super_written(struct bio *bio)
716
{
717
	struct md_rdev *rdev = bio->bi_private;
718
	struct mddev *mddev = rdev->mddev;
719

720 721
	if (bio->bi_error) {
		printk("md: super_written gets error=%d\n", bio->bi_error);
722
		md_error(mddev, rdev);
723
	}
724

725 726
	if (atomic_dec_and_test(&mddev->pending_writes))
		wake_up(&mddev->sb_wait);
N
Neil Brown 已提交
727
	bio_put(bio);
728 729
}

730
void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
731 732 733 734 735 736 737 738
		   sector_t sector, int size, struct page *page)
{
	/* write first size bytes of page to sector of rdev
	 * Increment mddev->pending_writes before returning
	 * and decrement it on completion, waking up sb_wait
	 * if zero is reached.
	 * If an error occurred, call md_error
	 */
739
	struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, mddev);
740

741
	bio->bi_bdev = rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev;
742
	bio->bi_iter.bi_sector = sector;
743 744 745
	bio_add_page(bio, page, size, 0);
	bio->bi_private = rdev;
	bio->bi_end_io = super_written;
746

747
	atomic_inc(&mddev->pending_writes);
748
	submit_bio(WRITE_FLUSH_FUA, bio);
749 750
}

751
void md_super_wait(struct mddev *mddev)
752
{
T
Tejun Heo 已提交
753
	/* wait for all superblock writes that were scheduled to complete */
754
	wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
755 756
}

757
int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
J
Jonathan Brassow 已提交
758
		 struct page *page, int rw, bool metadata_op)
L
Linus Torvalds 已提交
759
{
760
	struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev);
L
Linus Torvalds 已提交
761 762
	int ret;

763 764
	bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
		rdev->meta_bdev : rdev->bdev;
J
Jonathan Brassow 已提交
765
	if (metadata_op)
766
		bio->bi_iter.bi_sector = sector + rdev->sb_start;
767 768 769
	else if (rdev->mddev->reshape_position != MaxSector &&
		 (rdev->mddev->reshape_backwards ==
		  (sector >= rdev->mddev->reshape_position)))
770
		bio->bi_iter.bi_sector = sector + rdev->new_data_offset;
J
Jonathan Brassow 已提交
771
	else
772
		bio->bi_iter.bi_sector = sector + rdev->data_offset;
L
Linus Torvalds 已提交
773
	bio_add_page(bio, page, size, 0);
774
	submit_bio_wait(rw, bio);
L
Linus Torvalds 已提交
775

776
	ret = !bio->bi_error;
L
Linus Torvalds 已提交
777 778 779
	bio_put(bio);
	return ret;
}
780
EXPORT_SYMBOL_GPL(sync_page_io);
L
Linus Torvalds 已提交
781

782
static int read_disk_sb(struct md_rdev *rdev, int size)
L
Linus Torvalds 已提交
783 784
{
	char b[BDEVNAME_SIZE];
N
NeilBrown 已提交
785

L
Linus Torvalds 已提交
786 787 788
	if (rdev->sb_loaded)
		return 0;

J
Jonathan Brassow 已提交
789
	if (!sync_page_io(rdev, 0, size, rdev->sb_page, READ, true))
L
Linus Torvalds 已提交
790 791 792 793 794 795 796 797 798 799 800 801
		goto fail;
	rdev->sb_loaded = 1;
	return 0;

fail:
	printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
		bdevname(rdev->bdev,b));
	return -EINVAL;
}

static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
{
802
	return	sb1->set_uuid0 == sb2->set_uuid0 &&
A
Andre Noll 已提交
803 804 805
		sb1->set_uuid1 == sb2->set_uuid1 &&
		sb1->set_uuid2 == sb2->set_uuid2 &&
		sb1->set_uuid3 == sb2->set_uuid3;
L
Linus Torvalds 已提交
806 807 808 809 810 811 812 813 814 815 816 817
}

static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
{
	int ret;
	mdp_super_t *tmp1, *tmp2;

	tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
	tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);

	if (!tmp1 || !tmp2) {
		ret = 0;
818
		printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
L
Linus Torvalds 已提交
819 820 821 822 823 824 825 826 827 828 829 830
		goto abort;
	}

	*tmp1 = *sb1;
	*tmp2 = *sb2;

	/*
	 * nr_disks is not constant
	 */
	tmp1->nr_disks = 0;
	tmp2->nr_disks = 0;

A
Andre Noll 已提交
831
	ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
L
Linus Torvalds 已提交
832
abort:
833 834
	kfree(tmp1);
	kfree(tmp2);
L
Linus Torvalds 已提交
835 836 837
	return ret;
}

838 839 840 841 842 843
static u32 md_csum_fold(u32 csum)
{
	csum = (csum & 0xffff) + (csum >> 16);
	return (csum & 0xffff) + (csum >> 16);
}

844
static unsigned int calc_sb_csum(mdp_super_t *sb)
L
Linus Torvalds 已提交
845
{
846 847 848
	u64 newcsum = 0;
	u32 *sb32 = (u32*)sb;
	int i;
L
Linus Torvalds 已提交
849 850 851 852
	unsigned int disk_csum, csum;

	disk_csum = sb->sb_csum;
	sb->sb_csum = 0;
853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868

	for (i = 0; i < MD_SB_BYTES/4 ; i++)
		newcsum += sb32[i];
	csum = (newcsum & 0xffffffff) + (newcsum>>32);

#ifdef CONFIG_ALPHA
	/* This used to use csum_partial, which was wrong for several
	 * reasons including that different results are returned on
	 * different architectures.  It isn't critical that we get exactly
	 * the same return value as before (we always csum_fold before
	 * testing, and that removes any differences).  However as we
	 * know that csum_partial always returned a 16bit value on
	 * alphas, do a fold to maximise conformity to previous behaviour.
	 */
	sb->sb_csum = md_csum_fold(disk_csum);
#else
L
Linus Torvalds 已提交
869
	sb->sb_csum = disk_csum;
870
#endif
L
Linus Torvalds 已提交
871 872 873 874 875 876 877 878 879 880 881
	return csum;
}

/*
 * Handle superblock details.
 * We want to be able to handle multiple superblock formats
 * so we have a common interface to them all, and an array of
 * different handlers.
 * We rely on user-space to write the initial superblock, and support
 * reading and updating of superblocks.
 * Interface methods are:
882
 *   int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
L
Linus Torvalds 已提交
883 884 885 886 887 888 889 890 891
 *      loads and validates a superblock on dev.
 *      if refdev != NULL, compare superblocks on both devices
 *    Return:
 *      0 - dev has a superblock that is compatible with refdev
 *      1 - dev has a superblock that is compatible and newer than refdev
 *          so dev should be used as the refdev in future
 *     -EINVAL superblock incompatible or invalid
 *     -othererror e.g. -EIO
 *
892
 *   int validate_super(struct mddev *mddev, struct md_rdev *dev)
L
Linus Torvalds 已提交
893 894 895 896 897
 *      Verify that dev is acceptable into mddev.
 *       The first time, mddev->raid_disks will be 0, and data from
 *       dev should be merged in.  Subsequent calls check that dev
 *       is new enough.  Return 0 or -EINVAL
 *
898
 *   void sync_super(struct mddev *mddev, struct md_rdev *dev)
L
Linus Torvalds 已提交
899 900 901 902 903 904
 *     Update the superblock for rdev with data in mddev
 *     This does not write to disc.
 *
 */

struct super_type  {
905 906
	char		    *name;
	struct module	    *owner;
907 908
	int		    (*load_super)(struct md_rdev *rdev,
					  struct md_rdev *refdev,
909
					  int minor_version);
910 911 912 913
	int		    (*validate_super)(struct mddev *mddev,
					      struct md_rdev *rdev);
	void		    (*sync_super)(struct mddev *mddev,
					  struct md_rdev *rdev);
914
	unsigned long long  (*rdev_size_change)(struct md_rdev *rdev,
915
						sector_t num_sectors);
916 917
	int		    (*allow_new_offset)(struct md_rdev *rdev,
						unsigned long long new_offset);
L
Linus Torvalds 已提交
918 919
};

920 921 922 923 924 925 926 927
/*
 * Check that the given mddev has no bitmap.
 *
 * This function is called from the run method of all personalities that do not
 * support bitmaps. It prints an error message and returns non-zero if mddev
 * has a bitmap. Otherwise, it returns 0.
 *
 */
928
int md_check_no_bitmap(struct mddev *mddev)
929
{
930
	if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
931 932 933 934 935 936 937
		return 0;
	printk(KERN_ERR "%s: bitmaps are not supported for %s\n",
		mdname(mddev), mddev->pers->name);
	return 1;
}
EXPORT_SYMBOL(md_check_no_bitmap);

L
Linus Torvalds 已提交
938
/*
939
 * load_super for 0.90.0
L
Linus Torvalds 已提交
940
 */
941
static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
L
Linus Torvalds 已提交
942 943 944 945 946 947
{
	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
	mdp_super_t *sb;
	int ret;

	/*
948
	 * Calculate the position of the superblock (512byte sectors),
L
Linus Torvalds 已提交
949 950 951 952
	 * it's at the end of the disk.
	 *
	 * It also happens to be a multiple of 4Kb.
	 */
953
	rdev->sb_start = calc_dev_sboffset(rdev);
L
Linus Torvalds 已提交
954

955
	ret = read_disk_sb(rdev, MD_SB_BYTES);
L
Linus Torvalds 已提交
956 957 958 959 960
	if (ret) return ret;

	ret = -EINVAL;

	bdevname(rdev->bdev, b);
961
	sb = page_address(rdev->sb_page);
L
Linus Torvalds 已提交
962 963 964 965 966 967 968 969

	if (sb->md_magic != MD_SB_MAGIC) {
		printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
		       b);
		goto abort;
	}

	if (sb->major_version != 0 ||
970 971
	    sb->minor_version < 90 ||
	    sb->minor_version > 91) {
L
Linus Torvalds 已提交
972 973 974 975 976 977 978 979 980
		printk(KERN_WARNING "Bad version number %d.%d on %s\n",
			sb->major_version, sb->minor_version,
			b);
		goto abort;
	}

	if (sb->raid_disks <= 0)
		goto abort;

981
	if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
L
Linus Torvalds 已提交
982 983 984 985 986 987 988
		printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
			b);
		goto abort;
	}

	rdev->preferred_minor = sb->md_minor;
	rdev->data_offset = 0;
989
	rdev->new_data_offset = 0;
990
	rdev->sb_size = MD_SB_BYTES;
991
	rdev->badblocks.shift = -1;
L
Linus Torvalds 已提交
992 993 994 995 996 997

	if (sb->level == LEVEL_MULTIPATH)
		rdev->desc_nr = -1;
	else
		rdev->desc_nr = sb->this_disk.number;

998
	if (!refdev) {
L
Linus Torvalds 已提交
999
		ret = 1;
1000
	} else {
L
Linus Torvalds 已提交
1001
		__u64 ev1, ev2;
1002
		mdp_super_t *refsb = page_address(refdev->sb_page);
L
Linus Torvalds 已提交
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
		if (!uuid_equal(refsb, sb)) {
			printk(KERN_WARNING "md: %s has different UUID to %s\n",
				b, bdevname(refdev->bdev,b2));
			goto abort;
		}
		if (!sb_equal(refsb, sb)) {
			printk(KERN_WARNING "md: %s has same UUID"
			       " but different superblock to %s\n",
			       b, bdevname(refdev->bdev, b2));
			goto abort;
		}
		ev1 = md_event(sb);
		ev2 = md_event(refsb);
		if (ev1 > ev2)
			ret = 1;
1018
		else
L
Linus Torvalds 已提交
1019 1020
			ret = 0;
	}
1021
	rdev->sectors = rdev->sb_start;
1022 1023 1024 1025 1026
	/* Limit to 4TB as metadata cannot record more than that.
	 * (not needed for Linear and RAID0 as metadata doesn't
	 * record this size)
	 */
	if (rdev->sectors >= (2ULL << 32) && sb->level >= 1)
1027
		rdev->sectors = (2ULL << 32) - 2;
L
Linus Torvalds 已提交
1028

1029
	if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
1030 1031 1032
		/* "this cannot possibly happen" ... */
		ret = -EINVAL;

L
Linus Torvalds 已提交
1033 1034 1035 1036 1037 1038 1039
 abort:
	return ret;
}

/*
 * validate_super for 0.90.0
 */
1040
static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
L
Linus Torvalds 已提交
1041 1042
{
	mdp_disk_t *desc;
1043
	mdp_super_t *sb = page_address(rdev->sb_page);
1044
	__u64 ev1 = md_event(sb);
L
Linus Torvalds 已提交
1045

1046
	rdev->raid_disk = -1;
1047 1048
	clear_bit(Faulty, &rdev->flags);
	clear_bit(In_sync, &rdev->flags);
1049
	clear_bit(Bitmap_sync, &rdev->flags);
1050 1051
	clear_bit(WriteMostly, &rdev->flags);

L
Linus Torvalds 已提交
1052 1053 1054 1055
	if (mddev->raid_disks == 0) {
		mddev->major_version = 0;
		mddev->minor_version = sb->minor_version;
		mddev->patch_version = sb->patch_version;
1056
		mddev->external = 0;
1057
		mddev->chunk_sectors = sb->chunk_size >> 9;
L
Linus Torvalds 已提交
1058 1059 1060
		mddev->ctime = sb->ctime;
		mddev->utime = sb->utime;
		mddev->level = sb->level;
1061
		mddev->clevel[0] = 0;
L
Linus Torvalds 已提交
1062 1063
		mddev->layout = sb->layout;
		mddev->raid_disks = sb->raid_disks;
1064
		mddev->dev_sectors = ((sector_t)sb->size) * 2;
1065
		mddev->events = ev1;
1066
		mddev->bitmap_info.offset = 0;
1067 1068
		mddev->bitmap_info.space = 0;
		/* bitmap can use 60 K after the 4K superblocks */
1069
		mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
1070
		mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
1071
		mddev->reshape_backwards = 0;
L
Linus Torvalds 已提交
1072

1073 1074 1075 1076 1077
		if (mddev->minor_version >= 91) {
			mddev->reshape_position = sb->reshape_position;
			mddev->delta_disks = sb->delta_disks;
			mddev->new_level = sb->new_level;
			mddev->new_layout = sb->new_layout;
1078
			mddev->new_chunk_sectors = sb->new_chunk >> 9;
1079 1080
			if (mddev->delta_disks < 0)
				mddev->reshape_backwards = 1;
1081 1082 1083 1084 1085
		} else {
			mddev->reshape_position = MaxSector;
			mddev->delta_disks = 0;
			mddev->new_level = mddev->level;
			mddev->new_layout = mddev->layout;
1086
			mddev->new_chunk_sectors = mddev->chunk_sectors;
1087 1088
		}

L
Linus Torvalds 已提交
1089 1090 1091
		if (sb->state & (1<<MD_SB_CLEAN))
			mddev->recovery_cp = MaxSector;
		else {
1092
			if (sb->events_hi == sb->cp_events_hi &&
L
Linus Torvalds 已提交
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
				sb->events_lo == sb->cp_events_lo) {
				mddev->recovery_cp = sb->recovery_cp;
			} else
				mddev->recovery_cp = 0;
		}

		memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
		memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
		memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
		memcpy(mddev->uuid+12,&sb->set_uuid3, 4);

		mddev->max_disks = MD_SB_DISKS;
1105 1106

		if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
1107
		    mddev->bitmap_info.file == NULL) {
1108 1109
			mddev->bitmap_info.offset =
				mddev->bitmap_info.default_offset;
1110
			mddev->bitmap_info.space =
1111
				mddev->bitmap_info.default_space;
1112
		}
1113

1114
	} else if (mddev->pers == NULL) {
1115 1116
		/* Insist on good event counter while assembling, except
		 * for spares (which don't need an event count) */
L
Linus Torvalds 已提交
1117
		++ev1;
1118 1119
		if (sb->disks[rdev->desc_nr].state & (
			    (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
1120
			if (ev1 < mddev->events)
1121
				return -EINVAL;
1122 1123 1124 1125 1126 1127
	} else if (mddev->bitmap) {
		/* if adding to array with a bitmap, then we can accept an
		 * older device ... but not too old.
		 */
		if (ev1 < mddev->bitmap->events_cleared)
			return 0;
1128 1129
		if (ev1 < mddev->events)
			set_bit(Bitmap_sync, &rdev->flags);
1130 1131 1132 1133 1134
	} else {
		if (ev1 < mddev->events)
			/* just a hot-add of a new device, leave raid_disk at -1 */
			return 0;
	}
1135

L
Linus Torvalds 已提交
1136 1137 1138 1139
	if (mddev->level != LEVEL_MULTIPATH) {
		desc = sb->disks + rdev->desc_nr;

		if (desc->state & (1<<MD_DISK_FAULTY))
1140
			set_bit(Faulty, &rdev->flags);
1141 1142
		else if (desc->state & (1<<MD_DISK_SYNC) /* &&
			    desc->raid_disk < mddev->raid_disks */) {
1143
			set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
1144
			rdev->raid_disk = desc->raid_disk;
1145
			rdev->saved_raid_disk = desc->raid_disk;
1146 1147 1148 1149 1150 1151 1152 1153
		} else if (desc->state & (1<<MD_DISK_ACTIVE)) {
			/* active but not in sync implies recovery up to
			 * reshape position.  We don't know exactly where
			 * that is, so set to zero for now */
			if (mddev->minor_version >= 91) {
				rdev->recovery_offset = 0;
				rdev->raid_disk = desc->raid_disk;
			}
L
Linus Torvalds 已提交
1154
		}
1155 1156
		if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);
1157
	} else /* MULTIPATH are always insync */
1158
		set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
1159 1160 1161 1162 1163 1164
	return 0;
}

/*
 * sync_super for 0.90.0
 */
1165
static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
L
Linus Torvalds 已提交
1166 1167
{
	mdp_super_t *sb;
1168
	struct md_rdev *rdev2;
L
Linus Torvalds 已提交
1169
	int next_spare = mddev->raid_disks;
1170

L
Linus Torvalds 已提交
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183
	/* make rdev->sb match mddev data..
	 *
	 * 1/ zero out disks
	 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
	 * 3/ any empty disks < next_spare become removed
	 *
	 * disks[0] gets initialised to REMOVED because
	 * we cannot be sure from other fields if it has
	 * been initialised or not.
	 */
	int i;
	int active=0, working=0,failed=0,spare=0,nr_disks=0;

1184 1185
	rdev->sb_size = MD_SB_BYTES;

1186
	sb = page_address(rdev->sb_page);
L
Linus Torvalds 已提交
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200

	memset(sb, 0, sizeof(*sb));

	sb->md_magic = MD_SB_MAGIC;
	sb->major_version = mddev->major_version;
	sb->patch_version = mddev->patch_version;
	sb->gvalid_words  = 0; /* ignored */
	memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
	memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
	memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
	memcpy(&sb->set_uuid3, mddev->uuid+12,4);

	sb->ctime = mddev->ctime;
	sb->level = mddev->level;
A
Andre Noll 已提交
1201
	sb->size = mddev->dev_sectors / 2;
L
Linus Torvalds 已提交
1202 1203
	sb->raid_disks = mddev->raid_disks;
	sb->md_minor = mddev->md_minor;
1204
	sb->not_persistent = 0;
L
Linus Torvalds 已提交
1205 1206 1207 1208 1209
	sb->utime = mddev->utime;
	sb->state = 0;
	sb->events_hi = (mddev->events>>32);
	sb->events_lo = (u32)mddev->events;

1210 1211 1212 1213 1214 1215 1216 1217
	if (mddev->reshape_position == MaxSector)
		sb->minor_version = 90;
	else {
		sb->minor_version = 91;
		sb->reshape_position = mddev->reshape_position;
		sb->new_level = mddev->new_level;
		sb->delta_disks = mddev->delta_disks;
		sb->new_layout = mddev->new_layout;
1218
		sb->new_chunk = mddev->new_chunk_sectors << 9;
1219 1220
	}
	mddev->minor_version = sb->minor_version;
L
Linus Torvalds 已提交
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
	if (mddev->in_sync)
	{
		sb->recovery_cp = mddev->recovery_cp;
		sb->cp_events_hi = (mddev->events>>32);
		sb->cp_events_lo = (u32)mddev->events;
		if (mddev->recovery_cp == MaxSector)
			sb->state = (1<< MD_SB_CLEAN);
	} else
		sb->recovery_cp = 0;

	sb->layout = mddev->layout;
1232
	sb->chunk_size = mddev->chunk_sectors << 9;
L
Linus Torvalds 已提交
1233

1234
	if (mddev->bitmap && mddev->bitmap_info.file == NULL)
1235 1236
		sb->state |= (1<<MD_SB_BITMAP_PRESENT);

L
Linus Torvalds 已提交
1237
	sb->disks[0].state = (1<<MD_DISK_REMOVED);
N
NeilBrown 已提交
1238
	rdev_for_each(rdev2, mddev) {
L
Linus Torvalds 已提交
1239
		mdp_disk_t *d;
1240
		int desc_nr;
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
		int is_active = test_bit(In_sync, &rdev2->flags);

		if (rdev2->raid_disk >= 0 &&
		    sb->minor_version >= 91)
			/* we have nowhere to store the recovery_offset,
			 * but if it is not below the reshape_position,
			 * we can piggy-back on that.
			 */
			is_active = 1;
		if (rdev2->raid_disk < 0 ||
		    test_bit(Faulty, &rdev2->flags))
			is_active = 0;
		if (is_active)
1254
			desc_nr = rdev2->raid_disk;
L
Linus Torvalds 已提交
1255
		else
1256
			desc_nr = next_spare++;
1257
		rdev2->desc_nr = desc_nr;
L
Linus Torvalds 已提交
1258 1259 1260 1261 1262
		d = &sb->disks[rdev2->desc_nr];
		nr_disks++;
		d->number = rdev2->desc_nr;
		d->major = MAJOR(rdev2->bdev->bd_dev);
		d->minor = MINOR(rdev2->bdev->bd_dev);
1263
		if (is_active)
L
Linus Torvalds 已提交
1264 1265 1266
			d->raid_disk = rdev2->raid_disk;
		else
			d->raid_disk = rdev2->desc_nr; /* compatibility */
1267
		if (test_bit(Faulty, &rdev2->flags))
L
Linus Torvalds 已提交
1268
			d->state = (1<<MD_DISK_FAULTY);
1269
		else if (is_active) {
L
Linus Torvalds 已提交
1270
			d->state = (1<<MD_DISK_ACTIVE);
1271 1272
			if (test_bit(In_sync, &rdev2->flags))
				d->state |= (1<<MD_DISK_SYNC);
L
Linus Torvalds 已提交
1273 1274 1275 1276 1277 1278 1279
			active++;
			working++;
		} else {
			d->state = 0;
			spare++;
			working++;
		}
1280 1281
		if (test_bit(WriteMostly, &rdev2->flags))
			d->state |= (1<<MD_DISK_WRITEMOSTLY);
L
Linus Torvalds 已提交
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
	}
	/* now set the "removed" and "faulty" bits on any missing devices */
	for (i=0 ; i < mddev->raid_disks ; i++) {
		mdp_disk_t *d = &sb->disks[i];
		if (d->state == 0 && d->number == 0) {
			d->number = i;
			d->raid_disk = i;
			d->state = (1<<MD_DISK_REMOVED);
			d->state |= (1<<MD_DISK_FAULTY);
			failed++;
		}
	}
	sb->nr_disks = nr_disks;
	sb->active_disks = active;
	sb->working_disks = working;
	sb->failed_disks = failed;
	sb->spare_disks = spare;

	sb->this_disk = sb->disks[rdev->desc_nr];
	sb->sb_csum = calc_sb_csum(sb);
}

1304 1305 1306 1307
/*
 * rdev_size_change for 0.90.0
 */
static unsigned long long
1308
super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1309
{
A
Andre Noll 已提交
1310
	if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1311
		return 0; /* component must fit device */
1312
	if (rdev->mddev->bitmap_info.offset)
1313
		return 0; /* can't move bitmap */
1314
	rdev->sb_start = calc_dev_sboffset(rdev);
1315 1316
	if (!num_sectors || num_sectors > rdev->sb_start)
		num_sectors = rdev->sb_start;
1317 1318 1319
	/* Limit to 4TB as metadata cannot record more than that.
	 * 4TB == 2^32 KB, or 2*2^32 sectors.
	 */
1320
	if (num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1)
1321
		num_sectors = (2ULL << 32) - 2;
1322
	md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1323 1324
		       rdev->sb_page);
	md_super_wait(rdev->mddev);
1325
	return num_sectors;
1326 1327
}

1328 1329 1330 1331 1332 1333
static int
super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset)
{
	/* non-zero offset changes not possible with v0.90 */
	return new_offset == 0;
}
1334

L
Linus Torvalds 已提交
1335 1336 1337 1338
/*
 * version 1 superblock
 */

1339
static __le32 calc_sb_1_csum(struct mdp_superblock_1 *sb)
L
Linus Torvalds 已提交
1340
{
1341 1342
	__le32 disk_csum;
	u32 csum;
L
Linus Torvalds 已提交
1343 1344
	unsigned long long newcsum;
	int size = 256 + le32_to_cpu(sb->max_dev)*2;
1345
	__le32 *isuper = (__le32*)sb;
L
Linus Torvalds 已提交
1346 1347 1348 1349

	disk_csum = sb->sb_csum;
	sb->sb_csum = 0;
	newcsum = 0;
1350
	for (; size >= 4; size -= 4)
L
Linus Torvalds 已提交
1351 1352 1353
		newcsum += le32_to_cpu(*isuper++);

	if (size == 2)
1354
		newcsum += le16_to_cpu(*(__le16*) isuper);
L
Linus Torvalds 已提交
1355 1356 1357 1358 1359 1360

	csum = (newcsum & 0xffffffff) + (newcsum >> 32);
	sb->sb_csum = disk_csum;
	return cpu_to_le32(csum);
}

1361 1362
static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
			    int acknowledged);
1363
static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
L
Linus Torvalds 已提交
1364 1365 1366
{
	struct mdp_superblock_1 *sb;
	int ret;
1367
	sector_t sb_start;
1368
	sector_t sectors;
L
Linus Torvalds 已提交
1369
	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1370
	int bmask;
L
Linus Torvalds 已提交
1371 1372

	/*
1373
	 * Calculate the position of the superblock in 512byte sectors.
L
Linus Torvalds 已提交
1374 1375 1376 1377 1378 1379 1380 1381
	 * It is always aligned to a 4K boundary and
	 * depeding on minor_version, it can be:
	 * 0: At least 8K, but less than 12K, from end of device
	 * 1: At start of device
	 * 2: 4K from start of device.
	 */
	switch(minor_version) {
	case 0:
1382
		sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;
1383 1384
		sb_start -= 8*2;
		sb_start &= ~(sector_t)(4*2-1);
L
Linus Torvalds 已提交
1385 1386
		break;
	case 1:
1387
		sb_start = 0;
L
Linus Torvalds 已提交
1388 1389
		break;
	case 2:
1390
		sb_start = 8;
L
Linus Torvalds 已提交
1391 1392 1393 1394
		break;
	default:
		return -EINVAL;
	}
1395
	rdev->sb_start = sb_start;
L
Linus Torvalds 已提交
1396

1397 1398 1399 1400
	/* superblock is rarely larger than 1K, but it can be larger,
	 * and it is safe to read 4k, so we do that
	 */
	ret = read_disk_sb(rdev, 4096);
L
Linus Torvalds 已提交
1401 1402
	if (ret) return ret;

1403
	sb = page_address(rdev->sb_page);
L
Linus Torvalds 已提交
1404 1405 1406 1407

	if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
	    sb->major_version != cpu_to_le32(1) ||
	    le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
1408
	    le64_to_cpu(sb->super_offset) != rdev->sb_start ||
1409
	    (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
L
Linus Torvalds 已提交
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
		return -EINVAL;

	if (calc_sb_1_csum(sb) != sb->sb_csum) {
		printk("md: invalid superblock checksum on %s\n",
			bdevname(rdev->bdev,b));
		return -EINVAL;
	}
	if (le64_to_cpu(sb->data_size) < 10) {
		printk("md: data_size too small on %s\n",
		       bdevname(rdev->bdev,b));
		return -EINVAL;
	}
1422 1423 1424 1425 1426
	if (sb->pad0 ||
	    sb->pad3[0] ||
	    memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1])))
		/* Some padding is non-zero, might be a new feature */
		return -EINVAL;
1427

L
Linus Torvalds 已提交
1428 1429
	rdev->preferred_minor = 0xffff;
	rdev->data_offset = le64_to_cpu(sb->data_offset);
1430 1431 1432 1433
	rdev->new_data_offset = rdev->data_offset;
	if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) &&
	    (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
		rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset);
1434
	atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
L
Linus Torvalds 已提交
1435

1436
	rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
1437
	bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1438
	if (rdev->sb_size & bmask)
1439 1440 1441
		rdev->sb_size = (rdev->sb_size | bmask) + 1;

	if (minor_version
1442
	    && rdev->data_offset < sb_start + (rdev->sb_size/512))
1443
		return -EINVAL;
1444 1445 1446
	if (minor_version
	    && rdev->new_data_offset < sb_start + (rdev->sb_size/512))
		return -EINVAL;
1447

1448 1449 1450 1451 1452
	if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
		rdev->desc_nr = -1;
	else
		rdev->desc_nr = le32_to_cpu(sb->dev_number);

1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
	if (!rdev->bb_page) {
		rdev->bb_page = alloc_page(GFP_KERNEL);
		if (!rdev->bb_page)
			return -ENOMEM;
	}
	if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
	    rdev->badblocks.count == 0) {
		/* need to load the bad block list.
		 * Currently we limit it to one page.
		 */
		s32 offset;
		sector_t bb_sector;
		u64 *bbp;
		int i;
		int sectors = le16_to_cpu(sb->bblog_size);
		if (sectors > (PAGE_SIZE / 512))
			return -EINVAL;
		offset = le32_to_cpu(sb->bblog_offset);
		if (offset == 0)
			return -EINVAL;
		bb_sector = (long long)offset;
		if (!sync_page_io(rdev, bb_sector, sectors << 9,
				  rdev->bb_page, READ, true))
			return -EIO;
		bbp = (u64 *)page_address(rdev->bb_page);
		rdev->badblocks.shift = sb->bblog_shift;
		for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
			u64 bb = le64_to_cpu(*bbp);
			int count = bb & (0x3ff);
			u64 sector = bb >> 10;
			sector <<= sb->bblog_shift;
			count <<= sb->bblog_shift;
			if (bb + 1 == 0)
				break;
			if (md_set_badblocks(&rdev->badblocks,
					     sector, count, 1) == 0)
				return -EINVAL;
		}
1491 1492
	} else if (sb->bblog_offset != 0)
		rdev->badblocks.shift = 0;
1493

1494
	if (!refdev) {
1495
		ret = 1;
1496
	} else {
L
Linus Torvalds 已提交
1497
		__u64 ev1, ev2;
1498
		struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
L
Linus Torvalds 已提交
1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513

		if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
		    sb->level != refsb->level ||
		    sb->layout != refsb->layout ||
		    sb->chunksize != refsb->chunksize) {
			printk(KERN_WARNING "md: %s has strangely different"
				" superblock to %s\n",
				bdevname(rdev->bdev,b),
				bdevname(refdev->bdev,b2));
			return -EINVAL;
		}
		ev1 = le64_to_cpu(sb->events);
		ev2 = le64_to_cpu(refsb->events);

		if (ev1 > ev2)
1514 1515 1516
			ret = 1;
		else
			ret = 0;
L
Linus Torvalds 已提交
1517
	}
1518 1519 1520 1521 1522 1523
	if (minor_version) {
		sectors = (i_size_read(rdev->bdev->bd_inode) >> 9);
		sectors -= rdev->data_offset;
	} else
		sectors = rdev->sb_start;
	if (sectors < le64_to_cpu(sb->data_size))
L
Linus Torvalds 已提交
1524
		return -EINVAL;
1525
	rdev->sectors = le64_to_cpu(sb->data_size);
1526
	return ret;
L
Linus Torvalds 已提交
1527 1528
}

1529
static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
L
Linus Torvalds 已提交
1530
{
1531
	struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
1532
	__u64 ev1 = le64_to_cpu(sb->events);
L
Linus Torvalds 已提交
1533

1534
	rdev->raid_disk = -1;
1535 1536
	clear_bit(Faulty, &rdev->flags);
	clear_bit(In_sync, &rdev->flags);
1537
	clear_bit(Bitmap_sync, &rdev->flags);
1538 1539
	clear_bit(WriteMostly, &rdev->flags);

L
Linus Torvalds 已提交
1540 1541 1542
	if (mddev->raid_disks == 0) {
		mddev->major_version = 1;
		mddev->patch_version = 0;
1543
		mddev->external = 0;
1544
		mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
L
Linus Torvalds 已提交
1545 1546 1547
		mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
		mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
		mddev->level = le32_to_cpu(sb->level);
1548
		mddev->clevel[0] = 0;
L
Linus Torvalds 已提交
1549 1550
		mddev->layout = le32_to_cpu(sb->layout);
		mddev->raid_disks = le32_to_cpu(sb->raid_disks);
A
Andre Noll 已提交
1551
		mddev->dev_sectors = le64_to_cpu(sb->size);
1552
		mddev->events = ev1;
1553
		mddev->bitmap_info.offset = 0;
1554 1555 1556 1557
		mddev->bitmap_info.space = 0;
		/* Default location for bitmap is 1K after superblock
		 * using 3K - total of 4K
		 */
1558
		mddev->bitmap_info.default_offset = 1024 >> 9;
1559
		mddev->bitmap_info.default_space = (4096-1024) >> 9;
1560 1561
		mddev->reshape_backwards = 0;

L
Linus Torvalds 已提交
1562 1563 1564 1565
		mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
		memcpy(mddev->uuid, sb->set_uuid, 16);

		mddev->max_disks =  (4096-256)/2;
1566

1567
		if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1568
		    mddev->bitmap_info.file == NULL) {
1569 1570
			mddev->bitmap_info.offset =
				(__s32)le32_to_cpu(sb->bitmap_offset);
1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
			/* Metadata doesn't record how much space is available.
			 * For 1.0, we assume we can use up to the superblock
			 * if before, else to 4K beyond superblock.
			 * For others, assume no change is possible.
			 */
			if (mddev->minor_version > 0)
				mddev->bitmap_info.space = 0;
			else if (mddev->bitmap_info.offset > 0)
				mddev->bitmap_info.space =
					8 - mddev->bitmap_info.offset;
			else
				mddev->bitmap_info.space =
					-mddev->bitmap_info.offset;
		}
1585

1586 1587 1588 1589 1590
		if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
			mddev->reshape_position = le64_to_cpu(sb->reshape_position);
			mddev->delta_disks = le32_to_cpu(sb->delta_disks);
			mddev->new_level = le32_to_cpu(sb->new_level);
			mddev->new_layout = le32_to_cpu(sb->new_layout);
1591
			mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
1592 1593 1594 1595 1596
			if (mddev->delta_disks < 0 ||
			    (mddev->delta_disks == 0 &&
			     (le32_to_cpu(sb->feature_map)
			      & MD_FEATURE_RESHAPE_BACKWARDS)))
				mddev->reshape_backwards = 1;
1597 1598 1599 1600 1601
		} else {
			mddev->reshape_position = MaxSector;
			mddev->delta_disks = 0;
			mddev->new_level = mddev->level;
			mddev->new_layout = mddev->layout;
1602
			mddev->new_chunk_sectors = mddev->chunk_sectors;
1603 1604
		}

1605
	} else if (mddev->pers == NULL) {
1606 1607
		/* Insist of good event counter while assembling, except for
		 * spares (which don't need an event count) */
L
Linus Torvalds 已提交
1608
		++ev1;
1609 1610 1611 1612 1613
		if (rdev->desc_nr >= 0 &&
		    rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
		    le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < 0xfffe)
			if (ev1 < mddev->events)
				return -EINVAL;
1614 1615 1616 1617 1618 1619
	} else if (mddev->bitmap) {
		/* If adding to array with a bitmap, then we can accept an
		 * older device, but not too old.
		 */
		if (ev1 < mddev->bitmap->events_cleared)
			return 0;
1620 1621
		if (ev1 < mddev->events)
			set_bit(Bitmap_sync, &rdev->flags);
1622 1623 1624 1625 1626
	} else {
		if (ev1 < mddev->events)
			/* just a hot-add of a new device, leave raid_disk at -1 */
			return 0;
	}
L
Linus Torvalds 已提交
1627 1628
	if (mddev->level != LEVEL_MULTIPATH) {
		int role;
1629 1630 1631 1632 1633 1634
		if (rdev->desc_nr < 0 ||
		    rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
			role = 0xffff;
			rdev->desc_nr = -1;
		} else
			role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
L
Linus Torvalds 已提交
1635 1636 1637 1638
		switch(role) {
		case 0xffff: /* spare */
			break;
		case 0xfffe: /* faulty */
1639
			set_bit(Faulty, &rdev->flags);
L
Linus Torvalds 已提交
1640 1641
			break;
		default:
1642
			rdev->saved_raid_disk = role;
1643
			if ((le32_to_cpu(sb->feature_map) &
1644
			     MD_FEATURE_RECOVERY_OFFSET)) {
1645
				rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
1646 1647 1648 1649
				if (!(le32_to_cpu(sb->feature_map) &
				      MD_FEATURE_RECOVERY_BITMAP))
					rdev->saved_raid_disk = -1;
			} else
1650
				set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
1651 1652 1653
			rdev->raid_disk = role;
			break;
		}
1654 1655
		if (sb->devflags & WriteMostly1)
			set_bit(WriteMostly, &rdev->flags);
1656 1657
		if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT)
			set_bit(Replacement, &rdev->flags);
1658
	} else /* MULTIPATH are always insync */
1659
		set_bit(In_sync, &rdev->flags);
1660

L
Linus Torvalds 已提交
1661 1662 1663
	return 0;
}

1664
static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
L
Linus Torvalds 已提交
1665 1666
{
	struct mdp_superblock_1 *sb;
1667
	struct md_rdev *rdev2;
L
Linus Torvalds 已提交
1668 1669 1670
	int max_dev, i;
	/* make rdev->sb match mddev and rdev data. */

1671
	sb = page_address(rdev->sb_page);
L
Linus Torvalds 已提交
1672 1673 1674

	sb->feature_map = 0;
	sb->pad0 = 0;
1675
	sb->recovery_offset = cpu_to_le64(0);
L
Linus Torvalds 已提交
1676 1677 1678 1679 1680 1681 1682 1683 1684
	memset(sb->pad3, 0, sizeof(sb->pad3));

	sb->utime = cpu_to_le64((__u64)mddev->utime);
	sb->events = cpu_to_le64(mddev->events);
	if (mddev->in_sync)
		sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
	else
		sb->resync_offset = cpu_to_le64(0);

1685
	sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
1686

1687
	sb->raid_disks = cpu_to_le32(mddev->raid_disks);
A
Andre Noll 已提交
1688
	sb->size = cpu_to_le64(mddev->dev_sectors);
1689
	sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
1690 1691
	sb->level = cpu_to_le32(mddev->level);
	sb->layout = cpu_to_le32(mddev->layout);
1692

1693 1694 1695 1696
	if (test_bit(WriteMostly, &rdev->flags))
		sb->devflags |= WriteMostly1;
	else
		sb->devflags &= ~WriteMostly1;
1697 1698
	sb->data_offset = cpu_to_le64(rdev->data_offset);
	sb->data_size = cpu_to_le64(rdev->sectors);
1699

1700 1701
	if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
		sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
1702
		sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1703
	}
1704 1705

	if (rdev->raid_disk >= 0 &&
1706
	    !test_bit(In_sync, &rdev->flags)) {
1707 1708 1709 1710
		sb->feature_map |=
			cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
		sb->recovery_offset =
			cpu_to_le64(rdev->recovery_offset);
1711 1712 1713
		if (rdev->saved_raid_disk >= 0 && mddev->bitmap)
			sb->feature_map |=
				cpu_to_le32(MD_FEATURE_RECOVERY_BITMAP);
1714
	}
1715 1716 1717
	if (test_bit(Replacement, &rdev->flags))
		sb->feature_map |=
			cpu_to_le32(MD_FEATURE_REPLACEMENT);
1718

1719 1720 1721 1722 1723 1724
	if (mddev->reshape_position != MaxSector) {
		sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
		sb->reshape_position = cpu_to_le64(mddev->reshape_position);
		sb->new_layout = cpu_to_le32(mddev->new_layout);
		sb->delta_disks = cpu_to_le32(mddev->delta_disks);
		sb->new_level = cpu_to_le32(mddev->new_level);
1725
		sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
1726 1727 1728 1729
		if (mddev->delta_disks == 0 &&
		    mddev->reshape_backwards)
			sb->feature_map
				|= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
1730 1731 1732 1733 1734 1735
		if (rdev->new_data_offset != rdev->data_offset) {
			sb->feature_map
				|= cpu_to_le32(MD_FEATURE_NEW_OFFSET);
			sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset
							     - rdev->data_offset));
		}
1736
	}
1737

1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756
	if (rdev->badblocks.count == 0)
		/* Nothing to do for bad blocks*/ ;
	else if (sb->bblog_offset == 0)
		/* Cannot record bad blocks on this device */
		md_error(mddev, rdev);
	else {
		struct badblocks *bb = &rdev->badblocks;
		u64 *bbp = (u64 *)page_address(rdev->bb_page);
		u64 *p = bb->page;
		sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
		if (bb->changed) {
			unsigned seq;

retry:
			seq = read_seqbegin(&bb->lock);

			memset(bbp, 0xff, PAGE_SIZE);

			for (i = 0 ; i < bb->count ; i++) {
1757
				u64 internal_bb = p[i];
1758 1759
				u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
						| BB_LEN(internal_bb));
1760
				bbp[i] = cpu_to_le64(store_bb);
1761
			}
1762
			bb->changed = 0;
1763 1764 1765 1766 1767 1768 1769 1770 1771
			if (read_seqretry(&bb->lock, seq))
				goto retry;

			bb->sector = (rdev->sb_start +
				      (int)le32_to_cpu(sb->bblog_offset));
			bb->size = le16_to_cpu(sb->bblog_size);
		}
	}

L
Linus Torvalds 已提交
1772
	max_dev = 0;
N
NeilBrown 已提交
1773
	rdev_for_each(rdev2, mddev)
L
Linus Torvalds 已提交
1774 1775
		if (rdev2->desc_nr+1 > max_dev)
			max_dev = rdev2->desc_nr+1;
1776

1777 1778
	if (max_dev > le32_to_cpu(sb->max_dev)) {
		int bmask;
1779
		sb->max_dev = cpu_to_le32(max_dev);
1780 1781 1782 1783
		rdev->sb_size = max_dev * 2 + 256;
		bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
		if (rdev->sb_size & bmask)
			rdev->sb_size = (rdev->sb_size | bmask) + 1;
1784 1785 1786
	} else
		max_dev = le32_to_cpu(sb->max_dev);

L
Linus Torvalds 已提交
1787 1788
	for (i=0; i<max_dev;i++)
		sb->dev_roles[i] = cpu_to_le16(0xfffe);
1789

N
NeilBrown 已提交
1790
	rdev_for_each(rdev2, mddev) {
L
Linus Torvalds 已提交
1791
		i = rdev2->desc_nr;
1792
		if (test_bit(Faulty, &rdev2->flags))
L
Linus Torvalds 已提交
1793
			sb->dev_roles[i] = cpu_to_le16(0xfffe);
1794
		else if (test_bit(In_sync, &rdev2->flags))
L
Linus Torvalds 已提交
1795
			sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1796
		else if (rdev2->raid_disk >= 0)
1797
			sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
L
Linus Torvalds 已提交
1798 1799 1800 1801 1802 1803 1804
		else
			sb->dev_roles[i] = cpu_to_le16(0xffff);
	}

	sb->sb_csum = calc_sb_1_csum(sb);
}

1805
static unsigned long long
1806
super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1807 1808
{
	struct mdp_superblock_1 *sb;
1809
	sector_t max_sectors;
A
Andre Noll 已提交
1810
	if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1811
		return 0; /* component must fit device */
1812 1813
	if (rdev->data_offset != rdev->new_data_offset)
		return 0; /* too confusing */
1814
	if (rdev->sb_start < rdev->data_offset) {
1815
		/* minor versions 1 and 2; superblock before data */
1816
		max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9;
1817 1818 1819
		max_sectors -= rdev->data_offset;
		if (!num_sectors || num_sectors > max_sectors)
			num_sectors = max_sectors;
1820
	} else if (rdev->mddev->bitmap_info.offset) {
1821 1822 1823 1824
		/* minor version 0 with bitmap we can't move */
		return 0;
	} else {
		/* minor version 0; superblock after data */
1825
		sector_t sb_start;
1826
		sb_start = (i_size_read(rdev->bdev->bd_inode) >> 9) - 8*2;
1827
		sb_start &= ~(sector_t)(4*2 - 1);
1828
		max_sectors = rdev->sectors + sb_start - rdev->sb_start;
1829 1830
		if (!num_sectors || num_sectors > max_sectors)
			num_sectors = max_sectors;
1831
		rdev->sb_start = sb_start;
1832
	}
1833
	sb = page_address(rdev->sb_page);
1834
	sb->data_size = cpu_to_le64(num_sectors);
1835
	sb->super_offset = rdev->sb_start;
1836
	sb->sb_csum = calc_sb_1_csum(sb);
1837
	md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1838 1839
		       rdev->sb_page);
	md_super_wait(rdev->mddev);
1840
	return num_sectors;
1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868

}

static int
super_1_allow_new_offset(struct md_rdev *rdev,
			 unsigned long long new_offset)
{
	/* All necessary checks on new >= old have been done */
	struct bitmap *bitmap;
	if (new_offset >= rdev->data_offset)
		return 1;

	/* with 1.0 metadata, there is no metadata to tread on
	 * so we can always move back */
	if (rdev->mddev->minor_version == 0)
		return 1;

	/* otherwise we must be sure not to step on
	 * any metadata, so stay:
	 * 36K beyond start of superblock
	 * beyond end of badblocks
	 * beyond write-intent bitmap
	 */
	if (rdev->sb_start + (32+4)*2 > new_offset)
		return 0;
	bitmap = rdev->mddev->bitmap;
	if (bitmap && !rdev->mddev->bitmap_info.file &&
	    rdev->sb_start + rdev->mddev->bitmap_info.offset +
1869
	    bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
1870 1871 1872 1873 1874
		return 0;
	if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
		return 0;

	return 1;
1875
}
L
Linus Torvalds 已提交
1876

A
Adrian Bunk 已提交
1877
static struct super_type super_types[] = {
L
Linus Torvalds 已提交
1878 1879 1880
	[0] = {
		.name	= "0.90.0",
		.owner	= THIS_MODULE,
1881 1882 1883 1884
		.load_super	    = super_90_load,
		.validate_super	    = super_90_validate,
		.sync_super	    = super_90_sync,
		.rdev_size_change   = super_90_rdev_size_change,
1885
		.allow_new_offset   = super_90_allow_new_offset,
L
Linus Torvalds 已提交
1886 1887 1888 1889
	},
	[1] = {
		.name	= "md-1",
		.owner	= THIS_MODULE,
1890 1891 1892 1893
		.load_super	    = super_1_load,
		.validate_super	    = super_1_validate,
		.sync_super	    = super_1_sync,
		.rdev_size_change   = super_1_rdev_size_change,
1894
		.allow_new_offset   = super_1_allow_new_offset,
L
Linus Torvalds 已提交
1895 1896 1897
	},
};

1898
static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909
{
	if (mddev->sync_super) {
		mddev->sync_super(mddev, rdev);
		return;
	}

	BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));

	super_types[mddev->major_version].sync_super(mddev, rdev);
}

1910
static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
L
Linus Torvalds 已提交
1911
{
1912
	struct md_rdev *rdev, *rdev2;
L
Linus Torvalds 已提交
1913

1914 1915 1916
	rcu_read_lock();
	rdev_for_each_rcu(rdev, mddev1)
		rdev_for_each_rcu(rdev2, mddev2)
1917
			if (rdev->bdev->bd_contains ==
1918 1919
			    rdev2->bdev->bd_contains) {
				rcu_read_unlock();
1920
				return 1;
1921 1922
			}
	rcu_read_unlock();
L
Linus Torvalds 已提交
1923 1924 1925 1926 1927
	return 0;
}

static LIST_HEAD(pending_raid_disks);

1928 1929 1930 1931 1932 1933 1934
/*
 * Try to register data integrity profile for an mddev
 *
 * This is called when an array is started and after a disk has been kicked
 * from the array. It only succeeds if all working and active component devices
 * are integrity capable with matching profiles.
 */
1935
int md_integrity_register(struct mddev *mddev)
1936
{
1937
	struct md_rdev *rdev, *reference = NULL;
1938 1939 1940

	if (list_empty(&mddev->disks))
		return 0; /* nothing to do */
1941 1942
	if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
		return 0; /* shouldn't register, or already is */
N
NeilBrown 已提交
1943
	rdev_for_each(rdev, mddev) {
1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958
		/* skip spares and non-functional disks */
		if (test_bit(Faulty, &rdev->flags))
			continue;
		if (rdev->raid_disk < 0)
			continue;
		if (!reference) {
			/* Use the first rdev as the reference */
			reference = rdev;
			continue;
		}
		/* does this rdev's profile match the reference profile? */
		if (blk_integrity_compare(reference->bdev->bd_disk,
				rdev->bdev->bd_disk) < 0)
			return -EINVAL;
	}
1959 1960
	if (!reference || !bdev_get_integrity(reference->bdev))
		return 0;
1961 1962 1963 1964
	/*
	 * All component devices are integrity capable and have matching
	 * profiles, register the common profile for the md device.
	 */
1965 1966 1967
	blk_integrity_register(mddev->gendisk,
			       bdev_get_integrity(reference->bdev));

1968 1969 1970 1971 1972 1973
	printk(KERN_NOTICE "md: data integrity enabled on %s\n", mdname(mddev));
	if (bioset_integrity_create(mddev->bio_set, BIO_POOL_SIZE)) {
		printk(KERN_ERR "md: failed to create integrity pool for %s\n",
		       mdname(mddev));
		return -EINVAL;
	}
1974 1975 1976 1977 1978
	return 0;
}
EXPORT_SYMBOL(md_integrity_register);

/* Disable data integrity if non-capable/non-matching disk is being added */
1979
void md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
M
Martin K. Petersen 已提交
1980
{
1981 1982 1983 1984 1985 1986 1987 1988
	struct blk_integrity *bi_rdev;
	struct blk_integrity *bi_mddev;

	if (!mddev->gendisk)
		return;

	bi_rdev = bdev_get_integrity(rdev->bdev);
	bi_mddev = blk_get_integrity(mddev->gendisk);
M
Martin K. Petersen 已提交
1989

1990
	if (!bi_mddev) /* nothing to do */
M
Martin K. Petersen 已提交
1991
		return;
1992
	if (rdev->raid_disk < 0) /* skip spares */
M
Martin K. Petersen 已提交
1993
		return;
1994 1995 1996 1997 1998
	if (bi_rdev && blk_integrity_compare(mddev->gendisk,
					     rdev->bdev->bd_disk) >= 0)
		return;
	printk(KERN_NOTICE "disabling data integrity on %s\n", mdname(mddev));
	blk_integrity_unregister(mddev->gendisk);
M
Martin K. Petersen 已提交
1999
}
2000
EXPORT_SYMBOL(md_integrity_add_rdev);
M
Martin K. Petersen 已提交
2001

2002
static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev)
L
Linus Torvalds 已提交
2003
{
2004
	char b[BDEVNAME_SIZE];
2005
	struct kobject *ko;
2006
	int err;
L
Linus Torvalds 已提交
2007

2008 2009 2010 2011
	/* prevent duplicates */
	if (find_rdev(mddev, rdev->bdev->bd_dev))
		return -EEXIST;

2012 2013 2014
	/* make sure rdev->sectors exceeds mddev->dev_sectors */
	if (rdev->sectors && (mddev->dev_sectors == 0 ||
			rdev->sectors < mddev->dev_sectors)) {
2015 2016 2017 2018 2019 2020 2021 2022
		if (mddev->pers) {
			/* Cannot change size, so fail
			 * If mddev->level <= 0, then we don't care
			 * about aligning sizes (e.g. linear)
			 */
			if (mddev->level > 0)
				return -ENOSPC;
		} else
2023
			mddev->dev_sectors = rdev->sectors;
2024
	}
L
Linus Torvalds 已提交
2025 2026 2027 2028 2029

	/* Verify rdev->desc_nr is unique.
	 * If it is -1, assign a free number, else
	 * check number is not in use
	 */
2030
	rcu_read_lock();
L
Linus Torvalds 已提交
2031 2032
	if (rdev->desc_nr < 0) {
		int choice = 0;
2033 2034
		if (mddev->pers)
			choice = mddev->raid_disks;
2035
		while (md_find_rdev_nr_rcu(mddev, choice))
L
Linus Torvalds 已提交
2036 2037 2038
			choice++;
		rdev->desc_nr = choice;
	} else {
2039
		if (md_find_rdev_nr_rcu(mddev, rdev->desc_nr)) {
2040
			rcu_read_unlock();
L
Linus Torvalds 已提交
2041
			return -EBUSY;
2042
		}
L
Linus Torvalds 已提交
2043
	}
2044
	rcu_read_unlock();
2045 2046 2047 2048 2049
	if (mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
		printk(KERN_WARNING "md: %s: array is limited to %d devices\n",
		       mdname(mddev), mddev->max_disks);
		return -EBUSY;
	}
2050
	bdevname(rdev->bdev,b);
2051
	strreplace(b, '/', '!');
2052

L
Linus Torvalds 已提交
2053
	rdev->mddev = mddev;
2054
	printk(KERN_INFO "md: bind<%s>\n", b);
2055

2056
	if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
2057
		goto fail;
2058

T
Tejun Heo 已提交
2059
	ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
N
NeilBrown 已提交
2060 2061 2062
	if (sysfs_create_link(&rdev->kobj, ko, "block"))
		/* failure here is OK */;
	rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
2063

2064
	list_add_rcu(&rdev->same_set, &mddev->disks);
2065
	bd_link_disk_holder(rdev->bdev, mddev->gendisk);
2066 2067

	/* May as well allow recovery to be retried once */
2068
	mddev->recovery_disabled++;
M
Martin K. Petersen 已提交
2069

L
Linus Torvalds 已提交
2070
	return 0;
2071 2072 2073 2074 2075

 fail:
	printk(KERN_WARNING "md: failed to register dev-%s for %s\n",
	       b, mdname(mddev));
	return err;
L
Linus Torvalds 已提交
2076 2077
}

2078
static void md_delayed_delete(struct work_struct *ws)
2079
{
2080
	struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
2081
	kobject_del(&rdev->kobj);
2082
	kobject_put(&rdev->kobj);
2083 2084
}

2085
static void unbind_rdev_from_array(struct md_rdev *rdev)
L
Linus Torvalds 已提交
2086 2087
{
	char b[BDEVNAME_SIZE];
N
NeilBrown 已提交
2088

2089
	bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
2090
	list_del_rcu(&rdev->same_set);
L
Linus Torvalds 已提交
2091 2092
	printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
	rdev->mddev = NULL;
2093
	sysfs_remove_link(&rdev->kobj, "block");
2094 2095
	sysfs_put(rdev->sysfs_state);
	rdev->sysfs_state = NULL;
2096
	rdev->badblocks.count = 0;
2097
	/* We need to delay this, otherwise we can deadlock when
2098 2099
	 * writing to 'remove' to "dev/state".  We also need
	 * to delay it due to rcu usage.
2100
	 */
2101
	synchronize_rcu();
2102 2103
	INIT_WORK(&rdev->del_work, md_delayed_delete);
	kobject_get(&rdev->kobj);
T
Tejun Heo 已提交
2104
	queue_work(md_misc_wq, &rdev->del_work);
L
Linus Torvalds 已提交
2105 2106 2107 2108 2109 2110 2111
}

/*
 * prevent the device from being mounted, repartitioned or
 * otherwise reused by a RAID array (or any other kernel
 * subsystem), by bd_claiming the device.
 */
2112
static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared)
L
Linus Torvalds 已提交
2113 2114 2115 2116 2117
{
	int err = 0;
	struct block_device *bdev;
	char b[BDEVNAME_SIZE];

2118
	bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
2119
				 shared ? (struct md_rdev *)lock_rdev : rdev);
L
Linus Torvalds 已提交
2120 2121 2122 2123 2124 2125 2126 2127 2128
	if (IS_ERR(bdev)) {
		printk(KERN_ERR "md: could not open %s.\n",
			__bdevname(dev, b));
		return PTR_ERR(bdev);
	}
	rdev->bdev = bdev;
	return err;
}

2129
static void unlock_rdev(struct md_rdev *rdev)
L
Linus Torvalds 已提交
2130 2131 2132
{
	struct block_device *bdev = rdev->bdev;
	rdev->bdev = NULL;
2133
	blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
L
Linus Torvalds 已提交
2134 2135 2136 2137
}

void md_autodetect_dev(dev_t dev);

2138
static void export_rdev(struct md_rdev *rdev)
L
Linus Torvalds 已提交
2139 2140
{
	char b[BDEVNAME_SIZE];
N
NeilBrown 已提交
2141

L
Linus Torvalds 已提交
2142 2143
	printk(KERN_INFO "md: export_rdev(%s)\n",
		bdevname(rdev->bdev,b));
2144
	md_rdev_clear(rdev);
L
Linus Torvalds 已提交
2145
#ifndef MODULE
2146 2147
	if (test_bit(AutoDetected, &rdev->flags))
		md_autodetect_dev(rdev->bdev->bd_dev);
L
Linus Torvalds 已提交
2148 2149
#endif
	unlock_rdev(rdev);
2150
	kobject_put(&rdev->kobj);
L
Linus Torvalds 已提交
2151 2152
}

2153
void md_kick_rdev_from_array(struct md_rdev *rdev)
L
Linus Torvalds 已提交
2154 2155 2156 2157
{
	unbind_rdev_from_array(rdev);
	export_rdev(rdev);
}
2158
EXPORT_SYMBOL_GPL(md_kick_rdev_from_array);
L
Linus Torvalds 已提交
2159

2160
static void export_array(struct mddev *mddev)
L
Linus Torvalds 已提交
2161
{
N
NeilBrown 已提交
2162
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
2163

N
NeilBrown 已提交
2164 2165 2166
	while (!list_empty(&mddev->disks)) {
		rdev = list_first_entry(&mddev->disks, struct md_rdev,
					same_set);
2167
		md_kick_rdev_from_array(rdev);
L
Linus Torvalds 已提交
2168 2169 2170 2171 2172
	}
	mddev->raid_disks = 0;
	mddev->major_version = 0;
}

2173
static void sync_sbs(struct mddev *mddev, int nospares)
L
Linus Torvalds 已提交
2174
{
2175 2176 2177 2178 2179 2180
	/* Update each superblock (in-memory image), but
	 * if we are allowed to, skip spares which already
	 * have the right event counter, or have one earlier
	 * (which would mean they aren't being marked as dirty
	 * with the rest of the array)
	 */
2181
	struct md_rdev *rdev;
N
NeilBrown 已提交
2182
	rdev_for_each(rdev, mddev) {
2183 2184 2185 2186 2187 2188 2189
		if (rdev->sb_events == mddev->events ||
		    (nospares &&
		     rdev->raid_disk < 0 &&
		     rdev->sb_events+1 == mddev->events)) {
			/* Don't update this superblock */
			rdev->sb_loaded = 2;
		} else {
2190
			sync_super(mddev, rdev);
2191 2192
			rdev->sb_loaded = 1;
		}
L
Linus Torvalds 已提交
2193 2194 2195
	}
}

2196
void md_update_sb(struct mddev *mddev, int force_change)
L
Linus Torvalds 已提交
2197
{
2198
	struct md_rdev *rdev;
2199
	int sync_req;
2200
	int nospares = 0;
2201
	int any_badblocks_changed = 0;
L
Linus Torvalds 已提交
2202

2203 2204 2205 2206 2207
	if (mddev->ro) {
		if (force_change)
			set_bit(MD_CHANGE_DEVS, &mddev->flags);
		return;
	}
L
Linus Torvalds 已提交
2208
repeat:
2209
	/* First make sure individual recovery_offsets are correct */
N
NeilBrown 已提交
2210
	rdev_for_each(rdev, mddev) {
2211 2212 2213 2214 2215 2216
		if (rdev->raid_disk >= 0 &&
		    mddev->delta_disks >= 0 &&
		    !test_bit(In_sync, &rdev->flags) &&
		    mddev->curr_resync_completed > rdev->recovery_offset)
				rdev->recovery_offset = mddev->curr_resync_completed;

2217
	}
2218
	if (!mddev->persistent) {
2219
		clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2220
		clear_bit(MD_CHANGE_DEVS, &mddev->flags);
2221
		if (!mddev->external) {
2222
			clear_bit(MD_CHANGE_PENDING, &mddev->flags);
N
NeilBrown 已提交
2223
			rdev_for_each(rdev, mddev) {
2224
				if (rdev->badblocks.changed) {
2225
					rdev->badblocks.changed = 0;
2226 2227 2228 2229 2230 2231 2232 2233
					md_ack_all_badblocks(&rdev->badblocks);
					md_error(mddev, rdev);
				}
				clear_bit(Blocked, &rdev->flags);
				clear_bit(BlockedBadBlocks, &rdev->flags);
				wake_up(&rdev->blocked_wait);
			}
		}
2234 2235 2236 2237
		wake_up(&mddev->sb_wait);
		return;
	}

2238
	spin_lock(&mddev->lock);
2239

2240 2241
	mddev->utime = get_seconds();

2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252
	if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
		force_change = 1;
	if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
		/* just a clean<-> dirty transition, possibly leave spares alone,
		 * though if events isn't the right even/odd, we will have to do
		 * spares after all
		 */
		nospares = 1;
	if (force_change)
		nospares = 0;
	if (mddev->degraded)
2253 2254 2255 2256 2257 2258 2259 2260 2261
		/* If the array is degraded, then skipping spares is both
		 * dangerous and fairly pointless.
		 * Dangerous because a device that was removed from the array
		 * might have a event_count that still looks up-to-date,
		 * so it can be re-added without a resync.
		 * Pointless because if there are any spares to skip,
		 * then a recovery will happen and soon that array won't
		 * be degraded any more and the spare can go back to sleep then.
		 */
2262
		nospares = 0;
2263

2264
	sync_req = mddev->in_sync;
2265 2266 2267

	/* If this is just a dirty<->clean transition, and the array is clean
	 * and 'events' is odd, we can roll back to the previous clean state */
2268
	if (nospares
2269
	    && (mddev->in_sync && mddev->recovery_cp == MaxSector)
2270 2271
	    && mddev->can_decrease_events
	    && mddev->events != 1) {
2272
		mddev->events--;
2273 2274
		mddev->can_decrease_events = 0;
	} else {
2275 2276
		/* otherwise we have to go forward and ... */
		mddev->events ++;
2277
		mddev->can_decrease_events = nospares;
2278
	}
L
Linus Torvalds 已提交
2279

N
NeilBrown 已提交
2280 2281 2282 2283 2284 2285
	/*
	 * This 64-bit counter should never wrap.
	 * Either we are in around ~1 trillion A.C., assuming
	 * 1 reboot per second, or we have a bug...
	 */
	WARN_ON(mddev->events == 0);
2286

N
NeilBrown 已提交
2287
	rdev_for_each(rdev, mddev) {
2288 2289
		if (rdev->badblocks.changed)
			any_badblocks_changed++;
2290 2291 2292
		if (test_bit(Faulty, &rdev->flags))
			set_bit(FaultRecorded, &rdev->flags);
	}
2293

2294
	sync_sbs(mddev, nospares);
2295
	spin_unlock(&mddev->lock);
L
Linus Torvalds 已提交
2296

2297 2298
	pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
		 mdname(mddev), mddev->in_sync);
L
Linus Torvalds 已提交
2299

2300
	bitmap_update_sb(mddev->bitmap);
N
NeilBrown 已提交
2301
	rdev_for_each(rdev, mddev) {
L
Linus Torvalds 已提交
2302
		char b[BDEVNAME_SIZE];
2303

2304 2305
		if (rdev->sb_loaded != 1)
			continue; /* no noise on spare devices */
L
Linus Torvalds 已提交
2306

2307
		if (!test_bit(Faulty, &rdev->flags)) {
2308
			md_super_write(mddev,rdev,
2309
				       rdev->sb_start, rdev->sb_size,
2310
				       rdev->sb_page);
2311 2312 2313
			pr_debug("md: (write) %s's sb offset: %llu\n",
				 bdevname(rdev->bdev, b),
				 (unsigned long long)rdev->sb_start);
2314
			rdev->sb_events = mddev->events;
2315 2316 2317 2318 2319 2320 2321
			if (rdev->badblocks.size) {
				md_super_write(mddev, rdev,
					       rdev->badblocks.sector,
					       rdev->badblocks.size << 9,
					       rdev->bb_page);
				rdev->badblocks.size = 0;
			}
2322

2323
		} else
2324 2325
			pr_debug("md: %s (skipping faulty)\n",
				 bdevname(rdev->bdev, b));
2326

2327
		if (mddev->level == LEVEL_MULTIPATH)
L
Linus Torvalds 已提交
2328 2329 2330
			/* only need to write one superblock... */
			break;
	}
2331
	md_super_wait(mddev);
2332
	/* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
2333

2334
	spin_lock(&mddev->lock);
2335 2336
	if (mddev->in_sync != sync_req ||
	    test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
2337
		/* have to write it out again */
2338
		spin_unlock(&mddev->lock);
2339 2340
		goto repeat;
	}
2341
	clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2342
	spin_unlock(&mddev->lock);
2343
	wake_up(&mddev->sb_wait);
2344 2345
	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
		sysfs_notify(&mddev->kobj, NULL, "sync_completed");
2346

N
NeilBrown 已提交
2347
	rdev_for_each(rdev, mddev) {
2348 2349 2350 2351
		if (test_and_clear_bit(FaultRecorded, &rdev->flags))
			clear_bit(Blocked, &rdev->flags);

		if (any_badblocks_changed)
2352
			md_ack_all_badblocks(&rdev->badblocks);
2353 2354 2355
		clear_bit(BlockedBadBlocks, &rdev->flags);
		wake_up(&rdev->blocked_wait);
	}
L
Linus Torvalds 已提交
2356
}
2357
EXPORT_SYMBOL(md_update_sb);
L
Linus Torvalds 已提交
2358

G
Goldwyn Rodrigues 已提交
2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387
static int add_bound_rdev(struct md_rdev *rdev)
{
	struct mddev *mddev = rdev->mddev;
	int err = 0;

	if (!mddev->pers->hot_remove_disk) {
		/* If there is hot_add_disk but no hot_remove_disk
		 * then added disks for geometry changes,
		 * and should be added immediately.
		 */
		super_types[mddev->major_version].
			validate_super(mddev, rdev);
		err = mddev->pers->hot_add_disk(mddev, rdev);
		if (err) {
			unbind_rdev_from_array(rdev);
			export_rdev(rdev);
			return err;
		}
	}
	sysfs_notify_dirent_safe(rdev->sysfs_state);

	set_bit(MD_CHANGE_DEVS, &mddev->flags);
	if (mddev->degraded)
		set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	md_new_event(mddev);
	md_wakeup_thread(mddev->thread);
	return 0;
}
L
Linus Torvalds 已提交
2388

2389
/* words written to sysfs files may, or may not, be \n terminated.
2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408
 * We want to accept with case. For this we use cmd_match.
 */
static int cmd_match(const char *cmd, const char *str)
{
	/* See if cmd, written into a sysfs file, matches
	 * str.  They must either be the same, or cmd can
	 * have a trailing newline
	 */
	while (*cmd && *str && *cmd == *str) {
		cmd++;
		str++;
	}
	if (*cmd == '\n')
		cmd++;
	if (*str || *cmd)
		return 0;
	return 1;
}

2409 2410
struct rdev_sysfs_entry {
	struct attribute attr;
2411 2412
	ssize_t (*show)(struct md_rdev *, char *);
	ssize_t (*store)(struct md_rdev *, const char *, size_t);
2413 2414 2415
};

static ssize_t
2416
state_show(struct md_rdev *rdev, char *page)
2417 2418
{
	char *sep = "";
2419
	size_t len = 0;
2420
	unsigned long flags = ACCESS_ONCE(rdev->flags);
2421

2422
	if (test_bit(Faulty, &flags) ||
2423
	    rdev->badblocks.unacked_exist) {
2424 2425 2426
		len+= sprintf(page+len, "%sfaulty",sep);
		sep = ",";
	}
2427
	if (test_bit(In_sync, &flags)) {
2428 2429 2430
		len += sprintf(page+len, "%sin_sync",sep);
		sep = ",";
	}
2431
	if (test_bit(WriteMostly, &flags)) {
2432 2433 2434
		len += sprintf(page+len, "%swrite_mostly",sep);
		sep = ",";
	}
2435
	if (test_bit(Blocked, &flags) ||
2436
	    (rdev->badblocks.unacked_exist
2437
	     && !test_bit(Faulty, &flags))) {
2438 2439 2440
		len += sprintf(page+len, "%sblocked", sep);
		sep = ",";
	}
2441 2442
	if (!test_bit(Faulty, &flags) &&
	    !test_bit(In_sync, &flags)) {
2443 2444 2445
		len += sprintf(page+len, "%sspare", sep);
		sep = ",";
	}
2446
	if (test_bit(WriteErrorSeen, &flags)) {
2447 2448 2449
		len += sprintf(page+len, "%swrite_error", sep);
		sep = ",";
	}
2450
	if (test_bit(WantReplacement, &flags)) {
2451 2452 2453
		len += sprintf(page+len, "%swant_replacement", sep);
		sep = ",";
	}
2454
	if (test_bit(Replacement, &flags)) {
2455 2456 2457 2458
		len += sprintf(page+len, "%sreplacement", sep);
		sep = ",";
	}

2459 2460 2461
	return len+sprintf(page+len, "\n");
}

2462
static ssize_t
2463
state_store(struct md_rdev *rdev, const char *buf, size_t len)
2464 2465
{
	/* can write
2466
	 *  faulty  - simulates an error
2467
	 *  remove  - disconnects the device
2468 2469
	 *  writemostly - sets write_mostly
	 *  -writemostly - clears write_mostly
2470 2471
	 *  blocked - sets the Blocked flags
	 *  -blocked - clears the Blocked and possibly simulates an error
2472
	 *  insync - sets Insync providing device isn't active
2473 2474
	 *  -insync - clear Insync for a device with a slot assigned,
	 *            so that it gets rebuilt based on bitmap
2475 2476
	 *  write_error - sets WriteErrorSeen
	 *  -write_error - clears WriteErrorSeen
2477 2478 2479 2480
	 */
	int err = -EINVAL;
	if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
		md_error(rdev->mddev, rdev);
2481 2482 2483 2484
		if (test_bit(Faulty, &rdev->flags))
			err = 0;
		else
			err = -EBUSY;
2485 2486 2487 2488
	} else if (cmd_match(buf, "remove")) {
		if (rdev->raid_disk >= 0)
			err = -EBUSY;
		else {
2489
			struct mddev *mddev = rdev->mddev;
2490
			if (mddev_is_clustered(mddev))
2491
				md_cluster_ops->remove_disk(mddev, rdev);
2492
			md_kick_rdev_from_array(rdev);
2493 2494
			if (mddev_is_clustered(mddev))
				md_cluster_ops->metadata_update_start(mddev);
2495 2496
			if (mddev->pers)
				md_update_sb(mddev, 1);
2497
			md_new_event(mddev);
2498 2499
			if (mddev_is_clustered(mddev))
				md_cluster_ops->metadata_update_finish(mddev);
2500 2501
			err = 0;
		}
2502 2503 2504 2505 2506
	} else if (cmd_match(buf, "writemostly")) {
		set_bit(WriteMostly, &rdev->flags);
		err = 0;
	} else if (cmd_match(buf, "-writemostly")) {
		clear_bit(WriteMostly, &rdev->flags);
2507 2508 2509 2510 2511
		err = 0;
	} else if (cmd_match(buf, "blocked")) {
		set_bit(Blocked, &rdev->flags);
		err = 0;
	} else if (cmd_match(buf, "-blocked")) {
2512
		if (!test_bit(Faulty, &rdev->flags) &&
2513
		    rdev->badblocks.unacked_exist) {
2514 2515 2516 2517 2518
			/* metadata handler doesn't understand badblocks,
			 * so we need to fail the device
			 */
			md_error(rdev->mddev, rdev);
		}
2519
		clear_bit(Blocked, &rdev->flags);
2520
		clear_bit(BlockedBadBlocks, &rdev->flags);
2521 2522 2523 2524
		wake_up(&rdev->blocked_wait);
		set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
		md_wakeup_thread(rdev->mddev->thread);

2525 2526 2527
		err = 0;
	} else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
		set_bit(In_sync, &rdev->flags);
2528
		err = 0;
2529
	} else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0) {
2530 2531 2532 2533 2534 2535
		if (rdev->mddev->pers == NULL) {
			clear_bit(In_sync, &rdev->flags);
			rdev->saved_raid_disk = rdev->raid_disk;
			rdev->raid_disk = -1;
			err = 0;
		}
2536 2537 2538 2539 2540 2541
	} else if (cmd_match(buf, "write_error")) {
		set_bit(WriteErrorSeen, &rdev->flags);
		err = 0;
	} else if (cmd_match(buf, "-write_error")) {
		clear_bit(WriteErrorSeen, &rdev->flags);
		err = 0;
2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
	} else if (cmd_match(buf, "want_replacement")) {
		/* Any non-spare device that is not a replacement can
		 * become want_replacement at any time, but we then need to
		 * check if recovery is needed.
		 */
		if (rdev->raid_disk >= 0 &&
		    !test_bit(Replacement, &rdev->flags))
			set_bit(WantReplacement, &rdev->flags);
		set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
		md_wakeup_thread(rdev->mddev->thread);
		err = 0;
	} else if (cmd_match(buf, "-want_replacement")) {
		/* Clearing 'want_replacement' is always allowed.
		 * Once replacements starts it is too late though.
		 */
		err = 0;
		clear_bit(WantReplacement, &rdev->flags);
	} else if (cmd_match(buf, "replacement")) {
		/* Can only set a device as a replacement when array has not
		 * yet been started.  Once running, replacement is automatic
		 * from spares, or by assigning 'slot'.
		 */
		if (rdev->mddev->pers)
			err = -EBUSY;
		else {
			set_bit(Replacement, &rdev->flags);
			err = 0;
		}
	} else if (cmd_match(buf, "-replacement")) {
		/* Similarly, can only clear Replacement before start */
		if (rdev->mddev->pers)
			err = -EBUSY;
		else {
			clear_bit(Replacement, &rdev->flags);
			err = 0;
		}
G
Goldwyn Rodrigues 已提交
2578 2579
	} else if (cmd_match(buf, "re-add")) {
		if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1)) {
2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590
			/* clear_bit is performed _after_ all the devices
			 * have their local Faulty bit cleared. If any writes
			 * happen in the meantime in the local node, they
			 * will land in the local bitmap, which will be synced
			 * by this node eventually
			 */
			if (!mddev_is_clustered(rdev->mddev) ||
			    (err = md_cluster_ops->gather_bitmaps(rdev)) == 0) {
				clear_bit(Faulty, &rdev->flags);
				err = add_bound_rdev(rdev);
			}
G
Goldwyn Rodrigues 已提交
2591 2592
		} else
			err = -EBUSY;
2593
	}
N
NeilBrown 已提交
2594 2595
	if (!err)
		sysfs_notify_dirent_safe(rdev->sysfs_state);
2596 2597
	return err ? err : len;
}
2598
static struct rdev_sysfs_entry rdev_state =
2599
__ATTR_PREALLOC(state, S_IRUGO|S_IWUSR, state_show, state_store);
2600

2601
static ssize_t
2602
errors_show(struct md_rdev *rdev, char *page)
2603 2604 2605 2606 2607
{
	return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
}

static ssize_t
2608
errors_store(struct md_rdev *rdev, const char *buf, size_t len)
2609
{
A
Alexey Dobriyan 已提交
2610 2611 2612 2613 2614 2615 2616 2617
	unsigned int n;
	int rv;

	rv = kstrtouint(buf, 10, &n);
	if (rv < 0)
		return rv;
	atomic_set(&rdev->corrected_errors, n);
	return len;
2618 2619
}
static struct rdev_sysfs_entry rdev_errors =
2620
__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
2621

2622
static ssize_t
2623
slot_show(struct md_rdev *rdev, char *page)
2624 2625 2626 2627 2628 2629 2630 2631
{
	if (rdev->raid_disk < 0)
		return sprintf(page, "none\n");
	else
		return sprintf(page, "%d\n", rdev->raid_disk);
}

static ssize_t
2632
slot_store(struct md_rdev *rdev, const char *buf, size_t len)
2633
{
A
Alexey Dobriyan 已提交
2634
	int slot;
2635
	int err;
A
Alexey Dobriyan 已提交
2636

2637 2638
	if (strncmp(buf, "none", 4)==0)
		slot = -1;
A
Alexey Dobriyan 已提交
2639 2640 2641 2642 2643
	else {
		err = kstrtouint(buf, 10, (unsigned int *)&slot);
		if (err < 0)
			return err;
	}
2644
	if (rdev->mddev->pers && slot == -1) {
2645 2646 2647 2648 2649 2650 2651 2652 2653 2654
		/* Setting 'slot' on an active array requires also
		 * updating the 'rd%d' link, and communicating
		 * with the personality with ->hot_*_disk.
		 * For now we only support removing
		 * failed/spare devices.  This normally happens automatically,
		 * but not when the metadata is externally managed.
		 */
		if (rdev->raid_disk == -1)
			return -EEXIST;
		/* personality does all needed checks */
2655
		if (rdev->mddev->pers->hot_remove_disk == NULL)
2656
			return -EINVAL;
2657 2658 2659 2660
		clear_bit(Blocked, &rdev->flags);
		remove_and_add_spares(rdev->mddev, rdev);
		if (rdev->raid_disk >= 0)
			return -EBUSY;
2661 2662
		set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
		md_wakeup_thread(rdev->mddev->thread);
2663 2664
	} else if (rdev->mddev->pers) {
		/* Activating a spare .. or possibly reactivating
2665
		 * if we ever get bitmaps working here.
2666 2667 2668 2669 2670
		 */

		if (rdev->raid_disk != -1)
			return -EBUSY;

2671 2672 2673
		if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
			return -EBUSY;

2674 2675 2676
		if (rdev->mddev->pers->hot_add_disk == NULL)
			return -EINVAL;

2677 2678 2679 2680
		if (slot >= rdev->mddev->raid_disks &&
		    slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
			return -ENOSPC;

2681 2682 2683 2684 2685
		rdev->raid_disk = slot;
		if (test_bit(In_sync, &rdev->flags))
			rdev->saved_raid_disk = slot;
		else
			rdev->saved_raid_disk = -1;
2686
		clear_bit(In_sync, &rdev->flags);
2687
		clear_bit(Bitmap_sync, &rdev->flags);
2688 2689
		err = rdev->mddev->pers->
			hot_add_disk(rdev->mddev, rdev);
2690
		if (err) {
2691 2692
			rdev->raid_disk = -1;
			return err;
2693
		} else
N
NeilBrown 已提交
2694
			sysfs_notify_dirent_safe(rdev->sysfs_state);
2695
		if (sysfs_link_rdev(rdev->mddev, rdev))
N
NeilBrown 已提交
2696
			/* failure here is OK */;
2697
		/* don't wakeup anyone, leave that to userspace. */
2698
	} else {
2699 2700
		if (slot >= rdev->mddev->raid_disks &&
		    slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
2701 2702 2703
			return -ENOSPC;
		rdev->raid_disk = slot;
		/* assume it is working */
2704 2705
		clear_bit(Faulty, &rdev->flags);
		clear_bit(WriteMostly, &rdev->flags);
2706
		set_bit(In_sync, &rdev->flags);
N
NeilBrown 已提交
2707
		sysfs_notify_dirent_safe(rdev->sysfs_state);
2708
	}
2709 2710 2711 2712
	return len;
}

static struct rdev_sysfs_entry rdev_slot =
2713
__ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
2714

2715
static ssize_t
2716
offset_show(struct md_rdev *rdev, char *page)
2717
{
2718
	return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
2719 2720 2721
}

static ssize_t
2722
offset_store(struct md_rdev *rdev, const char *buf, size_t len)
2723
{
2724
	unsigned long long offset;
2725
	if (kstrtoull(buf, 10, &offset) < 0)
2726
		return -EINVAL;
2727
	if (rdev->mddev->pers && rdev->raid_disk >= 0)
2728
		return -EBUSY;
2729
	if (rdev->sectors && rdev->mddev->external)
2730 2731 2732
		/* Must set offset before size, so overlap checks
		 * can be sane */
		return -EBUSY;
2733
	rdev->data_offset = offset;
2734
	rdev->new_data_offset = offset;
2735 2736 2737 2738
	return len;
}

static struct rdev_sysfs_entry rdev_offset =
2739
__ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
2740

2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752
static ssize_t new_offset_show(struct md_rdev *rdev, char *page)
{
	return sprintf(page, "%llu\n",
		       (unsigned long long)rdev->new_data_offset);
}

static ssize_t new_offset_store(struct md_rdev *rdev,
				const char *buf, size_t len)
{
	unsigned long long new_offset;
	struct mddev *mddev = rdev->mddev;

2753
	if (kstrtoull(buf, 10, &new_offset) < 0)
2754 2755
		return -EINVAL;

2756 2757
	if (mddev->sync_thread ||
	    test_bit(MD_RECOVERY_RUNNING,&mddev->recovery))
2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798
		return -EBUSY;
	if (new_offset == rdev->data_offset)
		/* reset is always permitted */
		;
	else if (new_offset > rdev->data_offset) {
		/* must not push array size beyond rdev_sectors */
		if (new_offset - rdev->data_offset
		    + mddev->dev_sectors > rdev->sectors)
				return -E2BIG;
	}
	/* Metadata worries about other space details. */

	/* decreasing the offset is inconsistent with a backwards
	 * reshape.
	 */
	if (new_offset < rdev->data_offset &&
	    mddev->reshape_backwards)
		return -EINVAL;
	/* Increasing offset is inconsistent with forwards
	 * reshape.  reshape_direction should be set to
	 * 'backwards' first.
	 */
	if (new_offset > rdev->data_offset &&
	    !mddev->reshape_backwards)
		return -EINVAL;

	if (mddev->pers && mddev->persistent &&
	    !super_types[mddev->major_version]
	    .allow_new_offset(rdev, new_offset))
		return -E2BIG;
	rdev->new_data_offset = new_offset;
	if (new_offset > rdev->data_offset)
		mddev->reshape_backwards = 1;
	else if (new_offset < rdev->data_offset)
		mddev->reshape_backwards = 0;

	return len;
}
static struct rdev_sysfs_entry rdev_new_offset =
__ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store);

2799
static ssize_t
2800
rdev_size_show(struct md_rdev *rdev, char *page)
2801
{
2802
	return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
2803 2804
}

2805 2806 2807 2808 2809 2810 2811 2812 2813 2814
static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
{
	/* check if two start/length pairs overlap */
	if (s1+l1 <= s2)
		return 0;
	if (s2+l2 <= s1)
		return 0;
	return 1;
}

D
Dan Williams 已提交
2815 2816 2817 2818 2819
static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
{
	unsigned long long blocks;
	sector_t new;

2820
	if (kstrtoull(buf, 10, &blocks) < 0)
D
Dan Williams 已提交
2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833
		return -EINVAL;

	if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
		return -EINVAL; /* sector conversion overflow */

	new = blocks * 2;
	if (new != blocks * 2)
		return -EINVAL; /* unsigned long long to sector_t overflow */

	*sectors = new;
	return 0;
}

2834
static ssize_t
2835
rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
2836
{
2837
	struct mddev *my_mddev = rdev->mddev;
2838
	sector_t oldsectors = rdev->sectors;
D
Dan Williams 已提交
2839
	sector_t sectors;
2840

D
Dan Williams 已提交
2841
	if (strict_blocks_to_sectors(buf, &sectors) < 0)
N
Neil Brown 已提交
2842
		return -EINVAL;
2843 2844
	if (rdev->data_offset != rdev->new_data_offset)
		return -EINVAL; /* too confusing */
2845
	if (my_mddev->pers && rdev->raid_disk >= 0) {
N
Neil Brown 已提交
2846
		if (my_mddev->persistent) {
2847 2848 2849
			sectors = super_types[my_mddev->major_version].
				rdev_size_change(rdev, sectors);
			if (!sectors)
2850
				return -EBUSY;
2851
		} else if (!sectors)
2852
			sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
2853
				rdev->data_offset;
2854 2855 2856
		if (!my_mddev->pers->resize)
			/* Cannot change size for RAID0 or Linear etc */
			return -EINVAL;
2857
	}
2858
	if (sectors < my_mddev->dev_sectors)
2859
		return -EINVAL; /* component must fit device */
2860

2861 2862
	rdev->sectors = sectors;
	if (sectors > oldsectors && my_mddev->external) {
2863 2864 2865 2866 2867
		/* Need to check that all other rdevs with the same
		 * ->bdev do not overlap.  'rcu' is sufficient to walk
		 * the rdev lists safely.
		 * This check does not provide a hard guarantee, it
		 * just helps avoid dangerous mistakes.
2868
		 */
2869
		struct mddev *mddev;
2870
		int overlap = 0;
2871
		struct list_head *tmp;
2872

2873
		rcu_read_lock();
2874
		for_each_mddev(mddev, tmp) {
2875
			struct md_rdev *rdev2;
2876

N
NeilBrown 已提交
2877
			rdev_for_each(rdev2, mddev)
2878 2879 2880 2881 2882
				if (rdev->bdev == rdev2->bdev &&
				    rdev != rdev2 &&
				    overlaps(rdev->data_offset, rdev->sectors,
					     rdev2->data_offset,
					     rdev2->sectors)) {
2883 2884 2885 2886 2887 2888 2889 2890
					overlap = 1;
					break;
				}
			if (overlap) {
				mddev_put(mddev);
				break;
			}
		}
2891
		rcu_read_unlock();
2892 2893 2894
		if (overlap) {
			/* Someone else could have slipped in a size
			 * change here, but doing so is just silly.
2895
			 * We put oldsectors back because we *know* it is
2896 2897 2898
			 * safe, and trust userspace not to race with
			 * itself
			 */
2899
			rdev->sectors = oldsectors;
2900 2901 2902
			return -EBUSY;
		}
	}
2903 2904 2905 2906
	return len;
}

static struct rdev_sysfs_entry rdev_size =
2907
__ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
2908

2909
static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
2910 2911 2912 2913 2914 2915 2916 2917 2918 2919
{
	unsigned long long recovery_start = rdev->recovery_offset;

	if (test_bit(In_sync, &rdev->flags) ||
	    recovery_start == MaxSector)
		return sprintf(page, "none\n");

	return sprintf(page, "%llu\n", recovery_start);
}

2920
static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
2921 2922 2923 2924 2925
{
	unsigned long long recovery_start;

	if (cmd_match(buf, "none"))
		recovery_start = MaxSector;
2926
	else if (kstrtoull(buf, 10, &recovery_start))
2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943
		return -EINVAL;

	if (rdev->mddev->pers &&
	    rdev->raid_disk >= 0)
		return -EBUSY;

	rdev->recovery_offset = recovery_start;
	if (recovery_start == MaxSector)
		set_bit(In_sync, &rdev->flags);
	else
		clear_bit(In_sync, &rdev->flags);
	return len;
}

static struct rdev_sysfs_entry rdev_recovery_start =
__ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);

2944 2945 2946 2947 2948
static ssize_t
badblocks_show(struct badblocks *bb, char *page, int unack);
static ssize_t
badblocks_store(struct badblocks *bb, const char *page, size_t len, int unack);

2949
static ssize_t bb_show(struct md_rdev *rdev, char *page)
2950 2951 2952
{
	return badblocks_show(&rdev->badblocks, page, 0);
}
2953
static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
2954
{
2955 2956 2957 2958 2959
	int rv = badblocks_store(&rdev->badblocks, page, len, 0);
	/* Maybe that ack was all we needed */
	if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags))
		wake_up(&rdev->blocked_wait);
	return rv;
2960 2961 2962 2963
}
static struct rdev_sysfs_entry rdev_bad_blocks =
__ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);

2964
static ssize_t ubb_show(struct md_rdev *rdev, char *page)
2965 2966 2967
{
	return badblocks_show(&rdev->badblocks, page, 1);
}
2968
static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
2969 2970 2971 2972 2973 2974
{
	return badblocks_store(&rdev->badblocks, page, len, 1);
}
static struct rdev_sysfs_entry rdev_unack_bad_blocks =
__ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store);

2975 2976
static struct attribute *rdev_default_attrs[] = {
	&rdev_state.attr,
2977
	&rdev_errors.attr,
2978
	&rdev_slot.attr,
2979
	&rdev_offset.attr,
2980
	&rdev_new_offset.attr,
2981
	&rdev_size.attr,
2982
	&rdev_recovery_start.attr,
2983 2984
	&rdev_bad_blocks.attr,
	&rdev_unack_bad_blocks.attr,
2985 2986 2987 2988 2989 2990
	NULL,
};
static ssize_t
rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
{
	struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
2991
	struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
2992 2993 2994

	if (!entry->show)
		return -EIO;
2995 2996 2997
	if (!rdev->mddev)
		return -EBUSY;
	return entry->show(rdev, page);
2998 2999 3000 3001 3002 3003 3004
}

static ssize_t
rdev_attr_store(struct kobject *kobj, struct attribute *attr,
	      const char *page, size_t length)
{
	struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
3005
	struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
3006
	ssize_t rv;
3007
	struct mddev *mddev = rdev->mddev;
3008 3009 3010

	if (!entry->store)
		return -EIO;
3011 3012
	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
3013
	rv = mddev ? mddev_lock(mddev): -EBUSY;
3014
	if (!rv) {
3015 3016 3017 3018
		if (rdev->mddev == NULL)
			rv = -EBUSY;
		else
			rv = entry->store(rdev, page, length);
3019
		mddev_unlock(mddev);
3020 3021
	}
	return rv;
3022 3023 3024 3025
}

static void rdev_free(struct kobject *ko)
{
3026
	struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
3027 3028
	kfree(rdev);
}
3029
static const struct sysfs_ops rdev_sysfs_ops = {
3030 3031 3032 3033 3034 3035 3036 3037 3038
	.show		= rdev_attr_show,
	.store		= rdev_attr_store,
};
static struct kobj_type rdev_ktype = {
	.release	= rdev_free,
	.sysfs_ops	= &rdev_sysfs_ops,
	.default_attrs	= rdev_default_attrs,
};

3039
int md_rdev_init(struct md_rdev *rdev)
N
NeilBrown 已提交
3040 3041 3042 3043 3044 3045
{
	rdev->desc_nr = -1;
	rdev->saved_raid_disk = -1;
	rdev->raid_disk = -1;
	rdev->flags = 0;
	rdev->data_offset = 0;
3046
	rdev->new_data_offset = 0;
N
NeilBrown 已提交
3047 3048 3049
	rdev->sb_events = 0;
	rdev->last_read_error.tv_sec  = 0;
	rdev->last_read_error.tv_nsec = 0;
3050 3051
	rdev->sb_loaded = 0;
	rdev->bb_page = NULL;
N
NeilBrown 已提交
3052 3053 3054 3055 3056 3057
	atomic_set(&rdev->nr_pending, 0);
	atomic_set(&rdev->read_errors, 0);
	atomic_set(&rdev->corrected_errors, 0);

	INIT_LIST_HEAD(&rdev->same_set);
	init_waitqueue_head(&rdev->blocked_wait);
3058 3059 3060 3061 3062 3063

	/* Add space to store bad block list.
	 * This reserves the space even on arrays where it cannot
	 * be used - I wonder if that matters
	 */
	rdev->badblocks.count = 0;
3064
	rdev->badblocks.shift = -1; /* disabled until explicitly enabled */
3065 3066 3067 3068 3069 3070
	rdev->badblocks.page = kmalloc(PAGE_SIZE, GFP_KERNEL);
	seqlock_init(&rdev->badblocks.lock);
	if (rdev->badblocks.page == NULL)
		return -ENOMEM;

	return 0;
N
NeilBrown 已提交
3071 3072
}
EXPORT_SYMBOL_GPL(md_rdev_init);
L
Linus Torvalds 已提交
3073 3074 3075 3076 3077 3078 3079 3080 3081 3082
/*
 * Import a device. If 'super_format' >= 0, then sanity check the superblock
 *
 * mark the device faulty if:
 *
 *   - the device is nonexistent (zero size)
 *   - the device has no valid superblock
 *
 * a faulty rdev _never_ has rdev->sb set.
 */
3083
static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
L
Linus Torvalds 已提交
3084 3085 3086
{
	char b[BDEVNAME_SIZE];
	int err;
3087
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
3088 3089
	sector_t size;

3090
	rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
L
Linus Torvalds 已提交
3091 3092 3093 3094 3095
	if (!rdev) {
		printk(KERN_ERR "md: could not alloc mem for new device!\n");
		return ERR_PTR(-ENOMEM);
	}

3096 3097 3098 3099 3100
	err = md_rdev_init(rdev);
	if (err)
		goto abort_free;
	err = alloc_disk_sb(rdev);
	if (err)
L
Linus Torvalds 已提交
3101 3102
		goto abort_free;

3103
	err = lock_rdev(rdev, newdev, super_format == -2);
L
Linus Torvalds 已提交
3104 3105 3106
	if (err)
		goto abort_free;

3107
	kobject_init(&rdev->kobj, &rdev_ktype);
3108

3109
	size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
L
Linus Torvalds 已提交
3110
	if (!size) {
3111
		printk(KERN_WARNING
L
Linus Torvalds 已提交
3112 3113 3114 3115 3116 3117 3118 3119 3120 3121
			"md: %s has zero or unknown size, marking faulty!\n",
			bdevname(rdev->bdev,b));
		err = -EINVAL;
		goto abort_free;
	}

	if (super_format >= 0) {
		err = super_types[super_format].
			load_super(rdev, NULL, super_minor);
		if (err == -EINVAL) {
3122 3123 3124 3125 3126
			printk(KERN_WARNING
				"md: %s does not have a valid v%d.%d "
			       "superblock, not importing!\n",
				bdevname(rdev->bdev,b),
			       super_format, super_minor);
L
Linus Torvalds 已提交
3127 3128 3129
			goto abort_free;
		}
		if (err < 0) {
3130
			printk(KERN_WARNING
L
Linus Torvalds 已提交
3131 3132 3133 3134 3135
				"md: could not read %s's sb, not importing!\n",
				bdevname(rdev->bdev,b));
			goto abort_free;
		}
	}
3136

L
Linus Torvalds 已提交
3137 3138 3139
	return rdev;

abort_free:
3140 3141
	if (rdev->bdev)
		unlock_rdev(rdev);
3142
	md_rdev_clear(rdev);
L
Linus Torvalds 已提交
3143 3144 3145 3146 3147 3148 3149 3150
	kfree(rdev);
	return ERR_PTR(err);
}

/*
 * Check a full RAID array for plausibility
 */

3151
static void analyze_sbs(struct mddev *mddev)
L
Linus Torvalds 已提交
3152 3153
{
	int i;
3154
	struct md_rdev *rdev, *freshest, *tmp;
L
Linus Torvalds 已提交
3155 3156 3157
	char b[BDEVNAME_SIZE];

	freshest = NULL;
N
NeilBrown 已提交
3158
	rdev_for_each_safe(rdev, tmp, mddev)
L
Linus Torvalds 已提交
3159 3160 3161 3162 3163 3164 3165 3166 3167 3168
		switch (super_types[mddev->major_version].
			load_super(rdev, freshest, mddev->minor_version)) {
		case 1:
			freshest = rdev;
			break;
		case 0:
			break;
		default:
			printk( KERN_ERR \
				"md: fatal superblock inconsistency in %s"
3169
				" -- removing from array\n",
L
Linus Torvalds 已提交
3170
				bdevname(rdev->bdev,b));
3171
			md_kick_rdev_from_array(rdev);
L
Linus Torvalds 已提交
3172 3173 3174 3175 3176 3177
		}

	super_types[mddev->major_version].
		validate_super(mddev, freshest);

	i = 0;
N
NeilBrown 已提交
3178
	rdev_for_each_safe(rdev, tmp, mddev) {
3179 3180 3181
		if (mddev->max_disks &&
		    (rdev->desc_nr >= mddev->max_disks ||
		     i > mddev->max_disks)) {
3182 3183 3184 3185
			printk(KERN_WARNING
			       "md: %s: %s: only %d devices permitted\n",
			       mdname(mddev), bdevname(rdev->bdev, b),
			       mddev->max_disks);
3186
			md_kick_rdev_from_array(rdev);
3187 3188
			continue;
		}
3189
		if (rdev != freshest) {
L
Linus Torvalds 已提交
3190 3191 3192 3193 3194
			if (super_types[mddev->major_version].
			    validate_super(mddev, rdev)) {
				printk(KERN_WARNING "md: kicking non-fresh %s"
					" from array!\n",
					bdevname(rdev->bdev,b));
3195
				md_kick_rdev_from_array(rdev);
L
Linus Torvalds 已提交
3196 3197
				continue;
			}
3198 3199 3200 3201 3202 3203
			/* No device should have a Candidate flag
			 * when reading devices
			 */
			if (test_bit(Candidate, &rdev->flags)) {
				pr_info("md: kicking Cluster Candidate %s from array!\n",
					bdevname(rdev->bdev, b));
3204
				md_kick_rdev_from_array(rdev);
3205 3206
			}
		}
L
Linus Torvalds 已提交
3207 3208 3209
		if (mddev->level == LEVEL_MULTIPATH) {
			rdev->desc_nr = i++;
			rdev->raid_disk = rdev->desc_nr;
3210
			set_bit(In_sync, &rdev->flags);
3211
		} else if (rdev->raid_disk >= (mddev->raid_disks - min(0, mddev->delta_disks))) {
3212 3213
			rdev->raid_disk = -1;
			clear_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
3214 3215 3216 3217
		}
	}
}

3218 3219 3220
/* Read a fixed-point number.
 * Numbers in sysfs attributes should be in "standard" units where
 * possible, so time should be in seconds.
3221
 * However we internally use a a much smaller unit such as
3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257
 * milliseconds or jiffies.
 * This function takes a decimal number with a possible fractional
 * component, and produces an integer which is the result of
 * multiplying that number by 10^'scale'.
 * all without any floating-point arithmetic.
 */
int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
{
	unsigned long result = 0;
	long decimals = -1;
	while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
		if (*cp == '.')
			decimals = 0;
		else if (decimals < scale) {
			unsigned int value;
			value = *cp - '0';
			result = result * 10 + value;
			if (decimals >= 0)
				decimals++;
		}
		cp++;
	}
	if (*cp == '\n')
		cp++;
	if (*cp)
		return -EINVAL;
	if (decimals < 0)
		decimals = 0;
	while (decimals < scale) {
		result *= 10;
		decimals ++;
	}
	*res = result;
	return 0;
}

3258
static ssize_t
3259
safe_delay_show(struct mddev *mddev, char *page)
3260 3261 3262 3263 3264
{
	int msec = (mddev->safemode_delay*1000)/HZ;
	return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
}
static ssize_t
3265
safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
3266 3267
{
	unsigned long msec;
3268

3269
	if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
3270 3271 3272 3273
		return -EINVAL;
	if (msec == 0)
		mddev->safemode_delay = 0;
	else {
3274
		unsigned long old_delay = mddev->safemode_delay;
3275 3276 3277 3278 3279 3280 3281
		unsigned long new_delay = (msec*HZ)/1000;

		if (new_delay == 0)
			new_delay = 1;
		mddev->safemode_delay = new_delay;
		if (new_delay < old_delay || old_delay == 0)
			mod_timer(&mddev->safemode_timer, jiffies+1);
3282 3283 3284 3285
	}
	return len;
}
static struct md_sysfs_entry md_safe_delay =
3286
__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
3287

3288
static ssize_t
3289
level_show(struct mddev *mddev, char *page)
3290
{
3291 3292 3293 3294
	struct md_personality *p;
	int ret;
	spin_lock(&mddev->lock);
	p = mddev->pers;
3295
	if (p)
3296
		ret = sprintf(page, "%s\n", p->name);
3297
	else if (mddev->clevel[0])
3298
		ret = sprintf(page, "%s\n", mddev->clevel);
3299
	else if (mddev->level != LEVEL_NONE)
3300
		ret = sprintf(page, "%d\n", mddev->level);
3301
	else
3302 3303 3304
		ret = 0;
	spin_unlock(&mddev->lock);
	return ret;
3305 3306
}

3307
static ssize_t
3308
level_store(struct mddev *mddev, const char *buf, size_t len)
3309
{
3310
	char clevel[16];
3311 3312
	ssize_t rv;
	size_t slen = len;
3313
	struct md_personality *pers, *oldpers;
3314
	long level;
3315
	void *priv, *oldpriv;
3316
	struct md_rdev *rdev;
3317

3318 3319 3320 3321 3322 3323 3324
	if (slen == 0 || slen >= sizeof(clevel))
		return -EINVAL;

	rv = mddev_lock(mddev);
	if (rv)
		return rv;

3325
	if (mddev->pers == NULL) {
3326 3327 3328 3329
		strncpy(mddev->clevel, buf, slen);
		if (mddev->clevel[slen-1] == '\n')
			slen--;
		mddev->clevel[slen] = 0;
3330
		mddev->level = LEVEL_NONE;
3331 3332
		rv = len;
		goto out_unlock;
3333
	}
3334
	rv = -EROFS;
3335
	if (mddev->ro)
3336
		goto out_unlock;
3337 3338 3339 3340 3341 3342 3343

	/* request to change the personality.  Need to ensure:
	 *  - array is not engaged in resync/recovery/reshape
	 *  - old personality can be suspended
	 *  - new personality will access other array.
	 */

3344
	rv = -EBUSY;
3345
	if (mddev->sync_thread ||
3346
	    test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3347 3348
	    mddev->reshape_position != MaxSector ||
	    mddev->sysfs_active)
3349
		goto out_unlock;
3350

3351
	rv = -EINVAL;
3352 3353 3354
	if (!mddev->pers->quiesce) {
		printk(KERN_WARNING "md: %s: %s does not support online personality change\n",
		       mdname(mddev), mddev->pers->name);
3355
		goto out_unlock;
3356 3357 3358
	}

	/* Now find the new personality */
3359 3360 3361 3362
	strncpy(clevel, buf, slen);
	if (clevel[slen-1] == '\n')
		slen--;
	clevel[slen] = 0;
3363
	if (kstrtol(clevel, 10, &level))
3364
		level = LEVEL_NONE;
3365

3366 3367
	if (request_module("md-%s", clevel) != 0)
		request_module("md-level-%s", clevel);
3368
	spin_lock(&pers_lock);
3369
	pers = find_pers(level, clevel);
3370 3371
	if (!pers || !try_module_get(pers->owner)) {
		spin_unlock(&pers_lock);
3372
		printk(KERN_WARNING "md: personality %s not loaded\n", clevel);
3373 3374
		rv = -EINVAL;
		goto out_unlock;
3375 3376 3377 3378 3379 3380
	}
	spin_unlock(&pers_lock);

	if (pers == mddev->pers) {
		/* Nothing to do! */
		module_put(pers->owner);
3381 3382
		rv = len;
		goto out_unlock;
3383 3384 3385 3386
	}
	if (!pers->takeover) {
		module_put(pers->owner);
		printk(KERN_WARNING "md: %s: %s does not support personality takeover\n",
3387
		       mdname(mddev), clevel);
3388 3389
		rv = -EINVAL;
		goto out_unlock;
3390 3391
	}

N
NeilBrown 已提交
3392
	rdev_for_each(rdev, mddev)
3393 3394
		rdev->new_raid_disk = rdev->raid_disk;

3395 3396 3397 3398 3399 3400 3401
	/* ->takeover must set new_* and/or delta_disks
	 * if it succeeds, and may set them when it fails.
	 */
	priv = pers->takeover(mddev);
	if (IS_ERR(priv)) {
		mddev->new_level = mddev->level;
		mddev->new_layout = mddev->layout;
3402
		mddev->new_chunk_sectors = mddev->chunk_sectors;
3403 3404
		mddev->raid_disks -= mddev->delta_disks;
		mddev->delta_disks = 0;
3405
		mddev->reshape_backwards = 0;
3406 3407
		module_put(pers->owner);
		printk(KERN_WARNING "md: %s: %s would not accept array\n",
3408
		       mdname(mddev), clevel);
3409 3410
		rv = PTR_ERR(priv);
		goto out_unlock;
3411 3412 3413 3414
	}

	/* Looks like we have a winner */
	mddev_suspend(mddev);
3415
	mddev_detach(mddev);
3416 3417

	spin_lock(&mddev->lock);
3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428
	oldpers = mddev->pers;
	oldpriv = mddev->private;
	mddev->pers = pers;
	mddev->private = priv;
	strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
	mddev->level = mddev->new_level;
	mddev->layout = mddev->new_layout;
	mddev->chunk_sectors = mddev->new_chunk_sectors;
	mddev->delta_disks = 0;
	mddev->reshape_backwards = 0;
	mddev->degraded = 0;
3429
	spin_unlock(&mddev->lock);
3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443

	if (oldpers->sync_request == NULL &&
	    mddev->external) {
		/* We are converting from a no-redundancy array
		 * to a redundancy array and metadata is managed
		 * externally so we need to be sure that writes
		 * won't block due to a need to transition
		 *      clean->dirty
		 * until external management is started.
		 */
		mddev->in_sync = 0;
		mddev->safemode_delay = 0;
		mddev->safemode = 0;
	}
3444

3445 3446 3447
	oldpers->free(mddev, oldpriv);

	if (oldpers->sync_request == NULL &&
3448 3449 3450 3451 3452 3453
	    pers->sync_request != NULL) {
		/* need to add the md_redundancy_group */
		if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
			printk(KERN_WARNING
			       "md: cannot register extra attributes for %s\n",
			       mdname(mddev));
T
Tejun Heo 已提交
3454
		mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
3455
	}
3456
	if (oldpers->sync_request != NULL &&
3457 3458 3459 3460 3461 3462
	    pers->sync_request == NULL) {
		/* need to remove the md_redundancy_group */
		if (mddev->to_remove == NULL)
			mddev->to_remove = &md_redundancy_group;
	}

N
NeilBrown 已提交
3463
	rdev_for_each(rdev, mddev) {
3464 3465
		if (rdev->raid_disk < 0)
			continue;
3466
		if (rdev->new_raid_disk >= mddev->raid_disks)
3467 3468 3469
			rdev->new_raid_disk = -1;
		if (rdev->new_raid_disk == rdev->raid_disk)
			continue;
3470
		sysfs_unlink_rdev(mddev, rdev);
3471
	}
N
NeilBrown 已提交
3472
	rdev_for_each(rdev, mddev) {
3473 3474 3475 3476 3477 3478
		if (rdev->raid_disk < 0)
			continue;
		if (rdev->new_raid_disk == rdev->raid_disk)
			continue;
		rdev->raid_disk = rdev->new_raid_disk;
		if (rdev->raid_disk < 0)
3479
			clear_bit(In_sync, &rdev->flags);
3480
		else {
3481 3482 3483 3484
			if (sysfs_link_rdev(mddev, rdev))
				printk(KERN_WARNING "md: cannot register rd%d"
				       " for %s after level change\n",
				       rdev->raid_disk, mdname(mddev));
3485
		}
3486 3487
	}

3488
	if (pers->sync_request == NULL) {
3489 3490 3491 3492 3493 3494
		/* this is now an array without redundancy, so
		 * it must always be in_sync
		 */
		mddev->in_sync = 1;
		del_timer_sync(&mddev->safemode_timer);
	}
3495
	blk_set_stacking_limits(&mddev->queue->limits);
3496 3497
	pers->run(mddev);
	set_bit(MD_CHANGE_DEVS, &mddev->flags);
3498
	mddev_resume(mddev);
3499 3500
	if (!mddev->thread)
		md_update_sb(mddev, 1);
3501
	sysfs_notify(&mddev->kobj, NULL, "level");
3502
	md_new_event(mddev);
3503 3504 3505
	rv = len;
out_unlock:
	mddev_unlock(mddev);
3506 3507 3508 3509
	return rv;
}

static struct md_sysfs_entry md_level =
3510
__ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
3511

3512
static ssize_t
3513
layout_show(struct mddev *mddev, char *page)
3514 3515
{
	/* just a number, not meaningful for all levels */
3516 3517 3518 3519
	if (mddev->reshape_position != MaxSector &&
	    mddev->layout != mddev->new_layout)
		return sprintf(page, "%d (%d)\n",
			       mddev->new_layout, mddev->layout);
3520 3521 3522 3523
	return sprintf(page, "%d\n", mddev->layout);
}

static ssize_t
3524
layout_store(struct mddev *mddev, const char *buf, size_t len)
3525
{
A
Alexey Dobriyan 已提交
3526
	unsigned int n;
3527
	int err;
3528

A
Alexey Dobriyan 已提交
3529 3530 3531
	err = kstrtouint(buf, 10, &n);
	if (err < 0)
		return err;
3532 3533 3534
	err = mddev_lock(mddev);
	if (err)
		return err;
3535

3536
	if (mddev->pers) {
3537
		if (mddev->pers->check_reshape == NULL)
3538 3539 3540 3541 3542 3543 3544 3545
			err = -EBUSY;
		else if (mddev->ro)
			err = -EROFS;
		else {
			mddev->new_layout = n;
			err = mddev->pers->check_reshape(mddev);
			if (err)
				mddev->new_layout = mddev->layout;
3546
		}
3547
	} else {
3548
		mddev->new_layout = n;
3549 3550 3551
		if (mddev->reshape_position == MaxSector)
			mddev->layout = n;
	}
3552 3553
	mddev_unlock(mddev);
	return err ?: len;
3554 3555
}
static struct md_sysfs_entry md_layout =
3556
__ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
3557

3558
static ssize_t
3559
raid_disks_show(struct mddev *mddev, char *page)
3560
{
3561 3562
	if (mddev->raid_disks == 0)
		return 0;
3563 3564 3565 3566
	if (mddev->reshape_position != MaxSector &&
	    mddev->delta_disks != 0)
		return sprintf(page, "%d (%d)\n", mddev->raid_disks,
			       mddev->raid_disks - mddev->delta_disks);
3567 3568 3569
	return sprintf(page, "%d\n", mddev->raid_disks);
}

3570
static int update_raid_disks(struct mddev *mddev, int raid_disks);
3571 3572

static ssize_t
3573
raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
3574
{
A
Alexey Dobriyan 已提交
3575
	unsigned int n;
3576
	int err;
3577

A
Alexey Dobriyan 已提交
3578 3579 3580
	err = kstrtouint(buf, 10, &n);
	if (err < 0)
		return err;
3581

3582 3583 3584
	err = mddev_lock(mddev);
	if (err)
		return err;
3585
	if (mddev->pers)
3586
		err = update_raid_disks(mddev, n);
3587
	else if (mddev->reshape_position != MaxSector) {
3588
		struct md_rdev *rdev;
3589
		int olddisks = mddev->raid_disks - mddev->delta_disks;
3590

3591
		err = -EINVAL;
3592 3593 3594
		rdev_for_each(rdev, mddev) {
			if (olddisks < n &&
			    rdev->data_offset < rdev->new_data_offset)
3595
				goto out_unlock;
3596 3597
			if (olddisks > n &&
			    rdev->data_offset > rdev->new_data_offset)
3598
				goto out_unlock;
3599
		}
3600
		err = 0;
3601 3602
		mddev->delta_disks = n - olddisks;
		mddev->raid_disks = n;
3603
		mddev->reshape_backwards = (mddev->delta_disks < 0);
3604
	} else
3605
		mddev->raid_disks = n;
3606 3607 3608
out_unlock:
	mddev_unlock(mddev);
	return err ? err : len;
3609 3610
}
static struct md_sysfs_entry md_raid_disks =
3611
__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
3612

3613
static ssize_t
3614
chunk_size_show(struct mddev *mddev, char *page)
3615
{
3616
	if (mddev->reshape_position != MaxSector &&
3617 3618 3619
	    mddev->chunk_sectors != mddev->new_chunk_sectors)
		return sprintf(page, "%d (%d)\n",
			       mddev->new_chunk_sectors << 9,
3620 3621
			       mddev->chunk_sectors << 9);
	return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
3622 3623 3624
}

static ssize_t
3625
chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
3626
{
A
Alexey Dobriyan 已提交
3627
	unsigned long n;
3628
	int err;
3629

A
Alexey Dobriyan 已提交
3630 3631 3632
	err = kstrtoul(buf, 10, &n);
	if (err < 0)
		return err;
3633

3634 3635 3636
	err = mddev_lock(mddev);
	if (err)
		return err;
3637
	if (mddev->pers) {
3638
		if (mddev->pers->check_reshape == NULL)
3639 3640 3641 3642 3643 3644 3645 3646
			err = -EBUSY;
		else if (mddev->ro)
			err = -EROFS;
		else {
			mddev->new_chunk_sectors = n >> 9;
			err = mddev->pers->check_reshape(mddev);
			if (err)
				mddev->new_chunk_sectors = mddev->chunk_sectors;
3647
		}
3648
	} else {
3649
		mddev->new_chunk_sectors = n >> 9;
3650
		if (mddev->reshape_position == MaxSector)
3651
			mddev->chunk_sectors = n >> 9;
3652
	}
3653 3654
	mddev_unlock(mddev);
	return err ?: len;
3655 3656
}
static struct md_sysfs_entry md_chunk_size =
3657
__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
3658

3659
static ssize_t
3660
resync_start_show(struct mddev *mddev, char *page)
3661
{
3662 3663
	if (mddev->recovery_cp == MaxSector)
		return sprintf(page, "none\n");
3664 3665 3666 3667
	return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
}

static ssize_t
3668
resync_start_store(struct mddev *mddev, const char *buf, size_t len)
3669
{
A
Alexey Dobriyan 已提交
3670
	unsigned long long n;
3671
	int err;
A
Alexey Dobriyan 已提交
3672 3673 3674 3675 3676 3677 3678 3679 3680 3681

	if (cmd_match(buf, "none"))
		n = MaxSector;
	else {
		err = kstrtoull(buf, 10, &n);
		if (err < 0)
			return err;
		if (n != (sector_t)n)
			return -EINVAL;
	}
3682

3683 3684 3685
	err = mddev_lock(mddev);
	if (err)
		return err;
3686
	if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
3687
		err = -EBUSY;
3688

3689 3690 3691 3692 3693 3694 3695
	if (!err) {
		mddev->recovery_cp = n;
		if (mddev->pers)
			set_bit(MD_CHANGE_CLEAN, &mddev->flags);
	}
	mddev_unlock(mddev);
	return err ?: len;
3696 3697
}
static struct md_sysfs_entry md_resync_start =
3698 3699
__ATTR_PREALLOC(resync_start, S_IRUGO|S_IWUSR,
		resync_start_show, resync_start_store);
3700

3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712
/*
 * The array state can be:
 *
 * clear
 *     No devices, no size, no level
 *     Equivalent to STOP_ARRAY ioctl
 * inactive
 *     May have some settings, but array is not active
 *        all IO results in error
 *     When written, doesn't tear down array, but just stops it
 * suspended (not supported yet)
 *     All IO requests will block. The array can be reconfigured.
3713
 *     Writing this, if accepted, will block until array is quiescent
3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738
 * readonly
 *     no resync can happen.  no superblocks get written.
 *     write requests fail
 * read-auto
 *     like readonly, but behaves like 'clean' on a write request.
 *
 * clean - no pending writes, but otherwise active.
 *     When written to inactive array, starts without resync
 *     If a write request arrives then
 *       if metadata is known, mark 'dirty' and switch to 'active'.
 *       if not known, block and switch to write-pending
 *     If written to an active array that has pending writes, then fails.
 * active
 *     fully active: IO and resync can be happening.
 *     When written to inactive array, starts with resync
 *
 * write-pending
 *     clean, but writes are blocked waiting for 'active' to be written.
 *
 * active-idle
 *     like active, but no writes have been seen for a while (100msec).
 *
 */
enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
		   write_pending, active_idle, bad_word};
3739
static char *array_states[] = {
3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752
	"clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
	"write-pending", "active-idle", NULL };

static int match_word(const char *word, char **list)
{
	int n;
	for (n=0; list[n]; n++)
		if (cmd_match(word, list[n]))
			break;
	return n;
}

static ssize_t
3753
array_state_show(struct mddev *mddev, char *page)
3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767
{
	enum array_state st = inactive;

	if (mddev->pers)
		switch(mddev->ro) {
		case 1:
			st = readonly;
			break;
		case 2:
			st = read_auto;
			break;
		case 0:
			if (mddev->in_sync)
				st = clean;
3768
			else if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
3769
				st = write_pending;
3770 3771 3772 3773 3774 3775 3776 3777
			else if (mddev->safemode)
				st = active_idle;
			else
				st = active;
		}
	else {
		if (list_empty(&mddev->disks) &&
		    mddev->raid_disks == 0 &&
A
Andre Noll 已提交
3778
		    mddev->dev_sectors == 0)
3779 3780 3781 3782 3783 3784 3785
			st = clear;
		else
			st = inactive;
	}
	return sprintf(page, "%s\n", array_states[st]);
}

3786 3787 3788
static int do_md_stop(struct mddev *mddev, int ro, struct block_device *bdev);
static int md_set_readonly(struct mddev *mddev, struct block_device *bdev);
static int do_md_run(struct mddev *mddev);
3789
static int restart_array(struct mddev *mddev);
3790 3791

static ssize_t
3792
array_state_store(struct mddev *mddev, const char *buf, size_t len)
3793
{
3794
	int err;
3795
	enum array_state st = match_word(buf, array_states);
3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820

	if (mddev->pers && (st == active || st == clean) && mddev->ro != 1) {
		/* don't take reconfig_mutex when toggling between
		 * clean and active
		 */
		spin_lock(&mddev->lock);
		if (st == active) {
			restart_array(mddev);
			clear_bit(MD_CHANGE_PENDING, &mddev->flags);
			wake_up(&mddev->sb_wait);
			err = 0;
		} else /* st == clean */ {
			restart_array(mddev);
			if (atomic_read(&mddev->writes_pending) == 0) {
				if (mddev->in_sync == 0) {
					mddev->in_sync = 1;
					if (mddev->safemode == 1)
						mddev->safemode = 0;
					set_bit(MD_CHANGE_CLEAN, &mddev->flags);
				}
				err = 0;
			} else
				err = -EBUSY;
		}
		spin_unlock(&mddev->lock);
3821
		return err ?: len;
3822 3823 3824 3825 3826
	}
	err = mddev_lock(mddev);
	if (err)
		return err;
	err = -EINVAL;
3827 3828 3829 3830 3831
	switch(st) {
	case bad_word:
		break;
	case clear:
		/* stopping an active array */
3832
		err = do_md_stop(mddev, 0, NULL);
3833 3834 3835
		break;
	case inactive:
		/* stopping an active array */
3836
		if (mddev->pers)
3837
			err = do_md_stop(mddev, 2, NULL);
3838
		else
3839
			err = 0; /* already inactive */
3840 3841 3842 3843 3844
		break;
	case suspended:
		break; /* not supported yet */
	case readonly:
		if (mddev->pers)
3845
			err = md_set_readonly(mddev, NULL);
3846 3847
		else {
			mddev->ro = 1;
3848
			set_disk_ro(mddev->gendisk, 1);
3849 3850 3851 3852 3853
			err = do_md_run(mddev);
		}
		break;
	case read_auto:
		if (mddev->pers) {
3854
			if (mddev->ro == 0)
3855
				err = md_set_readonly(mddev, NULL);
3856
			else if (mddev->ro == 1)
3857 3858 3859 3860 3861
				err = restart_array(mddev);
			if (err == 0) {
				mddev->ro = 2;
				set_disk_ro(mddev->gendisk, 0);
			}
3862 3863 3864 3865 3866 3867 3868 3869
		} else {
			mddev->ro = 2;
			err = do_md_run(mddev);
		}
		break;
	case clean:
		if (mddev->pers) {
			restart_array(mddev);
3870
			spin_lock(&mddev->lock);
3871
			if (atomic_read(&mddev->writes_pending) == 0) {
3872 3873
				if (mddev->in_sync == 0) {
					mddev->in_sync = 1;
3874 3875
					if (mddev->safemode == 1)
						mddev->safemode = 0;
3876
					set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3877 3878 3879 3880
				}
				err = 0;
			} else
				err = -EBUSY;
3881
			spin_unlock(&mddev->lock);
3882 3883
		} else
			err = -EINVAL;
3884 3885 3886 3887
		break;
	case active:
		if (mddev->pers) {
			restart_array(mddev);
3888
			clear_bit(MD_CHANGE_PENDING, &mddev->flags);
3889 3890 3891 3892
			wake_up(&mddev->sb_wait);
			err = 0;
		} else {
			mddev->ro = 0;
3893
			set_disk_ro(mddev->gendisk, 0);
3894 3895 3896 3897 3898 3899 3900 3901
			err = do_md_run(mddev);
		}
		break;
	case write_pending:
	case active_idle:
		/* these cannot be set */
		break;
	}
3902 3903

	if (!err) {
3904 3905
		if (mddev->hold_active == UNTIL_IOCTL)
			mddev->hold_active = 0;
N
NeilBrown 已提交
3906
		sysfs_notify_dirent_safe(mddev->sysfs_state);
3907
	}
3908 3909
	mddev_unlock(mddev);
	return err ?: len;
3910
}
3911
static struct md_sysfs_entry md_array_state =
3912
__ATTR_PREALLOC(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
3913

3914
static ssize_t
3915
max_corrected_read_errors_show(struct mddev *mddev, char *page) {
3916 3917 3918 3919 3920
	return sprintf(page, "%d\n",
		       atomic_read(&mddev->max_corr_read_errors));
}

static ssize_t
3921
max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
3922
{
A
Alexey Dobriyan 已提交
3923 3924
	unsigned int n;
	int rv;
3925

A
Alexey Dobriyan 已提交
3926 3927 3928 3929 3930
	rv = kstrtouint(buf, 10, &n);
	if (rv < 0)
		return rv;
	atomic_set(&mddev->max_corr_read_errors, n);
	return len;
3931 3932 3933 3934 3935 3936
}

static struct md_sysfs_entry max_corr_read_errors =
__ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
	max_corrected_read_errors_store);

3937
static ssize_t
3938
null_show(struct mddev *mddev, char *page)
3939 3940 3941 3942 3943
{
	return -EINVAL;
}

static ssize_t
3944
new_dev_store(struct mddev *mddev, const char *buf, size_t len)
3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956
{
	/* buf must be %d:%d\n? giving major and minor numbers */
	/* The new device is added to the array.
	 * If the array has a persistent superblock, we read the
	 * superblock to initialise info and check validity.
	 * Otherwise, only checking done is that in bind_rdev_to_array,
	 * which mainly checks size.
	 */
	char *e;
	int major = simple_strtoul(buf, &e, 10);
	int minor;
	dev_t dev;
3957
	struct md_rdev *rdev;
3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969
	int err;

	if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
		return -EINVAL;
	minor = simple_strtoul(e+1, &e, 10);
	if (*e && *e != '\n')
		return -EINVAL;
	dev = MKDEV(major, minor);
	if (major != MAJOR(dev) ||
	    minor != MINOR(dev))
		return -EOVERFLOW;

3970 3971 3972 3973 3974
	flush_workqueue(md_misc_wq);

	err = mddev_lock(mddev);
	if (err)
		return err;
3975 3976 3977 3978
	if (mddev->persistent) {
		rdev = md_import_device(dev, mddev->major_version,
					mddev->minor_version);
		if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
3979 3980 3981
			struct md_rdev *rdev0
				= list_entry(mddev->disks.next,
					     struct md_rdev, same_set);
3982 3983 3984 3985 3986
			err = super_types[mddev->major_version]
				.load_super(rdev, rdev0, mddev->minor_version);
			if (err < 0)
				goto out;
		}
3987 3988 3989
	} else if (mddev->external)
		rdev = md_import_device(dev, -2, -1);
	else
3990 3991
		rdev = md_import_device(dev, -1, -1);

3992 3993
	if (IS_ERR(rdev)) {
		mddev_unlock(mddev);
3994
		return PTR_ERR(rdev);
3995
	}
3996 3997 3998 3999
	err = bind_rdev_to_array(rdev, mddev);
 out:
	if (err)
		export_rdev(rdev);
4000
	mddev_unlock(mddev);
4001 4002 4003 4004
	return err ? err : len;
}

static struct md_sysfs_entry md_new_device =
4005
__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
4006

4007
static ssize_t
4008
bitmap_store(struct mddev *mddev, const char *buf, size_t len)
4009 4010 4011
{
	char *end;
	unsigned long chunk, end_chunk;
4012
	int err;
4013

4014 4015 4016
	err = mddev_lock(mddev);
	if (err)
		return err;
4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029
	if (!mddev->bitmap)
		goto out;
	/* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
	while (*buf) {
		chunk = end_chunk = simple_strtoul(buf, &end, 0);
		if (buf == end) break;
		if (*end == '-') { /* range */
			buf = end + 1;
			end_chunk = simple_strtoul(buf, &end, 0);
			if (buf == end) break;
		}
		if (*end && !isspace(*end)) break;
		bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
4030
		buf = skip_spaces(end);
4031 4032 4033
	}
	bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
out:
4034
	mddev_unlock(mddev);
4035 4036 4037 4038 4039 4040
	return len;
}

static struct md_sysfs_entry md_bitmap =
__ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);

4041
static ssize_t
4042
size_show(struct mddev *mddev, char *page)
4043
{
A
Andre Noll 已提交
4044 4045
	return sprintf(page, "%llu\n",
		(unsigned long long)mddev->dev_sectors / 2);
4046 4047
}

4048
static int update_size(struct mddev *mddev, sector_t num_sectors);
4049 4050

static ssize_t
4051
size_store(struct mddev *mddev, const char *buf, size_t len)
4052 4053 4054 4055 4056
{
	/* If array is inactive, we can reduce the component size, but
	 * not increase it (except from 0).
	 * If array is active, we can try an on-line resize
	 */
D
Dan Williams 已提交
4057 4058
	sector_t sectors;
	int err = strict_blocks_to_sectors(buf, &sectors);
4059

A
Andre Noll 已提交
4060 4061
	if (err < 0)
		return err;
4062 4063 4064
	err = mddev_lock(mddev);
	if (err)
		return err;
4065
	if (mddev->pers) {
4066 4067
		if (mddev_is_clustered(mddev))
			md_cluster_ops->metadata_update_start(mddev);
A
Andre Noll 已提交
4068
		err = update_size(mddev, sectors);
4069
		md_update_sb(mddev, 1);
4070 4071
		if (mddev_is_clustered(mddev))
			md_cluster_ops->metadata_update_finish(mddev);
4072
	} else {
A
Andre Noll 已提交
4073 4074 4075
		if (mddev->dev_sectors == 0 ||
		    mddev->dev_sectors > sectors)
			mddev->dev_sectors = sectors;
4076 4077 4078
		else
			err = -ENOSPC;
	}
4079
	mddev_unlock(mddev);
4080 4081 4082 4083
	return err ? err : len;
}

static struct md_sysfs_entry md_size =
4084
__ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
4085

M
Masanari Iida 已提交
4086
/* Metadata version.
4087 4088 4089
 * This is one of
 *   'none' for arrays with no metadata (good luck...)
 *   'external' for arrays with externally managed metadata,
4090 4091 4092
 * or N.M for internally known formats
 */
static ssize_t
4093
metadata_show(struct mddev *mddev, char *page)
4094 4095 4096 4097
{
	if (mddev->persistent)
		return sprintf(page, "%d.%d\n",
			       mddev->major_version, mddev->minor_version);
4098 4099
	else if (mddev->external)
		return sprintf(page, "external:%s\n", mddev->metadata_type);
4100 4101 4102 4103 4104
	else
		return sprintf(page, "none\n");
}

static ssize_t
4105
metadata_store(struct mddev *mddev, const char *buf, size_t len)
4106 4107 4108
{
	int major, minor;
	char *e;
4109
	int err;
4110 4111 4112 4113
	/* Changing the details of 'external' metadata is
	 * always permitted.  Otherwise there must be
	 * no devices attached to the array.
	 */
4114 4115 4116 4117 4118

	err = mddev_lock(mddev);
	if (err)
		return err;
	err = -EBUSY;
4119 4120 4121
	if (mddev->external && strncmp(buf, "external:", 9) == 0)
		;
	else if (!list_empty(&mddev->disks))
4122
		goto out_unlock;
4123

4124
	err = 0;
4125 4126
	if (cmd_match(buf, "none")) {
		mddev->persistent = 0;
4127 4128 4129
		mddev->external = 0;
		mddev->major_version = 0;
		mddev->minor_version = 90;
4130
		goto out_unlock;
4131 4132
	}
	if (strncmp(buf, "external:", 9) == 0) {
4133
		size_t namelen = len-9;
4134 4135 4136 4137 4138 4139 4140 4141
		if (namelen >= sizeof(mddev->metadata_type))
			namelen = sizeof(mddev->metadata_type)-1;
		strncpy(mddev->metadata_type, buf+9, namelen);
		mddev->metadata_type[namelen] = 0;
		if (namelen && mddev->metadata_type[namelen-1] == '\n')
			mddev->metadata_type[--namelen] = 0;
		mddev->persistent = 0;
		mddev->external = 1;
4142 4143
		mddev->major_version = 0;
		mddev->minor_version = 90;
4144
		goto out_unlock;
4145 4146
	}
	major = simple_strtoul(buf, &e, 10);
4147
	err = -EINVAL;
4148
	if (e==buf || *e != '.')
4149
		goto out_unlock;
4150 4151
	buf = e+1;
	minor = simple_strtoul(buf, &e, 10);
4152
	if (e==buf || (*e && *e != '\n') )
4153 4154
		goto out_unlock;
	err = -ENOENT;
4155
	if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
4156
		goto out_unlock;
4157 4158 4159
	mddev->major_version = major;
	mddev->minor_version = minor;
	mddev->persistent = 1;
4160
	mddev->external = 0;
4161 4162 4163 4164
	err = 0;
out_unlock:
	mddev_unlock(mddev);
	return err ?: len;
4165 4166 4167
}

static struct md_sysfs_entry md_metadata =
4168
__ATTR_PREALLOC(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
4169

4170
static ssize_t
4171
action_show(struct mddev *mddev, char *page)
4172
{
4173
	char *type = "idle";
4174 4175
	unsigned long recovery = mddev->recovery;
	if (test_bit(MD_RECOVERY_FROZEN, &recovery))
4176
		type = "frozen";
4177 4178 4179
	else if (test_bit(MD_RECOVERY_RUNNING, &recovery) ||
	    (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &recovery))) {
		if (test_bit(MD_RECOVERY_RESHAPE, &recovery))
4180
			type = "reshape";
4181 4182
		else if (test_bit(MD_RECOVERY_SYNC, &recovery)) {
			if (!test_bit(MD_RECOVERY_REQUESTED, &recovery))
4183
				type = "resync";
4184
			else if (test_bit(MD_RECOVERY_CHECK, &recovery))
4185 4186 4187
				type = "check";
			else
				type = "repair";
4188
		} else if (test_bit(MD_RECOVERY_RECOVER, &recovery))
4189
			type = "recover";
4190 4191
		else if (mddev->reshape_position != MaxSector)
			type = "reshape";
4192 4193 4194 4195 4196
	}
	return sprintf(page, "%s\n", type);
}

static ssize_t
4197
action_store(struct mddev *mddev, const char *page, size_t len)
4198
{
4199 4200 4201
	if (!mddev->pers || !mddev->pers->sync_request)
		return -EINVAL;

4202 4203

	if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
4204 4205 4206 4207
		if (cmd_match(page, "frozen"))
			set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
		else
			clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4208 4209 4210 4211 4212
		if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
		    mddev_lock(mddev) == 0) {
			flush_workqueue(md_misc_wq);
			if (mddev->sync_thread) {
				set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4213 4214
				md_reap_sync_thread(mddev);
			}
4215
			mddev_unlock(mddev);
4216
		}
4217 4218
	} else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
		   test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
4219
		return -EBUSY;
4220
	else if (cmd_match(page, "resync"))
4221
		clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4222
	else if (cmd_match(page, "recover")) {
4223
		clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4224 4225
		set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
	} else if (cmd_match(page, "reshape")) {
4226 4227 4228
		int err;
		if (mddev->pers->start_reshape == NULL)
			return -EINVAL;
4229 4230
		err = mddev_lock(mddev);
		if (!err) {
4231
			clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4232 4233 4234
			err = mddev->pers->start_reshape(mddev);
			mddev_unlock(mddev);
		}
4235 4236
		if (err)
			return err;
4237
		sysfs_notify(&mddev->kobj, NULL, "degraded");
4238
	} else {
4239
		if (cmd_match(page, "check"))
4240
			set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
4241
		else if (!cmd_match(page, "repair"))
4242
			return -EINVAL;
4243
		clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4244 4245 4246
		set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
		set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
	}
4247 4248 4249 4250 4251 4252 4253
	if (mddev->ro == 2) {
		/* A write to sync_action is enough to justify
		 * canceling read-auto mode
		 */
		mddev->ro = 0;
		md_wakeup_thread(mddev->sync_thread);
	}
4254
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4255
	md_wakeup_thread(mddev->thread);
N
NeilBrown 已提交
4256
	sysfs_notify_dirent_safe(mddev->sysfs_action);
4257 4258 4259
	return len;
}

4260
static struct md_sysfs_entry md_scan_mode =
4261
__ATTR_PREALLOC(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
4262 4263 4264 4265 4266 4267 4268 4269 4270

static ssize_t
last_sync_action_show(struct mddev *mddev, char *page)
{
	return sprintf(page, "%s\n", mddev->last_sync_action);
}

static struct md_sysfs_entry md_last_scan_mode = __ATTR_RO(last_sync_action);

4271
static ssize_t
4272
mismatch_cnt_show(struct mddev *mddev, char *page)
4273 4274
{
	return sprintf(page, "%llu\n",
4275 4276
		       (unsigned long long)
		       atomic64_read(&mddev->resync_mismatches));
4277 4278
}

4279
static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
4280

4281
static ssize_t
4282
sync_min_show(struct mddev *mddev, char *page)
4283 4284 4285 4286 4287 4288
{
	return sprintf(page, "%d (%s)\n", speed_min(mddev),
		       mddev->sync_speed_min ? "local": "system");
}

static ssize_t
4289
sync_min_store(struct mddev *mddev, const char *buf, size_t len)
4290
{
A
Alexey Dobriyan 已提交
4291 4292 4293
	unsigned int min;
	int rv;

4294
	if (strncmp(buf, "system", 6)==0) {
A
Alexey Dobriyan 已提交
4295 4296 4297 4298 4299 4300 4301
		min = 0;
	} else {
		rv = kstrtouint(buf, 10, &min);
		if (rv < 0)
			return rv;
		if (min == 0)
			return -EINVAL;
4302 4303 4304 4305 4306 4307 4308 4309 4310
	}
	mddev->sync_speed_min = min;
	return len;
}

static struct md_sysfs_entry md_sync_min =
__ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);

static ssize_t
4311
sync_max_show(struct mddev *mddev, char *page)
4312 4313 4314 4315 4316 4317
{
	return sprintf(page, "%d (%s)\n", speed_max(mddev),
		       mddev->sync_speed_max ? "local": "system");
}

static ssize_t
4318
sync_max_store(struct mddev *mddev, const char *buf, size_t len)
4319
{
A
Alexey Dobriyan 已提交
4320 4321 4322
	unsigned int max;
	int rv;

4323
	if (strncmp(buf, "system", 6)==0) {
A
Alexey Dobriyan 已提交
4324 4325 4326 4327 4328 4329 4330
		max = 0;
	} else {
		rv = kstrtouint(buf, 10, &max);
		if (rv < 0)
			return rv;
		if (max == 0)
			return -EINVAL;
4331 4332 4333 4334 4335 4336 4337 4338
	}
	mddev->sync_speed_max = max;
	return len;
}

static struct md_sysfs_entry md_sync_max =
__ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);

4339
static ssize_t
4340
degraded_show(struct mddev *mddev, char *page)
4341 4342 4343 4344
{
	return sprintf(page, "%d\n", mddev->degraded);
}
static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
4345

4346
static ssize_t
4347
sync_force_parallel_show(struct mddev *mddev, char *page)
4348 4349 4350 4351 4352
{
	return sprintf(page, "%d\n", mddev->parallel_resync);
}

static ssize_t
4353
sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
4354 4355 4356
{
	long n;

4357
	if (kstrtol(buf, 10, &n))
4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375
		return -EINVAL;

	if (n != 0 && n != 1)
		return -EINVAL;

	mddev->parallel_resync = n;

	if (mddev->sync_thread)
		wake_up(&resync_wait);

	return len;
}

/* force parallel resync, even with shared block devices */
static struct md_sysfs_entry md_sync_force_parallel =
__ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
       sync_force_parallel_show, sync_force_parallel_store);

4376
static ssize_t
4377
sync_speed_show(struct mddev *mddev, char *page)
4378 4379
{
	unsigned long resync, dt, db;
4380 4381
	if (mddev->curr_resync == 0)
		return sprintf(page, "none\n");
4382 4383
	resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
	dt = (jiffies - mddev->resync_mark) / HZ;
4384
	if (!dt) dt++;
4385 4386
	db = resync - mddev->resync_mark_cnt;
	return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
4387 4388
}

4389
static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
4390 4391

static ssize_t
4392
sync_completed_show(struct mddev *mddev, char *page)
4393
{
4394
	unsigned long long max_sectors, resync;
4395

4396 4397 4398
	if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
		return sprintf(page, "none\n");

4399 4400 4401 4402
	if (mddev->curr_resync == 1 ||
	    mddev->curr_resync == 2)
		return sprintf(page, "delayed\n");

4403 4404
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
	    test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
A
Andre Noll 已提交
4405
		max_sectors = mddev->resync_max_sectors;
4406
	else
A
Andre Noll 已提交
4407
		max_sectors = mddev->dev_sectors;
4408

4409
	resync = mddev->curr_resync_completed;
4410
	return sprintf(page, "%llu / %llu\n", resync, max_sectors);
4411 4412
}

4413 4414
static struct md_sysfs_entry md_sync_completed =
	__ATTR_PREALLOC(sync_completed, S_IRUGO, sync_completed_show, NULL);
4415

4416
static ssize_t
4417
min_sync_show(struct mddev *mddev, char *page)
4418 4419 4420 4421 4422
{
	return sprintf(page, "%llu\n",
		       (unsigned long long)mddev->resync_min);
}
static ssize_t
4423
min_sync_store(struct mddev *mddev, const char *buf, size_t len)
4424 4425
{
	unsigned long long min;
4426 4427
	int err;

4428
	if (kstrtoull(buf, 10, &min))
4429
		return -EINVAL;
4430 4431 4432

	spin_lock(&mddev->lock);
	err = -EINVAL;
4433
	if (min > mddev->resync_max)
4434 4435 4436
		goto out_unlock;

	err = -EBUSY;
4437
	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4438
		goto out_unlock;
4439

4440 4441
	/* Round down to multiple of 4K for safety */
	mddev->resync_min = round_down(min, 8);
4442
	err = 0;
4443

4444 4445 4446
out_unlock:
	spin_unlock(&mddev->lock);
	return err ?: len;
4447 4448 4449 4450 4451
}

static struct md_sysfs_entry md_min_sync =
__ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);

4452
static ssize_t
4453
max_sync_show(struct mddev *mddev, char *page)
4454 4455 4456 4457 4458 4459 4460 4461
{
	if (mddev->resync_max == MaxSector)
		return sprintf(page, "max\n");
	else
		return sprintf(page, "%llu\n",
			       (unsigned long long)mddev->resync_max);
}
static ssize_t
4462
max_sync_store(struct mddev *mddev, const char *buf, size_t len)
4463
{
4464 4465
	int err;
	spin_lock(&mddev->lock);
4466 4467 4468
	if (strncmp(buf, "max", 3) == 0)
		mddev->resync_max = MaxSector;
	else {
4469
		unsigned long long max;
4470 4471 4472
		int chunk;

		err = -EINVAL;
4473
		if (kstrtoull(buf, 10, &max))
4474
			goto out_unlock;
4475
		if (max < mddev->resync_min)
4476 4477 4478
			goto out_unlock;

		err = -EBUSY;
4479
		if (max < mddev->resync_max &&
4480
		    mddev->ro == 0 &&
4481
		    test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4482
			goto out_unlock;
4483 4484

		/* Must be a multiple of chunk_size */
4485 4486
		chunk = mddev->chunk_sectors;
		if (chunk) {
4487
			sector_t temp = max;
4488 4489 4490 4491

			err = -EINVAL;
			if (sector_div(temp, chunk))
				goto out_unlock;
4492 4493 4494 4495
		}
		mddev->resync_max = max;
	}
	wake_up(&mddev->recovery_wait);
4496 4497 4498 4499
	err = 0;
out_unlock:
	spin_unlock(&mddev->lock);
	return err ?: len;
4500 4501 4502 4503 4504
}

static struct md_sysfs_entry md_max_sync =
__ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);

4505
static ssize_t
4506
suspend_lo_show(struct mddev *mddev, char *page)
4507 4508 4509 4510 4511
{
	return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
}

static ssize_t
4512
suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
4513
{
A
Alexey Dobriyan 已提交
4514
	unsigned long long old, new;
4515
	int err;
4516

A
Alexey Dobriyan 已提交
4517 4518 4519 4520
	err = kstrtoull(buf, 10, &new);
	if (err < 0)
		return err;
	if (new != (sector_t)new)
4521
		return -EINVAL;
4522

4523 4524 4525 4526 4527 4528 4529 4530
	err = mddev_lock(mddev);
	if (err)
		return err;
	err = -EINVAL;
	if (mddev->pers == NULL ||
	    mddev->pers->quiesce == NULL)
		goto unlock;
	old = mddev->suspend_lo;
4531 4532 4533
	mddev->suspend_lo = new;
	if (new >= old)
		/* Shrinking suspended region */
4534
		mddev->pers->quiesce(mddev, 2);
4535 4536 4537 4538 4539
	else {
		/* Expanding suspended region - need to wait */
		mddev->pers->quiesce(mddev, 1);
		mddev->pers->quiesce(mddev, 0);
	}
4540 4541 4542 4543
	err = 0;
unlock:
	mddev_unlock(mddev);
	return err ?: len;
4544 4545 4546 4547 4548
}
static struct md_sysfs_entry md_suspend_lo =
__ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);

static ssize_t
4549
suspend_hi_show(struct mddev *mddev, char *page)
4550 4551 4552 4553 4554
{
	return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
}

static ssize_t
4555
suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
4556
{
A
Alexey Dobriyan 已提交
4557
	unsigned long long old, new;
4558
	int err;
4559

A
Alexey Dobriyan 已提交
4560 4561 4562 4563
	err = kstrtoull(buf, 10, &new);
	if (err < 0)
		return err;
	if (new != (sector_t)new)
4564
		return -EINVAL;
4565

4566 4567 4568 4569 4570 4571 4572 4573
	err = mddev_lock(mddev);
	if (err)
		return err;
	err = -EINVAL;
	if (mddev->pers == NULL ||
	    mddev->pers->quiesce == NULL)
		goto unlock;
	old = mddev->suspend_hi;
4574 4575 4576 4577 4578 4579
	mddev->suspend_hi = new;
	if (new <= old)
		/* Shrinking suspended region */
		mddev->pers->quiesce(mddev, 2);
	else {
		/* Expanding suspended region - need to wait */
4580 4581
		mddev->pers->quiesce(mddev, 1);
		mddev->pers->quiesce(mddev, 0);
4582
	}
4583 4584 4585 4586
	err = 0;
unlock:
	mddev_unlock(mddev);
	return err ?: len;
4587 4588 4589 4590
}
static struct md_sysfs_entry md_suspend_hi =
__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);

4591
static ssize_t
4592
reshape_position_show(struct mddev *mddev, char *page)
4593 4594 4595 4596 4597 4598 4599 4600 4601
{
	if (mddev->reshape_position != MaxSector)
		return sprintf(page, "%llu\n",
			       (unsigned long long)mddev->reshape_position);
	strcpy(page, "none\n");
	return 5;
}

static ssize_t
4602
reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
4603
{
4604
	struct md_rdev *rdev;
A
Alexey Dobriyan 已提交
4605
	unsigned long long new;
4606 4607
	int err;

A
Alexey Dobriyan 已提交
4608 4609 4610 4611
	err = kstrtoull(buf, 10, &new);
	if (err < 0)
		return err;
	if (new != (sector_t)new)
4612
		return -EINVAL;
4613 4614 4615 4616 4617 4618
	err = mddev_lock(mddev);
	if (err)
		return err;
	err = -EBUSY;
	if (mddev->pers)
		goto unlock;
4619 4620
	mddev->reshape_position = new;
	mddev->delta_disks = 0;
4621
	mddev->reshape_backwards = 0;
4622 4623
	mddev->new_level = mddev->level;
	mddev->new_layout = mddev->layout;
4624
	mddev->new_chunk_sectors = mddev->chunk_sectors;
4625 4626
	rdev_for_each(rdev, mddev)
		rdev->new_data_offset = rdev->data_offset;
4627 4628 4629 4630
	err = 0;
unlock:
	mddev_unlock(mddev);
	return err ?: len;
4631 4632 4633 4634 4635 4636
}

static struct md_sysfs_entry md_reshape_position =
__ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
       reshape_position_store);

4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647
static ssize_t
reshape_direction_show(struct mddev *mddev, char *page)
{
	return sprintf(page, "%s\n",
		       mddev->reshape_backwards ? "backwards" : "forwards");
}

static ssize_t
reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
{
	int backwards = 0;
4648 4649
	int err;

4650 4651 4652 4653 4654 4655 4656 4657 4658
	if (cmd_match(buf, "forwards"))
		backwards = 0;
	else if (cmd_match(buf, "backwards"))
		backwards = 1;
	else
		return -EINVAL;
	if (mddev->reshape_backwards == backwards)
		return len;

4659 4660 4661
	err = mddev_lock(mddev);
	if (err)
		return err;
4662 4663
	/* check if we are allowed to change */
	if (mddev->delta_disks)
4664 4665
		err = -EBUSY;
	else if (mddev->persistent &&
4666
	    mddev->major_version == 0)
4667 4668 4669 4670 4671
		err =  -EINVAL;
	else
		mddev->reshape_backwards = backwards;
	mddev_unlock(mddev);
	return err ?: len;
4672 4673 4674 4675 4676 4677
}

static struct md_sysfs_entry md_reshape_direction =
__ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
       reshape_direction_store);

D
Dan Williams 已提交
4678
static ssize_t
4679
array_size_show(struct mddev *mddev, char *page)
D
Dan Williams 已提交
4680 4681 4682 4683 4684 4685 4686 4687 4688
{
	if (mddev->external_size)
		return sprintf(page, "%llu\n",
			       (unsigned long long)mddev->array_sectors/2);
	else
		return sprintf(page, "default\n");
}

static ssize_t
4689
array_size_store(struct mddev *mddev, const char *buf, size_t len)
D
Dan Williams 已提交
4690 4691
{
	sector_t sectors;
4692 4693 4694 4695 4696
	int err;

	err = mddev_lock(mddev);
	if (err)
		return err;
D
Dan Williams 已提交
4697 4698 4699 4700 4701 4702 4703 4704 4705 4706

	if (strncmp(buf, "default", 7) == 0) {
		if (mddev->pers)
			sectors = mddev->pers->size(mddev, 0, 0);
		else
			sectors = mddev->array_sectors;

		mddev->external_size = 0;
	} else {
		if (strict_blocks_to_sectors(buf, &sectors) < 0)
4707 4708 4709 4710 4711
			err = -EINVAL;
		else if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
			err = -E2BIG;
		else
			mddev->external_size = 1;
D
Dan Williams 已提交
4712 4713
	}

4714 4715 4716 4717 4718 4719
	if (!err) {
		mddev->array_sectors = sectors;
		if (mddev->pers) {
			set_capacity(mddev->gendisk, mddev->array_sectors);
			revalidate_disk(mddev->gendisk);
		}
4720
	}
4721 4722
	mddev_unlock(mddev);
	return err ?: len;
D
Dan Williams 已提交
4723 4724 4725 4726 4727
}

static struct md_sysfs_entry md_array_size =
__ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
       array_size_store);
4728

4729 4730
static struct attribute *md_default_attrs[] = {
	&md_level.attr,
4731
	&md_layout.attr,
4732
	&md_raid_disks.attr,
4733
	&md_chunk_size.attr,
4734
	&md_size.attr,
4735
	&md_resync_start.attr,
4736
	&md_metadata.attr,
4737
	&md_new_device.attr,
4738
	&md_safe_delay.attr,
4739
	&md_array_state.attr,
4740
	&md_reshape_position.attr,
4741
	&md_reshape_direction.attr,
D
Dan Williams 已提交
4742
	&md_array_size.attr,
4743
	&max_corr_read_errors.attr,
4744 4745 4746 4747
	NULL,
};

static struct attribute *md_redundancy_attrs[] = {
4748
	&md_scan_mode.attr,
4749
	&md_last_scan_mode.attr,
4750
	&md_mismatches.attr,
4751 4752 4753
	&md_sync_min.attr,
	&md_sync_max.attr,
	&md_sync_speed.attr,
4754
	&md_sync_force_parallel.attr,
4755
	&md_sync_completed.attr,
4756
	&md_min_sync.attr,
4757
	&md_max_sync.attr,
4758 4759
	&md_suspend_lo.attr,
	&md_suspend_hi.attr,
4760
	&md_bitmap.attr,
4761
	&md_degraded.attr,
4762 4763
	NULL,
};
4764 4765 4766 4767 4768
static struct attribute_group md_redundancy_group = {
	.name = NULL,
	.attrs = md_redundancy_attrs,
};

4769 4770 4771 4772
static ssize_t
md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
{
	struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
4773
	struct mddev *mddev = container_of(kobj, struct mddev, kobj);
4774
	ssize_t rv;
4775 4776 4777

	if (!entry->show)
		return -EIO;
4778 4779 4780 4781 4782 4783 4784 4785
	spin_lock(&all_mddevs_lock);
	if (list_empty(&mddev->all_mddevs)) {
		spin_unlock(&all_mddevs_lock);
		return -EBUSY;
	}
	mddev_get(mddev);
	spin_unlock(&all_mddevs_lock);

4786
	rv = entry->show(mddev, page);
4787
	mddev_put(mddev);
4788
	return rv;
4789 4790 4791 4792 4793 4794 4795
}

static ssize_t
md_attr_store(struct kobject *kobj, struct attribute *attr,
	      const char *page, size_t length)
{
	struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
4796
	struct mddev *mddev = container_of(kobj, struct mddev, kobj);
4797
	ssize_t rv;
4798 4799 4800

	if (!entry->store)
		return -EIO;
4801 4802
	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
4803 4804 4805 4806 4807 4808 4809
	spin_lock(&all_mddevs_lock);
	if (list_empty(&mddev->all_mddevs)) {
		spin_unlock(&all_mddevs_lock);
		return -EBUSY;
	}
	mddev_get(mddev);
	spin_unlock(&all_mddevs_lock);
4810
	rv = entry->store(mddev, page, length);
4811
	mddev_put(mddev);
4812
	return rv;
4813 4814 4815 4816
}

static void md_free(struct kobject *ko)
{
4817
	struct mddev *mddev = container_of(ko, struct mddev, kobj);
4818 4819 4820 4821

	if (mddev->sysfs_state)
		sysfs_put(mddev->sysfs_state);

4822 4823
	if (mddev->queue)
		blk_cleanup_queue(mddev->queue);
4824 4825 4826 4827 4828
	if (mddev->gendisk) {
		del_gendisk(mddev->gendisk);
		put_disk(mddev->gendisk);
	}

4829 4830 4831
	kfree(mddev);
}

4832
static const struct sysfs_ops md_sysfs_ops = {
4833 4834 4835 4836 4837 4838 4839 4840 4841
	.show	= md_attr_show,
	.store	= md_attr_store,
};
static struct kobj_type md_ktype = {
	.release	= md_free,
	.sysfs_ops	= &md_sysfs_ops,
	.default_attrs	= md_default_attrs,
};

L
Linus Torvalds 已提交
4842 4843
int mdp_major = 0;

4844 4845
static void mddev_delayed_delete(struct work_struct *ws)
{
4846
	struct mddev *mddev = container_of(ws, struct mddev, del_work);
4847

4848
	sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
4849 4850 4851 4852
	kobject_del(&mddev->kobj);
	kobject_put(&mddev->kobj);
}

4853
static int md_alloc(dev_t dev, char *name)
L
Linus Torvalds 已提交
4854
{
A
Arjan van de Ven 已提交
4855
	static DEFINE_MUTEX(disks_mutex);
4856
	struct mddev *mddev = mddev_find(dev);
L
Linus Torvalds 已提交
4857
	struct gendisk *disk;
4858 4859 4860
	int partitioned;
	int shift;
	int unit;
4861
	int error;
L
Linus Torvalds 已提交
4862 4863

	if (!mddev)
4864 4865 4866 4867 4868
		return -ENODEV;

	partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
	shift = partitioned ? MdpMinorShift : 0;
	unit = MINOR(mddev->unit) >> shift;
L
Linus Torvalds 已提交
4869

T
Tejun Heo 已提交
4870 4871
	/* wait for any previous instance of this device to be
	 * completely removed (mddev_delayed_delete).
4872
	 */
T
Tejun Heo 已提交
4873
	flush_workqueue(md_misc_wq);
4874

A
Arjan van de Ven 已提交
4875
	mutex_lock(&disks_mutex);
N
NeilBrown 已提交
4876 4877 4878
	error = -EEXIST;
	if (mddev->gendisk)
		goto abort;
4879 4880 4881 4882

	if (name) {
		/* Need to ensure that 'name' is not a duplicate.
		 */
4883
		struct mddev *mddev2;
4884 4885 4886 4887 4888 4889
		spin_lock(&all_mddevs_lock);

		list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
			if (mddev2->gendisk &&
			    strcmp(mddev2->gendisk->disk_name, name) == 0) {
				spin_unlock(&all_mddevs_lock);
N
NeilBrown 已提交
4890
				goto abort;
4891 4892
			}
		spin_unlock(&all_mddevs_lock);
L
Linus Torvalds 已提交
4893
	}
4894

N
NeilBrown 已提交
4895
	error = -ENOMEM;
4896
	mddev->queue = blk_alloc_queue(GFP_KERNEL);
N
NeilBrown 已提交
4897 4898
	if (!mddev->queue)
		goto abort;
4899 4900 4901
	mddev->queue->queuedata = mddev;

	blk_queue_make_request(mddev->queue, md_make_request);
4902
	blk_set_stacking_limits(&mddev->queue->limits);
4903

L
Linus Torvalds 已提交
4904 4905
	disk = alloc_disk(1 << shift);
	if (!disk) {
4906 4907
		blk_cleanup_queue(mddev->queue);
		mddev->queue = NULL;
N
NeilBrown 已提交
4908
		goto abort;
L
Linus Torvalds 已提交
4909
	}
4910
	disk->major = MAJOR(mddev->unit);
L
Linus Torvalds 已提交
4911
	disk->first_minor = unit << shift;
4912 4913 4914
	if (name)
		strcpy(disk->disk_name, name);
	else if (partitioned)
L
Linus Torvalds 已提交
4915
		sprintf(disk->disk_name, "md_d%d", unit);
4916
	else
L
Linus Torvalds 已提交
4917 4918 4919 4920
		sprintf(disk->disk_name, "md%d", unit);
	disk->fops = &md_fops;
	disk->private_data = mddev;
	disk->queue = mddev->queue;
4921
	blk_queue_flush(mddev->queue, REQ_FLUSH | REQ_FUA);
4922
	/* Allow extended partitions.  This makes the
4923
	 * 'mdp' device redundant, but we can't really
4924 4925 4926
	 * remove it now.
	 */
	disk->flags |= GENHD_FL_EXT_DEVT;
L
Linus Torvalds 已提交
4927
	mddev->gendisk = disk;
4928 4929 4930 4931 4932 4933
	/* As soon as we call add_disk(), another thread could get
	 * through to md_open, so make sure it doesn't get too far
	 */
	mutex_lock(&mddev->open_mutex);
	add_disk(disk);

4934 4935
	error = kobject_init_and_add(&mddev->kobj, &md_ktype,
				     &disk_to_dev(disk)->kobj, "%s", "md");
N
NeilBrown 已提交
4936 4937 4938 4939
	if (error) {
		/* This isn't possible, but as kobject_init_and_add is marked
		 * __must_check, we must do something with the result
		 */
4940 4941
		printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
		       disk->disk_name);
N
NeilBrown 已提交
4942 4943
		error = 0;
	}
N
NeilBrown 已提交
4944 4945
	if (mddev->kobj.sd &&
	    sysfs_create_group(&mddev->kobj, &md_bitmap_group))
4946
		printk(KERN_DEBUG "pointless warning\n");
4947
	mutex_unlock(&mddev->open_mutex);
N
NeilBrown 已提交
4948 4949
 abort:
	mutex_unlock(&disks_mutex);
N
NeilBrown 已提交
4950
	if (!error && mddev->kobj.sd) {
4951
		kobject_uevent(&mddev->kobj, KOBJ_ADD);
N
NeilBrown 已提交
4952
		mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
4953
	}
4954
	mddev_put(mddev);
N
NeilBrown 已提交
4955
	return error;
4956 4957 4958 4959 4960
}

static struct kobject *md_probe(dev_t dev, int *part, void *data)
{
	md_alloc(dev, NULL);
L
Linus Torvalds 已提交
4961 4962 4963
	return NULL;
}

4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982
static int add_named_array(const char *val, struct kernel_param *kp)
{
	/* val must be "md_*" where * is not all digits.
	 * We allocate an array with a large free minor number, and
	 * set the name to val.  val must not already be an active name.
	 */
	int len = strlen(val);
	char buf[DISK_NAME_LEN];

	while (len && val[len-1] == '\n')
		len--;
	if (len >= DISK_NAME_LEN)
		return -E2BIG;
	strlcpy(buf, val, len+1);
	if (strncmp(buf, "md_", 3) != 0)
		return -EINVAL;
	return md_alloc(0, buf);
}

L
Linus Torvalds 已提交
4983 4984
static void md_safemode_timeout(unsigned long data)
{
4985
	struct mddev *mddev = (struct mddev *) data;
L
Linus Torvalds 已提交
4986

4987 4988 4989
	if (!atomic_read(&mddev->writes_pending)) {
		mddev->safemode = 1;
		if (mddev->external)
N
NeilBrown 已提交
4990
			sysfs_notify_dirent_safe(mddev->sysfs_state);
4991
	}
L
Linus Torvalds 已提交
4992 4993 4994
	md_wakeup_thread(mddev->thread);
}

4995
static int start_dirty_degraded;
L
Linus Torvalds 已提交
4996

4997
int md_run(struct mddev *mddev)
L
Linus Torvalds 已提交
4998
{
4999
	int err;
5000
	struct md_rdev *rdev;
5001
	struct md_personality *pers;
L
Linus Torvalds 已提交
5002

5003 5004
	if (list_empty(&mddev->disks))
		/* cannot run an array with no devices.. */
L
Linus Torvalds 已提交
5005 5006 5007 5008
		return -EINVAL;

	if (mddev->pers)
		return -EBUSY;
5009 5010 5011
	/* Cannot run until previous stop completes properly */
	if (mddev->sysfs_active)
		return -EBUSY;
5012

L
Linus Torvalds 已提交
5013 5014 5015
	/*
	 * Analyze all RAID superblock(s)
	 */
5016 5017 5018
	if (!mddev->raid_disks) {
		if (!mddev->persistent)
			return -EINVAL;
5019
		analyze_sbs(mddev);
5020
	}
L
Linus Torvalds 已提交
5021

5022 5023 5024 5025
	if (mddev->level != LEVEL_NONE)
		request_module("md-level-%d", mddev->level);
	else if (mddev->clevel[0])
		request_module("md-%s", mddev->clevel);
L
Linus Torvalds 已提交
5026 5027 5028 5029 5030 5031

	/*
	 * Drop all container device buffers, from now on
	 * the only valid external interface is through the md
	 * device.
	 */
N
NeilBrown 已提交
5032
	rdev_for_each(rdev, mddev) {
5033
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
5034 5035
			continue;
		sync_blockdev(rdev->bdev);
5036
		invalidate_bdev(rdev->bdev);
5037 5038 5039

		/* perform some consistency tests on the device.
		 * We don't want the data to overlap the metadata,
A
Andre Noll 已提交
5040
		 * Internal Bitmap issues have been handled elsewhere.
5041
		 */
5042 5043 5044
		if (rdev->meta_bdev) {
			/* Nothing to check */;
		} else if (rdev->data_offset < rdev->sb_start) {
A
Andre Noll 已提交
5045 5046
			if (mddev->dev_sectors &&
			    rdev->data_offset + mddev->dev_sectors
5047
			    > rdev->sb_start) {
5048 5049 5050 5051 5052
				printk("md: %s: data overlaps metadata\n",
				       mdname(mddev));
				return -EINVAL;
			}
		} else {
5053
			if (rdev->sb_start + rdev->sb_size/512
5054 5055 5056 5057 5058 5059
			    > rdev->data_offset) {
				printk("md: %s: metadata overlaps data\n",
				       mdname(mddev));
				return -EINVAL;
			}
		}
N
NeilBrown 已提交
5060
		sysfs_notify_dirent_safe(rdev->sysfs_state);
L
Linus Torvalds 已提交
5061 5062
	}

5063
	if (mddev->bio_set == NULL)
5064
		mddev->bio_set = bioset_create(BIO_POOL_SIZE, 0);
5065

L
Linus Torvalds 已提交
5066
	spin_lock(&pers_lock);
5067
	pers = find_pers(mddev->level, mddev->clevel);
5068
	if (!pers || !try_module_get(pers->owner)) {
L
Linus Torvalds 已提交
5069
		spin_unlock(&pers_lock);
5070 5071 5072 5073 5074 5075
		if (mddev->level != LEVEL_NONE)
			printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
			       mddev->level);
		else
			printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
			       mddev->clevel);
L
Linus Torvalds 已提交
5076 5077 5078
		return -EINVAL;
	}
	spin_unlock(&pers_lock);
5079 5080 5081 5082
	if (mddev->level != pers->level) {
		mddev->level = pers->level;
		mddev->new_level = pers->level;
	}
5083
	strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
L
Linus Torvalds 已提交
5084

5085
	if (mddev->reshape_position != MaxSector &&
5086
	    pers->start_reshape == NULL) {
5087 5088 5089 5090 5091
		/* This personality cannot handle reshaping... */
		module_put(pers->owner);
		return -EINVAL;
	}

5092 5093 5094 5095 5096
	if (pers->sync_request) {
		/* Warn if this is a potentially silly
		 * configuration.
		 */
		char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
5097
		struct md_rdev *rdev2;
5098
		int warned = 0;
5099

N
NeilBrown 已提交
5100 5101
		rdev_for_each(rdev, mddev)
			rdev_for_each(rdev2, mddev) {
5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114
				if (rdev < rdev2 &&
				    rdev->bdev->bd_contains ==
				    rdev2->bdev->bd_contains) {
					printk(KERN_WARNING
					       "%s: WARNING: %s appears to be"
					       " on the same physical disk as"
					       " %s.\n",
					       mdname(mddev),
					       bdevname(rdev->bdev,b),
					       bdevname(rdev2->bdev,b2));
					warned = 1;
				}
			}
5115

5116 5117 5118 5119 5120 5121
		if (warned)
			printk(KERN_WARNING
			       "True protection against single-disk"
			       " failure might be compromised.\n");
	}

5122
	mddev->recovery = 0;
A
Andre Noll 已提交
5123 5124 5125
	/* may be over-ridden by personality */
	mddev->resync_max_sectors = mddev->dev_sectors;

5126
	mddev->ok_start_degraded = start_dirty_degraded;
L
Linus Torvalds 已提交
5127

5128
	if (start_readonly && mddev->ro == 0)
5129 5130
		mddev->ro = 2; /* read-only, but switch on first write */

5131
	err = pers->run(mddev);
5132 5133
	if (err)
		printk(KERN_ERR "md: pers->run() failed ...\n");
5134
	else if (pers->size(mddev, 0, 0) < mddev->array_sectors) {
D
Dan Williams 已提交
5135 5136 5137 5138 5139
		WARN_ONCE(!mddev->external_size, "%s: default size too small,"
			  " but 'external_size' not in effect?\n", __func__);
		printk(KERN_ERR
		       "md: invalid array_size %llu > default size %llu\n",
		       (unsigned long long)mddev->array_sectors / 2,
5140
		       (unsigned long long)pers->size(mddev, 0, 0) / 2);
D
Dan Williams 已提交
5141 5142
		err = -EINVAL;
	}
5143
	if (err == 0 && pers->sync_request &&
5144
	    (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
5145 5146 5147 5148 5149
		struct bitmap *bitmap;

		bitmap = bitmap_create(mddev, -1);
		if (IS_ERR(bitmap)) {
			err = PTR_ERR(bitmap);
5150 5151
			printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
			       mdname(mddev), err);
5152 5153 5154
		} else
			mddev->bitmap = bitmap;

5155
	}
L
Linus Torvalds 已提交
5156
	if (err) {
5157
		mddev_detach(mddev);
5158 5159
		if (mddev->private)
			pers->free(mddev, mddev->private);
5160
		mddev->private = NULL;
5161
		module_put(pers->owner);
5162 5163
		bitmap_destroy(mddev);
		return err;
L
Linus Torvalds 已提交
5164
	}
5165 5166 5167 5168
	if (mddev->queue) {
		mddev->queue->backing_dev_info.congested_data = mddev;
		mddev->queue->backing_dev_info.congested_fn = md_congested;
	}
5169
	if (pers->sync_request) {
N
NeilBrown 已提交
5170 5171
		if (mddev->kobj.sd &&
		    sysfs_create_group(&mddev->kobj, &md_redundancy_group))
5172 5173 5174
			printk(KERN_WARNING
			       "md: cannot register extra attributes for %s\n",
			       mdname(mddev));
N
NeilBrown 已提交
5175
		mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
5176
	} else if (mddev->ro == 2) /* auto-readonly not meaningful */
5177 5178
		mddev->ro = 0;

5179
	atomic_set(&mddev->writes_pending,0);
5180 5181
	atomic_set(&mddev->max_corr_read_errors,
		   MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
L
Linus Torvalds 已提交
5182
	mddev->safemode = 0;
5183
	mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
L
Linus Torvalds 已提交
5184
	mddev->in_sync = 1;
5185
	smp_wmb();
5186 5187
	spin_lock(&mddev->lock);
	mddev->pers = pers;
5188
	mddev->ready = 1;
5189
	spin_unlock(&mddev->lock);
N
NeilBrown 已提交
5190
	rdev_for_each(rdev, mddev)
5191 5192
		if (rdev->raid_disk >= 0)
			if (sysfs_link_rdev(mddev, rdev))
N
NeilBrown 已提交
5193
				/* failure here is OK */;
5194

5195 5196 5197 5198 5199
	if (mddev->degraded && !mddev->ro)
		/* This ensures that recovering status is reported immediately
		 * via sysfs - until a lack of spares is confirmed.
		 */
		set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
L
Linus Torvalds 已提交
5200
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5201

5202
	if (mddev->flags & MD_UPDATE_SB_FLAGS)
5203
		md_update_sb(mddev, 0);
L
Linus Torvalds 已提交
5204

5205
	md_new_event(mddev);
N
NeilBrown 已提交
5206 5207
	sysfs_notify_dirent_safe(mddev->sysfs_state);
	sysfs_notify_dirent_safe(mddev->sysfs_action);
5208
	sysfs_notify(&mddev->kobj, NULL, "degraded");
L
Linus Torvalds 已提交
5209 5210
	return 0;
}
5211
EXPORT_SYMBOL_GPL(md_run);
L
Linus Torvalds 已提交
5212

5213
static int do_md_run(struct mddev *mddev)
5214 5215 5216 5217 5218 5219
{
	int err;

	err = md_run(mddev);
	if (err)
		goto out;
5220 5221 5222 5223 5224
	err = bitmap_load(mddev);
	if (err) {
		bitmap_destroy(mddev);
		goto out;
	}
5225 5226 5227 5228

	md_wakeup_thread(mddev->thread);
	md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */

5229 5230
	set_capacity(mddev->gendisk, mddev->array_sectors);
	revalidate_disk(mddev->gendisk);
5231
	mddev->changed = 1;
5232 5233 5234 5235 5236
	kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
out:
	return err;
}

5237
static int restart_array(struct mddev *mddev)
L
Linus Torvalds 已提交
5238 5239 5240
{
	struct gendisk *disk = mddev->gendisk;

A
Andre Noll 已提交
5241
	/* Complain if it has no devices */
L
Linus Torvalds 已提交
5242
	if (list_empty(&mddev->disks))
A
Andre Noll 已提交
5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256
		return -ENXIO;
	if (!mddev->pers)
		return -EINVAL;
	if (!mddev->ro)
		return -EBUSY;
	mddev->safemode = 0;
	mddev->ro = 0;
	set_disk_ro(disk, 0);
	printk(KERN_INFO "md: %s switched to read-write mode.\n",
		mdname(mddev));
	/* Kick recovery or resync if necessary */
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	md_wakeup_thread(mddev->thread);
	md_wakeup_thread(mddev->sync_thread);
N
NeilBrown 已提交
5257
	sysfs_notify_dirent_safe(mddev->sysfs_state);
A
Andre Noll 已提交
5258
	return 0;
L
Linus Torvalds 已提交
5259 5260
}

5261
static void md_clean(struct mddev *mddev)
N
NeilBrown 已提交
5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282
{
	mddev->array_sectors = 0;
	mddev->external_size = 0;
	mddev->dev_sectors = 0;
	mddev->raid_disks = 0;
	mddev->recovery_cp = 0;
	mddev->resync_min = 0;
	mddev->resync_max = MaxSector;
	mddev->reshape_position = MaxSector;
	mddev->external = 0;
	mddev->persistent = 0;
	mddev->level = LEVEL_NONE;
	mddev->clevel[0] = 0;
	mddev->flags = 0;
	mddev->ro = 0;
	mddev->metadata_type[0] = 0;
	mddev->chunk_sectors = 0;
	mddev->ctime = mddev->utime = 0;
	mddev->layout = 0;
	mddev->max_disks = 0;
	mddev->events = 0;
5283
	mddev->can_decrease_events = 0;
N
NeilBrown 已提交
5284
	mddev->delta_disks = 0;
5285
	mddev->reshape_backwards = 0;
N
NeilBrown 已提交
5286 5287 5288 5289
	mddev->new_level = LEVEL_NONE;
	mddev->new_layout = 0;
	mddev->new_chunk_sectors = 0;
	mddev->curr_resync = 0;
5290
	atomic64_set(&mddev->resync_mismatches, 0);
N
NeilBrown 已提交
5291 5292 5293 5294
	mddev->suspend_lo = mddev->suspend_hi = 0;
	mddev->sync_speed_min = mddev->sync_speed_max = 0;
	mddev->recovery = 0;
	mddev->in_sync = 0;
5295
	mddev->changed = 0;
N
NeilBrown 已提交
5296 5297
	mddev->degraded = 0;
	mddev->safemode = 0;
5298
	mddev->private = NULL;
N
NeilBrown 已提交
5299 5300
	mddev->bitmap_info.offset = 0;
	mddev->bitmap_info.default_offset = 0;
5301
	mddev->bitmap_info.default_space = 0;
N
NeilBrown 已提交
5302 5303 5304 5305 5306
	mddev->bitmap_info.chunksize = 0;
	mddev->bitmap_info.daemon_sleep = 0;
	mddev->bitmap_info.max_write_behind = 0;
}

5307
static void __md_stop_writes(struct mddev *mddev)
5308
{
5309 5310
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_start(mddev);
5311
	set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5312
	flush_workqueue(md_misc_wq);
5313 5314
	if (mddev->sync_thread) {
		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5315
		md_reap_sync_thread(mddev);
5316 5317 5318 5319 5320 5321 5322
	}

	del_timer_sync(&mddev->safemode_timer);

	bitmap_flush(mddev);
	md_super_wait(mddev);

5323
	if (mddev->ro == 0 &&
5324
	    (!mddev->in_sync || (mddev->flags & MD_UPDATE_SB_FLAGS))) {
5325 5326 5327 5328
		/* mark array as shutdown cleanly */
		mddev->in_sync = 1;
		md_update_sb(mddev, 1);
	}
5329 5330
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_finish(mddev);
5331
}
5332

5333
void md_stop_writes(struct mddev *mddev)
5334
{
5335
	mddev_lock_nointr(mddev);
5336 5337 5338
	__md_stop_writes(mddev);
	mddev_unlock(mddev);
}
5339
EXPORT_SYMBOL_GPL(md_stop_writes);
5340

5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351
static void mddev_detach(struct mddev *mddev)
{
	struct bitmap *bitmap = mddev->bitmap;
	/* wait for behind writes to complete */
	if (bitmap && atomic_read(&bitmap->behind_writes) > 0) {
		printk(KERN_INFO "md:%s: behind writes in progress - waiting to stop.\n",
		       mdname(mddev));
		/* need to kick something here to make sure I/O goes? */
		wait_event(bitmap->behind_wait,
			   atomic_read(&bitmap->behind_writes) == 0);
	}
5352
	if (mddev->pers && mddev->pers->quiesce) {
5353 5354 5355 5356 5357 5358 5359 5360
		mddev->pers->quiesce(mddev, 1);
		mddev->pers->quiesce(mddev, 0);
	}
	md_unregister_thread(&mddev->thread);
	if (mddev->queue)
		blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
}

5361
static void __md_stop(struct mddev *mddev)
N
NeilBrown 已提交
5362
{
5363
	struct md_personality *pers = mddev->pers;
5364
	mddev_detach(mddev);
5365 5366
	/* Ensure ->event_work is done */
	flush_workqueue(md_misc_wq);
5367 5368
	spin_lock(&mddev->lock);
	mddev->ready = 0;
N
NeilBrown 已提交
5369
	mddev->pers = NULL;
5370 5371
	spin_unlock(&mddev->lock);
	pers->free(mddev, mddev->private);
5372
	mddev->private = NULL;
5373 5374 5375
	if (pers->sync_request && mddev->to_remove == NULL)
		mddev->to_remove = &md_redundancy_group;
	module_put(pers->owner);
N
NeilBrown 已提交
5376
	clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
N
NeilBrown 已提交
5377
}
5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389

void md_stop(struct mddev *mddev)
{
	/* stop the array and free an attached data structures.
	 * This is called from dm-raid
	 */
	__md_stop(mddev);
	bitmap_destroy(mddev);
	if (mddev->bio_set)
		bioset_free(mddev->bio_set);
}

5390
EXPORT_SYMBOL_GPL(md_stop);
N
NeilBrown 已提交
5391

5392
static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
5393 5394
{
	int err = 0;
5395 5396 5397 5398 5399 5400 5401
	int did_freeze = 0;

	if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
		did_freeze = 1;
		set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
		md_wakeup_thread(mddev->thread);
	}
5402
	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5403
		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5404
	if (mddev->sync_thread)
5405 5406 5407
		/* Thread might be blocked waiting for metadata update
		 * which will now never happen */
		wake_up_process(mddev->sync_thread->tsk);
5408

5409 5410
	if (mddev->external && test_bit(MD_CHANGE_PENDING, &mddev->flags))
		return -EBUSY;
5411
	mddev_unlock(mddev);
5412 5413
	wait_event(resync_wait, !test_bit(MD_RECOVERY_RUNNING,
					  &mddev->recovery));
5414 5415
	wait_event(mddev->sb_wait,
		   !test_bit(MD_CHANGE_PENDING, &mddev->flags));
5416 5417
	mddev_lock_nointr(mddev);

5418
	mutex_lock(&mddev->open_mutex);
5419
	if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
5420
	    mddev->sync_thread ||
5421
	    test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
5422
	    (bdev && !test_bit(MD_STILL_CLOSED, &mddev->flags))) {
5423
		printk("md: %s still in use.\n",mdname(mddev));
5424 5425
		if (did_freeze) {
			clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5426
			set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5427 5428
			md_wakeup_thread(mddev->thread);
		}
5429 5430 5431 5432
		err = -EBUSY;
		goto out;
	}
	if (mddev->pers) {
5433
		__md_stop_writes(mddev);
5434 5435 5436 5437 5438 5439 5440

		err  = -ENXIO;
		if (mddev->ro==1)
			goto out;
		mddev->ro = 1;
		set_disk_ro(mddev->gendisk, 1);
		clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5441 5442
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
		md_wakeup_thread(mddev->thread);
N
NeilBrown 已提交
5443
		sysfs_notify_dirent_safe(mddev->sysfs_state);
5444
		err = 0;
5445 5446 5447 5448 5449 5450
	}
out:
	mutex_unlock(&mddev->open_mutex);
	return err;
}

5451 5452 5453 5454
/* mode:
 *   0 - completely stop and dis-assemble array
 *   2 - stop but do not disassemble array
 */
5455
static int do_md_stop(struct mddev *mddev, int mode,
5456
		      struct block_device *bdev)
L
Linus Torvalds 已提交
5457 5458
{
	struct gendisk *disk = mddev->gendisk;
5459
	struct md_rdev *rdev;
5460 5461 5462 5463 5464 5465 5466
	int did_freeze = 0;

	if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
		did_freeze = 1;
		set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
		md_wakeup_thread(mddev->thread);
	}
5467
	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5468
		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5469
	if (mddev->sync_thread)
5470 5471 5472
		/* Thread might be blocked waiting for metadata update
		 * which will now never happen */
		wake_up_process(mddev->sync_thread->tsk);
5473

5474
	mddev_unlock(mddev);
5475 5476 5477
	wait_event(resync_wait, (mddev->sync_thread == NULL &&
				 !test_bit(MD_RECOVERY_RUNNING,
					   &mddev->recovery)));
5478
	mddev_lock_nointr(mddev);
L
Linus Torvalds 已提交
5479

N
NeilBrown 已提交
5480
	mutex_lock(&mddev->open_mutex);
5481
	if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
5482 5483
	    mddev->sysfs_active ||
	    mddev->sync_thread ||
5484
	    test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
5485
	    (bdev && !test_bit(MD_STILL_CLOSED, &mddev->flags))) {
5486
		printk("md: %s still in use.\n",mdname(mddev));
N
NeilBrown 已提交
5487
		mutex_unlock(&mddev->open_mutex);
5488 5489
		if (did_freeze) {
			clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5490
			set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5491 5492
			md_wakeup_thread(mddev->thread);
		}
5493 5494
		return -EBUSY;
	}
N
NeilBrown 已提交
5495
	if (mddev->pers) {
5496 5497
		if (mddev->ro)
			set_disk_ro(disk, 0);
5498

5499
		__md_stop_writes(mddev);
5500
		__md_stop(mddev);
5501
		mddev->queue->backing_dev_info.congested_fn = NULL;
N
NeilBrown 已提交
5502

5503
		/* tell userspace to handle 'inactive' */
N
NeilBrown 已提交
5504
		sysfs_notify_dirent_safe(mddev->sysfs_state);
5505

N
NeilBrown 已提交
5506
		rdev_for_each(rdev, mddev)
5507 5508
			if (rdev->raid_disk >= 0)
				sysfs_unlink_rdev(mddev, rdev);
5509

5510
		set_capacity(disk, 0);
N
NeilBrown 已提交
5511
		mutex_unlock(&mddev->open_mutex);
5512
		mddev->changed = 1;
5513
		revalidate_disk(disk);
5514

5515 5516
		if (mddev->ro)
			mddev->ro = 0;
N
NeilBrown 已提交
5517 5518
	} else
		mutex_unlock(&mddev->open_mutex);
L
Linus Torvalds 已提交
5519 5520 5521
	/*
	 * Free resources if final stop
	 */
5522
	if (mode == 0) {
L
Linus Torvalds 已提交
5523 5524
		printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));

5525
		bitmap_destroy(mddev);
5526
		if (mddev->bitmap_info.file) {
5527 5528
			struct file *f = mddev->bitmap_info.file;
			spin_lock(&mddev->lock);
5529
			mddev->bitmap_info.file = NULL;
5530 5531
			spin_unlock(&mddev->lock);
			fput(f);
5532
		}
5533
		mddev->bitmap_info.offset = 0;
5534

L
Linus Torvalds 已提交
5535 5536
		export_array(mddev);

N
NeilBrown 已提交
5537
		md_clean(mddev);
5538
		kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
5539 5540
		if (mddev->hold_active == UNTIL_STOP)
			mddev->hold_active = 0;
5541
	}
5542
	md_new_event(mddev);
N
NeilBrown 已提交
5543
	sysfs_notify_dirent_safe(mddev->sysfs_state);
N
NeilBrown 已提交
5544
	return 0;
L
Linus Torvalds 已提交
5545 5546
}

J
Jeff Garzik 已提交
5547
#ifndef MODULE
5548
static void autorun_array(struct mddev *mddev)
L
Linus Torvalds 已提交
5549
{
5550
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
5551 5552
	int err;

5553
	if (list_empty(&mddev->disks))
L
Linus Torvalds 已提交
5554 5555 5556 5557
		return;

	printk(KERN_INFO "md: running: ");

N
NeilBrown 已提交
5558
	rdev_for_each(rdev, mddev) {
L
Linus Torvalds 已提交
5559 5560 5561 5562 5563
		char b[BDEVNAME_SIZE];
		printk("<%s>", bdevname(rdev->bdev,b));
	}
	printk("\n");

5564
	err = do_md_run(mddev);
L
Linus Torvalds 已提交
5565 5566
	if (err) {
		printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
5567
		do_md_stop(mddev, 0, NULL);
L
Linus Torvalds 已提交
5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584
	}
}

/*
 * lets try to run arrays based on all disks that have arrived
 * until now. (those are in pending_raid_disks)
 *
 * the method: pick the first pending disk, collect all disks with
 * the same UUID, remove all from the pending list and put them into
 * the 'same_array' list. Then order this list based on superblock
 * update time (freshest comes first), kick out 'old' disks and
 * compare superblocks. If everything's fine then run it.
 *
 * If "unit" is allocated, then bump its reference count
 */
static void autorun_devices(int part)
{
5585
	struct md_rdev *rdev0, *rdev, *tmp;
5586
	struct mddev *mddev;
L
Linus Torvalds 已提交
5587 5588 5589 5590
	char b[BDEVNAME_SIZE];

	printk(KERN_INFO "md: autorun ...\n");
	while (!list_empty(&pending_raid_disks)) {
5591
		int unit;
L
Linus Torvalds 已提交
5592
		dev_t dev;
5593
		LIST_HEAD(candidates);
L
Linus Torvalds 已提交
5594
		rdev0 = list_entry(pending_raid_disks.next,
5595
					 struct md_rdev, same_set);
L
Linus Torvalds 已提交
5596 5597 5598 5599

		printk(KERN_INFO "md: considering %s ...\n",
			bdevname(rdev0->bdev,b));
		INIT_LIST_HEAD(&candidates);
5600
		rdev_for_each_list(rdev, tmp, &pending_raid_disks)
L
Linus Torvalds 已提交
5601 5602 5603 5604 5605 5606 5607 5608 5609 5610
			if (super_90_load(rdev, rdev0, 0) >= 0) {
				printk(KERN_INFO "md:  adding %s ...\n",
					bdevname(rdev->bdev,b));
				list_move(&rdev->same_set, &candidates);
			}
		/*
		 * now we have a set of devices, with all of them having
		 * mostly sane superblocks. It's time to allocate the
		 * mddev.
		 */
5611 5612 5613 5614 5615 5616 5617 5618 5619
		if (part) {
			dev = MKDEV(mdp_major,
				    rdev0->preferred_minor << MdpMinorShift);
			unit = MINOR(dev) >> MdpMinorShift;
		} else {
			dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
			unit = MINOR(dev);
		}
		if (rdev0->preferred_minor != unit) {
L
Linus Torvalds 已提交
5620 5621 5622 5623 5624 5625 5626
			printk(KERN_INFO "md: unit number in %s is bad: %d\n",
			       bdevname(rdev0->bdev, b), rdev0->preferred_minor);
			break;
		}

		md_probe(dev, NULL, NULL);
		mddev = mddev_find(dev);
N
Neil Brown 已提交
5627 5628 5629 5630
		if (!mddev || !mddev->gendisk) {
			if (mddev)
				mddev_put(mddev);
			printk(KERN_ERR
L
Linus Torvalds 已提交
5631 5632 5633
				"md: cannot allocate memory for md drive.\n");
			break;
		}
5634
		if (mddev_lock(mddev))
L
Linus Torvalds 已提交
5635 5636 5637 5638
			printk(KERN_WARNING "md: %s locked, cannot run\n",
			       mdname(mddev));
		else if (mddev->raid_disks || mddev->major_version
			 || !list_empty(&mddev->disks)) {
5639
			printk(KERN_WARNING
L
Linus Torvalds 已提交
5640 5641 5642 5643 5644
				"md: %s already running, cannot run %s\n",
				mdname(mddev), bdevname(rdev0->bdev,b));
			mddev_unlock(mddev);
		} else {
			printk(KERN_INFO "md: created %s\n", mdname(mddev));
5645
			mddev->persistent = 1;
5646
			rdev_for_each_list(rdev, tmp, &candidates) {
L
Linus Torvalds 已提交
5647 5648 5649 5650 5651 5652 5653 5654 5655 5656
				list_del_init(&rdev->same_set);
				if (bind_rdev_to_array(rdev, mddev))
					export_rdev(rdev);
			}
			autorun_array(mddev);
			mddev_unlock(mddev);
		}
		/* on success, candidates will be empty, on error
		 * it won't...
		 */
5657
		rdev_for_each_list(rdev, tmp, &candidates) {
5658
			list_del_init(&rdev->same_set);
L
Linus Torvalds 已提交
5659
			export_rdev(rdev);
5660
		}
L
Linus Torvalds 已提交
5661 5662 5663 5664
		mddev_put(mddev);
	}
	printk(KERN_INFO "md: ... autorun DONE.\n");
}
J
Jeff Garzik 已提交
5665
#endif /* !MODULE */
L
Linus Torvalds 已提交
5666

5667
static int get_version(void __user *arg)
L
Linus Torvalds 已提交
5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680
{
	mdu_version_t ver;

	ver.major = MD_MAJOR_VERSION;
	ver.minor = MD_MINOR_VERSION;
	ver.patchlevel = MD_PATCHLEVEL_VERSION;

	if (copy_to_user(arg, &ver, sizeof(ver)))
		return -EFAULT;

	return 0;
}

5681
static int get_array_info(struct mddev *mddev, void __user *arg)
L
Linus Torvalds 已提交
5682 5683
{
	mdu_array_info_t info;
5684
	int nr,working,insync,failed,spare;
5685
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
5686

5687 5688 5689
	nr = working = insync = failed = spare = 0;
	rcu_read_lock();
	rdev_for_each_rcu(rdev, mddev) {
L
Linus Torvalds 已提交
5690
		nr++;
5691
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
5692 5693 5694
			failed++;
		else {
			working++;
5695
			if (test_bit(In_sync, &rdev->flags))
5696
				insync++;
L
Linus Torvalds 已提交
5697 5698 5699 5700
			else
				spare++;
		}
	}
5701
	rcu_read_unlock();
L
Linus Torvalds 已提交
5702 5703 5704 5705 5706 5707

	info.major_version = mddev->major_version;
	info.minor_version = mddev->minor_version;
	info.patch_version = MD_PATCHLEVEL_VERSION;
	info.ctime         = mddev->ctime;
	info.level         = mddev->level;
A
Andre Noll 已提交
5708 5709
	info.size          = mddev->dev_sectors / 2;
	if (info.size != mddev->dev_sectors / 2) /* overflow */
5710
		info.size = -1;
L
Linus Torvalds 已提交
5711 5712 5713 5714 5715 5716 5717 5718 5719
	info.nr_disks      = nr;
	info.raid_disks    = mddev->raid_disks;
	info.md_minor      = mddev->md_minor;
	info.not_persistent= !mddev->persistent;

	info.utime         = mddev->utime;
	info.state         = 0;
	if (mddev->in_sync)
		info.state = (1<<MD_SB_CLEAN);
5720
	if (mddev->bitmap && mddev->bitmap_info.offset)
5721
		info.state |= (1<<MD_SB_BITMAP_PRESENT);
5722 5723
	if (mddev_is_clustered(mddev))
		info.state |= (1<<MD_SB_CLUSTERED);
5724
	info.active_disks  = insync;
L
Linus Torvalds 已提交
5725 5726 5727 5728 5729
	info.working_disks = working;
	info.failed_disks  = failed;
	info.spare_disks   = spare;

	info.layout        = mddev->layout;
5730
	info.chunk_size    = mddev->chunk_sectors << 9;
L
Linus Torvalds 已提交
5731 5732 5733 5734 5735 5736 5737

	if (copy_to_user(arg, &info, sizeof(info)))
		return -EFAULT;

	return 0;
}

5738
static int get_bitmap_file(struct mddev *mddev, void __user * arg)
5739 5740
{
	mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
5741
	char *ptr;
5742
	int err;
5743

5744
	file = kzalloc(sizeof(*file), GFP_NOIO);
5745
	if (!file)
5746
		return -ENOMEM;
5747

5748 5749
	err = 0;
	spin_lock(&mddev->lock);
5750 5751 5752 5753 5754 5755 5756 5757 5758 5759
	/* bitmap enabled */
	if (mddev->bitmap_info.file) {
		ptr = file_path(mddev->bitmap_info.file, file->pathname,
				sizeof(file->pathname));
		if (IS_ERR(ptr))
			err = PTR_ERR(ptr);
		else
			memmove(file->pathname, ptr,
				sizeof(file->pathname)-(ptr-file->pathname));
	}
5760
	spin_unlock(&mddev->lock);
5761

5762 5763
	if (err == 0 &&
	    copy_to_user(arg, file, sizeof(*file)))
5764
		err = -EFAULT;
5765

5766 5767 5768 5769
	kfree(file);
	return err;
}

5770
static int get_disk_info(struct mddev *mddev, void __user * arg)
L
Linus Torvalds 已提交
5771 5772
{
	mdu_disk_info_t info;
5773
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
5774 5775 5776 5777

	if (copy_from_user(&info, arg, sizeof(info)))
		return -EFAULT;

5778
	rcu_read_lock();
5779
	rdev = md_find_rdev_nr_rcu(mddev, info.number);
L
Linus Torvalds 已提交
5780 5781 5782 5783 5784
	if (rdev) {
		info.major = MAJOR(rdev->bdev->bd_dev);
		info.minor = MINOR(rdev->bdev->bd_dev);
		info.raid_disk = rdev->raid_disk;
		info.state = 0;
5785
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
5786
			info.state |= (1<<MD_DISK_FAULTY);
5787
		else if (test_bit(In_sync, &rdev->flags)) {
L
Linus Torvalds 已提交
5788 5789 5790
			info.state |= (1<<MD_DISK_ACTIVE);
			info.state |= (1<<MD_DISK_SYNC);
		}
5791 5792
		if (test_bit(WriteMostly, &rdev->flags))
			info.state |= (1<<MD_DISK_WRITEMOSTLY);
L
Linus Torvalds 已提交
5793 5794 5795 5796 5797
	} else {
		info.major = info.minor = 0;
		info.raid_disk = -1;
		info.state = (1<<MD_DISK_REMOVED);
	}
5798
	rcu_read_unlock();
L
Linus Torvalds 已提交
5799 5800 5801 5802 5803 5804 5805

	if (copy_to_user(arg, &info, sizeof(info)))
		return -EFAULT;

	return 0;
}

5806
static int add_new_disk(struct mddev *mddev, mdu_disk_info_t *info)
L
Linus Torvalds 已提交
5807 5808
{
	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
5809
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
5810 5811
	dev_t dev = MKDEV(info->major,info->minor);

5812 5813
	if (mddev_is_clustered(mddev) &&
		!(info->state & ((1 << MD_DISK_CLUSTER_ADD) | (1 << MD_DISK_CANDIDATE)))) {
5814
		pr_err("%s: Cannot add to clustered mddev.\n",
5815 5816 5817 5818
			       mdname(mddev));
		return -EINVAL;
	}

L
Linus Torvalds 已提交
5819 5820 5821 5822 5823 5824 5825 5826
	if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
		return -EOVERFLOW;

	if (!mddev->raid_disks) {
		int err;
		/* expecting a device which has a superblock */
		rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
		if (IS_ERR(rdev)) {
5827
			printk(KERN_WARNING
L
Linus Torvalds 已提交
5828 5829 5830 5831 5832
				"md: md_import_device returned %ld\n",
				PTR_ERR(rdev));
			return PTR_ERR(rdev);
		}
		if (!list_empty(&mddev->disks)) {
5833 5834 5835
			struct md_rdev *rdev0
				= list_entry(mddev->disks.next,
					     struct md_rdev, same_set);
5836
			err = super_types[mddev->major_version]
L
Linus Torvalds 已提交
5837 5838
				.load_super(rdev, rdev0, mddev->minor_version);
			if (err < 0) {
5839
				printk(KERN_WARNING
L
Linus Torvalds 已提交
5840
					"md: %s has different UUID to %s\n",
5841
					bdevname(rdev->bdev,b),
L
Linus Torvalds 已提交
5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860
					bdevname(rdev0->bdev,b2));
				export_rdev(rdev);
				return -EINVAL;
			}
		}
		err = bind_rdev_to_array(rdev, mddev);
		if (err)
			export_rdev(rdev);
		return err;
	}

	/*
	 * add_new_disk can be used once the array is assembled
	 * to add "hot spares".  They must already have a superblock
	 * written
	 */
	if (mddev->pers) {
		int err;
		if (!mddev->pers->hot_add_disk) {
5861
			printk(KERN_WARNING
L
Linus Torvalds 已提交
5862 5863 5864 5865
				"%s: personality does not support diskops!\n",
			       mdname(mddev));
			return -EINVAL;
		}
5866 5867 5868 5869 5870
		if (mddev->persistent)
			rdev = md_import_device(dev, mddev->major_version,
						mddev->minor_version);
		else
			rdev = md_import_device(dev, -1, -1);
L
Linus Torvalds 已提交
5871
		if (IS_ERR(rdev)) {
5872
			printk(KERN_WARNING
L
Linus Torvalds 已提交
5873 5874 5875 5876
				"md: md_import_device returned %ld\n",
				PTR_ERR(rdev));
			return PTR_ERR(rdev);
		}
5877
		/* set saved_raid_disk if appropriate */
5878 5879
		if (!mddev->persistent) {
			if (info->state & (1<<MD_DISK_SYNC)  &&
5880
			    info->raid_disk < mddev->raid_disks) {
5881
				rdev->raid_disk = info->raid_disk;
5882
				set_bit(In_sync, &rdev->flags);
5883
				clear_bit(Bitmap_sync, &rdev->flags);
5884
			} else
5885
				rdev->raid_disk = -1;
5886
			rdev->saved_raid_disk = rdev->raid_disk;
5887 5888 5889
		} else
			super_types[mddev->major_version].
				validate_super(mddev, rdev);
5890
		if ((info->state & (1<<MD_DISK_SYNC)) &&
5891
		     rdev->raid_disk != info->raid_disk) {
5892 5893 5894 5895 5896 5897 5898
			/* This was a hot-add request, but events doesn't
			 * match, so reject it.
			 */
			export_rdev(rdev);
			return -EINVAL;
		}

5899
		clear_bit(In_sync, &rdev->flags); /* just to be sure */
5900 5901
		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);
5902 5903
		else
			clear_bit(WriteMostly, &rdev->flags);
5904

5905 5906 5907 5908 5909 5910 5911
		/*
		 * check whether the device shows up in other nodes
		 */
		if (mddev_is_clustered(mddev)) {
			if (info->state & (1 << MD_DISK_CANDIDATE)) {
				/* Through --cluster-confirm */
				set_bit(Candidate, &rdev->flags);
5912 5913 5914 5915 5916
				err = md_cluster_ops->new_disk_ack(mddev, true);
				if (err) {
					export_rdev(rdev);
					return err;
				}
5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927
			} else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) {
				/* --add initiated by this node */
				err = md_cluster_ops->add_new_disk_start(mddev, rdev);
				if (err) {
					md_cluster_ops->add_new_disk_finish(mddev);
					export_rdev(rdev);
					return err;
				}
			}
		}

L
Linus Torvalds 已提交
5928 5929 5930 5931
		rdev->raid_disk = -1;
		err = bind_rdev_to_array(rdev, mddev);
		if (err)
			export_rdev(rdev);
5932
		else
G
Goldwyn Rodrigues 已提交
5933
			err = add_bound_rdev(rdev);
5934 5935 5936
		if (mddev_is_clustered(mddev) &&
				(info->state & (1 << MD_DISK_CLUSTER_ADD)))
			md_cluster_ops->add_new_disk_finish(mddev);
L
Linus Torvalds 已提交
5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950
		return err;
	}

	/* otherwise, add_new_disk is only allowed
	 * for major_version==0 superblocks
	 */
	if (mddev->major_version != 0) {
		printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
		       mdname(mddev));
		return -EINVAL;
	}

	if (!(info->state & (1<<MD_DISK_FAULTY))) {
		int err;
5951
		rdev = md_import_device(dev, -1, 0);
L
Linus Torvalds 已提交
5952
		if (IS_ERR(rdev)) {
5953
			printk(KERN_WARNING
L
Linus Torvalds 已提交
5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964
				"md: error, md_import_device() returned %ld\n",
				PTR_ERR(rdev));
			return PTR_ERR(rdev);
		}
		rdev->desc_nr = info->number;
		if (info->raid_disk < mddev->raid_disks)
			rdev->raid_disk = info->raid_disk;
		else
			rdev->raid_disk = -1;

		if (rdev->raid_disk < mddev->raid_disks)
5965 5966
			if (info->state & (1<<MD_DISK_SYNC))
				set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
5967

5968 5969 5970
		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);

L
Linus Torvalds 已提交
5971 5972
		if (!mddev->persistent) {
			printk(KERN_INFO "md: nonpersistent superblock ...\n");
5973 5974
			rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
		} else
5975
			rdev->sb_start = calc_dev_sboffset(rdev);
5976
		rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
5977

5978 5979 5980 5981 5982
		err = bind_rdev_to_array(rdev, mddev);
		if (err) {
			export_rdev(rdev);
			return err;
		}
L
Linus Torvalds 已提交
5983 5984 5985 5986 5987
	}

	return 0;
}

5988
static int hot_remove_disk(struct mddev *mddev, dev_t dev)
L
Linus Torvalds 已提交
5989 5990
{
	char b[BDEVNAME_SIZE];
5991
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
5992 5993 5994 5995 5996

	rdev = find_rdev(mddev, dev);
	if (!rdev)
		return -ENXIO;

5997 5998 5999
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_start(mddev);

6000 6001 6002
	clear_bit(Blocked, &rdev->flags);
	remove_and_add_spares(mddev, rdev);

L
Linus Torvalds 已提交
6003 6004 6005
	if (rdev->raid_disk >= 0)
		goto busy;

6006 6007 6008
	if (mddev_is_clustered(mddev))
		md_cluster_ops->remove_disk(mddev, rdev);

6009
	md_kick_rdev_from_array(rdev);
6010
	md_update_sb(mddev, 1);
6011
	md_new_event(mddev);
L
Linus Torvalds 已提交
6012

6013 6014 6015
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_finish(mddev);

L
Linus Torvalds 已提交
6016 6017
	return 0;
busy:
6018 6019
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_cancel(mddev);
6020
	printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
L
Linus Torvalds 已提交
6021 6022 6023 6024
		bdevname(rdev->bdev,b), mdname(mddev));
	return -EBUSY;
}

6025
static int hot_add_disk(struct mddev *mddev, dev_t dev)
L
Linus Torvalds 已提交
6026 6027 6028
{
	char b[BDEVNAME_SIZE];
	int err;
6029
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040

	if (!mddev->pers)
		return -ENODEV;

	if (mddev->major_version != 0) {
		printk(KERN_WARNING "%s: HOT_ADD may only be used with"
			" version-0 superblocks.\n",
			mdname(mddev));
		return -EINVAL;
	}
	if (!mddev->pers->hot_add_disk) {
6041
		printk(KERN_WARNING
L
Linus Torvalds 已提交
6042 6043 6044 6045 6046
			"%s: personality does not support diskops!\n",
			mdname(mddev));
		return -EINVAL;
	}

6047
	rdev = md_import_device(dev, -1, 0);
L
Linus Torvalds 已提交
6048
	if (IS_ERR(rdev)) {
6049
		printk(KERN_WARNING
L
Linus Torvalds 已提交
6050 6051 6052 6053 6054 6055
			"md: error, md_import_device() returned %ld\n",
			PTR_ERR(rdev));
		return -EINVAL;
	}

	if (mddev->persistent)
6056
		rdev->sb_start = calc_dev_sboffset(rdev);
L
Linus Torvalds 已提交
6057
	else
6058
		rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
L
Linus Torvalds 已提交
6059

6060
	rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
6061

6062
	if (test_bit(Faulty, &rdev->flags)) {
6063
		printk(KERN_WARNING
L
Linus Torvalds 已提交
6064 6065 6066 6067 6068
			"md: can not hot-add faulty %s disk to %s!\n",
			bdevname(rdev->bdev,b), mdname(mddev));
		err = -EINVAL;
		goto abort_export;
	}
6069 6070 6071

	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_start(mddev);
6072
	clear_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
6073
	rdev->desc_nr = -1;
6074
	rdev->saved_raid_disk = -1;
6075 6076
	err = bind_rdev_to_array(rdev, mddev);
	if (err)
6077
		goto abort_clustered;
L
Linus Torvalds 已提交
6078 6079 6080 6081 6082 6083 6084 6085

	/*
	 * The rest should better be atomic, we can have disk failures
	 * noticed in interrupt contexts ...
	 */

	rdev->raid_disk = -1;

6086
	md_update_sb(mddev, 1);
L
Linus Torvalds 已提交
6087

6088 6089
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_finish(mddev);
L
Linus Torvalds 已提交
6090 6091 6092 6093 6094 6095
	/*
	 * Kick recovery, maybe this spare has to be added to the
	 * array immediately.
	 */
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	md_wakeup_thread(mddev->thread);
6096
	md_new_event(mddev);
L
Linus Torvalds 已提交
6097 6098
	return 0;

6099 6100 6101
abort_clustered:
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_cancel(mddev);
L
Linus Torvalds 已提交
6102 6103 6104 6105 6106
abort_export:
	export_rdev(rdev);
	return err;
}

6107
static int set_bitmap_file(struct mddev *mddev, int fd)
6108
{
6109
	int err = 0;
6110

6111
	if (mddev->pers) {
6112
		if (!mddev->pers->quiesce || !mddev->thread)
6113 6114 6115 6116 6117
			return -EBUSY;
		if (mddev->recovery || mddev->sync_thread)
			return -EBUSY;
		/* we should be able to change the bitmap.. */
	}
6118

6119
	if (fd >= 0) {
6120
		struct inode *inode;
N
NeilBrown 已提交
6121 6122 6123
		struct file *f;

		if (mddev->bitmap || mddev->bitmap_info.file)
6124
			return -EEXIST; /* cannot add when bitmap is present */
N
NeilBrown 已提交
6125
		f = fget(fd);
6126

N
NeilBrown 已提交
6127
		if (f == NULL) {
6128 6129 6130 6131 6132
			printk(KERN_ERR "%s: error: failed to get bitmap file\n",
			       mdname(mddev));
			return -EBADF;
		}

N
NeilBrown 已提交
6133
		inode = f->f_mapping->host;
6134 6135 6136 6137
		if (!S_ISREG(inode->i_mode)) {
			printk(KERN_ERR "%s: error: bitmap file must be a regular file\n",
			       mdname(mddev));
			err = -EBADF;
N
NeilBrown 已提交
6138
		} else if (!(f->f_mode & FMODE_WRITE)) {
6139 6140 6141 6142
			printk(KERN_ERR "%s: error: bitmap file must open for write\n",
			       mdname(mddev));
			err = -EBADF;
		} else if (atomic_read(&inode->i_writecount) != 1) {
6143 6144
			printk(KERN_ERR "%s: error: bitmap file is already in use\n",
			       mdname(mddev));
6145 6146 6147
			err = -EBUSY;
		}
		if (err) {
N
NeilBrown 已提交
6148
			fput(f);
6149 6150
			return err;
		}
N
NeilBrown 已提交
6151
		mddev->bitmap_info.file = f;
6152
		mddev->bitmap_info.offset = 0; /* file overrides offset */
6153 6154 6155 6156 6157
	} else if (mddev->bitmap == NULL)
		return -ENOENT; /* cannot remove what isn't there */
	err = 0;
	if (mddev->pers) {
		mddev->pers->quiesce(mddev, 1);
6158
		if (fd >= 0) {
6159 6160 6161 6162 6163
			struct bitmap *bitmap;

			bitmap = bitmap_create(mddev, -1);
			if (!IS_ERR(bitmap)) {
				mddev->bitmap = bitmap;
6164
				err = bitmap_load(mddev);
6165 6166
			} else
				err = PTR_ERR(bitmap);
6167
		}
6168
		if (fd < 0 || err) {
6169
			bitmap_destroy(mddev);
6170 6171
			fd = -1; /* make sure to put the file */
		}
6172
		mddev->pers->quiesce(mddev, 0);
6173 6174
	}
	if (fd < 0) {
6175 6176 6177 6178 6179 6180 6181
		struct file *f = mddev->bitmap_info.file;
		if (f) {
			spin_lock(&mddev->lock);
			mddev->bitmap_info.file = NULL;
			spin_unlock(&mddev->lock);
			fput(f);
		}
6182 6183
	}

6184 6185 6186
	return err;
}

L
Linus Torvalds 已提交
6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199
/*
 * set_array_info is used two different ways
 * The original usage is when creating a new array.
 * In this usage, raid_disks is > 0 and it together with
 *  level, size, not_persistent,layout,chunksize determine the
 *  shape of the array.
 *  This will always create an array with a type-0.90.0 superblock.
 * The newer usage is when assembling an array.
 *  In this case raid_disks will be 0, and the major_version field is
 *  use to determine which style super-blocks are to be found on the devices.
 *  The minor and patch _version numbers are also kept incase the
 *  super_block handler wishes to interpret them.
 */
6200
static int set_array_info(struct mddev *mddev, mdu_array_info_t *info)
L
Linus Torvalds 已提交
6201 6202 6203 6204 6205
{

	if (info->raid_disks == 0) {
		/* just setting version number for superblock loading */
		if (info->major_version < 0 ||
6206
		    info->major_version >= ARRAY_SIZE(super_types) ||
L
Linus Torvalds 已提交
6207 6208
		    super_types[info->major_version].name == NULL) {
			/* maybe try to auto-load a module? */
6209
			printk(KERN_INFO
L
Linus Torvalds 已提交
6210 6211 6212 6213 6214 6215 6216
				"md: superblock version %d not known\n",
				info->major_version);
			return -EINVAL;
		}
		mddev->major_version = info->major_version;
		mddev->minor_version = info->minor_version;
		mddev->patch_version = info->patch_version;
6217
		mddev->persistent = !info->not_persistent;
6218 6219 6220 6221
		/* ensure mddev_put doesn't delete this now that there
		 * is some minimal configuration.
		 */
		mddev->ctime         = get_seconds();
L
Linus Torvalds 已提交
6222 6223 6224 6225 6226 6227 6228 6229
		return 0;
	}
	mddev->major_version = MD_MAJOR_VERSION;
	mddev->minor_version = MD_MINOR_VERSION;
	mddev->patch_version = MD_PATCHLEVEL_VERSION;
	mddev->ctime         = get_seconds();

	mddev->level         = info->level;
6230
	mddev->clevel[0]     = 0;
A
Andre Noll 已提交
6231
	mddev->dev_sectors   = 2 * (sector_t)info->size;
L
Linus Torvalds 已提交
6232 6233 6234 6235 6236 6237 6238 6239 6240
	mddev->raid_disks    = info->raid_disks;
	/* don't set md_minor, it is determined by which /dev/md* was
	 * openned
	 */
	if (info->state & (1<<MD_SB_CLEAN))
		mddev->recovery_cp = MaxSector;
	else
		mddev->recovery_cp = 0;
	mddev->persistent    = ! info->not_persistent;
6241
	mddev->external	     = 0;
L
Linus Torvalds 已提交
6242 6243

	mddev->layout        = info->layout;
6244
	mddev->chunk_sectors = info->chunk_size >> 9;
L
Linus Torvalds 已提交
6245 6246 6247

	mddev->max_disks     = MD_SB_DISKS;

6248 6249
	if (mddev->persistent)
		mddev->flags         = 0;
6250
	set_bit(MD_CHANGE_DEVS, &mddev->flags);
L
Linus Torvalds 已提交
6251

6252
	mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
6253
	mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
6254
	mddev->bitmap_info.offset = 0;
6255

6256 6257
	mddev->reshape_position = MaxSector;

L
Linus Torvalds 已提交
6258 6259 6260 6261 6262
	/*
	 * Generate a 128 bit UUID
	 */
	get_random_bytes(mddev->uuid, 16);

6263
	mddev->new_level = mddev->level;
6264
	mddev->new_chunk_sectors = mddev->chunk_sectors;
6265 6266
	mddev->new_layout = mddev->layout;
	mddev->delta_disks = 0;
6267
	mddev->reshape_backwards = 0;
6268

L
Linus Torvalds 已提交
6269 6270 6271
	return 0;
}

6272
void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
6273
{
D
Dan Williams 已提交
6274 6275 6276 6277 6278
	WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);

	if (mddev->external_size)
		return;

6279 6280 6281 6282
	mddev->array_sectors = array_sectors;
}
EXPORT_SYMBOL(md_set_array_sectors);

6283
static int update_size(struct mddev *mddev, sector_t num_sectors)
6284
{
6285
	struct md_rdev *rdev;
6286
	int rv;
6287
	int fit = (num_sectors == 0);
6288 6289 6290

	if (mddev->pers->resize == NULL)
		return -EINVAL;
6291 6292 6293 6294 6295
	/* The "num_sectors" is the number of sectors of each device that
	 * is used.  This can only make sense for arrays with redundancy.
	 * linear and raid0 always use whatever space is available. We can only
	 * consider changing this number if no resync or reconstruction is
	 * happening, and if the new size is acceptable. It must fit before the
6296
	 * sb_start or, if that is <data_offset, it must fit before the size
6297 6298
	 * of each device.  If num_sectors is zero, we find the largest size
	 * that fits.
6299
	 */
6300 6301
	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
	    mddev->sync_thread)
6302
		return -EBUSY;
6303 6304
	if (mddev->ro)
		return -EROFS;
6305

N
NeilBrown 已提交
6306
	rdev_for_each(rdev, mddev) {
6307
		sector_t avail = rdev->sectors;
6308

6309 6310 6311
		if (fit && (num_sectors == 0 || num_sectors > avail))
			num_sectors = avail;
		if (avail < num_sectors)
6312 6313
			return -ENOSPC;
	}
6314
	rv = mddev->pers->resize(mddev, num_sectors);
6315 6316
	if (!rv)
		revalidate_disk(mddev->gendisk);
6317 6318 6319
	return rv;
}

6320
static int update_raid_disks(struct mddev *mddev, int raid_disks)
6321 6322
{
	int rv;
6323
	struct md_rdev *rdev;
6324
	/* change the number of raid disks */
6325
	if (mddev->pers->check_reshape == NULL)
6326
		return -EINVAL;
6327 6328
	if (mddev->ro)
		return -EROFS;
6329
	if (raid_disks <= 0 ||
6330
	    (mddev->max_disks && raid_disks >= mddev->max_disks))
6331
		return -EINVAL;
6332 6333 6334
	if (mddev->sync_thread ||
	    test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
	    mddev->reshape_position != MaxSector)
6335
		return -EBUSY;
6336 6337 6338 6339 6340 6341 6342 6343 6344 6345

	rdev_for_each(rdev, mddev) {
		if (mddev->raid_disks < raid_disks &&
		    rdev->data_offset < rdev->new_data_offset)
			return -EINVAL;
		if (mddev->raid_disks > raid_disks &&
		    rdev->data_offset > rdev->new_data_offset)
			return -EINVAL;
	}

6346
	mddev->delta_disks = raid_disks - mddev->raid_disks;
6347 6348 6349 6350
	if (mddev->delta_disks < 0)
		mddev->reshape_backwards = 1;
	else if (mddev->delta_disks > 0)
		mddev->reshape_backwards = 0;
6351 6352

	rv = mddev->pers->check_reshape(mddev);
6353
	if (rv < 0) {
6354
		mddev->delta_disks = 0;
6355 6356
		mddev->reshape_backwards = 0;
	}
6357 6358 6359
	return rv;
}

L
Linus Torvalds 已提交
6360 6361 6362 6363 6364 6365 6366 6367
/*
 * update_array_info is used to change the configuration of an
 * on-line array.
 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
 * fields in the info are checked against the array.
 * Any differences that cannot be handled will cause an error.
 * Normally, only one change can be managed at a time.
 */
6368
static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
L
Linus Torvalds 已提交
6369 6370 6371
{
	int rv = 0;
	int cnt = 0;
6372 6373 6374
	int state = 0;

	/* calculate expected state,ignoring low bits */
6375
	if (mddev->bitmap && mddev->bitmap_info.offset)
6376
		state |= (1 << MD_SB_BITMAP_PRESENT);
L
Linus Torvalds 已提交
6377 6378 6379 6380 6381 6382 6383

	if (mddev->major_version != info->major_version ||
	    mddev->minor_version != info->minor_version ||
/*	    mddev->patch_version != info->patch_version || */
	    mddev->ctime         != info->ctime         ||
	    mddev->level         != info->level         ||
/*	    mddev->layout        != info->layout        || */
F
Firo Yang 已提交
6384
	    mddev->persistent	 != !info->not_persistent ||
6385
	    mddev->chunk_sectors != info->chunk_size >> 9 ||
6386 6387 6388
	    /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
	    ((state^info->state) & 0xfffffe00)
		)
L
Linus Torvalds 已提交
6389 6390
		return -EINVAL;
	/* Check there is only one change */
A
Andre Noll 已提交
6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402
	if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
		cnt++;
	if (mddev->raid_disks != info->raid_disks)
		cnt++;
	if (mddev->layout != info->layout)
		cnt++;
	if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
		cnt++;
	if (cnt == 0)
		return 0;
	if (cnt > 1)
		return -EINVAL;
L
Linus Torvalds 已提交
6403 6404 6405 6406 6407 6408

	if (mddev->layout != info->layout) {
		/* Change layout
		 * we don't need to do anything at the md level, the
		 * personality will take care of it all.
		 */
6409
		if (mddev->pers->check_reshape == NULL)
L
Linus Torvalds 已提交
6410
			return -EINVAL;
6411 6412
		else {
			mddev->new_layout = info->layout;
6413
			rv = mddev->pers->check_reshape(mddev);
6414 6415 6416 6417
			if (rv)
				mddev->new_layout = mddev->layout;
			return rv;
		}
L
Linus Torvalds 已提交
6418
	}
6419 6420
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_start(mddev);
A
Andre Noll 已提交
6421
	if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
6422
		rv = update_size(mddev, (sector_t)info->size * 2);
6423

6424 6425 6426
	if (mddev->raid_disks    != info->raid_disks)
		rv = update_raid_disks(mddev, info->raid_disks);

6427
	if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
6428 6429 6430 6431 6432 6433 6434 6435
		if (mddev->pers->quiesce == NULL || mddev->thread == NULL) {
			rv = -EINVAL;
			goto err;
		}
		if (mddev->recovery || mddev->sync_thread) {
			rv = -EBUSY;
			goto err;
		}
6436
		if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
6437
			struct bitmap *bitmap;
6438
			/* add the bitmap */
6439 6440 6441 6442 6443 6444 6445 6446
			if (mddev->bitmap) {
				rv = -EEXIST;
				goto err;
			}
			if (mddev->bitmap_info.default_offset == 0) {
				rv = -EINVAL;
				goto err;
			}
6447 6448
			mddev->bitmap_info.offset =
				mddev->bitmap_info.default_offset;
6449 6450
			mddev->bitmap_info.space =
				mddev->bitmap_info.default_space;
6451
			mddev->pers->quiesce(mddev, 1);
6452 6453 6454
			bitmap = bitmap_create(mddev, -1);
			if (!IS_ERR(bitmap)) {
				mddev->bitmap = bitmap;
6455
				rv = bitmap_load(mddev);
6456 6457
			} else
				rv = PTR_ERR(bitmap);
6458 6459 6460 6461 6462
			if (rv)
				bitmap_destroy(mddev);
			mddev->pers->quiesce(mddev, 0);
		} else {
			/* remove the bitmap */
6463 6464 6465 6466 6467 6468 6469 6470
			if (!mddev->bitmap) {
				rv = -ENOENT;
				goto err;
			}
			if (mddev->bitmap->storage.file) {
				rv = -EINVAL;
				goto err;
			}
6471 6472 6473
			mddev->pers->quiesce(mddev, 1);
			bitmap_destroy(mddev);
			mddev->pers->quiesce(mddev, 0);
6474
			mddev->bitmap_info.offset = 0;
6475 6476
		}
	}
6477
	md_update_sb(mddev, 1);
6478 6479 6480 6481 6482 6483
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_finish(mddev);
	return rv;
err:
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_cancel(mddev);
L
Linus Torvalds 已提交
6484 6485 6486
	return rv;
}

6487
static int set_disk_faulty(struct mddev *mddev, dev_t dev)
L
Linus Torvalds 已提交
6488
{
6489
	struct md_rdev *rdev;
6490
	int err = 0;
L
Linus Torvalds 已提交
6491 6492 6493 6494

	if (mddev->pers == NULL)
		return -ENODEV;

6495 6496
	rcu_read_lock();
	rdev = find_rdev_rcu(mddev, dev);
L
Linus Torvalds 已提交
6497
	if (!rdev)
6498 6499 6500 6501 6502 6503 6504 6505
		err =  -ENODEV;
	else {
		md_error(mddev, rdev);
		if (!test_bit(Faulty, &rdev->flags))
			err = -EBUSY;
	}
	rcu_read_unlock();
	return err;
L
Linus Torvalds 已提交
6506 6507
}

6508 6509 6510 6511 6512 6513
/*
 * We have a problem here : there is no easy way to give a CHS
 * virtual geometry. We currently pretend that we have a 2 heads
 * 4 sectors (with a BIG number of cylinders...). This drives
 * dosfs just mad... ;-)
 */
6514 6515
static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
{
6516
	struct mddev *mddev = bdev->bd_disk->private_data;
6517 6518 6519

	geo->heads = 2;
	geo->sectors = 4;
6520
	geo->cylinders = mddev->array_sectors / 8;
6521 6522 6523
	return 0;
}

6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542
static inline bool md_ioctl_valid(unsigned int cmd)
{
	switch (cmd) {
	case ADD_NEW_DISK:
	case BLKROSET:
	case GET_ARRAY_INFO:
	case GET_BITMAP_FILE:
	case GET_DISK_INFO:
	case HOT_ADD_DISK:
	case HOT_REMOVE_DISK:
	case RAID_AUTORUN:
	case RAID_VERSION:
	case RESTART_ARRAY_RW:
	case RUN_ARRAY:
	case SET_ARRAY_INFO:
	case SET_BITMAP_FILE:
	case SET_DISK_FAULTY:
	case STOP_ARRAY:
	case STOP_ARRAY_RO:
6543
	case CLUSTERED_DISK_NACK:
6544 6545 6546 6547 6548 6549
		return true;
	default:
		return false;
	}
}

A
Al Viro 已提交
6550
static int md_ioctl(struct block_device *bdev, fmode_t mode,
L
Linus Torvalds 已提交
6551 6552 6553 6554
			unsigned int cmd, unsigned long arg)
{
	int err = 0;
	void __user *argp = (void __user *)arg;
6555
	struct mddev *mddev = NULL;
6556
	int ro;
L
Linus Torvalds 已提交
6557

6558 6559 6560
	if (!md_ioctl_valid(cmd))
		return -ENOTTY;

6561 6562 6563 6564 6565 6566 6567 6568 6569
	switch (cmd) {
	case RAID_VERSION:
	case GET_ARRAY_INFO:
	case GET_DISK_INFO:
		break;
	default:
		if (!capable(CAP_SYS_ADMIN))
			return -EACCES;
	}
L
Linus Torvalds 已提交
6570 6571 6572 6573 6574

	/*
	 * Commands dealing with the RAID driver but not any
	 * particular array:
	 */
6575 6576 6577
	switch (cmd) {
	case RAID_VERSION:
		err = get_version(argp);
6578
		goto out;
L
Linus Torvalds 已提交
6579 6580

#ifndef MODULE
6581 6582 6583
	case RAID_AUTORUN:
		err = 0;
		autostart_arrays(arg);
6584
		goto out;
L
Linus Torvalds 已提交
6585
#endif
6586
	default:;
L
Linus Torvalds 已提交
6587 6588 6589 6590 6591 6592
	}

	/*
	 * Commands creating/starting a new array:
	 */

A
Al Viro 已提交
6593
	mddev = bdev->bd_disk->private_data;
L
Linus Torvalds 已提交
6594 6595 6596

	if (!mddev) {
		BUG();
6597
		goto out;
L
Linus Torvalds 已提交
6598 6599
	}

6600 6601 6602 6603 6604 6605 6606
	/* Some actions do not requires the mutex */
	switch (cmd) {
	case GET_ARRAY_INFO:
		if (!mddev->raid_disks && !mddev->external)
			err = -ENODEV;
		else
			err = get_array_info(mddev, argp);
6607
		goto out;
6608 6609 6610 6611 6612 6613

	case GET_DISK_INFO:
		if (!mddev->raid_disks && !mddev->external)
			err = -ENODEV;
		else
			err = get_disk_info(mddev, argp);
6614
		goto out;
6615 6616 6617

	case SET_DISK_FAULTY:
		err = set_disk_faulty(mddev, new_decode_dev(arg));
6618
		goto out;
6619 6620 6621 6622 6623

	case GET_BITMAP_FILE:
		err = get_bitmap_file(mddev, argp);
		goto out;

6624 6625
	}

6626 6627 6628 6629
	if (cmd == ADD_NEW_DISK)
		/* need to ensure md_delayed_delete() has completed */
		flush_workqueue(md_misc_wq);

6630 6631 6632 6633 6634 6635
	if (cmd == HOT_REMOVE_DISK)
		/* need to ensure recovery thread has run */
		wait_event_interruptible_timeout(mddev->sb_wait,
						 !test_bit(MD_RECOVERY_NEEDED,
							   &mddev->flags),
						 msecs_to_jiffies(5000));
6636 6637 6638 6639 6640
	if (cmd == STOP_ARRAY || cmd == STOP_ARRAY_RO) {
		/* Need to flush page cache, and ensure no-one else opens
		 * and writes
		 */
		mutex_lock(&mddev->open_mutex);
6641
		if (mddev->pers && atomic_read(&mddev->openers) > 1) {
6642 6643
			mutex_unlock(&mddev->open_mutex);
			err = -EBUSY;
6644
			goto out;
6645 6646 6647 6648 6649
		}
		set_bit(MD_STILL_CLOSED, &mddev->flags);
		mutex_unlock(&mddev->open_mutex);
		sync_blockdev(bdev);
	}
L
Linus Torvalds 已提交
6650 6651
	err = mddev_lock(mddev);
	if (err) {
6652
		printk(KERN_INFO
L
Linus Torvalds 已提交
6653 6654
			"md: ioctl lock interrupted, reason %d, cmd %d\n",
			err, cmd);
6655
		goto out;
L
Linus Torvalds 已提交
6656 6657
	}

6658 6659 6660 6661 6662 6663
	if (cmd == SET_ARRAY_INFO) {
		mdu_array_info_t info;
		if (!arg)
			memset(&info, 0, sizeof(info));
		else if (copy_from_user(&info, argp, sizeof(info))) {
			err = -EFAULT;
6664
			goto unlock;
6665 6666 6667 6668 6669 6670
		}
		if (mddev->pers) {
			err = update_array_info(mddev, &info);
			if (err) {
				printk(KERN_WARNING "md: couldn't update"
				       " array info. %d\n", err);
6671
				goto unlock;
L
Linus Torvalds 已提交
6672
			}
6673
			goto unlock;
6674 6675 6676 6677 6678 6679
		}
		if (!list_empty(&mddev->disks)) {
			printk(KERN_WARNING
			       "md: array %s already has disks!\n",
			       mdname(mddev));
			err = -EBUSY;
6680
			goto unlock;
6681 6682 6683 6684 6685 6686
		}
		if (mddev->raid_disks) {
			printk(KERN_WARNING
			       "md: array %s already initialised!\n",
			       mdname(mddev));
			err = -EBUSY;
6687
			goto unlock;
6688 6689 6690 6691 6692
		}
		err = set_array_info(mddev, &info);
		if (err) {
			printk(KERN_WARNING "md: couldn't set"
			       " array info. %d\n", err);
6693
			goto unlock;
6694
		}
6695
		goto unlock;
L
Linus Torvalds 已提交
6696 6697 6698 6699 6700
	}

	/*
	 * Commands querying/configuring an existing array:
	 */
6701
	/* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
6702
	 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
6703 6704 6705 6706
	if ((!mddev->raid_disks && !mddev->external)
	    && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
	    && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
	    && cmd != GET_BITMAP_FILE) {
L
Linus Torvalds 已提交
6707
		err = -ENODEV;
6708
		goto unlock;
L
Linus Torvalds 已提交
6709 6710 6711 6712 6713
	}

	/*
	 * Commands even a read-only array can execute:
	 */
6714 6715 6716
	switch (cmd) {
	case RESTART_ARRAY_RW:
		err = restart_array(mddev);
6717
		goto unlock;
L
Linus Torvalds 已提交
6718

6719 6720
	case STOP_ARRAY:
		err = do_md_stop(mddev, 0, bdev);
6721
		goto unlock;
L
Linus Torvalds 已提交
6722

6723 6724
	case STOP_ARRAY_RO:
		err = md_set_readonly(mddev, bdev);
6725
		goto unlock;
L
Linus Torvalds 已提交
6726

6727 6728
	case HOT_REMOVE_DISK:
		err = hot_remove_disk(mddev, new_decode_dev(arg));
6729
		goto unlock;
6730

6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744
	case ADD_NEW_DISK:
		/* We can support ADD_NEW_DISK on read-only arrays
		 * on if we are re-adding a preexisting device.
		 * So require mddev->pers and MD_DISK_SYNC.
		 */
		if (mddev->pers) {
			mdu_disk_info_t info;
			if (copy_from_user(&info, argp, sizeof(info)))
				err = -EFAULT;
			else if (!(info.state & (1<<MD_DISK_SYNC)))
				/* Need to clear read-only for this */
				break;
			else
				err = add_new_disk(mddev, &info);
6745
			goto unlock;
6746 6747 6748
		}
		break;

6749 6750 6751
	case BLKROSET:
		if (get_user(ro, (int __user *)(arg))) {
			err = -EFAULT;
6752
			goto unlock;
6753 6754
		}
		err = -EINVAL;
6755

6756 6757 6758 6759
		/* if the bdev is going readonly the value of mddev->ro
		 * does not matter, no writes are coming
		 */
		if (ro)
6760
			goto unlock;
6761

6762 6763
		/* are we are already prepared for writes? */
		if (mddev->ro != 1)
6764
			goto unlock;
6765

6766 6767 6768 6769 6770 6771 6772 6773
		/* transitioning to readauto need only happen for
		 * arrays that call md_write_start
		 */
		if (mddev->pers) {
			err = restart_array(mddev);
			if (err == 0) {
				mddev->ro = 2;
				set_disk_ro(mddev->gendisk, 0);
6774
			}
6775
		}
6776
		goto unlock;
L
Linus Torvalds 已提交
6777 6778 6779 6780
	}

	/*
	 * The remaining ioctls are changing the state of the
6781
	 * superblock, so we do not allow them on read-only arrays.
L
Linus Torvalds 已提交
6782
	 */
6783
	if (mddev->ro && mddev->pers) {
6784 6785
		if (mddev->ro == 2) {
			mddev->ro = 0;
N
NeilBrown 已提交
6786
			sysfs_notify_dirent_safe(mddev->sysfs_state);
6787
			set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6788 6789 6790 6791 6792 6793 6794 6795 6796
			/* mddev_unlock will wake thread */
			/* If a device failed while we were read-only, we
			 * need to make sure the metadata is updated now.
			 */
			if (test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
				mddev_unlock(mddev);
				wait_event(mddev->sb_wait,
					   !test_bit(MD_CHANGE_DEVS, &mddev->flags) &&
					   !test_bit(MD_CHANGE_PENDING, &mddev->flags));
6797
				mddev_lock_nointr(mddev);
6798
			}
6799 6800
		} else {
			err = -EROFS;
6801
			goto unlock;
6802
		}
L
Linus Torvalds 已提交
6803 6804
	}

6805 6806
	switch (cmd) {
	case ADD_NEW_DISK:
L
Linus Torvalds 已提交
6807
	{
6808 6809 6810 6811 6812
		mdu_disk_info_t info;
		if (copy_from_user(&info, argp, sizeof(info)))
			err = -EFAULT;
		else
			err = add_new_disk(mddev, &info);
6813
		goto unlock;
6814
	}
L
Linus Torvalds 已提交
6815

6816 6817 6818 6819 6820 6821 6822
	case CLUSTERED_DISK_NACK:
		if (mddev_is_clustered(mddev))
			md_cluster_ops->new_disk_ack(mddev, false);
		else
			err = -EINVAL;
		goto unlock;

6823 6824
	case HOT_ADD_DISK:
		err = hot_add_disk(mddev, new_decode_dev(arg));
6825
		goto unlock;
L
Linus Torvalds 已提交
6826

6827 6828
	case RUN_ARRAY:
		err = do_md_run(mddev);
6829
		goto unlock;
L
Linus Torvalds 已提交
6830

6831 6832
	case SET_BITMAP_FILE:
		err = set_bitmap_file(mddev, (int)arg);
6833
		goto unlock;
6834

6835 6836
	default:
		err = -EINVAL;
6837
		goto unlock;
L
Linus Torvalds 已提交
6838 6839
	}

6840
unlock:
6841 6842 6843
	if (mddev->hold_active == UNTIL_IOCTL &&
	    err != -EINVAL)
		mddev->hold_active = 0;
L
Linus Torvalds 已提交
6844
	mddev_unlock(mddev);
6845
out:
L
Linus Torvalds 已提交
6846 6847
	return err;
}
6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866
#ifdef CONFIG_COMPAT
static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
		    unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
	case HOT_REMOVE_DISK:
	case HOT_ADD_DISK:
	case SET_DISK_FAULTY:
	case SET_BITMAP_FILE:
		/* These take in integer arg, do not convert */
		break;
	default:
		arg = (unsigned long)compat_ptr(arg);
		break;
	}

	return md_ioctl(bdev, mode, cmd, arg);
}
#endif /* CONFIG_COMPAT */
L
Linus Torvalds 已提交
6867

A
Al Viro 已提交
6868
static int md_open(struct block_device *bdev, fmode_t mode)
L
Linus Torvalds 已提交
6869 6870 6871 6872 6873
{
	/*
	 * Succeed if we can lock the mddev, which confirms that
	 * it isn't being stopped right now.
	 */
6874
	struct mddev *mddev = mddev_find(bdev->bd_dev);
L
Linus Torvalds 已提交
6875 6876
	int err;

6877 6878 6879
	if (!mddev)
		return -ENODEV;

6880 6881 6882 6883 6884 6885
	if (mddev->gendisk != bdev->bd_disk) {
		/* we are racing with mddev_put which is discarding this
		 * bd_disk.
		 */
		mddev_put(mddev);
		/* Wait until bdev->bd_disk is definitely gone */
T
Tejun Heo 已提交
6886
		flush_workqueue(md_misc_wq);
6887 6888 6889 6890 6891
		/* Then retry the open from the top */
		return -ERESTARTSYS;
	}
	BUG_ON(mddev != bdev->bd_disk->private_data);

N
NeilBrown 已提交
6892
	if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
L
Linus Torvalds 已提交
6893 6894 6895
		goto out;

	err = 0;
6896
	atomic_inc(&mddev->openers);
6897
	clear_bit(MD_STILL_CLOSED, &mddev->flags);
N
NeilBrown 已提交
6898
	mutex_unlock(&mddev->open_mutex);
L
Linus Torvalds 已提交
6899

6900
	check_disk_change(bdev);
L
Linus Torvalds 已提交
6901 6902 6903 6904
 out:
	return err;
}

6905
static void md_release(struct gendisk *disk, fmode_t mode)
L
Linus Torvalds 已提交
6906
{
6907
	struct mddev *mddev = disk->private_data;
L
Linus Torvalds 已提交
6908

E
Eric Sesterhenn 已提交
6909
	BUG_ON(!mddev);
6910
	atomic_dec(&mddev->openers);
L
Linus Torvalds 已提交
6911 6912
	mddev_put(mddev);
}
6913 6914 6915

static int md_media_changed(struct gendisk *disk)
{
6916
	struct mddev *mddev = disk->private_data;
6917 6918 6919 6920 6921 6922

	return mddev->changed;
}

static int md_revalidate(struct gendisk *disk)
{
6923
	struct mddev *mddev = disk->private_data;
6924 6925 6926 6927

	mddev->changed = 0;
	return 0;
}
6928
static const struct block_device_operations md_fops =
L
Linus Torvalds 已提交
6929 6930
{
	.owner		= THIS_MODULE,
A
Al Viro 已提交
6931 6932
	.open		= md_open,
	.release	= md_release,
N
NeilBrown 已提交
6933
	.ioctl		= md_ioctl,
6934 6935 6936
#ifdef CONFIG_COMPAT
	.compat_ioctl	= md_compat_ioctl,
#endif
6937
	.getgeo		= md_getgeo,
6938 6939
	.media_changed  = md_media_changed,
	.revalidate_disk= md_revalidate,
L
Linus Torvalds 已提交
6940 6941
};

6942
static int md_thread(void *arg)
L
Linus Torvalds 已提交
6943
{
6944
	struct md_thread *thread = arg;
L
Linus Torvalds 已提交
6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957

	/*
	 * md_thread is a 'system-thread', it's priority should be very
	 * high. We avoid resource deadlocks individually in each
	 * raid personality. (RAID5 does preallocation) We also use RR and
	 * the very same RT priority as kswapd, thus we will never get
	 * into a priority inversion deadlock.
	 *
	 * we definitely have to have equal or higher priority than
	 * bdflush, otherwise bdflush will deadlock if there are too
	 * many dirty RAID5 blocks.
	 */

N
NeilBrown 已提交
6958
	allow_signal(SIGKILL);
6959
	while (!kthread_should_stop()) {
L
Linus Torvalds 已提交
6960

6961 6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973
		/* We need to wait INTERRUPTIBLE so that
		 * we don't add to the load-average.
		 * That means we need to be sure no signals are
		 * pending
		 */
		if (signal_pending(current))
			flush_signals(current);

		wait_event_interruptible_timeout
			(thread->wqueue,
			 test_bit(THREAD_WAKEUP, &thread->flags)
			 || kthread_should_stop(),
			 thread->timeout);
L
Linus Torvalds 已提交
6974

6975 6976
		clear_bit(THREAD_WAKEUP, &thread->flags);
		if (!kthread_should_stop())
S
Shaohua Li 已提交
6977
			thread->run(thread);
L
Linus Torvalds 已提交
6978
	}
6979

L
Linus Torvalds 已提交
6980 6981 6982
	return 0;
}

6983
void md_wakeup_thread(struct md_thread *thread)
L
Linus Torvalds 已提交
6984 6985
{
	if (thread) {
6986
		pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
L
Linus Torvalds 已提交
6987 6988 6989 6990
		set_bit(THREAD_WAKEUP, &thread->flags);
		wake_up(&thread->wqueue);
	}
}
6991
EXPORT_SYMBOL(md_wakeup_thread);
L
Linus Torvalds 已提交
6992

S
Shaohua Li 已提交
6993 6994
struct md_thread *md_register_thread(void (*run) (struct md_thread *),
		struct mddev *mddev, const char *name)
L
Linus Torvalds 已提交
6995
{
6996
	struct md_thread *thread;
L
Linus Torvalds 已提交
6997

6998
	thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
L
Linus Torvalds 已提交
6999 7000 7001 7002 7003 7004 7005
	if (!thread)
		return NULL;

	init_waitqueue_head(&thread->wqueue);

	thread->run = run;
	thread->mddev = mddev;
7006
	thread->timeout = MAX_SCHEDULE_TIMEOUT;
7007 7008 7009
	thread->tsk = kthread_run(md_thread, thread,
				  "%s_%s",
				  mdname(thread->mddev),
7010
				  name);
7011
	if (IS_ERR(thread->tsk)) {
L
Linus Torvalds 已提交
7012 7013 7014 7015 7016
		kfree(thread);
		return NULL;
	}
	return thread;
}
7017
EXPORT_SYMBOL(md_register_thread);
L
Linus Torvalds 已提交
7018

7019
void md_unregister_thread(struct md_thread **threadp)
L
Linus Torvalds 已提交
7020
{
7021
	struct md_thread *thread = *threadp;
7022 7023
	if (!thread)
		return;
7024
	pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
7025 7026 7027 7028 7029 7030
	/* Locking ensures that mddev_unlock does not wake_up a
	 * non-existent thread
	 */
	spin_lock(&pers_lock);
	*threadp = NULL;
	spin_unlock(&pers_lock);
7031 7032

	kthread_stop(thread->tsk);
L
Linus Torvalds 已提交
7033 7034
	kfree(thread);
}
7035
EXPORT_SYMBOL(md_unregister_thread);
L
Linus Torvalds 已提交
7036

7037
void md_error(struct mddev *mddev, struct md_rdev *rdev)
L
Linus Torvalds 已提交
7038
{
7039
	if (!rdev || test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
7040
		return;
7041

7042
	if (!mddev->pers || !mddev->pers->error_handler)
L
Linus Torvalds 已提交
7043 7044
		return;
	mddev->pers->error_handler(mddev,rdev);
7045 7046
	if (mddev->degraded)
		set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
N
NeilBrown 已提交
7047
	sysfs_notify_dirent_safe(rdev->sysfs_state);
L
Linus Torvalds 已提交
7048 7049 7050
	set_bit(MD_RECOVERY_INTR, &mddev->recovery);
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	md_wakeup_thread(mddev->thread);
7051
	if (mddev->event_work.func)
T
Tejun Heo 已提交
7052
		queue_work(md_misc_wq, &mddev->event_work);
7053
	md_new_event_inintr(mddev);
L
Linus Torvalds 已提交
7054
}
7055
EXPORT_SYMBOL(md_error);
L
Linus Torvalds 已提交
7056 7057 7058 7059 7060 7061

/* seq_file implementation /proc/mdstat */

static void status_unused(struct seq_file *seq)
{
	int i = 0;
7062
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
7063 7064 7065

	seq_printf(seq, "unused devices: ");

7066
	list_for_each_entry(rdev, &pending_raid_disks, same_set) {
L
Linus Torvalds 已提交
7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077
		char b[BDEVNAME_SIZE];
		i++;
		seq_printf(seq, "%s ",
			      bdevname(rdev->bdev,b));
	}
	if (!i)
		seq_printf(seq, "<none>");

	seq_printf(seq, "\n");
}

7078
static int status_resync(struct seq_file *seq, struct mddev *mddev)
L
Linus Torvalds 已提交
7079
{
7080 7081 7082
	sector_t max_sectors, resync, res;
	unsigned long dt, db;
	sector_t rt;
7083 7084
	int scale;
	unsigned int per_milli;
L
Linus Torvalds 已提交
7085

7086 7087
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
	    test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7088
		max_sectors = mddev->resync_max_sectors;
L
Linus Torvalds 已提交
7089
	else
7090
		max_sectors = mddev->dev_sectors;
L
Linus Torvalds 已提交
7091

7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111
	resync = mddev->curr_resync;
	if (resync <= 3) {
		if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
			/* Still cleaning up */
			resync = max_sectors;
	} else
		resync -= atomic_read(&mddev->recovery_active);

	if (resync == 0) {
		if (mddev->recovery_cp < MaxSector) {
			seq_printf(seq, "\tresync=PENDING");
			return 1;
		}
		return 0;
	}
	if (resync < 3) {
		seq_printf(seq, "\tresync=DELAYED");
		return 1;
	}

N
NeilBrown 已提交
7112
	WARN_ON(max_sectors == 0);
7113
	/* Pick 'scale' such that (resync>>scale)*1000 will fit
7114
	 * in a sector_t, and (max_sectors>>scale) will fit in a
7115 7116 7117 7118 7119
	 * u32, as those are the requirements for sector_div.
	 * Thus 'scale' must be at least 10
	 */
	scale = 10;
	if (sizeof(sector_t) > sizeof(unsigned long)) {
7120
		while ( max_sectors/2 > (1ULL<<(scale+32)))
7121 7122 7123
			scale++;
	}
	res = (resync>>scale)*1000;
7124
	sector_div(res, (u32)((max_sectors>>scale)+1));
7125 7126

	per_milli = res;
L
Linus Torvalds 已提交
7127
	{
7128
		int i, x = per_milli/50, y = 20-x;
L
Linus Torvalds 已提交
7129 7130 7131 7132 7133 7134 7135 7136
		seq_printf(seq, "[");
		for (i = 0; i < x; i++)
			seq_printf(seq, "=");
		seq_printf(seq, ">");
		for (i = 0; i < y; i++)
			seq_printf(seq, ".");
		seq_printf(seq, "] ");
	}
7137
	seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
7138 7139
		   (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
		    "reshape" :
7140 7141 7142 7143 7144
		    (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
		     "check" :
		     (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
		      "resync" : "recovery"))),
		   per_milli/10, per_milli % 10,
7145 7146
		   (unsigned long long) resync/2,
		   (unsigned long long) max_sectors/2);
L
Linus Torvalds 已提交
7147 7148 7149 7150 7151

	/*
	 * dt: time from mark until now
	 * db: blocks written from mark until now
	 * rt: remaining time
7152 7153 7154 7155
	 *
	 * rt is a sector_t, so could be 32bit or 64bit.
	 * So we divide before multiply in case it is 32bit and close
	 * to the limit.
L
Lucas De Marchi 已提交
7156
	 * We scale the divisor (db) by 32 to avoid losing precision
7157 7158 7159 7160
	 * near the end of resync when the number of remaining sectors
	 * is close to 'db'.
	 * We then divide rt by 32 after multiplying by db to compensate.
	 * The '+1' avoids division by zero if db is very small.
L
Linus Torvalds 已提交
7161 7162 7163
	 */
	dt = ((jiffies - mddev->resync_mark) / HZ);
	if (!dt) dt++;
7164 7165
	db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
		- mddev->resync_mark_cnt;
L
Linus Torvalds 已提交
7166

7167 7168 7169 7170 7171 7172 7173
	rt = max_sectors - resync;    /* number of remaining sectors */
	sector_div(rt, db/32+1);
	rt *= dt;
	rt >>= 5;

	seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
		   ((unsigned long)rt % 60)/6);
L
Linus Torvalds 已提交
7174

7175
	seq_printf(seq, " speed=%ldK/sec", db/2/dt);
7176
	return 1;
L
Linus Torvalds 已提交
7177 7178 7179 7180 7181 7182
}

static void *md_seq_start(struct seq_file *seq, loff_t *pos)
{
	struct list_head *tmp;
	loff_t l = *pos;
7183
	struct mddev *mddev;
L
Linus Torvalds 已提交
7184 7185 7186 7187 7188 7189 7190 7191 7192 7193

	if (l >= 0x10000)
		return NULL;
	if (!l--)
		/* header */
		return (void*)1;

	spin_lock(&all_mddevs_lock);
	list_for_each(tmp,&all_mddevs)
		if (!l--) {
7194
			mddev = list_entry(tmp, struct mddev, all_mddevs);
L
Linus Torvalds 已提交
7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207
			mddev_get(mddev);
			spin_unlock(&all_mddevs_lock);
			return mddev;
		}
	spin_unlock(&all_mddevs_lock);
	if (!l--)
		return (void*)2;/* tail */
	return NULL;
}

static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct list_head *tmp;
7208
	struct mddev *next_mddev, *mddev = v;
7209

L
Linus Torvalds 已提交
7210 7211 7212 7213 7214 7215 7216 7217 7218 7219
	++*pos;
	if (v == (void*)2)
		return NULL;

	spin_lock(&all_mddevs_lock);
	if (v == (void*)1)
		tmp = all_mddevs.next;
	else
		tmp = mddev->all_mddevs.next;
	if (tmp != &all_mddevs)
7220
		next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
L
Linus Torvalds 已提交
7221 7222 7223
	else {
		next_mddev = (void*)2;
		*pos = 0x10000;
7224
	}
L
Linus Torvalds 已提交
7225 7226 7227 7228 7229 7230 7231 7232 7233 7234
	spin_unlock(&all_mddevs_lock);

	if (v != (void*)1)
		mddev_put(mddev);
	return next_mddev;

}

static void md_seq_stop(struct seq_file *seq, void *v)
{
7235
	struct mddev *mddev = v;
L
Linus Torvalds 已提交
7236 7237 7238 7239 7240 7241 7242

	if (mddev && v != (void*)1 && v != (void*)2)
		mddev_put(mddev);
}

static int md_seq_show(struct seq_file *seq, void *v)
{
7243
	struct mddev *mddev = v;
7244
	sector_t sectors;
7245
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
7246 7247

	if (v == (void*)1) {
7248
		struct md_personality *pers;
L
Linus Torvalds 已提交
7249 7250
		seq_printf(seq, "Personalities : ");
		spin_lock(&pers_lock);
7251 7252
		list_for_each_entry(pers, &pers_list, list)
			seq_printf(seq, "[%s] ", pers->name);
L
Linus Torvalds 已提交
7253 7254 7255

		spin_unlock(&pers_lock);
		seq_printf(seq, "\n");
7256
		seq->poll_event = atomic_read(&md_event_count);
L
Linus Torvalds 已提交
7257 7258 7259 7260 7261 7262 7263
		return 0;
	}
	if (v == (void*)2) {
		status_unused(seq);
		return 0;
	}

7264
	spin_lock(&mddev->lock);
L
Linus Torvalds 已提交
7265 7266 7267 7268
	if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
		seq_printf(seq, "%s : %sactive", mdname(mddev),
						mddev->pers ? "" : "in");
		if (mddev->pers) {
7269
			if (mddev->ro==1)
L
Linus Torvalds 已提交
7270
				seq_printf(seq, " (read-only)");
7271
			if (mddev->ro==2)
7272
				seq_printf(seq, " (auto-read-only)");
L
Linus Torvalds 已提交
7273 7274 7275
			seq_printf(seq, " %s", mddev->pers->name);
		}

7276
		sectors = 0;
7277 7278
		rcu_read_lock();
		rdev_for_each_rcu(rdev, mddev) {
L
Linus Torvalds 已提交
7279 7280 7281
			char b[BDEVNAME_SIZE];
			seq_printf(seq, " %s[%d]",
				bdevname(rdev->bdev,b), rdev->desc_nr);
7282 7283
			if (test_bit(WriteMostly, &rdev->flags))
				seq_printf(seq, "(W)");
7284
			if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
7285 7286
				seq_printf(seq, "(F)");
				continue;
7287 7288
			}
			if (rdev->raid_disk < 0)
7289
				seq_printf(seq, "(S)"); /* spare */
7290 7291
			if (test_bit(Replacement, &rdev->flags))
				seq_printf(seq, "(R)");
7292
			sectors += rdev->sectors;
L
Linus Torvalds 已提交
7293
		}
7294
		rcu_read_unlock();
L
Linus Torvalds 已提交
7295 7296 7297 7298

		if (!list_empty(&mddev->disks)) {
			if (mddev->pers)
				seq_printf(seq, "\n      %llu blocks",
7299 7300
					   (unsigned long long)
					   mddev->array_sectors / 2);
L
Linus Torvalds 已提交
7301 7302
			else
				seq_printf(seq, "\n      %llu blocks",
7303
					   (unsigned long long)sectors / 2);
L
Linus Torvalds 已提交
7304
		}
7305 7306 7307 7308 7309 7310 7311
		if (mddev->persistent) {
			if (mddev->major_version != 0 ||
			    mddev->minor_version != 90) {
				seq_printf(seq," super %d.%d",
					   mddev->major_version,
					   mddev->minor_version);
			}
7312 7313 7314 7315
		} else if (mddev->external)
			seq_printf(seq, " super external:%s",
				   mddev->metadata_type);
		else
7316
			seq_printf(seq, " super non-persistent");
L
Linus Torvalds 已提交
7317 7318

		if (mddev->pers) {
7319
			mddev->pers->status(seq, mddev);
7320
			seq_printf(seq, "\n      ");
7321
			if (mddev->pers->sync_request) {
7322
				if (status_resync(seq, mddev))
7323 7324
					seq_printf(seq, "\n      ");
			}
7325 7326 7327
		} else
			seq_printf(seq, "\n       ");

7328
		bitmap_status(seq, mddev->bitmap);
L
Linus Torvalds 已提交
7329 7330 7331

		seq_printf(seq, "\n");
	}
7332
	spin_unlock(&mddev->lock);
7333

L
Linus Torvalds 已提交
7334 7335 7336
	return 0;
}

J
Jan Engelhardt 已提交
7337
static const struct seq_operations md_seq_ops = {
L
Linus Torvalds 已提交
7338 7339 7340 7341 7342 7343 7344 7345
	.start  = md_seq_start,
	.next   = md_seq_next,
	.stop   = md_seq_stop,
	.show   = md_seq_show,
};

static int md_seq_open(struct inode *inode, struct file *file)
{
7346
	struct seq_file *seq;
L
Linus Torvalds 已提交
7347 7348 7349
	int error;

	error = seq_open(file, &md_seq_ops);
7350
	if (error)
7351 7352 7353 7354
		return error;

	seq = file->private_data;
	seq->poll_event = atomic_read(&md_event_count);
L
Linus Torvalds 已提交
7355 7356 7357
	return error;
}

7358
static int md_unloading;
7359 7360
static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
{
7361
	struct seq_file *seq = filp->private_data;
7362 7363
	int mask;

7364
	if (md_unloading)
7365
		return POLLIN|POLLRDNORM|POLLERR|POLLPRI;
7366 7367 7368 7369 7370
	poll_wait(filp, &md_event_waiters, wait);

	/* always allow read */
	mask = POLLIN | POLLRDNORM;

7371
	if (seq->poll_event != atomic_read(&md_event_count))
7372 7373 7374 7375
		mask |= POLLERR | POLLPRI;
	return mask;
}

7376
static const struct file_operations md_seq_fops = {
7377
	.owner		= THIS_MODULE,
L
Linus Torvalds 已提交
7378 7379 7380
	.open           = md_seq_open,
	.read           = seq_read,
	.llseek         = seq_lseek,
7381
	.release	= seq_release_private,
7382
	.poll		= mdstat_poll,
L
Linus Torvalds 已提交
7383 7384
};

7385
int register_md_personality(struct md_personality *p)
L
Linus Torvalds 已提交
7386
{
7387 7388
	printk(KERN_INFO "md: %s personality registered for level %d\n",
						p->name, p->level);
L
Linus Torvalds 已提交
7389
	spin_lock(&pers_lock);
7390
	list_add_tail(&p->list, &pers_list);
L
Linus Torvalds 已提交
7391 7392 7393
	spin_unlock(&pers_lock);
	return 0;
}
7394
EXPORT_SYMBOL(register_md_personality);
L
Linus Torvalds 已提交
7395

7396
int unregister_md_personality(struct md_personality *p)
L
Linus Torvalds 已提交
7397
{
7398
	printk(KERN_INFO "md: %s personality unregistered\n", p->name);
L
Linus Torvalds 已提交
7399
	spin_lock(&pers_lock);
7400
	list_del_init(&p->list);
L
Linus Torvalds 已提交
7401 7402 7403
	spin_unlock(&pers_lock);
	return 0;
}
7404
EXPORT_SYMBOL(unregister_md_personality);
L
Linus Torvalds 已提交
7405

7406 7407
int register_md_cluster_operations(struct md_cluster_operations *ops,
				   struct module *module)
7408
{
7409
	int ret = 0;
7410
	spin_lock(&pers_lock);
7411 7412 7413 7414 7415 7416
	if (md_cluster_ops != NULL)
		ret = -EALREADY;
	else {
		md_cluster_ops = ops;
		md_cluster_mod = module;
	}
7417
	spin_unlock(&pers_lock);
7418
	return ret;
7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437
}
EXPORT_SYMBOL(register_md_cluster_operations);

int unregister_md_cluster_operations(void)
{
	spin_lock(&pers_lock);
	md_cluster_ops = NULL;
	spin_unlock(&pers_lock);
	return 0;
}
EXPORT_SYMBOL(unregister_md_cluster_operations);

int md_setup_cluster(struct mddev *mddev, int nodes)
{
	int err;

	err = request_module("md-cluster");
	if (err) {
		pr_err("md-cluster module not found.\n");
7438
		return -ENOENT;
7439 7440 7441 7442 7443 7444 7445 7446 7447
	}

	spin_lock(&pers_lock);
	if (!md_cluster_ops || !try_module_get(md_cluster_mod)) {
		spin_unlock(&pers_lock);
		return -ENOENT;
	}
	spin_unlock(&pers_lock);

G
Goldwyn Rodrigues 已提交
7448
	return md_cluster_ops->join(mddev, nodes);
7449 7450 7451 7452
}

void md_cluster_stop(struct mddev *mddev)
{
G
Goldwyn Rodrigues 已提交
7453 7454
	if (!md_cluster_ops)
		return;
7455 7456 7457 7458
	md_cluster_ops->leave(mddev);
	module_put(md_cluster_mod);
}

7459
static int is_mddev_idle(struct mddev *mddev, int init)
L
Linus Torvalds 已提交
7460
{
7461
	struct md_rdev *rdev;
L
Linus Torvalds 已提交
7462
	int idle;
N
NeilBrown 已提交
7463
	int curr_events;
L
Linus Torvalds 已提交
7464 7465

	idle = 1;
7466 7467
	rcu_read_lock();
	rdev_for_each_rcu(rdev, mddev) {
L
Linus Torvalds 已提交
7468
		struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
N
NeilBrown 已提交
7469 7470 7471
		curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
			      (int)part_stat_read(&disk->part0, sectors[1]) -
			      atomic_read(&disk->sync_io);
7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491
		/* sync IO will cause sync_io to increase before the disk_stats
		 * as sync_io is counted when a request starts, and
		 * disk_stats is counted when it completes.
		 * So resync activity will cause curr_events to be smaller than
		 * when there was no such activity.
		 * non-sync IO will cause disk_stat to increase without
		 * increasing sync_io so curr_events will (eventually)
		 * be larger than it was before.  Once it becomes
		 * substantially larger, the test below will cause
		 * the array to appear non-idle, and resync will slow
		 * down.
		 * If there is a lot of outstanding resync activity when
		 * we set last_event to curr_events, then all that activity
		 * completing might cause the array to appear non-idle
		 * and resync will be slowed down even though there might
		 * not have been non-resync activity.  This will only
		 * happen once though.  'last_events' will soon reflect
		 * the state where there is little or no outstanding
		 * resync requests, and further resync activity will
		 * always make curr_events less than last_events.
7492
		 *
L
Linus Torvalds 已提交
7493
		 */
N
NeilBrown 已提交
7494
		if (init || curr_events - rdev->last_events > 64) {
L
Linus Torvalds 已提交
7495 7496 7497 7498
			rdev->last_events = curr_events;
			idle = 0;
		}
	}
7499
	rcu_read_unlock();
L
Linus Torvalds 已提交
7500 7501 7502
	return idle;
}

7503
void md_done_sync(struct mddev *mddev, int blocks, int ok)
L
Linus Torvalds 已提交
7504 7505 7506 7507 7508
{
	/* another "blocks" (512byte) blocks have been synced */
	atomic_sub(blocks, &mddev->recovery_active);
	wake_up(&mddev->recovery_wait);
	if (!ok) {
7509
		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7510
		set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
L
Linus Torvalds 已提交
7511 7512 7513 7514
		md_wakeup_thread(mddev->thread);
		// stop recovery, signal do_sync ....
	}
}
7515
EXPORT_SYMBOL(md_done_sync);
L
Linus Torvalds 已提交
7516

7517 7518
/* md_write_start(mddev, bi)
 * If we need to update some array metadata (e.g. 'active' flag
7519 7520
 * in superblock) before writing, schedule a superblock update
 * and wait for it to complete.
7521
 */
7522
void md_write_start(struct mddev *mddev, struct bio *bi)
L
Linus Torvalds 已提交
7523
{
7524
	int did_change = 0;
7525
	if (bio_data_dir(bi) != WRITE)
7526
		return;
7527

7528 7529 7530 7531 7532 7533
	BUG_ON(mddev->ro == 1);
	if (mddev->ro == 2) {
		/* need to switch to read/write */
		mddev->ro = 0;
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
		md_wakeup_thread(mddev->thread);
7534
		md_wakeup_thread(mddev->sync_thread);
7535
		did_change = 1;
7536
	}
7537
	atomic_inc(&mddev->writes_pending);
7538 7539
	if (mddev->safemode == 1)
		mddev->safemode = 0;
7540
	if (mddev->in_sync) {
7541
		spin_lock(&mddev->lock);
7542 7543
		if (mddev->in_sync) {
			mddev->in_sync = 0;
7544
			set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7545
			set_bit(MD_CHANGE_PENDING, &mddev->flags);
7546
			md_wakeup_thread(mddev->thread);
7547
			did_change = 1;
7548
		}
7549
		spin_unlock(&mddev->lock);
7550
	}
7551
	if (did_change)
N
NeilBrown 已提交
7552
		sysfs_notify_dirent_safe(mddev->sysfs_state);
7553 7554
	wait_event(mddev->sb_wait,
		   !test_bit(MD_CHANGE_PENDING, &mddev->flags));
L
Linus Torvalds 已提交
7555
}
7556
EXPORT_SYMBOL(md_write_start);
L
Linus Torvalds 已提交
7557

7558
void md_write_end(struct mddev *mddev)
L
Linus Torvalds 已提交
7559 7560 7561 7562
{
	if (atomic_dec_and_test(&mddev->writes_pending)) {
		if (mddev->safemode == 2)
			md_wakeup_thread(mddev->thread);
7563
		else if (mddev->safemode_delay)
L
Linus Torvalds 已提交
7564 7565 7566
			mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
	}
}
7567
EXPORT_SYMBOL(md_write_end);
L
Linus Torvalds 已提交
7568

7569 7570 7571 7572 7573
/* md_allow_write(mddev)
 * Calling this ensures that the array is marked 'active' so that writes
 * may proceed without blocking.  It is important to call this before
 * attempting a GFP_KERNEL allocation while holding the mddev lock.
 * Must be called with mddev_lock held.
7574 7575 7576
 *
 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
 * is dropped, so return -EAGAIN after notifying userspace.
7577
 */
7578
int md_allow_write(struct mddev *mddev)
7579 7580
{
	if (!mddev->pers)
7581
		return 0;
7582
	if (mddev->ro)
7583
		return 0;
7584
	if (!mddev->pers->sync_request)
7585
		return 0;
7586

7587
	spin_lock(&mddev->lock);
7588 7589 7590
	if (mddev->in_sync) {
		mddev->in_sync = 0;
		set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7591
		set_bit(MD_CHANGE_PENDING, &mddev->flags);
7592 7593 7594
		if (mddev->safemode_delay &&
		    mddev->safemode == 0)
			mddev->safemode = 1;
7595
		spin_unlock(&mddev->lock);
7596 7597
		if (mddev_is_clustered(mddev))
			md_cluster_ops->metadata_update_start(mddev);
7598
		md_update_sb(mddev, 0);
7599 7600
		if (mddev_is_clustered(mddev))
			md_cluster_ops->metadata_update_finish(mddev);
N
NeilBrown 已提交
7601
		sysfs_notify_dirent_safe(mddev->sysfs_state);
7602
	} else
7603
		spin_unlock(&mddev->lock);
7604

7605
	if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
7606 7607 7608
		return -EAGAIN;
	else
		return 0;
7609 7610 7611
}
EXPORT_SYMBOL_GPL(md_allow_write);

L
Linus Torvalds 已提交
7612 7613
#define SYNC_MARKS	10
#define	SYNC_MARK_STEP	(3*HZ)
7614
#define UPDATE_FREQUENCY (5*60*HZ)
S
Shaohua Li 已提交
7615
void md_do_sync(struct md_thread *thread)
L
Linus Torvalds 已提交
7616
{
S
Shaohua Li 已提交
7617
	struct mddev *mddev = thread->mddev;
7618
	struct mddev *mddev2;
L
Linus Torvalds 已提交
7619 7620
	unsigned int currspeed = 0,
		 window;
X
Xiao Ni 已提交
7621
	sector_t max_sectors,j, io_sectors, recovery_done;
L
Linus Torvalds 已提交
7622
	unsigned long mark[SYNC_MARKS];
7623
	unsigned long update_time;
L
Linus Torvalds 已提交
7624 7625 7626 7627
	sector_t mark_cnt[SYNC_MARKS];
	int last_mark,m;
	struct list_head *tmp;
	sector_t last_check;
7628
	int skipped = 0;
7629
	struct md_rdev *rdev;
7630
	char *desc, *action = NULL;
M
majianpeng 已提交
7631
	struct blk_plug plug;
L
Linus Torvalds 已提交
7632 7633 7634 7635

	/* just incase thread restarts... */
	if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
		return;
7636 7637
	if (mddev->ro) {/* never try to sync a read-only array */
		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7638
		return;
7639
	}
L
Linus Torvalds 已提交
7640

7641
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7642
		if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
7643
			desc = "data-check";
7644 7645
			action = "check";
		} else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
7646
			desc = "requested-resync";
7647 7648
			action = "repair";
		} else
7649 7650 7651 7652 7653 7654
			desc = "resync";
	} else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
		desc = "reshape";
	else
		desc = "recovery";

7655 7656
	mddev->last_sync_action = action ?: desc;

L
Linus Torvalds 已提交
7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672 7673 7674 7675 7676
	/* we overload curr_resync somewhat here.
	 * 0 == not engaged in resync at all
	 * 2 == checking that there is no conflict with another sync
	 * 1 == like 2, but have yielded to allow conflicting resync to
	 *		commense
	 * other == active in resync - this many blocks
	 *
	 * Before starting a resync we must have set curr_resync to
	 * 2, and then checked that every "conflicting" array has curr_resync
	 * less than ours.  When we find one that is the same or higher
	 * we wait on resync_wait.  To avoid deadlock, we reduce curr_resync
	 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
	 * This will mean we have to start checking from the beginning again.
	 *
	 */

	do {
		mddev->curr_resync = 2;

	try_again:
7677
		if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
L
Linus Torvalds 已提交
7678
			goto skip;
7679
		for_each_mddev(mddev2, tmp) {
L
Linus Torvalds 已提交
7680 7681
			if (mddev2 == mddev)
				continue;
7682 7683 7684
			if (!mddev->parallel_resync
			&&  mddev2->curr_resync
			&&  match_mddev_units(mddev, mddev2)) {
L
Linus Torvalds 已提交
7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695
				DEFINE_WAIT(wq);
				if (mddev < mddev2 && mddev->curr_resync == 2) {
					/* arbitrarily yield */
					mddev->curr_resync = 1;
					wake_up(&resync_wait);
				}
				if (mddev > mddev2 && mddev->curr_resync == 1)
					/* no need to wait here, we can wait the next
					 * time 'round when curr_resync == 2
					 */
					continue;
7696 7697 7698 7699 7700
				/* We need to wait 'interruptible' so as not to
				 * contribute to the load average, and not to
				 * be caught by 'softlockup'
				 */
				prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
7701
				if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
7702
				    mddev2->curr_resync >= mddev->curr_resync) {
7703 7704
					printk(KERN_INFO "md: delaying %s of %s"
					       " until %s has finished (they"
L
Linus Torvalds 已提交
7705
					       " share one or more physical units)\n",
7706
					       desc, mdname(mddev), mdname(mddev2));
L
Linus Torvalds 已提交
7707
					mddev_put(mddev2);
7708 7709
					if (signal_pending(current))
						flush_signals(current);
L
Linus Torvalds 已提交
7710 7711 7712 7713 7714 7715 7716 7717 7718
					schedule();
					finish_wait(&resync_wait, &wq);
					goto try_again;
				}
				finish_wait(&resync_wait, &wq);
			}
		}
	} while (mddev->curr_resync < 2);

7719
	j = 0;
7720
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
L
Linus Torvalds 已提交
7721
		/* resync follows the size requested by the personality,
7722
		 * which defaults to physical size, but can be virtual size
L
Linus Torvalds 已提交
7723 7724
		 */
		max_sectors = mddev->resync_max_sectors;
7725
		atomic64_set(&mddev->resync_mismatches, 0);
7726
		/* we don't use the checkpoint if there's a bitmap */
7727 7728 7729
		if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
			j = mddev->resync_min;
		else if (!mddev->bitmap)
7730
			j = mddev->recovery_cp;
7731

7732
	} else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7733
		max_sectors = mddev->resync_max_sectors;
7734
	else {
L
Linus Torvalds 已提交
7735
		/* recovery follows the physical size of devices */
A
Andre Noll 已提交
7736
		max_sectors = mddev->dev_sectors;
7737
		j = MaxSector;
7738
		rcu_read_lock();
N
NeilBrown 已提交
7739
		rdev_for_each_rcu(rdev, mddev)
7740 7741 7742 7743 7744
			if (rdev->raid_disk >= 0 &&
			    !test_bit(Faulty, &rdev->flags) &&
			    !test_bit(In_sync, &rdev->flags) &&
			    rdev->recovery_offset < j)
				j = rdev->recovery_offset;
7745
		rcu_read_unlock();
7746 7747 7748 7749 7750 7751 7752 7753 7754 7755 7756 7757 7758

		/* If there is a bitmap, we need to make sure all
		 * writes that started before we added a spare
		 * complete before we start doing a recovery.
		 * Otherwise the write might complete and (via
		 * bitmap_endwrite) set a bit in the bitmap after the
		 * recovery has checked that bit and skipped that
		 * region.
		 */
		if (mddev->bitmap) {
			mddev->pers->quiesce(mddev, 1);
			mddev->pers->quiesce(mddev, 0);
		}
7759
	}
L
Linus Torvalds 已提交
7760

7761 7762 7763
	printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
	printk(KERN_INFO "md: minimum _guaranteed_  speed:"
		" %d KB/sec/disk.\n", speed_min(mddev));
7764
	printk(KERN_INFO "md: using maximum available idle IO bandwidth "
7765 7766
	       "(but not more than %d KB/sec) for %s.\n",
	       speed_max(mddev), desc);
L
Linus Torvalds 已提交
7767

N
NeilBrown 已提交
7768
	is_mddev_idle(mddev, 1); /* this initializes IO event counters */
7769

7770
	io_sectors = 0;
L
Linus Torvalds 已提交
7771 7772
	for (m = 0; m < SYNC_MARKS; m++) {
		mark[m] = jiffies;
7773
		mark_cnt[m] = io_sectors;
L
Linus Torvalds 已提交
7774 7775 7776 7777 7778 7779 7780 7781 7782
	}
	last_mark = 0;
	mddev->resync_mark = mark[last_mark];
	mddev->resync_mark_cnt = mark_cnt[last_mark];

	/*
	 * Tune reconstruction:
	 */
	window = 32*(PAGE_SIZE/512);
J
Jonathan Brassow 已提交
7783 7784
	printk(KERN_INFO "md: using %dk window, over a total of %lluk.\n",
		window/2, (unsigned long long)max_sectors/2);
L
Linus Torvalds 已提交
7785 7786 7787 7788 7789

	atomic_set(&mddev->recovery_active, 0);
	last_check = 0;

	if (j>2) {
7790
		printk(KERN_INFO
7791 7792
		       "md: resuming %s of %s from checkpoint.\n",
		       desc, mdname(mddev));
L
Linus Torvalds 已提交
7793
		mddev->curr_resync = j;
7794 7795
	} else
		mddev->curr_resync = 3; /* no longer delayed */
7796
	mddev->curr_resync_completed = j;
7797 7798
	sysfs_notify(&mddev->kobj, NULL, "sync_completed");
	md_new_event(mddev);
7799
	update_time = jiffies;
L
Linus Torvalds 已提交
7800

7801
	if (mddev_is_clustered(mddev))
7802
		md_cluster_ops->resync_start(mddev, j, max_sectors);
7803

M
majianpeng 已提交
7804
	blk_start_plug(&plug);
L
Linus Torvalds 已提交
7805
	while (j < max_sectors) {
7806
		sector_t sectors;
L
Linus Torvalds 已提交
7807

7808
		skipped = 0;
7809

7810 7811 7812 7813
		if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
		    ((mddev->curr_resync > mddev->curr_resync_completed &&
		      (mddev->curr_resync - mddev->curr_resync_completed)
		      > (max_sectors >> 4)) ||
7814
		     time_after_eq(jiffies, update_time + UPDATE_FREQUENCY) ||
7815
		     (j - mddev->curr_resync_completed)*2
7816 7817
		     >= mddev->resync_max - mddev->curr_resync_completed ||
		     mddev->curr_resync_completed > mddev->resync_max
7818
			    )) {
7819 7820 7821
			/* time to update curr_resync_completed */
			wait_event(mddev->recovery_wait,
				   atomic_read(&mddev->recovery_active) == 0);
7822
			mddev->curr_resync_completed = j;
K
kernelmail 已提交
7823 7824 7825
			if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
			    j > mddev->recovery_cp)
				mddev->recovery_cp = j;
7826
			update_time = jiffies;
7827
			set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7828
			sysfs_notify(&mddev->kobj, NULL, "sync_completed");
7829
		}
7830

7831 7832
		while (j >= mddev->resync_max &&
		       !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
7833 7834 7835 7836 7837 7838 7839
			/* As this condition is controlled by user-space,
			 * we can block indefinitely, so use '_interruptible'
			 * to avoid triggering warnings.
			 */
			flush_signals(current); /* just in case */
			wait_event_interruptible(mddev->recovery_wait,
						 mddev->resync_max > j
7840 7841
						 || test_bit(MD_RECOVERY_INTR,
							     &mddev->recovery));
7842
		}
7843

7844 7845
		if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
			break;
7846

7847
		sectors = mddev->pers->sync_request(mddev, j, &skipped);
7848
		if (sectors == 0) {
7849
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7850
			break;
L
Linus Torvalds 已提交
7851
		}
7852 7853 7854 7855 7856 7857

		if (!skipped) { /* actual IO requested */
			io_sectors += sectors;
			atomic_add(sectors, &mddev->recovery_active);
		}

7858 7859 7860
		if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
			break;

L
Linus Torvalds 已提交
7861
		j += sectors;
7862 7863 7864
		if (j > max_sectors)
			/* when skipping, extra large numbers can be returned. */
			j = max_sectors;
7865 7866
		if (j > 2)
			mddev->curr_resync = j;
7867 7868
		if (mddev_is_clustered(mddev))
			md_cluster_ops->resync_info_update(mddev, j, max_sectors);
7869
		mddev->curr_mark_cnt = io_sectors;
7870
		if (last_check == 0)
7871
			/* this is the earliest that rebuild will be
7872 7873 7874
			 * visible in /proc/mdstat
			 */
			md_new_event(mddev);
7875 7876

		if (last_check + window > io_sectors || j == max_sectors)
L
Linus Torvalds 已提交
7877 7878
			continue;

7879
		last_check = io_sectors;
L
Linus Torvalds 已提交
7880 7881 7882 7883 7884 7885 7886 7887
	repeat:
		if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
			/* step marks */
			int next = (last_mark+1) % SYNC_MARKS;

			mddev->resync_mark = mark[next];
			mddev->resync_mark_cnt = mark_cnt[next];
			mark[next] = jiffies;
7888
			mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
L
Linus Torvalds 已提交
7889 7890 7891
			last_mark = next;
		}

7892 7893
		if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
			break;
L
Linus Torvalds 已提交
7894 7895 7896 7897 7898 7899 7900 7901 7902 7903 7904

		/*
		 * this loop exits only if either when we are slower than
		 * the 'hard' speed limit, or the system was IO-idle for
		 * a jiffy.
		 * the system might be non-idle CPU-wise, but we only care
		 * about not overloading the IO subsystem. (things like an
		 * e2fsck being done on the RAID array should execute fast)
		 */
		cond_resched();

X
Xiao Ni 已提交
7905 7906
		recovery_done = io_sectors - atomic_read(&mddev->recovery_active);
		currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2
7907
			/((jiffies-mddev->resync_mark)/HZ +1) +1;
L
Linus Torvalds 已提交
7908

7909
		if (currspeed > speed_min(mddev)) {
7910
			if (currspeed > speed_max(mddev)) {
7911
				msleep(500);
L
Linus Torvalds 已提交
7912 7913
				goto repeat;
			}
7914 7915 7916 7917 7918 7919 7920 7921
			if (!is_mddev_idle(mddev, 0)) {
				/*
				 * Give other IO more of a chance.
				 * The faster the devices, the less we wait.
				 */
				wait_event(mddev->recovery_wait,
					   !atomic_read(&mddev->recovery_active));
			}
L
Linus Torvalds 已提交
7922 7923
		}
	}
7924 7925 7926
	printk(KERN_INFO "md: %s: %s %s.\n",mdname(mddev), desc,
	       test_bit(MD_RECOVERY_INTR, &mddev->recovery)
	       ? "interrupted" : "done");
L
Linus Torvalds 已提交
7927 7928 7929
	/*
	 * this also signals 'finished resyncing' to md_stop
	 */
M
majianpeng 已提交
7930
	blk_finish_plug(&plug);
L
Linus Torvalds 已提交
7931 7932
	wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));

7933 7934 7935 7936 7937 7938
	if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
	    !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
	    mddev->curr_resync > 2) {
		mddev->curr_resync_completed = mddev->curr_resync;
		sysfs_notify(&mddev->kobj, NULL, "sync_completed");
	}
L
Linus Torvalds 已提交
7939
	/* tell personality that we are finished */
7940
	mddev->pers->sync_request(mddev, max_sectors, &skipped);
L
Linus Torvalds 已提交
7941

7942
	if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
7943 7944 7945 7946 7947
	    mddev->curr_resync > 2) {
		if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
			if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
				if (mddev->curr_resync >= mddev->recovery_cp) {
					printk(KERN_INFO
7948 7949
					       "md: checkpointing %s of %s.\n",
					       desc, mdname(mddev));
7950 7951 7952 7953 7954 7955 7956
					if (test_bit(MD_RECOVERY_ERROR,
						&mddev->recovery))
						mddev->recovery_cp =
							mddev->curr_resync_completed;
					else
						mddev->recovery_cp =
							mddev->curr_resync;
7957 7958 7959 7960 7961 7962
				}
			} else
				mddev->recovery_cp = MaxSector;
		} else {
			if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
				mddev->curr_resync = MaxSector;
7963
			rcu_read_lock();
N
NeilBrown 已提交
7964
			rdev_for_each_rcu(rdev, mddev)
7965
				if (rdev->raid_disk >= 0 &&
7966
				    mddev->delta_disks >= 0 &&
7967 7968 7969 7970
				    !test_bit(Faulty, &rdev->flags) &&
				    !test_bit(In_sync, &rdev->flags) &&
				    rdev->recovery_offset < mddev->curr_resync)
					rdev->recovery_offset = mddev->curr_resync;
7971
			rcu_read_unlock();
7972
		}
L
Linus Torvalds 已提交
7973
	}
7974
 skip:
7975 7976 7977
	if (mddev_is_clustered(mddev))
		md_cluster_ops->resync_finish(mddev);

7978
	set_bit(MD_CHANGE_DEVS, &mddev->flags);
L
Linus Torvalds 已提交
7979

7980
	spin_lock(&mddev->lock);
7981 7982 7983 7984 7985 7986 7987
	if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
		/* We completed so min/max setting can be forgotten if used. */
		if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
			mddev->resync_min = 0;
		mddev->resync_max = MaxSector;
	} else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
		mddev->resync_min = mddev->curr_resync_completed;
7988
	set_bit(MD_RECOVERY_DONE, &mddev->recovery);
L
Linus Torvalds 已提交
7989
	mddev->curr_resync = 0;
7990 7991
	spin_unlock(&mddev->lock);

L
Linus Torvalds 已提交
7992 7993
	wake_up(&resync_wait);
	md_wakeup_thread(mddev->thread);
7994
	return;
L
Linus Torvalds 已提交
7995
}
7996
EXPORT_SYMBOL_GPL(md_do_sync);
L
Linus Torvalds 已提交
7997

7998 7999
static int remove_and_add_spares(struct mddev *mddev,
				 struct md_rdev *this)
8000
{
8001
	struct md_rdev *rdev;
8002
	int spares = 0;
8003
	int removed = 0;
8004

N
NeilBrown 已提交
8005
	rdev_for_each(rdev, mddev)
8006 8007
		if ((this == NULL || rdev == this) &&
		    rdev->raid_disk >= 0 &&
8008
		    !test_bit(Blocked, &rdev->flags) &&
8009 8010 8011 8012
		    (test_bit(Faulty, &rdev->flags) ||
		     ! test_bit(In_sync, &rdev->flags)) &&
		    atomic_read(&rdev->nr_pending)==0) {
			if (mddev->pers->hot_remove_disk(
8013
				    mddev, rdev) == 0) {
8014
				sysfs_unlink_rdev(mddev, rdev);
8015
				rdev->raid_disk = -1;
8016
				removed++;
8017 8018
			}
		}
8019 8020
	if (removed && mddev->kobj.sd)
		sysfs_notify(&mddev->kobj, NULL, "degraded");
8021

8022 8023 8024
	if (this)
		goto no_add;

N
NeilBrown 已提交
8025
	rdev_for_each(rdev, mddev) {
8026 8027 8028 8029
		if (rdev->raid_disk >= 0 &&
		    !test_bit(In_sync, &rdev->flags) &&
		    !test_bit(Faulty, &rdev->flags))
			spares++;
8030 8031 8032 8033 8034
		if (rdev->raid_disk >= 0)
			continue;
		if (test_bit(Faulty, &rdev->flags))
			continue;
		if (mddev->ro &&
8035 8036
		    ! (rdev->saved_raid_disk >= 0 &&
		       !test_bit(Bitmap_sync, &rdev->flags)))
8037 8038
			continue;

8039 8040
		if (rdev->saved_raid_disk < 0)
			rdev->recovery_offset = 0;
8041 8042 8043 8044 8045 8046 8047
		if (mddev->pers->
		    hot_add_disk(mddev, rdev) == 0) {
			if (sysfs_link_rdev(mddev, rdev))
				/* failure here is OK */;
			spares++;
			md_new_event(mddev);
			set_bit(MD_CHANGE_DEVS, &mddev->flags);
8048
		}
8049
	}
8050
no_add:
8051 8052
	if (removed)
		set_bit(MD_CHANGE_DEVS, &mddev->flags);
8053 8054
	return spares;
}
8055

8056 8057 8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071 8072
static void md_start_sync(struct work_struct *ws)
{
	struct mddev *mddev = container_of(ws, struct mddev, del_work);

	mddev->sync_thread = md_register_thread(md_do_sync,
						mddev,
						"resync");
	if (!mddev->sync_thread) {
		printk(KERN_ERR "%s: could not start resync"
		       " thread...\n",
		       mdname(mddev));
		/* leave the spares where they are, it shouldn't hurt */
		clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
		clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
		clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
		clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
		clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8073
		wake_up(&resync_wait);
8074 8075 8076 8077 8078 8079 8080 8081 8082 8083
		if (test_and_clear_bit(MD_RECOVERY_RECOVER,
				       &mddev->recovery))
			if (mddev->sysfs_action)
				sysfs_notify_dirent_safe(mddev->sysfs_action);
	} else
		md_wakeup_thread(mddev->sync_thread);
	sysfs_notify_dirent_safe(mddev->sysfs_action);
	md_new_event(mddev);
}

L
Linus Torvalds 已提交
8084 8085 8086 8087 8088 8089 8090 8091 8092 8093
/*
 * This routine is regularly called by all per-raid-array threads to
 * deal with generic issues like resync and super-block update.
 * Raid personalities that don't have a thread (linear/raid0) do not
 * need this as they never do any recovery or update the superblock.
 *
 * It does not do any resync itself, but rather "forks" off other threads
 * to do that as needed.
 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
 * "->recovery" and create a thread at ->sync_thread.
8094
 * When the thread finishes it sets MD_RECOVERY_DONE
L
Linus Torvalds 已提交
8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105
 * and wakeups up this thread which will reap the thread and finish up.
 * This thread also removes any faulty devices (with nr_pending == 0).
 *
 * The overall approach is:
 *  1/ if the superblock needs updating, update it.
 *  2/ If a recovery thread is running, don't do anything else.
 *  3/ If recovery has finished, clean up, possibly marking spares active.
 *  4/ If there are any faulty devices, remove them.
 *  5/ If array is degraded, try to add spares devices
 *  6/ If array has spares or is not in-sync, start a resync thread.
 */
8106
void md_check_recovery(struct mddev *mddev)
L
Linus Torvalds 已提交
8107
{
8108 8109 8110
	if (mddev->suspended)
		return;

8111
	if (mddev->bitmap)
8112
		bitmap_daemon_work(mddev);
L
Linus Torvalds 已提交
8113

8114
	if (signal_pending(current)) {
8115
		if (mddev->pers->sync_request && !mddev->external) {
8116 8117 8118 8119 8120 8121 8122
			printk(KERN_INFO "md: %s in immediate safe mode\n",
			       mdname(mddev));
			mddev->safemode = 2;
		}
		flush_signals(current);
	}

8123 8124
	if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
		return;
L
Linus Torvalds 已提交
8125
	if ( ! (
8126
		(mddev->flags & MD_UPDATE_SB_FLAGS & ~ (1<<MD_CHANGE_PENDING)) ||
L
Linus Torvalds 已提交
8127
		test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
8128
		test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
8129
		(mddev->external == 0 && mddev->safemode == 1) ||
8130 8131
		(mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
		 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
L
Linus Torvalds 已提交
8132 8133
		))
		return;
8134

8135
	if (mddev_trylock(mddev)) {
8136
		int spares = 0;
8137

8138
		if (mddev->ro) {
8139 8140 8141 8142 8143 8144 8145 8146 8147
			struct md_rdev *rdev;
			if (!mddev->external && mddev->in_sync)
				/* 'Blocked' flag not needed as failed devices
				 * will be recorded if array switched to read/write.
				 * Leaving it set will prevent the device
				 * from being removed.
				 */
				rdev_for_each(rdev, mddev)
					clear_bit(Blocked, &rdev->flags);
8148 8149 8150 8151 8152 8153
			/* On a read-only array we can:
			 * - remove failed devices
			 * - add already-in_sync devices if the array itself
			 *   is in-sync.
			 * As we only add devices that are already in-sync,
			 * we can activate the spares immediately.
8154
			 */
8155
			remove_and_add_spares(mddev, NULL);
8156 8157 8158
			/* There is no thread, but we need to call
			 * ->spare_active and clear saved_raid_disk
			 */
8159
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8160
			md_reap_sync_thread(mddev);
8161
			clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8162
			clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8163
			clear_bit(MD_CHANGE_PENDING, &mddev->flags);
8164 8165 8166
			goto unlock;
		}

8167
		if (!mddev->external) {
8168
			int did_change = 0;
8169
			spin_lock(&mddev->lock);
8170 8171 8172 8173 8174
			if (mddev->safemode &&
			    !atomic_read(&mddev->writes_pending) &&
			    !mddev->in_sync &&
			    mddev->recovery_cp == MaxSector) {
				mddev->in_sync = 1;
8175
				did_change = 1;
8176
				set_bit(MD_CHANGE_CLEAN, &mddev->flags);
8177 8178 8179
			}
			if (mddev->safemode == 1)
				mddev->safemode = 0;
8180
			spin_unlock(&mddev->lock);
8181
			if (did_change)
N
NeilBrown 已提交
8182
				sysfs_notify_dirent_safe(mddev->sysfs_state);
8183 8184
		}

8185 8186 8187
		if (mddev->flags & MD_UPDATE_SB_FLAGS) {
			if (mddev_is_clustered(mddev))
				md_cluster_ops->metadata_update_start(mddev);
8188
			md_update_sb(mddev, 0);
8189 8190 8191
			if (mddev_is_clustered(mddev))
				md_cluster_ops->metadata_update_finish(mddev);
		}
8192

L
Linus Torvalds 已提交
8193 8194 8195 8196 8197 8198 8199
		if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
		    !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
			/* resync/recovery still happening */
			clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
			goto unlock;
		}
		if (mddev->sync_thread) {
8200
			md_reap_sync_thread(mddev);
L
Linus Torvalds 已提交
8201 8202
			goto unlock;
		}
8203 8204 8205
		/* Set RUNNING before clearing NEEDED to avoid
		 * any transients in the value of "sync_action".
		 */
8206
		mddev->curr_resync_completed = 0;
8207
		spin_lock(&mddev->lock);
8208
		set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8209
		spin_unlock(&mddev->lock);
8210 8211 8212 8213 8214
		/* Clear some bits that don't mean anything, but
		 * might be left set
		 */
		clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
		clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
L
Linus Torvalds 已提交
8215

8216 8217
		if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
		    test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
8218
			goto not_running;
L
Linus Torvalds 已提交
8219 8220 8221
		/* no recovery is running.
		 * remove any failed drives, then
		 * add spares if possible.
8222
		 * Spares are also removed and re-added, to allow
L
Linus Torvalds 已提交
8223 8224 8225
		 * the personality to fail the re-add.
		 */

8226
		if (mddev->reshape_position != MaxSector) {
8227 8228
			if (mddev->pers->check_reshape == NULL ||
			    mddev->pers->check_reshape(mddev) != 0)
8229
				/* Cannot proceed */
8230
				goto not_running;
8231
			set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8232
			clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8233
		} else if ((spares = remove_and_add_spares(mddev, NULL))) {
8234 8235
			clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
			clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8236
			clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
8237
			set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8238 8239
		} else if (mddev->recovery_cp < MaxSector) {
			set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8240
			clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8241 8242
		} else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
			/* nothing to be done ... */
8243
			goto not_running;
8244

L
Linus Torvalds 已提交
8245
		if (mddev->pers->sync_request) {
8246
			if (spares) {
8247 8248 8249 8250 8251 8252
				/* We are adding a device or devices to an array
				 * which has the bitmap stored on all devices.
				 * So make sure all bitmap pages get written
				 */
				bitmap_write_all(mddev->bitmap);
			}
8253 8254 8255
			INIT_WORK(&mddev->del_work, md_start_sync);
			queue_work(md_misc_wq, &mddev->del_work);
			goto unlock;
L
Linus Torvalds 已提交
8256
		}
8257
	not_running:
8258 8259
		if (!mddev->sync_thread) {
			clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8260
			wake_up(&resync_wait);
8261 8262
			if (test_and_clear_bit(MD_RECOVERY_RECOVER,
					       &mddev->recovery))
8263
				if (mddev->sysfs_action)
N
NeilBrown 已提交
8264
					sysfs_notify_dirent_safe(mddev->sysfs_action);
8265
		}
8266 8267
	unlock:
		wake_up(&mddev->sb_wait);
L
Linus Torvalds 已提交
8268 8269 8270
		mddev_unlock(mddev);
	}
}
8271
EXPORT_SYMBOL(md_check_recovery);
L
Linus Torvalds 已提交
8272

8273 8274 8275 8276 8277 8278 8279 8280 8281 8282 8283 8284 8285 8286 8287 8288
void md_reap_sync_thread(struct mddev *mddev)
{
	struct md_rdev *rdev;

	/* resync has finished, collect result */
	md_unregister_thread(&mddev->sync_thread);
	if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
	    !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
		/* success...*/
		/* activate any spares */
		if (mddev->pers->spare_active(mddev)) {
			sysfs_notify(&mddev->kobj, NULL,
				     "degraded");
			set_bit(MD_CHANGE_DEVS, &mddev->flags);
		}
	}
8289 8290
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_start(mddev);
8291 8292 8293 8294 8295
	if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
	    mddev->pers->finish_reshape)
		mddev->pers->finish_reshape(mddev);

	/* If array is no-longer degraded, then any saved_raid_disk
8296
	 * information must be scrapped.
8297
	 */
8298 8299
	if (!mddev->degraded)
		rdev_for_each(rdev, mddev)
8300 8301 8302
			rdev->saved_raid_disk = -1;

	md_update_sb(mddev, 1);
8303 8304
	if (mddev_is_clustered(mddev))
		md_cluster_ops->metadata_update_finish(mddev);
8305
	clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8306
	clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
8307 8308 8309 8310
	clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
	clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
	clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
	clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8311
	wake_up(&resync_wait);
8312 8313 8314 8315 8316 8317 8318
	/* flag recovery needed just to double check */
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	sysfs_notify_dirent_safe(mddev->sysfs_action);
	md_new_event(mddev);
	if (mddev->event_work.func)
		queue_work(md_misc_wq, &mddev->event_work);
}
8319
EXPORT_SYMBOL(md_reap_sync_thread);
8320

8321
void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
8322
{
N
NeilBrown 已提交
8323
	sysfs_notify_dirent_safe(rdev->sysfs_state);
8324
	wait_event_timeout(rdev->blocked_wait,
8325 8326
			   !test_bit(Blocked, &rdev->flags) &&
			   !test_bit(BlockedBadBlocks, &rdev->flags),
8327 8328 8329 8330 8331
			   msecs_to_jiffies(5000));
	rdev_dec_pending(rdev, mddev);
}
EXPORT_SYMBOL(md_wait_for_blocked_rdev);

8332 8333 8334 8335 8336 8337 8338 8339 8340 8341 8342 8343 8344 8345
void md_finish_reshape(struct mddev *mddev)
{
	/* called be personality module when reshape completes. */
	struct md_rdev *rdev;

	rdev_for_each(rdev, mddev) {
		if (rdev->data_offset > rdev->new_data_offset)
			rdev->sectors += rdev->data_offset - rdev->new_data_offset;
		else
			rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
		rdev->data_offset = rdev->new_data_offset;
	}
}
EXPORT_SYMBOL(md_finish_reshape);
8346 8347 8348 8349 8350 8351 8352 8353 8354 8355 8356 8357 8358 8359 8360 8361 8362 8363 8364 8365 8366 8367 8368 8369 8370 8371 8372 8373 8374 8375 8376

/* Bad block management.
 * We can record which blocks on each device are 'bad' and so just
 * fail those blocks, or that stripe, rather than the whole device.
 * Entries in the bad-block table are 64bits wide.  This comprises:
 * Length of bad-range, in sectors: 0-511 for lengths 1-512
 * Start of bad-range, sector offset, 54 bits (allows 8 exbibytes)
 *  A 'shift' can be set so that larger blocks are tracked and
 *  consequently larger devices can be covered.
 * 'Acknowledged' flag - 1 bit. - the most significant bit.
 *
 * Locking of the bad-block table uses a seqlock so md_is_badblock
 * might need to retry if it is very unlucky.
 * We will sometimes want to check for bad blocks in a bi_end_io function,
 * so we use the write_seqlock_irq variant.
 *
 * When looking for a bad block we specify a range and want to
 * know if any block in the range is bad.  So we binary-search
 * to the last range that starts at-or-before the given endpoint,
 * (or "before the sector after the target range")
 * then see if it ends after the given start.
 * We return
 *  0 if there are no known bad blocks in the range
 *  1 if there are known bad block which are all acknowledged
 * -1 if there are bad blocks which have not yet been acknowledged in metadata.
 * plus the start/length of the first bad section we overlap.
 */
int md_is_badblock(struct badblocks *bb, sector_t s, int sectors,
		   sector_t *first_bad, int *bad_sectors)
{
	int hi;
8377
	int lo;
8378
	u64 *p = bb->page;
8379
	int rv;
8380 8381 8382 8383 8384 8385 8386 8387 8388 8389 8390 8391 8392 8393
	sector_t target = s + sectors;
	unsigned seq;

	if (bb->shift > 0) {
		/* round the start down, and the end up */
		s >>= bb->shift;
		target += (1<<bb->shift) - 1;
		target >>= bb->shift;
		sectors = target - s;
	}
	/* 'target' is now the first block after the bad range */

retry:
	seq = read_seqbegin(&bb->lock);
8394 8395
	lo = 0;
	rv = 0;
8396 8397 8398 8399 8400 8401 8402 8403 8404 8405 8406 8407 8408 8409 8410 8411 8412 8413 8414 8415 8416 8417 8418 8419 8420 8421 8422 8423 8424 8425 8426 8427 8428 8429 8430 8431 8432 8433 8434 8435 8436 8437 8438 8439 8440 8441 8442 8443 8444 8445 8446 8447 8448 8449 8450 8451 8452 8453 8454 8455 8456 8457 8458
	hi = bb->count;

	/* Binary search between lo and hi for 'target'
	 * i.e. for the last range that starts before 'target'
	 */
	/* INVARIANT: ranges before 'lo' and at-or-after 'hi'
	 * are known not to be the last range before target.
	 * VARIANT: hi-lo is the number of possible
	 * ranges, and decreases until it reaches 1
	 */
	while (hi - lo > 1) {
		int mid = (lo + hi) / 2;
		sector_t a = BB_OFFSET(p[mid]);
		if (a < target)
			/* This could still be the one, earlier ranges
			 * could not. */
			lo = mid;
		else
			/* This and later ranges are definitely out. */
			hi = mid;
	}
	/* 'lo' might be the last that started before target, but 'hi' isn't */
	if (hi > lo) {
		/* need to check all range that end after 's' to see if
		 * any are unacknowledged.
		 */
		while (lo >= 0 &&
		       BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > s) {
			if (BB_OFFSET(p[lo]) < target) {
				/* starts before the end, and finishes after
				 * the start, so they must overlap
				 */
				if (rv != -1 && BB_ACK(p[lo]))
					rv = 1;
				else
					rv = -1;
				*first_bad = BB_OFFSET(p[lo]);
				*bad_sectors = BB_LEN(p[lo]);
			}
			lo--;
		}
	}

	if (read_seqretry(&bb->lock, seq))
		goto retry;

	return rv;
}
EXPORT_SYMBOL_GPL(md_is_badblock);

/*
 * Add a range of bad blocks to the table.
 * This might extend the table, or might contract it
 * if two adjacent ranges can be merged.
 * We binary-search to find the 'insertion' point, then
 * decide how best to handle it.
 */
static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
			    int acknowledged)
{
	u64 *p;
	int lo, hi;
	int rv = 1;
8459
	unsigned long flags;
8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470 8471 8472 8473

	if (bb->shift < 0)
		/* badblocks are disabled */
		return 0;

	if (bb->shift) {
		/* round the start down, and the end up */
		sector_t next = s + sectors;
		s >>= bb->shift;
		next += (1<<bb->shift) - 1;
		next >>= bb->shift;
		sectors = next - s;
	}

8474
	write_seqlock_irqsave(&bb->lock, flags);
8475 8476 8477 8478 8479 8480 8481 8482 8483 8484 8485 8486 8487 8488 8489 8490 8491 8492 8493 8494 8495 8496 8497 8498 8499 8500 8501 8502 8503 8504 8505 8506 8507 8508 8509 8510 8511 8512 8513 8514 8515 8516 8517 8518 8519 8520 8521 8522 8523 8524 8525 8526 8527 8528 8529 8530 8531 8532 8533 8534 8535 8536 8537 8538 8539 8540 8541 8542 8543 8544 8545 8546 8547 8548 8549 8550 8551 8552 8553 8554 8555 8556 8557 8558 8559 8560 8561 8562 8563 8564 8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580 8581 8582 8583 8584 8585 8586 8587

	p = bb->page;
	lo = 0;
	hi = bb->count;
	/* Find the last range that starts at-or-before 's' */
	while (hi - lo > 1) {
		int mid = (lo + hi) / 2;
		sector_t a = BB_OFFSET(p[mid]);
		if (a <= s)
			lo = mid;
		else
			hi = mid;
	}
	if (hi > lo && BB_OFFSET(p[lo]) > s)
		hi = lo;

	if (hi > lo) {
		/* we found a range that might merge with the start
		 * of our new range
		 */
		sector_t a = BB_OFFSET(p[lo]);
		sector_t e = a + BB_LEN(p[lo]);
		int ack = BB_ACK(p[lo]);
		if (e >= s) {
			/* Yes, we can merge with a previous range */
			if (s == a && s + sectors >= e)
				/* new range covers old */
				ack = acknowledged;
			else
				ack = ack && acknowledged;

			if (e < s + sectors)
				e = s + sectors;
			if (e - a <= BB_MAX_LEN) {
				p[lo] = BB_MAKE(a, e-a, ack);
				s = e;
			} else {
				/* does not all fit in one range,
				 * make p[lo] maximal
				 */
				if (BB_LEN(p[lo]) != BB_MAX_LEN)
					p[lo] = BB_MAKE(a, BB_MAX_LEN, ack);
				s = a + BB_MAX_LEN;
			}
			sectors = e - s;
		}
	}
	if (sectors && hi < bb->count) {
		/* 'hi' points to the first range that starts after 's'.
		 * Maybe we can merge with the start of that range */
		sector_t a = BB_OFFSET(p[hi]);
		sector_t e = a + BB_LEN(p[hi]);
		int ack = BB_ACK(p[hi]);
		if (a <= s + sectors) {
			/* merging is possible */
			if (e <= s + sectors) {
				/* full overlap */
				e = s + sectors;
				ack = acknowledged;
			} else
				ack = ack && acknowledged;

			a = s;
			if (e - a <= BB_MAX_LEN) {
				p[hi] = BB_MAKE(a, e-a, ack);
				s = e;
			} else {
				p[hi] = BB_MAKE(a, BB_MAX_LEN, ack);
				s = a + BB_MAX_LEN;
			}
			sectors = e - s;
			lo = hi;
			hi++;
		}
	}
	if (sectors == 0 && hi < bb->count) {
		/* we might be able to combine lo and hi */
		/* Note: 's' is at the end of 'lo' */
		sector_t a = BB_OFFSET(p[hi]);
		int lolen = BB_LEN(p[lo]);
		int hilen = BB_LEN(p[hi]);
		int newlen = lolen + hilen - (s - a);
		if (s >= a && newlen < BB_MAX_LEN) {
			/* yes, we can combine them */
			int ack = BB_ACK(p[lo]) && BB_ACK(p[hi]);
			p[lo] = BB_MAKE(BB_OFFSET(p[lo]), newlen, ack);
			memmove(p + hi, p + hi + 1,
				(bb->count - hi - 1) * 8);
			bb->count--;
		}
	}
	while (sectors) {
		/* didn't merge (it all).
		 * Need to add a range just before 'hi' */
		if (bb->count >= MD_MAX_BADBLOCKS) {
			/* No room for more */
			rv = 0;
			break;
		} else {
			int this_sectors = sectors;
			memmove(p + hi + 1, p + hi,
				(bb->count - hi) * 8);
			bb->count++;

			if (this_sectors > BB_MAX_LEN)
				this_sectors = BB_MAX_LEN;
			p[hi] = BB_MAKE(s, this_sectors, acknowledged);
			sectors -= this_sectors;
			s += this_sectors;
		}
	}

	bb->changed = 1;
8588 8589
	if (!acknowledged)
		bb->unacked_exist = 1;
8590
	write_sequnlock_irqrestore(&bb->lock, flags);
8591 8592 8593 8594

	return rv;
}

8595
int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
8596
		       int is_new)
8597
{
8598 8599 8600 8601 8602 8603 8604
	int rv;
	if (is_new)
		s += rdev->new_data_offset;
	else
		s += rdev->data_offset;
	rv = md_set_badblocks(&rdev->badblocks,
			      s, sectors, 0);
8605 8606
	if (rv) {
		/* Make sure they get written out promptly */
8607
		sysfs_notify_dirent_safe(rdev->sysfs_state);
8608
		set_bit(MD_CHANGE_CLEAN, &rdev->mddev->flags);
8609
		set_bit(MD_CHANGE_PENDING, &rdev->mddev->flags);
8610 8611 8612 8613 8614 8615 8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627 8628 8629 8630 8631 8632 8633 8634 8635 8636 8637 8638 8639 8640 8641 8642 8643 8644 8645 8646 8647 8648 8649 8650 8651 8652 8653 8654 8655 8656 8657 8658 8659 8660 8661 8662 8663 8664 8665 8666 8667 8668 8669
		md_wakeup_thread(rdev->mddev->thread);
	}
	return rv;
}
EXPORT_SYMBOL_GPL(rdev_set_badblocks);

/*
 * Remove a range of bad blocks from the table.
 * This may involve extending the table if we spilt a region,
 * but it must not fail.  So if the table becomes full, we just
 * drop the remove request.
 */
static int md_clear_badblocks(struct badblocks *bb, sector_t s, int sectors)
{
	u64 *p;
	int lo, hi;
	sector_t target = s + sectors;
	int rv = 0;

	if (bb->shift > 0) {
		/* When clearing we round the start up and the end down.
		 * This should not matter as the shift should align with
		 * the block size and no rounding should ever be needed.
		 * However it is better the think a block is bad when it
		 * isn't than to think a block is not bad when it is.
		 */
		s += (1<<bb->shift) - 1;
		s >>= bb->shift;
		target >>= bb->shift;
		sectors = target - s;
	}

	write_seqlock_irq(&bb->lock);

	p = bb->page;
	lo = 0;
	hi = bb->count;
	/* Find the last range that starts before 'target' */
	while (hi - lo > 1) {
		int mid = (lo + hi) / 2;
		sector_t a = BB_OFFSET(p[mid]);
		if (a < target)
			lo = mid;
		else
			hi = mid;
	}
	if (hi > lo) {
		/* p[lo] is the last range that could overlap the
		 * current range.  Earlier ranges could also overlap,
		 * but only this one can overlap the end of the range.
		 */
		if (BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > target) {
			/* Partial overlap, leave the tail of this range */
			int ack = BB_ACK(p[lo]);
			sector_t a = BB_OFFSET(p[lo]);
			sector_t end = a + BB_LEN(p[lo]);

			if (a < s) {
				/* we need to split this range */
				if (bb->count >= MD_MAX_BADBLOCKS) {
8670
					rv = -ENOSPC;
8671 8672 8673 8674 8675 8676 8677 8678 8679 8680 8681 8682 8683 8684 8685 8686 8687 8688 8689 8690 8691 8692 8693 8694 8695 8696 8697 8698 8699 8700 8701 8702 8703 8704 8705 8706 8707 8708 8709 8710
					goto out;
				}
				memmove(p+lo+1, p+lo, (bb->count - lo) * 8);
				bb->count++;
				p[lo] = BB_MAKE(a, s-a, ack);
				lo++;
			}
			p[lo] = BB_MAKE(target, end - target, ack);
			/* there is no longer an overlap */
			hi = lo;
			lo--;
		}
		while (lo >= 0 &&
		       BB_OFFSET(p[lo]) + BB_LEN(p[lo]) > s) {
			/* This range does overlap */
			if (BB_OFFSET(p[lo]) < s) {
				/* Keep the early parts of this range. */
				int ack = BB_ACK(p[lo]);
				sector_t start = BB_OFFSET(p[lo]);
				p[lo] = BB_MAKE(start, s - start, ack);
				/* now low doesn't overlap, so.. */
				break;
			}
			lo--;
		}
		/* 'lo' is strictly before, 'hi' is strictly after,
		 * anything between needs to be discarded
		 */
		if (hi - lo > 1) {
			memmove(p+lo+1, p+hi, (bb->count - hi) * 8);
			bb->count -= (hi - lo - 1);
		}
	}

	bb->changed = 1;
out:
	write_sequnlock_irq(&bb->lock);
	return rv;
}

8711 8712
int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
			 int is_new)
8713
{
8714 8715 8716 8717
	if (is_new)
		s += rdev->new_data_offset;
	else
		s += rdev->data_offset;
8718
	return md_clear_badblocks(&rdev->badblocks,
8719
				  s, sectors);
8720 8721 8722 8723 8724 8725 8726 8727 8728 8729 8730 8731 8732 8733 8734
}
EXPORT_SYMBOL_GPL(rdev_clear_badblocks);

/*
 * Acknowledge all bad blocks in a list.
 * This only succeeds if ->changed is clear.  It is used by
 * in-kernel metadata updates
 */
void md_ack_all_badblocks(struct badblocks *bb)
{
	if (bb->page == NULL || bb->changed)
		/* no point even trying */
		return;
	write_seqlock_irq(&bb->lock);

8735
	if (bb->changed == 0 && bb->unacked_exist) {
8736 8737 8738 8739 8740 8741 8742 8743 8744
		u64 *p = bb->page;
		int i;
		for (i = 0; i < bb->count ; i++) {
			if (!BB_ACK(p[i])) {
				sector_t start = BB_OFFSET(p[i]);
				int len = BB_LEN(p[i]);
				p[i] = BB_MAKE(start, len, 1);
			}
		}
8745
		bb->unacked_exist = 0;
8746 8747 8748 8749 8750
	}
	write_sequnlock_irq(&bb->lock);
}
EXPORT_SYMBOL_GPL(md_ack_all_badblocks);

8751 8752 8753 8754 8755 8756 8757 8758 8759 8760 8761 8762 8763 8764 8765 8766 8767 8768 8769 8770 8771 8772 8773 8774 8775 8776 8777 8778 8779 8780 8781 8782 8783 8784 8785 8786 8787 8788 8789 8790 8791 8792
/* sysfs access to bad-blocks list.
 * We present two files.
 * 'bad-blocks' lists sector numbers and lengths of ranges that
 *    are recorded as bad.  The list is truncated to fit within
 *    the one-page limit of sysfs.
 *    Writing "sector length" to this file adds an acknowledged
 *    bad block list.
 * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
 *    been acknowledged.  Writing to this file adds bad blocks
 *    without acknowledging them.  This is largely for testing.
 */

static ssize_t
badblocks_show(struct badblocks *bb, char *page, int unack)
{
	size_t len;
	int i;
	u64 *p = bb->page;
	unsigned seq;

	if (bb->shift < 0)
		return 0;

retry:
	seq = read_seqbegin(&bb->lock);

	len = 0;
	i = 0;

	while (len < PAGE_SIZE && i < bb->count) {
		sector_t s = BB_OFFSET(p[i]);
		unsigned int length = BB_LEN(p[i]);
		int ack = BB_ACK(p[i]);
		i++;

		if (unack && ack)
			continue;

		len += snprintf(page+len, PAGE_SIZE-len, "%llu %u\n",
				(unsigned long long)s << bb->shift,
				length << bb->shift);
	}
8793 8794
	if (unack && len == 0)
		bb->unacked_exist = 0;
8795 8796 8797 8798 8799 8800 8801 8802 8803 8804 8805 8806 8807 8808 8809 8810 8811 8812 8813 8814 8815 8816 8817 8818 8819 8820 8821 8822 8823 8824 8825 8826 8827 8828 8829 8830 8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841 8842 8843 8844

	if (read_seqretry(&bb->lock, seq))
		goto retry;

	return len;
}

#define DO_DEBUG 1

static ssize_t
badblocks_store(struct badblocks *bb, const char *page, size_t len, int unack)
{
	unsigned long long sector;
	int length;
	char newline;
#ifdef DO_DEBUG
	/* Allow clearing via sysfs *only* for testing/debugging.
	 * Normally only a successful write may clear a badblock
	 */
	int clear = 0;
	if (page[0] == '-') {
		clear = 1;
		page++;
	}
#endif /* DO_DEBUG */

	switch (sscanf(page, "%llu %d%c", &sector, &length, &newline)) {
	case 3:
		if (newline != '\n')
			return -EINVAL;
	case 2:
		if (length <= 0)
			return -EINVAL;
		break;
	default:
		return -EINVAL;
	}

#ifdef DO_DEBUG
	if (clear) {
		md_clear_badblocks(bb, sector, length);
		return len;
	}
#endif /* DO_DEBUG */
	if (md_set_badblocks(bb, sector, length, !unack))
		return len;
	else
		return -ENOSPC;
}

A
Adrian Bunk 已提交
8845 8846
static int md_notify_reboot(struct notifier_block *this,
			    unsigned long code, void *x)
L
Linus Torvalds 已提交
8847 8848
{
	struct list_head *tmp;
8849
	struct mddev *mddev;
8850
	int need_delay = 0;
L
Linus Torvalds 已提交
8851

8852 8853
	for_each_mddev(mddev, tmp) {
		if (mddev_trylock(mddev)) {
8854 8855
			if (mddev->pers)
				__md_stop_writes(mddev);
8856 8857
			if (mddev->persistent)
				mddev->safemode = 2;
8858
			mddev_unlock(mddev);
8859
		}
8860
		need_delay = 1;
L
Linus Torvalds 已提交
8861
	}
8862 8863 8864 8865 8866 8867 8868 8869 8870
	/*
	 * certain more exotic SCSI devices are known to be
	 * volatile wrt too early system reboots. While the
	 * right place to handle this issue is the given
	 * driver, we do want to have a safe RAID driver ...
	 */
	if (need_delay)
		mdelay(1000*1);

L
Linus Torvalds 已提交
8871 8872 8873
	return NOTIFY_DONE;
}

A
Adrian Bunk 已提交
8874
static struct notifier_block md_notifier = {
L
Linus Torvalds 已提交
8875 8876 8877 8878 8879 8880 8881
	.notifier_call	= md_notify_reboot,
	.next		= NULL,
	.priority	= INT_MAX, /* before any real devices */
};

static void md_geninit(void)
{
8882
	pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
L
Linus Torvalds 已提交
8883

8884
	proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
L
Linus Torvalds 已提交
8885 8886
}

A
Adrian Bunk 已提交
8887
static int __init md_init(void)
L
Linus Torvalds 已提交
8888
{
T
Tejun Heo 已提交
8889 8890
	int ret = -ENOMEM;

8891
	md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
T
Tejun Heo 已提交
8892 8893 8894 8895 8896 8897 8898 8899 8900 8901 8902 8903 8904 8905
	if (!md_wq)
		goto err_wq;

	md_misc_wq = alloc_workqueue("md_misc", 0, 0);
	if (!md_misc_wq)
		goto err_misc_wq;

	if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
		goto err_md;

	if ((ret = register_blkdev(0, "mdp")) < 0)
		goto err_mdp;
	mdp_major = ret;

8906
	blk_register_region(MKDEV(MD_MAJOR, 0), 512, THIS_MODULE,
8907 8908
			    md_probe, NULL, NULL);
	blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
L
Linus Torvalds 已提交
8909 8910 8911
			    md_probe, NULL, NULL);

	register_reboot_notifier(&md_notifier);
8912
	raid_table_header = register_sysctl_table(raid_root_table);
L
Linus Torvalds 已提交
8913 8914

	md_geninit();
8915
	return 0;
L
Linus Torvalds 已提交
8916

T
Tejun Heo 已提交
8917 8918 8919 8920 8921 8922 8923 8924 8925
err_mdp:
	unregister_blkdev(MD_MAJOR, "md");
err_md:
	destroy_workqueue(md_misc_wq);
err_misc_wq:
	destroy_workqueue(md_wq);
err_wq:
	return ret;
}
L
Linus Torvalds 已提交
8926

8927 8928 8929 8930 8931 8932 8933 8934 8935 8936 8937 8938 8939 8940 8941 8942 8943 8944 8945 8946 8947 8948
void md_reload_sb(struct mddev *mddev)
{
	struct md_rdev *rdev, *tmp;

	rdev_for_each_safe(rdev, tmp, mddev) {
		rdev->sb_loaded = 0;
		ClearPageUptodate(rdev->sb_page);
	}
	mddev->raid_disks = 0;
	analyze_sbs(mddev);
	rdev_for_each_safe(rdev, tmp, mddev) {
		struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
		/* since we don't write to faulty devices, we figure out if the
		 *  disk is faulty by comparing events
		 */
		if (mddev->events > sb->events)
			set_bit(Faulty, &rdev->flags);
	}

}
EXPORT_SYMBOL(md_reload_sb);

L
Linus Torvalds 已提交
8949 8950 8951 8952 8953 8954
#ifndef MODULE

/*
 * Searches all registered partitions for autorun RAID arrays
 * at boot time.
 */
8955 8956 8957 8958 8959 8960

static LIST_HEAD(all_detected_devices);
struct detected_devices_node {
	struct list_head list;
	dev_t dev;
};
L
Linus Torvalds 已提交
8961 8962 8963

void md_autodetect_dev(dev_t dev)
{
8964 8965 8966 8967 8968 8969 8970 8971 8972 8973
	struct detected_devices_node *node_detected_dev;

	node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
	if (node_detected_dev) {
		node_detected_dev->dev = dev;
		list_add_tail(&node_detected_dev->list, &all_detected_devices);
	} else {
		printk(KERN_CRIT "md: md_autodetect_dev: kzalloc failed"
			", skipping dev(%d,%d)\n", MAJOR(dev), MINOR(dev));
	}
L
Linus Torvalds 已提交
8974 8975 8976 8977
}

static void autostart_arrays(int part)
{
8978
	struct md_rdev *rdev;
8979 8980 8981
	struct detected_devices_node *node_detected_dev;
	dev_t dev;
	int i_scanned, i_passed;
L
Linus Torvalds 已提交
8982

8983 8984
	i_scanned = 0;
	i_passed = 0;
L
Linus Torvalds 已提交
8985

8986
	printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
L
Linus Torvalds 已提交
8987

8988 8989 8990 8991 8992 8993 8994
	while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
		i_scanned++;
		node_detected_dev = list_entry(all_detected_devices.next,
					struct detected_devices_node, list);
		list_del(&node_detected_dev->list);
		dev = node_detected_dev->dev;
		kfree(node_detected_dev);
8995
		rdev = md_import_device(dev,0, 90);
L
Linus Torvalds 已提交
8996 8997 8998
		if (IS_ERR(rdev))
			continue;

N
NeilBrown 已提交
8999
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
9000
			continue;
N
NeilBrown 已提交
9001

9002
		set_bit(AutoDetected, &rdev->flags);
L
Linus Torvalds 已提交
9003
		list_add(&rdev->same_set, &pending_raid_disks);
9004
		i_passed++;
L
Linus Torvalds 已提交
9005
	}
9006 9007 9008

	printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
						i_scanned, i_passed);
L
Linus Torvalds 已提交
9009 9010 9011 9012

	autorun_devices(part);
}

J
Jeff Garzik 已提交
9013
#endif /* !MODULE */
L
Linus Torvalds 已提交
9014 9015 9016

static __exit void md_exit(void)
{
9017
	struct mddev *mddev;
L
Linus Torvalds 已提交
9018
	struct list_head *tmp;
9019
	int delay = 1;
9020

9021
	blk_unregister_region(MKDEV(MD_MAJOR,0), 512);
9022
	blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
L
Linus Torvalds 已提交
9023

C
Christoph Hellwig 已提交
9024
	unregister_blkdev(MD_MAJOR,"md");
L
Linus Torvalds 已提交
9025 9026 9027
	unregister_blkdev(mdp_major, "mdp");
	unregister_reboot_notifier(&md_notifier);
	unregister_sysctl_table(raid_table_header);
9028 9029 9030 9031 9032 9033 9034 9035 9036 9037 9038

	/* We cannot unload the modules while some process is
	 * waiting for us in select() or poll() - wake them up
	 */
	md_unloading = 1;
	while (waitqueue_active(&md_event_waiters)) {
		/* not safe to leave yet */
		wake_up(&md_event_waiters);
		msleep(delay);
		delay += delay;
	}
L
Linus Torvalds 已提交
9039
	remove_proc_entry("mdstat", NULL);
9040

9041
	for_each_mddev(mddev, tmp) {
L
Linus Torvalds 已提交
9042
		export_array(mddev);
9043
		mddev->hold_active = 0;
L
Linus Torvalds 已提交
9044
	}
T
Tejun Heo 已提交
9045 9046
	destroy_workqueue(md_misc_wq);
	destroy_workqueue(md_wq);
L
Linus Torvalds 已提交
9047 9048
}

9049
subsys_initcall(md_init);
L
Linus Torvalds 已提交
9050 9051
module_exit(md_exit)

9052 9053 9054 9055 9056 9057
static int get_ro(char *buffer, struct kernel_param *kp)
{
	return sprintf(buffer, "%d", start_readonly);
}
static int set_ro(const char *val, struct kernel_param *kp)
{
A
Alexey Dobriyan 已提交
9058
	return kstrtouint(val, 10, (unsigned int *)&start_readonly);
9059 9060
}

9061 9062
module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
9063
module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
9064

L
Linus Torvalds 已提交
9065
MODULE_LICENSE("GPL");
9066
MODULE_DESCRIPTION("MD RAID framework");
9067
MODULE_ALIAS("md");
9068
MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);