md.c 190.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/smp_lock.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 61

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


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

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

68 69
static void md_print_devices(void);

70 71
static DECLARE_WAIT_QUEUE_HEAD(resync_wait);

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

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

static int sysctl_speed_limit_min = 1000;
static int sysctl_speed_limit_max = 200000;
95 96 97 98 99 100 101 102 103 104 105
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 已提交
106 107 108 109 110 111 112 113

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),
114
		.mode		= S_IRUGO|S_IWUSR,
115
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
116 117 118 119 120
	},
	{
		.procname	= "speed_limit_max",
		.data		= &sysctl_speed_limit_max,
		.maxlen		= sizeof(int),
121
		.mode		= S_IRUGO|S_IWUSR,
122
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
123
	},
124
	{ }
L
Linus Torvalds 已提交
125 126 127 128 129 130
};

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

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

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

149 150
static int start_readonly;

151 152 153 154 155 156 157 158 159 160
/*
 * 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
 */
161
static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
162
static atomic_t md_event_count;
163
void md_new_event(mddev_t *mddev)
164 165 166 167
{
	atomic_inc(&md_event_count);
	wake_up(&md_event_waiters);
}
168
EXPORT_SYMBOL_GPL(md_new_event);
169

170 171 172
/* Alternate version that can be called from interrupts
 * when calling sysfs_notify isn't needed.
 */
173
static void md_new_event_inintr(mddev_t *mddev)
174 175 176 177 178
{
	atomic_inc(&md_event_count);
	wake_up(&md_event_waiters);
}

L
Linus Torvalds 已提交
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
/*
 * 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.
 */
194
#define for_each_mddev(mddev,tmp)					\
L
Linus Torvalds 已提交
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
									\
	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;})					\
		)


210 211 212 213 214 215 216 217
/* 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 已提交
218
{
219
	const int rw = bio_data_dir(bio);
220 221
	mddev_t *mddev = q->queuedata;
	int rv;
222 223
	int cpu;

224 225 226 227 228
	if (mddev == NULL || mddev->pers == NULL) {
		bio_io_error(bio);
		return 0;
	}
	rcu_read_lock();
229
	if (mddev->suspended || mddev->barrier) {
230 231 232 233
		DEFINE_WAIT(__wait);
		for (;;) {
			prepare_to_wait(&mddev->sb_wait, &__wait,
					TASK_UNINTERRUPTIBLE);
234
			if (!mddev->suspended && !mddev->barrier)
235 236 237 238 239 240 241 242 243
				break;
			rcu_read_unlock();
			schedule();
			rcu_read_lock();
		}
		finish_wait(&mddev->sb_wait, &__wait);
	}
	atomic_inc(&mddev->active_io);
	rcu_read_unlock();
244

245
	rv = mddev->pers->make_request(mddev, bio);
246 247 248 249 250 251 252

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

253 254 255 256 257 258
	if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
		wake_up(&mddev->sb_wait);

	return rv;
}

259 260 261 262 263 264
/* 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.
 */
265
void mddev_suspend(mddev_t *mddev)
266 267 268 269 270 271 272
{
	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);
}
273
EXPORT_SYMBOL_GPL(mddev_suspend);
274

275
void mddev_resume(mddev_t *mddev)
276 277 278 279
{
	mddev->suspended = 0;
	wake_up(&mddev->sb_wait);
	mddev->pers->quiesce(mddev, 0);
L
Linus Torvalds 已提交
280
}
281
EXPORT_SYMBOL_GPL(mddev_resume);
L
Linus Torvalds 已提交
282

283 284
int mddev_congested(mddev_t *mddev, int bits)
{
285 286
	if (mddev->barrier)
		return 1;
287 288 289 290
	return mddev->suspended;
}
EXPORT_SYMBOL(mddev_congested);

291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
/*
 * Generic barrier handling for md
 */

#define POST_REQUEST_BARRIER ((void*)1)

static void md_end_barrier(struct bio *bio, int err)
{
	mdk_rdev_t *rdev = bio->bi_private;
	mddev_t *mddev = rdev->mddev;
	if (err == -EOPNOTSUPP && mddev->barrier != POST_REQUEST_BARRIER)
		set_bit(BIO_EOPNOTSUPP, &mddev->barrier->bi_flags);

	rdev_dec_pending(rdev, mddev);

	if (atomic_dec_and_test(&mddev->flush_pending)) {
		if (mddev->barrier == POST_REQUEST_BARRIER) {
			/* This was a post-request barrier */
			mddev->barrier = NULL;
			wake_up(&mddev->sb_wait);
		} else
			/* The pre-request barrier has finished */
			schedule_work(&mddev->barrier_work);
	}
	bio_put(bio);
}

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

	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();
			bi = bio_alloc(GFP_KERNEL, 0);
			bi->bi_end_io = md_end_barrier;
			bi->bi_private = rdev;
			bi->bi_bdev = rdev->bdev;
			atomic_inc(&mddev->flush_pending);
			submit_bio(WRITE_BARRIER, bi);
			rcu_read_lock();
			rdev_dec_pending(rdev, mddev);
		}
	rcu_read_unlock();
}

static void md_submit_barrier(struct work_struct *ws)
{
	mddev_t *mddev = container_of(ws, mddev_t, barrier_work);
	struct bio *bio = mddev->barrier;

	atomic_set(&mddev->flush_pending, 1);

	if (test_bit(BIO_EOPNOTSUPP, &bio->bi_flags))
		bio_endio(bio, -EOPNOTSUPP);
	else if (bio->bi_size == 0)
		/* an empty barrier - all done */
		bio_endio(bio, 0);
	else {
359
		bio->bi_rw &= ~REQ_HARDBARRIER;
360
		if (mddev->pers->make_request(mddev, bio))
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
			generic_make_request(bio);
		mddev->barrier = POST_REQUEST_BARRIER;
		submit_barriers(mddev);
	}
	if (atomic_dec_and_test(&mddev->flush_pending)) {
		mddev->barrier = NULL;
		wake_up(&mddev->sb_wait);
	}
}

void md_barrier_request(mddev_t *mddev, struct bio *bio)
{
	spin_lock_irq(&mddev->write_lock);
	wait_event_lock_irq(mddev->sb_wait,
			    !mddev->barrier,
			    mddev->write_lock, /*nothing*/);
	mddev->barrier = bio;
	spin_unlock_irq(&mddev->write_lock);

	atomic_set(&mddev->flush_pending, 1);
	INIT_WORK(&mddev->barrier_work, md_submit_barrier);

	submit_barriers(mddev);

	if (atomic_dec_and_test(&mddev->flush_pending))
		schedule_work(&mddev->barrier_work);
}
EXPORT_SYMBOL(md_barrier_request);
389

390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
/* 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 已提交
435 436 437 438 439 440
static inline mddev_t *mddev_get(mddev_t *mddev)
{
	atomic_inc(&mddev->active);
	return mddev;
}

441
static void mddev_delayed_delete(struct work_struct *ws);
442

L
Linus Torvalds 已提交
443 444 445 446
static void mddev_put(mddev_t *mddev)
{
	if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
		return;
447
	if (!mddev->raid_disks && list_empty(&mddev->disks) &&
448 449 450
	    mddev->ctime == 0 && !mddev->hold_active) {
		/* Array is not configured at all, and not held active,
		 * so destroy it */
L
Linus Torvalds 已提交
451
		list_del(&mddev->all_mddevs);
452 453 454 455 456 457 458 459 460 461 462 463 464
		if (mddev->gendisk) {
			/* we did a probe so need to clean up.
			 * Call schedule_work inside the spinlock
			 * so that flush_scheduled_work() after
			 * mddev_find will succeed in waiting for the
			 * work to be done.
			 */
			INIT_WORK(&mddev->del_work, mddev_delayed_delete);
			schedule_work(&mddev->del_work);
		} else
			kfree(mddev);
	}
	spin_unlock(&all_mddevs_lock);
L
Linus Torvalds 已提交
465 466
}

467
void mddev_init(mddev_t *mddev)
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
{
	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;
}
487
EXPORT_SYMBOL_GPL(mddev_init);
488

L
Linus Torvalds 已提交
489 490 491 492 493 494
static mddev_t * mddev_find(dev_t unit)
{
	mddev_t *mddev, *new = NULL;

 retry:
	spin_lock(&all_mddevs_lock);
495 496 497 498 499 500 501 502 503 504 505 506

	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 已提交
507
			spin_unlock(&all_mddevs_lock);
508 509
			new->hold_active = UNTIL_IOCTL;
			return new;
L
Linus Torvalds 已提交
510
		}
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
	} 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 已提交
539 540 541 542 543 544
		list_add(&new->all_mddevs, &all_mddevs);
		spin_unlock(&all_mddevs_lock);
		return new;
	}
	spin_unlock(&all_mddevs_lock);

545
	new = kzalloc(sizeof(*new), GFP_KERNEL);
L
Linus Torvalds 已提交
546 547 548 549 550 551 552 553 554
	if (!new)
		return NULL;

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

555
	mddev_init(new);
L
Linus Torvalds 已提交
556 557 558 559 560 561

	goto retry;
}

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

D
Dan Williams 已提交
565 566 567 568 569
static inline int mddev_is_locked(mddev_t *mddev)
{
	return mutex_is_locked(&mddev->reconfig_mutex);
}

L
Linus Torvalds 已提交
570 571
static inline int mddev_trylock(mddev_t * mddev)
{
572
	return mutex_trylock(&mddev->reconfig_mutex);
L
Linus Torvalds 已提交
573 574
}

575 576
static struct attribute_group md_redundancy_group;

577
static void mddev_unlock(mddev_t * mddev)
L
Linus Torvalds 已提交
578
{
579
	if (mddev->to_remove) {
580 581 582 583
		/* 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.
584 585 586 587 588 589 590
		 * 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.
591
		 */
592 593
		struct attribute_group *to_remove = mddev->to_remove;
		mddev->to_remove = NULL;
594
		mddev->sysfs_active = 1;
595 596
		mutex_unlock(&mddev->reconfig_mutex);

N
NeilBrown 已提交
597 598 599 600 601 602 603 604 605 606
		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;
			}
607
		}
608
		mddev->sysfs_active = 0;
609 610
	} else
		mutex_unlock(&mddev->reconfig_mutex);
L
Linus Torvalds 已提交
611

612
	md_wakeup_thread(mddev->thread);
L
Linus Torvalds 已提交
613 614
}

615
static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
L
Linus Torvalds 已提交
616
{
617
	mdk_rdev_t *rdev;
L
Linus Torvalds 已提交
618

619
	list_for_each_entry(rdev, &mddev->disks, same_set)
L
Linus Torvalds 已提交
620 621
		if (rdev->desc_nr == nr)
			return rdev;
622

L
Linus Torvalds 已提交
623 624 625 626 627 628 629
	return NULL;
}

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

630
	list_for_each_entry(rdev, &mddev->disks, same_set)
L
Linus Torvalds 已提交
631 632
		if (rdev->bdev->bd_dev == dev)
			return rdev;
633

L
Linus Torvalds 已提交
634 635 636
	return NULL;
}

637
static struct mdk_personality *find_pers(int level, char *clevel)
638 639
{
	struct mdk_personality *pers;
640 641
	list_for_each_entry(pers, &pers_list, list) {
		if (level != LEVEL_NONE && pers->level == level)
642
			return pers;
643 644 645
		if (strcmp(pers->name, clevel)==0)
			return pers;
	}
646 647 648
	return NULL;
}

649
/* return the offset of the super block in 512byte sectors */
650
static inline sector_t calc_dev_sboffset(struct block_device *bdev)
L
Linus Torvalds 已提交
651
{
652 653
	sector_t num_sectors = bdev->bd_inode->i_size / 512;
	return MD_NEW_SIZE_SECTORS(num_sectors);
L
Linus Torvalds 已提交
654 655 656 657 658 659 660 661 662 663
}

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");
664
		return -ENOMEM;
L
Linus Torvalds 已提交
665 666 667 668 669 670 671 672
	}

	return 0;
}

static void free_disk_sb(mdk_rdev_t * rdev)
{
	if (rdev->sb_page) {
673
		put_page(rdev->sb_page);
L
Linus Torvalds 已提交
674 675
		rdev->sb_loaded = 0;
		rdev->sb_page = NULL;
676
		rdev->sb_start = 0;
677
		rdev->sectors = 0;
L
Linus Torvalds 已提交
678 679 680 681
	}
}


682
static void super_written(struct bio *bio, int error)
683 684
{
	mdk_rdev_t *rdev = bio->bi_private;
685
	mddev_t *mddev = rdev->mddev;
686

687 688 689 690
	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));
691
		md_error(mddev, rdev);
692
	}
693

694 695
	if (atomic_dec_and_test(&mddev->pending_writes))
		wake_up(&mddev->sb_wait);
N
Neil Brown 已提交
696
	bio_put(bio);
697 698
}

699
static void super_written_barrier(struct bio *bio, int error)
700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
{
	struct bio *bio2 = bio->bi_private;
	mdk_rdev_t *rdev = bio2->bi_private;
	mddev_t *mddev = rdev->mddev;

	if (!test_bit(BIO_UPTODATE, &bio->bi_flags) &&
	    error == -EOPNOTSUPP) {
		unsigned long flags;
		/* barriers don't appear to be supported :-( */
		set_bit(BarriersNotsupp, &rdev->flags);
		mddev->barriers_work = 0;
		spin_lock_irqsave(&mddev->write_lock, flags);
		bio2->bi_next = mddev->biolist;
		mddev->biolist = bio2;
		spin_unlock_irqrestore(&mddev->write_lock, flags);
		wake_up(&mddev->sb_wait);
		bio_put(bio);
717 718 719 720
	} else {
		bio_put(bio2);
		bio->bi_private = rdev;
		super_written(bio, error);
721 722 723
	}
}

724 725 726 727 728 729 730 731
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
732
	 *
733
	 * As we might need to resubmit the request if REQ_HARDBARRIER
734
	 * causes ENOTSUPP, we allocate a spare bio...
735 736
	 */
	struct bio *bio = bio_alloc(GFP_NOIO, 1);
737
	int rw = REQ_WRITE | REQ_SYNC | REQ_UNPLUG;
738 739 740 741 742 743

	bio->bi_bdev = rdev->bdev;
	bio->bi_sector = sector;
	bio_add_page(bio, page, size, 0);
	bio->bi_private = rdev;
	bio->bi_end_io = super_written;
744 745
	bio->bi_rw = rw;

746
	atomic_inc(&mddev->pending_writes);
747 748
	if (!test_bit(BarriersNotsupp, &rdev->flags)) {
		struct bio *rbio;
749
		rw |= REQ_HARDBARRIER;
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
		rbio = bio_clone(bio, GFP_NOIO);
		rbio->bi_private = bio;
		rbio->bi_end_io = super_written_barrier;
		submit_bio(rw, rbio);
	} else
		submit_bio(rw, bio);
}

void md_super_wait(mddev_t *mddev)
{
	/* wait for all superblock writes that were scheduled to complete.
	 * if any had to be retried (due to BARRIER problems), retry them
	 */
	DEFINE_WAIT(wq);
	for(;;) {
		prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
		if (atomic_read(&mddev->pending_writes)==0)
			break;
		while (mddev->biolist) {
			struct bio *bio;
			spin_lock_irq(&mddev->write_lock);
			bio = mddev->biolist;
			mddev->biolist = bio->bi_next ;
			bio->bi_next = NULL;
			spin_unlock_irq(&mddev->write_lock);
			submit_bio(bio->bi_rw, bio);
		}
		schedule();
	}
	finish_wait(&mddev->sb_wait, &wq);
780 781
}

782
static void bi_complete(struct bio *bio, int error)
L
Linus Torvalds 已提交
783 784 785 786
{
	complete((struct completion*)bio->bi_private);
}

787
int sync_page_io(struct block_device *bdev, sector_t sector, int size,
L
Linus Torvalds 已提交
788 789
		   struct page *page, int rw)
{
790
	struct bio *bio = bio_alloc(GFP_NOIO, 1);
L
Linus Torvalds 已提交
791 792 793
	struct completion event;
	int ret;

794
	rw |= REQ_SYNC | REQ_UNPLUG;
L
Linus Torvalds 已提交
795 796 797 798 799 800 801 802 803 804 805 806 807 808

	bio->bi_bdev = bdev;
	bio->bi_sector = sector;
	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;
}
809
EXPORT_SYMBOL_GPL(sync_page_io);
L
Linus Torvalds 已提交
810

811
static int read_disk_sb(mdk_rdev_t * rdev, int size)
L
Linus Torvalds 已提交
812 813 814 815 816 817 818 819 820 821
{
	char b[BDEVNAME_SIZE];
	if (!rdev->sb_page) {
		MD_BUG();
		return -EINVAL;
	}
	if (rdev->sb_loaded)
		return 0;


822
	if (!sync_page_io(rdev->bdev, rdev->sb_start, size, rdev->sb_page, READ))
L
Linus Torvalds 已提交
823 824 825 826 827 828 829 830 831 832 833 834
		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 已提交
835 836 837 838
	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 已提交
839 840 841 842 843 844 845 846 847 848 849 850
}

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;
851
		printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
L
Linus Torvalds 已提交
852 853 854 855 856 857 858 859 860 861 862 863
		goto abort;
	}

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

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

A
Andre Noll 已提交
864
	ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
L
Linus Torvalds 已提交
865
abort:
866 867
	kfree(tmp1);
	kfree(tmp2);
L
Linus Torvalds 已提交
868 869 870
	return ret;
}

871 872 873 874 875 876 877

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

L
Linus Torvalds 已提交
878 879
static unsigned int calc_sb_csum(mdp_super_t * sb)
{
880 881 882
	u64 newcsum = 0;
	u32 *sb32 = (u32*)sb;
	int i;
L
Linus Torvalds 已提交
883 884 885 886
	unsigned int disk_csum, csum;

	disk_csum = sb->sb_csum;
	sb->sb_csum = 0;
887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903

	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 已提交
904
	sb->sb_csum = disk_csum;
905
#endif
L
Linus Torvalds 已提交
906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
	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  {
941 942 943 944 945 946 947
	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,
948
						sector_t num_sectors);
L
Linus Torvalds 已提交
949 950
};

951 952 953 954 955 956 957 958 959 960
/*
 * 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)
{
961
	if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
962 963 964 965 966 967 968
		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 已提交
969 970 971 972 973 974 975 976 977 978
/*
 * 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;

	/*
979
	 * Calculate the position of the superblock (512byte sectors),
L
Linus Torvalds 已提交
980 981 982 983
	 * it's at the end of the disk.
	 *
	 * It also happens to be a multiple of 4Kb.
	 */
984
	rdev->sb_start = calc_dev_sboffset(rdev->bdev);
L
Linus Torvalds 已提交
985

986
	ret = read_disk_sb(rdev, MD_SB_BYTES);
L
Linus Torvalds 已提交
987 988 989 990 991 992 993 994 995 996 997 998 999 1000
	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 ||
1001 1002
	    sb->minor_version < 90 ||
	    sb->minor_version > 91) {
L
Linus Torvalds 已提交
1003 1004 1005 1006 1007 1008 1009 1010 1011
		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;

1012
	if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
L
Linus Torvalds 已提交
1013 1014 1015 1016 1017 1018 1019
		printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
			b);
		goto abort;
	}

	rdev->preferred_minor = sb->md_minor;
	rdev->data_offset = 0;
1020
	rdev->sb_size = MD_SB_BYTES;
L
Linus Torvalds 已提交
1021 1022 1023 1024 1025 1026

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

1027
	if (!refdev) {
L
Linus Torvalds 已提交
1028
		ret = 1;
1029
	} else {
L
Linus Torvalds 已提交
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
		__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;
	}
1050
	rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
1051

1052
	if (rdev->sectors < sb->size * 2 && sb->level > 1)
1053 1054 1055
		/* "this cannot possibly happen" ... */
		ret = -EINVAL;

L
Linus Torvalds 已提交
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
 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);
1067
	__u64 ev1 = md_event(sb);
L
Linus Torvalds 已提交
1068

1069
	rdev->raid_disk = -1;
1070 1071 1072 1073 1074
	clear_bit(Faulty, &rdev->flags);
	clear_bit(In_sync, &rdev->flags);
	clear_bit(WriteMostly, &rdev->flags);
	clear_bit(BarriersNotsupp, &rdev->flags);

L
Linus Torvalds 已提交
1075 1076 1077 1078
	if (mddev->raid_disks == 0) {
		mddev->major_version = 0;
		mddev->minor_version = sb->minor_version;
		mddev->patch_version = sb->patch_version;
1079
		mddev->external = 0;
1080
		mddev->chunk_sectors = sb->chunk_size >> 9;
L
Linus Torvalds 已提交
1081 1082 1083
		mddev->ctime = sb->ctime;
		mddev->utime = sb->utime;
		mddev->level = sb->level;
1084
		mddev->clevel[0] = 0;
L
Linus Torvalds 已提交
1085 1086
		mddev->layout = sb->layout;
		mddev->raid_disks = sb->raid_disks;
A
Andre Noll 已提交
1087
		mddev->dev_sectors = sb->size * 2;
1088
		mddev->events = ev1;
1089 1090
		mddev->bitmap_info.offset = 0;
		mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
L
Linus Torvalds 已提交
1091

1092 1093 1094 1095 1096
		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;
1097
			mddev->new_chunk_sectors = sb->new_chunk >> 9;
1098 1099 1100 1101 1102
		} else {
			mddev->reshape_position = MaxSector;
			mddev->delta_disks = 0;
			mddev->new_level = mddev->level;
			mddev->new_layout = mddev->layout;
1103
			mddev->new_chunk_sectors = mddev->chunk_sectors;
1104 1105
		}

L
Linus Torvalds 已提交
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
		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;
1122 1123

		if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
1124 1125 1126
		    mddev->bitmap_info.file == NULL)
			mddev->bitmap_info.offset =
				mddev->bitmap_info.default_offset;
1127

1128
	} else if (mddev->pers == NULL) {
1129 1130
		/* Insist on good event counter while assembling, except
		 * for spares (which don't need an event count) */
L
Linus Torvalds 已提交
1131
		++ev1;
1132 1133 1134 1135
		if (sb->disks[rdev->desc_nr].state & (
			    (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
			if (ev1 < mddev->events) 
				return -EINVAL;
1136 1137 1138 1139 1140 1141
	} 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;
1142 1143 1144 1145 1146
	} else {
		if (ev1 < mddev->events)
			/* just a hot-add of a new device, leave raid_disk at -1 */
			return 0;
	}
1147

L
Linus Torvalds 已提交
1148 1149 1150 1151
	if (mddev->level != LEVEL_MULTIPATH) {
		desc = sb->disks + rdev->desc_nr;

		if (desc->state & (1<<MD_DISK_FAULTY))
1152
			set_bit(Faulty, &rdev->flags);
1153 1154
		else if (desc->state & (1<<MD_DISK_SYNC) /* &&
			    desc->raid_disk < mddev->raid_disks */) {
1155
			set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
1156
			rdev->raid_disk = desc->raid_disk;
1157 1158 1159 1160 1161 1162 1163 1164
		} 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 已提交
1165
		}
1166 1167
		if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);
1168
	} else /* MULTIPATH are always insync */
1169
		set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
	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;
1181

L
Linus Torvalds 已提交
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195

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

1196 1197
	rdev->sb_size = MD_SB_BYTES;

L
Linus Torvalds 已提交
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
	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 已提交
1213
	sb->size = mddev->dev_sectors / 2;
L
Linus Torvalds 已提交
1214 1215
	sb->raid_disks = mddev->raid_disks;
	sb->md_minor = mddev->md_minor;
1216
	sb->not_persistent = 0;
L
Linus Torvalds 已提交
1217 1218 1219 1220 1221
	sb->utime = mddev->utime;
	sb->state = 0;
	sb->events_hi = (mddev->events>>32);
	sb->events_lo = (u32)mddev->events;

1222 1223 1224 1225 1226 1227 1228 1229
	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;
1230
		sb->new_chunk = mddev->new_chunk_sectors << 9;
1231 1232
	}
	mddev->minor_version = sb->minor_version;
L
Linus Torvalds 已提交
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
	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;
1244
	sb->chunk_size = mddev->chunk_sectors << 9;
L
Linus Torvalds 已提交
1245

1246
	if (mddev->bitmap && mddev->bitmap_info.file == NULL)
1247 1248
		sb->state |= (1<<MD_SB_BITMAP_PRESENT);

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

1316 1317 1318 1319
/*
 * rdev_size_change for 0.90.0
 */
static unsigned long long
1320
super_90_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
1321
{
A
Andre Noll 已提交
1322
	if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1323
		return 0; /* component must fit device */
1324
	if (rdev->mddev->bitmap_info.offset)
1325
		return 0; /* can't move bitmap */
1326
	rdev->sb_start = calc_dev_sboffset(rdev->bdev);
1327 1328
	if (!num_sectors || num_sectors > rdev->sb_start)
		num_sectors = rdev->sb_start;
1329
	md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1330 1331
		       rdev->sb_page);
	md_super_wait(rdev->mddev);
1332
	return num_sectors / 2; /* kB for sysfs */
1333 1334 1335
}


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

1340
static __le32 calc_sb_1_csum(struct mdp_superblock_1 * sb)
L
Linus Torvalds 已提交
1341
{
1342 1343
	__le32 disk_csum;
	u32 csum;
L
Linus Torvalds 已提交
1344 1345
	unsigned long long newcsum;
	int size = 256 + le32_to_cpu(sb->max_dev)*2;
1346
	__le32 *isuper = (__le32*)sb;
L
Linus Torvalds 已提交
1347 1348 1349 1350 1351 1352 1353 1354 1355
	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)
1356
		newcsum += le16_to_cpu(*(__le16*) isuper);
L
Linus Torvalds 已提交
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366

	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;
1367
	sector_t sb_start;
L
Linus Torvalds 已提交
1368
	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1369
	int bmask;
L
Linus Torvalds 已提交
1370 1371

	/*
1372
	 * Calculate the position of the superblock in 512byte sectors.
L
Linus Torvalds 已提交
1373 1374 1375 1376 1377 1378 1379 1380
	 * 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:
1381 1382 1383
		sb_start = rdev->bdev->bd_inode->i_size >> 9;
		sb_start -= 8*2;
		sb_start &= ~(sector_t)(4*2-1);
L
Linus Torvalds 已提交
1384 1385
		break;
	case 1:
1386
		sb_start = 0;
L
Linus Torvalds 已提交
1387 1388
		break;
	case 2:
1389
		sb_start = 8;
L
Linus Torvalds 已提交
1390 1391 1392 1393
		break;
	default:
		return -EINVAL;
	}
1394
	rdev->sb_start = sb_start;
L
Linus Torvalds 已提交
1395

1396 1397 1398 1399
	/* 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 已提交
1400 1401 1402 1403 1404 1405 1406 1407
	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 ||
1408
	    le64_to_cpu(sb->super_offset) != rdev->sb_start ||
1409
	    (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
L
Linus Torvalds 已提交
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
		return -EINVAL;

	if (calc_sb_1_csum(sb) != sb->sb_csum) {
		printk("md: invalid superblock checksum on %s\n",
			bdevname(rdev->bdev,b));
		return -EINVAL;
	}
	if (le64_to_cpu(sb->data_size) < 10) {
		printk("md: data_size too small on %s\n",
		       bdevname(rdev->bdev,b));
		return -EINVAL;
	}
1422

L
Linus Torvalds 已提交
1423 1424
	rdev->preferred_minor = 0xffff;
	rdev->data_offset = le64_to_cpu(sb->data_offset);
1425
	atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
L
Linus Torvalds 已提交
1426

1427
	rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
1428
	bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1429
	if (rdev->sb_size & bmask)
1430 1431 1432
		rdev->sb_size = (rdev->sb_size | bmask) + 1;

	if (minor_version
1433
	    && rdev->data_offset < sb_start + (rdev->sb_size/512))
1434
		return -EINVAL;
1435

1436 1437 1438 1439 1440
	if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
		rdev->desc_nr = -1;
	else
		rdev->desc_nr = le32_to_cpu(sb->dev_number);

1441
	if (!refdev) {
1442
		ret = 1;
1443
	} else {
L
Linus Torvalds 已提交
1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461
		__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)
1462 1463 1464
			ret = 1;
		else
			ret = 0;
L
Linus Torvalds 已提交
1465
	}
1466
	if (minor_version)
1467 1468
		rdev->sectors = (rdev->bdev->bd_inode->i_size >> 9) -
			le64_to_cpu(sb->data_offset);
L
Linus Torvalds 已提交
1469
	else
1470 1471
		rdev->sectors = rdev->sb_start;
	if (rdev->sectors < le64_to_cpu(sb->data_size))
L
Linus Torvalds 已提交
1472
		return -EINVAL;
1473 1474
	rdev->sectors = le64_to_cpu(sb->data_size);
	if (le64_to_cpu(sb->size) > rdev->sectors)
1475
		return -EINVAL;
1476
	return ret;
L
Linus Torvalds 已提交
1477 1478 1479 1480 1481
}

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);
1482
	__u64 ev1 = le64_to_cpu(sb->events);
L
Linus Torvalds 已提交
1483

1484
	rdev->raid_disk = -1;
1485 1486 1487 1488 1489
	clear_bit(Faulty, &rdev->flags);
	clear_bit(In_sync, &rdev->flags);
	clear_bit(WriteMostly, &rdev->flags);
	clear_bit(BarriersNotsupp, &rdev->flags);

L
Linus Torvalds 已提交
1490 1491 1492
	if (mddev->raid_disks == 0) {
		mddev->major_version = 1;
		mddev->patch_version = 0;
1493
		mddev->external = 0;
1494
		mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
L
Linus Torvalds 已提交
1495 1496 1497
		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);
1498
		mddev->clevel[0] = 0;
L
Linus Torvalds 已提交
1499 1500
		mddev->layout = le32_to_cpu(sb->layout);
		mddev->raid_disks = le32_to_cpu(sb->raid_disks);
A
Andre Noll 已提交
1501
		mddev->dev_sectors = le64_to_cpu(sb->size);
1502
		mddev->events = ev1;
1503 1504
		mddev->bitmap_info.offset = 0;
		mddev->bitmap_info.default_offset = 1024 >> 9;
L
Linus Torvalds 已提交
1505 1506 1507 1508 1509
		
		mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
		memcpy(mddev->uuid, sb->set_uuid, 16);

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

1511
		if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1512 1513 1514
		    mddev->bitmap_info.file == NULL )
			mddev->bitmap_info.offset =
				(__s32)le32_to_cpu(sb->bitmap_offset);
1515

1516 1517 1518 1519 1520
		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);
1521
			mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
1522 1523 1524 1525 1526
		} else {
			mddev->reshape_position = MaxSector;
			mddev->delta_disks = 0;
			mddev->new_level = mddev->level;
			mddev->new_layout = mddev->layout;
1527
			mddev->new_chunk_sectors = mddev->chunk_sectors;
1528 1529
		}

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

L
Linus Torvalds 已提交
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
	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;
1592
	sb->recovery_offset = cpu_to_le64(0);
L
Linus Torvalds 已提交
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603
	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);

1604
	sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
1605

1606
	sb->raid_disks = cpu_to_le32(mddev->raid_disks);
A
Andre Noll 已提交
1607
	sb->size = cpu_to_le64(mddev->dev_sectors);
1608
	sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
1609 1610
	sb->level = cpu_to_le32(mddev->level);
	sb->layout = cpu_to_le32(mddev->layout);
1611

1612 1613
	if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
		sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
1614
		sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1615
	}
1616 1617

	if (rdev->raid_disk >= 0 &&
1618
	    !test_bit(In_sync, &rdev->flags)) {
1619 1620 1621 1622
		sb->feature_map |=
			cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
		sb->recovery_offset =
			cpu_to_le64(rdev->recovery_offset);
1623 1624
	}

1625 1626 1627 1628 1629 1630
	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);
1631
		sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
1632
	}
1633

L
Linus Torvalds 已提交
1634
	max_dev = 0;
1635
	list_for_each_entry(rdev2, &mddev->disks, same_set)
L
Linus Torvalds 已提交
1636 1637
		if (rdev2->desc_nr+1 > max_dev)
			max_dev = rdev2->desc_nr+1;
1638

1639 1640
	if (max_dev > le32_to_cpu(sb->max_dev)) {
		int bmask;
1641
		sb->max_dev = cpu_to_le32(max_dev);
1642 1643 1644 1645
		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;
1646 1647 1648
	} else
		max_dev = le32_to_cpu(sb->max_dev);

L
Linus Torvalds 已提交
1649 1650 1651
	for (i=0; i<max_dev;i++)
		sb->dev_roles[i] = cpu_to_le16(0xfffe);
	
1652
	list_for_each_entry(rdev2, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
1653
		i = rdev2->desc_nr;
1654
		if (test_bit(Faulty, &rdev2->flags))
L
Linus Torvalds 已提交
1655
			sb->dev_roles[i] = cpu_to_le16(0xfffe);
1656
		else if (test_bit(In_sync, &rdev2->flags))
L
Linus Torvalds 已提交
1657
			sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1658
		else if (rdev2->raid_disk >= 0)
1659
			sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
L
Linus Torvalds 已提交
1660 1661 1662 1663 1664 1665 1666
		else
			sb->dev_roles[i] = cpu_to_le16(0xffff);
	}

	sb->sb_csum = calc_sb_1_csum(sb);
}

1667
static unsigned long long
1668
super_1_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
1669 1670
{
	struct mdp_superblock_1 *sb;
1671
	sector_t max_sectors;
A
Andre Noll 已提交
1672
	if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1673
		return 0; /* component must fit device */
1674
	if (rdev->sb_start < rdev->data_offset) {
1675
		/* minor versions 1 and 2; superblock before data */
1676 1677 1678 1679
		max_sectors = rdev->bdev->bd_inode->i_size >> 9;
		max_sectors -= rdev->data_offset;
		if (!num_sectors || num_sectors > max_sectors)
			num_sectors = max_sectors;
1680
	} else if (rdev->mddev->bitmap_info.offset) {
1681 1682 1683 1684
		/* minor version 0 with bitmap we can't move */
		return 0;
	} else {
		/* minor version 0; superblock after data */
1685 1686 1687
		sector_t sb_start;
		sb_start = (rdev->bdev->bd_inode->i_size >> 9) - 8*2;
		sb_start &= ~(sector_t)(4*2 - 1);
1688
		max_sectors = rdev->sectors + sb_start - rdev->sb_start;
1689 1690
		if (!num_sectors || num_sectors > max_sectors)
			num_sectors = max_sectors;
1691
		rdev->sb_start = sb_start;
1692 1693
	}
	sb = (struct mdp_superblock_1 *) page_address(rdev->sb_page);
1694
	sb->data_size = cpu_to_le64(num_sectors);
1695
	sb->super_offset = rdev->sb_start;
1696
	sb->sb_csum = calc_sb_1_csum(sb);
1697
	md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1698 1699
		       rdev->sb_page);
	md_super_wait(rdev->mddev);
1700
	return num_sectors / 2; /* kB for sysfs */
1701
}
L
Linus Torvalds 已提交
1702

A
Adrian Bunk 已提交
1703
static struct super_type super_types[] = {
L
Linus Torvalds 已提交
1704 1705 1706
	[0] = {
		.name	= "0.90.0",
		.owner	= THIS_MODULE,
1707 1708 1709 1710
		.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 已提交
1711 1712 1713 1714
	},
	[1] = {
		.name	= "md-1",
		.owner	= THIS_MODULE,
1715 1716 1717 1718
		.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 已提交
1719 1720 1721 1722 1723
	},
};

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

1726 1727 1728
	rcu_read_lock();
	rdev_for_each_rcu(rdev, mddev1)
		rdev_for_each_rcu(rdev2, mddev2)
1729
			if (rdev->bdev->bd_contains ==
1730 1731
			    rdev2->bdev->bd_contains) {
				rcu_read_unlock();
1732
				return 1;
1733 1734
			}
	rcu_read_unlock();
L
Linus Torvalds 已提交
1735 1736 1737 1738 1739
	return 0;
}

static LIST_HEAD(pending_raid_disks);

1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 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
/*
 * 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 已提交
1795 1796
{
	struct blk_integrity *bi_rdev = bdev_get_integrity(rdev->bdev);
1797
	struct blk_integrity *bi_mddev = blk_get_integrity(mddev->gendisk);
M
Martin K. Petersen 已提交
1798

1799
	if (!bi_mddev) /* nothing to do */
M
Martin K. Petersen 已提交
1800
		return;
1801
	if (rdev->raid_disk < 0) /* skip spares */
M
Martin K. Petersen 已提交
1802
		return;
1803 1804 1805 1806 1807
	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 已提交
1808
}
1809
EXPORT_SYMBOL(md_integrity_add_rdev);
M
Martin K. Petersen 已提交
1810

L
Linus Torvalds 已提交
1811 1812
static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
{
1813
	char b[BDEVNAME_SIZE];
1814
	struct kobject *ko;
1815
	char *s;
1816
	int err;
L
Linus Torvalds 已提交
1817 1818 1819 1820 1821

	if (rdev->mddev) {
		MD_BUG();
		return -EINVAL;
	}
1822 1823 1824 1825 1826

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

1827 1828 1829
	/* make sure rdev->sectors exceeds mddev->dev_sectors */
	if (rdev->sectors && (mddev->dev_sectors == 0 ||
			rdev->sectors < mddev->dev_sectors)) {
1830 1831 1832 1833 1834 1835 1836 1837
		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
1838
			mddev->dev_sectors = rdev->sectors;
1839
	}
L
Linus Torvalds 已提交
1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854

	/* 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;
	}
1855 1856 1857 1858 1859
	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;
	}
1860
	bdevname(rdev->bdev,b);
1861
	while ( (s=strchr(b, '/')) != NULL)
1862
		*s = '!';
1863

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

1867
	if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
1868
		goto fail;
1869

T
Tejun Heo 已提交
1870
	ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
N
NeilBrown 已提交
1871 1872 1873
	if (sysfs_create_link(&rdev->kobj, ko, "block"))
		/* failure here is OK */;
	rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
1874

1875
	list_add_rcu(&rdev->same_set, &mddev->disks);
1876
	bd_claim_by_disk(rdev->bdev, rdev->bdev->bd_holder, mddev->gendisk);
1877 1878 1879

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

L
Linus Torvalds 已提交
1881
	return 0;
1882 1883 1884 1885 1886

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

1889
static void md_delayed_delete(struct work_struct *ws)
1890 1891 1892
{
	mdk_rdev_t *rdev = container_of(ws, mdk_rdev_t, del_work);
	kobject_del(&rdev->kobj);
1893
	kobject_put(&rdev->kobj);
1894 1895
}

L
Linus Torvalds 已提交
1896 1897 1898 1899 1900 1901 1902
static void unbind_rdev_from_array(mdk_rdev_t * rdev)
{
	char b[BDEVNAME_SIZE];
	if (!rdev->mddev) {
		MD_BUG();
		return;
	}
1903
	bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
1904
	list_del_rcu(&rdev->same_set);
L
Linus Torvalds 已提交
1905 1906
	printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
	rdev->mddev = NULL;
1907
	sysfs_remove_link(&rdev->kobj, "block");
1908 1909
	sysfs_put(rdev->sysfs_state);
	rdev->sysfs_state = NULL;
1910
	/* We need to delay this, otherwise we can deadlock when
1911 1912
	 * writing to 'remove' to "dev/state".  We also need
	 * to delay it due to rcu usage.
1913
	 */
1914
	synchronize_rcu();
1915 1916
	INIT_WORK(&rdev->del_work, md_delayed_delete);
	kobject_get(&rdev->kobj);
1917
	schedule_work(&rdev->del_work);
L
Linus Torvalds 已提交
1918 1919 1920 1921 1922 1923 1924
}

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

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

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
1971 1972
	if (test_bit(AutoDetected, &rdev->flags))
		md_autodetect_dev(rdev->bdev->bd_dev);
L
Linus Torvalds 已提交
1973 1974
#endif
	unlock_rdev(rdev);
1975
	kobject_put(&rdev->kobj);
L
Linus Torvalds 已提交
1976 1977 1978 1979 1980 1981 1982 1983 1984 1985
}

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)
{
1986
	mdk_rdev_t *rdev, *tmp;
L
Linus Torvalds 已提交
1987

1988
	rdev_for_each(rdev, tmp, mddev) {
L
Linus Torvalds 已提交
1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
		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);
}

2007
static void print_sb_90(mdp_super_t *sb)
L
Linus Torvalds 已提交
2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037
{
	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);
2038
}
L
Linus Torvalds 已提交
2039

2040 2041 2042 2043 2044
static void print_sb_1(struct mdp_superblock_1 *sb)
{
	__u8 *uuid;

	uuid = sb->set_uuid;
2045
	printk(KERN_INFO
2046
	       "md:  SB: (V:%u) (F:0x%08x) Array-ID:<%pU>\n"
2047
	       "md:    Name: \"%s\" CT:%llu\n",
2048 2049
		le32_to_cpu(sb->major_version),
		le32_to_cpu(sb->feature_map),
2050
		uuid,
2051 2052 2053 2054 2055
		sb->set_name,
		(unsigned long long)le64_to_cpu(sb->ctime)
		       & MD_SUPERBLOCK_1_TIME_SEC_MASK);

	uuid = sb->device_uuid;
2056 2057
	printk(KERN_INFO
	       "md:       L%u SZ%llu RD:%u LO:%u CS:%u DO:%llu DS:%llu SO:%llu"
2058
			" RO:%llu\n"
2059
	       "md:     Dev:%08x UUID: %pU\n"
2060 2061
	       "md:       (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
	       "md:         (MaxDev:%u) \n",
2062 2063 2064 2065 2066 2067 2068 2069 2070 2071
		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),
2072
		uuid,
2073 2074 2075 2076 2077 2078 2079
		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 已提交
2080 2081
}

2082
static void print_rdev(mdk_rdev_t *rdev, int major_version)
L
Linus Torvalds 已提交
2083 2084
{
	char b[BDEVNAME_SIZE];
2085 2086
	printk(KERN_INFO "md: rdev %s, Sect:%08llu F:%d S:%d DN:%u\n",
		bdevname(rdev->bdev, b), (unsigned long long)rdev->sectors,
2087 2088
	        test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags),
	        rdev->desc_nr);
L
Linus Torvalds 已提交
2089
	if (rdev->sb_loaded) {
2090 2091 2092 2093 2094 2095 2096 2097 2098
		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 已提交
2099 2100 2101 2102
	} else
		printk(KERN_INFO "md: no rdev superblock!\n");
}

2103
static void md_print_devices(void)
L
Linus Torvalds 已提交
2104
{
2105
	struct list_head *tmp;
L
Linus Torvalds 已提交
2106 2107 2108 2109 2110 2111 2112 2113
	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");
2114
	for_each_mddev(mddev, tmp) {
L
Linus Torvalds 已提交
2115

2116 2117 2118 2119
		if (mddev->bitmap)
			bitmap_print_sb(mddev->bitmap);
		else
			printk("%s: ", mdname(mddev));
2120
		list_for_each_entry(rdev, &mddev->disks, same_set)
L
Linus Torvalds 已提交
2121 2122 2123
			printk("<%s>", bdevname(rdev->bdev,b));
		printk("\n");

2124
		list_for_each_entry(rdev, &mddev->disks, same_set)
2125
			print_rdev(rdev, mddev->major_version);
L
Linus Torvalds 已提交
2126 2127 2128 2129 2130 2131
	}
	printk("md:	**********************************\n");
	printk("\n");
}


2132
static void sync_sbs(mddev_t * mddev, int nospares)
L
Linus Torvalds 已提交
2133
{
2134 2135 2136 2137 2138 2139
	/* 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 已提交
2140
	mdk_rdev_t *rdev;
2141
	list_for_each_entry(rdev, &mddev->disks, same_set) {
2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152
		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 已提交
2153 2154 2155
	}
}

2156
static void md_update_sb(mddev_t * mddev, int force_change)
L
Linus Torvalds 已提交
2157 2158
{
	mdk_rdev_t *rdev;
2159
	int sync_req;
2160
	int nospares = 0;
L
Linus Torvalds 已提交
2161 2162

repeat:
2163 2164 2165 2166 2167 2168 2169 2170 2171
	/* 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;

	}	
2172
	if (!mddev->persistent) {
2173
		clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2174 2175 2176 2177 2178
		clear_bit(MD_CHANGE_DEVS, &mddev->flags);
		wake_up(&mddev->sb_wait);
		return;
	}

2179
	spin_lock_irq(&mddev->write_lock);
2180

2181 2182
	mddev->utime = get_seconds();

2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193
	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)
2194 2195 2196 2197 2198 2199 2200 2201 2202
		/* 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.
		 */
2203
		nospares = 0;
2204

2205
	sync_req = mddev->in_sync;
2206 2207 2208

	/* 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 */
2209
	if (nospares
2210
	    && (mddev->in_sync && mddev->recovery_cp == MaxSector)
2211 2212
	    && mddev->can_decrease_events
	    && mddev->events != 1) {
2213
		mddev->events--;
2214 2215
		mddev->can_decrease_events = 0;
	} else {
2216 2217
		/* otherwise we have to go forward and ... */
		mddev->events ++;
2218
		mddev->can_decrease_events = nospares;
2219
	}
L
Linus Torvalds 已提交
2220 2221 2222 2223 2224 2225 2226 2227 2228 2229

	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 --;
	}
2230
	sync_sbs(mddev, nospares);
2231
	spin_unlock_irq(&mddev->write_lock);
L
Linus Torvalds 已提交
2232 2233 2234 2235 2236

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

2237
	bitmap_update_sb(mddev->bitmap);
2238
	list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
2239 2240
		char b[BDEVNAME_SIZE];
		dprintk(KERN_INFO "md: ");
2241 2242
		if (rdev->sb_loaded != 1)
			continue; /* no noise on spare devices */
2243
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
2244 2245 2246
			dprintk("(skipping faulty ");

		dprintk("%s ", bdevname(rdev->bdev,b));
2247
		if (!test_bit(Faulty, &rdev->flags)) {
2248
			md_super_write(mddev,rdev,
2249
				       rdev->sb_start, rdev->sb_size,
2250 2251 2252
				       rdev->sb_page);
			dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
				bdevname(rdev->bdev,b),
2253
				(unsigned long long)rdev->sb_start);
2254
			rdev->sb_events = mddev->events;
2255

L
Linus Torvalds 已提交
2256 2257
		} else
			dprintk(")\n");
2258
		if (mddev->level == LEVEL_MULTIPATH)
L
Linus Torvalds 已提交
2259 2260 2261
			/* only need to write one superblock... */
			break;
	}
2262
	md_super_wait(mddev);
2263
	/* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
2264

2265
	spin_lock_irq(&mddev->write_lock);
2266 2267
	if (mddev->in_sync != sync_req ||
	    test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
2268
		/* have to write it out again */
2269
		spin_unlock_irq(&mddev->write_lock);
2270 2271
		goto repeat;
	}
2272
	clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2273
	spin_unlock_irq(&mddev->write_lock);
2274
	wake_up(&mddev->sb_wait);
2275 2276
	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
		sysfs_notify(&mddev->kobj, NULL, "sync_completed");
2277

L
Linus Torvalds 已提交
2278 2279
}

2280
/* words written to sysfs files may, or may not, be \n terminated.
2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299
 * 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;
}

2300 2301 2302 2303 2304 2305 2306
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
2307
state_show(mdk_rdev_t *rdev, char *page)
2308 2309
{
	char *sep = "";
2310
	size_t len = 0;
2311

2312
	if (test_bit(Faulty, &rdev->flags)) {
2313 2314 2315
		len+= sprintf(page+len, "%sfaulty",sep);
		sep = ",";
	}
2316
	if (test_bit(In_sync, &rdev->flags)) {
2317 2318 2319
		len += sprintf(page+len, "%sin_sync",sep);
		sep = ",";
	}
2320 2321 2322 2323
	if (test_bit(WriteMostly, &rdev->flags)) {
		len += sprintf(page+len, "%swrite_mostly",sep);
		sep = ",";
	}
2324 2325 2326 2327
	if (test_bit(Blocked, &rdev->flags)) {
		len += sprintf(page+len, "%sblocked", sep);
		sep = ",";
	}
2328 2329
	if (!test_bit(Faulty, &rdev->flags) &&
	    !test_bit(In_sync, &rdev->flags)) {
2330 2331 2332 2333 2334 2335
		len += sprintf(page+len, "%sspare", sep);
		sep = ",";
	}
	return len+sprintf(page+len, "\n");
}

2336 2337 2338 2339 2340 2341
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
2342 2343
	 *  writemostly - sets write_mostly
	 *  -writemostly - clears write_mostly
2344 2345
	 *  blocked - sets the Blocked flag
	 *  -blocked - clears the Blocked flag
2346
	 *  insync - sets Insync providing device isn't active
2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357
	 */
	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);
2358 2359
			if (mddev->pers)
				md_update_sb(mddev, 1);
2360 2361 2362
			md_new_event(mddev);
			err = 0;
		}
2363 2364 2365 2366 2367
	} else if (cmd_match(buf, "writemostly")) {
		set_bit(WriteMostly, &rdev->flags);
		err = 0;
	} else if (cmd_match(buf, "-writemostly")) {
		clear_bit(WriteMostly, &rdev->flags);
2368 2369 2370 2371 2372 2373 2374 2375 2376 2377
		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);

2378 2379 2380
		err = 0;
	} else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
		set_bit(In_sync, &rdev->flags);
2381
		err = 0;
2382
	}
N
NeilBrown 已提交
2383 2384
	if (!err)
		sysfs_notify_dirent_safe(rdev->sysfs_state);
2385 2386
	return err ? err : len;
}
2387 2388
static struct rdev_sysfs_entry rdev_state =
__ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store);
2389

2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407
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 =
2408
__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
2409

2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422
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;
2423 2424
	int err;
	char nm[20];
2425 2426 2427 2428 2429
	int slot = simple_strtoul(buf, &e, 10);
	if (strncmp(buf, "none", 4)==0)
		slot = -1;
	else if (e==buf || (*e && *e!= '\n'))
		return -EINVAL;
2430
	if (rdev->mddev->pers && slot == -1) {
2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448
		/* 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);
2449
		rdev->raid_disk = -1;
2450 2451
		set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
		md_wakeup_thread(rdev->mddev->thread);
2452 2453 2454
	} else if (rdev->mddev->pers) {
		mdk_rdev_t *rdev2;
		/* Activating a spare .. or possibly reactivating
2455
		 * if we ever get bitmaps working here.
2456 2457 2458 2459 2460 2461 2462 2463
		 */

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

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

2464
		list_for_each_entry(rdev2, &rdev->mddev->disks, same_set)
2465 2466 2467 2468 2469 2470 2471 2472 2473 2474
			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);
2475
		if (err) {
2476 2477
			rdev->raid_disk = -1;
			return err;
2478
		} else
N
NeilBrown 已提交
2479
			sysfs_notify_dirent_safe(rdev->sysfs_state);
2480 2481
		sprintf(nm, "rd%d", rdev->raid_disk);
		if (sysfs_create_link(&rdev->mddev->kobj, &rdev->kobj, nm))
N
NeilBrown 已提交
2482
			/* failure here is OK */;
2483
		/* don't wakeup anyone, leave that to userspace. */
2484 2485 2486 2487 2488
	} else {
		if (slot >= rdev->mddev->raid_disks)
			return -ENOSPC;
		rdev->raid_disk = slot;
		/* assume it is working */
2489 2490
		clear_bit(Faulty, &rdev->flags);
		clear_bit(WriteMostly, &rdev->flags);
2491
		set_bit(In_sync, &rdev->flags);
N
NeilBrown 已提交
2492
		sysfs_notify_dirent_safe(rdev->sysfs_state);
2493
	}
2494 2495 2496 2497 2498
	return len;
}


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

2501 2502 2503
static ssize_t
offset_show(mdk_rdev_t *rdev, char *page)
{
2504
	return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
2505 2506 2507 2508 2509 2510 2511 2512 2513
}

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;
2514
	if (rdev->mddev->pers && rdev->raid_disk >= 0)
2515
		return -EBUSY;
2516
	if (rdev->sectors && rdev->mddev->external)
2517 2518 2519
		/* Must set offset before size, so overlap checks
		 * can be sane */
		return -EBUSY;
2520 2521 2522 2523 2524
	rdev->data_offset = offset;
	return len;
}

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

2527 2528 2529
static ssize_t
rdev_size_show(mdk_rdev_t *rdev, char *page)
{
2530
	return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
2531 2532
}

2533 2534 2535 2536 2537 2538 2539 2540 2541 2542
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 已提交
2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561
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;
}

2562 2563 2564
static ssize_t
rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
{
2565
	mddev_t *my_mddev = rdev->mddev;
2566
	sector_t oldsectors = rdev->sectors;
D
Dan Williams 已提交
2567
	sector_t sectors;
2568

D
Dan Williams 已提交
2569
	if (strict_blocks_to_sectors(buf, &sectors) < 0)
N
Neil Brown 已提交
2570
		return -EINVAL;
2571
	if (my_mddev->pers && rdev->raid_disk >= 0) {
N
Neil Brown 已提交
2572
		if (my_mddev->persistent) {
2573 2574 2575
			sectors = super_types[my_mddev->major_version].
				rdev_size_change(rdev, sectors);
			if (!sectors)
2576
				return -EBUSY;
2577 2578 2579
		} else if (!sectors)
			sectors = (rdev->bdev->bd_inode->i_size >> 9) -
				rdev->data_offset;
2580
	}
2581
	if (sectors < my_mddev->dev_sectors)
2582
		return -EINVAL; /* component must fit device */
2583

2584 2585
	rdev->sectors = sectors;
	if (sectors > oldsectors && my_mddev->external) {
2586 2587
		/* need to check that all other rdevs with the same ->bdev
		 * do not overlap.  We need to unlock the mddev to avoid
2588
		 * a deadlock.  We have already changed rdev->sectors, and if
2589 2590 2591 2592
		 * we have to change it back, we will have the lock again.
		 */
		mddev_t *mddev;
		int overlap = 0;
2593
		struct list_head *tmp;
2594

2595
		mddev_unlock(my_mddev);
2596
		for_each_mddev(mddev, tmp) {
2597 2598 2599
			mdk_rdev_t *rdev2;

			mddev_lock(mddev);
2600
			list_for_each_entry(rdev2, &mddev->disks, same_set)
2601 2602 2603
				if (test_bit(AllReserved, &rdev2->flags) ||
				    (rdev->bdev == rdev2->bdev &&
				     rdev != rdev2 &&
2604
				     overlaps(rdev->data_offset, rdev->sectors,
2605
					      rdev2->data_offset,
2606
					      rdev2->sectors))) {
2607 2608 2609 2610 2611 2612 2613 2614 2615
					overlap = 1;
					break;
				}
			mddev_unlock(mddev);
			if (overlap) {
				mddev_put(mddev);
				break;
			}
		}
2616
		mddev_lock(my_mddev);
2617 2618 2619
		if (overlap) {
			/* Someone else could have slipped in a size
			 * change here, but doing so is just silly.
2620
			 * We put oldsectors back because we *know* it is
2621 2622 2623
			 * safe, and trust userspace not to race with
			 * itself
			 */
2624
			rdev->sectors = oldsectors;
2625 2626 2627
			return -EBUSY;
		}
	}
2628 2629 2630 2631
	return len;
}

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

2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669

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

2670 2671
static struct attribute *rdev_default_attrs[] = {
	&rdev_state.attr,
2672
	&rdev_errors.attr,
2673
	&rdev_slot.attr,
2674
	&rdev_offset.attr,
2675
	&rdev_size.attr,
2676
	&rdev_recovery_start.attr,
2677 2678 2679 2680 2681 2682 2683
	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);
2684 2685
	mddev_t *mddev = rdev->mddev;
	ssize_t rv;
2686 2687 2688

	if (!entry->show)
		return -EIO;
2689 2690 2691 2692 2693 2694 2695 2696 2697 2698

	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;
2699 2700 2701 2702 2703 2704 2705 2706
}

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);
2707 2708
	ssize_t rv;
	mddev_t *mddev = rdev->mddev;
2709 2710 2711

	if (!entry->store)
		return -EIO;
2712 2713
	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
2714
	rv = mddev ? mddev_lock(mddev): -EBUSY;
2715
	if (!rv) {
2716 2717 2718 2719
		if (rdev->mddev == NULL)
			rv = -EBUSY;
		else
			rv = entry->store(rdev, page, length);
2720
		mddev_unlock(mddev);
2721 2722
	}
	return rv;
2723 2724 2725 2726 2727 2728 2729
}

static void rdev_free(struct kobject *ko)
{
	mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj);
	kfree(rdev);
}
2730
static const struct sysfs_ops rdev_sysfs_ops = {
2731 2732 2733 2734 2735 2736 2737 2738 2739
	.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 已提交
2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757
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 已提交
2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774
/*
 * 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;

2775
	rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
L
Linus Torvalds 已提交
2776 2777 2778 2779 2780
	if (!rdev) {
		printk(KERN_ERR "md: could not alloc mem for new device!\n");
		return ERR_PTR(-ENOMEM);
	}

N
NeilBrown 已提交
2781
	md_rdev_init(rdev);
L
Linus Torvalds 已提交
2782 2783 2784
	if ((err = alloc_disk_sb(rdev)))
		goto abort_free;

2785
	err = lock_rdev(rdev, newdev, super_format == -2);
L
Linus Torvalds 已提交
2786 2787 2788
	if (err)
		goto abort_free;

2789
	kobject_init(&rdev->kobj, &rdev_ktype);
2790

L
Linus Torvalds 已提交
2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803
	size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
	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) {
2804 2805 2806 2807 2808
			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 已提交
2809 2810 2811 2812 2813 2814 2815 2816 2817
			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;
		}
	}
2818

L
Linus Torvalds 已提交
2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835
	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
 */


2836
static void analyze_sbs(mddev_t * mddev)
L
Linus Torvalds 已提交
2837 2838
{
	int i;
2839
	mdk_rdev_t *rdev, *freshest, *tmp;
L
Linus Torvalds 已提交
2840 2841 2842
	char b[BDEVNAME_SIZE];

	freshest = NULL;
2843
	rdev_for_each(rdev, tmp, mddev)
L
Linus Torvalds 已提交
2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863
		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;
2864
	rdev_for_each(rdev, tmp, mddev) {
2865 2866 2867
		if (mddev->max_disks &&
		    (rdev->desc_nr >= mddev->max_disks ||
		     i > mddev->max_disks)) {
2868 2869 2870 2871 2872 2873 2874
			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 已提交
2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886
		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;
2887
			set_bit(In_sync, &rdev->flags);
2888
		} else if (rdev->raid_disk >= (mddev->raid_disks - min(0, mddev->delta_disks))) {
2889 2890
			rdev->raid_disk = -1;
			clear_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
2891 2892 2893 2894
		}
	}
}

2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 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
/* 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;
}


2936 2937
static void md_safemode_timeout(unsigned long data);

2938 2939 2940 2941 2942 2943 2944 2945 2946 2947
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;
2948

2949
	if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
2950 2951 2952 2953
		return -EINVAL;
	if (msec == 0)
		mddev->safemode_delay = 0;
	else {
2954
		unsigned long old_delay = mddev->safemode_delay;
2955 2956 2957
		mddev->safemode_delay = (msec*HZ)/1000;
		if (mddev->safemode_delay == 0)
			mddev->safemode_delay = 1;
2958 2959
		if (mddev->safemode_delay < old_delay)
			md_safemode_timeout((unsigned long)mddev);
2960 2961 2962 2963
	}
	return len;
}
static struct md_sysfs_entry md_safe_delay =
2964
__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
2965

2966
static ssize_t
2967
level_show(mddev_t *mddev, char *page)
2968
{
2969
	struct mdk_personality *p = mddev->pers;
2970
	if (p)
2971
		return sprintf(page, "%s\n", p->name);
2972 2973 2974 2975 2976 2977
	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;
2978 2979
}

2980 2981 2982
static ssize_t
level_store(mddev_t *mddev, const char *buf, size_t len)
{
2983
	char clevel[16];
2984
	ssize_t rv = len;
2985
	struct mdk_personality *pers;
2986
	long level;
2987
	void *priv;
2988
	mdk_rdev_t *rdev;
2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008

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

3009 3010 3011
	if (mddev->sync_thread ||
	    mddev->reshape_position != MaxSector ||
	    mddev->sysfs_active)
3012
		return -EBUSY;
3013 3014 3015 3016 3017 3018 3019 3020

	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 */
3021
	if (len == 0 || len >= sizeof(clevel))
3022
		return -EINVAL;
3023 3024
	strncpy(clevel, buf, len);
	if (clevel[len-1] == '\n')
3025
		len--;
3026 3027 3028
	clevel[len] = 0;
	if (strict_strtol(clevel, 10, &level))
		level = LEVEL_NONE;
3029

3030 3031
	if (request_module("md-%s", clevel) != 0)
		request_module("md-level-%s", clevel);
3032
	spin_lock(&pers_lock);
3033
	pers = find_pers(level, clevel);
3034 3035
	if (!pers || !try_module_get(pers->owner)) {
		spin_unlock(&pers_lock);
3036
		printk(KERN_WARNING "md: personality %s not loaded\n", clevel);
3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048
		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",
3049
		       mdname(mddev), clevel);
3050 3051 3052
		return -EINVAL;
	}

3053 3054 3055
	list_for_each_entry(rdev, &mddev->disks, same_set)
		rdev->new_raid_disk = rdev->raid_disk;

3056 3057 3058 3059 3060 3061 3062
	/* ->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;
3063
		mddev->new_chunk_sectors = mddev->chunk_sectors;
3064 3065 3066 3067
		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",
3068
		       mdname(mddev), clevel);
3069 3070 3071 3072 3073 3074
		return PTR_ERR(priv);
	}

	/* Looks like we have a winner */
	mddev_suspend(mddev);
	mddev->pers->stop(mddev);
3075 3076 3077 3078 3079 3080 3081 3082
	
	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));
3083
		mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, NULL, "sync_action");
3084 3085 3086 3087 3088 3089 3090 3091
	}		
	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;
	}

3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105
	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;
	}

3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123
	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)
3124
			clear_bit(In_sync, &rdev->flags);
3125 3126 3127 3128 3129 3130
		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));
3131
		}
3132 3133 3134
	}

	module_put(mddev->pers->owner);
3135 3136 3137 3138 3139
	mddev->pers = pers;
	mddev->private = priv;
	strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
	mddev->level = mddev->new_level;
	mddev->layout = mddev->new_layout;
3140
	mddev->chunk_sectors = mddev->new_chunk_sectors;
3141
	mddev->delta_disks = 0;
3142 3143 3144 3145 3146 3147 3148
	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);
	}
3149 3150 3151 3152 3153
	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);
3154
	sysfs_notify(&mddev->kobj, NULL, "level");
3155
	md_new_event(mddev);
3156 3157 3158 3159
	return rv;
}

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

3162 3163 3164 3165 3166

static ssize_t
layout_show(mddev_t *mddev, char *page)
{
	/* just a number, not meaningful for all levels */
3167 3168 3169 3170
	if (mddev->reshape_position != MaxSector &&
	    mddev->layout != mddev->new_layout)
		return sprintf(page, "%d (%d)\n",
			       mddev->new_layout, mddev->layout);
3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182
	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;

3183 3184
	if (mddev->pers) {
		int err;
3185
		if (mddev->pers->check_reshape == NULL)
3186
			return -EBUSY;
3187
		mddev->new_layout = n;
3188
		err = mddev->pers->check_reshape(mddev);
3189 3190
		if (err) {
			mddev->new_layout = mddev->layout;
3191
			return err;
3192
		}
3193
	} else {
3194
		mddev->new_layout = n;
3195 3196 3197
		if (mddev->reshape_position == MaxSector)
			mddev->layout = n;
	}
3198 3199 3200
	return len;
}
static struct md_sysfs_entry md_layout =
3201
__ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
3202 3203


3204
static ssize_t
3205
raid_disks_show(mddev_t *mddev, char *page)
3206
{
3207 3208
	if (mddev->raid_disks == 0)
		return 0;
3209 3210 3211 3212
	if (mddev->reshape_position != MaxSector &&
	    mddev->delta_disks != 0)
		return sprintf(page, "%d (%d)\n", mddev->raid_disks,
			       mddev->raid_disks - mddev->delta_disks);
3213 3214 3215
	return sprintf(page, "%d\n", mddev->raid_disks);
}

3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229
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);
3230 3231 3232 3233 3234
	else if (mddev->reshape_position != MaxSector) {
		int olddisks = mddev->raid_disks - mddev->delta_disks;
		mddev->delta_disks = n - olddisks;
		mddev->raid_disks = n;
	} else
3235 3236 3237 3238
		mddev->raid_disks = n;
	return rv ? rv : len;
}
static struct md_sysfs_entry md_raid_disks =
3239
__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
3240

3241 3242 3243
static ssize_t
chunk_size_show(mddev_t *mddev, char *page)
{
3244
	if (mddev->reshape_position != MaxSector &&
3245 3246 3247
	    mddev->chunk_sectors != mddev->new_chunk_sectors)
		return sprintf(page, "%d (%d)\n",
			       mddev->new_chunk_sectors << 9,
3248 3249
			       mddev->chunk_sectors << 9);
	return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260
}

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;

3261 3262
	if (mddev->pers) {
		int err;
3263
		if (mddev->pers->check_reshape == NULL)
3264
			return -EBUSY;
3265
		mddev->new_chunk_sectors = n >> 9;
3266
		err = mddev->pers->check_reshape(mddev);
3267 3268
		if (err) {
			mddev->new_chunk_sectors = mddev->chunk_sectors;
3269
			return err;
3270
		}
3271
	} else {
3272
		mddev->new_chunk_sectors = n >> 9;
3273
		if (mddev->reshape_position == MaxSector)
3274
			mddev->chunk_sectors = n >> 9;
3275
	}
3276 3277 3278
	return len;
}
static struct md_sysfs_entry md_chunk_size =
3279
__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
3280

3281 3282 3283
static ssize_t
resync_start_show(mddev_t *mddev, char *page)
{
3284 3285
	if (mddev->recovery_cp == MaxSector)
		return sprintf(page, "none\n");
3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296
	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;
3297 3298 3299
	if (cmd_match(buf, "none"))
		n = MaxSector;
	else if (!*buf || (*e && *e != '\n'))
3300 3301 3302 3303 3304 3305
		return -EINVAL;

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

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

3393
static int do_md_stop(mddev_t * mddev, int ro, int is_open);
3394
static int md_set_readonly(mddev_t * mddev, int is_open);
3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407
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 */
3408
		if (atomic_read(&mddev->openers) > 0)
3409
			return -EBUSY;
3410
		err = do_md_stop(mddev, 0, 0);
3411 3412 3413 3414
		break;
	case inactive:
		/* stopping an active array */
		if (mddev->pers) {
3415
			if (atomic_read(&mddev->openers) > 0)
3416
				return -EBUSY;
3417
			err = do_md_stop(mddev, 2, 0);
3418 3419
		} else
			err = 0; /* already inactive */
3420 3421 3422 3423 3424
		break;
	case suspended:
		break; /* not supported yet */
	case readonly:
		if (mddev->pers)
3425
			err = md_set_readonly(mddev, 0);
3426 3427
		else {
			mddev->ro = 1;
3428
			set_disk_ro(mddev->gendisk, 1);
3429 3430 3431 3432 3433
			err = do_md_run(mddev);
		}
		break;
	case read_auto:
		if (mddev->pers) {
3434
			if (mddev->ro == 0)
3435
				err = md_set_readonly(mddev, 0);
3436
			else if (mddev->ro == 1)
3437 3438 3439 3440 3441
				err = restart_array(mddev);
			if (err == 0) {
				mddev->ro = 2;
				set_disk_ro(mddev->gendisk, 0);
			}
3442 3443 3444 3445 3446 3447 3448 3449 3450 3451
		} 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) {
3452 3453
				if (mddev->in_sync == 0) {
					mddev->in_sync = 1;
3454 3455
					if (mddev->safemode == 1)
						mddev->safemode = 0;
3456
					set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3457 3458 3459 3460
				}
				err = 0;
			} else
				err = -EBUSY;
3461
			spin_unlock_irq(&mddev->write_lock);
3462 3463
		} else
			err = -EINVAL;
3464 3465 3466 3467
		break;
	case active:
		if (mddev->pers) {
			restart_array(mddev);
3468
			clear_bit(MD_CHANGE_PENDING, &mddev->flags);
3469 3470 3471 3472
			wake_up(&mddev->sb_wait);
			err = 0;
		} else {
			mddev->ro = 0;
3473
			set_disk_ro(mddev->gendisk, 0);
3474 3475 3476 3477 3478 3479 3480 3481 3482 3483
			err = do_md_run(mddev);
		}
		break;
	case write_pending:
	case active_idle:
		/* these cannot be set */
		break;
	}
	if (err)
		return err;
3484
	else {
N
NeilBrown 已提交
3485
		sysfs_notify_dirent_safe(mddev->sysfs_state);
3486
		return len;
3487
	}
3488
}
3489 3490
static struct md_sysfs_entry md_array_state =
__ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
3491

3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514
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);

3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 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
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;
		}
3560 3561 3562
	} else if (mddev->external)
		rdev = md_import_device(dev, -2, -1);
	else
3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574
		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 =
3575
__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
3576

3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595
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);
3596
		buf = skip_spaces(end);
3597 3598 3599 3600 3601 3602 3603 3604 3605
	}
	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);

3606 3607 3608
static ssize_t
size_show(mddev_t *mddev, char *page)
{
A
Andre Noll 已提交
3609 3610
	return sprintf(page, "%llu\n",
		(unsigned long long)mddev->dev_sectors / 2);
3611 3612
}

3613
static int update_size(mddev_t *mddev, sector_t num_sectors);
3614 3615 3616 3617 3618 3619 3620 3621

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 已提交
3622 3623
	sector_t sectors;
	int err = strict_blocks_to_sectors(buf, &sectors);
3624

A
Andre Noll 已提交
3625 3626
	if (err < 0)
		return err;
3627
	if (mddev->pers) {
A
Andre Noll 已提交
3628
		err = update_size(mddev, sectors);
3629
		md_update_sb(mddev, 1);
3630
	} else {
A
Andre Noll 已提交
3631 3632 3633
		if (mddev->dev_sectors == 0 ||
		    mddev->dev_sectors > sectors)
			mddev->dev_sectors = sectors;
3634 3635 3636 3637 3638 3639 3640
		else
			err = -ENOSPC;
	}
	return err ? err : len;
}

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

3643 3644

/* Metdata version.
3645 3646 3647
 * This is one of
 *   'none' for arrays with no metadata (good luck...)
 *   'external' for arrays with externally managed metadata,
3648 3649 3650 3651 3652 3653 3654 3655
 * 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);
3656 3657
	else if (mddev->external)
		return sprintf(page, "external:%s\n", mddev->metadata_type);
3658 3659 3660 3661 3662 3663 3664 3665 3666
	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;
3667 3668 3669 3670 3671 3672 3673
	/* 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))
3674 3675 3676 3677
		return -EBUSY;

	if (cmd_match(buf, "none")) {
		mddev->persistent = 0;
3678 3679 3680 3681 3682 3683
		mddev->external = 0;
		mddev->major_version = 0;
		mddev->minor_version = 90;
		return len;
	}
	if (strncmp(buf, "external:", 9) == 0) {
3684
		size_t namelen = len-9;
3685 3686 3687 3688 3689 3690 3691 3692
		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;
3693 3694 3695 3696 3697 3698 3699 3700 3701
		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);
3702
	if (e==buf || (*e && *e != '\n') )
3703
		return -EINVAL;
3704
	if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
3705 3706 3707 3708
		return -ENOENT;
	mddev->major_version = major;
	mddev->minor_version = minor;
	mddev->persistent = 1;
3709
	mddev->external = 0;
3710 3711 3712 3713
	return len;
}

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

3716
static ssize_t
3717
action_show(mddev_t *mddev, char *page)
3718
{
3719
	char *type = "idle";
3720 3721 3722
	if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
		type = "frozen";
	else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3723
	    (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))) {
3724 3725 3726
		if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
			type = "reshape";
		else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
3727 3728 3729 3730 3731 3732
			if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
				type = "resync";
			else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
				type = "check";
			else
				type = "repair";
3733
		} else if (test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
3734 3735 3736 3737 3738 3739
			type = "recover";
	}
	return sprintf(page, "%s\n", type);
}

static ssize_t
3740
action_store(mddev_t *mddev, const char *page, size_t len)
3741
{
3742 3743 3744
	if (!mddev->pers || !mddev->pers->sync_request)
		return -EINVAL;

3745 3746 3747 3748 3749 3750
	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")) {
3751 3752 3753 3754 3755 3756
		if (mddev->sync_thread) {
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
			md_unregister_thread(mddev->sync_thread);
			mddev->sync_thread = NULL;
			mddev->recovery = 0;
		}
3757 3758
	} else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
		   test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
3759
		return -EBUSY;
3760 3761 3762 3763
	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);
3764
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3765
	} else if (cmd_match(page, "reshape")) {
3766 3767 3768 3769 3770 3771
		int err;
		if (mddev->pers->start_reshape == NULL)
			return -EINVAL;
		err = mddev->pers->start_reshape(mddev);
		if (err)
			return err;
3772
		sysfs_notify(&mddev->kobj, NULL, "degraded");
3773
	} else {
3774
		if (cmd_match(page, "check"))
3775
			set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
3776
		else if (!cmd_match(page, "repair"))
3777 3778 3779 3780
			return -EINVAL;
		set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
		set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
	}
3781
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3782
	md_wakeup_thread(mddev->thread);
N
NeilBrown 已提交
3783
	sysfs_notify_dirent_safe(mddev->sysfs_action);
3784 3785 3786
	return len;
}

3787
static ssize_t
3788
mismatch_cnt_show(mddev_t *mddev, char *page)
3789 3790 3791 3792 3793
{
	return sprintf(page, "%llu\n",
		       (unsigned long long) mddev->resync_mismatches);
}

3794 3795
static struct md_sysfs_entry md_scan_mode =
__ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
3796

3797

3798
static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
3799

3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 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
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);

3852 3853 3854 3855 3856 3857
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);
3858

3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888
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);

3889 3890 3891 3892
static ssize_t
sync_speed_show(mddev_t *mddev, char *page)
{
	unsigned long resync, dt, db;
3893 3894
	if (mddev->curr_resync == 0)
		return sprintf(page, "none\n");
3895 3896
	resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
	dt = (jiffies - mddev->resync_mark) / HZ;
3897
	if (!dt) dt++;
3898 3899
	db = resync - mddev->resync_mark_cnt;
	return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
3900 3901
}

3902
static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
3903 3904 3905 3906

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

3909 3910 3911
	if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
		return sprintf(page, "none\n");

3912
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
A
Andre Noll 已提交
3913
		max_sectors = mddev->resync_max_sectors;
3914
	else
A
Andre Noll 已提交
3915
		max_sectors = mddev->dev_sectors;
3916

3917
	resync = mddev->curr_resync_completed;
A
Andre Noll 已提交
3918
	return sprintf(page, "%lu / %lu\n", resync, max_sectors);
3919 3920
}

3921
static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
3922

3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940
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 */
3941
	if (mddev->chunk_sectors) {
3942
		sector_t temp = min;
3943
		if (sector_div(temp, mddev->chunk_sectors))
3944 3945 3946 3947 3948 3949 3950 3951 3952 3953
			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);

3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968
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 {
3969 3970 3971 3972
		unsigned long long max;
		if (strict_strtoull(buf, 10, &max))
			return -EINVAL;
		if (max < mddev->resync_min)
3973 3974
			return -EINVAL;
		if (max < mddev->resync_max &&
3975
		    mddev->ro == 0 &&
3976 3977 3978 3979
		    test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
			return -EBUSY;

		/* Must be a multiple of chunk_size */
3980
		if (mddev->chunk_sectors) {
3981
			sector_t temp = max;
3982
			if (sector_div(temp, mddev->chunk_sectors))
3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993
				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);

3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005
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);

4006 4007
	if (mddev->pers == NULL || 
	    mddev->pers->quiesce == NULL)
4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034
		return -EINVAL;
	if (buf == e || (*e && *e != '\n'))
		return -EINVAL;
	if (new >= mddev->suspend_hi ||
	    (new > mddev->suspend_lo && new < mddev->suspend_hi)) {
		mddev->suspend_lo = new;
		mddev->pers->quiesce(mddev, 2);
		return len;
	} else
		return -EINVAL;
}
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);

4035 4036
	if (mddev->pers == NULL ||
	    mddev->pers->quiesce == NULL)
4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051
		return -EINVAL;
	if (buf == e || (*e && *e != '\n'))
		return -EINVAL;
	if ((new <= mddev->suspend_lo && mddev->suspend_lo >= mddev->suspend_hi) ||
	    (new > mddev->suspend_lo && new > mddev->suspend_hi)) {
		mddev->suspend_hi = new;
		mddev->pers->quiesce(mddev, 1);
		mddev->pers->quiesce(mddev, 0);
		return len;
	} else
		return -EINVAL;
}
static struct md_sysfs_entry md_suspend_hi =
__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);

4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074
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;
4075
	mddev->new_chunk_sectors = mddev->chunk_sectors;
4076 4077 4078 4079 4080 4081 4082
	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 已提交
4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108
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)
4109
			return -E2BIG;
D
Dan Williams 已提交
4110 4111 4112 4113 4114 4115

		mddev->external_size = 1;
	}

	mddev->array_sectors = sectors;
	set_capacity(mddev->gendisk, mddev->array_sectors);
4116 4117
	if (mddev->pers)
		revalidate_disk(mddev->gendisk);
D
Dan Williams 已提交
4118 4119 4120 4121 4122 4123 4124

	return len;
}

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

4126 4127
static struct attribute *md_default_attrs[] = {
	&md_level.attr,
4128
	&md_layout.attr,
4129
	&md_raid_disks.attr,
4130
	&md_chunk_size.attr,
4131
	&md_size.attr,
4132
	&md_resync_start.attr,
4133
	&md_metadata.attr,
4134
	&md_new_device.attr,
4135
	&md_safe_delay.attr,
4136
	&md_array_state.attr,
4137
	&md_reshape_position.attr,
D
Dan Williams 已提交
4138
	&md_array_size.attr,
4139
	&max_corr_read_errors.attr,
4140 4141 4142 4143
	NULL,
};

static struct attribute *md_redundancy_attrs[] = {
4144
	&md_scan_mode.attr,
4145
	&md_mismatches.attr,
4146 4147 4148
	&md_sync_min.attr,
	&md_sync_max.attr,
	&md_sync_speed.attr,
4149
	&md_sync_force_parallel.attr,
4150
	&md_sync_completed.attr,
4151
	&md_min_sync.attr,
4152
	&md_max_sync.attr,
4153 4154
	&md_suspend_lo.attr,
	&md_suspend_hi.attr,
4155
	&md_bitmap.attr,
4156
	&md_degraded.attr,
4157 4158
	NULL,
};
4159 4160 4161 4162 4163
static struct attribute_group md_redundancy_group = {
	.name = NULL,
	.attrs = md_redundancy_attrs,
};

4164 4165 4166 4167 4168 4169

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);
4170
	ssize_t rv;
4171 4172 4173

	if (!entry->show)
		return -EIO;
I
Ingo Molnar 已提交
4174 4175 4176 4177 4178
	rv = mddev_lock(mddev);
	if (!rv) {
		rv = entry->show(mddev, page);
		mddev_unlock(mddev);
	}
4179
	return rv;
4180 4181 4182 4183 4184 4185 4186 4187
}

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);
4188
	ssize_t rv;
4189 4190 4191

	if (!entry->store)
		return -EIO;
4192 4193
	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
I
Ingo Molnar 已提交
4194
	rv = mddev_lock(mddev);
4195 4196
	if (mddev->hold_active == UNTIL_IOCTL)
		mddev->hold_active = 0;
I
Ingo Molnar 已提交
4197 4198 4199 4200
	if (!rv) {
		rv = entry->store(mddev, page, length);
		mddev_unlock(mddev);
	}
4201
	return rv;
4202 4203 4204 4205 4206
}

static void md_free(struct kobject *ko)
{
	mddev_t *mddev = container_of(ko, mddev_t, kobj);
4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217

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

4218 4219 4220
	kfree(mddev);
}

4221
static const struct sysfs_ops md_sysfs_ops = {
4222 4223 4224 4225 4226 4227 4228 4229 4230
	.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 已提交
4231 4232
int mdp_major = 0;

4233 4234 4235 4236
static void mddev_delayed_delete(struct work_struct *ws)
{
	mddev_t *mddev = container_of(ws, mddev_t, del_work);

4237
	sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
4238 4239 4240 4241
	kobject_del(&mddev->kobj);
	kobject_put(&mddev->kobj);
}

4242
static int md_alloc(dev_t dev, char *name)
L
Linus Torvalds 已提交
4243
{
A
Arjan van de Ven 已提交
4244
	static DEFINE_MUTEX(disks_mutex);
L
Linus Torvalds 已提交
4245 4246
	mddev_t *mddev = mddev_find(dev);
	struct gendisk *disk;
4247 4248 4249
	int partitioned;
	int shift;
	int unit;
4250
	int error;
L
Linus Torvalds 已提交
4251 4252

	if (!mddev)
4253 4254 4255 4256 4257
		return -ENODEV;

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

4259 4260 4261 4262 4263
	/* wait for any previous instance if this device
	 * to be completed removed (mddev_delayed_delete).
	 */
	flush_scheduled_work();

A
Arjan van de Ven 已提交
4264
	mutex_lock(&disks_mutex);
N
NeilBrown 已提交
4265 4266 4267
	error = -EEXIST;
	if (mddev->gendisk)
		goto abort;
4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278

	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 已提交
4279
				goto abort;
4280 4281
			}
		spin_unlock(&all_mddevs_lock);
L
Linus Torvalds 已提交
4282
	}
4283

N
NeilBrown 已提交
4284
	error = -ENOMEM;
4285
	mddev->queue = blk_alloc_queue(GFP_KERNEL);
N
NeilBrown 已提交
4286 4287
	if (!mddev->queue)
		goto abort;
4288 4289
	mddev->queue->queuedata = mddev;

4290 4291 4292
	/* Can be unlocked because the queue is new: no concurrency */
	queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, mddev->queue);

4293
	blk_queue_make_request(mddev->queue, md_make_request);
4294

L
Linus Torvalds 已提交
4295 4296
	disk = alloc_disk(1 << shift);
	if (!disk) {
4297 4298
		blk_cleanup_queue(mddev->queue);
		mddev->queue = NULL;
N
NeilBrown 已提交
4299
		goto abort;
L
Linus Torvalds 已提交
4300
	}
4301
	disk->major = MAJOR(mddev->unit);
L
Linus Torvalds 已提交
4302
	disk->first_minor = unit << shift;
4303 4304 4305
	if (name)
		strcpy(disk->disk_name, name);
	else if (partitioned)
L
Linus Torvalds 已提交
4306
		sprintf(disk->disk_name, "md_d%d", unit);
4307
	else
L
Linus Torvalds 已提交
4308 4309 4310 4311
		sprintf(disk->disk_name, "md%d", unit);
	disk->fops = &md_fops;
	disk->private_data = mddev;
	disk->queue = mddev->queue;
4312
	/* Allow extended partitions.  This makes the
4313
	 * 'mdp' device redundant, but we can't really
4314 4315 4316
	 * remove it now.
	 */
	disk->flags |= GENHD_FL_EXT_DEVT;
L
Linus Torvalds 已提交
4317 4318
	add_disk(disk);
	mddev->gendisk = disk;
4319 4320
	error = kobject_init_and_add(&mddev->kobj, &md_ktype,
				     &disk_to_dev(disk)->kobj, "%s", "md");
N
NeilBrown 已提交
4321 4322 4323 4324
	if (error) {
		/* This isn't possible, but as kobject_init_and_add is marked
		 * __must_check, we must do something with the result
		 */
4325 4326
		printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
		       disk->disk_name);
N
NeilBrown 已提交
4327 4328
		error = 0;
	}
N
NeilBrown 已提交
4329 4330
	if (mddev->kobj.sd &&
	    sysfs_create_group(&mddev->kobj, &md_bitmap_group))
4331
		printk(KERN_DEBUG "pointless warning\n");
N
NeilBrown 已提交
4332 4333
 abort:
	mutex_unlock(&disks_mutex);
N
NeilBrown 已提交
4334
	if (!error && mddev->kobj.sd) {
4335
		kobject_uevent(&mddev->kobj, KOBJ_ADD);
N
NeilBrown 已提交
4336
		mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
4337
	}
4338
	mddev_put(mddev);
N
NeilBrown 已提交
4339
	return error;
4340 4341 4342 4343 4344
}

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

4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366
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 已提交
4367 4368 4369 4370
static void md_safemode_timeout(unsigned long data)
{
	mddev_t *mddev = (mddev_t *) data;

4371 4372 4373
	if (!atomic_read(&mddev->writes_pending)) {
		mddev->safemode = 1;
		if (mddev->external)
N
NeilBrown 已提交
4374
			sysfs_notify_dirent_safe(mddev->sysfs_state);
4375
	}
L
Linus Torvalds 已提交
4376 4377 4378
	md_wakeup_thread(mddev->thread);
}

4379
static int start_dirty_degraded;
L
Linus Torvalds 已提交
4380

4381
int md_run(mddev_t *mddev)
L
Linus Torvalds 已提交
4382
{
4383
	int err;
L
Linus Torvalds 已提交
4384
	mdk_rdev_t *rdev;
4385
	struct mdk_personality *pers;
L
Linus Torvalds 已提交
4386

4387 4388
	if (list_empty(&mddev->disks))
		/* cannot run an array with no devices.. */
L
Linus Torvalds 已提交
4389 4390 4391 4392
		return -EINVAL;

	if (mddev->pers)
		return -EBUSY;
4393 4394 4395
	/* Cannot run until previous stop completes properly */
	if (mddev->sysfs_active)
		return -EBUSY;
4396

L
Linus Torvalds 已提交
4397 4398 4399
	/*
	 * Analyze all RAID superblock(s)
	 */
4400 4401 4402
	if (!mddev->raid_disks) {
		if (!mddev->persistent)
			return -EINVAL;
4403
		analyze_sbs(mddev);
4404
	}
L
Linus Torvalds 已提交
4405

4406 4407 4408 4409
	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 已提交
4410 4411 4412 4413 4414 4415

	/*
	 * Drop all container device buffers, from now on
	 * the only valid external interface is through the md
	 * device.
	 */
4416
	list_for_each_entry(rdev, &mddev->disks, same_set) {
4417
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
4418 4419
			continue;
		sync_blockdev(rdev->bdev);
4420
		invalidate_bdev(rdev->bdev);
4421 4422 4423

		/* perform some consistency tests on the device.
		 * We don't want the data to overlap the metadata,
A
Andre Noll 已提交
4424
		 * Internal Bitmap issues have been handled elsewhere.
4425
		 */
4426
		if (rdev->data_offset < rdev->sb_start) {
A
Andre Noll 已提交
4427 4428
			if (mddev->dev_sectors &&
			    rdev->data_offset + mddev->dev_sectors
4429
			    > rdev->sb_start) {
4430 4431 4432 4433 4434
				printk("md: %s: data overlaps metadata\n",
				       mdname(mddev));
				return -EINVAL;
			}
		} else {
4435
			if (rdev->sb_start + rdev->sb_size/512
4436 4437 4438 4439 4440 4441
			    > rdev->data_offset) {
				printk("md: %s: metadata overlaps data\n",
				       mdname(mddev));
				return -EINVAL;
			}
		}
N
NeilBrown 已提交
4442
		sysfs_notify_dirent_safe(rdev->sysfs_state);
L
Linus Torvalds 已提交
4443 4444 4445
	}

	spin_lock(&pers_lock);
4446
	pers = find_pers(mddev->level, mddev->clevel);
4447
	if (!pers || !try_module_get(pers->owner)) {
L
Linus Torvalds 已提交
4448
		spin_unlock(&pers_lock);
4449 4450 4451 4452 4453 4454
		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 已提交
4455 4456
		return -EINVAL;
	}
4457
	mddev->pers = pers;
L
Linus Torvalds 已提交
4458
	spin_unlock(&pers_lock);
4459 4460 4461 4462
	if (mddev->level != pers->level) {
		mddev->level = pers->level;
		mddev->new_level = pers->level;
	}
4463
	strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
L
Linus Torvalds 已提交
4464

4465
	if (mddev->reshape_position != MaxSector &&
4466
	    pers->start_reshape == NULL) {
4467 4468 4469 4470 4471 4472
		/* This personality cannot handle reshaping... */
		mddev->pers = NULL;
		module_put(pers->owner);
		return -EINVAL;
	}

4473 4474 4475 4476 4477 4478 4479
	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;
4480 4481 4482

		list_for_each_entry(rdev, &mddev->disks, same_set)
			list_for_each_entry(rdev2, &mddev->disks, same_set) {
4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495
				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;
				}
			}
4496

4497 4498 4499 4500 4501 4502
		if (warned)
			printk(KERN_WARNING
			       "True protection against single-disk"
			       " failure might be compromised.\n");
	}

4503
	mddev->recovery = 0;
A
Andre Noll 已提交
4504 4505 4506
	/* may be over-ridden by personality */
	mddev->resync_max_sectors = mddev->dev_sectors;

4507
	mddev->barriers_work = 1;
4508
	mddev->ok_start_degraded = start_dirty_degraded;
L
Linus Torvalds 已提交
4509

4510
	if (start_readonly && mddev->ro == 0)
4511 4512
		mddev->ro = 2; /* read-only, but switch on first write */

4513
	err = mddev->pers->run(mddev);
4514 4515
	if (err)
		printk(KERN_ERR "md: pers->run() failed ...\n");
D
Dan Williams 已提交
4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526
	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) {
4527 4528 4529 4530 4531 4532 4533
		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 已提交
4534 4535 4536
	if (err) {
		module_put(mddev->pers->owner);
		mddev->pers = NULL;
4537 4538
		bitmap_destroy(mddev);
		return err;
L
Linus Torvalds 已提交
4539
	}
4540
	if (mddev->pers->sync_request) {
N
NeilBrown 已提交
4541 4542
		if (mddev->kobj.sd &&
		    sysfs_create_group(&mddev->kobj, &md_redundancy_group))
4543 4544 4545
			printk(KERN_WARNING
			       "md: cannot register extra attributes for %s\n",
			       mdname(mddev));
N
NeilBrown 已提交
4546
		mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
4547
	} else if (mddev->ro == 2) /* auto-readonly not meaningful */
4548 4549
		mddev->ro = 0;

L
Linus Torvalds 已提交
4550
 	atomic_set(&mddev->writes_pending,0);
4551 4552
	atomic_set(&mddev->max_corr_read_errors,
		   MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
L
Linus Torvalds 已提交
4553 4554 4555
	mddev->safemode = 0;
	mddev->safemode_timer.function = md_safemode_timeout;
	mddev->safemode_timer.data = (unsigned long) mddev;
4556
	mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
L
Linus Torvalds 已提交
4557
	mddev->in_sync = 1;
4558

4559
	list_for_each_entry(rdev, &mddev->disks, same_set)
4560 4561 4562
		if (rdev->raid_disk >= 0) {
			char nm[20];
			sprintf(nm, "rd%d", rdev->raid_disk);
4563
			if (sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
N
NeilBrown 已提交
4564
				/* failure here is OK */;
4565
		}
L
Linus Torvalds 已提交
4566 4567 4568
	
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	
4569 4570
	if (mddev->flags)
		md_update_sb(mddev, 0);
L
Linus Torvalds 已提交
4571

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

4575
	md_new_event(mddev);
N
NeilBrown 已提交
4576 4577
	sysfs_notify_dirent_safe(mddev->sysfs_state);
	sysfs_notify_dirent_safe(mddev->sysfs_action);
4578
	sysfs_notify(&mddev->kobj, NULL, "degraded");
L
Linus Torvalds 已提交
4579 4580
	return 0;
}
4581
EXPORT_SYMBOL_GPL(md_run);
L
Linus Torvalds 已提交
4582

4583 4584 4585 4586 4587 4588 4589
static int do_md_run(mddev_t *mddev)
{
	int err;

	err = md_run(mddev);
	if (err)
		goto out;
4590 4591 4592 4593 4594
	err = bitmap_load(mddev);
	if (err) {
		bitmap_destroy(mddev);
		goto out;
	}
4595 4596 4597 4598 4599 4600 4601
	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 已提交
4602 4603 4604 4605
static int restart_array(mddev_t *mddev)
{
	struct gendisk *disk = mddev->gendisk;

A
Andre Noll 已提交
4606
	/* Complain if it has no devices */
L
Linus Torvalds 已提交
4607
	if (list_empty(&mddev->disks))
A
Andre Noll 已提交
4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621
		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 已提交
4622
	sysfs_notify_dirent_safe(mddev->sysfs_state);
A
Andre Noll 已提交
4623
	return 0;
L
Linus Torvalds 已提交
4624 4625
}

4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642
/* 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;
}

4643
void restore_bitmap_write_access(struct file *file)
4644 4645 4646 4647 4648 4649 4650 4651
{
	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 已提交
4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673
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;
4674
	mddev->can_decrease_events = 0;
N
NeilBrown 已提交
4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692
	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->barriers_work = 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;
4693
	mddev->plug = NULL;
N
NeilBrown 已提交
4694 4695
}

4696
void md_stop_writes(mddev_t *mddev)
4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715
{
	if (mddev->sync_thread) {
		set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
		md_unregister_thread(mddev->sync_thread);
		mddev->sync_thread = NULL;
	}

	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);
	}
}
4716
EXPORT_SYMBOL_GPL(md_stop_writes);
4717

4718
void md_stop(mddev_t *mddev)
N
NeilBrown 已提交
4719 4720 4721 4722 4723 4724
{
	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 已提交
4725
	clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
N
NeilBrown 已提交
4726
}
4727
EXPORT_SYMBOL_GPL(md_stop);
N
NeilBrown 已提交
4728

4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746
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) {
		md_stop_writes(mddev);

		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 已提交
4747
		sysfs_notify_dirent_safe(mddev->sysfs_state);
4748 4749 4750 4751 4752 4753 4754
		err = 0;	
	}
out:
	mutex_unlock(&mddev->open_mutex);
	return err;
}

4755 4756 4757 4758
/* mode:
 *   0 - completely stop and dis-assemble array
 *   2 - stop but do not disassemble array
 */
4759
static int do_md_stop(mddev_t * mddev, int mode, int is_open)
L
Linus Torvalds 已提交
4760 4761
{
	struct gendisk *disk = mddev->gendisk;
4762
	mdk_rdev_t *rdev;
L
Linus Torvalds 已提交
4763

N
NeilBrown 已提交
4764
	mutex_lock(&mddev->open_mutex);
4765 4766
	if (atomic_read(&mddev->openers) > is_open ||
	    mddev->sysfs_active) {
4767
		printk("md: %s still in use.\n",mdname(mddev));
N
NeilBrown 已提交
4768 4769 4770
		mutex_unlock(&mddev->open_mutex);
		return -EBUSY;
	}
L
Linus Torvalds 已提交
4771

N
NeilBrown 已提交
4772
	if (mddev->pers) {
4773 4774
		if (mddev->ro)
			set_disk_ro(disk, 0);
4775

4776
		md_stop_writes(mddev);
4777 4778 4779 4780
		md_stop(mddev);
		mddev->queue->merge_bvec_fn = NULL;
		mddev->queue->unplug_fn = NULL;
		mddev->queue->backing_dev_info.congested_fn = NULL;
N
NeilBrown 已提交
4781

4782
		/* tell userspace to handle 'inactive' */
N
NeilBrown 已提交
4783
		sysfs_notify_dirent_safe(mddev->sysfs_state);
4784

4785 4786 4787 4788 4789 4790
		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);
			}
4791

4792
		set_capacity(disk, 0);
N
NeilBrown 已提交
4793
		mutex_unlock(&mddev->open_mutex);
4794
		revalidate_disk(disk);
4795

4796 4797
		if (mddev->ro)
			mddev->ro = 0;
N
NeilBrown 已提交
4798 4799
	} else
		mutex_unlock(&mddev->open_mutex);
L
Linus Torvalds 已提交
4800 4801 4802
	/*
	 * Free resources if final stop
	 */
4803
	if (mode == 0) {
L
Linus Torvalds 已提交
4804 4805
		printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));

4806
		bitmap_destroy(mddev);
4807 4808 4809 4810
		if (mddev->bitmap_info.file) {
			restore_bitmap_write_access(mddev->bitmap_info.file);
			fput(mddev->bitmap_info.file);
			mddev->bitmap_info.file = NULL;
4811
		}
4812
		mddev->bitmap_info.offset = 0;
4813

L
Linus Torvalds 已提交
4814 4815
		export_array(mddev);

N
NeilBrown 已提交
4816
		md_clean(mddev);
4817
		kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
4818 4819
		if (mddev->hold_active == UNTIL_STOP)
			mddev->hold_active = 0;
4820
	}
M
Martin K. Petersen 已提交
4821
	blk_integrity_unregister(disk);
4822
	md_new_event(mddev);
N
NeilBrown 已提交
4823
	sysfs_notify_dirent_safe(mddev->sysfs_state);
N
NeilBrown 已提交
4824
	return 0;
L
Linus Torvalds 已提交
4825 4826
}

J
Jeff Garzik 已提交
4827
#ifndef MODULE
L
Linus Torvalds 已提交
4828 4829 4830 4831 4832
static void autorun_array(mddev_t *mddev)
{
	mdk_rdev_t *rdev;
	int err;

4833
	if (list_empty(&mddev->disks))
L
Linus Torvalds 已提交
4834 4835 4836 4837
		return;

	printk(KERN_INFO "md: running: ");

4838
	list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
4839 4840 4841 4842 4843
		char b[BDEVNAME_SIZE];
		printk("<%s>", bdevname(rdev->bdev,b));
	}
	printk("\n");

4844
	err = do_md_run(mddev);
L
Linus Torvalds 已提交
4845 4846
	if (err) {
		printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
4847
		do_md_stop(mddev, 0, 0);
L
Linus Torvalds 已提交
4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864
	}
}

/*
 * 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)
{
4865
	mdk_rdev_t *rdev0, *rdev, *tmp;
L
Linus Torvalds 已提交
4866 4867 4868 4869 4870
	mddev_t *mddev;
	char b[BDEVNAME_SIZE];

	printk(KERN_INFO "md: autorun ...\n");
	while (!list_empty(&pending_raid_disks)) {
4871
		int unit;
L
Linus Torvalds 已提交
4872
		dev_t dev;
4873
		LIST_HEAD(candidates);
L
Linus Torvalds 已提交
4874 4875 4876 4877 4878 4879
		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);
4880
		rdev_for_each_list(rdev, tmp, &pending_raid_disks)
L
Linus Torvalds 已提交
4881 4882 4883 4884 4885 4886 4887 4888 4889 4890
			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.
		 */
4891 4892 4893 4894 4895 4896 4897 4898 4899
		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 已提交
4900 4901 4902 4903 4904 4905 4906
			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 已提交
4907 4908 4909 4910
		if (!mddev || !mddev->gendisk) {
			if (mddev)
				mddev_put(mddev);
			printk(KERN_ERR
L
Linus Torvalds 已提交
4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924
				"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));
4925
			mddev->persistent = 1;
4926
			rdev_for_each_list(rdev, tmp, &candidates) {
L
Linus Torvalds 已提交
4927 4928 4929 4930 4931 4932 4933 4934 4935 4936
				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...
		 */
4937
		rdev_for_each_list(rdev, tmp, &candidates) {
4938
			list_del_init(&rdev->same_set);
L
Linus Torvalds 已提交
4939
			export_rdev(rdev);
4940
		}
L
Linus Torvalds 已提交
4941 4942 4943 4944
		mddev_put(mddev);
	}
	printk(KERN_INFO "md: ... autorun DONE.\n");
}
J
Jeff Garzik 已提交
4945
#endif /* !MODULE */
L
Linus Torvalds 已提交
4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963

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;
4964
	int nr,working,insync,failed,spare;
L
Linus Torvalds 已提交
4965 4966
	mdk_rdev_t *rdev;

4967
	nr=working=insync=failed=spare=0;
4968
	list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
4969
		nr++;
4970
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
4971 4972 4973
			failed++;
		else {
			working++;
4974
			if (test_bit(In_sync, &rdev->flags))
4975
				insync++;	
L
Linus Torvalds 已提交
4976 4977 4978 4979 4980 4981 4982 4983 4984 4985
			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 已提交
4986 4987
	info.size          = mddev->dev_sectors / 2;
	if (info.size != mddev->dev_sectors / 2) /* overflow */
4988
		info.size = -1;
L
Linus Torvalds 已提交
4989 4990 4991 4992 4993 4994 4995 4996 4997
	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);
4998
	if (mddev->bitmap && mddev->bitmap_info.offset)
4999
		info.state = (1<<MD_SB_BITMAP_PRESENT);
5000
	info.active_disks  = insync;
L
Linus Torvalds 已提交
5001 5002 5003 5004 5005
	info.working_disks = working;
	info.failed_disks  = failed;
	info.spare_disks   = spare;

	info.layout        = mddev->layout;
5006
	info.chunk_size    = mddev->chunk_sectors << 9;
L
Linus Torvalds 已提交
5007 5008 5009 5010 5011 5012 5013

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

	return 0;
}

5014
static int get_bitmap_file(mddev_t * mddev, void __user * arg)
5015 5016 5017 5018 5019
{
	mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
	char *ptr, *buf = NULL;
	int err = -ENOMEM;

5020 5021 5022 5023
	if (md_allow_write(mddev))
		file = kmalloc(sizeof(*file), GFP_NOIO);
	else
		file = kmalloc(sizeof(*file), GFP_KERNEL);
5024

5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037
	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 已提交
5038 5039
	ptr = d_path(&mddev->bitmap->file->f_path, buf, sizeof(file->pathname));
	if (IS_ERR(ptr))
5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053
		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 已提交
5054 5055 5056 5057 5058 5059 5060 5061
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;

5062
	rdev = find_rdev_nr(mddev, info.number);
L
Linus Torvalds 已提交
5063 5064 5065 5066 5067
	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;
5068
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
5069
			info.state |= (1<<MD_DISK_FAULTY);
5070
		else if (test_bit(In_sync, &rdev->flags)) {
L
Linus Torvalds 已提交
5071 5072 5073
			info.state |= (1<<MD_DISK_ACTIVE);
			info.state |= (1<<MD_DISK_SYNC);
		}
5074 5075
		if (test_bit(WriteMostly, &rdev->flags))
			info.state |= (1<<MD_DISK_WRITEMOSTLY);
L
Linus Torvalds 已提交
5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109
	} 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);
5110
			err = super_types[mddev->major_version]
L
Linus Torvalds 已提交
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
				.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;
		}
5140 5141 5142 5143 5144
		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 已提交
5145 5146 5147 5148 5149 5150
		if (IS_ERR(rdev)) {
			printk(KERN_WARNING 
				"md: md_import_device returned %ld\n",
				PTR_ERR(rdev));
			return PTR_ERR(rdev);
		}
5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162
		/* set save_raid_disk if appropriate */
		if (!mddev->persistent) {
			if (info->state & (1<<MD_DISK_SYNC)  &&
			    info->raid_disk < mddev->raid_disks)
				rdev->raid_disk = info->raid_disk;
			else
				rdev->raid_disk = -1;
		} else
			super_types[mddev->major_version].
				validate_super(mddev, rdev);
		rdev->saved_raid_disk = rdev->raid_disk;

5163
		clear_bit(In_sync, &rdev->flags); /* just to be sure */
5164 5165
		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);
5166 5167
		else
			clear_bit(WriteMostly, &rdev->flags);
5168

L
Linus Torvalds 已提交
5169 5170
		rdev->raid_disk = -1;
		err = bind_rdev_to_array(rdev, mddev);
5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181
		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 已提交
5182 5183
		if (err)
			export_rdev(rdev);
5184
		else
N
NeilBrown 已提交
5185
			sysfs_notify_dirent_safe(rdev->sysfs_state);
5186

5187
		md_update_sb(mddev, 1);
5188 5189
		if (mddev->degraded)
			set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
5190
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5191
		md_wakeup_thread(mddev->thread);
L
Linus Torvalds 已提交
5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205
		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;
5206
		rdev = md_import_device(dev, -1, 0);
L
Linus Torvalds 已提交
5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219
		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)
5220 5221
			if (info->state & (1<<MD_DISK_SYNC))
				set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
5222

5223 5224 5225
		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);

L
Linus Torvalds 已提交
5226 5227
		if (!mddev->persistent) {
			printk(KERN_INFO "md: nonpersistent superblock ...\n");
5228
			rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
L
Linus Torvalds 已提交
5229
		} else 
5230
			rdev->sb_start = calc_dev_sboffset(rdev->bdev);
5231
		rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
5232

5233 5234 5235 5236 5237
		err = bind_rdev_to_array(rdev, mddev);
		if (err) {
			export_rdev(rdev);
			return err;
		}
L
Linus Torvalds 已提交
5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255
	}

	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);
5256
	md_update_sb(mddev, 1);
5257
	md_new_event(mddev);
L
Linus Torvalds 已提交
5258 5259 5260

	return 0;
busy:
5261
	printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
L
Linus Torvalds 已提交
5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287
		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;
	}

5288
	rdev = md_import_device(dev, -1, 0);
L
Linus Torvalds 已提交
5289 5290 5291 5292 5293 5294 5295 5296
	if (IS_ERR(rdev)) {
		printk(KERN_WARNING 
			"md: error, md_import_device() returned %ld\n",
			PTR_ERR(rdev));
		return -EINVAL;
	}

	if (mddev->persistent)
5297
		rdev->sb_start = calc_dev_sboffset(rdev->bdev);
L
Linus Torvalds 已提交
5298
	else
5299
		rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
L
Linus Torvalds 已提交
5300

5301
	rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
5302

5303
	if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
5304 5305 5306 5307 5308 5309
		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;
	}
5310
	clear_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
5311
	rdev->desc_nr = -1;
5312
	rdev->saved_raid_disk = -1;
5313 5314 5315
	err = bind_rdev_to_array(rdev, mddev);
	if (err)
		goto abort_export;
L
Linus Torvalds 已提交
5316 5317 5318 5319 5320 5321 5322 5323

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

	rdev->raid_disk = -1;

5324
	md_update_sb(mddev, 1);
L
Linus Torvalds 已提交
5325 5326 5327 5328 5329 5330 5331

	/*
	 * 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);
5332
	md_new_event(mddev);
L
Linus Torvalds 已提交
5333 5334 5335 5336 5337 5338 5339
	return 0;

abort_export:
	export_rdev(rdev);
	return err;
}

5340 5341 5342 5343
static int set_bitmap_file(mddev_t *mddev, int fd)
{
	int err;

5344 5345 5346 5347 5348 5349 5350
	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.. */
	}
5351 5352


5353 5354 5355
	if (fd >= 0) {
		if (mddev->bitmap)
			return -EEXIST; /* cannot add when bitmap is present */
5356
		mddev->bitmap_info.file = fget(fd);
5357

5358
		if (mddev->bitmap_info.file == NULL) {
5359 5360 5361 5362 5363
			printk(KERN_ERR "%s: error: failed to get bitmap file\n",
			       mdname(mddev));
			return -EBADF;
		}

5364
		err = deny_bitmap_write_access(mddev->bitmap_info.file);
5365 5366 5367
		if (err) {
			printk(KERN_ERR "%s: error: bitmap file is already in use\n",
			       mdname(mddev));
5368 5369
			fput(mddev->bitmap_info.file);
			mddev->bitmap_info.file = NULL;
5370 5371
			return err;
		}
5372
		mddev->bitmap_info.offset = 0; /* file overrides offset */
5373 5374 5375 5376 5377
	} else if (mddev->bitmap == NULL)
		return -ENOENT; /* cannot remove what isn't there */
	err = 0;
	if (mddev->pers) {
		mddev->pers->quiesce(mddev, 1);
5378
		if (fd >= 0) {
5379
			err = bitmap_create(mddev);
5380 5381 5382
			if (!err)
				err = bitmap_load(mddev);
		}
5383
		if (fd < 0 || err) {
5384
			bitmap_destroy(mddev);
5385 5386
			fd = -1; /* make sure to put the file */
		}
5387
		mddev->pers->quiesce(mddev, 0);
5388 5389
	}
	if (fd < 0) {
5390 5391 5392
		if (mddev->bitmap_info.file) {
			restore_bitmap_write_access(mddev->bitmap_info.file);
			fput(mddev->bitmap_info.file);
5393
		}
5394
		mddev->bitmap_info.file = NULL;
5395 5396
	}

5397 5398 5399
	return err;
}

L
Linus Torvalds 已提交
5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418
/*
 * 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 ||
5419
		    info->major_version >= ARRAY_SIZE(super_types) ||
L
Linus Torvalds 已提交
5420 5421 5422 5423 5424 5425 5426 5427 5428 5429
		    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;
5430
		mddev->persistent = !info->not_persistent;
5431 5432 5433 5434
		/* ensure mddev_put doesn't delete this now that there
		 * is some minimal configuration.
		 */
		mddev->ctime         = get_seconds();
L
Linus Torvalds 已提交
5435 5436 5437 5438 5439 5440 5441 5442
		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;
5443
	mddev->clevel[0]     = 0;
A
Andre Noll 已提交
5444
	mddev->dev_sectors   = 2 * (sector_t)info->size;
L
Linus Torvalds 已提交
5445 5446 5447 5448 5449 5450 5451 5452 5453
	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;
5454
	mddev->external	     = 0;
L
Linus Torvalds 已提交
5455 5456

	mddev->layout        = info->layout;
5457
	mddev->chunk_sectors = info->chunk_size >> 9;
L
Linus Torvalds 已提交
5458 5459 5460

	mddev->max_disks     = MD_SB_DISKS;

5461 5462
	if (mddev->persistent)
		mddev->flags         = 0;
5463
	set_bit(MD_CHANGE_DEVS, &mddev->flags);
L
Linus Torvalds 已提交
5464

5465 5466
	mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
	mddev->bitmap_info.offset = 0;
5467

5468 5469
	mddev->reshape_position = MaxSector;

L
Linus Torvalds 已提交
5470 5471 5472 5473 5474
	/*
	 * Generate a 128 bit UUID
	 */
	get_random_bytes(mddev->uuid, 16);

5475
	mddev->new_level = mddev->level;
5476
	mddev->new_chunk_sectors = mddev->chunk_sectors;
5477 5478 5479
	mddev->new_layout = mddev->layout;
	mddev->delta_disks = 0;

L
Linus Torvalds 已提交
5480 5481 5482
	return 0;
}

5483 5484
void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors)
{
D
Dan Williams 已提交
5485 5486 5487 5488 5489
	WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);

	if (mddev->external_size)
		return;

5490 5491 5492 5493
	mddev->array_sectors = array_sectors;
}
EXPORT_SYMBOL(md_set_array_sectors);

5494
static int update_size(mddev_t *mddev, sector_t num_sectors)
5495
{
5496
	mdk_rdev_t *rdev;
5497
	int rv;
5498
	int fit = (num_sectors == 0);
5499 5500 5501

	if (mddev->pers->resize == NULL)
		return -EINVAL;
5502 5503 5504 5505 5506
	/* 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
5507
	 * sb_start or, if that is <data_offset, it must fit before the size
5508 5509 5510
	 * of each device.  If num_sectors is zero, we find the largest size
	 * that fits.

5511 5512 5513
	 */
	if (mddev->sync_thread)
		return -EBUSY;
5514 5515 5516 5517 5518
	if (mddev->bitmap)
		/* Sorry, cannot grow a bitmap yet, just remove it,
		 * grow, and re-add.
		 */
		return -EBUSY;
5519
	list_for_each_entry(rdev, &mddev->disks, same_set) {
5520
		sector_t avail = rdev->sectors;
5521

5522 5523 5524
		if (fit && (num_sectors == 0 || num_sectors > avail))
			num_sectors = avail;
		if (avail < num_sectors)
5525 5526
			return -ENOSPC;
	}
5527
	rv = mddev->pers->resize(mddev, num_sectors);
5528 5529
	if (!rv)
		revalidate_disk(mddev->gendisk);
5530 5531 5532
	return rv;
}

5533 5534 5535 5536
static int update_raid_disks(mddev_t *mddev, int raid_disks)
{
	int rv;
	/* change the number of raid disks */
5537
	if (mddev->pers->check_reshape == NULL)
5538 5539
		return -EINVAL;
	if (raid_disks <= 0 ||
5540
	    (mddev->max_disks && raid_disks >= mddev->max_disks))
5541
		return -EINVAL;
5542
	if (mddev->sync_thread || mddev->reshape_position != MaxSector)
5543
		return -EBUSY;
5544 5545 5546
	mddev->delta_disks = raid_disks - mddev->raid_disks;

	rv = mddev->pers->check_reshape(mddev);
5547 5548 5549 5550
	return rv;
}


L
Linus Torvalds 已提交
5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562
/*
 * 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;
5563 5564 5565
	int state = 0;

	/* calculate expected state,ignoring low bits */
5566
	if (mddev->bitmap && mddev->bitmap_info.offset)
5567
		state |= (1 << MD_SB_BITMAP_PRESENT);
L
Linus Torvalds 已提交
5568 5569 5570 5571 5572 5573 5574 5575

	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||
5576
	    mddev->chunk_sectors != info->chunk_size >> 9 ||
5577 5578 5579
	    /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
	    ((state^info->state) & 0xfffffe00)
		)
L
Linus Torvalds 已提交
5580 5581
		return -EINVAL;
	/* Check there is only one change */
A
Andre Noll 已提交
5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593
	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 已提交
5594 5595 5596 5597 5598 5599

	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.
		 */
5600
		if (mddev->pers->check_reshape == NULL)
L
Linus Torvalds 已提交
5601
			return -EINVAL;
5602 5603
		else {
			mddev->new_layout = info->layout;
5604
			rv = mddev->pers->check_reshape(mddev);
5605 5606 5607 5608
			if (rv)
				mddev->new_layout = mddev->layout;
			return rv;
		}
L
Linus Torvalds 已提交
5609
	}
A
Andre Noll 已提交
5610
	if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
5611
		rv = update_size(mddev, (sector_t)info->size * 2);
5612

5613 5614 5615
	if (mddev->raid_disks    != info->raid_disks)
		rv = update_raid_disks(mddev, info->raid_disks);

5616 5617 5618 5619 5620 5621 5622 5623 5624
	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;
5625
			if (mddev->bitmap_info.default_offset == 0)
5626
				return -EINVAL;
5627 5628
			mddev->bitmap_info.offset =
				mddev->bitmap_info.default_offset;
5629 5630
			mddev->pers->quiesce(mddev, 1);
			rv = bitmap_create(mddev);
5631 5632
			if (!rv)
				rv = bitmap_load(mddev);
5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644
			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);
5645
			mddev->bitmap_info.offset = 0;
5646 5647
		}
	}
5648
	md_update_sb(mddev, 1);
L
Linus Torvalds 已提交
5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666
	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;
}

5667 5668 5669 5670 5671 5672
/*
 * 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... ;-)
 */
5673 5674 5675 5676 5677 5678
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;
5679
	geo->cylinders = mddev->array_sectors / 8;
5680 5681 5682
	return 0;
}

A
Al Viro 已提交
5683
static int md_ioctl(struct block_device *bdev, fmode_t mode,
L
Linus Torvalds 已提交
5684 5685 5686 5687 5688
			unsigned int cmd, unsigned long arg)
{
	int err = 0;
	void __user *argp = (void __user *)arg;
	mddev_t *mddev = NULL;
5689
	int ro;
L
Linus Torvalds 已提交
5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721

	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 已提交
5722
	mddev = bdev->bd_disk->private_data;
L
Linus Torvalds 已提交
5723 5724 5725 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 5758 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

	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:
	 */
5786
	/* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
5787
	 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
5788 5789 5790 5791
	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 已提交
5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804
		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;

5805
		case GET_BITMAP_FILE:
5806
			err = get_bitmap_file(mddev, argp);
5807 5808
			goto done_unlock;

L
Linus Torvalds 已提交
5809 5810 5811 5812 5813 5814 5815 5816 5817
		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:
5818
			err = do_md_stop(mddev, 0, 1);
L
Linus Torvalds 已提交
5819 5820 5821
			goto done_unlock;

		case STOP_ARRAY_RO:
5822
			err = md_set_readonly(mddev, 1);
L
Linus Torvalds 已提交
5823 5824
			goto done_unlock;

5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852
		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 已提交
5853 5854 5855 5856
	}

	/*
	 * The remaining ioctls are changing the state of the
5857 5858 5859 5860
	 * 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 已提交
5861
	 */
5862
	if (_IOC_TYPE(cmd) == MD_MAJOR && mddev->ro && mddev->pers) {
5863 5864
		if (mddev->ro == 2) {
			mddev->ro = 0;
N
NeilBrown 已提交
5865
			sysfs_notify_dirent_safe(mddev->sysfs_state);
5866 5867
			set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
			md_wakeup_thread(mddev->thread);
5868 5869 5870 5871
		} else {
			err = -EROFS;
			goto abort_unlock;
		}
L
Linus Torvalds 已提交
5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898
	}

	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:
5899
			err = do_md_run(mddev);
L
Linus Torvalds 已提交
5900 5901
			goto done_unlock;

5902 5903 5904 5905
		case SET_BITMAP_FILE:
			err = set_bitmap_file(mddev, (int)arg);
			goto done_unlock;

L
Linus Torvalds 已提交
5906 5907 5908 5909 5910 5911 5912
		default:
			err = -EINVAL;
			goto abort_unlock;
	}

done_unlock:
abort_unlock:
5913 5914 5915
	if (mddev->hold_active == UNTIL_IOCTL &&
	    err != -EINVAL)
		mddev->hold_active = 0;
L
Linus Torvalds 已提交
5916 5917 5918 5919 5920 5921 5922 5923 5924
	mddev_unlock(mddev);

	return err;
done:
	if (err)
		MD_BUG();
abort:
	return err;
}
5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943
#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 已提交
5944

A
Al Viro 已提交
5945
static int md_open(struct block_device *bdev, fmode_t mode)
L
Linus Torvalds 已提交
5946 5947 5948 5949 5950
{
	/*
	 * Succeed if we can lock the mddev, which confirms that
	 * it isn't being stopped right now.
	 */
5951
	mddev_t *mddev = mddev_find(bdev->bd_dev);
L
Linus Torvalds 已提交
5952 5953
	int err;

5954
	lock_kernel();
5955 5956 5957 5958 5959 5960 5961 5962
	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 */
		flush_scheduled_work();
		/* Then retry the open from the top */
5963
		unlock_kernel();
5964 5965 5966 5967
		return -ERESTARTSYS;
	}
	BUG_ON(mddev != bdev->bd_disk->private_data);

N
NeilBrown 已提交
5968
	if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
L
Linus Torvalds 已提交
5969 5970 5971
		goto out;

	err = 0;
5972
	atomic_inc(&mddev->openers);
N
NeilBrown 已提交
5973
	mutex_unlock(&mddev->open_mutex);
L
Linus Torvalds 已提交
5974

5975
	check_disk_size_change(mddev->gendisk, bdev);
L
Linus Torvalds 已提交
5976
 out:
5977
	unlock_kernel();
L
Linus Torvalds 已提交
5978 5979 5980
	return err;
}

A
Al Viro 已提交
5981
static int md_release(struct gendisk *disk, fmode_t mode)
L
Linus Torvalds 已提交
5982
{
A
Al Viro 已提交
5983
 	mddev_t *mddev = disk->private_data;
L
Linus Torvalds 已提交
5984

E
Eric Sesterhenn 已提交
5985
	BUG_ON(!mddev);
5986
	lock_kernel();
5987
	atomic_dec(&mddev->openers);
L
Linus Torvalds 已提交
5988
	mddev_put(mddev);
5989
	unlock_kernel();
L
Linus Torvalds 已提交
5990 5991 5992

	return 0;
}
5993
static const struct block_device_operations md_fops =
L
Linus Torvalds 已提交
5994 5995
{
	.owner		= THIS_MODULE,
A
Al Viro 已提交
5996 5997
	.open		= md_open,
	.release	= md_release,
N
NeilBrown 已提交
5998
	.ioctl		= md_ioctl,
5999 6000 6001
#ifdef CONFIG_COMPAT
	.compat_ioctl	= md_compat_ioctl,
#endif
6002
	.getgeo		= md_getgeo,
L
Linus Torvalds 已提交
6003 6004
};

A
Adrian Bunk 已提交
6005
static int md_thread(void * arg)
L
Linus Torvalds 已提交
6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020
{
	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 已提交
6021
	allow_signal(SIGKILL);
6022
	while (!kthread_should_stop()) {
L
Linus Torvalds 已提交
6023

6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036
		/* 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 已提交
6037 6038 6039

		clear_bit(THREAD_WAKEUP, &thread->flags);

6040
		thread->run(thread->mddev);
L
Linus Torvalds 已提交
6041
	}
6042

L
Linus Torvalds 已提交
6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059
	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;

6060
	thread = kzalloc(sizeof(mdk_thread_t), GFP_KERNEL);
L
Linus Torvalds 已提交
6061 6062 6063 6064 6065 6066 6067
	if (!thread)
		return NULL;

	init_waitqueue_head(&thread->wqueue);

	thread->run = run;
	thread->mddev = mddev;
6068
	thread->timeout = MAX_SCHEDULE_TIMEOUT;
6069 6070 6071 6072
	thread->tsk = kthread_run(md_thread, thread,
				  "%s_%s",
				  mdname(thread->mddev),
				  name ?: mddev->pers->name);
6073
	if (IS_ERR(thread->tsk)) {
L
Linus Torvalds 已提交
6074 6075 6076 6077 6078 6079 6080 6081
		kfree(thread);
		return NULL;
	}
	return thread;
}

void md_unregister_thread(mdk_thread_t *thread)
{
6082 6083
	if (!thread)
		return;
6084
	dprintk("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
6085 6086

	kthread_stop(thread->tsk);
L
Linus Torvalds 已提交
6087 6088 6089 6090 6091 6092 6093 6094 6095 6096
	kfree(thread);
}

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

6097
	if (!rdev || test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
6098
		return;
6099 6100 6101

	if (mddev->external)
		set_bit(Blocked, &rdev->flags);
6102
/*
L
Linus Torvalds 已提交
6103 6104 6105 6106 6107
	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));
6108
*/
6109 6110
	if (!mddev->pers)
		return;
L
Linus Torvalds 已提交
6111 6112 6113
	if (!mddev->pers->error_handler)
		return;
	mddev->pers->error_handler(mddev,rdev);
6114 6115
	if (mddev->degraded)
		set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
N
NeilBrown 已提交
6116
	sysfs_notify_dirent_safe(rdev->sysfs_state);
L
Linus Torvalds 已提交
6117 6118 6119
	set_bit(MD_RECOVERY_INTR, &mddev->recovery);
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	md_wakeup_thread(mddev->thread);
6120 6121
	if (mddev->event_work.func)
		schedule_work(&mddev->event_work);
6122
	md_new_event_inintr(mddev);
L
Linus Torvalds 已提交
6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133
}

/* 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: ");

6134
	list_for_each_entry(rdev, &pending_raid_disks, same_set) {
L
Linus Torvalds 已提交
6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148
		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)
{
6149 6150 6151
	sector_t max_sectors, resync, res;
	unsigned long dt, db;
	sector_t rt;
6152 6153
	int scale;
	unsigned int per_milli;
L
Linus Torvalds 已提交
6154

6155
	resync = mddev->curr_resync - atomic_read(&mddev->recovery_active);
L
Linus Torvalds 已提交
6156 6157

	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
6158
		max_sectors = mddev->resync_max_sectors;
L
Linus Torvalds 已提交
6159
	else
6160
		max_sectors = mddev->dev_sectors;
L
Linus Torvalds 已提交
6161 6162 6163 6164

	/*
	 * Should not happen.
	 */
6165
	if (!max_sectors) {
L
Linus Torvalds 已提交
6166 6167 6168
		MD_BUG();
		return;
	}
6169
	/* Pick 'scale' such that (resync>>scale)*1000 will fit
6170
	 * in a sector_t, and (max_sectors>>scale) will fit in a
6171 6172 6173 6174 6175
	 * 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)) {
6176
		while ( max_sectors/2 > (1ULL<<(scale+32)))
6177 6178 6179
			scale++;
	}
	res = (resync>>scale)*1000;
6180
	sector_div(res, (u32)((max_sectors>>scale)+1));
6181 6182

	per_milli = res;
L
Linus Torvalds 已提交
6183
	{
6184
		int i, x = per_milli/50, y = 20-x;
L
Linus Torvalds 已提交
6185 6186 6187 6188 6189 6190 6191 6192
		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, "] ");
	}
6193
	seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
6194 6195
		   (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
		    "reshape" :
6196 6197 6198 6199 6200
		    (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
		     "check" :
		     (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
		      "resync" : "recovery"))),
		   per_milli/10, per_milli % 10,
6201 6202
		   (unsigned long long) resync/2,
		   (unsigned long long) max_sectors/2);
L
Linus Torvalds 已提交
6203 6204 6205 6206 6207

	/*
	 * dt: time from mark until now
	 * db: blocks written from mark until now
	 * rt: remaining time
6208 6209 6210 6211 6212 6213 6214 6215 6216
	 *
	 * 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 已提交
6217 6218 6219
	 */
	dt = ((jiffies - mddev->resync_mark) / HZ);
	if (!dt) dt++;
6220 6221
	db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
		- mddev->resync_mark_cnt;
L
Linus Torvalds 已提交
6222

6223 6224 6225 6226 6227 6228 6229
	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 已提交
6230

6231
	seq_printf(seq, " speed=%ldK/sec", db/2/dt);
L
Linus Torvalds 已提交
6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 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
}

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

6296 6297 6298 6299
struct mdstat_info {
	int event;
};

L
Linus Torvalds 已提交
6300 6301 6302
static int md_seq_show(struct seq_file *seq, void *v)
{
	mddev_t *mddev = v;
6303
	sector_t sectors;
L
Linus Torvalds 已提交
6304
	mdk_rdev_t *rdev;
6305
	struct mdstat_info *mi = seq->private;
6306
	struct bitmap *bitmap;
L
Linus Torvalds 已提交
6307 6308

	if (v == (void*)1) {
6309
		struct mdk_personality *pers;
L
Linus Torvalds 已提交
6310 6311
		seq_printf(seq, "Personalities : ");
		spin_lock(&pers_lock);
6312 6313
		list_for_each_entry(pers, &pers_list, list)
			seq_printf(seq, "[%s] ", pers->name);
L
Linus Torvalds 已提交
6314 6315 6316

		spin_unlock(&pers_lock);
		seq_printf(seq, "\n");
6317
		mi->event = atomic_read(&md_event_count);
L
Linus Torvalds 已提交
6318 6319 6320 6321 6322 6323 6324
		return 0;
	}
	if (v == (void*)2) {
		status_unused(seq);
		return 0;
	}

I
Ingo Molnar 已提交
6325
	if (mddev_lock(mddev) < 0)
L
Linus Torvalds 已提交
6326
		return -EINTR;
I
Ingo Molnar 已提交
6327

L
Linus Torvalds 已提交
6328 6329 6330 6331
	if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
		seq_printf(seq, "%s : %sactive", mdname(mddev),
						mddev->pers ? "" : "in");
		if (mddev->pers) {
6332
			if (mddev->ro==1)
L
Linus Torvalds 已提交
6333
				seq_printf(seq, " (read-only)");
6334
			if (mddev->ro==2)
6335
				seq_printf(seq, " (auto-read-only)");
L
Linus Torvalds 已提交
6336 6337 6338
			seq_printf(seq, " %s", mddev->pers->name);
		}

6339
		sectors = 0;
6340
		list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
6341 6342 6343
			char b[BDEVNAME_SIZE];
			seq_printf(seq, " %s[%d]",
				bdevname(rdev->bdev,b), rdev->desc_nr);
6344 6345
			if (test_bit(WriteMostly, &rdev->flags))
				seq_printf(seq, "(W)");
6346
			if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
6347 6348
				seq_printf(seq, "(F)");
				continue;
6349 6350
			} else if (rdev->raid_disk < 0)
				seq_printf(seq, "(S)"); /* spare */
6351
			sectors += rdev->sectors;
L
Linus Torvalds 已提交
6352 6353 6354 6355 6356
		}

		if (!list_empty(&mddev->disks)) {
			if (mddev->pers)
				seq_printf(seq, "\n      %llu blocks",
6357 6358
					   (unsigned long long)
					   mddev->array_sectors / 2);
L
Linus Torvalds 已提交
6359 6360
			else
				seq_printf(seq, "\n      %llu blocks",
6361
					   (unsigned long long)sectors / 2);
L
Linus Torvalds 已提交
6362
		}
6363 6364 6365 6366 6367 6368 6369
		if (mddev->persistent) {
			if (mddev->major_version != 0 ||
			    mddev->minor_version != 90) {
				seq_printf(seq," super %d.%d",
					   mddev->major_version,
					   mddev->minor_version);
			}
6370 6371 6372 6373
		} else if (mddev->external)
			seq_printf(seq, " super external:%s",
				   mddev->metadata_type);
		else
6374
			seq_printf(seq, " super non-persistent");
L
Linus Torvalds 已提交
6375 6376

		if (mddev->pers) {
6377
			mddev->pers->status(seq, mddev);
L
Linus Torvalds 已提交
6378
	 		seq_printf(seq, "\n      ");
6379 6380
			if (mddev->pers->sync_request) {
				if (mddev->curr_resync > 2) {
6381
					status_resync(seq, mddev);
6382 6383 6384 6385 6386 6387
					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      ");
			}
6388 6389 6390 6391 6392 6393 6394
		} else
			seq_printf(seq, "\n       ");

		if ((bitmap = mddev->bitmap)) {
			unsigned long chunk_kb;
			unsigned long flags;
			spin_lock_irqsave(&bitmap->lock, flags);
6395
			chunk_kb = mddev->bitmap_info.chunksize >> 10;
6396 6397 6398 6399 6400 6401
			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),
6402
				chunk_kb ? chunk_kb : mddev->bitmap_info.chunksize,
6403
				chunk_kb ? "KB" : "B");
6404 6405
			if (bitmap->file) {
				seq_printf(seq, ", file: ");
6406
				seq_path(seq, &bitmap->file->f_path, " \t\n");
6407
			}
6408

6409 6410
			seq_printf(seq, "\n");
			spin_unlock_irqrestore(&bitmap->lock, flags);
L
Linus Torvalds 已提交
6411 6412 6413 6414 6415 6416 6417 6418 6419
		}

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

J
Jan Engelhardt 已提交
6420
static const struct seq_operations md_seq_ops = {
L
Linus Torvalds 已提交
6421 6422 6423 6424 6425 6426 6427 6428 6429
	.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;
6430 6431 6432
	struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL);
	if (mi == NULL)
		return -ENOMEM;
L
Linus Torvalds 已提交
6433 6434

	error = seq_open(file, &md_seq_ops);
6435 6436 6437 6438 6439 6440 6441
	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 已提交
6442 6443 6444
	return error;
}

6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460
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;
}

6461
static const struct file_operations md_seq_fops = {
6462
	.owner		= THIS_MODULE,
L
Linus Torvalds 已提交
6463 6464 6465
	.open           = md_seq_open,
	.read           = seq_read,
	.llseek         = seq_lseek,
6466
	.release	= seq_release_private,
6467
	.poll		= mdstat_poll,
L
Linus Torvalds 已提交
6468 6469
};

6470
int register_md_personality(struct mdk_personality *p)
L
Linus Torvalds 已提交
6471 6472
{
	spin_lock(&pers_lock);
6473 6474
	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 已提交
6475 6476 6477 6478
	spin_unlock(&pers_lock);
	return 0;
}

6479
int unregister_md_personality(struct mdk_personality *p)
L
Linus Torvalds 已提交
6480
{
6481
	printk(KERN_INFO "md: %s personality unregistered\n", p->name);
L
Linus Torvalds 已提交
6482
	spin_lock(&pers_lock);
6483
	list_del_init(&p->list);
L
Linus Torvalds 已提交
6484 6485 6486 6487
	spin_unlock(&pers_lock);
	return 0;
}

N
NeilBrown 已提交
6488
static int is_mddev_idle(mddev_t *mddev, int init)
L
Linus Torvalds 已提交
6489 6490 6491
{
	mdk_rdev_t * rdev;
	int idle;
N
NeilBrown 已提交
6492
	int curr_events;
L
Linus Torvalds 已提交
6493 6494

	idle = 1;
6495 6496
	rcu_read_lock();
	rdev_for_each_rcu(rdev, mddev) {
L
Linus Torvalds 已提交
6497
		struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
N
NeilBrown 已提交
6498 6499 6500
		curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
			      (int)part_stat_read(&disk->part0, sectors[1]) -
			      atomic_read(&disk->sync_io);
6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520
		/* 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.
6521
		 *
L
Linus Torvalds 已提交
6522
		 */
N
NeilBrown 已提交
6523
		if (init || curr_events - rdev->last_events > 64) {
L
Linus Torvalds 已提交
6524 6525 6526 6527
			rdev->last_events = curr_events;
			idle = 0;
		}
	}
6528
	rcu_read_unlock();
L
Linus Torvalds 已提交
6529 6530 6531 6532 6533 6534 6535 6536 6537
	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) {
6538
		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
L
Linus Torvalds 已提交
6539 6540 6541 6542 6543 6544
		md_wakeup_thread(mddev->thread);
		// stop recovery, signal do_sync ....
	}
}


6545 6546
/* md_write_start(mddev, bi)
 * If we need to update some array metadata (e.g. 'active' flag
6547 6548
 * in superblock) before writing, schedule a superblock update
 * and wait for it to complete.
6549
 */
6550
void md_write_start(mddev_t *mddev, struct bio *bi)
L
Linus Torvalds 已提交
6551
{
6552
	int did_change = 0;
6553
	if (bio_data_dir(bi) != WRITE)
6554
		return;
6555

6556 6557 6558 6559 6560 6561
	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);
6562
		md_wakeup_thread(mddev->sync_thread);
6563
		did_change = 1;
6564
	}
6565
	atomic_inc(&mddev->writes_pending);
6566 6567
	if (mddev->safemode == 1)
		mddev->safemode = 0;
6568
	if (mddev->in_sync) {
6569
		spin_lock_irq(&mddev->write_lock);
6570 6571
		if (mddev->in_sync) {
			mddev->in_sync = 0;
6572
			set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6573
			set_bit(MD_CHANGE_PENDING, &mddev->flags);
6574
			md_wakeup_thread(mddev->thread);
6575
			did_change = 1;
6576
		}
6577
		spin_unlock_irq(&mddev->write_lock);
6578
	}
6579
	if (did_change)
N
NeilBrown 已提交
6580
		sysfs_notify_dirent_safe(mddev->sysfs_state);
6581 6582
	wait_event(mddev->sb_wait,
		   !test_bit(MD_CHANGE_PENDING, &mddev->flags));
L
Linus Torvalds 已提交
6583 6584 6585 6586 6587 6588 6589
}

void md_write_end(mddev_t *mddev)
{
	if (atomic_dec_and_test(&mddev->writes_pending)) {
		if (mddev->safemode == 2)
			md_wakeup_thread(mddev->thread);
6590
		else if (mddev->safemode_delay)
L
Linus Torvalds 已提交
6591 6592 6593 6594
			mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
	}
}

6595 6596 6597 6598 6599
/* 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.
6600 6601 6602
 *
 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
 * is dropped, so return -EAGAIN after notifying userspace.
6603
 */
6604
int md_allow_write(mddev_t *mddev)
6605 6606
{
	if (!mddev->pers)
6607
		return 0;
6608
	if (mddev->ro)
6609
		return 0;
6610
	if (!mddev->pers->sync_request)
6611
		return 0;
6612 6613 6614 6615 6616

	spin_lock_irq(&mddev->write_lock);
	if (mddev->in_sync) {
		mddev->in_sync = 0;
		set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6617
		set_bit(MD_CHANGE_PENDING, &mddev->flags);
6618 6619 6620 6621 6622
		if (mddev->safemode_delay &&
		    mddev->safemode == 0)
			mddev->safemode = 1;
		spin_unlock_irq(&mddev->write_lock);
		md_update_sb(mddev, 0);
N
NeilBrown 已提交
6623
		sysfs_notify_dirent_safe(mddev->sysfs_state);
6624 6625
	} else
		spin_unlock_irq(&mddev->write_lock);
6626

6627
	if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
6628 6629 6630
		return -EAGAIN;
	else
		return 0;
6631 6632 6633
}
EXPORT_SYMBOL_GPL(md_allow_write);

N
NeilBrown 已提交
6634
void md_unplug(mddev_t *mddev)
6635 6636 6637 6638 6639 6640 6641
{
	if (mddev->queue)
		blk_unplug(mddev->queue);
	if (mddev->plug)
		mddev->plug->unplug_fn(mddev->plug);
}

L
Linus Torvalds 已提交
6642 6643
#define SYNC_MARKS	10
#define	SYNC_MARK_STEP	(3*HZ)
6644
void md_do_sync(mddev_t *mddev)
L
Linus Torvalds 已提交
6645 6646 6647 6648
{
	mddev_t *mddev2;
	unsigned int currspeed = 0,
		 window;
6649
	sector_t max_sectors,j, io_sectors;
L
Linus Torvalds 已提交
6650 6651 6652 6653 6654
	unsigned long mark[SYNC_MARKS];
	sector_t mark_cnt[SYNC_MARKS];
	int last_mark,m;
	struct list_head *tmp;
	sector_t last_check;
6655
	int skipped = 0;
6656
	mdk_rdev_t *rdev;
6657
	char *desc;
L
Linus Torvalds 已提交
6658 6659 6660 6661

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

6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676
	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 已提交
6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696
	/* 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:
6697
		if (kthread_should_stop())
N
NeilBrown 已提交
6698
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6699 6700

		if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
L
Linus Torvalds 已提交
6701
			goto skip;
6702
		for_each_mddev(mddev2, tmp) {
L
Linus Torvalds 已提交
6703 6704
			if (mddev2 == mddev)
				continue;
6705 6706 6707
			if (!mddev->parallel_resync
			&&  mddev2->curr_resync
			&&  match_mddev_units(mddev, mddev2)) {
L
Linus Torvalds 已提交
6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718
				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;
6719 6720 6721 6722 6723
				/* 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);
6724
				if (!kthread_should_stop() &&
6725
				    mddev2->curr_resync >= mddev->curr_resync) {
6726 6727
					printk(KERN_INFO "md: delaying %s of %s"
					       " until %s has finished (they"
L
Linus Torvalds 已提交
6728
					       " share one or more physical units)\n",
6729
					       desc, mdname(mddev), mdname(mddev2));
L
Linus Torvalds 已提交
6730
					mddev_put(mddev2);
6731 6732
					if (signal_pending(current))
						flush_signals(current);
L
Linus Torvalds 已提交
6733 6734 6735 6736 6737 6738 6739 6740 6741
					schedule();
					finish_wait(&resync_wait, &wq);
					goto try_again;
				}
				finish_wait(&resync_wait, &wq);
			}
		}
	} while (mddev->curr_resync < 2);

6742
	j = 0;
6743
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
L
Linus Torvalds 已提交
6744
		/* resync follows the size requested by the personality,
6745
		 * which defaults to physical size, but can be virtual size
L
Linus Torvalds 已提交
6746 6747
		 */
		max_sectors = mddev->resync_max_sectors;
6748
		mddev->resync_mismatches = 0;
6749
		/* we don't use the checkpoint if there's a bitmap */
6750 6751 6752
		if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
			j = mddev->resync_min;
		else if (!mddev->bitmap)
6753
			j = mddev->recovery_cp;
6754

6755
	} else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
A
Andre Noll 已提交
6756
		max_sectors = mddev->dev_sectors;
6757
	else {
L
Linus Torvalds 已提交
6758
		/* recovery follows the physical size of devices */
A
Andre Noll 已提交
6759
		max_sectors = mddev->dev_sectors;
6760
		j = MaxSector;
6761 6762
		rcu_read_lock();
		list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
6763 6764 6765 6766 6767
			if (rdev->raid_disk >= 0 &&
			    !test_bit(Faulty, &rdev->flags) &&
			    !test_bit(In_sync, &rdev->flags) &&
			    rdev->recovery_offset < j)
				j = rdev->recovery_offset;
6768
		rcu_read_unlock();
6769
	}
L
Linus Torvalds 已提交
6770

6771 6772 6773
	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));
6774
	printk(KERN_INFO "md: using maximum available idle IO bandwidth "
6775 6776
	       "(but not more than %d KB/sec) for %s.\n",
	       speed_max(mddev), desc);
L
Linus Torvalds 已提交
6777

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

6780
	io_sectors = 0;
L
Linus Torvalds 已提交
6781 6782
	for (m = 0; m < SYNC_MARKS; m++) {
		mark[m] = jiffies;
6783
		mark_cnt[m] = io_sectors;
L
Linus Torvalds 已提交
6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800
	}
	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 
6801 6802
		       "md: resuming %s of %s from checkpoint.\n",
		       desc, mdname(mddev));
L
Linus Torvalds 已提交
6803 6804
		mddev->curr_resync = j;
	}
6805
	mddev->curr_resync_completed = mddev->curr_resync;
L
Linus Torvalds 已提交
6806 6807

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

6810
		skipped = 0;
6811

6812 6813 6814 6815 6816 6817 6818
		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
			    )) {
6819
			/* time to update curr_resync_completed */
6820
			md_unplug(mddev);
6821 6822 6823 6824
			wait_event(mddev->recovery_wait,
				   atomic_read(&mddev->recovery_active) == 0);
			mddev->curr_resync_completed =
				mddev->curr_resync;
6825
			set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6826
			sysfs_notify(&mddev->kobj, NULL, "sync_completed");
6827
		}
6828

6829 6830 6831 6832 6833 6834 6835 6836 6837 6838
		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());
		}
6839 6840 6841 6842

		if (kthread_should_stop())
			goto interrupted;

6843
		sectors = mddev->pers->sync_request(mddev, j, &skipped,
6844
						  currspeed < speed_min(mddev));
6845
		if (sectors == 0) {
6846
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
L
Linus Torvalds 已提交
6847 6848
			goto out;
		}
6849 6850 6851 6852 6853 6854

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

L
Linus Torvalds 已提交
6855 6856
		j += sectors;
		if (j>1) mddev->curr_resync = j;
6857
		mddev->curr_mark_cnt = io_sectors;
6858 6859 6860 6861 6862
		if (last_check == 0)
			/* this is the earliers that rebuilt will be
			 * visible in /proc/mdstat
			 */
			md_new_event(mddev);
6863 6864

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

6867
		last_check = io_sectors;
L
Linus Torvalds 已提交
6868

6869
		if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
L
Linus Torvalds 已提交
6870 6871 6872 6873 6874 6875 6876 6877 6878 6879
			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;
6880
			mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
L
Linus Torvalds 已提交
6881 6882 6883 6884
			last_mark = next;
		}


6885 6886 6887
		if (kthread_should_stop())
			goto interrupted;

L
Linus Torvalds 已提交
6888 6889 6890 6891 6892 6893 6894 6895 6896

		/*
		 * 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)
		 */
6897
		md_unplug(mddev);
L
Linus Torvalds 已提交
6898 6899
		cond_resched();

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

6903 6904
		if (currspeed > speed_min(mddev)) {
			if ((currspeed > speed_max(mddev)) ||
N
NeilBrown 已提交
6905
					!is_mddev_idle(mddev, 0)) {
6906
				msleep(500);
L
Linus Torvalds 已提交
6907 6908 6909 6910
				goto repeat;
			}
		}
	}
6911
	printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc);
L
Linus Torvalds 已提交
6912 6913 6914 6915
	/*
	 * this also signals 'finished resyncing' to md_stop
	 */
 out:
6916
	md_unplug(mddev);
L
Linus Torvalds 已提交
6917 6918 6919 6920

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

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

6923
	if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
6924 6925 6926 6927 6928
	    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
6929 6930
					       "md: checkpointing %s of %s.\n",
					       desc, mdname(mddev));
6931 6932 6933 6934 6935 6936 6937
					mddev->recovery_cp = mddev->curr_resync;
				}
			} else
				mddev->recovery_cp = MaxSector;
		} else {
			if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
				mddev->curr_resync = MaxSector;
6938 6939
			rcu_read_lock();
			list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
6940
				if (rdev->raid_disk >= 0 &&
6941
				    mddev->delta_disks >= 0 &&
6942 6943 6944 6945
				    !test_bit(Faulty, &rdev->flags) &&
				    !test_bit(In_sync, &rdev->flags) &&
				    rdev->recovery_offset < mddev->curr_resync)
					rdev->recovery_offset = mddev->curr_resync;
6946
			rcu_read_unlock();
6947
		}
L
Linus Torvalds 已提交
6948
	}
6949
	set_bit(MD_CHANGE_DEVS, &mddev->flags);
L
Linus Torvalds 已提交
6950 6951

 skip:
6952 6953 6954 6955 6956 6957 6958
	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 已提交
6959
	mddev->curr_resync = 0;
6960 6961
	if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
		mddev->curr_resync_completed = 0;
6962
	sysfs_notify(&mddev->kobj, NULL, "sync_completed");
L
Linus Torvalds 已提交
6963 6964 6965
	wake_up(&resync_wait);
	set_bit(MD_RECOVERY_DONE, &mddev->recovery);
	md_wakeup_thread(mddev->thread);
6966 6967 6968 6969 6970 6971 6972 6973 6974 6975 6976
	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 已提交
6977
}
6978
EXPORT_SYMBOL_GPL(md_do_sync);
L
Linus Torvalds 已提交
6979 6980


6981 6982 6983 6984 6985
static int remove_and_add_spares(mddev_t *mddev)
{
	mdk_rdev_t *rdev;
	int spares = 0;

6986 6987
	mddev->curr_resync_completed = 0;

6988
	list_for_each_entry(rdev, &mddev->disks, same_set)
6989
		if (rdev->raid_disk >= 0 &&
6990
		    !test_bit(Blocked, &rdev->flags) &&
6991 6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002
		    (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;
			}
		}

7003
	if (mddev->degraded && ! mddev->ro && !mddev->recovery_disabled) {
7004
		list_for_each_entry(rdev, &mddev->disks, same_set) {
7005
			if (rdev->raid_disk >= 0 &&
7006 7007
			    !test_bit(In_sync, &rdev->flags) &&
			    !test_bit(Blocked, &rdev->flags))
7008
				spares++;
7009 7010 7011
			if (rdev->raid_disk < 0
			    && !test_bit(Faulty, &rdev->flags)) {
				rdev->recovery_offset = 0;
7012 7013
				if (mddev->pers->
				    hot_add_disk(mddev, rdev) == 0) {
7014 7015
					char nm[20];
					sprintf(nm, "rd%d", rdev->raid_disk);
7016 7017
					if (sysfs_create_link(&mddev->kobj,
							      &rdev->kobj, nm))
N
NeilBrown 已提交
7018
						/* failure here is OK */;
7019 7020
					spares++;
					md_new_event(mddev);
7021
					set_bit(MD_CHANGE_DEVS, &mddev->flags);
7022 7023 7024
				} else
					break;
			}
7025
		}
7026 7027 7028
	}
	return spares;
}
L
Linus Torvalds 已提交
7029 7030 7031 7032 7033 7034 7035 7036 7037 7038
/*
 * 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.
7039
 * When the thread finishes it sets MD_RECOVERY_DONE
L
Linus Torvalds 已提交
7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055
 * 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)
{
	mdk_rdev_t *rdev;


7056
	if (mddev->bitmap)
7057
		bitmap_daemon_work(mddev);
L
Linus Torvalds 已提交
7058 7059 7060

	if (mddev->ro)
		return;
7061 7062

	if (signal_pending(current)) {
7063
		if (mddev->pers->sync_request && !mddev->external) {
7064 7065 7066 7067 7068 7069 7070
			printk(KERN_INFO "md: %s in immediate safe mode\n",
			       mdname(mddev));
			mddev->safemode = 2;
		}
		flush_signals(current);
	}

7071 7072
	if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
		return;
L
Linus Torvalds 已提交
7073
	if ( ! (
7074
		(mddev->flags & ~ (1<<MD_CHANGE_PENDING)) ||
L
Linus Torvalds 已提交
7075
		test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
7076
		test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
7077
		(mddev->external == 0 && mddev->safemode == 1) ||
7078 7079
		(mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
		 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
L
Linus Torvalds 已提交
7080 7081
		))
		return;
7082

7083
	if (mddev_trylock(mddev)) {
7084
		int spares = 0;
7085

7086 7087 7088 7089 7090 7091 7092 7093 7094
		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;
		}

7095
		if (!mddev->external) {
7096
			int did_change = 0;
7097 7098 7099 7100 7101 7102
			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;
7103
				did_change = 1;
7104
				set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7105 7106 7107 7108
			}
			if (mddev->safemode == 1)
				mddev->safemode = 0;
			spin_unlock_irq(&mddev->write_lock);
7109
			if (did_change)
N
NeilBrown 已提交
7110
				sysfs_notify_dirent_safe(mddev->sysfs_state);
7111 7112
		}

7113 7114
		if (mddev->flags)
			md_update_sb(mddev, 0);
7115

L
Linus Torvalds 已提交
7116 7117 7118 7119 7120 7121 7122 7123 7124 7125
		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) {
			/* resync has finished, collect result */
			md_unregister_thread(mddev->sync_thread);
			mddev->sync_thread = NULL;
7126 7127
			if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
			    !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
L
Linus Torvalds 已提交
7128 7129
				/* success...*/
				/* activate any spares */
7130 7131 7132
				if (mddev->pers->spare_active(mddev))
					sysfs_notify(&mddev->kobj, NULL,
						     "degraded");
L
Linus Torvalds 已提交
7133
			}
7134 7135 7136
			if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
			    mddev->pers->finish_reshape)
				mddev->pers->finish_reshape(mddev);
7137
			md_update_sb(mddev, 1);
7138 7139 7140 7141 7142

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

L
Linus Torvalds 已提交
7146 7147 7148
			mddev->recovery = 0;
			/* flag recovery needed just to double check */
			set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
N
NeilBrown 已提交
7149
			sysfs_notify_dirent_safe(mddev->sysfs_action);
7150
			md_new_event(mddev);
L
Linus Torvalds 已提交
7151 7152
			goto unlock;
		}
7153 7154 7155 7156 7157
		/* 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);
7158 7159 7160 7161 7162
		/* 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 已提交
7163

7164 7165
		if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
			goto unlock;
L
Linus Torvalds 已提交
7166 7167 7168 7169 7170 7171 7172
		/* 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.
		 */

7173
		if (mddev->reshape_position != MaxSector) {
7174 7175
			if (mddev->pers->check_reshape == NULL ||
			    mddev->pers->check_reshape(mddev) != 0)
7176 7177 7178
				/* Cannot proceed */
				goto unlock;
			set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7179
			clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7180
		} else if ((spares = remove_and_add_spares(mddev))) {
7181 7182
			clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
			clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
7183
			clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
7184
			set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7185 7186
		} else if (mddev->recovery_cp < MaxSector) {
			set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7187
			clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7188 7189
		} else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
			/* nothing to be done ... */
L
Linus Torvalds 已提交
7190
			goto unlock;
7191

L
Linus Torvalds 已提交
7192
		if (mddev->pers->sync_request) {
7193 7194 7195 7196 7197 7198 7199
			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 已提交
7200 7201
			mddev->sync_thread = md_register_thread(md_do_sync,
								mddev,
7202
								"resync");
L
Linus Torvalds 已提交
7203 7204 7205 7206 7207 7208
			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 */
				mddev->recovery = 0;
7209
			} else
L
Linus Torvalds 已提交
7210
				md_wakeup_thread(mddev->sync_thread);
N
NeilBrown 已提交
7211
			sysfs_notify_dirent_safe(mddev->sysfs_action);
7212
			md_new_event(mddev);
L
Linus Torvalds 已提交
7213 7214
		}
	unlock:
7215 7216 7217 7218
		if (!mddev->sync_thread) {
			clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
			if (test_and_clear_bit(MD_RECOVERY_RECOVER,
					       &mddev->recovery))
7219
				if (mddev->sysfs_action)
N
NeilBrown 已提交
7220
					sysfs_notify_dirent_safe(mddev->sysfs_action);
7221
		}
L
Linus Torvalds 已提交
7222 7223 7224 7225
		mddev_unlock(mddev);
	}
}

7226 7227
void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
{
N
NeilBrown 已提交
7228
	sysfs_notify_dirent_safe(rdev->sysfs_state);
7229 7230 7231 7232 7233 7234 7235
	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 已提交
7236 7237
static int md_notify_reboot(struct notifier_block *this,
			    unsigned long code, void *x)
L
Linus Torvalds 已提交
7238 7239 7240 7241 7242 7243 7244 7245
{
	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");

7246
		for_each_mddev(mddev, tmp)
7247
			if (mddev_trylock(mddev)) {
7248 7249 7250 7251
				/* Force a switch to readonly even array
				 * appears to still be in use.  Hence
				 * the '100'.
				 */
7252
				md_set_readonly(mddev, 100);
7253 7254
				mddev_unlock(mddev);
			}
L
Linus Torvalds 已提交
7255 7256 7257 7258 7259 7260 7261 7262 7263 7264 7265
		/*
		 * 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 已提交
7266
static struct notifier_block md_notifier = {
L
Linus Torvalds 已提交
7267 7268 7269 7270 7271 7272 7273 7274 7275
	.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));

7276
	proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
L
Linus Torvalds 已提交
7277 7278
}

A
Adrian Bunk 已提交
7279
static int __init md_init(void)
L
Linus Torvalds 已提交
7280
{
C
Christoph Hellwig 已提交
7281
	if (register_blkdev(MD_MAJOR, "md"))
L
Linus Torvalds 已提交
7282 7283
		return -1;
	if ((mdp_major=register_blkdev(0, "mdp"))<=0) {
C
Christoph Hellwig 已提交
7284
		unregister_blkdev(MD_MAJOR, "md");
L
Linus Torvalds 已提交
7285 7286
		return -1;
	}
C
Christoph Hellwig 已提交
7287
	blk_register_region(MKDEV(MD_MAJOR, 0), 1UL<<MINORBITS, THIS_MODULE,
7288 7289
			    md_probe, NULL, NULL);
	blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
L
Linus Torvalds 已提交
7290 7291 7292
			    md_probe, NULL, NULL);

	register_reboot_notifier(&md_notifier);
7293
	raid_table_header = register_sysctl_table(raid_root_table);
L
Linus Torvalds 已提交
7294 7295

	md_geninit();
7296
	return 0;
L
Linus Torvalds 已提交
7297 7298 7299 7300 7301 7302 7303 7304 7305
}


#ifndef MODULE

/*
 * Searches all registered partitions for autorun RAID arrays
 * at boot time.
 */
7306 7307 7308 7309 7310 7311

static LIST_HEAD(all_detected_devices);
struct detected_devices_node {
	struct list_head list;
	dev_t dev;
};
L
Linus Torvalds 已提交
7312 7313 7314

void md_autodetect_dev(dev_t dev)
{
7315 7316 7317 7318 7319 7320 7321 7322 7323 7324
	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 已提交
7325 7326 7327 7328 7329 7330
}


static void autostart_arrays(int part)
{
	mdk_rdev_t *rdev;
7331 7332 7333
	struct detected_devices_node *node_detected_dev;
	dev_t dev;
	int i_scanned, i_passed;
L
Linus Torvalds 已提交
7334

7335 7336
	i_scanned = 0;
	i_passed = 0;
L
Linus Torvalds 已提交
7337

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

7340 7341 7342 7343 7344 7345 7346
	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);
7347
		rdev = md_import_device(dev,0, 90);
L
Linus Torvalds 已提交
7348 7349 7350
		if (IS_ERR(rdev))
			continue;

7351
		if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
7352 7353 7354
			MD_BUG();
			continue;
		}
7355
		set_bit(AutoDetected, &rdev->flags);
L
Linus Torvalds 已提交
7356
		list_add(&rdev->same_set, &pending_raid_disks);
7357
		i_passed++;
L
Linus Torvalds 已提交
7358
	}
7359 7360 7361

	printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
						i_scanned, i_passed);
L
Linus Torvalds 已提交
7362 7363 7364 7365

	autorun_devices(part);
}

J
Jeff Garzik 已提交
7366
#endif /* !MODULE */
L
Linus Torvalds 已提交
7367 7368 7369 7370 7371

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

C
Christoph Hellwig 已提交
7373
	blk_unregister_region(MKDEV(MD_MAJOR,0), 1U << MINORBITS);
7374
	blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
L
Linus Torvalds 已提交
7375

C
Christoph Hellwig 已提交
7376
	unregister_blkdev(MD_MAJOR,"md");
L
Linus Torvalds 已提交
7377 7378 7379 7380
	unregister_blkdev(mdp_major, "mdp");
	unregister_reboot_notifier(&md_notifier);
	unregister_sysctl_table(raid_table_header);
	remove_proc_entry("mdstat", NULL);
7381
	for_each_mddev(mddev, tmp) {
L
Linus Torvalds 已提交
7382
		export_array(mddev);
7383
		mddev->hold_active = 0;
L
Linus Torvalds 已提交
7384 7385 7386
	}
}

7387
subsys_initcall(md_init);
L
Linus Torvalds 已提交
7388 7389
module_exit(md_exit)

7390 7391 7392 7393 7394 7395 7396 7397 7398 7399
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;
7400
		return 0;
7401 7402 7403 7404
	}
	return -EINVAL;
}

7405 7406
module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
7407

7408
module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
7409

L
Linus Torvalds 已提交
7410 7411 7412 7413 7414 7415 7416 7417 7418 7419 7420
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");
7421
MODULE_DESCRIPTION("MD RAID framework");
7422
MODULE_ALIAS("md");
7423
MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);