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

     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>
39
#include <linux/mutex.h>
L
Linus Torvalds 已提交
40
#include <linux/buffer_head.h> /* for invalidate_bdev */
41
#include <linux/poll.h>
42
#include <linux/ctype.h>
43
#include <linux/string.h>
44 45 46 47
#include <linux/hdreg.h>
#include <linux/proc_fs.h>
#include <linux/random.h>
#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"
L
Linus Torvalds 已提交
56 57 58 59 60

#define DEBUG 0
#define dprintk(x...) ((void)(DEBUG && printk(x)))

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

64
static LIST_HEAD(pers_list);
L
Linus Torvalds 已提交
65 66
static DEFINE_SPINLOCK(pers_lock);

67 68
static void md_print_devices(void);

69
static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
T
Tejun Heo 已提交
70 71
static struct workqueue_struct *md_wq;
static struct workqueue_struct *md_misc_wq;
72

73 74
#define MD_BUG(x...) { printk("md: bug in file %s, line %d\n", __FILE__, __LINE__); md_print_devices(); }

75 76 77 78 79 80
/*
 * 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 已提交
81 82 83 84
/*
 * 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
85
 * the RAID driver will use the maximum available bandwidth if the IO
L
Linus Torvalds 已提交
86 87 88 89 90
 * 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.
91
 * or /sys/block/mdX/md/sync_speed_{min,max}
L
Linus Torvalds 已提交
92 93 94 95
 */

static int sysctl_speed_limit_min = 1000;
static int sysctl_speed_limit_max = 200000;
96 97 98 99 100 101 102 103 104 105 106
static inline int speed_min(mddev_t *mddev)
{
	return mddev->sync_speed_min ?
		mddev->sync_speed_min : sysctl_speed_limit_min;
}

static inline int speed_max(mddev_t *mddev)
{
	return mddev->sync_speed_max ?
		mddev->sync_speed_max : sysctl_speed_limit_max;
}
L
Linus Torvalds 已提交
107 108 109 110 111 112 113 114

static struct ctl_table_header *raid_table_header;

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

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

static ctl_table raid_root_table[] = {
	{
		.procname	= "dev",
		.maxlen		= 0,
		.mode		= 0555,
		.child		= raid_dir_table,
	},
145
	{  }
L
Linus Torvalds 已提交
146 147
};

148
static const struct block_device_operations md_fops;
L
Linus Torvalds 已提交
149

150 151
static int start_readonly;

152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
/* bio_clone_mddev
 * like bio_clone, but with a local bio set
 */

static void mddev_bio_destructor(struct bio *bio)
{
	mddev_t *mddev, **mddevp;

	mddevp = (void*)bio;
	mddev = mddevp[-1];

	bio_free(bio, mddev->bio_set);
}

struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
			    mddev_t *mddev)
{
	struct bio *b;
	mddev_t **mddevp;

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

	b = bio_alloc_bioset(gfp_mask, nr_iovecs,
			     mddev->bio_set);
	if (!b)
		return NULL;
	mddevp = (void*)b;
	mddevp[-1] = mddev;
	b->bi_destructor = mddev_bio_destructor;
	return b;
}
EXPORT_SYMBOL_GPL(bio_alloc_mddev);

struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
			    mddev_t *mddev)
{
	struct bio *b;
	mddev_t **mddevp;

	if (!mddev || !mddev->bio_set)
		return bio_clone(bio, gfp_mask);

	b = bio_alloc_bioset(gfp_mask, bio->bi_max_vecs,
			     mddev->bio_set);
	if (!b)
		return NULL;
	mddevp = (void*)b;
	mddevp[-1] = mddev;
	b->bi_destructor = mddev_bio_destructor;
	__bio_clone(b, bio);
	if (bio_integrity(bio)) {
		int ret;

		ret = bio_integrity_clone(b, bio, gfp_mask, mddev->bio_set);

		if (ret < 0) {
			bio_put(b);
			return NULL;
		}
	}

	return b;
}
EXPORT_SYMBOL_GPL(bio_clone_mddev);

218 219 220 221 222 223 224 225 226 227
/*
 * 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
 */
228
static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
229
static atomic_t md_event_count;
230
void md_new_event(mddev_t *mddev)
231 232 233 234
{
	atomic_inc(&md_event_count);
	wake_up(&md_event_waiters);
}
235
EXPORT_SYMBOL_GPL(md_new_event);
236

237 238 239
/* Alternate version that can be called from interrupts
 * when calling sysfs_notify isn't needed.
 */
240
static void md_new_event_inintr(mddev_t *mddev)
241 242 243 244 245
{
	atomic_inc(&md_event_count);
	wake_up(&md_event_waiters);
}

L
Linus Torvalds 已提交
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
/*
 * 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.
 */
261
#define for_each_mddev(mddev,tmp)					\
L
Linus Torvalds 已提交
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
									\
	for (({ spin_lock(&all_mddevs_lock); 				\
		tmp = all_mddevs.next;					\
		mddev = NULL;});					\
	     ({ if (tmp != &all_mddevs)					\
			mddev_get(list_entry(tmp, mddev_t, all_mddevs));\
		spin_unlock(&all_mddevs_lock);				\
		if (mddev) mddev_put(mddev);				\
		mddev = list_entry(tmp, mddev_t, all_mddevs);		\
		tmp != &all_mddevs;});					\
	     ({ spin_lock(&all_mddevs_lock);				\
		tmp = tmp->next;})					\
		)


277 278 279 280 281 282 283 284
/* 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.
 */
static int md_make_request(struct request_queue *q, struct bio *bio)
L
Linus Torvalds 已提交
285
{
286
	const int rw = bio_data_dir(bio);
287 288
	mddev_t *mddev = q->queuedata;
	int rv;
289 290
	int cpu;

291 292
	if (mddev == NULL || mddev->pers == NULL
	    || !mddev->ready) {
293 294 295
		bio_io_error(bio);
		return 0;
	}
296
	smp_rmb(); /* Ensure implications of  'active' are visible */
297
	rcu_read_lock();
T
Tejun Heo 已提交
298
	if (mddev->suspended) {
299 300 301 302
		DEFINE_WAIT(__wait);
		for (;;) {
			prepare_to_wait(&mddev->sb_wait, &__wait,
					TASK_UNINTERRUPTIBLE);
T
Tejun Heo 已提交
303
			if (!mddev->suspended)
304 305 306 307 308 309 310 311 312
				break;
			rcu_read_unlock();
			schedule();
			rcu_read_lock();
		}
		finish_wait(&mddev->sb_wait, &__wait);
	}
	atomic_inc(&mddev->active_io);
	rcu_read_unlock();
313

314
	rv = mddev->pers->make_request(mddev, bio);
315 316 317 318 319 320 321

	cpu = part_stat_lock();
	part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
	part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw],
		      bio_sectors(bio));
	part_stat_unlock();

322 323 324 325 326 327
	if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
		wake_up(&mddev->sb_wait);

	return rv;
}

328 329 330 331 332 333
/* mddev_suspend makes sure no new requests are submitted
 * to the device, and that any requests that have been submitted
 * are completely handled.
 * Once ->stop is called and completes, the module will be completely
 * unused.
 */
334
void mddev_suspend(mddev_t *mddev)
335 336 337 338 339 340 341
{
	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);
}
342
EXPORT_SYMBOL_GPL(mddev_suspend);
343

344
void mddev_resume(mddev_t *mddev)
345 346 347 348
{
	mddev->suspended = 0;
	wake_up(&mddev->sb_wait);
	mddev->pers->quiesce(mddev, 0);
L
Linus Torvalds 已提交
349
}
350
EXPORT_SYMBOL_GPL(mddev_resume);
L
Linus Torvalds 已提交
351

352 353 354 355 356 357
int mddev_congested(mddev_t *mddev, int bits)
{
	return mddev->suspended;
}
EXPORT_SYMBOL(mddev_congested);

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

T
Tejun Heo 已提交
362
static void md_end_flush(struct bio *bio, int err)
363 364 365 366 367 368 369
{
	mdk_rdev_t *rdev = bio->bi_private;
	mddev_t *mddev = rdev->mddev;

	rdev_dec_pending(rdev, mddev);

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

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

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

N
NeilBrown 已提交
383 384
	INIT_WORK(&mddev->flush_work, md_submit_flush_data);
	atomic_set(&mddev->flush_pending, 1);
385 386 387 388 389 390 391 392 393 394 395 396
	rcu_read_lock();
	list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
		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();
397
			bi = bio_alloc_mddev(GFP_KERNEL, 0, mddev);
T
Tejun Heo 已提交
398
			bi->bi_end_io = md_end_flush;
399 400 401
			bi->bi_private = rdev;
			bi->bi_bdev = rdev->bdev;
			atomic_inc(&mddev->flush_pending);
T
Tejun Heo 已提交
402
			submit_bio(WRITE_FLUSH, bi);
403 404 405 406
			rcu_read_lock();
			rdev_dec_pending(rdev, mddev);
		}
	rcu_read_unlock();
N
NeilBrown 已提交
407 408
	if (atomic_dec_and_test(&mddev->flush_pending))
		queue_work(md_wq, &mddev->flush_work);
409 410
}

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

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

	mddev->flush_bio = NULL;
	wake_up(&mddev->sb_wait);
427 428
}

T
Tejun Heo 已提交
429
void md_flush_request(mddev_t *mddev, struct bio *bio)
430 431 432
{
	spin_lock_irq(&mddev->write_lock);
	wait_event_lock_irq(mddev->sb_wait,
T
Tejun Heo 已提交
433
			    !mddev->flush_bio,
434
			    mddev->write_lock, /*nothing*/);
T
Tejun Heo 已提交
435
	mddev->flush_bio = bio;
436 437
	spin_unlock_irq(&mddev->write_lock);

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

443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
/* Support for plugging.
 * This mirrors the plugging support in request_queue, but does not
 * require having a whole queue
 */
static void plugger_work(struct work_struct *work)
{
	struct plug_handle *plug =
		container_of(work, struct plug_handle, unplug_work);
	plug->unplug_fn(plug);
}
static void plugger_timeout(unsigned long data)
{
	struct plug_handle *plug = (void *)data;
	kblockd_schedule_work(NULL, &plug->unplug_work);
}
void plugger_init(struct plug_handle *plug,
		  void (*unplug_fn)(struct plug_handle *))
{
	plug->unplug_flag = 0;
	plug->unplug_fn = unplug_fn;
	init_timer(&plug->unplug_timer);
	plug->unplug_timer.function = plugger_timeout;
	plug->unplug_timer.data = (unsigned long)plug;
	INIT_WORK(&plug->unplug_work, plugger_work);
}
EXPORT_SYMBOL_GPL(plugger_init);

void plugger_set_plug(struct plug_handle *plug)
{
	if (!test_and_set_bit(PLUGGED_FLAG, &plug->unplug_flag))
		mod_timer(&plug->unplug_timer, jiffies + msecs_to_jiffies(3)+1);
}
EXPORT_SYMBOL_GPL(plugger_set_plug);

int plugger_remove_plug(struct plug_handle *plug)
{
	if (test_and_clear_bit(PLUGGED_FLAG, &plug->unplug_flag)) {
		del_timer(&plug->unplug_timer);
		return 1;
	} else
		return 0;
}
EXPORT_SYMBOL_GPL(plugger_remove_plug);


L
Linus Torvalds 已提交
488 489 490 491 492 493
static inline mddev_t *mddev_get(mddev_t *mddev)
{
	atomic_inc(&mddev->active);
	return mddev;
}

494
static void mddev_delayed_delete(struct work_struct *ws);
495

L
Linus Torvalds 已提交
496 497
static void mddev_put(mddev_t *mddev)
{
498 499
	struct bio_set *bs = NULL;

L
Linus Torvalds 已提交
500 501
	if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
		return;
502
	if (!mddev->raid_disks && list_empty(&mddev->disks) &&
503 504 505
	    mddev->ctime == 0 && !mddev->hold_active) {
		/* Array is not configured at all, and not held active,
		 * so destroy it */
L
Linus Torvalds 已提交
506
		list_del(&mddev->all_mddevs);
507 508
		bs = mddev->bio_set;
		mddev->bio_set = NULL;
509
		if (mddev->gendisk) {
T
Tejun Heo 已提交
510 511 512 513
			/* 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.
514 515
			 */
			INIT_WORK(&mddev->del_work, mddev_delayed_delete);
T
Tejun Heo 已提交
516
			queue_work(md_misc_wq, &mddev->del_work);
517 518 519 520
		} else
			kfree(mddev);
	}
	spin_unlock(&all_mddevs_lock);
521 522
	if (bs)
		bioset_free(bs);
L
Linus Torvalds 已提交
523 524
}

525
void mddev_init(mddev_t *mddev)
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
{
	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);
	init_timer(&mddev->safemode_timer);
	atomic_set(&mddev->active, 1);
	atomic_set(&mddev->openers, 0);
	atomic_set(&mddev->active_io, 0);
	spin_lock_init(&mddev->write_lock);
	atomic_set(&mddev->flush_pending, 0);
	init_waitqueue_head(&mddev->sb_wait);
	init_waitqueue_head(&mddev->recovery_wait);
	mddev->reshape_position = MaxSector;
	mddev->resync_min = 0;
	mddev->resync_max = MaxSector;
	mddev->level = LEVEL_NONE;
}
545
EXPORT_SYMBOL_GPL(mddev_init);
546

L
Linus Torvalds 已提交
547 548 549 550 551 552
static mddev_t * mddev_find(dev_t unit)
{
	mddev_t *mddev, *new = NULL;

 retry:
	spin_lock(&all_mddevs_lock);
553 554 555 556 557 558 559 560 561 562 563 564

	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 已提交
565
			spin_unlock(&all_mddevs_lock);
566 567
			new->hold_active = UNTIL_IOCTL;
			return new;
L
Linus Torvalds 已提交
568
		}
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
	} 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;
			}
				
			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 已提交
597 598 599 600 601 602
		list_add(&new->all_mddevs, &all_mddevs);
		spin_unlock(&all_mddevs_lock);
		return new;
	}
	spin_unlock(&all_mddevs_lock);

603
	new = kzalloc(sizeof(*new), GFP_KERNEL);
L
Linus Torvalds 已提交
604 605 606 607 608 609 610 611 612
	if (!new)
		return NULL;

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

613
	mddev_init(new);
L
Linus Torvalds 已提交
614 615 616 617 618 619

	goto retry;
}

static inline int mddev_lock(mddev_t * mddev)
{
620
	return mutex_lock_interruptible(&mddev->reconfig_mutex);
L
Linus Torvalds 已提交
621 622
}

D
Dan Williams 已提交
623 624 625 626 627
static inline int mddev_is_locked(mddev_t *mddev)
{
	return mutex_is_locked(&mddev->reconfig_mutex);
}

L
Linus Torvalds 已提交
628 629
static inline int mddev_trylock(mddev_t * mddev)
{
630
	return mutex_trylock(&mddev->reconfig_mutex);
L
Linus Torvalds 已提交
631 632
}

633 634
static struct attribute_group md_redundancy_group;

635
static void mddev_unlock(mddev_t * mddev)
L
Linus Torvalds 已提交
636
{
637
	if (mddev->to_remove) {
638 639 640 641
		/* 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.
642 643 644 645 646 647 648
		 * 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.
649
		 */
650 651
		struct attribute_group *to_remove = mddev->to_remove;
		mddev->to_remove = NULL;
652
		mddev->sysfs_active = 1;
653 654
		mutex_unlock(&mddev->reconfig_mutex);

N
NeilBrown 已提交
655 656 657 658 659 660 661 662 663 664
		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;
			}
665
		}
666
		mddev->sysfs_active = 0;
667 668
	} else
		mutex_unlock(&mddev->reconfig_mutex);
L
Linus Torvalds 已提交
669

670
	md_wakeup_thread(mddev->thread);
L
Linus Torvalds 已提交
671 672
}

673
static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
L
Linus Torvalds 已提交
674
{
675
	mdk_rdev_t *rdev;
L
Linus Torvalds 已提交
676

677
	list_for_each_entry(rdev, &mddev->disks, same_set)
L
Linus Torvalds 已提交
678 679
		if (rdev->desc_nr == nr)
			return rdev;
680

L
Linus Torvalds 已提交
681 682 683 684 685 686 687
	return NULL;
}

static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
{
	mdk_rdev_t *rdev;

688
	list_for_each_entry(rdev, &mddev->disks, same_set)
L
Linus Torvalds 已提交
689 690
		if (rdev->bdev->bd_dev == dev)
			return rdev;
691

L
Linus Torvalds 已提交
692 693 694
	return NULL;
}

695
static struct mdk_personality *find_pers(int level, char *clevel)
696 697
{
	struct mdk_personality *pers;
698 699
	list_for_each_entry(pers, &pers_list, list) {
		if (level != LEVEL_NONE && pers->level == level)
700
			return pers;
701 702 703
		if (strcmp(pers->name, clevel)==0)
			return pers;
	}
704 705 706
	return NULL;
}

707
/* return the offset of the super block in 512byte sectors */
708
static inline sector_t calc_dev_sboffset(mdk_rdev_t *rdev)
L
Linus Torvalds 已提交
709
{
710
	sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
711
	return MD_NEW_SIZE_SECTORS(num_sectors);
L
Linus Torvalds 已提交
712 713 714 715 716 717 718 719 720 721
}

static int alloc_disk_sb(mdk_rdev_t * rdev)
{
	if (rdev->sb_page)
		MD_BUG();

	rdev->sb_page = alloc_page(GFP_KERNEL);
	if (!rdev->sb_page) {
		printk(KERN_ALERT "md: out of memory.\n");
722
		return -ENOMEM;
L
Linus Torvalds 已提交
723 724 725 726 727 728 729 730
	}

	return 0;
}

static void free_disk_sb(mdk_rdev_t * rdev)
{
	if (rdev->sb_page) {
731
		put_page(rdev->sb_page);
L
Linus Torvalds 已提交
732 733
		rdev->sb_loaded = 0;
		rdev->sb_page = NULL;
734
		rdev->sb_start = 0;
735
		rdev->sectors = 0;
L
Linus Torvalds 已提交
736 737 738 739
	}
}


740
static void super_written(struct bio *bio, int error)
741 742
{
	mdk_rdev_t *rdev = bio->bi_private;
743
	mddev_t *mddev = rdev->mddev;
744

745 746 747 748
	if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags)) {
		printk("md: super_written gets error=%d, uptodate=%d\n",
		       error, test_bit(BIO_UPTODATE, &bio->bi_flags));
		WARN_ON(test_bit(BIO_UPTODATE, &bio->bi_flags));
749
		md_error(mddev, rdev);
750
	}
751

752 753
	if (atomic_dec_and_test(&mddev->pending_writes))
		wake_up(&mddev->sb_wait);
N
Neil Brown 已提交
754
	bio_put(bio);
755 756 757 758 759 760 761 762 763 764 765
}

void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
		   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
	 */
766
	struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, mddev);
767

768
	bio->bi_bdev = rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev;
769 770 771 772
	bio->bi_sector = sector;
	bio_add_page(bio, page, size, 0);
	bio->bi_private = rdev;
	bio->bi_end_io = super_written;
773

774
	atomic_inc(&mddev->pending_writes);
T
Tejun Heo 已提交
775 776
	submit_bio(REQ_WRITE | REQ_SYNC | REQ_UNPLUG | REQ_FLUSH | REQ_FUA,
		   bio);
777 778 779 780
}

void md_super_wait(mddev_t *mddev)
{
T
Tejun Heo 已提交
781
	/* wait for all superblock writes that were scheduled to complete */
782 783 784 785 786 787 788 789
	DEFINE_WAIT(wq);
	for(;;) {
		prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
		if (atomic_read(&mddev->pending_writes)==0)
			break;
		schedule();
	}
	finish_wait(&mddev->sb_wait, &wq);
790 791
}

792
static void bi_complete(struct bio *bio, int error)
L
Linus Torvalds 已提交
793 794 795 796
{
	complete((struct completion*)bio->bi_private);
}

797
int sync_page_io(mdk_rdev_t *rdev, sector_t sector, int size,
J
Jonathan Brassow 已提交
798
		 struct page *page, int rw, bool metadata_op)
L
Linus Torvalds 已提交
799
{
800
	struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev);
L
Linus Torvalds 已提交
801 802 803
	struct completion event;
	int ret;

804
	rw |= REQ_SYNC | REQ_UNPLUG;
L
Linus Torvalds 已提交
805

806 807
	bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
		rdev->meta_bdev : rdev->bdev;
J
Jonathan Brassow 已提交
808 809 810 811
	if (metadata_op)
		bio->bi_sector = sector + rdev->sb_start;
	else
		bio->bi_sector = sector + rdev->data_offset;
L
Linus Torvalds 已提交
812 813 814 815 816 817 818 819 820 821 822
	bio_add_page(bio, page, size, 0);
	init_completion(&event);
	bio->bi_private = &event;
	bio->bi_end_io = bi_complete;
	submit_bio(rw, bio);
	wait_for_completion(&event);

	ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
	bio_put(bio);
	return ret;
}
823
EXPORT_SYMBOL_GPL(sync_page_io);
L
Linus Torvalds 已提交
824

825
static int read_disk_sb(mdk_rdev_t * rdev, int size)
L
Linus Torvalds 已提交
826 827 828 829 830 831 832 833 834 835
{
	char b[BDEVNAME_SIZE];
	if (!rdev->sb_page) {
		MD_BUG();
		return -EINVAL;
	}
	if (rdev->sb_loaded)
		return 0;


J
Jonathan Brassow 已提交
836
	if (!sync_page_io(rdev, 0, size, rdev->sb_page, READ, true))
L
Linus Torvalds 已提交
837 838 839 840 841 842 843 844 845 846 847 848
		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)
{
A
Andre Noll 已提交
849 850 851 852
	return 	sb1->set_uuid0 == sb2->set_uuid0 &&
		sb1->set_uuid1 == sb2->set_uuid1 &&
		sb1->set_uuid2 == sb2->set_uuid2 &&
		sb1->set_uuid3 == sb2->set_uuid3;
L
Linus Torvalds 已提交
853 854 855 856 857 858 859 860 861 862 863 864
}

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;
865
		printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
L
Linus Torvalds 已提交
866 867 868 869 870 871 872 873 874 875 876 877
		goto abort;
	}

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

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

A
Andre Noll 已提交
878
	ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
L
Linus Torvalds 已提交
879
abort:
880 881
	kfree(tmp1);
	kfree(tmp2);
L
Linus Torvalds 已提交
882 883 884
	return ret;
}

885 886 887 888 889 890 891

static u32 md_csum_fold(u32 csum)
{
	csum = (csum & 0xffff) + (csum >> 16);
	return (csum & 0xffff) + (csum >> 16);
}

L
Linus Torvalds 已提交
892 893
static unsigned int calc_sb_csum(mdp_super_t * sb)
{
894 895 896
	u64 newcsum = 0;
	u32 *sb32 = (u32*)sb;
	int i;
L
Linus Torvalds 已提交
897 898 899 900
	unsigned int disk_csum, csum;

	disk_csum = sb->sb_csum;
	sb->sb_csum = 0;
901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917

	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 已提交
918
	sb->sb_csum = disk_csum;
919
#endif
L
Linus Torvalds 已提交
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954
	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:
 *   int load_super(mdk_rdev_t *dev, mdk_rdev_t *refdev, int minor_version)
 *      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
 *
 *   int validate_super(mddev_t *mddev, mdk_rdev_t *dev)
 *      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
 *
 *   void sync_super(mddev_t *mddev, mdk_rdev_t *dev)
 *     Update the superblock for rdev with data in mddev
 *     This does not write to disc.
 *
 */

struct super_type  {
955 956 957 958 959 960 961
	char		    *name;
	struct module	    *owner;
	int		    (*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev,
					  int minor_version);
	int		    (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
	void		    (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
	unsigned long long  (*rdev_size_change)(mdk_rdev_t *rdev,
962
						sector_t num_sectors);
L
Linus Torvalds 已提交
963 964
};

965 966 967 968 969 970 971 972 973 974
/*
 * 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.
 *
 */
int md_check_no_bitmap(mddev_t *mddev)
{
975
	if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
976 977 978 979 980 981 982
		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 已提交
983 984 985 986 987 988 989 990 991 992
/*
 * load_super for 0.90.0 
 */
static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
{
	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
	mdp_super_t *sb;
	int ret;

	/*
993
	 * Calculate the position of the superblock (512byte sectors),
L
Linus Torvalds 已提交
994 995 996 997
	 * it's at the end of the disk.
	 *
	 * It also happens to be a multiple of 4Kb.
	 */
998
	rdev->sb_start = calc_dev_sboffset(rdev);
L
Linus Torvalds 已提交
999

1000
	ret = read_disk_sb(rdev, MD_SB_BYTES);
L
Linus Torvalds 已提交
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
	if (ret) return ret;

	ret = -EINVAL;

	bdevname(rdev->bdev, b);
	sb = (mdp_super_t*)page_address(rdev->sb_page);

	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 ||
1015 1016
	    sb->minor_version < 90 ||
	    sb->minor_version > 91) {
L
Linus Torvalds 已提交
1017 1018 1019 1020 1021 1022 1023 1024 1025
		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;

1026
	if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
L
Linus Torvalds 已提交
1027 1028 1029 1030 1031 1032 1033
		printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
			b);
		goto abort;
	}

	rdev->preferred_minor = sb->md_minor;
	rdev->data_offset = 0;
1034
	rdev->sb_size = MD_SB_BYTES;
L
Linus Torvalds 已提交
1035 1036 1037 1038 1039 1040

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

1041
	if (!refdev) {
L
Linus Torvalds 已提交
1042
		ret = 1;
1043
	} else {
L
Linus Torvalds 已提交
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
		__u64 ev1, ev2;
		mdp_super_t *refsb = (mdp_super_t*)page_address(refdev->sb_page);
		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;
		else 
			ret = 0;
	}
1064
	rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
1065

1066
	if (rdev->sectors < sb->size * 2 && sb->level > 1)
1067 1068 1069
		/* "this cannot possibly happen" ... */
		ret = -EINVAL;

L
Linus Torvalds 已提交
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
 abort:
	return ret;
}

/*
 * validate_super for 0.90.0
 */
static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
{
	mdp_disk_t *desc;
	mdp_super_t *sb = (mdp_super_t *)page_address(rdev->sb_page);
1081
	__u64 ev1 = md_event(sb);
L
Linus Torvalds 已提交
1082

1083
	rdev->raid_disk = -1;
1084 1085 1086 1087
	clear_bit(Faulty, &rdev->flags);
	clear_bit(In_sync, &rdev->flags);
	clear_bit(WriteMostly, &rdev->flags);

L
Linus Torvalds 已提交
1088 1089 1090 1091
	if (mddev->raid_disks == 0) {
		mddev->major_version = 0;
		mddev->minor_version = sb->minor_version;
		mddev->patch_version = sb->patch_version;
1092
		mddev->external = 0;
1093
		mddev->chunk_sectors = sb->chunk_size >> 9;
L
Linus Torvalds 已提交
1094 1095 1096
		mddev->ctime = sb->ctime;
		mddev->utime = sb->utime;
		mddev->level = sb->level;
1097
		mddev->clevel[0] = 0;
L
Linus Torvalds 已提交
1098 1099
		mddev->layout = sb->layout;
		mddev->raid_disks = sb->raid_disks;
A
Andre Noll 已提交
1100
		mddev->dev_sectors = sb->size * 2;
1101
		mddev->events = ev1;
1102 1103
		mddev->bitmap_info.offset = 0;
		mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
L
Linus Torvalds 已提交
1104

1105 1106 1107 1108 1109
		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;
1110
			mddev->new_chunk_sectors = sb->new_chunk >> 9;
1111 1112 1113 1114 1115
		} else {
			mddev->reshape_position = MaxSector;
			mddev->delta_disks = 0;
			mddev->new_level = mddev->level;
			mddev->new_layout = mddev->layout;
1116
			mddev->new_chunk_sectors = mddev->chunk_sectors;
1117 1118
		}

L
Linus Torvalds 已提交
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
		if (sb->state & (1<<MD_SB_CLEAN))
			mddev->recovery_cp = MaxSector;
		else {
			if (sb->events_hi == sb->cp_events_hi && 
				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;
1135 1136

		if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
1137 1138 1139
		    mddev->bitmap_info.file == NULL)
			mddev->bitmap_info.offset =
				mddev->bitmap_info.default_offset;
1140

1141
	} else if (mddev->pers == NULL) {
1142 1143
		/* Insist on good event counter while assembling, except
		 * for spares (which don't need an event count) */
L
Linus Torvalds 已提交
1144
		++ev1;
1145 1146 1147 1148
		if (sb->disks[rdev->desc_nr].state & (
			    (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
			if (ev1 < mddev->events) 
				return -EINVAL;
1149 1150 1151 1152 1153 1154
	} 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;
1155 1156 1157 1158 1159
	} else {
		if (ev1 < mddev->events)
			/* just a hot-add of a new device, leave raid_disk at -1 */
			return 0;
	}
1160

L
Linus Torvalds 已提交
1161 1162 1163 1164
	if (mddev->level != LEVEL_MULTIPATH) {
		desc = sb->disks + rdev->desc_nr;

		if (desc->state & (1<<MD_DISK_FAULTY))
1165
			set_bit(Faulty, &rdev->flags);
1166 1167
		else if (desc->state & (1<<MD_DISK_SYNC) /* &&
			    desc->raid_disk < mddev->raid_disks */) {
1168
			set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
1169
			rdev->raid_disk = desc->raid_disk;
1170 1171 1172 1173 1174 1175 1176 1177
		} 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 已提交
1178
		}
1179 1180
		if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);
1181
	} else /* MULTIPATH are always insync */
1182
		set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
	return 0;
}

/*
 * sync_super for 0.90.0
 */
static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
{
	mdp_super_t *sb;
	mdk_rdev_t *rdev2;
	int next_spare = mddev->raid_disks;
1194

L
Linus Torvalds 已提交
1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208

	/* 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;

1209 1210
	rdev->sb_size = MD_SB_BYTES;

L
Linus Torvalds 已提交
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
	sb = (mdp_super_t*)page_address(rdev->sb_page);

	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 已提交
1226
	sb->size = mddev->dev_sectors / 2;
L
Linus Torvalds 已提交
1227 1228
	sb->raid_disks = mddev->raid_disks;
	sb->md_minor = mddev->md_minor;
1229
	sb->not_persistent = 0;
L
Linus Torvalds 已提交
1230 1231 1232 1233 1234
	sb->utime = mddev->utime;
	sb->state = 0;
	sb->events_hi = (mddev->events>>32);
	sb->events_lo = (u32)mddev->events;

1235 1236 1237 1238 1239 1240 1241 1242
	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;
1243
		sb->new_chunk = mddev->new_chunk_sectors << 9;
1244 1245
	}
	mddev->minor_version = sb->minor_version;
L
Linus Torvalds 已提交
1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
	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;
1257
	sb->chunk_size = mddev->chunk_sectors << 9;
L
Linus Torvalds 已提交
1258

1259
	if (mddev->bitmap && mddev->bitmap_info.file == NULL)
1260 1261
		sb->state |= (1<<MD_SB_BITMAP_PRESENT);

L
Linus Torvalds 已提交
1262
	sb->disks[0].state = (1<<MD_DISK_REMOVED);
1263
	list_for_each_entry(rdev2, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
1264
		mdp_disk_t *d;
1265
		int desc_nr;
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278
		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)
1279
			desc_nr = rdev2->raid_disk;
L
Linus Torvalds 已提交
1280
		else
1281
			desc_nr = next_spare++;
1282
		rdev2->desc_nr = desc_nr;
L
Linus Torvalds 已提交
1283 1284 1285 1286 1287
		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);
1288
		if (is_active)
L
Linus Torvalds 已提交
1289 1290 1291
			d->raid_disk = rdev2->raid_disk;
		else
			d->raid_disk = rdev2->desc_nr; /* compatibility */
1292
		if (test_bit(Faulty, &rdev2->flags))
L
Linus Torvalds 已提交
1293
			d->state = (1<<MD_DISK_FAULTY);
1294
		else if (is_active) {
L
Linus Torvalds 已提交
1295
			d->state = (1<<MD_DISK_ACTIVE);
1296 1297
			if (test_bit(In_sync, &rdev2->flags))
				d->state |= (1<<MD_DISK_SYNC);
L
Linus Torvalds 已提交
1298 1299 1300 1301 1302 1303 1304
			active++;
			working++;
		} else {
			d->state = 0;
			spare++;
			working++;
		}
1305 1306
		if (test_bit(WriteMostly, &rdev2->flags))
			d->state |= (1<<MD_DISK_WRITEMOSTLY);
L
Linus Torvalds 已提交
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328
	}
	/* 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);
}

1329 1330 1331 1332
/*
 * rdev_size_change for 0.90.0
 */
static unsigned long long
1333
super_90_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
1334
{
A
Andre Noll 已提交
1335
	if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1336
		return 0; /* component must fit device */
1337
	if (rdev->mddev->bitmap_info.offset)
1338
		return 0; /* can't move bitmap */
1339
	rdev->sb_start = calc_dev_sboffset(rdev);
1340 1341
	if (!num_sectors || num_sectors > rdev->sb_start)
		num_sectors = rdev->sb_start;
1342
	md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1343 1344
		       rdev->sb_page);
	md_super_wait(rdev->mddev);
1345
	return num_sectors;
1346 1347 1348
}


L
Linus Torvalds 已提交
1349 1350 1351 1352
/*
 * version 1 superblock
 */

1353
static __le32 calc_sb_1_csum(struct mdp_superblock_1 * sb)
L
Linus Torvalds 已提交
1354
{
1355 1356
	__le32 disk_csum;
	u32 csum;
L
Linus Torvalds 已提交
1357 1358
	unsigned long long newcsum;
	int size = 256 + le32_to_cpu(sb->max_dev)*2;
1359
	__le32 *isuper = (__le32*)sb;
L
Linus Torvalds 已提交
1360 1361 1362 1363 1364 1365 1366 1367 1368
	int i;

	disk_csum = sb->sb_csum;
	sb->sb_csum = 0;
	newcsum = 0;
	for (i=0; size>=4; size -= 4 )
		newcsum += le32_to_cpu(*isuper++);

	if (size == 2)
1369
		newcsum += le16_to_cpu(*(__le16*) isuper);
L
Linus Torvalds 已提交
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379

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

static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
{
	struct mdp_superblock_1 *sb;
	int ret;
1380
	sector_t sb_start;
L
Linus Torvalds 已提交
1381
	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1382
	int bmask;
L
Linus Torvalds 已提交
1383 1384

	/*
1385
	 * Calculate the position of the superblock in 512byte sectors.
L
Linus Torvalds 已提交
1386 1387 1388 1389 1390 1391 1392 1393
	 * 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:
1394
		sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;
1395 1396
		sb_start -= 8*2;
		sb_start &= ~(sector_t)(4*2-1);
L
Linus Torvalds 已提交
1397 1398
		break;
	case 1:
1399
		sb_start = 0;
L
Linus Torvalds 已提交
1400 1401
		break;
	case 2:
1402
		sb_start = 8;
L
Linus Torvalds 已提交
1403 1404 1405 1406
		break;
	default:
		return -EINVAL;
	}
1407
	rdev->sb_start = sb_start;
L
Linus Torvalds 已提交
1408

1409 1410 1411 1412
	/* 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 已提交
1413 1414 1415 1416 1417 1418 1419 1420
	if (ret) return ret;


	sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);

	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 ||
1421
	    le64_to_cpu(sb->super_offset) != rdev->sb_start ||
1422
	    (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
L
Linus Torvalds 已提交
1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434
		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;
	}
1435

L
Linus Torvalds 已提交
1436 1437
	rdev->preferred_minor = 0xffff;
	rdev->data_offset = le64_to_cpu(sb->data_offset);
1438
	atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
L
Linus Torvalds 已提交
1439

1440
	rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
1441
	bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1442
	if (rdev->sb_size & bmask)
1443 1444 1445
		rdev->sb_size = (rdev->sb_size | bmask) + 1;

	if (minor_version
1446
	    && rdev->data_offset < sb_start + (rdev->sb_size/512))
1447
		return -EINVAL;
1448

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

1454
	if (!refdev) {
1455
		ret = 1;
1456
	} else {
L
Linus Torvalds 已提交
1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
		__u64 ev1, ev2;
		struct mdp_superblock_1 *refsb = 
			(struct mdp_superblock_1*)page_address(refdev->sb_page);

		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)
1475 1476 1477
			ret = 1;
		else
			ret = 0;
L
Linus Torvalds 已提交
1478
	}
1479
	if (minor_version)
1480
		rdev->sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
1481
			le64_to_cpu(sb->data_offset);
L
Linus Torvalds 已提交
1482
	else
1483 1484
		rdev->sectors = rdev->sb_start;
	if (rdev->sectors < le64_to_cpu(sb->data_size))
L
Linus Torvalds 已提交
1485
		return -EINVAL;
1486 1487
	rdev->sectors = le64_to_cpu(sb->data_size);
	if (le64_to_cpu(sb->size) > rdev->sectors)
1488
		return -EINVAL;
1489
	return ret;
L
Linus Torvalds 已提交
1490 1491 1492 1493 1494
}

static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
{
	struct mdp_superblock_1 *sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
1495
	__u64 ev1 = le64_to_cpu(sb->events);
L
Linus Torvalds 已提交
1496

1497
	rdev->raid_disk = -1;
1498 1499 1500 1501
	clear_bit(Faulty, &rdev->flags);
	clear_bit(In_sync, &rdev->flags);
	clear_bit(WriteMostly, &rdev->flags);

L
Linus Torvalds 已提交
1502 1503 1504
	if (mddev->raid_disks == 0) {
		mddev->major_version = 1;
		mddev->patch_version = 0;
1505
		mddev->external = 0;
1506
		mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
L
Linus Torvalds 已提交
1507 1508 1509
		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);
1510
		mddev->clevel[0] = 0;
L
Linus Torvalds 已提交
1511 1512
		mddev->layout = le32_to_cpu(sb->layout);
		mddev->raid_disks = le32_to_cpu(sb->raid_disks);
A
Andre Noll 已提交
1513
		mddev->dev_sectors = le64_to_cpu(sb->size);
1514
		mddev->events = ev1;
1515 1516
		mddev->bitmap_info.offset = 0;
		mddev->bitmap_info.default_offset = 1024 >> 9;
L
Linus Torvalds 已提交
1517 1518 1519 1520 1521
		
		mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
		memcpy(mddev->uuid, sb->set_uuid, 16);

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

1523
		if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1524 1525 1526
		    mddev->bitmap_info.file == NULL )
			mddev->bitmap_info.offset =
				(__s32)le32_to_cpu(sb->bitmap_offset);
1527

1528 1529 1530 1531 1532
		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);
1533
			mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
1534 1535 1536 1537 1538
		} else {
			mddev->reshape_position = MaxSector;
			mddev->delta_disks = 0;
			mddev->new_level = mddev->level;
			mddev->new_layout = mddev->layout;
1539
			mddev->new_chunk_sectors = mddev->chunk_sectors;
1540 1541
		}

1542
	} else if (mddev->pers == NULL) {
1543 1544
		/* Insist of good event counter while assembling, except for
		 * spares (which don't need an event count) */
L
Linus Torvalds 已提交
1545
		++ev1;
1546 1547 1548 1549 1550
		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;
1551 1552 1553 1554 1555 1556
	} 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;
1557 1558 1559 1560 1561
	} else {
		if (ev1 < mddev->events)
			/* just a hot-add of a new device, leave raid_disk at -1 */
			return 0;
	}
L
Linus Torvalds 已提交
1562 1563
	if (mddev->level != LEVEL_MULTIPATH) {
		int role;
1564 1565 1566 1567 1568 1569
		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 已提交
1570 1571 1572 1573
		switch(role) {
		case 0xffff: /* spare */
			break;
		case 0xfffe: /* faulty */
1574
			set_bit(Faulty, &rdev->flags);
L
Linus Torvalds 已提交
1575 1576
			break;
		default:
1577 1578 1579 1580 1581
			if ((le32_to_cpu(sb->feature_map) &
			     MD_FEATURE_RECOVERY_OFFSET))
				rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
			else
				set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
1582 1583 1584
			rdev->raid_disk = role;
			break;
		}
1585 1586
		if (sb->devflags & WriteMostly1)
			set_bit(WriteMostly, &rdev->flags);
1587
	} else /* MULTIPATH are always insync */
1588
		set_bit(In_sync, &rdev->flags);
1589

L
Linus Torvalds 已提交
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603
	return 0;
}

static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
{
	struct mdp_superblock_1 *sb;
	mdk_rdev_t *rdev2;
	int max_dev, i;
	/* make rdev->sb match mddev and rdev data. */

	sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);

	sb->feature_map = 0;
	sb->pad0 = 0;
1604
	sb->recovery_offset = cpu_to_le64(0);
L
Linus Torvalds 已提交
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
	memset(sb->pad1, 0, sizeof(sb->pad1));
	memset(sb->pad2, 0, sizeof(sb->pad2));
	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);

1616
	sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
1617

1618
	sb->raid_disks = cpu_to_le32(mddev->raid_disks);
A
Andre Noll 已提交
1619
	sb->size = cpu_to_le64(mddev->dev_sectors);
1620
	sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
1621 1622
	sb->level = cpu_to_le32(mddev->level);
	sb->layout = cpu_to_le32(mddev->layout);
1623

1624 1625
	if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
		sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
1626
		sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1627
	}
1628 1629

	if (rdev->raid_disk >= 0 &&
1630
	    !test_bit(In_sync, &rdev->flags)) {
1631 1632 1633 1634
		sb->feature_map |=
			cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
		sb->recovery_offset =
			cpu_to_le64(rdev->recovery_offset);
1635 1636
	}

1637 1638 1639 1640 1641 1642
	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);
1643
		sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
1644
	}
1645

L
Linus Torvalds 已提交
1646
	max_dev = 0;
1647
	list_for_each_entry(rdev2, &mddev->disks, same_set)
L
Linus Torvalds 已提交
1648 1649
		if (rdev2->desc_nr+1 > max_dev)
			max_dev = rdev2->desc_nr+1;
1650

1651 1652
	if (max_dev > le32_to_cpu(sb->max_dev)) {
		int bmask;
1653
		sb->max_dev = cpu_to_le32(max_dev);
1654 1655 1656 1657
		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;
1658 1659 1660
	} else
		max_dev = le32_to_cpu(sb->max_dev);

L
Linus Torvalds 已提交
1661 1662 1663
	for (i=0; i<max_dev;i++)
		sb->dev_roles[i] = cpu_to_le16(0xfffe);
	
1664
	list_for_each_entry(rdev2, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
1665
		i = rdev2->desc_nr;
1666
		if (test_bit(Faulty, &rdev2->flags))
L
Linus Torvalds 已提交
1667
			sb->dev_roles[i] = cpu_to_le16(0xfffe);
1668
		else if (test_bit(In_sync, &rdev2->flags))
L
Linus Torvalds 已提交
1669
			sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1670
		else if (rdev2->raid_disk >= 0)
1671
			sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
L
Linus Torvalds 已提交
1672 1673 1674 1675 1676 1677 1678
		else
			sb->dev_roles[i] = cpu_to_le16(0xffff);
	}

	sb->sb_csum = calc_sb_1_csum(sb);
}

1679
static unsigned long long
1680
super_1_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
1681 1682
{
	struct mdp_superblock_1 *sb;
1683
	sector_t max_sectors;
A
Andre Noll 已提交
1684
	if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1685
		return 0; /* component must fit device */
1686
	if (rdev->sb_start < rdev->data_offset) {
1687
		/* minor versions 1 and 2; superblock before data */
1688
		max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9;
1689 1690 1691
		max_sectors -= rdev->data_offset;
		if (!num_sectors || num_sectors > max_sectors)
			num_sectors = max_sectors;
1692
	} else if (rdev->mddev->bitmap_info.offset) {
1693 1694 1695 1696
		/* minor version 0 with bitmap we can't move */
		return 0;
	} else {
		/* minor version 0; superblock after data */
1697
		sector_t sb_start;
1698
		sb_start = (i_size_read(rdev->bdev->bd_inode) >> 9) - 8*2;
1699
		sb_start &= ~(sector_t)(4*2 - 1);
1700
		max_sectors = rdev->sectors + sb_start - rdev->sb_start;
1701 1702
		if (!num_sectors || num_sectors > max_sectors)
			num_sectors = max_sectors;
1703
		rdev->sb_start = sb_start;
1704 1705
	}
	sb = (struct mdp_superblock_1 *) page_address(rdev->sb_page);
1706
	sb->data_size = cpu_to_le64(num_sectors);
1707
	sb->super_offset = rdev->sb_start;
1708
	sb->sb_csum = calc_sb_1_csum(sb);
1709
	md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1710 1711
		       rdev->sb_page);
	md_super_wait(rdev->mddev);
1712
	return num_sectors;
1713
}
L
Linus Torvalds 已提交
1714

A
Adrian Bunk 已提交
1715
static struct super_type super_types[] = {
L
Linus Torvalds 已提交
1716 1717 1718
	[0] = {
		.name	= "0.90.0",
		.owner	= THIS_MODULE,
1719 1720 1721 1722
		.load_super	    = super_90_load,
		.validate_super	    = super_90_validate,
		.sync_super	    = super_90_sync,
		.rdev_size_change   = super_90_rdev_size_change,
L
Linus Torvalds 已提交
1723 1724 1725 1726
	},
	[1] = {
		.name	= "md-1",
		.owner	= THIS_MODULE,
1727 1728 1729 1730
		.load_super	    = super_1_load,
		.validate_super	    = super_1_validate,
		.sync_super	    = super_1_sync,
		.rdev_size_change   = super_1_rdev_size_change,
L
Linus Torvalds 已提交
1731 1732 1733 1734 1735
	},
};

static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
{
1736
	mdk_rdev_t *rdev, *rdev2;
L
Linus Torvalds 已提交
1737

1738 1739 1740
	rcu_read_lock();
	rdev_for_each_rcu(rdev, mddev1)
		rdev_for_each_rcu(rdev2, mddev2)
1741
			if (rdev->bdev->bd_contains ==
1742 1743
			    rdev2->bdev->bd_contains) {
				rcu_read_unlock();
1744
				return 1;
1745 1746
			}
	rcu_read_unlock();
L
Linus Torvalds 已提交
1747 1748 1749 1750 1751
	return 0;
}

static LIST_HEAD(pending_raid_disks);

1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806
/*
 * 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.
 */
int md_integrity_register(mddev_t *mddev)
{
	mdk_rdev_t *rdev, *reference = NULL;

	if (list_empty(&mddev->disks))
		return 0; /* nothing to do */
	if (blk_get_integrity(mddev->gendisk))
		return 0; /* already registered */
	list_for_each_entry(rdev, &mddev->disks, same_set) {
		/* skip spares and non-functional disks */
		if (test_bit(Faulty, &rdev->flags))
			continue;
		if (rdev->raid_disk < 0)
			continue;
		/*
		 * If at least one rdev is not integrity capable, we can not
		 * enable data integrity for the md device.
		 */
		if (!bdev_get_integrity(rdev->bdev))
			return -EINVAL;
		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;
	}
	/*
	 * All component devices are integrity capable and have matching
	 * profiles, register the common profile for the md device.
	 */
	if (blk_integrity_register(mddev->gendisk,
			bdev_get_integrity(reference->bdev)) != 0) {
		printk(KERN_ERR "md: failed to register integrity for %s\n",
			mdname(mddev));
		return -EINVAL;
	}
	printk(KERN_NOTICE "md: data integrity on %s enabled\n",
		mdname(mddev));
	return 0;
}
EXPORT_SYMBOL(md_integrity_register);

/* Disable data integrity if non-capable/non-matching disk is being added */
void md_integrity_add_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
M
Martin K. Petersen 已提交
1807 1808
{
	struct blk_integrity *bi_rdev = bdev_get_integrity(rdev->bdev);
1809
	struct blk_integrity *bi_mddev = blk_get_integrity(mddev->gendisk);
M
Martin K. Petersen 已提交
1810

1811
	if (!bi_mddev) /* nothing to do */
M
Martin K. Petersen 已提交
1812
		return;
1813
	if (rdev->raid_disk < 0) /* skip spares */
M
Martin K. Petersen 已提交
1814
		return;
1815 1816 1817 1818 1819
	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 已提交
1820
}
1821
EXPORT_SYMBOL(md_integrity_add_rdev);
M
Martin K. Petersen 已提交
1822

L
Linus Torvalds 已提交
1823 1824
static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
{
1825
	char b[BDEVNAME_SIZE];
1826
	struct kobject *ko;
1827
	char *s;
1828
	int err;
L
Linus Torvalds 已提交
1829 1830 1831 1832 1833

	if (rdev->mddev) {
		MD_BUG();
		return -EINVAL;
	}
1834 1835 1836 1837 1838

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

1839 1840 1841
	/* make sure rdev->sectors exceeds mddev->dev_sectors */
	if (rdev->sectors && (mddev->dev_sectors == 0 ||
			rdev->sectors < mddev->dev_sectors)) {
1842 1843 1844 1845 1846 1847 1848 1849
		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
1850
			mddev->dev_sectors = rdev->sectors;
1851
	}
L
Linus Torvalds 已提交
1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866

	/* Verify rdev->desc_nr is unique.
	 * If it is -1, assign a free number, else
	 * check number is not in use
	 */
	if (rdev->desc_nr < 0) {
		int choice = 0;
		if (mddev->pers) choice = mddev->raid_disks;
		while (find_rdev_nr(mddev, choice))
			choice++;
		rdev->desc_nr = choice;
	} else {
		if (find_rdev_nr(mddev, rdev->desc_nr))
			return -EBUSY;
	}
1867 1868 1869 1870 1871
	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;
	}
1872
	bdevname(rdev->bdev,b);
1873
	while ( (s=strchr(b, '/')) != NULL)
1874
		*s = '!';
1875

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

1879
	if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
1880
		goto fail;
1881

T
Tejun Heo 已提交
1882
	ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
N
NeilBrown 已提交
1883 1884 1885
	if (sysfs_create_link(&rdev->kobj, ko, "block"))
		/* failure here is OK */;
	rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
1886

1887
	list_add_rcu(&rdev->same_set, &mddev->disks);
1888
	bd_claim_by_disk(rdev->bdev, rdev->bdev->bd_holder, mddev->gendisk);
1889 1890 1891

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

L
Linus Torvalds 已提交
1893
	return 0;
1894 1895 1896 1897 1898

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

1901
static void md_delayed_delete(struct work_struct *ws)
1902 1903 1904
{
	mdk_rdev_t *rdev = container_of(ws, mdk_rdev_t, del_work);
	kobject_del(&rdev->kobj);
1905
	kobject_put(&rdev->kobj);
1906 1907
}

L
Linus Torvalds 已提交
1908 1909 1910 1911 1912 1913 1914
static void unbind_rdev_from_array(mdk_rdev_t * rdev)
{
	char b[BDEVNAME_SIZE];
	if (!rdev->mddev) {
		MD_BUG();
		return;
	}
1915
	bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
1916
	list_del_rcu(&rdev->same_set);
L
Linus Torvalds 已提交
1917 1918
	printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
	rdev->mddev = NULL;
1919
	sysfs_remove_link(&rdev->kobj, "block");
1920 1921
	sysfs_put(rdev->sysfs_state);
	rdev->sysfs_state = NULL;
1922
	/* We need to delay this, otherwise we can deadlock when
1923 1924
	 * writing to 'remove' to "dev/state".  We also need
	 * to delay it due to rcu usage.
1925
	 */
1926
	synchronize_rcu();
1927 1928
	INIT_WORK(&rdev->del_work, md_delayed_delete);
	kobject_get(&rdev->kobj);
T
Tejun Heo 已提交
1929
	queue_work(md_misc_wq, &rdev->del_work);
L
Linus Torvalds 已提交
1930 1931 1932 1933 1934 1935 1936
}

/*
 * prevent the device from being mounted, repartitioned or
 * otherwise reused by a RAID array (or any other kernel
 * subsystem), by bd_claiming the device.
 */
1937
static int lock_rdev(mdk_rdev_t *rdev, dev_t dev, int shared)
L
Linus Torvalds 已提交
1938 1939 1940 1941 1942
{
	int err = 0;
	struct block_device *bdev;
	char b[BDEVNAME_SIZE];

1943
	bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
L
Linus Torvalds 已提交
1944 1945 1946 1947 1948
	if (IS_ERR(bdev)) {
		printk(KERN_ERR "md: could not open %s.\n",
			__bdevname(dev, b));
		return PTR_ERR(bdev);
	}
1949
	err = bd_claim(bdev, shared ? (mdk_rdev_t *)lock_rdev : rdev);
L
Linus Torvalds 已提交
1950 1951 1952
	if (err) {
		printk(KERN_ERR "md: could not bd_claim %s.\n",
			bdevname(bdev, b));
A
Al Viro 已提交
1953
		blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
L
Linus Torvalds 已提交
1954 1955
		return err;
	}
1956 1957
	if (!shared)
		set_bit(AllReserved, &rdev->flags);
L
Linus Torvalds 已提交
1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968
	rdev->bdev = bdev;
	return err;
}

static void unlock_rdev(mdk_rdev_t *rdev)
{
	struct block_device *bdev = rdev->bdev;
	rdev->bdev = NULL;
	if (!bdev)
		MD_BUG();
	bd_release(bdev);
A
Al Viro 已提交
1969
	blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
L
Linus Torvalds 已提交
1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982
}

void md_autodetect_dev(dev_t dev);

static void export_rdev(mdk_rdev_t * rdev)
{
	char b[BDEVNAME_SIZE];
	printk(KERN_INFO "md: export_rdev(%s)\n",
		bdevname(rdev->bdev,b));
	if (rdev->mddev)
		MD_BUG();
	free_disk_sb(rdev);
#ifndef MODULE
1983 1984
	if (test_bit(AutoDetected, &rdev->flags))
		md_autodetect_dev(rdev->bdev->bd_dev);
L
Linus Torvalds 已提交
1985 1986
#endif
	unlock_rdev(rdev);
1987
	kobject_put(&rdev->kobj);
L
Linus Torvalds 已提交
1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
}

static void kick_rdev_from_array(mdk_rdev_t * rdev)
{
	unbind_rdev_from_array(rdev);
	export_rdev(rdev);
}

static void export_array(mddev_t *mddev)
{
1998
	mdk_rdev_t *rdev, *tmp;
L
Linus Torvalds 已提交
1999

2000
	rdev_for_each(rdev, tmp, mddev) {
L
Linus Torvalds 已提交
2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018
		if (!rdev->mddev) {
			MD_BUG();
			continue;
		}
		kick_rdev_from_array(rdev);
	}
	if (!list_empty(&mddev->disks))
		MD_BUG();
	mddev->raid_disks = 0;
	mddev->major_version = 0;
}

static void print_desc(mdp_disk_t *desc)
{
	printk(" DISK<N:%d,(%d,%d),R:%d,S:%d>\n", desc->number,
		desc->major,desc->minor,desc->raid_disk,desc->state);
}

2019
static void print_sb_90(mdp_super_t *sb)
L
Linus Torvalds 已提交
2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
{
	int i;

	printk(KERN_INFO 
		"md:  SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n",
		sb->major_version, sb->minor_version, sb->patch_version,
		sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3,
		sb->ctime);
	printk(KERN_INFO "md:     L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n",
		sb->level, sb->size, sb->nr_disks, sb->raid_disks,
		sb->md_minor, sb->layout, sb->chunk_size);
	printk(KERN_INFO "md:     UT:%08x ST:%d AD:%d WD:%d"
		" FD:%d SD:%d CSUM:%08x E:%08lx\n",
		sb->utime, sb->state, sb->active_disks, sb->working_disks,
		sb->failed_disks, sb->spare_disks,
		sb->sb_csum, (unsigned long)sb->events_lo);

	printk(KERN_INFO);
	for (i = 0; i < MD_SB_DISKS; i++) {
		mdp_disk_t *desc;

		desc = sb->disks + i;
		if (desc->number || desc->major || desc->minor ||
		    desc->raid_disk || (desc->state && (desc->state != 4))) {
			printk("     D %2d: ", i);
			print_desc(desc);
		}
	}
	printk(KERN_INFO "md:     THIS: ");
	print_desc(&sb->this_disk);
2050
}
L
Linus Torvalds 已提交
2051

2052 2053 2054 2055 2056
static void print_sb_1(struct mdp_superblock_1 *sb)
{
	__u8 *uuid;

	uuid = sb->set_uuid;
2057
	printk(KERN_INFO
2058
	       "md:  SB: (V:%u) (F:0x%08x) Array-ID:<%pU>\n"
2059
	       "md:    Name: \"%s\" CT:%llu\n",
2060 2061
		le32_to_cpu(sb->major_version),
		le32_to_cpu(sb->feature_map),
2062
		uuid,
2063 2064 2065 2066 2067
		sb->set_name,
		(unsigned long long)le64_to_cpu(sb->ctime)
		       & MD_SUPERBLOCK_1_TIME_SEC_MASK);

	uuid = sb->device_uuid;
2068 2069
	printk(KERN_INFO
	       "md:       L%u SZ%llu RD:%u LO:%u CS:%u DO:%llu DS:%llu SO:%llu"
2070
			" RO:%llu\n"
2071
	       "md:     Dev:%08x UUID: %pU\n"
2072 2073
	       "md:       (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
	       "md:         (MaxDev:%u) \n",
2074 2075 2076 2077 2078 2079 2080 2081 2082 2083
		le32_to_cpu(sb->level),
		(unsigned long long)le64_to_cpu(sb->size),
		le32_to_cpu(sb->raid_disks),
		le32_to_cpu(sb->layout),
		le32_to_cpu(sb->chunksize),
		(unsigned long long)le64_to_cpu(sb->data_offset),
		(unsigned long long)le64_to_cpu(sb->data_size),
		(unsigned long long)le64_to_cpu(sb->super_offset),
		(unsigned long long)le64_to_cpu(sb->recovery_offset),
		le32_to_cpu(sb->dev_number),
2084
		uuid,
2085 2086 2087 2088 2089 2090 2091
		sb->devflags,
		(unsigned long long)le64_to_cpu(sb->utime) & MD_SUPERBLOCK_1_TIME_SEC_MASK,
		(unsigned long long)le64_to_cpu(sb->events),
		(unsigned long long)le64_to_cpu(sb->resync_offset),
		le32_to_cpu(sb->sb_csum),
		le32_to_cpu(sb->max_dev)
		);
L
Linus Torvalds 已提交
2092 2093
}

2094
static void print_rdev(mdk_rdev_t *rdev, int major_version)
L
Linus Torvalds 已提交
2095 2096
{
	char b[BDEVNAME_SIZE];
2097 2098
	printk(KERN_INFO "md: rdev %s, Sect:%08llu F:%d S:%d DN:%u\n",
		bdevname(rdev->bdev, b), (unsigned long long)rdev->sectors,
2099 2100
	        test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags),
	        rdev->desc_nr);
L
Linus Torvalds 已提交
2101
	if (rdev->sb_loaded) {
2102 2103 2104 2105 2106 2107 2108 2109 2110
		printk(KERN_INFO "md: rdev superblock (MJ:%d):\n", major_version);
		switch (major_version) {
		case 0:
			print_sb_90((mdp_super_t*)page_address(rdev->sb_page));
			break;
		case 1:
			print_sb_1((struct mdp_superblock_1 *)page_address(rdev->sb_page));
			break;
		}
L
Linus Torvalds 已提交
2111 2112 2113 2114
	} else
		printk(KERN_INFO "md: no rdev superblock!\n");
}

2115
static void md_print_devices(void)
L
Linus Torvalds 已提交
2116
{
2117
	struct list_head *tmp;
L
Linus Torvalds 已提交
2118 2119 2120 2121 2122 2123 2124 2125
	mdk_rdev_t *rdev;
	mddev_t *mddev;
	char b[BDEVNAME_SIZE];

	printk("\n");
	printk("md:	**********************************\n");
	printk("md:	* <COMPLETE RAID STATE PRINTOUT> *\n");
	printk("md:	**********************************\n");
2126
	for_each_mddev(mddev, tmp) {
L
Linus Torvalds 已提交
2127

2128 2129 2130 2131
		if (mddev->bitmap)
			bitmap_print_sb(mddev->bitmap);
		else
			printk("%s: ", mdname(mddev));
2132
		list_for_each_entry(rdev, &mddev->disks, same_set)
L
Linus Torvalds 已提交
2133 2134 2135
			printk("<%s>", bdevname(rdev->bdev,b));
		printk("\n");

2136
		list_for_each_entry(rdev, &mddev->disks, same_set)
2137
			print_rdev(rdev, mddev->major_version);
L
Linus Torvalds 已提交
2138 2139 2140 2141 2142 2143
	}
	printk("md:	**********************************\n");
	printk("\n");
}


2144
static void sync_sbs(mddev_t * mddev, int nospares)
L
Linus Torvalds 已提交
2145
{
2146 2147 2148 2149 2150 2151
	/* 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)
	 */
L
Linus Torvalds 已提交
2152
	mdk_rdev_t *rdev;
2153
	list_for_each_entry(rdev, &mddev->disks, same_set) {
2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164
		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 {
			super_types[mddev->major_version].
				sync_super(mddev, rdev);
			rdev->sb_loaded = 1;
		}
L
Linus Torvalds 已提交
2165 2166 2167
	}
}

2168
static void md_update_sb(mddev_t * mddev, int force_change)
L
Linus Torvalds 已提交
2169 2170
{
	mdk_rdev_t *rdev;
2171
	int sync_req;
2172
	int nospares = 0;
L
Linus Torvalds 已提交
2173 2174

repeat:
2175 2176 2177 2178 2179 2180 2181 2182 2183
	/* First make sure individual recovery_offsets are correct */
	list_for_each_entry(rdev, &mddev->disks, same_set) {
		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;

	}	
2184
	if (!mddev->persistent) {
2185
		clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2186
		clear_bit(MD_CHANGE_DEVS, &mddev->flags);
2187 2188
		if (!mddev->external)
			clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2189 2190 2191 2192
		wake_up(&mddev->sb_wait);
		return;
	}

2193
	spin_lock_irq(&mddev->write_lock);
2194

2195 2196
	mddev->utime = get_seconds();

2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207
	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)
2208 2209 2210 2211 2212 2213 2214 2215 2216
		/* 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.
		 */
2217
		nospares = 0;
2218

2219
	sync_req = mddev->in_sync;
2220 2221 2222

	/* 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 */
2223
	if (nospares
2224
	    && (mddev->in_sync && mddev->recovery_cp == MaxSector)
2225 2226
	    && mddev->can_decrease_events
	    && mddev->events != 1) {
2227
		mddev->events--;
2228 2229
		mddev->can_decrease_events = 0;
	} else {
2230 2231
		/* otherwise we have to go forward and ... */
		mddev->events ++;
2232
		mddev->can_decrease_events = nospares;
2233
	}
L
Linus Torvalds 已提交
2234 2235 2236 2237 2238 2239 2240 2241 2242 2243

	if (!mddev->events) {
		/*
		 * oops, 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:
		 */
		MD_BUG();
		mddev->events --;
	}
2244
	sync_sbs(mddev, nospares);
2245
	spin_unlock_irq(&mddev->write_lock);
L
Linus Torvalds 已提交
2246 2247 2248 2249 2250

	dprintk(KERN_INFO 
		"md: updating %s RAID superblock on device (in sync %d)\n",
		mdname(mddev),mddev->in_sync);

2251
	bitmap_update_sb(mddev->bitmap);
2252
	list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
2253 2254
		char b[BDEVNAME_SIZE];
		dprintk(KERN_INFO "md: ");
2255 2256
		if (rdev->sb_loaded != 1)
			continue; /* no noise on spare devices */
2257
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
2258 2259 2260
			dprintk("(skipping faulty ");

		dprintk("%s ", bdevname(rdev->bdev,b));
2261
		if (!test_bit(Faulty, &rdev->flags)) {
2262
			md_super_write(mddev,rdev,
2263
				       rdev->sb_start, rdev->sb_size,
2264 2265 2266
				       rdev->sb_page);
			dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
				bdevname(rdev->bdev,b),
2267
				(unsigned long long)rdev->sb_start);
2268
			rdev->sb_events = mddev->events;
2269

L
Linus Torvalds 已提交
2270 2271
		} else
			dprintk(")\n");
2272
		if (mddev->level == LEVEL_MULTIPATH)
L
Linus Torvalds 已提交
2273 2274 2275
			/* only need to write one superblock... */
			break;
	}
2276
	md_super_wait(mddev);
2277
	/* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
2278

2279
	spin_lock_irq(&mddev->write_lock);
2280 2281
	if (mddev->in_sync != sync_req ||
	    test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
2282
		/* have to write it out again */
2283
		spin_unlock_irq(&mddev->write_lock);
2284 2285
		goto repeat;
	}
2286
	clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2287
	spin_unlock_irq(&mddev->write_lock);
2288
	wake_up(&mddev->sb_wait);
2289 2290
	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
		sysfs_notify(&mddev->kobj, NULL, "sync_completed");
2291

L
Linus Torvalds 已提交
2292 2293
}

2294
/* words written to sysfs files may, or may not, be \n terminated.
2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
 * 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;
}

2314 2315 2316 2317 2318 2319 2320
struct rdev_sysfs_entry {
	struct attribute attr;
	ssize_t (*show)(mdk_rdev_t *, char *);
	ssize_t (*store)(mdk_rdev_t *, const char *, size_t);
};

static ssize_t
2321
state_show(mdk_rdev_t *rdev, char *page)
2322 2323
{
	char *sep = "";
2324
	size_t len = 0;
2325

2326
	if (test_bit(Faulty, &rdev->flags)) {
2327 2328 2329
		len+= sprintf(page+len, "%sfaulty",sep);
		sep = ",";
	}
2330
	if (test_bit(In_sync, &rdev->flags)) {
2331 2332 2333
		len += sprintf(page+len, "%sin_sync",sep);
		sep = ",";
	}
2334 2335 2336 2337
	if (test_bit(WriteMostly, &rdev->flags)) {
		len += sprintf(page+len, "%swrite_mostly",sep);
		sep = ",";
	}
2338 2339 2340 2341
	if (test_bit(Blocked, &rdev->flags)) {
		len += sprintf(page+len, "%sblocked", sep);
		sep = ",";
	}
2342 2343
	if (!test_bit(Faulty, &rdev->flags) &&
	    !test_bit(In_sync, &rdev->flags)) {
2344 2345 2346 2347 2348 2349
		len += sprintf(page+len, "%sspare", sep);
		sep = ",";
	}
	return len+sprintf(page+len, "\n");
}

2350 2351 2352 2353 2354 2355
static ssize_t
state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
{
	/* can write
	 *  faulty  - simulates and error
	 *  remove  - disconnects the device
2356 2357
	 *  writemostly - sets write_mostly
	 *  -writemostly - clears write_mostly
2358 2359
	 *  blocked - sets the Blocked flag
	 *  -blocked - clears the Blocked flag
2360
	 *  insync - sets Insync providing device isn't active
2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371
	 */
	int err = -EINVAL;
	if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
		md_error(rdev->mddev, rdev);
		err = 0;
	} else if (cmd_match(buf, "remove")) {
		if (rdev->raid_disk >= 0)
			err = -EBUSY;
		else {
			mddev_t *mddev = rdev->mddev;
			kick_rdev_from_array(rdev);
2372 2373
			if (mddev->pers)
				md_update_sb(mddev, 1);
2374 2375 2376
			md_new_event(mddev);
			err = 0;
		}
2377 2378 2379 2380 2381
	} else if (cmd_match(buf, "writemostly")) {
		set_bit(WriteMostly, &rdev->flags);
		err = 0;
	} else if (cmd_match(buf, "-writemostly")) {
		clear_bit(WriteMostly, &rdev->flags);
2382 2383 2384 2385 2386 2387 2388 2389 2390 2391
		err = 0;
	} else if (cmd_match(buf, "blocked")) {
		set_bit(Blocked, &rdev->flags);
		err = 0;
	} else if (cmd_match(buf, "-blocked")) {
		clear_bit(Blocked, &rdev->flags);
		wake_up(&rdev->blocked_wait);
		set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
		md_wakeup_thread(rdev->mddev->thread);

2392 2393 2394
		err = 0;
	} else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
		set_bit(In_sync, &rdev->flags);
2395
		err = 0;
2396
	}
N
NeilBrown 已提交
2397 2398
	if (!err)
		sysfs_notify_dirent_safe(rdev->sysfs_state);
2399 2400
	return err ? err : len;
}
2401 2402
static struct rdev_sysfs_entry rdev_state =
__ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store);
2403

2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421
static ssize_t
errors_show(mdk_rdev_t *rdev, char *page)
{
	return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
}

static ssize_t
errors_store(mdk_rdev_t *rdev, const char *buf, size_t len)
{
	char *e;
	unsigned long n = simple_strtoul(buf, &e, 10);
	if (*buf && (*e == 0 || *e == '\n')) {
		atomic_set(&rdev->corrected_errors, n);
		return len;
	}
	return -EINVAL;
}
static struct rdev_sysfs_entry rdev_errors =
2422
__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
2423

2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
static ssize_t
slot_show(mdk_rdev_t *rdev, char *page)
{
	if (rdev->raid_disk < 0)
		return sprintf(page, "none\n");
	else
		return sprintf(page, "%d\n", rdev->raid_disk);
}

static ssize_t
slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
{
	char *e;
2437 2438
	int err;
	char nm[20];
2439 2440 2441 2442 2443
	int slot = simple_strtoul(buf, &e, 10);
	if (strncmp(buf, "none", 4)==0)
		slot = -1;
	else if (e==buf || (*e && *e!= '\n'))
		return -EINVAL;
2444
	if (rdev->mddev->pers && slot == -1) {
2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462
		/* 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 */
		if (rdev->mddev->pers->hot_add_disk == NULL)
			return -EINVAL;
		err = rdev->mddev->pers->
			hot_remove_disk(rdev->mddev, rdev->raid_disk);
		if (err)
			return err;
		sprintf(nm, "rd%d", rdev->raid_disk);
		sysfs_remove_link(&rdev->mddev->kobj, nm);
2463
		rdev->raid_disk = -1;
2464 2465
		set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
		md_wakeup_thread(rdev->mddev->thread);
2466 2467 2468
	} else if (rdev->mddev->pers) {
		mdk_rdev_t *rdev2;
		/* Activating a spare .. or possibly reactivating
2469
		 * if we ever get bitmaps working here.
2470 2471 2472 2473 2474 2475 2476 2477
		 */

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

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

2478
		list_for_each_entry(rdev2, &rdev->mddev->disks, same_set)
2479 2480 2481 2482 2483 2484 2485 2486 2487 2488
			if (rdev2->raid_disk == slot)
				return -EEXIST;

		rdev->raid_disk = slot;
		if (test_bit(In_sync, &rdev->flags))
			rdev->saved_raid_disk = slot;
		else
			rdev->saved_raid_disk = -1;
		err = rdev->mddev->pers->
			hot_add_disk(rdev->mddev, rdev);
2489
		if (err) {
2490 2491
			rdev->raid_disk = -1;
			return err;
2492
		} else
N
NeilBrown 已提交
2493
			sysfs_notify_dirent_safe(rdev->sysfs_state);
2494 2495
		sprintf(nm, "rd%d", rdev->raid_disk);
		if (sysfs_create_link(&rdev->mddev->kobj, &rdev->kobj, nm))
N
NeilBrown 已提交
2496
			/* failure here is OK */;
2497
		/* don't wakeup anyone, leave that to userspace. */
2498 2499 2500 2501 2502
	} else {
		if (slot >= rdev->mddev->raid_disks)
			return -ENOSPC;
		rdev->raid_disk = slot;
		/* assume it is working */
2503 2504
		clear_bit(Faulty, &rdev->flags);
		clear_bit(WriteMostly, &rdev->flags);
2505
		set_bit(In_sync, &rdev->flags);
N
NeilBrown 已提交
2506
		sysfs_notify_dirent_safe(rdev->sysfs_state);
2507
	}
2508 2509 2510 2511 2512
	return len;
}


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

2515 2516 2517
static ssize_t
offset_show(mdk_rdev_t *rdev, char *page)
{
2518
	return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
2519 2520 2521 2522 2523 2524 2525 2526 2527
}

static ssize_t
offset_store(mdk_rdev_t *rdev, const char *buf, size_t len)
{
	char *e;
	unsigned long long offset = simple_strtoull(buf, &e, 10);
	if (e==buf || (*e && *e != '\n'))
		return -EINVAL;
2528
	if (rdev->mddev->pers && rdev->raid_disk >= 0)
2529
		return -EBUSY;
2530
	if (rdev->sectors && rdev->mddev->external)
2531 2532 2533
		/* Must set offset before size, so overlap checks
		 * can be sane */
		return -EBUSY;
2534 2535 2536 2537 2538
	rdev->data_offset = offset;
	return len;
}

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

2541 2542 2543
static ssize_t
rdev_size_show(mdk_rdev_t *rdev, char *page)
{
2544
	return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
2545 2546
}

2547 2548 2549 2550 2551 2552 2553 2554 2555 2556
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 已提交
2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575
static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
{
	unsigned long long blocks;
	sector_t new;

	if (strict_strtoull(buf, 10, &blocks) < 0)
		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;
}

2576 2577 2578
static ssize_t
rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
{
2579
	mddev_t *my_mddev = rdev->mddev;
2580
	sector_t oldsectors = rdev->sectors;
D
Dan Williams 已提交
2581
	sector_t sectors;
2582

D
Dan Williams 已提交
2583
	if (strict_blocks_to_sectors(buf, &sectors) < 0)
N
Neil Brown 已提交
2584
		return -EINVAL;
2585
	if (my_mddev->pers && rdev->raid_disk >= 0) {
N
Neil Brown 已提交
2586
		if (my_mddev->persistent) {
2587 2588 2589
			sectors = super_types[my_mddev->major_version].
				rdev_size_change(rdev, sectors);
			if (!sectors)
2590
				return -EBUSY;
2591
		} else if (!sectors)
2592
			sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
2593
				rdev->data_offset;
2594
	}
2595
	if (sectors < my_mddev->dev_sectors)
2596
		return -EINVAL; /* component must fit device */
2597

2598 2599
	rdev->sectors = sectors;
	if (sectors > oldsectors && my_mddev->external) {
2600 2601
		/* need to check that all other rdevs with the same ->bdev
		 * do not overlap.  We need to unlock the mddev to avoid
2602
		 * a deadlock.  We have already changed rdev->sectors, and if
2603 2604 2605 2606
		 * we have to change it back, we will have the lock again.
		 */
		mddev_t *mddev;
		int overlap = 0;
2607
		struct list_head *tmp;
2608

2609
		mddev_unlock(my_mddev);
2610
		for_each_mddev(mddev, tmp) {
2611 2612 2613
			mdk_rdev_t *rdev2;

			mddev_lock(mddev);
2614
			list_for_each_entry(rdev2, &mddev->disks, same_set)
2615 2616 2617
				if (test_bit(AllReserved, &rdev2->flags) ||
				    (rdev->bdev == rdev2->bdev &&
				     rdev != rdev2 &&
2618
				     overlaps(rdev->data_offset, rdev->sectors,
2619
					      rdev2->data_offset,
2620
					      rdev2->sectors))) {
2621 2622 2623 2624 2625 2626 2627 2628 2629
					overlap = 1;
					break;
				}
			mddev_unlock(mddev);
			if (overlap) {
				mddev_put(mddev);
				break;
			}
		}
2630
		mddev_lock(my_mddev);
2631 2632 2633
		if (overlap) {
			/* Someone else could have slipped in a size
			 * change here, but doing so is just silly.
2634
			 * We put oldsectors back because we *know* it is
2635 2636 2637
			 * safe, and trust userspace not to race with
			 * itself
			 */
2638
			rdev->sectors = oldsectors;
2639 2640 2641
			return -EBUSY;
		}
	}
2642 2643 2644 2645
	return len;
}

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

2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683

static ssize_t recovery_start_show(mdk_rdev_t *rdev, char *page)
{
	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);
}

static ssize_t recovery_start_store(mdk_rdev_t *rdev, const char *buf, size_t len)
{
	unsigned long long recovery_start;

	if (cmd_match(buf, "none"))
		recovery_start = MaxSector;
	else if (strict_strtoull(buf, 10, &recovery_start))
		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);

2684 2685
static struct attribute *rdev_default_attrs[] = {
	&rdev_state.attr,
2686
	&rdev_errors.attr,
2687
	&rdev_slot.attr,
2688
	&rdev_offset.attr,
2689
	&rdev_size.attr,
2690
	&rdev_recovery_start.attr,
2691 2692 2693 2694 2695 2696 2697
	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);
	mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
2698 2699
	mddev_t *mddev = rdev->mddev;
	ssize_t rv;
2700 2701 2702

	if (!entry->show)
		return -EIO;
2703 2704 2705 2706 2707 2708 2709 2710 2711 2712

	rv = mddev ? mddev_lock(mddev) : -EBUSY;
	if (!rv) {
		if (rdev->mddev == NULL)
			rv = -EBUSY;
		else
			rv = entry->show(rdev, page);
		mddev_unlock(mddev);
	}
	return rv;
2713 2714 2715 2716 2717 2718 2719 2720
}

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);
	mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
2721 2722
	ssize_t rv;
	mddev_t *mddev = rdev->mddev;
2723 2724 2725

	if (!entry->store)
		return -EIO;
2726 2727
	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
2728
	rv = mddev ? mddev_lock(mddev): -EBUSY;
2729
	if (!rv) {
2730 2731 2732 2733
		if (rdev->mddev == NULL)
			rv = -EBUSY;
		else
			rv = entry->store(rdev, page, length);
2734
		mddev_unlock(mddev);
2735 2736
	}
	return rv;
2737 2738 2739 2740 2741 2742 2743
}

static void rdev_free(struct kobject *ko)
{
	mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj);
	kfree(rdev);
}
2744
static const struct sysfs_ops rdev_sysfs_ops = {
2745 2746 2747 2748 2749 2750 2751 2752 2753
	.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,
};

N
NeilBrown 已提交
2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771
void md_rdev_init(mdk_rdev_t *rdev)
{
	rdev->desc_nr = -1;
	rdev->saved_raid_disk = -1;
	rdev->raid_disk = -1;
	rdev->flags = 0;
	rdev->data_offset = 0;
	rdev->sb_events = 0;
	rdev->last_read_error.tv_sec  = 0;
	rdev->last_read_error.tv_nsec = 0;
	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);
}
EXPORT_SYMBOL_GPL(md_rdev_init);
L
Linus Torvalds 已提交
2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788
/*
 * 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.
 */
static mdk_rdev_t *md_import_device(dev_t newdev, int super_format, int super_minor)
{
	char b[BDEVNAME_SIZE];
	int err;
	mdk_rdev_t *rdev;
	sector_t size;

2789
	rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
L
Linus Torvalds 已提交
2790 2791 2792 2793 2794
	if (!rdev) {
		printk(KERN_ERR "md: could not alloc mem for new device!\n");
		return ERR_PTR(-ENOMEM);
	}

N
NeilBrown 已提交
2795
	md_rdev_init(rdev);
L
Linus Torvalds 已提交
2796 2797 2798
	if ((err = alloc_disk_sb(rdev)))
		goto abort_free;

2799
	err = lock_rdev(rdev, newdev, super_format == -2);
L
Linus Torvalds 已提交
2800 2801 2802
	if (err)
		goto abort_free;

2803
	kobject_init(&rdev->kobj, &rdev_ktype);
2804

2805
	size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
L
Linus Torvalds 已提交
2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817
	if (!size) {
		printk(KERN_WARNING 
			"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) {
2818 2819 2820 2821 2822
			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 已提交
2823 2824 2825 2826 2827 2828 2829 2830 2831
			goto abort_free;
		}
		if (err < 0) {
			printk(KERN_WARNING 
				"md: could not read %s's sb, not importing!\n",
				bdevname(rdev->bdev,b));
			goto abort_free;
		}
	}
2832

L
Linus Torvalds 已提交
2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849
	return rdev;

abort_free:
	if (rdev->sb_page) {
		if (rdev->bdev)
			unlock_rdev(rdev);
		free_disk_sb(rdev);
	}
	kfree(rdev);
	return ERR_PTR(err);
}

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


2850
static void analyze_sbs(mddev_t * mddev)
L
Linus Torvalds 已提交
2851 2852
{
	int i;
2853
	mdk_rdev_t *rdev, *freshest, *tmp;
L
Linus Torvalds 已提交
2854 2855 2856
	char b[BDEVNAME_SIZE];

	freshest = NULL;
2857
	rdev_for_each(rdev, tmp, mddev)
L
Linus Torvalds 已提交
2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877
		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"
				" -- removing from array\n", 
				bdevname(rdev->bdev,b));
			kick_rdev_from_array(rdev);
		}


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

	i = 0;
2878
	rdev_for_each(rdev, tmp, mddev) {
2879 2880 2881
		if (mddev->max_disks &&
		    (rdev->desc_nr >= mddev->max_disks ||
		     i > mddev->max_disks)) {
2882 2883 2884 2885 2886 2887 2888
			printk(KERN_WARNING
			       "md: %s: %s: only %d devices permitted\n",
			       mdname(mddev), bdevname(rdev->bdev, b),
			       mddev->max_disks);
			kick_rdev_from_array(rdev);
			continue;
		}
L
Linus Torvalds 已提交
2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900
		if (rdev != freshest)
			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));
				kick_rdev_from_array(rdev);
				continue;
			}
		if (mddev->level == LEVEL_MULTIPATH) {
			rdev->desc_nr = i++;
			rdev->raid_disk = rdev->desc_nr;
2901
			set_bit(In_sync, &rdev->flags);
2902
		} else if (rdev->raid_disk >= (mddev->raid_disks - min(0, mddev->delta_disks))) {
2903 2904
			rdev->raid_disk = -1;
			clear_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
2905 2906 2907 2908
		}
	}
}

2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949
/* Read a fixed-point number.
 * Numbers in sysfs attributes should be in "standard" units where
 * possible, so time should be in seconds.
 * However we internally use a a much smaller unit such as 
 * 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;
}


2950 2951
static void md_safemode_timeout(unsigned long data);

2952 2953 2954 2955 2956 2957 2958 2959 2960 2961
static ssize_t
safe_delay_show(mddev_t *mddev, char *page)
{
	int msec = (mddev->safemode_delay*1000)/HZ;
	return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
}
static ssize_t
safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len)
{
	unsigned long msec;
2962

2963
	if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
2964 2965 2966 2967
		return -EINVAL;
	if (msec == 0)
		mddev->safemode_delay = 0;
	else {
2968
		unsigned long old_delay = mddev->safemode_delay;
2969 2970 2971
		mddev->safemode_delay = (msec*HZ)/1000;
		if (mddev->safemode_delay == 0)
			mddev->safemode_delay = 1;
2972 2973
		if (mddev->safemode_delay < old_delay)
			md_safemode_timeout((unsigned long)mddev);
2974 2975 2976 2977
	}
	return len;
}
static struct md_sysfs_entry md_safe_delay =
2978
__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
2979

2980
static ssize_t
2981
level_show(mddev_t *mddev, char *page)
2982
{
2983
	struct mdk_personality *p = mddev->pers;
2984
	if (p)
2985
		return sprintf(page, "%s\n", p->name);
2986 2987 2988 2989 2990 2991
	else if (mddev->clevel[0])
		return sprintf(page, "%s\n", mddev->clevel);
	else if (mddev->level != LEVEL_NONE)
		return sprintf(page, "%d\n", mddev->level);
	else
		return 0;
2992 2993
}

2994 2995 2996
static ssize_t
level_store(mddev_t *mddev, const char *buf, size_t len)
{
2997
	char clevel[16];
2998
	ssize_t rv = len;
2999
	struct mdk_personality *pers;
3000
	long level;
3001
	void *priv;
3002
	mdk_rdev_t *rdev;
3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022

	if (mddev->pers == NULL) {
		if (len == 0)
			return 0;
		if (len >= sizeof(mddev->clevel))
			return -ENOSPC;
		strncpy(mddev->clevel, buf, len);
		if (mddev->clevel[len-1] == '\n')
			len--;
		mddev->clevel[len] = 0;
		mddev->level = LEVEL_NONE;
		return rv;
	}

	/* 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.
	 */

3023 3024 3025
	if (mddev->sync_thread ||
	    mddev->reshape_position != MaxSector ||
	    mddev->sysfs_active)
3026
		return -EBUSY;
3027 3028 3029 3030 3031 3032 3033 3034

	if (!mddev->pers->quiesce) {
		printk(KERN_WARNING "md: %s: %s does not support online personality change\n",
		       mdname(mddev), mddev->pers->name);
		return -EINVAL;
	}

	/* Now find the new personality */
3035
	if (len == 0 || len >= sizeof(clevel))
3036
		return -EINVAL;
3037 3038
	strncpy(clevel, buf, len);
	if (clevel[len-1] == '\n')
3039
		len--;
3040 3041 3042
	clevel[len] = 0;
	if (strict_strtol(clevel, 10, &level))
		level = LEVEL_NONE;
3043

3044 3045
	if (request_module("md-%s", clevel) != 0)
		request_module("md-level-%s", clevel);
3046
	spin_lock(&pers_lock);
3047
	pers = find_pers(level, clevel);
3048 3049
	if (!pers || !try_module_get(pers->owner)) {
		spin_unlock(&pers_lock);
3050
		printk(KERN_WARNING "md: personality %s not loaded\n", clevel);
3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062
		return -EINVAL;
	}
	spin_unlock(&pers_lock);

	if (pers == mddev->pers) {
		/* Nothing to do! */
		module_put(pers->owner);
		return rv;
	}
	if (!pers->takeover) {
		module_put(pers->owner);
		printk(KERN_WARNING "md: %s: %s does not support personality takeover\n",
3063
		       mdname(mddev), clevel);
3064 3065 3066
		return -EINVAL;
	}

3067 3068 3069
	list_for_each_entry(rdev, &mddev->disks, same_set)
		rdev->new_raid_disk = rdev->raid_disk;

3070 3071 3072 3073 3074 3075 3076
	/* ->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;
3077
		mddev->new_chunk_sectors = mddev->chunk_sectors;
3078 3079 3080 3081
		mddev->raid_disks -= mddev->delta_disks;
		mddev->delta_disks = 0;
		module_put(pers->owner);
		printk(KERN_WARNING "md: %s: %s would not accept array\n",
3082
		       mdname(mddev), clevel);
3083 3084 3085 3086 3087 3088
		return PTR_ERR(priv);
	}

	/* Looks like we have a winner */
	mddev_suspend(mddev);
	mddev->pers->stop(mddev);
3089 3090 3091 3092 3093 3094 3095 3096
	
	if (mddev->pers->sync_request == NULL &&
	    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));
3097
		mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, NULL, "sync_action");
3098 3099 3100 3101 3102 3103 3104 3105
	}		
	if (mddev->pers->sync_request != NULL &&
	    pers->sync_request == NULL) {
		/* need to remove the md_redundancy_group */
		if (mddev->to_remove == NULL)
			mddev->to_remove = &md_redundancy_group;
	}

3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119
	if (mddev->pers->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;
	}

3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137
	list_for_each_entry(rdev, &mddev->disks, same_set) {
		char nm[20];
		if (rdev->raid_disk < 0)
			continue;
		if (rdev->new_raid_disk > mddev->raid_disks)
			rdev->new_raid_disk = -1;
		if (rdev->new_raid_disk == rdev->raid_disk)
			continue;
		sprintf(nm, "rd%d", rdev->raid_disk);
		sysfs_remove_link(&mddev->kobj, nm);
	}
	list_for_each_entry(rdev, &mddev->disks, same_set) {
		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)
3138
			clear_bit(In_sync, &rdev->flags);
3139 3140 3141 3142 3143 3144
		else {
			char nm[20];
			sprintf(nm, "rd%d", rdev->raid_disk);
			if(sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
				printk("md: cannot register %s for %s after level change\n",
				       nm, mdname(mddev));
3145
		}
3146 3147 3148
	}

	module_put(mddev->pers->owner);
3149 3150 3151 3152 3153
	mddev->pers = pers;
	mddev->private = priv;
	strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
	mddev->level = mddev->new_level;
	mddev->layout = mddev->new_layout;
3154
	mddev->chunk_sectors = mddev->new_chunk_sectors;
3155
	mddev->delta_disks = 0;
3156 3157 3158 3159 3160 3161 3162
	if (mddev->pers->sync_request == NULL) {
		/* this is now an array without redundancy, so
		 * it must always be in_sync
		 */
		mddev->in_sync = 1;
		del_timer_sync(&mddev->safemode_timer);
	}
3163 3164 3165 3166 3167
	pers->run(mddev);
	mddev_resume(mddev);
	set_bit(MD_CHANGE_DEVS, &mddev->flags);
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	md_wakeup_thread(mddev->thread);
3168
	sysfs_notify(&mddev->kobj, NULL, "level");
3169
	md_new_event(mddev);
3170 3171 3172 3173
	return rv;
}

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

3176 3177 3178 3179 3180

static ssize_t
layout_show(mddev_t *mddev, char *page)
{
	/* just a number, not meaningful for all levels */
3181 3182 3183 3184
	if (mddev->reshape_position != MaxSector &&
	    mddev->layout != mddev->new_layout)
		return sprintf(page, "%d (%d)\n",
			       mddev->new_layout, mddev->layout);
3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196
	return sprintf(page, "%d\n", mddev->layout);
}

static ssize_t
layout_store(mddev_t *mddev, const char *buf, size_t len)
{
	char *e;
	unsigned long n = simple_strtoul(buf, &e, 10);

	if (!*buf || (*e && *e != '\n'))
		return -EINVAL;

3197 3198
	if (mddev->pers) {
		int err;
3199
		if (mddev->pers->check_reshape == NULL)
3200
			return -EBUSY;
3201
		mddev->new_layout = n;
3202
		err = mddev->pers->check_reshape(mddev);
3203 3204
		if (err) {
			mddev->new_layout = mddev->layout;
3205
			return err;
3206
		}
3207
	} else {
3208
		mddev->new_layout = n;
3209 3210 3211
		if (mddev->reshape_position == MaxSector)
			mddev->layout = n;
	}
3212 3213 3214
	return len;
}
static struct md_sysfs_entry md_layout =
3215
__ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
3216 3217


3218
static ssize_t
3219
raid_disks_show(mddev_t *mddev, char *page)
3220
{
3221 3222
	if (mddev->raid_disks == 0)
		return 0;
3223 3224 3225 3226
	if (mddev->reshape_position != MaxSector &&
	    mddev->delta_disks != 0)
		return sprintf(page, "%d (%d)\n", mddev->raid_disks,
			       mddev->raid_disks - mddev->delta_disks);
3227 3228 3229
	return sprintf(page, "%d\n", mddev->raid_disks);
}

3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243
static int update_raid_disks(mddev_t *mddev, int raid_disks);

static ssize_t
raid_disks_store(mddev_t *mddev, const char *buf, size_t len)
{
	char *e;
	int rv = 0;
	unsigned long n = simple_strtoul(buf, &e, 10);

	if (!*buf || (*e && *e != '\n'))
		return -EINVAL;

	if (mddev->pers)
		rv = update_raid_disks(mddev, n);
3244 3245 3246 3247 3248
	else if (mddev->reshape_position != MaxSector) {
		int olddisks = mddev->raid_disks - mddev->delta_disks;
		mddev->delta_disks = n - olddisks;
		mddev->raid_disks = n;
	} else
3249 3250 3251 3252
		mddev->raid_disks = n;
	return rv ? rv : len;
}
static struct md_sysfs_entry md_raid_disks =
3253
__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
3254

3255 3256 3257
static ssize_t
chunk_size_show(mddev_t *mddev, char *page)
{
3258
	if (mddev->reshape_position != MaxSector &&
3259 3260 3261
	    mddev->chunk_sectors != mddev->new_chunk_sectors)
		return sprintf(page, "%d (%d)\n",
			       mddev->new_chunk_sectors << 9,
3262 3263
			       mddev->chunk_sectors << 9);
	return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274
}

static ssize_t
chunk_size_store(mddev_t *mddev, const char *buf, size_t len)
{
	char *e;
	unsigned long n = simple_strtoul(buf, &e, 10);

	if (!*buf || (*e && *e != '\n'))
		return -EINVAL;

3275 3276
	if (mddev->pers) {
		int err;
3277
		if (mddev->pers->check_reshape == NULL)
3278
			return -EBUSY;
3279
		mddev->new_chunk_sectors = n >> 9;
3280
		err = mddev->pers->check_reshape(mddev);
3281 3282
		if (err) {
			mddev->new_chunk_sectors = mddev->chunk_sectors;
3283
			return err;
3284
		}
3285
	} else {
3286
		mddev->new_chunk_sectors = n >> 9;
3287
		if (mddev->reshape_position == MaxSector)
3288
			mddev->chunk_sectors = n >> 9;
3289
	}
3290 3291 3292
	return len;
}
static struct md_sysfs_entry md_chunk_size =
3293
__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
3294

3295 3296 3297
static ssize_t
resync_start_show(mddev_t *mddev, char *page)
{
3298 3299
	if (mddev->recovery_cp == MaxSector)
		return sprintf(page, "none\n");
3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310
	return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
}

static ssize_t
resync_start_store(mddev_t *mddev, const char *buf, size_t len)
{
	char *e;
	unsigned long long n = simple_strtoull(buf, &e, 10);

	if (mddev->pers)
		return -EBUSY;
3311 3312 3313
	if (cmd_match(buf, "none"))
		n = MaxSector;
	else if (!*buf || (*e && *e != '\n'))
3314 3315 3316 3317 3318 3319
		return -EINVAL;

	mddev->recovery_cp = n;
	return len;
}
static struct md_sysfs_entry md_resync_start =
3320
__ATTR(resync_start, S_IRUGO|S_IWUSR, resync_start_show, resync_start_store);
3321

3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333
/*
 * 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.
3334
 *     Writing this, if accepted, will block until array is quiescent
3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359
 * 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};
3360
static char *array_states[] = {
3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388
	"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
array_state_show(mddev_t *mddev, char *page)
{
	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;
3389
			else if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
3390
				st = write_pending;
3391 3392 3393 3394 3395 3396 3397 3398
			else if (mddev->safemode)
				st = active_idle;
			else
				st = active;
		}
	else {
		if (list_empty(&mddev->disks) &&
		    mddev->raid_disks == 0 &&
A
Andre Noll 已提交
3399
		    mddev->dev_sectors == 0)
3400 3401 3402 3403 3404 3405 3406
			st = clear;
		else
			st = inactive;
	}
	return sprintf(page, "%s\n", array_states[st]);
}

3407
static int do_md_stop(mddev_t * mddev, int ro, int is_open);
3408
static int md_set_readonly(mddev_t * mddev, int is_open);
3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421
static int do_md_run(mddev_t * mddev);
static int restart_array(mddev_t *mddev);

static ssize_t
array_state_store(mddev_t *mddev, const char *buf, size_t len)
{
	int err = -EINVAL;
	enum array_state st = match_word(buf, array_states);
	switch(st) {
	case bad_word:
		break;
	case clear:
		/* stopping an active array */
3422
		if (atomic_read(&mddev->openers) > 0)
3423
			return -EBUSY;
3424
		err = do_md_stop(mddev, 0, 0);
3425 3426 3427 3428
		break;
	case inactive:
		/* stopping an active array */
		if (mddev->pers) {
3429
			if (atomic_read(&mddev->openers) > 0)
3430
				return -EBUSY;
3431
			err = do_md_stop(mddev, 2, 0);
3432 3433
		} else
			err = 0; /* already inactive */
3434 3435 3436 3437 3438
		break;
	case suspended:
		break; /* not supported yet */
	case readonly:
		if (mddev->pers)
3439
			err = md_set_readonly(mddev, 0);
3440 3441
		else {
			mddev->ro = 1;
3442
			set_disk_ro(mddev->gendisk, 1);
3443 3444 3445 3446 3447
			err = do_md_run(mddev);
		}
		break;
	case read_auto:
		if (mddev->pers) {
3448
			if (mddev->ro == 0)
3449
				err = md_set_readonly(mddev, 0);
3450
			else if (mddev->ro == 1)
3451 3452 3453 3454 3455
				err = restart_array(mddev);
			if (err == 0) {
				mddev->ro = 2;
				set_disk_ro(mddev->gendisk, 0);
			}
3456 3457 3458 3459 3460 3461 3462 3463 3464 3465
		} else {
			mddev->ro = 2;
			err = do_md_run(mddev);
		}
		break;
	case clean:
		if (mddev->pers) {
			restart_array(mddev);
			spin_lock_irq(&mddev->write_lock);
			if (atomic_read(&mddev->writes_pending) == 0) {
3466 3467
				if (mddev->in_sync == 0) {
					mddev->in_sync = 1;
3468 3469
					if (mddev->safemode == 1)
						mddev->safemode = 0;
3470
					set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3471 3472 3473 3474
				}
				err = 0;
			} else
				err = -EBUSY;
3475
			spin_unlock_irq(&mddev->write_lock);
3476 3477
		} else
			err = -EINVAL;
3478 3479 3480 3481
		break;
	case active:
		if (mddev->pers) {
			restart_array(mddev);
3482
			clear_bit(MD_CHANGE_PENDING, &mddev->flags);
3483 3484 3485 3486
			wake_up(&mddev->sb_wait);
			err = 0;
		} else {
			mddev->ro = 0;
3487
			set_disk_ro(mddev->gendisk, 0);
3488 3489 3490 3491 3492 3493 3494 3495 3496 3497
			err = do_md_run(mddev);
		}
		break;
	case write_pending:
	case active_idle:
		/* these cannot be set */
		break;
	}
	if (err)
		return err;
3498
	else {
N
NeilBrown 已提交
3499
		sysfs_notify_dirent_safe(mddev->sysfs_state);
3500
		return len;
3501
	}
3502
}
3503 3504
static struct md_sysfs_entry md_array_state =
__ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
3505

3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528
static ssize_t
max_corrected_read_errors_show(mddev_t *mddev, char *page) {
	return sprintf(page, "%d\n",
		       atomic_read(&mddev->max_corr_read_errors));
}

static ssize_t
max_corrected_read_errors_store(mddev_t *mddev, const char *buf, size_t len)
{
	char *e;
	unsigned long n = simple_strtoul(buf, &e, 10);

	if (*buf && (*e == 0 || *e == '\n')) {
		atomic_set(&mddev->max_corr_read_errors, n);
		return len;
	}
	return -EINVAL;
}

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);

3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573
static ssize_t
null_show(mddev_t *mddev, char *page)
{
	return -EINVAL;
}

static ssize_t
new_dev_store(mddev_t *mddev, const char *buf, size_t len)
{
	/* 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;
	mdk_rdev_t *rdev;
	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;


	if (mddev->persistent) {
		rdev = md_import_device(dev, mddev->major_version,
					mddev->minor_version);
		if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
			mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
						       mdk_rdev_t, same_set);
			err = super_types[mddev->major_version]
				.load_super(rdev, rdev0, mddev->minor_version);
			if (err < 0)
				goto out;
		}
3574 3575 3576
	} else if (mddev->external)
		rdev = md_import_device(dev, -2, -1);
	else
3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588
		rdev = md_import_device(dev, -1, -1);

	if (IS_ERR(rdev))
		return PTR_ERR(rdev);
	err = bind_rdev_to_array(rdev, mddev);
 out:
	if (err)
		export_rdev(rdev);
	return err ? err : len;
}

static struct md_sysfs_entry md_new_device =
3589
__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
3590

3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609
static ssize_t
bitmap_store(mddev_t *mddev, const char *buf, size_t len)
{
	char *end;
	unsigned long chunk, end_chunk;

	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);
3610
		buf = skip_spaces(end);
3611 3612 3613 3614 3615 3616 3617 3618 3619
	}
	bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
out:
	return len;
}

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

3620 3621 3622
static ssize_t
size_show(mddev_t *mddev, char *page)
{
A
Andre Noll 已提交
3623 3624
	return sprintf(page, "%llu\n",
		(unsigned long long)mddev->dev_sectors / 2);
3625 3626
}

3627
static int update_size(mddev_t *mddev, sector_t num_sectors);
3628 3629 3630 3631 3632 3633 3634 3635

static ssize_t
size_store(mddev_t *mddev, const char *buf, size_t len)
{
	/* 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 已提交
3636 3637
	sector_t sectors;
	int err = strict_blocks_to_sectors(buf, &sectors);
3638

A
Andre Noll 已提交
3639 3640
	if (err < 0)
		return err;
3641
	if (mddev->pers) {
A
Andre Noll 已提交
3642
		err = update_size(mddev, sectors);
3643
		md_update_sb(mddev, 1);
3644
	} else {
A
Andre Noll 已提交
3645 3646 3647
		if (mddev->dev_sectors == 0 ||
		    mddev->dev_sectors > sectors)
			mddev->dev_sectors = sectors;
3648 3649 3650 3651 3652 3653 3654
		else
			err = -ENOSPC;
	}
	return err ? err : len;
}

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

3657 3658

/* Metdata version.
3659 3660 3661
 * This is one of
 *   'none' for arrays with no metadata (good luck...)
 *   'external' for arrays with externally managed metadata,
3662 3663 3664 3665 3666 3667 3668 3669
 * or N.M for internally known formats
 */
static ssize_t
metadata_show(mddev_t *mddev, char *page)
{
	if (mddev->persistent)
		return sprintf(page, "%d.%d\n",
			       mddev->major_version, mddev->minor_version);
3670 3671
	else if (mddev->external)
		return sprintf(page, "external:%s\n", mddev->metadata_type);
3672 3673 3674 3675 3676 3677 3678 3679 3680
	else
		return sprintf(page, "none\n");
}

static ssize_t
metadata_store(mddev_t *mddev, const char *buf, size_t len)
{
	int major, minor;
	char *e;
3681 3682 3683 3684 3685 3686 3687
	/* Changing the details of 'external' metadata is
	 * always permitted.  Otherwise there must be
	 * no devices attached to the array.
	 */
	if (mddev->external && strncmp(buf, "external:", 9) == 0)
		;
	else if (!list_empty(&mddev->disks))
3688 3689 3690 3691
		return -EBUSY;

	if (cmd_match(buf, "none")) {
		mddev->persistent = 0;
3692 3693 3694 3695 3696 3697
		mddev->external = 0;
		mddev->major_version = 0;
		mddev->minor_version = 90;
		return len;
	}
	if (strncmp(buf, "external:", 9) == 0) {
3698
		size_t namelen = len-9;
3699 3700 3701 3702 3703 3704 3705 3706
		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;
3707 3708 3709 3710 3711 3712 3713 3714 3715
		mddev->major_version = 0;
		mddev->minor_version = 90;
		return len;
	}
	major = simple_strtoul(buf, &e, 10);
	if (e==buf || *e != '.')
		return -EINVAL;
	buf = e+1;
	minor = simple_strtoul(buf, &e, 10);
3716
	if (e==buf || (*e && *e != '\n') )
3717
		return -EINVAL;
3718
	if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
3719 3720 3721 3722
		return -ENOENT;
	mddev->major_version = major;
	mddev->minor_version = minor;
	mddev->persistent = 1;
3723
	mddev->external = 0;
3724 3725 3726 3727
	return len;
}

static struct md_sysfs_entry md_metadata =
3728
__ATTR(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
3729

3730
static ssize_t
3731
action_show(mddev_t *mddev, char *page)
3732
{
3733
	char *type = "idle";
3734 3735 3736
	if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
		type = "frozen";
	else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3737
	    (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))) {
3738 3739 3740
		if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
			type = "reshape";
		else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
3741 3742 3743 3744 3745 3746
			if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
				type = "resync";
			else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
				type = "check";
			else
				type = "repair";
3747
		} else if (test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
3748 3749 3750 3751 3752
			type = "recover";
	}
	return sprintf(page, "%s\n", type);
}

3753 3754
static void reap_sync_thread(mddev_t *mddev);

3755
static ssize_t
3756
action_store(mddev_t *mddev, const char *page, size_t len)
3757
{
3758 3759 3760
	if (!mddev->pers || !mddev->pers->sync_request)
		return -EINVAL;

3761 3762 3763 3764 3765 3766
	if (cmd_match(page, "frozen"))
		set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
	else
		clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

	if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
3767 3768
		if (mddev->sync_thread) {
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
3769
			reap_sync_thread(mddev);
3770
		}
3771 3772
	} else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
		   test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
3773
		return -EBUSY;
3774 3775 3776 3777
	else if (cmd_match(page, "resync"))
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	else if (cmd_match(page, "recover")) {
		set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
3778
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3779
	} else if (cmd_match(page, "reshape")) {
3780 3781 3782 3783 3784 3785
		int err;
		if (mddev->pers->start_reshape == NULL)
			return -EINVAL;
		err = mddev->pers->start_reshape(mddev);
		if (err)
			return err;
3786
		sysfs_notify(&mddev->kobj, NULL, "degraded");
3787
	} else {
3788
		if (cmd_match(page, "check"))
3789
			set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
3790
		else if (!cmd_match(page, "repair"))
3791 3792 3793 3794
			return -EINVAL;
		set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
		set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
	}
3795
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3796
	md_wakeup_thread(mddev->thread);
N
NeilBrown 已提交
3797
	sysfs_notify_dirent_safe(mddev->sysfs_action);
3798 3799 3800
	return len;
}

3801
static ssize_t
3802
mismatch_cnt_show(mddev_t *mddev, char *page)
3803 3804 3805 3806 3807
{
	return sprintf(page, "%llu\n",
		       (unsigned long long) mddev->resync_mismatches);
}

3808 3809
static struct md_sysfs_entry md_scan_mode =
__ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
3810

3811

3812
static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
3813

3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865
static ssize_t
sync_min_show(mddev_t *mddev, char *page)
{
	return sprintf(page, "%d (%s)\n", speed_min(mddev),
		       mddev->sync_speed_min ? "local": "system");
}

static ssize_t
sync_min_store(mddev_t *mddev, const char *buf, size_t len)
{
	int min;
	char *e;
	if (strncmp(buf, "system", 6)==0) {
		mddev->sync_speed_min = 0;
		return len;
	}
	min = simple_strtoul(buf, &e, 10);
	if (buf == e || (*e && *e != '\n') || min <= 0)
		return -EINVAL;
	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
sync_max_show(mddev_t *mddev, char *page)
{
	return sprintf(page, "%d (%s)\n", speed_max(mddev),
		       mddev->sync_speed_max ? "local": "system");
}

static ssize_t
sync_max_store(mddev_t *mddev, const char *buf, size_t len)
{
	int max;
	char *e;
	if (strncmp(buf, "system", 6)==0) {
		mddev->sync_speed_max = 0;
		return len;
	}
	max = simple_strtoul(buf, &e, 10);
	if (buf == e || (*e && *e != '\n') || max <= 0)
		return -EINVAL;
	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);

3866 3867 3868 3869 3870 3871
static ssize_t
degraded_show(mddev_t *mddev, char *page)
{
	return sprintf(page, "%d\n", mddev->degraded);
}
static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
3872

3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902
static ssize_t
sync_force_parallel_show(mddev_t *mddev, char *page)
{
	return sprintf(page, "%d\n", mddev->parallel_resync);
}

static ssize_t
sync_force_parallel_store(mddev_t *mddev, const char *buf, size_t len)
{
	long n;

	if (strict_strtol(buf, 10, &n))
		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);

3903 3904 3905 3906
static ssize_t
sync_speed_show(mddev_t *mddev, char *page)
{
	unsigned long resync, dt, db;
3907 3908
	if (mddev->curr_resync == 0)
		return sprintf(page, "none\n");
3909 3910
	resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
	dt = (jiffies - mddev->resync_mark) / HZ;
3911
	if (!dt) dt++;
3912 3913
	db = resync - mddev->resync_mark_cnt;
	return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
3914 3915
}

3916
static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
3917 3918 3919 3920

static ssize_t
sync_completed_show(mddev_t *mddev, char *page)
{
A
Andre Noll 已提交
3921
	unsigned long max_sectors, resync;
3922

3923 3924 3925
	if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
		return sprintf(page, "none\n");

3926
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
A
Andre Noll 已提交
3927
		max_sectors = mddev->resync_max_sectors;
3928
	else
A
Andre Noll 已提交
3929
		max_sectors = mddev->dev_sectors;
3930

3931
	resync = mddev->curr_resync_completed;
A
Andre Noll 已提交
3932
	return sprintf(page, "%lu / %lu\n", resync, max_sectors);
3933 3934
}

3935
static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
3936

3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954
static ssize_t
min_sync_show(mddev_t *mddev, char *page)
{
	return sprintf(page, "%llu\n",
		       (unsigned long long)mddev->resync_min);
}
static ssize_t
min_sync_store(mddev_t *mddev, const char *buf, size_t len)
{
	unsigned long long min;
	if (strict_strtoull(buf, 10, &min))
		return -EINVAL;
	if (min > mddev->resync_max)
		return -EINVAL;
	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
		return -EBUSY;

	/* Must be a multiple of chunk_size */
3955
	if (mddev->chunk_sectors) {
3956
		sector_t temp = min;
3957
		if (sector_div(temp, mddev->chunk_sectors))
3958 3959 3960 3961 3962 3963 3964 3965 3966 3967
			return -EINVAL;
	}
	mddev->resync_min = min;

	return len;
}

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

3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982
static ssize_t
max_sync_show(mddev_t *mddev, char *page)
{
	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
max_sync_store(mddev_t *mddev, const char *buf, size_t len)
{
	if (strncmp(buf, "max", 3) == 0)
		mddev->resync_max = MaxSector;
	else {
3983 3984 3985 3986
		unsigned long long max;
		if (strict_strtoull(buf, 10, &max))
			return -EINVAL;
		if (max < mddev->resync_min)
3987 3988
			return -EINVAL;
		if (max < mddev->resync_max &&
3989
		    mddev->ro == 0 &&
3990 3991 3992 3993
		    test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
			return -EBUSY;

		/* Must be a multiple of chunk_size */
3994
		if (mddev->chunk_sectors) {
3995
			sector_t temp = max;
3996
			if (sector_div(temp, mddev->chunk_sectors))
3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007
				return -EINVAL;
		}
		mddev->resync_max = max;
	}
	wake_up(&mddev->recovery_wait);
	return len;
}

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

4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018
static ssize_t
suspend_lo_show(mddev_t *mddev, char *page)
{
	return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
}

static ssize_t
suspend_lo_store(mddev_t *mddev, const char *buf, size_t len)
{
	char *e;
	unsigned long long new = simple_strtoull(buf, &e, 10);
4019
	unsigned long long old = mddev->suspend_lo;
4020

4021 4022
	if (mddev->pers == NULL || 
	    mddev->pers->quiesce == NULL)
4023 4024 4025
		return -EINVAL;
	if (buf == e || (*e && *e != '\n'))
		return -EINVAL;
4026 4027 4028 4029

	mddev->suspend_lo = new;
	if (new >= old)
		/* Shrinking suspended region */
4030
		mddev->pers->quiesce(mddev, 2);
4031 4032 4033 4034 4035 4036
	else {
		/* Expanding suspended region - need to wait */
		mddev->pers->quiesce(mddev, 1);
		mddev->pers->quiesce(mddev, 0);
	}
	return len;
4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052
}
static struct md_sysfs_entry md_suspend_lo =
__ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);


static ssize_t
suspend_hi_show(mddev_t *mddev, char *page)
{
	return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
}

static ssize_t
suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
{
	char *e;
	unsigned long long new = simple_strtoull(buf, &e, 10);
4053
	unsigned long long old = mddev->suspend_hi;
4054

4055 4056
	if (mddev->pers == NULL ||
	    mddev->pers->quiesce == NULL)
4057 4058 4059
		return -EINVAL;
	if (buf == e || (*e && *e != '\n'))
		return -EINVAL;
4060 4061 4062 4063 4064 4065 4066

	mddev->suspend_hi = new;
	if (new <= old)
		/* Shrinking suspended region */
		mddev->pers->quiesce(mddev, 2);
	else {
		/* Expanding suspended region - need to wait */
4067 4068
		mddev->pers->quiesce(mddev, 1);
		mddev->pers->quiesce(mddev, 0);
4069 4070
	}
	return len;
4071 4072 4073 4074
}
static struct md_sysfs_entry md_suspend_hi =
__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);

4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097
static ssize_t
reshape_position_show(mddev_t *mddev, char *page)
{
	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
reshape_position_store(mddev_t *mddev, const char *buf, size_t len)
{
	char *e;
	unsigned long long new = simple_strtoull(buf, &e, 10);
	if (mddev->pers)
		return -EBUSY;
	if (buf == e || (*e && *e != '\n'))
		return -EINVAL;
	mddev->reshape_position = new;
	mddev->delta_disks = 0;
	mddev->new_level = mddev->level;
	mddev->new_layout = mddev->layout;
4098
	mddev->new_chunk_sectors = mddev->chunk_sectors;
4099 4100 4101 4102 4103 4104 4105
	return len;
}

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

D
Dan Williams 已提交
4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131
static ssize_t
array_size_show(mddev_t *mddev, char *page)
{
	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
array_size_store(mddev_t *mddev, const char *buf, size_t len)
{
	sector_t sectors;

	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)
			return -EINVAL;
		if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
4132
			return -E2BIG;
D
Dan Williams 已提交
4133 4134 4135 4136 4137 4138

		mddev->external_size = 1;
	}

	mddev->array_sectors = sectors;
	set_capacity(mddev->gendisk, mddev->array_sectors);
4139 4140
	if (mddev->pers)
		revalidate_disk(mddev->gendisk);
D
Dan Williams 已提交
4141 4142 4143 4144 4145 4146 4147

	return len;
}

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

4149 4150
static struct attribute *md_default_attrs[] = {
	&md_level.attr,
4151
	&md_layout.attr,
4152
	&md_raid_disks.attr,
4153
	&md_chunk_size.attr,
4154
	&md_size.attr,
4155
	&md_resync_start.attr,
4156
	&md_metadata.attr,
4157
	&md_new_device.attr,
4158
	&md_safe_delay.attr,
4159
	&md_array_state.attr,
4160
	&md_reshape_position.attr,
D
Dan Williams 已提交
4161
	&md_array_size.attr,
4162
	&max_corr_read_errors.attr,
4163 4164 4165 4166
	NULL,
};

static struct attribute *md_redundancy_attrs[] = {
4167
	&md_scan_mode.attr,
4168
	&md_mismatches.attr,
4169 4170 4171
	&md_sync_min.attr,
	&md_sync_max.attr,
	&md_sync_speed.attr,
4172
	&md_sync_force_parallel.attr,
4173
	&md_sync_completed.attr,
4174
	&md_min_sync.attr,
4175
	&md_max_sync.attr,
4176 4177
	&md_suspend_lo.attr,
	&md_suspend_hi.attr,
4178
	&md_bitmap.attr,
4179
	&md_degraded.attr,
4180 4181
	NULL,
};
4182 4183 4184 4185 4186
static struct attribute_group md_redundancy_group = {
	.name = NULL,
	.attrs = md_redundancy_attrs,
};

4187 4188 4189 4190 4191 4192

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);
	mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
4193
	ssize_t rv;
4194 4195 4196

	if (!entry->show)
		return -EIO;
I
Ingo Molnar 已提交
4197 4198 4199 4200 4201
	rv = mddev_lock(mddev);
	if (!rv) {
		rv = entry->show(mddev, page);
		mddev_unlock(mddev);
	}
4202
	return rv;
4203 4204 4205 4206 4207 4208 4209 4210
}

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);
	mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
4211
	ssize_t rv;
4212 4213 4214

	if (!entry->store)
		return -EIO;
4215 4216
	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
I
Ingo Molnar 已提交
4217
	rv = mddev_lock(mddev);
4218 4219
	if (mddev->hold_active == UNTIL_IOCTL)
		mddev->hold_active = 0;
I
Ingo Molnar 已提交
4220 4221 4222 4223
	if (!rv) {
		rv = entry->store(mddev, page, length);
		mddev_unlock(mddev);
	}
4224
	return rv;
4225 4226 4227 4228 4229
}

static void md_free(struct kobject *ko)
{
	mddev_t *mddev = container_of(ko, mddev_t, kobj);
4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240

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

	if (mddev->gendisk) {
		del_gendisk(mddev->gendisk);
		put_disk(mddev->gendisk);
	}
	if (mddev->queue)
		blk_cleanup_queue(mddev->queue);

4241 4242 4243
	kfree(mddev);
}

4244
static const struct sysfs_ops md_sysfs_ops = {
4245 4246 4247 4248 4249 4250 4251 4252 4253
	.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 已提交
4254 4255
int mdp_major = 0;

4256 4257 4258 4259
static void mddev_delayed_delete(struct work_struct *ws)
{
	mddev_t *mddev = container_of(ws, mddev_t, del_work);

4260
	sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
4261 4262 4263 4264
	kobject_del(&mddev->kobj);
	kobject_put(&mddev->kobj);
}

4265
static int md_alloc(dev_t dev, char *name)
L
Linus Torvalds 已提交
4266
{
A
Arjan van de Ven 已提交
4267
	static DEFINE_MUTEX(disks_mutex);
L
Linus Torvalds 已提交
4268 4269
	mddev_t *mddev = mddev_find(dev);
	struct gendisk *disk;
4270 4271 4272
	int partitioned;
	int shift;
	int unit;
4273
	int error;
L
Linus Torvalds 已提交
4274 4275

	if (!mddev)
4276 4277 4278 4279 4280
		return -ENODEV;

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

T
Tejun Heo 已提交
4282 4283
	/* wait for any previous instance of this device to be
	 * completely removed (mddev_delayed_delete).
4284
	 */
T
Tejun Heo 已提交
4285
	flush_workqueue(md_misc_wq);
4286

A
Arjan van de Ven 已提交
4287
	mutex_lock(&disks_mutex);
N
NeilBrown 已提交
4288 4289 4290
	error = -EEXIST;
	if (mddev->gendisk)
		goto abort;
4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301

	if (name) {
		/* Need to ensure that 'name' is not a duplicate.
		 */
		mddev_t *mddev2;
		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 已提交
4302
				goto abort;
4303 4304
			}
		spin_unlock(&all_mddevs_lock);
L
Linus Torvalds 已提交
4305
	}
4306

N
NeilBrown 已提交
4307
	error = -ENOMEM;
4308
	mddev->queue = blk_alloc_queue(GFP_KERNEL);
N
NeilBrown 已提交
4309 4310
	if (!mddev->queue)
		goto abort;
4311 4312 4313
	mddev->queue->queuedata = mddev;

	blk_queue_make_request(mddev->queue, md_make_request);
4314

L
Linus Torvalds 已提交
4315 4316
	disk = alloc_disk(1 << shift);
	if (!disk) {
4317 4318
		blk_cleanup_queue(mddev->queue);
		mddev->queue = NULL;
N
NeilBrown 已提交
4319
		goto abort;
L
Linus Torvalds 已提交
4320
	}
4321
	disk->major = MAJOR(mddev->unit);
L
Linus Torvalds 已提交
4322
	disk->first_minor = unit << shift;
4323 4324 4325
	if (name)
		strcpy(disk->disk_name, name);
	else if (partitioned)
L
Linus Torvalds 已提交
4326
		sprintf(disk->disk_name, "md_d%d", unit);
4327
	else
L
Linus Torvalds 已提交
4328 4329 4330 4331
		sprintf(disk->disk_name, "md%d", unit);
	disk->fops = &md_fops;
	disk->private_data = mddev;
	disk->queue = mddev->queue;
4332
	/* Allow extended partitions.  This makes the
4333
	 * 'mdp' device redundant, but we can't really
4334 4335 4336
	 * remove it now.
	 */
	disk->flags |= GENHD_FL_EXT_DEVT;
L
Linus Torvalds 已提交
4337 4338
	add_disk(disk);
	mddev->gendisk = disk;
4339 4340
	error = kobject_init_and_add(&mddev->kobj, &md_ktype,
				     &disk_to_dev(disk)->kobj, "%s", "md");
N
NeilBrown 已提交
4341 4342 4343 4344
	if (error) {
		/* This isn't possible, but as kobject_init_and_add is marked
		 * __must_check, we must do something with the result
		 */
4345 4346
		printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
		       disk->disk_name);
N
NeilBrown 已提交
4347 4348
		error = 0;
	}
N
NeilBrown 已提交
4349 4350
	if (mddev->kobj.sd &&
	    sysfs_create_group(&mddev->kobj, &md_bitmap_group))
4351
		printk(KERN_DEBUG "pointless warning\n");
4352 4353

	blk_queue_flush(mddev->queue, REQ_FLUSH | REQ_FUA);
N
NeilBrown 已提交
4354 4355
 abort:
	mutex_unlock(&disks_mutex);
N
NeilBrown 已提交
4356
	if (!error && mddev->kobj.sd) {
4357
		kobject_uevent(&mddev->kobj, KOBJ_ADD);
N
NeilBrown 已提交
4358
		mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
4359
	}
4360
	mddev_put(mddev);
N
NeilBrown 已提交
4361
	return error;
4362 4363 4364 4365 4366
}

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

4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388
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 已提交
4389 4390 4391 4392
static void md_safemode_timeout(unsigned long data)
{
	mddev_t *mddev = (mddev_t *) data;

4393 4394 4395
	if (!atomic_read(&mddev->writes_pending)) {
		mddev->safemode = 1;
		if (mddev->external)
N
NeilBrown 已提交
4396
			sysfs_notify_dirent_safe(mddev->sysfs_state);
4397
	}
L
Linus Torvalds 已提交
4398 4399 4400
	md_wakeup_thread(mddev->thread);
}

4401
static int start_dirty_degraded;
L
Linus Torvalds 已提交
4402

4403
int md_run(mddev_t *mddev)
L
Linus Torvalds 已提交
4404
{
4405
	int err;
L
Linus Torvalds 已提交
4406
	mdk_rdev_t *rdev;
4407
	struct mdk_personality *pers;
L
Linus Torvalds 已提交
4408

4409 4410
	if (list_empty(&mddev->disks))
		/* cannot run an array with no devices.. */
L
Linus Torvalds 已提交
4411 4412 4413 4414
		return -EINVAL;

	if (mddev->pers)
		return -EBUSY;
4415 4416 4417
	/* Cannot run until previous stop completes properly */
	if (mddev->sysfs_active)
		return -EBUSY;
4418

L
Linus Torvalds 已提交
4419 4420 4421
	/*
	 * Analyze all RAID superblock(s)
	 */
4422 4423 4424
	if (!mddev->raid_disks) {
		if (!mddev->persistent)
			return -EINVAL;
4425
		analyze_sbs(mddev);
4426
	}
L
Linus Torvalds 已提交
4427

4428 4429 4430 4431
	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 已提交
4432 4433 4434 4435 4436 4437

	/*
	 * Drop all container device buffers, from now on
	 * the only valid external interface is through the md
	 * device.
	 */
4438
	list_for_each_entry(rdev, &mddev->disks, same_set) {
4439
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
4440 4441
			continue;
		sync_blockdev(rdev->bdev);
4442
		invalidate_bdev(rdev->bdev);
4443 4444 4445

		/* perform some consistency tests on the device.
		 * We don't want the data to overlap the metadata,
A
Andre Noll 已提交
4446
		 * Internal Bitmap issues have been handled elsewhere.
4447
		 */
4448 4449 4450
		if (rdev->meta_bdev) {
			/* Nothing to check */;
		} else if (rdev->data_offset < rdev->sb_start) {
A
Andre Noll 已提交
4451 4452
			if (mddev->dev_sectors &&
			    rdev->data_offset + mddev->dev_sectors
4453
			    > rdev->sb_start) {
4454 4455 4456 4457 4458
				printk("md: %s: data overlaps metadata\n",
				       mdname(mddev));
				return -EINVAL;
			}
		} else {
4459
			if (rdev->sb_start + rdev->sb_size/512
4460 4461 4462 4463 4464 4465
			    > rdev->data_offset) {
				printk("md: %s: metadata overlaps data\n",
				       mdname(mddev));
				return -EINVAL;
			}
		}
N
NeilBrown 已提交
4466
		sysfs_notify_dirent_safe(rdev->sysfs_state);
L
Linus Torvalds 已提交
4467 4468
	}

4469 4470 4471
	if (mddev->bio_set == NULL)
		mddev->bio_set = bioset_create(BIO_POOL_SIZE, sizeof(mddev));

L
Linus Torvalds 已提交
4472
	spin_lock(&pers_lock);
4473
	pers = find_pers(mddev->level, mddev->clevel);
4474
	if (!pers || !try_module_get(pers->owner)) {
L
Linus Torvalds 已提交
4475
		spin_unlock(&pers_lock);
4476 4477 4478 4479 4480 4481
		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 已提交
4482 4483
		return -EINVAL;
	}
4484
	mddev->pers = pers;
L
Linus Torvalds 已提交
4485
	spin_unlock(&pers_lock);
4486 4487 4488 4489
	if (mddev->level != pers->level) {
		mddev->level = pers->level;
		mddev->new_level = pers->level;
	}
4490
	strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
L
Linus Torvalds 已提交
4491

4492
	if (mddev->reshape_position != MaxSector &&
4493
	    pers->start_reshape == NULL) {
4494 4495 4496 4497 4498 4499
		/* This personality cannot handle reshaping... */
		mddev->pers = NULL;
		module_put(pers->owner);
		return -EINVAL;
	}

4500 4501 4502 4503 4504 4505 4506
	if (pers->sync_request) {
		/* Warn if this is a potentially silly
		 * configuration.
		 */
		char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
		mdk_rdev_t *rdev2;
		int warned = 0;
4507 4508 4509

		list_for_each_entry(rdev, &mddev->disks, same_set)
			list_for_each_entry(rdev2, &mddev->disks, same_set) {
4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522
				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;
				}
			}
4523

4524 4525 4526 4527 4528 4529
		if (warned)
			printk(KERN_WARNING
			       "True protection against single-disk"
			       " failure might be compromised.\n");
	}

4530
	mddev->recovery = 0;
A
Andre Noll 已提交
4531 4532 4533
	/* may be over-ridden by personality */
	mddev->resync_max_sectors = mddev->dev_sectors;

4534
	mddev->ok_start_degraded = start_dirty_degraded;
L
Linus Torvalds 已提交
4535

4536
	if (start_readonly && mddev->ro == 0)
4537 4538
		mddev->ro = 2; /* read-only, but switch on first write */

4539
	err = mddev->pers->run(mddev);
4540 4541
	if (err)
		printk(KERN_ERR "md: pers->run() failed ...\n");
D
Dan Williams 已提交
4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552
	else if (mddev->pers->size(mddev, 0, 0) < mddev->array_sectors) {
		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,
		       (unsigned long long)mddev->pers->size(mddev, 0, 0) / 2);
		err = -EINVAL;
		mddev->pers->stop(mddev);
	}
	if (err == 0 && mddev->pers->sync_request) {
4553 4554 4555 4556 4557 4558 4559
		err = bitmap_create(mddev);
		if (err) {
			printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
			       mdname(mddev), err);
			mddev->pers->stop(mddev);
		}
	}
L
Linus Torvalds 已提交
4560 4561 4562
	if (err) {
		module_put(mddev->pers->owner);
		mddev->pers = NULL;
4563 4564
		bitmap_destroy(mddev);
		return err;
L
Linus Torvalds 已提交
4565
	}
4566
	if (mddev->pers->sync_request) {
N
NeilBrown 已提交
4567 4568
		if (mddev->kobj.sd &&
		    sysfs_create_group(&mddev->kobj, &md_redundancy_group))
4569 4570 4571
			printk(KERN_WARNING
			       "md: cannot register extra attributes for %s\n",
			       mdname(mddev));
N
NeilBrown 已提交
4572
		mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
4573
	} else if (mddev->ro == 2) /* auto-readonly not meaningful */
4574 4575
		mddev->ro = 0;

L
Linus Torvalds 已提交
4576
 	atomic_set(&mddev->writes_pending,0);
4577 4578
	atomic_set(&mddev->max_corr_read_errors,
		   MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
L
Linus Torvalds 已提交
4579 4580 4581
	mddev->safemode = 0;
	mddev->safemode_timer.function = md_safemode_timeout;
	mddev->safemode_timer.data = (unsigned long) mddev;
4582
	mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
L
Linus Torvalds 已提交
4583
	mddev->in_sync = 1;
4584 4585
	smp_wmb();
	mddev->ready = 1;
4586
	list_for_each_entry(rdev, &mddev->disks, same_set)
4587 4588 4589
		if (rdev->raid_disk >= 0) {
			char nm[20];
			sprintf(nm, "rd%d", rdev->raid_disk);
4590
			if (sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
N
NeilBrown 已提交
4591
				/* failure here is OK */;
4592
		}
L
Linus Torvalds 已提交
4593 4594 4595
	
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	
4596 4597
	if (mddev->flags)
		md_update_sb(mddev, 0);
L
Linus Torvalds 已提交
4598

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

4602
	md_new_event(mddev);
N
NeilBrown 已提交
4603 4604
	sysfs_notify_dirent_safe(mddev->sysfs_state);
	sysfs_notify_dirent_safe(mddev->sysfs_action);
4605
	sysfs_notify(&mddev->kobj, NULL, "degraded");
L
Linus Torvalds 已提交
4606 4607
	return 0;
}
4608
EXPORT_SYMBOL_GPL(md_run);
L
Linus Torvalds 已提交
4609

4610 4611 4612 4613 4614 4615 4616
static int do_md_run(mddev_t *mddev)
{
	int err;

	err = md_run(mddev);
	if (err)
		goto out;
4617 4618 4619 4620 4621
	err = bitmap_load(mddev);
	if (err) {
		bitmap_destroy(mddev);
		goto out;
	}
4622 4623 4624 4625 4626 4627 4628
	set_capacity(mddev->gendisk, mddev->array_sectors);
	revalidate_disk(mddev->gendisk);
	kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
out:
	return err;
}

L
Linus Torvalds 已提交
4629 4630 4631 4632
static int restart_array(mddev_t *mddev)
{
	struct gendisk *disk = mddev->gendisk;

A
Andre Noll 已提交
4633
	/* Complain if it has no devices */
L
Linus Torvalds 已提交
4634
	if (list_empty(&mddev->disks))
A
Andre Noll 已提交
4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648
		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 已提交
4649
	sysfs_notify_dirent_safe(mddev->sysfs_state);
A
Andre Noll 已提交
4650
	return 0;
L
Linus Torvalds 已提交
4651 4652
}

4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669
/* similar to deny_write_access, but accounts for our holding a reference
 * to the file ourselves */
static int deny_bitmap_write_access(struct file * file)
{
	struct inode *inode = file->f_mapping->host;

	spin_lock(&inode->i_lock);
	if (atomic_read(&inode->i_writecount) > 1) {
		spin_unlock(&inode->i_lock);
		return -ETXTBSY;
	}
	atomic_set(&inode->i_writecount, -1);
	spin_unlock(&inode->i_lock);

	return 0;
}

4670
void restore_bitmap_write_access(struct file *file)
4671 4672 4673 4674 4675 4676 4677 4678
{
	struct inode *inode = file->f_mapping->host;

	spin_lock(&inode->i_lock);
	atomic_set(&inode->i_writecount, 1);
	spin_unlock(&inode->i_lock);
}

N
NeilBrown 已提交
4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700
static void md_clean(mddev_t *mddev)
{
	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;
4701
	mddev->can_decrease_events = 0;
N
NeilBrown 已提交
4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718
	mddev->delta_disks = 0;
	mddev->new_level = LEVEL_NONE;
	mddev->new_layout = 0;
	mddev->new_chunk_sectors = 0;
	mddev->curr_resync = 0;
	mddev->resync_mismatches = 0;
	mddev->suspend_lo = mddev->suspend_hi = 0;
	mddev->sync_speed_min = mddev->sync_speed_max = 0;
	mddev->recovery = 0;
	mddev->in_sync = 0;
	mddev->degraded = 0;
	mddev->safemode = 0;
	mddev->bitmap_info.offset = 0;
	mddev->bitmap_info.default_offset = 0;
	mddev->bitmap_info.chunksize = 0;
	mddev->bitmap_info.daemon_sleep = 0;
	mddev->bitmap_info.max_write_behind = 0;
4719
	mddev->plug = NULL;
N
NeilBrown 已提交
4720 4721
}

4722
static void __md_stop_writes(mddev_t *mddev)
4723 4724 4725 4726
{
	if (mddev->sync_thread) {
		set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4727
		reap_sync_thread(mddev);
4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740
	}

	del_timer_sync(&mddev->safemode_timer);

	bitmap_flush(mddev);
	md_super_wait(mddev);

	if (!mddev->in_sync || mddev->flags) {
		/* mark array as shutdown cleanly */
		mddev->in_sync = 1;
		md_update_sb(mddev, 1);
	}
}
4741 4742 4743 4744 4745 4746 4747

void md_stop_writes(mddev_t *mddev)
{
	mddev_lock(mddev);
	__md_stop_writes(mddev);
	mddev_unlock(mddev);
}
4748
EXPORT_SYMBOL_GPL(md_stop_writes);
4749

4750
void md_stop(mddev_t *mddev)
N
NeilBrown 已提交
4751
{
4752
	mddev->ready = 0;
N
NeilBrown 已提交
4753 4754 4755 4756 4757
	mddev->pers->stop(mddev);
	if (mddev->pers->sync_request && mddev->to_remove == NULL)
		mddev->to_remove = &md_redundancy_group;
	module_put(mddev->pers->owner);
	mddev->pers = NULL;
N
NeilBrown 已提交
4758
	clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
N
NeilBrown 已提交
4759
}
4760
EXPORT_SYMBOL_GPL(md_stop);
N
NeilBrown 已提交
4761

4762 4763 4764 4765 4766 4767 4768 4769 4770 4771
static int md_set_readonly(mddev_t *mddev, int is_open)
{
	int err = 0;
	mutex_lock(&mddev->open_mutex);
	if (atomic_read(&mddev->openers) > is_open) {
		printk("md: %s still in use.\n",mdname(mddev));
		err = -EBUSY;
		goto out;
	}
	if (mddev->pers) {
4772
		__md_stop_writes(mddev);
4773 4774 4775 4776 4777 4778 4779

		err  = -ENXIO;
		if (mddev->ro==1)
			goto out;
		mddev->ro = 1;
		set_disk_ro(mddev->gendisk, 1);
		clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
N
NeilBrown 已提交
4780
		sysfs_notify_dirent_safe(mddev->sysfs_state);
4781 4782 4783 4784 4785 4786 4787
		err = 0;	
	}
out:
	mutex_unlock(&mddev->open_mutex);
	return err;
}

4788 4789 4790 4791
/* mode:
 *   0 - completely stop and dis-assemble array
 *   2 - stop but do not disassemble array
 */
4792
static int do_md_stop(mddev_t * mddev, int mode, int is_open)
L
Linus Torvalds 已提交
4793 4794
{
	struct gendisk *disk = mddev->gendisk;
4795
	mdk_rdev_t *rdev;
L
Linus Torvalds 已提交
4796

N
NeilBrown 已提交
4797
	mutex_lock(&mddev->open_mutex);
4798 4799
	if (atomic_read(&mddev->openers) > is_open ||
	    mddev->sysfs_active) {
4800
		printk("md: %s still in use.\n",mdname(mddev));
N
NeilBrown 已提交
4801 4802 4803
		mutex_unlock(&mddev->open_mutex);
		return -EBUSY;
	}
L
Linus Torvalds 已提交
4804

N
NeilBrown 已提交
4805
	if (mddev->pers) {
4806 4807
		if (mddev->ro)
			set_disk_ro(disk, 0);
4808

4809
		__md_stop_writes(mddev);
4810 4811 4812 4813
		md_stop(mddev);
		mddev->queue->merge_bvec_fn = NULL;
		mddev->queue->unplug_fn = NULL;
		mddev->queue->backing_dev_info.congested_fn = NULL;
N
NeilBrown 已提交
4814

4815
		/* tell userspace to handle 'inactive' */
N
NeilBrown 已提交
4816
		sysfs_notify_dirent_safe(mddev->sysfs_state);
4817

4818 4819 4820 4821 4822 4823
		list_for_each_entry(rdev, &mddev->disks, same_set)
			if (rdev->raid_disk >= 0) {
				char nm[20];
				sprintf(nm, "rd%d", rdev->raid_disk);
				sysfs_remove_link(&mddev->kobj, nm);
			}
4824

4825
		set_capacity(disk, 0);
N
NeilBrown 已提交
4826
		mutex_unlock(&mddev->open_mutex);
4827
		revalidate_disk(disk);
4828

4829 4830
		if (mddev->ro)
			mddev->ro = 0;
N
NeilBrown 已提交
4831 4832
	} else
		mutex_unlock(&mddev->open_mutex);
L
Linus Torvalds 已提交
4833 4834 4835
	/*
	 * Free resources if final stop
	 */
4836
	if (mode == 0) {
L
Linus Torvalds 已提交
4837 4838
		printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));

4839
		bitmap_destroy(mddev);
4840 4841 4842 4843
		if (mddev->bitmap_info.file) {
			restore_bitmap_write_access(mddev->bitmap_info.file);
			fput(mddev->bitmap_info.file);
			mddev->bitmap_info.file = NULL;
4844
		}
4845
		mddev->bitmap_info.offset = 0;
4846

L
Linus Torvalds 已提交
4847 4848
		export_array(mddev);

N
NeilBrown 已提交
4849
		md_clean(mddev);
4850
		kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
4851 4852
		if (mddev->hold_active == UNTIL_STOP)
			mddev->hold_active = 0;
4853
	}
M
Martin K. Petersen 已提交
4854
	blk_integrity_unregister(disk);
4855
	md_new_event(mddev);
N
NeilBrown 已提交
4856
	sysfs_notify_dirent_safe(mddev->sysfs_state);
N
NeilBrown 已提交
4857
	return 0;
L
Linus Torvalds 已提交
4858 4859
}

J
Jeff Garzik 已提交
4860
#ifndef MODULE
L
Linus Torvalds 已提交
4861 4862 4863 4864 4865
static void autorun_array(mddev_t *mddev)
{
	mdk_rdev_t *rdev;
	int err;

4866
	if (list_empty(&mddev->disks))
L
Linus Torvalds 已提交
4867 4868 4869 4870
		return;

	printk(KERN_INFO "md: running: ");

4871
	list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
4872 4873 4874 4875 4876
		char b[BDEVNAME_SIZE];
		printk("<%s>", bdevname(rdev->bdev,b));
	}
	printk("\n");

4877
	err = do_md_run(mddev);
L
Linus Torvalds 已提交
4878 4879
	if (err) {
		printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
4880
		do_md_stop(mddev, 0, 0);
L
Linus Torvalds 已提交
4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897
	}
}

/*
 * 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)
{
4898
	mdk_rdev_t *rdev0, *rdev, *tmp;
L
Linus Torvalds 已提交
4899 4900 4901 4902 4903
	mddev_t *mddev;
	char b[BDEVNAME_SIZE];

	printk(KERN_INFO "md: autorun ...\n");
	while (!list_empty(&pending_raid_disks)) {
4904
		int unit;
L
Linus Torvalds 已提交
4905
		dev_t dev;
4906
		LIST_HEAD(candidates);
L
Linus Torvalds 已提交
4907 4908 4909 4910 4911 4912
		rdev0 = list_entry(pending_raid_disks.next,
					 mdk_rdev_t, same_set);

		printk(KERN_INFO "md: considering %s ...\n",
			bdevname(rdev0->bdev,b));
		INIT_LIST_HEAD(&candidates);
4913
		rdev_for_each_list(rdev, tmp, &pending_raid_disks)
L
Linus Torvalds 已提交
4914 4915 4916 4917 4918 4919 4920 4921 4922 4923
			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.
		 */
4924 4925 4926 4927 4928 4929 4930 4931 4932
		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 已提交
4933 4934 4935 4936 4937 4938 4939
			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 已提交
4940 4941 4942 4943
		if (!mddev || !mddev->gendisk) {
			if (mddev)
				mddev_put(mddev);
			printk(KERN_ERR
L
Linus Torvalds 已提交
4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957
				"md: cannot allocate memory for md drive.\n");
			break;
		}
		if (mddev_lock(mddev)) 
			printk(KERN_WARNING "md: %s locked, cannot run\n",
			       mdname(mddev));
		else if (mddev->raid_disks || mddev->major_version
			 || !list_empty(&mddev->disks)) {
			printk(KERN_WARNING 
				"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));
4958
			mddev->persistent = 1;
4959
			rdev_for_each_list(rdev, tmp, &candidates) {
L
Linus Torvalds 已提交
4960 4961 4962 4963 4964 4965 4966 4967 4968 4969
				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...
		 */
4970
		rdev_for_each_list(rdev, tmp, &candidates) {
4971
			list_del_init(&rdev->same_set);
L
Linus Torvalds 已提交
4972
			export_rdev(rdev);
4973
		}
L
Linus Torvalds 已提交
4974 4975 4976 4977
		mddev_put(mddev);
	}
	printk(KERN_INFO "md: ... autorun DONE.\n");
}
J
Jeff Garzik 已提交
4978
#endif /* !MODULE */
L
Linus Torvalds 已提交
4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996

static int get_version(void __user * arg)
{
	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;
}

static int get_array_info(mddev_t * mddev, void __user * arg)
{
	mdu_array_info_t info;
4997
	int nr,working,insync,failed,spare;
L
Linus Torvalds 已提交
4998 4999
	mdk_rdev_t *rdev;

5000
	nr=working=insync=failed=spare=0;
5001
	list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
5002
		nr++;
5003
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
5004 5005 5006
			failed++;
		else {
			working++;
5007
			if (test_bit(In_sync, &rdev->flags))
5008
				insync++;	
L
Linus Torvalds 已提交
5009 5010 5011 5012 5013 5014 5015 5016 5017 5018
			else
				spare++;
		}
	}

	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 已提交
5019 5020
	info.size          = mddev->dev_sectors / 2;
	if (info.size != mddev->dev_sectors / 2) /* overflow */
5021
		info.size = -1;
L
Linus Torvalds 已提交
5022 5023 5024 5025 5026 5027 5028 5029 5030
	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);
5031
	if (mddev->bitmap && mddev->bitmap_info.offset)
5032
		info.state = (1<<MD_SB_BITMAP_PRESENT);
5033
	info.active_disks  = insync;
L
Linus Torvalds 已提交
5034 5035 5036 5037 5038
	info.working_disks = working;
	info.failed_disks  = failed;
	info.spare_disks   = spare;

	info.layout        = mddev->layout;
5039
	info.chunk_size    = mddev->chunk_sectors << 9;
L
Linus Torvalds 已提交
5040 5041 5042 5043 5044 5045 5046

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

	return 0;
}

5047
static int get_bitmap_file(mddev_t * mddev, void __user * arg)
5048 5049 5050 5051 5052
{
	mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
	char *ptr, *buf = NULL;
	int err = -ENOMEM;

5053 5054 5055 5056
	if (md_allow_write(mddev))
		file = kmalloc(sizeof(*file), GFP_NOIO);
	else
		file = kmalloc(sizeof(*file), GFP_KERNEL);
5057

5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070
	if (!file)
		goto out;

	/* bitmap disabled, zero the first byte and copy out */
	if (!mddev->bitmap || !mddev->bitmap->file) {
		file->pathname[0] = '\0';
		goto copy_out;
	}

	buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
	if (!buf)
		goto out;

C
Christoph Hellwig 已提交
5071 5072
	ptr = d_path(&mddev->bitmap->file->f_path, buf, sizeof(file->pathname));
	if (IS_ERR(ptr))
5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086
		goto out;

	strcpy(file->pathname, ptr);

copy_out:
	err = 0;
	if (copy_to_user(arg, file, sizeof(*file)))
		err = -EFAULT;
out:
	kfree(buf);
	kfree(file);
	return err;
}

L
Linus Torvalds 已提交
5087 5088 5089 5090 5091 5092 5093 5094
static int get_disk_info(mddev_t * mddev, void __user * arg)
{
	mdu_disk_info_t info;
	mdk_rdev_t *rdev;

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

5095
	rdev = find_rdev_nr(mddev, info.number);
L
Linus Torvalds 已提交
5096 5097 5098 5099 5100
	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;
5101
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
5102
			info.state |= (1<<MD_DISK_FAULTY);
5103
		else if (test_bit(In_sync, &rdev->flags)) {
L
Linus Torvalds 已提交
5104 5105 5106
			info.state |= (1<<MD_DISK_ACTIVE);
			info.state |= (1<<MD_DISK_SYNC);
		}
5107 5108
		if (test_bit(WriteMostly, &rdev->flags))
			info.state |= (1<<MD_DISK_WRITEMOSTLY);
L
Linus Torvalds 已提交
5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142
	} else {
		info.major = info.minor = 0;
		info.raid_disk = -1;
		info.state = (1<<MD_DISK_REMOVED);
	}

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

	return 0;
}

static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
{
	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
	mdk_rdev_t *rdev;
	dev_t dev = MKDEV(info->major,info->minor);

	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)) {
			printk(KERN_WARNING 
				"md: md_import_device returned %ld\n",
				PTR_ERR(rdev));
			return PTR_ERR(rdev);
		}
		if (!list_empty(&mddev->disks)) {
			mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
							mdk_rdev_t, same_set);
5143
			err = super_types[mddev->major_version]
L
Linus Torvalds 已提交
5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172
				.load_super(rdev, rdev0, mddev->minor_version);
			if (err < 0) {
				printk(KERN_WARNING 
					"md: %s has different UUID to %s\n",
					bdevname(rdev->bdev,b), 
					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) {
			printk(KERN_WARNING 
				"%s: personality does not support diskops!\n",
			       mdname(mddev));
			return -EINVAL;
		}
5173 5174 5175 5176 5177
		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 已提交
5178 5179 5180 5181 5182 5183
		if (IS_ERR(rdev)) {
			printk(KERN_WARNING 
				"md: md_import_device returned %ld\n",
				PTR_ERR(rdev));
			return PTR_ERR(rdev);
		}
5184
		/* set saved_raid_disk if appropriate */
5185 5186
		if (!mddev->persistent) {
			if (info->state & (1<<MD_DISK_SYNC)  &&
5187
			    info->raid_disk < mddev->raid_disks) {
5188
				rdev->raid_disk = info->raid_disk;
5189 5190
				set_bit(In_sync, &rdev->flags);
			} else
5191 5192 5193 5194
				rdev->raid_disk = -1;
		} else
			super_types[mddev->major_version].
				validate_super(mddev, rdev);
5195 5196 5197 5198
		if (test_bit(In_sync, &rdev->flags))
			rdev->saved_raid_disk = rdev->raid_disk;
		else
			rdev->saved_raid_disk = -1;
5199

5200
		clear_bit(In_sync, &rdev->flags); /* just to be sure */
5201 5202
		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);
5203 5204
		else
			clear_bit(WriteMostly, &rdev->flags);
5205

L
Linus Torvalds 已提交
5206 5207
		rdev->raid_disk = -1;
		err = bind_rdev_to_array(rdev, mddev);
5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218
		if (!err && !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);
		}
L
Linus Torvalds 已提交
5219 5220
		if (err)
			export_rdev(rdev);
5221
		else
N
NeilBrown 已提交
5222
			sysfs_notify_dirent_safe(rdev->sysfs_state);
5223

5224
		md_update_sb(mddev, 1);
5225 5226
		if (mddev->degraded)
			set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
5227
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5228
		md_wakeup_thread(mddev->thread);
L
Linus Torvalds 已提交
5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242
		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;
5243
		rdev = md_import_device(dev, -1, 0);
L
Linus Torvalds 已提交
5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256
		if (IS_ERR(rdev)) {
			printk(KERN_WARNING 
				"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)
5257 5258
			if (info->state & (1<<MD_DISK_SYNC))
				set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
5259

5260 5261 5262
		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);

L
Linus Torvalds 已提交
5263 5264
		if (!mddev->persistent) {
			printk(KERN_INFO "md: nonpersistent superblock ...\n");
5265 5266
			rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
		} else
5267
			rdev->sb_start = calc_dev_sboffset(rdev);
5268
		rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
5269

5270 5271 5272 5273 5274
		err = bind_rdev_to_array(rdev, mddev);
		if (err) {
			export_rdev(rdev);
			return err;
		}
L
Linus Torvalds 已提交
5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292
	}

	return 0;
}

static int hot_remove_disk(mddev_t * mddev, dev_t dev)
{
	char b[BDEVNAME_SIZE];
	mdk_rdev_t *rdev;

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

	if (rdev->raid_disk >= 0)
		goto busy;

	kick_rdev_from_array(rdev);
5293
	md_update_sb(mddev, 1);
5294
	md_new_event(mddev);
L
Linus Torvalds 已提交
5295 5296 5297

	return 0;
busy:
5298
	printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
L
Linus Torvalds 已提交
5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324
		bdevname(rdev->bdev,b), mdname(mddev));
	return -EBUSY;
}

static int hot_add_disk(mddev_t * mddev, dev_t dev)
{
	char b[BDEVNAME_SIZE];
	int err;
	mdk_rdev_t *rdev;

	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) {
		printk(KERN_WARNING 
			"%s: personality does not support diskops!\n",
			mdname(mddev));
		return -EINVAL;
	}

5325
	rdev = md_import_device(dev, -1, 0);
L
Linus Torvalds 已提交
5326 5327 5328 5329 5330 5331 5332 5333
	if (IS_ERR(rdev)) {
		printk(KERN_WARNING 
			"md: error, md_import_device() returned %ld\n",
			PTR_ERR(rdev));
		return -EINVAL;
	}

	if (mddev->persistent)
5334
		rdev->sb_start = calc_dev_sboffset(rdev);
L
Linus Torvalds 已提交
5335
	else
5336
		rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
L
Linus Torvalds 已提交
5337

5338
	rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
5339

5340
	if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
5341 5342 5343 5344 5345 5346
		printk(KERN_WARNING 
			"md: can not hot-add faulty %s disk to %s!\n",
			bdevname(rdev->bdev,b), mdname(mddev));
		err = -EINVAL;
		goto abort_export;
	}
5347
	clear_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
5348
	rdev->desc_nr = -1;
5349
	rdev->saved_raid_disk = -1;
5350 5351 5352
	err = bind_rdev_to_array(rdev, mddev);
	if (err)
		goto abort_export;
L
Linus Torvalds 已提交
5353 5354 5355 5356 5357 5358 5359 5360

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

	rdev->raid_disk = -1;

5361
	md_update_sb(mddev, 1);
L
Linus Torvalds 已提交
5362 5363 5364 5365 5366 5367 5368

	/*
	 * 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);
5369
	md_new_event(mddev);
L
Linus Torvalds 已提交
5370 5371 5372 5373 5374 5375 5376
	return 0;

abort_export:
	export_rdev(rdev);
	return err;
}

5377 5378 5379 5380
static int set_bitmap_file(mddev_t *mddev, int fd)
{
	int err;

5381 5382 5383 5384 5385 5386 5387
	if (mddev->pers) {
		if (!mddev->pers->quiesce)
			return -EBUSY;
		if (mddev->recovery || mddev->sync_thread)
			return -EBUSY;
		/* we should be able to change the bitmap.. */
	}
5388 5389


5390 5391 5392
	if (fd >= 0) {
		if (mddev->bitmap)
			return -EEXIST; /* cannot add when bitmap is present */
5393
		mddev->bitmap_info.file = fget(fd);
5394

5395
		if (mddev->bitmap_info.file == NULL) {
5396 5397 5398 5399 5400
			printk(KERN_ERR "%s: error: failed to get bitmap file\n",
			       mdname(mddev));
			return -EBADF;
		}

5401
		err = deny_bitmap_write_access(mddev->bitmap_info.file);
5402 5403 5404
		if (err) {
			printk(KERN_ERR "%s: error: bitmap file is already in use\n",
			       mdname(mddev));
5405 5406
			fput(mddev->bitmap_info.file);
			mddev->bitmap_info.file = NULL;
5407 5408
			return err;
		}
5409
		mddev->bitmap_info.offset = 0; /* file overrides offset */
5410 5411 5412 5413 5414
	} else if (mddev->bitmap == NULL)
		return -ENOENT; /* cannot remove what isn't there */
	err = 0;
	if (mddev->pers) {
		mddev->pers->quiesce(mddev, 1);
5415
		if (fd >= 0) {
5416
			err = bitmap_create(mddev);
5417 5418 5419
			if (!err)
				err = bitmap_load(mddev);
		}
5420
		if (fd < 0 || err) {
5421
			bitmap_destroy(mddev);
5422 5423
			fd = -1; /* make sure to put the file */
		}
5424
		mddev->pers->quiesce(mddev, 0);
5425 5426
	}
	if (fd < 0) {
5427 5428 5429
		if (mddev->bitmap_info.file) {
			restore_bitmap_write_access(mddev->bitmap_info.file);
			fput(mddev->bitmap_info.file);
5430
		}
5431
		mddev->bitmap_info.file = NULL;
5432 5433
	}

5434 5435 5436
	return err;
}

L
Linus Torvalds 已提交
5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455
/*
 * 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.
 */
static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
{

	if (info->raid_disks == 0) {
		/* just setting version number for superblock loading */
		if (info->major_version < 0 ||
5456
		    info->major_version >= ARRAY_SIZE(super_types) ||
L
Linus Torvalds 已提交
5457 5458 5459 5460 5461 5462 5463 5464 5465 5466
		    super_types[info->major_version].name == NULL) {
			/* maybe try to auto-load a module? */
			printk(KERN_INFO 
				"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;
5467
		mddev->persistent = !info->not_persistent;
5468 5469 5470 5471
		/* ensure mddev_put doesn't delete this now that there
		 * is some minimal configuration.
		 */
		mddev->ctime         = get_seconds();
L
Linus Torvalds 已提交
5472 5473 5474 5475 5476 5477 5478 5479
		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;
5480
	mddev->clevel[0]     = 0;
A
Andre Noll 已提交
5481
	mddev->dev_sectors   = 2 * (sector_t)info->size;
L
Linus Torvalds 已提交
5482 5483 5484 5485 5486 5487 5488 5489 5490
	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;
5491
	mddev->external	     = 0;
L
Linus Torvalds 已提交
5492 5493

	mddev->layout        = info->layout;
5494
	mddev->chunk_sectors = info->chunk_size >> 9;
L
Linus Torvalds 已提交
5495 5496 5497

	mddev->max_disks     = MD_SB_DISKS;

5498 5499
	if (mddev->persistent)
		mddev->flags         = 0;
5500
	set_bit(MD_CHANGE_DEVS, &mddev->flags);
L
Linus Torvalds 已提交
5501

5502 5503
	mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
	mddev->bitmap_info.offset = 0;
5504

5505 5506
	mddev->reshape_position = MaxSector;

L
Linus Torvalds 已提交
5507 5508 5509 5510 5511
	/*
	 * Generate a 128 bit UUID
	 */
	get_random_bytes(mddev->uuid, 16);

5512
	mddev->new_level = mddev->level;
5513
	mddev->new_chunk_sectors = mddev->chunk_sectors;
5514 5515 5516
	mddev->new_layout = mddev->layout;
	mddev->delta_disks = 0;

L
Linus Torvalds 已提交
5517 5518 5519
	return 0;
}

5520 5521
void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors)
{
D
Dan Williams 已提交
5522 5523 5524 5525 5526
	WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);

	if (mddev->external_size)
		return;

5527 5528 5529 5530
	mddev->array_sectors = array_sectors;
}
EXPORT_SYMBOL(md_set_array_sectors);

5531
static int update_size(mddev_t *mddev, sector_t num_sectors)
5532
{
5533
	mdk_rdev_t *rdev;
5534
	int rv;
5535
	int fit = (num_sectors == 0);
5536 5537 5538

	if (mddev->pers->resize == NULL)
		return -EINVAL;
5539 5540 5541 5542 5543
	/* 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
5544
	 * sb_start or, if that is <data_offset, it must fit before the size
5545 5546
	 * of each device.  If num_sectors is zero, we find the largest size
	 * that fits.
5547 5548 5549
	 */
	if (mddev->sync_thread)
		return -EBUSY;
5550 5551 5552 5553 5554
	if (mddev->bitmap)
		/* Sorry, cannot grow a bitmap yet, just remove it,
		 * grow, and re-add.
		 */
		return -EBUSY;
5555
	list_for_each_entry(rdev, &mddev->disks, same_set) {
5556
		sector_t avail = rdev->sectors;
5557

5558 5559 5560
		if (fit && (num_sectors == 0 || num_sectors > avail))
			num_sectors = avail;
		if (avail < num_sectors)
5561 5562
			return -ENOSPC;
	}
5563
	rv = mddev->pers->resize(mddev, num_sectors);
5564 5565
	if (!rv)
		revalidate_disk(mddev->gendisk);
5566 5567 5568
	return rv;
}

5569 5570 5571 5572
static int update_raid_disks(mddev_t *mddev, int raid_disks)
{
	int rv;
	/* change the number of raid disks */
5573
	if (mddev->pers->check_reshape == NULL)
5574 5575
		return -EINVAL;
	if (raid_disks <= 0 ||
5576
	    (mddev->max_disks && raid_disks >= mddev->max_disks))
5577
		return -EINVAL;
5578
	if (mddev->sync_thread || mddev->reshape_position != MaxSector)
5579
		return -EBUSY;
5580 5581 5582
	mddev->delta_disks = raid_disks - mddev->raid_disks;

	rv = mddev->pers->check_reshape(mddev);
5583 5584 5585 5586
	return rv;
}


L
Linus Torvalds 已提交
5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598
/*
 * 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.
 */
static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
{
	int rv = 0;
	int cnt = 0;
5599 5600 5601
	int state = 0;

	/* calculate expected state,ignoring low bits */
5602
	if (mddev->bitmap && mddev->bitmap_info.offset)
5603
		state |= (1 << MD_SB_BITMAP_PRESENT);
L
Linus Torvalds 已提交
5604 5605 5606 5607 5608 5609 5610 5611

	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        || */
	    !mddev->persistent	 != info->not_persistent||
5612
	    mddev->chunk_sectors != info->chunk_size >> 9 ||
5613 5614 5615
	    /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
	    ((state^info->state) & 0xfffffe00)
		)
L
Linus Torvalds 已提交
5616 5617
		return -EINVAL;
	/* Check there is only one change */
A
Andre Noll 已提交
5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629
	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 已提交
5630 5631 5632 5633 5634 5635

	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.
		 */
5636
		if (mddev->pers->check_reshape == NULL)
L
Linus Torvalds 已提交
5637
			return -EINVAL;
5638 5639
		else {
			mddev->new_layout = info->layout;
5640
			rv = mddev->pers->check_reshape(mddev);
5641 5642 5643 5644
			if (rv)
				mddev->new_layout = mddev->layout;
			return rv;
		}
L
Linus Torvalds 已提交
5645
	}
A
Andre Noll 已提交
5646
	if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
5647
		rv = update_size(mddev, (sector_t)info->size * 2);
5648

5649 5650 5651
	if (mddev->raid_disks    != info->raid_disks)
		rv = update_raid_disks(mddev, info->raid_disks);

5652 5653 5654 5655 5656 5657 5658 5659 5660
	if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
		if (mddev->pers->quiesce == NULL)
			return -EINVAL;
		if (mddev->recovery || mddev->sync_thread)
			return -EBUSY;
		if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
			/* add the bitmap */
			if (mddev->bitmap)
				return -EEXIST;
5661
			if (mddev->bitmap_info.default_offset == 0)
5662
				return -EINVAL;
5663 5664
			mddev->bitmap_info.offset =
				mddev->bitmap_info.default_offset;
5665 5666
			mddev->pers->quiesce(mddev, 1);
			rv = bitmap_create(mddev);
5667 5668
			if (!rv)
				rv = bitmap_load(mddev);
5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680
			if (rv)
				bitmap_destroy(mddev);
			mddev->pers->quiesce(mddev, 0);
		} else {
			/* remove the bitmap */
			if (!mddev->bitmap)
				return -ENOENT;
			if (mddev->bitmap->file)
				return -EINVAL;
			mddev->pers->quiesce(mddev, 1);
			bitmap_destroy(mddev);
			mddev->pers->quiesce(mddev, 0);
5681
			mddev->bitmap_info.offset = 0;
5682 5683
		}
	}
5684
	md_update_sb(mddev, 1);
L
Linus Torvalds 已提交
5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702
	return rv;
}

static int set_disk_faulty(mddev_t *mddev, dev_t dev)
{
	mdk_rdev_t *rdev;

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

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

	md_error(mddev, rdev);
	return 0;
}

5703 5704 5705 5706 5707 5708
/*
 * 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... ;-)
 */
5709 5710 5711 5712 5713 5714
static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
{
	mddev_t *mddev = bdev->bd_disk->private_data;

	geo->heads = 2;
	geo->sectors = 4;
5715
	geo->cylinders = mddev->array_sectors / 8;
5716 5717 5718
	return 0;
}

A
Al Viro 已提交
5719
static int md_ioctl(struct block_device *bdev, fmode_t mode,
L
Linus Torvalds 已提交
5720 5721 5722 5723 5724
			unsigned int cmd, unsigned long arg)
{
	int err = 0;
	void __user *argp = (void __user *)arg;
	mddev_t *mddev = NULL;
5725
	int ro;
L
Linus Torvalds 已提交
5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	/*
	 * Commands dealing with the RAID driver but not any
	 * particular array:
	 */
	switch (cmd)
	{
		case RAID_VERSION:
			err = get_version(argp);
			goto done;

		case PRINT_RAID_DEBUG:
			err = 0;
			md_print_devices();
			goto done;

#ifndef MODULE
		case RAID_AUTORUN:
			err = 0;
			autostart_arrays(arg);
			goto done;
#endif
		default:;
	}

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

A
Al Viro 已提交
5758
	mddev = bdev->bd_disk->private_data;
L
Linus Torvalds 已提交
5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821

	if (!mddev) {
		BUG();
		goto abort;
	}

	err = mddev_lock(mddev);
	if (err) {
		printk(KERN_INFO 
			"md: ioctl lock interrupted, reason %d, cmd %d\n",
			err, cmd);
		goto abort;
	}

	switch (cmd)
	{
		case 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;
					goto abort_unlock;
				}
				if (mddev->pers) {
					err = update_array_info(mddev, &info);
					if (err) {
						printk(KERN_WARNING "md: couldn't update"
						       " array info. %d\n", err);
						goto abort_unlock;
					}
					goto done_unlock;
				}
				if (!list_empty(&mddev->disks)) {
					printk(KERN_WARNING
					       "md: array %s already has disks!\n",
					       mdname(mddev));
					err = -EBUSY;
					goto abort_unlock;
				}
				if (mddev->raid_disks) {
					printk(KERN_WARNING
					       "md: array %s already initialised!\n",
					       mdname(mddev));
					err = -EBUSY;
					goto abort_unlock;
				}
				err = set_array_info(mddev, &info);
				if (err) {
					printk(KERN_WARNING "md: couldn't set"
					       " array info. %d\n", err);
					goto abort_unlock;
				}
			}
			goto done_unlock;

		default:;
	}

	/*
	 * Commands querying/configuring an existing array:
	 */
5822
	/* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
5823
	 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
5824 5825 5826 5827
	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 已提交
5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840
		err = -ENODEV;
		goto abort_unlock;
	}

	/*
	 * Commands even a read-only array can execute:
	 */
	switch (cmd)
	{
		case GET_ARRAY_INFO:
			err = get_array_info(mddev, argp);
			goto done_unlock;

5841
		case GET_BITMAP_FILE:
5842
			err = get_bitmap_file(mddev, argp);
5843 5844
			goto done_unlock;

L
Linus Torvalds 已提交
5845 5846 5847 5848 5849 5850 5851 5852 5853
		case GET_DISK_INFO:
			err = get_disk_info(mddev, argp);
			goto done_unlock;

		case RESTART_ARRAY_RW:
			err = restart_array(mddev);
			goto done_unlock;

		case STOP_ARRAY:
5854
			err = do_md_stop(mddev, 0, 1);
L
Linus Torvalds 已提交
5855 5856 5857
			goto done_unlock;

		case STOP_ARRAY_RO:
5858
			err = md_set_readonly(mddev, 1);
L
Linus Torvalds 已提交
5859 5860
			goto done_unlock;

5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888
		case BLKROSET:
			if (get_user(ro, (int __user *)(arg))) {
				err = -EFAULT;
				goto done_unlock;
			}
			err = -EINVAL;

			/* if the bdev is going readonly the value of mddev->ro
			 * does not matter, no writes are coming
			 */
			if (ro)
				goto done_unlock;

			/* are we are already prepared for writes? */
			if (mddev->ro != 1)
				goto done_unlock;

			/* 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);
				}
			}
			goto done_unlock;
L
Linus Torvalds 已提交
5889 5890 5891 5892
	}

	/*
	 * The remaining ioctls are changing the state of the
5893 5894 5895 5896
	 * superblock, so we do not allow them on read-only arrays.
	 * However non-MD ioctls (e.g. get-size) will still come through
	 * here and hit the 'default' below, so only disallow
	 * 'md' ioctls, and switch to rw mode if started auto-readonly.
L
Linus Torvalds 已提交
5897
	 */
5898
	if (_IOC_TYPE(cmd) == MD_MAJOR && mddev->ro && mddev->pers) {
5899 5900
		if (mddev->ro == 2) {
			mddev->ro = 0;
N
NeilBrown 已提交
5901
			sysfs_notify_dirent_safe(mddev->sysfs_state);
5902 5903
			set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
			md_wakeup_thread(mddev->thread);
5904 5905 5906 5907
		} else {
			err = -EROFS;
			goto abort_unlock;
		}
L
Linus Torvalds 已提交
5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934
	}

	switch (cmd)
	{
		case ADD_NEW_DISK:
		{
			mdu_disk_info_t info;
			if (copy_from_user(&info, argp, sizeof(info)))
				err = -EFAULT;
			else
				err = add_new_disk(mddev, &info);
			goto done_unlock;
		}

		case HOT_REMOVE_DISK:
			err = hot_remove_disk(mddev, new_decode_dev(arg));
			goto done_unlock;

		case HOT_ADD_DISK:
			err = hot_add_disk(mddev, new_decode_dev(arg));
			goto done_unlock;

		case SET_DISK_FAULTY:
			err = set_disk_faulty(mddev, new_decode_dev(arg));
			goto done_unlock;

		case RUN_ARRAY:
5935
			err = do_md_run(mddev);
L
Linus Torvalds 已提交
5936 5937
			goto done_unlock;

5938 5939 5940 5941
		case SET_BITMAP_FILE:
			err = set_bitmap_file(mddev, (int)arg);
			goto done_unlock;

L
Linus Torvalds 已提交
5942 5943 5944 5945 5946 5947 5948
		default:
			err = -EINVAL;
			goto abort_unlock;
	}

done_unlock:
abort_unlock:
5949 5950 5951
	if (mddev->hold_active == UNTIL_IOCTL &&
	    err != -EINVAL)
		mddev->hold_active = 0;
L
Linus Torvalds 已提交
5952 5953 5954 5955 5956 5957 5958 5959 5960
	mddev_unlock(mddev);

	return err;
done:
	if (err)
		MD_BUG();
abort:
	return err;
}
5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979
#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 已提交
5980

A
Al Viro 已提交
5981
static int md_open(struct block_device *bdev, fmode_t mode)
L
Linus Torvalds 已提交
5982 5983 5984 5985 5986
{
	/*
	 * Succeed if we can lock the mddev, which confirms that
	 * it isn't being stopped right now.
	 */
5987
	mddev_t *mddev = mddev_find(bdev->bd_dev);
L
Linus Torvalds 已提交
5988 5989
	int err;

5990 5991 5992 5993 5994 5995
	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 已提交
5996
		flush_workqueue(md_misc_wq);
5997 5998 5999 6000 6001
		/* Then retry the open from the top */
		return -ERESTARTSYS;
	}
	BUG_ON(mddev != bdev->bd_disk->private_data);

N
NeilBrown 已提交
6002
	if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
L
Linus Torvalds 已提交
6003 6004 6005
		goto out;

	err = 0;
6006
	atomic_inc(&mddev->openers);
N
NeilBrown 已提交
6007
	mutex_unlock(&mddev->open_mutex);
L
Linus Torvalds 已提交
6008

6009
	check_disk_size_change(mddev->gendisk, bdev);
L
Linus Torvalds 已提交
6010 6011 6012 6013
 out:
	return err;
}

A
Al Viro 已提交
6014
static int md_release(struct gendisk *disk, fmode_t mode)
L
Linus Torvalds 已提交
6015
{
A
Al Viro 已提交
6016
 	mddev_t *mddev = disk->private_data;
L
Linus Torvalds 已提交
6017

E
Eric Sesterhenn 已提交
6018
	BUG_ON(!mddev);
6019
	atomic_dec(&mddev->openers);
L
Linus Torvalds 已提交
6020 6021 6022 6023
	mddev_put(mddev);

	return 0;
}
6024
static const struct block_device_operations md_fops =
L
Linus Torvalds 已提交
6025 6026
{
	.owner		= THIS_MODULE,
A
Al Viro 已提交
6027 6028
	.open		= md_open,
	.release	= md_release,
N
NeilBrown 已提交
6029
	.ioctl		= md_ioctl,
6030 6031 6032
#ifdef CONFIG_COMPAT
	.compat_ioctl	= md_compat_ioctl,
#endif
6033
	.getgeo		= md_getgeo,
L
Linus Torvalds 已提交
6034 6035
};

A
Adrian Bunk 已提交
6036
static int md_thread(void * arg)
L
Linus Torvalds 已提交
6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051
{
	mdk_thread_t *thread = arg;

	/*
	 * 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 已提交
6052
	allow_signal(SIGKILL);
6053
	while (!kthread_should_stop()) {
L
Linus Torvalds 已提交
6054

6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067
		/* 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 已提交
6068

6069 6070
		clear_bit(THREAD_WAKEUP, &thread->flags);
		if (!kthread_should_stop())
6071
			thread->run(thread->mddev);
L
Linus Torvalds 已提交
6072
	}
6073

L
Linus Torvalds 已提交
6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090
	return 0;
}

void md_wakeup_thread(mdk_thread_t *thread)
{
	if (thread) {
		dprintk("md: waking up MD thread %s.\n", thread->tsk->comm);
		set_bit(THREAD_WAKEUP, &thread->flags);
		wake_up(&thread->wqueue);
	}
}

mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
				 const char *name)
{
	mdk_thread_t *thread;

6091
	thread = kzalloc(sizeof(mdk_thread_t), GFP_KERNEL);
L
Linus Torvalds 已提交
6092 6093 6094 6095 6096 6097 6098
	if (!thread)
		return NULL;

	init_waitqueue_head(&thread->wqueue);

	thread->run = run;
	thread->mddev = mddev;
6099
	thread->timeout = MAX_SCHEDULE_TIMEOUT;
6100 6101 6102 6103
	thread->tsk = kthread_run(md_thread, thread,
				  "%s_%s",
				  mdname(thread->mddev),
				  name ?: mddev->pers->name);
6104
	if (IS_ERR(thread->tsk)) {
L
Linus Torvalds 已提交
6105 6106 6107 6108 6109 6110 6111 6112
		kfree(thread);
		return NULL;
	}
	return thread;
}

void md_unregister_thread(mdk_thread_t *thread)
{
6113 6114
	if (!thread)
		return;
6115
	dprintk("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
6116 6117

	kthread_stop(thread->tsk);
L
Linus Torvalds 已提交
6118 6119 6120 6121 6122 6123 6124 6125 6126 6127
	kfree(thread);
}

void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
{
	if (!mddev) {
		MD_BUG();
		return;
	}

6128
	if (!rdev || test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
6129
		return;
6130 6131 6132

	if (mddev->external)
		set_bit(Blocked, &rdev->flags);
6133
/*
L
Linus Torvalds 已提交
6134 6135 6136 6137 6138
	dprintk("md_error dev:%s, rdev:(%d:%d), (caller: %p,%p,%p,%p).\n",
		mdname(mddev),
		MAJOR(rdev->bdev->bd_dev), MINOR(rdev->bdev->bd_dev),
		__builtin_return_address(0),__builtin_return_address(1),
		__builtin_return_address(2),__builtin_return_address(3));
6139
*/
6140 6141
	if (!mddev->pers)
		return;
L
Linus Torvalds 已提交
6142 6143 6144
	if (!mddev->pers->error_handler)
		return;
	mddev->pers->error_handler(mddev,rdev);
6145 6146
	if (mddev->degraded)
		set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
N
NeilBrown 已提交
6147
	sysfs_notify_dirent_safe(rdev->sysfs_state);
L
Linus Torvalds 已提交
6148 6149 6150
	set_bit(MD_RECOVERY_INTR, &mddev->recovery);
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	md_wakeup_thread(mddev->thread);
6151
	if (mddev->event_work.func)
T
Tejun Heo 已提交
6152
		queue_work(md_misc_wq, &mddev->event_work);
6153
	md_new_event_inintr(mddev);
L
Linus Torvalds 已提交
6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164
}

/* seq_file implementation /proc/mdstat */

static void status_unused(struct seq_file *seq)
{
	int i = 0;
	mdk_rdev_t *rdev;

	seq_printf(seq, "unused devices: ");

6165
	list_for_each_entry(rdev, &pending_raid_disks, same_set) {
L
Linus Torvalds 已提交
6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179
		char b[BDEVNAME_SIZE];
		i++;
		seq_printf(seq, "%s ",
			      bdevname(rdev->bdev,b));
	}
	if (!i)
		seq_printf(seq, "<none>");

	seq_printf(seq, "\n");
}


static void status_resync(struct seq_file *seq, mddev_t * mddev)
{
6180 6181 6182
	sector_t max_sectors, resync, res;
	unsigned long dt, db;
	sector_t rt;
6183 6184
	int scale;
	unsigned int per_milli;
L
Linus Torvalds 已提交
6185

6186
	resync = mddev->curr_resync - atomic_read(&mddev->recovery_active);
L
Linus Torvalds 已提交
6187 6188

	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
6189
		max_sectors = mddev->resync_max_sectors;
L
Linus Torvalds 已提交
6190
	else
6191
		max_sectors = mddev->dev_sectors;
L
Linus Torvalds 已提交
6192 6193 6194 6195

	/*
	 * Should not happen.
	 */
6196
	if (!max_sectors) {
L
Linus Torvalds 已提交
6197 6198 6199
		MD_BUG();
		return;
	}
6200
	/* Pick 'scale' such that (resync>>scale)*1000 will fit
6201
	 * in a sector_t, and (max_sectors>>scale) will fit in a
6202 6203 6204 6205 6206
	 * 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)) {
6207
		while ( max_sectors/2 > (1ULL<<(scale+32)))
6208 6209 6210
			scale++;
	}
	res = (resync>>scale)*1000;
6211
	sector_div(res, (u32)((max_sectors>>scale)+1));
6212 6213

	per_milli = res;
L
Linus Torvalds 已提交
6214
	{
6215
		int i, x = per_milli/50, y = 20-x;
L
Linus Torvalds 已提交
6216 6217 6218 6219 6220 6221 6222 6223
		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, "] ");
	}
6224
	seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
6225 6226
		   (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
		    "reshape" :
6227 6228 6229 6230 6231
		    (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
		     "check" :
		     (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
		      "resync" : "recovery"))),
		   per_milli/10, per_milli % 10,
6232 6233
		   (unsigned long long) resync/2,
		   (unsigned long long) max_sectors/2);
L
Linus Torvalds 已提交
6234 6235 6236 6237 6238

	/*
	 * dt: time from mark until now
	 * db: blocks written from mark until now
	 * rt: remaining time
6239 6240 6241 6242 6243 6244 6245 6246 6247
	 *
	 * 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.
	 * We scale the divisor (db) by 32 to avoid loosing precision
	 * 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 已提交
6248 6249 6250
	 */
	dt = ((jiffies - mddev->resync_mark) / HZ);
	if (!dt) dt++;
6251 6252
	db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
		- mddev->resync_mark_cnt;
L
Linus Torvalds 已提交
6253

6254 6255 6256 6257 6258 6259 6260
	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 已提交
6261

6262
	seq_printf(seq, " speed=%ldK/sec", db/2/dt);
L
Linus Torvalds 已提交
6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326
}

static void *md_seq_start(struct seq_file *seq, loff_t *pos)
{
	struct list_head *tmp;
	loff_t l = *pos;
	mddev_t *mddev;

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

	spin_lock(&all_mddevs_lock);
	list_for_each(tmp,&all_mddevs)
		if (!l--) {
			mddev = list_entry(tmp, mddev_t, all_mddevs);
			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;
	mddev_t *next_mddev, *mddev = v;
	
	++*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)
		next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs));
	else {
		next_mddev = (void*)2;
		*pos = 0x10000;
	}		
	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)
{
	mddev_t *mddev = v;

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

6327 6328 6329 6330
struct mdstat_info {
	int event;
};

L
Linus Torvalds 已提交
6331 6332 6333
static int md_seq_show(struct seq_file *seq, void *v)
{
	mddev_t *mddev = v;
6334
	sector_t sectors;
L
Linus Torvalds 已提交
6335
	mdk_rdev_t *rdev;
6336
	struct mdstat_info *mi = seq->private;
6337
	struct bitmap *bitmap;
L
Linus Torvalds 已提交
6338 6339

	if (v == (void*)1) {
6340
		struct mdk_personality *pers;
L
Linus Torvalds 已提交
6341 6342
		seq_printf(seq, "Personalities : ");
		spin_lock(&pers_lock);
6343 6344
		list_for_each_entry(pers, &pers_list, list)
			seq_printf(seq, "[%s] ", pers->name);
L
Linus Torvalds 已提交
6345 6346 6347

		spin_unlock(&pers_lock);
		seq_printf(seq, "\n");
6348
		mi->event = atomic_read(&md_event_count);
L
Linus Torvalds 已提交
6349 6350 6351 6352 6353 6354 6355
		return 0;
	}
	if (v == (void*)2) {
		status_unused(seq);
		return 0;
	}

I
Ingo Molnar 已提交
6356
	if (mddev_lock(mddev) < 0)
L
Linus Torvalds 已提交
6357
		return -EINTR;
I
Ingo Molnar 已提交
6358

L
Linus Torvalds 已提交
6359 6360 6361 6362
	if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
		seq_printf(seq, "%s : %sactive", mdname(mddev),
						mddev->pers ? "" : "in");
		if (mddev->pers) {
6363
			if (mddev->ro==1)
L
Linus Torvalds 已提交
6364
				seq_printf(seq, " (read-only)");
6365
			if (mddev->ro==2)
6366
				seq_printf(seq, " (auto-read-only)");
L
Linus Torvalds 已提交
6367 6368 6369
			seq_printf(seq, " %s", mddev->pers->name);
		}

6370
		sectors = 0;
6371
		list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
6372 6373 6374
			char b[BDEVNAME_SIZE];
			seq_printf(seq, " %s[%d]",
				bdevname(rdev->bdev,b), rdev->desc_nr);
6375 6376
			if (test_bit(WriteMostly, &rdev->flags))
				seq_printf(seq, "(W)");
6377
			if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
6378 6379
				seq_printf(seq, "(F)");
				continue;
6380 6381
			} else if (rdev->raid_disk < 0)
				seq_printf(seq, "(S)"); /* spare */
6382
			sectors += rdev->sectors;
L
Linus Torvalds 已提交
6383 6384 6385 6386 6387
		}

		if (!list_empty(&mddev->disks)) {
			if (mddev->pers)
				seq_printf(seq, "\n      %llu blocks",
6388 6389
					   (unsigned long long)
					   mddev->array_sectors / 2);
L
Linus Torvalds 已提交
6390 6391
			else
				seq_printf(seq, "\n      %llu blocks",
6392
					   (unsigned long long)sectors / 2);
L
Linus Torvalds 已提交
6393
		}
6394 6395 6396 6397 6398 6399 6400
		if (mddev->persistent) {
			if (mddev->major_version != 0 ||
			    mddev->minor_version != 90) {
				seq_printf(seq," super %d.%d",
					   mddev->major_version,
					   mddev->minor_version);
			}
6401 6402 6403 6404
		} else if (mddev->external)
			seq_printf(seq, " super external:%s",
				   mddev->metadata_type);
		else
6405
			seq_printf(seq, " super non-persistent");
L
Linus Torvalds 已提交
6406 6407

		if (mddev->pers) {
6408
			mddev->pers->status(seq, mddev);
L
Linus Torvalds 已提交
6409
	 		seq_printf(seq, "\n      ");
6410 6411
			if (mddev->pers->sync_request) {
				if (mddev->curr_resync > 2) {
6412
					status_resync(seq, mddev);
6413 6414 6415 6416 6417 6418
					seq_printf(seq, "\n      ");
				} else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
					seq_printf(seq, "\tresync=DELAYED\n      ");
				else if (mddev->recovery_cp < MaxSector)
					seq_printf(seq, "\tresync=PENDING\n      ");
			}
6419 6420 6421 6422 6423 6424 6425
		} else
			seq_printf(seq, "\n       ");

		if ((bitmap = mddev->bitmap)) {
			unsigned long chunk_kb;
			unsigned long flags;
			spin_lock_irqsave(&bitmap->lock, flags);
6426
			chunk_kb = mddev->bitmap_info.chunksize >> 10;
6427 6428 6429 6430 6431 6432
			seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "
				"%lu%s chunk",
				bitmap->pages - bitmap->missing_pages,
				bitmap->pages,
				(bitmap->pages - bitmap->missing_pages)
					<< (PAGE_SHIFT - 10),
6433
				chunk_kb ? chunk_kb : mddev->bitmap_info.chunksize,
6434
				chunk_kb ? "KB" : "B");
6435 6436
			if (bitmap->file) {
				seq_printf(seq, ", file: ");
6437
				seq_path(seq, &bitmap->file->f_path, " \t\n");
6438
			}
6439

6440 6441
			seq_printf(seq, "\n");
			spin_unlock_irqrestore(&bitmap->lock, flags);
L
Linus Torvalds 已提交
6442 6443 6444 6445 6446 6447 6448 6449 6450
		}

		seq_printf(seq, "\n");
	}
	mddev_unlock(mddev);
	
	return 0;
}

J
Jan Engelhardt 已提交
6451
static const struct seq_operations md_seq_ops = {
L
Linus Torvalds 已提交
6452 6453 6454 6455 6456 6457 6458 6459 6460
	.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)
{
	int error;
6461 6462 6463
	struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL);
	if (mi == NULL)
		return -ENOMEM;
L
Linus Torvalds 已提交
6464 6465

	error = seq_open(file, &md_seq_ops);
6466 6467 6468 6469 6470 6471 6472
	if (error)
		kfree(mi);
	else {
		struct seq_file *p = file->private_data;
		p->private = mi;
		mi->event = atomic_read(&md_event_count);
	}
L
Linus Torvalds 已提交
6473 6474 6475
	return error;
}

6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491
static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
{
	struct seq_file *m = filp->private_data;
	struct mdstat_info *mi = m->private;
	int mask;

	poll_wait(filp, &md_event_waiters, wait);

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

	if (mi->event != atomic_read(&md_event_count))
		mask |= POLLERR | POLLPRI;
	return mask;
}

6492
static const struct file_operations md_seq_fops = {
6493
	.owner		= THIS_MODULE,
L
Linus Torvalds 已提交
6494 6495 6496
	.open           = md_seq_open,
	.read           = seq_read,
	.llseek         = seq_lseek,
6497
	.release	= seq_release_private,
6498
	.poll		= mdstat_poll,
L
Linus Torvalds 已提交
6499 6500
};

6501
int register_md_personality(struct mdk_personality *p)
L
Linus Torvalds 已提交
6502 6503
{
	spin_lock(&pers_lock);
6504 6505
	list_add_tail(&p->list, &pers_list);
	printk(KERN_INFO "md: %s personality registered for level %d\n", p->name, p->level);
L
Linus Torvalds 已提交
6506 6507 6508 6509
	spin_unlock(&pers_lock);
	return 0;
}

6510
int unregister_md_personality(struct mdk_personality *p)
L
Linus Torvalds 已提交
6511
{
6512
	printk(KERN_INFO "md: %s personality unregistered\n", p->name);
L
Linus Torvalds 已提交
6513
	spin_lock(&pers_lock);
6514
	list_del_init(&p->list);
L
Linus Torvalds 已提交
6515 6516 6517 6518
	spin_unlock(&pers_lock);
	return 0;
}

N
NeilBrown 已提交
6519
static int is_mddev_idle(mddev_t *mddev, int init)
L
Linus Torvalds 已提交
6520 6521 6522
{
	mdk_rdev_t * rdev;
	int idle;
N
NeilBrown 已提交
6523
	int curr_events;
L
Linus Torvalds 已提交
6524 6525

	idle = 1;
6526 6527
	rcu_read_lock();
	rdev_for_each_rcu(rdev, mddev) {
L
Linus Torvalds 已提交
6528
		struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
N
NeilBrown 已提交
6529 6530 6531
		curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
			      (int)part_stat_read(&disk->part0, sectors[1]) -
			      atomic_read(&disk->sync_io);
6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551
		/* 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.
6552
		 *
L
Linus Torvalds 已提交
6553
		 */
N
NeilBrown 已提交
6554
		if (init || curr_events - rdev->last_events > 64) {
L
Linus Torvalds 已提交
6555 6556 6557 6558
			rdev->last_events = curr_events;
			idle = 0;
		}
	}
6559
	rcu_read_unlock();
L
Linus Torvalds 已提交
6560 6561 6562 6563 6564 6565 6566 6567 6568
	return idle;
}

void md_done_sync(mddev_t *mddev, int blocks, int ok)
{
	/* another "blocks" (512byte) blocks have been synced */
	atomic_sub(blocks, &mddev->recovery_active);
	wake_up(&mddev->recovery_wait);
	if (!ok) {
6569
		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
L
Linus Torvalds 已提交
6570 6571 6572 6573 6574 6575
		md_wakeup_thread(mddev->thread);
		// stop recovery, signal do_sync ....
	}
}


6576 6577
/* md_write_start(mddev, bi)
 * If we need to update some array metadata (e.g. 'active' flag
6578 6579
 * in superblock) before writing, schedule a superblock update
 * and wait for it to complete.
6580
 */
6581
void md_write_start(mddev_t *mddev, struct bio *bi)
L
Linus Torvalds 已提交
6582
{
6583
	int did_change = 0;
6584
	if (bio_data_dir(bi) != WRITE)
6585
		return;
6586

6587 6588 6589 6590 6591 6592
	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);
6593
		md_wakeup_thread(mddev->sync_thread);
6594
		did_change = 1;
6595
	}
6596
	atomic_inc(&mddev->writes_pending);
6597 6598
	if (mddev->safemode == 1)
		mddev->safemode = 0;
6599
	if (mddev->in_sync) {
6600
		spin_lock_irq(&mddev->write_lock);
6601 6602
		if (mddev->in_sync) {
			mddev->in_sync = 0;
6603
			set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6604
			set_bit(MD_CHANGE_PENDING, &mddev->flags);
6605
			md_wakeup_thread(mddev->thread);
6606
			did_change = 1;
6607
		}
6608
		spin_unlock_irq(&mddev->write_lock);
6609
	}
6610
	if (did_change)
N
NeilBrown 已提交
6611
		sysfs_notify_dirent_safe(mddev->sysfs_state);
6612 6613
	wait_event(mddev->sb_wait,
		   !test_bit(MD_CHANGE_PENDING, &mddev->flags));
L
Linus Torvalds 已提交
6614 6615 6616 6617 6618 6619 6620
}

void md_write_end(mddev_t *mddev)
{
	if (atomic_dec_and_test(&mddev->writes_pending)) {
		if (mddev->safemode == 2)
			md_wakeup_thread(mddev->thread);
6621
		else if (mddev->safemode_delay)
L
Linus Torvalds 已提交
6622 6623 6624 6625
			mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
	}
}

6626 6627 6628 6629 6630
/* 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.
6631 6632 6633
 *
 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
 * is dropped, so return -EAGAIN after notifying userspace.
6634
 */
6635
int md_allow_write(mddev_t *mddev)
6636 6637
{
	if (!mddev->pers)
6638
		return 0;
6639
	if (mddev->ro)
6640
		return 0;
6641
	if (!mddev->pers->sync_request)
6642
		return 0;
6643 6644 6645 6646 6647

	spin_lock_irq(&mddev->write_lock);
	if (mddev->in_sync) {
		mddev->in_sync = 0;
		set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6648
		set_bit(MD_CHANGE_PENDING, &mddev->flags);
6649 6650 6651 6652 6653
		if (mddev->safemode_delay &&
		    mddev->safemode == 0)
			mddev->safemode = 1;
		spin_unlock_irq(&mddev->write_lock);
		md_update_sb(mddev, 0);
N
NeilBrown 已提交
6654
		sysfs_notify_dirent_safe(mddev->sysfs_state);
6655 6656
	} else
		spin_unlock_irq(&mddev->write_lock);
6657

6658
	if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
6659 6660 6661
		return -EAGAIN;
	else
		return 0;
6662 6663 6664
}
EXPORT_SYMBOL_GPL(md_allow_write);

N
NeilBrown 已提交
6665
void md_unplug(mddev_t *mddev)
6666 6667 6668 6669 6670 6671 6672
{
	if (mddev->queue)
		blk_unplug(mddev->queue);
	if (mddev->plug)
		mddev->plug->unplug_fn(mddev->plug);
}

L
Linus Torvalds 已提交
6673 6674
#define SYNC_MARKS	10
#define	SYNC_MARK_STEP	(3*HZ)
6675
void md_do_sync(mddev_t *mddev)
L
Linus Torvalds 已提交
6676 6677 6678 6679
{
	mddev_t *mddev2;
	unsigned int currspeed = 0,
		 window;
6680
	sector_t max_sectors,j, io_sectors;
L
Linus Torvalds 已提交
6681 6682 6683 6684 6685
	unsigned long mark[SYNC_MARKS];
	sector_t mark_cnt[SYNC_MARKS];
	int last_mark,m;
	struct list_head *tmp;
	sector_t last_check;
6686
	int skipped = 0;
6687
	mdk_rdev_t *rdev;
6688
	char *desc;
L
Linus Torvalds 已提交
6689 6690 6691 6692

	/* just incase thread restarts... */
	if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
		return;
6693 6694
	if (mddev->ro) /* never try to sync a read-only array */
		return;
L
Linus Torvalds 已提交
6695

6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
		if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
			desc = "data-check";
		else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
			desc = "requested-resync";
		else
			desc = "resync";
	} else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
		desc = "reshape";
	else
		desc = "recovery";

L
Linus Torvalds 已提交
6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727
	/* 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:
6728
		if (kthread_should_stop())
N
NeilBrown 已提交
6729
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6730 6731

		if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
L
Linus Torvalds 已提交
6732
			goto skip;
6733
		for_each_mddev(mddev2, tmp) {
L
Linus Torvalds 已提交
6734 6735
			if (mddev2 == mddev)
				continue;
6736 6737 6738
			if (!mddev->parallel_resync
			&&  mddev2->curr_resync
			&&  match_mddev_units(mddev, mddev2)) {
L
Linus Torvalds 已提交
6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749
				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;
6750 6751 6752 6753 6754
				/* 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);
6755
				if (!kthread_should_stop() &&
6756
				    mddev2->curr_resync >= mddev->curr_resync) {
6757 6758
					printk(KERN_INFO "md: delaying %s of %s"
					       " until %s has finished (they"
L
Linus Torvalds 已提交
6759
					       " share one or more physical units)\n",
6760
					       desc, mdname(mddev), mdname(mddev2));
L
Linus Torvalds 已提交
6761
					mddev_put(mddev2);
6762 6763
					if (signal_pending(current))
						flush_signals(current);
L
Linus Torvalds 已提交
6764 6765 6766 6767 6768 6769 6770 6771 6772
					schedule();
					finish_wait(&resync_wait, &wq);
					goto try_again;
				}
				finish_wait(&resync_wait, &wq);
			}
		}
	} while (mddev->curr_resync < 2);

6773
	j = 0;
6774
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
L
Linus Torvalds 已提交
6775
		/* resync follows the size requested by the personality,
6776
		 * which defaults to physical size, but can be virtual size
L
Linus Torvalds 已提交
6777 6778
		 */
		max_sectors = mddev->resync_max_sectors;
6779
		mddev->resync_mismatches = 0;
6780
		/* we don't use the checkpoint if there's a bitmap */
6781 6782 6783
		if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
			j = mddev->resync_min;
		else if (!mddev->bitmap)
6784
			j = mddev->recovery_cp;
6785

6786
	} else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
A
Andre Noll 已提交
6787
		max_sectors = mddev->dev_sectors;
6788
	else {
L
Linus Torvalds 已提交
6789
		/* recovery follows the physical size of devices */
A
Andre Noll 已提交
6790
		max_sectors = mddev->dev_sectors;
6791
		j = MaxSector;
6792 6793
		rcu_read_lock();
		list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
6794 6795 6796 6797 6798
			if (rdev->raid_disk >= 0 &&
			    !test_bit(Faulty, &rdev->flags) &&
			    !test_bit(In_sync, &rdev->flags) &&
			    rdev->recovery_offset < j)
				j = rdev->recovery_offset;
6799
		rcu_read_unlock();
6800
	}
L
Linus Torvalds 已提交
6801

6802 6803 6804
	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));
6805
	printk(KERN_INFO "md: using maximum available idle IO bandwidth "
6806 6807
	       "(but not more than %d KB/sec) for %s.\n",
	       speed_max(mddev), desc);
L
Linus Torvalds 已提交
6808

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

6811
	io_sectors = 0;
L
Linus Torvalds 已提交
6812 6813
	for (m = 0; m < SYNC_MARKS; m++) {
		mark[m] = jiffies;
6814
		mark_cnt[m] = io_sectors;
L
Linus Torvalds 已提交
6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831
	}
	last_mark = 0;
	mddev->resync_mark = mark[last_mark];
	mddev->resync_mark_cnt = mark_cnt[last_mark];

	/*
	 * Tune reconstruction:
	 */
	window = 32*(PAGE_SIZE/512);
	printk(KERN_INFO "md: using %dk window, over a total of %llu blocks.\n",
		window/2,(unsigned long long) max_sectors/2);

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

	if (j>2) {
		printk(KERN_INFO 
6832 6833
		       "md: resuming %s of %s from checkpoint.\n",
		       desc, mdname(mddev));
L
Linus Torvalds 已提交
6834 6835
		mddev->curr_resync = j;
	}
6836
	mddev->curr_resync_completed = j;
L
Linus Torvalds 已提交
6837 6838

	while (j < max_sectors) {
6839
		sector_t sectors;
L
Linus Torvalds 已提交
6840

6841
		skipped = 0;
6842

6843 6844 6845 6846 6847 6848 6849
		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)) ||
		     (j - mddev->curr_resync_completed)*2
		     >= mddev->resync_max - mddev->curr_resync_completed
			    )) {
6850
			/* time to update curr_resync_completed */
6851
			md_unplug(mddev);
6852 6853
			wait_event(mddev->recovery_wait,
				   atomic_read(&mddev->recovery_active) == 0);
6854
			mddev->curr_resync_completed = j;
6855
			set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6856
			sysfs_notify(&mddev->kobj, NULL, "sync_completed");
6857
		}
6858

6859 6860 6861 6862 6863 6864 6865 6866 6867 6868
		while (j >= mddev->resync_max && !kthread_should_stop()) {
			/* 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
						 || kthread_should_stop());
		}
6869 6870 6871 6872

		if (kthread_should_stop())
			goto interrupted;

6873
		sectors = mddev->pers->sync_request(mddev, j, &skipped,
6874
						  currspeed < speed_min(mddev));
6875
		if (sectors == 0) {
6876
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
L
Linus Torvalds 已提交
6877 6878
			goto out;
		}
6879 6880 6881 6882 6883 6884

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

L
Linus Torvalds 已提交
6885 6886
		j += sectors;
		if (j>1) mddev->curr_resync = j;
6887
		mddev->curr_mark_cnt = io_sectors;
6888 6889 6890 6891 6892
		if (last_check == 0)
			/* this is the earliers that rebuilt will be
			 * visible in /proc/mdstat
			 */
			md_new_event(mddev);
6893 6894

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

6897
		last_check = io_sectors;
L
Linus Torvalds 已提交
6898

6899
		if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
L
Linus Torvalds 已提交
6900 6901 6902 6903 6904 6905 6906 6907 6908 6909
			break;

	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;
6910
			mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
L
Linus Torvalds 已提交
6911 6912 6913 6914
			last_mark = next;
		}


6915 6916 6917
		if (kthread_should_stop())
			goto interrupted;

L
Linus Torvalds 已提交
6918 6919 6920 6921 6922 6923 6924 6925 6926

		/*
		 * 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)
		 */
6927
		md_unplug(mddev);
L
Linus Torvalds 已提交
6928 6929
		cond_resched();

6930 6931
		currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
			/((jiffies-mddev->resync_mark)/HZ +1) +1;
L
Linus Torvalds 已提交
6932

6933 6934
		if (currspeed > speed_min(mddev)) {
			if ((currspeed > speed_max(mddev)) ||
N
NeilBrown 已提交
6935
					!is_mddev_idle(mddev, 0)) {
6936
				msleep(500);
L
Linus Torvalds 已提交
6937 6938 6939 6940
				goto repeat;
			}
		}
	}
6941
	printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc);
L
Linus Torvalds 已提交
6942 6943 6944 6945
	/*
	 * this also signals 'finished resyncing' to md_stop
	 */
 out:
6946
	md_unplug(mddev);
L
Linus Torvalds 已提交
6947 6948 6949 6950

	wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));

	/* tell personality that we are finished */
6951
	mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
L
Linus Torvalds 已提交
6952

6953
	if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
6954 6955 6956 6957 6958
	    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
6959 6960
					       "md: checkpointing %s of %s.\n",
					       desc, mdname(mddev));
6961 6962 6963 6964 6965 6966 6967
					mddev->recovery_cp = mddev->curr_resync;
				}
			} else
				mddev->recovery_cp = MaxSector;
		} else {
			if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
				mddev->curr_resync = MaxSector;
6968 6969
			rcu_read_lock();
			list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
6970
				if (rdev->raid_disk >= 0 &&
6971
				    mddev->delta_disks >= 0 &&
6972 6973 6974 6975
				    !test_bit(Faulty, &rdev->flags) &&
				    !test_bit(In_sync, &rdev->flags) &&
				    rdev->recovery_offset < mddev->curr_resync)
					rdev->recovery_offset = mddev->curr_resync;
6976
			rcu_read_unlock();
6977
		}
L
Linus Torvalds 已提交
6978
	}
6979
	set_bit(MD_CHANGE_DEVS, &mddev->flags);
L
Linus Torvalds 已提交
6980 6981

 skip:
6982 6983 6984 6985 6986 6987 6988
	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;
L
Linus Torvalds 已提交
6989
	mddev->curr_resync = 0;
6990 6991
	if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
		mddev->curr_resync_completed = 0;
6992
	sysfs_notify(&mddev->kobj, NULL, "sync_completed");
L
Linus Torvalds 已提交
6993 6994 6995
	wake_up(&resync_wait);
	set_bit(MD_RECOVERY_DONE, &mddev->recovery);
	md_wakeup_thread(mddev->thread);
6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006
	return;

 interrupted:
	/*
	 * got a signal, exit.
	 */
	printk(KERN_INFO
	       "md: md_do_sync() got signal ... exiting\n");
	set_bit(MD_RECOVERY_INTR, &mddev->recovery);
	goto out;

L
Linus Torvalds 已提交
7007
}
7008
EXPORT_SYMBOL_GPL(md_do_sync);
L
Linus Torvalds 已提交
7009 7010


7011 7012 7013 7014 7015
static int remove_and_add_spares(mddev_t *mddev)
{
	mdk_rdev_t *rdev;
	int spares = 0;

7016 7017
	mddev->curr_resync_completed = 0;

7018
	list_for_each_entry(rdev, &mddev->disks, same_set)
7019
		if (rdev->raid_disk >= 0 &&
7020
		    !test_bit(Blocked, &rdev->flags) &&
7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032
		    (test_bit(Faulty, &rdev->flags) ||
		     ! test_bit(In_sync, &rdev->flags)) &&
		    atomic_read(&rdev->nr_pending)==0) {
			if (mddev->pers->hot_remove_disk(
				    mddev, rdev->raid_disk)==0) {
				char nm[20];
				sprintf(nm,"rd%d", rdev->raid_disk);
				sysfs_remove_link(&mddev->kobj, nm);
				rdev->raid_disk = -1;
			}
		}

7033
	if (mddev->degraded && ! mddev->ro && !mddev->recovery_disabled) {
7034
		list_for_each_entry(rdev, &mddev->disks, same_set) {
7035
			if (rdev->raid_disk >= 0 &&
7036 7037
			    !test_bit(In_sync, &rdev->flags) &&
			    !test_bit(Blocked, &rdev->flags))
7038
				spares++;
7039 7040 7041
			if (rdev->raid_disk < 0
			    && !test_bit(Faulty, &rdev->flags)) {
				rdev->recovery_offset = 0;
7042 7043
				if (mddev->pers->
				    hot_add_disk(mddev, rdev) == 0) {
7044 7045
					char nm[20];
					sprintf(nm, "rd%d", rdev->raid_disk);
7046 7047
					if (sysfs_create_link(&mddev->kobj,
							      &rdev->kobj, nm))
N
NeilBrown 已提交
7048
						/* failure here is OK */;
7049 7050
					spares++;
					md_new_event(mddev);
7051
					set_bit(MD_CHANGE_DEVS, &mddev->flags);
7052 7053 7054
				} else
					break;
			}
7055
		}
7056 7057 7058
	}
	return spares;
}
7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097

static void reap_sync_thread(mddev_t *mddev)
{
	mdk_rdev_t *rdev;

	/* resync has finished, collect result */
	md_unregister_thread(mddev->sync_thread);
	mddev->sync_thread = NULL;
	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");
	}
	if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
	    mddev->pers->finish_reshape)
		mddev->pers->finish_reshape(mddev);
	md_update_sb(mddev, 1);

	/* if array is no-longer degraded, then any saved_raid_disk
	 * information must be scrapped
	 */
	if (!mddev->degraded)
		list_for_each_entry(rdev, &mddev->disks, same_set)
			rdev->saved_raid_disk = -1;

	clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
	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);
	/* 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);
}

L
Linus Torvalds 已提交
7098 7099 7100 7101 7102 7103 7104 7105 7106 7107
/*
 * 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.
7108
 * When the thread finishes it sets MD_RECOVERY_DONE
L
Linus Torvalds 已提交
7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121
 * 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.
 */
void md_check_recovery(mddev_t *mddev)
{
7122
	if (mddev->bitmap)
7123
		bitmap_daemon_work(mddev);
L
Linus Torvalds 已提交
7124 7125 7126

	if (mddev->ro)
		return;
7127 7128

	if (signal_pending(current)) {
7129
		if (mddev->pers->sync_request && !mddev->external) {
7130 7131 7132 7133 7134 7135 7136
			printk(KERN_INFO "md: %s in immediate safe mode\n",
			       mdname(mddev));
			mddev->safemode = 2;
		}
		flush_signals(current);
	}

7137 7138
	if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
		return;
L
Linus Torvalds 已提交
7139
	if ( ! (
7140
		(mddev->flags & ~ (1<<MD_CHANGE_PENDING)) ||
L
Linus Torvalds 已提交
7141
		test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
7142
		test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
7143
		(mddev->external == 0 && mddev->safemode == 1) ||
7144 7145
		(mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
		 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
L
Linus Torvalds 已提交
7146 7147
		))
		return;
7148

7149
	if (mddev_trylock(mddev)) {
7150
		int spares = 0;
7151

7152 7153 7154 7155 7156 7157 7158 7159 7160
		if (mddev->ro) {
			/* Only thing we do on a ro array is remove
			 * failed devices.
			 */
			remove_and_add_spares(mddev);
			clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
			goto unlock;
		}

7161
		if (!mddev->external) {
7162
			int did_change = 0;
7163 7164 7165 7166 7167 7168
			spin_lock_irq(&mddev->write_lock);
			if (mddev->safemode &&
			    !atomic_read(&mddev->writes_pending) &&
			    !mddev->in_sync &&
			    mddev->recovery_cp == MaxSector) {
				mddev->in_sync = 1;
7169
				did_change = 1;
7170
				set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7171 7172 7173 7174
			}
			if (mddev->safemode == 1)
				mddev->safemode = 0;
			spin_unlock_irq(&mddev->write_lock);
7175
			if (did_change)
N
NeilBrown 已提交
7176
				sysfs_notify_dirent_safe(mddev->sysfs_state);
7177 7178
		}

7179 7180
		if (mddev->flags)
			md_update_sb(mddev, 0);
7181

L
Linus Torvalds 已提交
7182 7183 7184 7185 7186 7187 7188
		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) {
7189
			reap_sync_thread(mddev);
L
Linus Torvalds 已提交
7190 7191
			goto unlock;
		}
7192 7193 7194 7195 7196
		/* Set RUNNING before clearing NEEDED to avoid
		 * any transients in the value of "sync_action".
		 */
		set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
		clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7197 7198 7199 7200 7201
		/* 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 已提交
7202

7203 7204
		if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
			goto unlock;
L
Linus Torvalds 已提交
7205 7206 7207 7208 7209 7210 7211
		/* no recovery is running.
		 * remove any failed drives, then
		 * add spares if possible.
		 * Spare are also removed and re-added, to allow
		 * the personality to fail the re-add.
		 */

7212
		if (mddev->reshape_position != MaxSector) {
7213 7214
			if (mddev->pers->check_reshape == NULL ||
			    mddev->pers->check_reshape(mddev) != 0)
7215 7216 7217
				/* Cannot proceed */
				goto unlock;
			set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7218
			clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7219
		} else if ((spares = remove_and_add_spares(mddev))) {
7220 7221
			clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
			clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
7222
			clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
7223
			set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7224 7225
		} else if (mddev->recovery_cp < MaxSector) {
			set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7226
			clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7227 7228
		} else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
			/* nothing to be done ... */
L
Linus Torvalds 已提交
7229
			goto unlock;
7230

L
Linus Torvalds 已提交
7231
		if (mddev->pers->sync_request) {
7232 7233 7234 7235 7236 7237 7238
			if (spares && mddev->bitmap && ! mddev->bitmap->file) {
				/* 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);
			}
L
Linus Torvalds 已提交
7239 7240
			mddev->sync_thread = md_register_thread(md_do_sync,
								mddev,
7241
								"resync");
L
Linus Torvalds 已提交
7242 7243 7244 7245 7246
			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 */
7247 7248 7249 7250 7251
				clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
				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);
7252
			} else
L
Linus Torvalds 已提交
7253
				md_wakeup_thread(mddev->sync_thread);
N
NeilBrown 已提交
7254
			sysfs_notify_dirent_safe(mddev->sysfs_action);
7255
			md_new_event(mddev);
L
Linus Torvalds 已提交
7256 7257
		}
	unlock:
7258 7259 7260 7261
		if (!mddev->sync_thread) {
			clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
			if (test_and_clear_bit(MD_RECOVERY_RECOVER,
					       &mddev->recovery))
7262
				if (mddev->sysfs_action)
N
NeilBrown 已提交
7263
					sysfs_notify_dirent_safe(mddev->sysfs_action);
7264
		}
L
Linus Torvalds 已提交
7265 7266 7267 7268
		mddev_unlock(mddev);
	}
}

7269 7270
void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
{
N
NeilBrown 已提交
7271
	sysfs_notify_dirent_safe(rdev->sysfs_state);
7272 7273 7274 7275 7276 7277 7278
	wait_event_timeout(rdev->blocked_wait,
			   !test_bit(Blocked, &rdev->flags),
			   msecs_to_jiffies(5000));
	rdev_dec_pending(rdev, mddev);
}
EXPORT_SYMBOL(md_wait_for_blocked_rdev);

A
Adrian Bunk 已提交
7279 7280
static int md_notify_reboot(struct notifier_block *this,
			    unsigned long code, void *x)
L
Linus Torvalds 已提交
7281 7282 7283 7284 7285 7286 7287 7288
{
	struct list_head *tmp;
	mddev_t *mddev;

	if ((code == SYS_DOWN) || (code == SYS_HALT) || (code == SYS_POWER_OFF)) {

		printk(KERN_INFO "md: stopping all md devices.\n");

7289
		for_each_mddev(mddev, tmp)
7290
			if (mddev_trylock(mddev)) {
7291 7292 7293 7294
				/* Force a switch to readonly even array
				 * appears to still be in use.  Hence
				 * the '100'.
				 */
7295
				md_set_readonly(mddev, 100);
7296 7297
				mddev_unlock(mddev);
			}
L
Linus Torvalds 已提交
7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308
		/*
		 * 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 ...
		 */
		mdelay(1000*1);
	}
	return NOTIFY_DONE;
}

A
Adrian Bunk 已提交
7309
static struct notifier_block md_notifier = {
L
Linus Torvalds 已提交
7310 7311 7312 7313 7314 7315 7316 7317 7318
	.notifier_call	= md_notify_reboot,
	.next		= NULL,
	.priority	= INT_MAX, /* before any real devices */
};

static void md_geninit(void)
{
	dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));

7319
	proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
L
Linus Torvalds 已提交
7320 7321
}

A
Adrian Bunk 已提交
7322
static int __init md_init(void)
L
Linus Torvalds 已提交
7323
{
T
Tejun Heo 已提交
7324 7325 7326 7327 7328 7329 7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340
	int ret = -ENOMEM;

	md_wq = alloc_workqueue("md", WQ_RESCUER, 0);
	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;

C
Christoph Hellwig 已提交
7341
	blk_register_region(MKDEV(MD_MAJOR, 0), 1UL<<MINORBITS, THIS_MODULE,
7342 7343
			    md_probe, NULL, NULL);
	blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
L
Linus Torvalds 已提交
7344 7345 7346
			    md_probe, NULL, NULL);

	register_reboot_notifier(&md_notifier);
7347
	raid_table_header = register_sysctl_table(raid_root_table);
L
Linus Torvalds 已提交
7348 7349

	md_geninit();
7350
	return 0;
L
Linus Torvalds 已提交
7351

T
Tejun Heo 已提交
7352 7353 7354 7355 7356 7357 7358 7359 7360
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 已提交
7361 7362 7363 7364 7365 7366 7367

#ifndef MODULE

/*
 * Searches all registered partitions for autorun RAID arrays
 * at boot time.
 */
7368 7369 7370 7371 7372 7373

static LIST_HEAD(all_detected_devices);
struct detected_devices_node {
	struct list_head list;
	dev_t dev;
};
L
Linus Torvalds 已提交
7374 7375 7376

void md_autodetect_dev(dev_t dev)
{
7377 7378 7379 7380 7381 7382 7383 7384 7385 7386
	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 已提交
7387 7388 7389 7390 7391 7392
}


static void autostart_arrays(int part)
{
	mdk_rdev_t *rdev;
7393 7394 7395
	struct detected_devices_node *node_detected_dev;
	dev_t dev;
	int i_scanned, i_passed;
L
Linus Torvalds 已提交
7396

7397 7398
	i_scanned = 0;
	i_passed = 0;
L
Linus Torvalds 已提交
7399

7400
	printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
L
Linus Torvalds 已提交
7401

7402 7403 7404 7405 7406 7407 7408
	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);
7409
		rdev = md_import_device(dev,0, 90);
L
Linus Torvalds 已提交
7410 7411 7412
		if (IS_ERR(rdev))
			continue;

7413
		if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
7414 7415 7416
			MD_BUG();
			continue;
		}
7417
		set_bit(AutoDetected, &rdev->flags);
L
Linus Torvalds 已提交
7418
		list_add(&rdev->same_set, &pending_raid_disks);
7419
		i_passed++;
L
Linus Torvalds 已提交
7420
	}
7421 7422 7423

	printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
						i_scanned, i_passed);
L
Linus Torvalds 已提交
7424 7425 7426 7427

	autorun_devices(part);
}

J
Jeff Garzik 已提交
7428
#endif /* !MODULE */
L
Linus Torvalds 已提交
7429 7430 7431 7432 7433

static __exit void md_exit(void)
{
	mddev_t *mddev;
	struct list_head *tmp;
7434

C
Christoph Hellwig 已提交
7435
	blk_unregister_region(MKDEV(MD_MAJOR,0), 1U << MINORBITS);
7436
	blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
L
Linus Torvalds 已提交
7437

C
Christoph Hellwig 已提交
7438
	unregister_blkdev(MD_MAJOR,"md");
L
Linus Torvalds 已提交
7439 7440 7441 7442
	unregister_blkdev(mdp_major, "mdp");
	unregister_reboot_notifier(&md_notifier);
	unregister_sysctl_table(raid_table_header);
	remove_proc_entry("mdstat", NULL);
7443
	for_each_mddev(mddev, tmp) {
L
Linus Torvalds 已提交
7444
		export_array(mddev);
7445
		mddev->hold_active = 0;
L
Linus Torvalds 已提交
7446
	}
T
Tejun Heo 已提交
7447 7448
	destroy_workqueue(md_misc_wq);
	destroy_workqueue(md_wq);
L
Linus Torvalds 已提交
7449 7450
}

7451
subsys_initcall(md_init);
L
Linus Torvalds 已提交
7452 7453
module_exit(md_exit)

7454 7455 7456 7457 7458 7459 7460 7461 7462 7463
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)
{
	char *e;
	int num = simple_strtoul(val, &e, 10);
	if (*val && (*e == '\0' || *e == '\n')) {
		start_readonly = num;
7464
		return 0;
7465 7466 7467 7468
	}
	return -EINVAL;
}

7469 7470
module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
7471

7472
module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
7473

L
Linus Torvalds 已提交
7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484
EXPORT_SYMBOL(register_md_personality);
EXPORT_SYMBOL(unregister_md_personality);
EXPORT_SYMBOL(md_error);
EXPORT_SYMBOL(md_done_sync);
EXPORT_SYMBOL(md_write_start);
EXPORT_SYMBOL(md_write_end);
EXPORT_SYMBOL(md_register_thread);
EXPORT_SYMBOL(md_unregister_thread);
EXPORT_SYMBOL(md_wakeup_thread);
EXPORT_SYMBOL(md_check_recovery);
MODULE_LICENSE("GPL");
7485
MODULE_DESCRIPTION("MD RAID framework");
7486
MODULE_ALIAS("md");
7487
MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);