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

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

   Changes:

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

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

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

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

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

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

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

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

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

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

67 68
static void md_print_devices(void);

69 70
static DECLARE_WAIT_QUEUE_HEAD(resync_wait);

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

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

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

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

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

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

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

148 149
static int start_readonly;

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

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

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


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

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

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

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

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

	return rv;
}

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

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

282 283 284 285 286 287
int mddev_congested(mddev_t *mddev, int bits)
{
	return mddev->suspended;
}
EXPORT_SYMBOL(mddev_congested);

288
/*
T
Tejun Heo 已提交
289
 * Generic flush handling for md
290 291
 */

T
Tejun Heo 已提交
292
static void md_end_flush(struct bio *bio, int err)
293 294 295 296 297 298 299
{
	mdk_rdev_t *rdev = bio->bi_private;
	mddev_t *mddev = rdev->mddev;

	rdev_dec_pending(rdev, mddev);

	if (atomic_dec_and_test(&mddev->flush_pending)) {
T
Tejun Heo 已提交
300 301
		/* The pre-request flush has finished */
		schedule_work(&mddev->flush_work);
302 303 304 305
	}
	bio_put(bio);
}

T
Tejun Heo 已提交
306
static void submit_flushes(mddev_t *mddev)
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
{
	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);
T
Tejun Heo 已提交
323
			bi->bi_end_io = md_end_flush;
324 325 326
			bi->bi_private = rdev;
			bi->bi_bdev = rdev->bdev;
			atomic_inc(&mddev->flush_pending);
T
Tejun Heo 已提交
327
			submit_bio(WRITE_FLUSH, bi);
328 329 330 331 332 333
			rcu_read_lock();
			rdev_dec_pending(rdev, mddev);
		}
	rcu_read_unlock();
}

T
Tejun Heo 已提交
334
static void md_submit_flush_data(struct work_struct *ws)
335
{
T
Tejun Heo 已提交
336 337
	mddev_t *mddev = container_of(ws, mddev_t, flush_work);
	struct bio *bio = mddev->flush_bio;
338 339 340

	atomic_set(&mddev->flush_pending, 1);

T
Tejun Heo 已提交
341
	if (bio->bi_size == 0)
342 343 344
		/* an empty barrier - all done */
		bio_endio(bio, 0);
	else {
T
Tejun Heo 已提交
345
		bio->bi_rw &= ~REQ_FLUSH;
346
		if (mddev->pers->make_request(mddev, bio))
347 348 349
			generic_make_request(bio);
	}
	if (atomic_dec_and_test(&mddev->flush_pending)) {
T
Tejun Heo 已提交
350
		mddev->flush_bio = NULL;
351 352 353 354
		wake_up(&mddev->sb_wait);
	}
}

T
Tejun Heo 已提交
355
void md_flush_request(mddev_t *mddev, struct bio *bio)
356 357 358
{
	spin_lock_irq(&mddev->write_lock);
	wait_event_lock_irq(mddev->sb_wait,
T
Tejun Heo 已提交
359
			    !mddev->flush_bio,
360
			    mddev->write_lock, /*nothing*/);
T
Tejun Heo 已提交
361
	mddev->flush_bio = bio;
362 363 364
	spin_unlock_irq(&mddev->write_lock);

	atomic_set(&mddev->flush_pending, 1);
T
Tejun Heo 已提交
365
	INIT_WORK(&mddev->flush_work, md_submit_flush_data);
366

T
Tejun Heo 已提交
367
	submit_flushes(mddev);
368 369

	if (atomic_dec_and_test(&mddev->flush_pending))
T
Tejun Heo 已提交
370
		schedule_work(&mddev->flush_work);
371
}
T
Tejun Heo 已提交
372
EXPORT_SYMBOL(md_flush_request);
373

374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 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
/* 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 已提交
419 420 421 422 423 424
static inline mddev_t *mddev_get(mddev_t *mddev)
{
	atomic_inc(&mddev->active);
	return mddev;
}

425
static void mddev_delayed_delete(struct work_struct *ws);
426

L
Linus Torvalds 已提交
427 428 429 430
static void mddev_put(mddev_t *mddev)
{
	if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
		return;
431
	if (!mddev->raid_disks && list_empty(&mddev->disks) &&
432 433 434
	    mddev->ctime == 0 && !mddev->hold_active) {
		/* Array is not configured at all, and not held active,
		 * so destroy it */
L
Linus Torvalds 已提交
435
		list_del(&mddev->all_mddevs);
436 437 438 439 440 441 442 443 444 445 446 447 448
		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 已提交
449 450
}

451
void mddev_init(mddev_t *mddev)
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
{
	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;
}
471
EXPORT_SYMBOL_GPL(mddev_init);
472

L
Linus Torvalds 已提交
473 474 475 476 477 478
static mddev_t * mddev_find(dev_t unit)
{
	mddev_t *mddev, *new = NULL;

 retry:
	spin_lock(&all_mddevs_lock);
479 480 481 482 483 484 485 486 487 488 489 490

	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 已提交
491
			spin_unlock(&all_mddevs_lock);
492 493
			new->hold_active = UNTIL_IOCTL;
			return new;
L
Linus Torvalds 已提交
494
		}
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
	} 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 已提交
523 524 525 526 527 528
		list_add(&new->all_mddevs, &all_mddevs);
		spin_unlock(&all_mddevs_lock);
		return new;
	}
	spin_unlock(&all_mddevs_lock);

529
	new = kzalloc(sizeof(*new), GFP_KERNEL);
L
Linus Torvalds 已提交
530 531 532 533 534 535 536 537 538
	if (!new)
		return NULL;

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

539
	mddev_init(new);
L
Linus Torvalds 已提交
540 541 542 543 544 545

	goto retry;
}

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

D
Dan Williams 已提交
549 550 551 552 553
static inline int mddev_is_locked(mddev_t *mddev)
{
	return mutex_is_locked(&mddev->reconfig_mutex);
}

L
Linus Torvalds 已提交
554 555
static inline int mddev_trylock(mddev_t * mddev)
{
556
	return mutex_trylock(&mddev->reconfig_mutex);
L
Linus Torvalds 已提交
557 558
}

559 560
static struct attribute_group md_redundancy_group;

561
static void mddev_unlock(mddev_t * mddev)
L
Linus Torvalds 已提交
562
{
563
	if (mddev->to_remove) {
564 565 566 567
		/* 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.
568 569 570 571 572 573 574
		 * 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.
575
		 */
576 577
		struct attribute_group *to_remove = mddev->to_remove;
		mddev->to_remove = NULL;
578
		mddev->sysfs_active = 1;
579 580
		mutex_unlock(&mddev->reconfig_mutex);

N
NeilBrown 已提交
581 582 583 584 585 586 587 588 589 590
		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;
			}
591
		}
592
		mddev->sysfs_active = 0;
593 594
	} else
		mutex_unlock(&mddev->reconfig_mutex);
L
Linus Torvalds 已提交
595

596
	md_wakeup_thread(mddev->thread);
L
Linus Torvalds 已提交
597 598
}

599
static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
L
Linus Torvalds 已提交
600
{
601
	mdk_rdev_t *rdev;
L
Linus Torvalds 已提交
602

603
	list_for_each_entry(rdev, &mddev->disks, same_set)
L
Linus Torvalds 已提交
604 605
		if (rdev->desc_nr == nr)
			return rdev;
606

L
Linus Torvalds 已提交
607 608 609 610 611 612 613
	return NULL;
}

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

614
	list_for_each_entry(rdev, &mddev->disks, same_set)
L
Linus Torvalds 已提交
615 616
		if (rdev->bdev->bd_dev == dev)
			return rdev;
617

L
Linus Torvalds 已提交
618 619 620
	return NULL;
}

621
static struct mdk_personality *find_pers(int level, char *clevel)
622 623
{
	struct mdk_personality *pers;
624 625
	list_for_each_entry(pers, &pers_list, list) {
		if (level != LEVEL_NONE && pers->level == level)
626
			return pers;
627 628 629
		if (strcmp(pers->name, clevel)==0)
			return pers;
	}
630 631 632
	return NULL;
}

633
/* return the offset of the super block in 512byte sectors */
634
static inline sector_t calc_dev_sboffset(struct block_device *bdev)
L
Linus Torvalds 已提交
635
{
636 637
	sector_t num_sectors = bdev->bd_inode->i_size / 512;
	return MD_NEW_SIZE_SECTORS(num_sectors);
L
Linus Torvalds 已提交
638 639 640 641 642 643 644 645 646 647
}

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");
648
		return -ENOMEM;
L
Linus Torvalds 已提交
649 650 651 652 653 654 655 656
	}

	return 0;
}

static void free_disk_sb(mdk_rdev_t * rdev)
{
	if (rdev->sb_page) {
657
		put_page(rdev->sb_page);
L
Linus Torvalds 已提交
658 659
		rdev->sb_loaded = 0;
		rdev->sb_page = NULL;
660
		rdev->sb_start = 0;
661
		rdev->sectors = 0;
L
Linus Torvalds 已提交
662 663 664 665
	}
}


666
static void super_written(struct bio *bio, int error)
667 668
{
	mdk_rdev_t *rdev = bio->bi_private;
669
	mddev_t *mddev = rdev->mddev;
670

671 672 673 674
	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));
675
		md_error(mddev, rdev);
676
	}
677

678 679
	if (atomic_dec_and_test(&mddev->pending_writes))
		wake_up(&mddev->sb_wait);
N
Neil Brown 已提交
680
	bio_put(bio);
681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
}

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
	 */
	struct bio *bio = bio_alloc(GFP_NOIO, 1);

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

700
	atomic_inc(&mddev->pending_writes);
T
Tejun Heo 已提交
701 702
	submit_bio(REQ_WRITE | REQ_SYNC | REQ_UNPLUG | REQ_FLUSH | REQ_FUA,
		   bio);
703 704 705 706
}

void md_super_wait(mddev_t *mddev)
{
T
Tejun Heo 已提交
707
	/* wait for all superblock writes that were scheduled to complete */
708 709 710 711 712 713 714 715
	DEFINE_WAIT(wq);
	for(;;) {
		prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
		if (atomic_read(&mddev->pending_writes)==0)
			break;
		schedule();
	}
	finish_wait(&mddev->sb_wait, &wq);
716 717
}

718
static void bi_complete(struct bio *bio, int error)
L
Linus Torvalds 已提交
719 720 721 722
{
	complete((struct completion*)bio->bi_private);
}

723
int sync_page_io(struct block_device *bdev, sector_t sector, int size,
L
Linus Torvalds 已提交
724 725
		   struct page *page, int rw)
{
726
	struct bio *bio = bio_alloc(GFP_NOIO, 1);
L
Linus Torvalds 已提交
727 728 729
	struct completion event;
	int ret;

730
	rw |= REQ_SYNC | REQ_UNPLUG;
L
Linus Torvalds 已提交
731 732 733 734 735 736 737 738 739 740 741 742 743 744

	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;
}
745
EXPORT_SYMBOL_GPL(sync_page_io);
L
Linus Torvalds 已提交
746

747
static int read_disk_sb(mdk_rdev_t * rdev, int size)
L
Linus Torvalds 已提交
748 749 750 751 752 753 754 755 756 757
{
	char b[BDEVNAME_SIZE];
	if (!rdev->sb_page) {
		MD_BUG();
		return -EINVAL;
	}
	if (rdev->sb_loaded)
		return 0;


758
	if (!sync_page_io(rdev->bdev, rdev->sb_start, size, rdev->sb_page, READ))
L
Linus Torvalds 已提交
759 760 761 762 763 764 765 766 767 768 769 770
		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 已提交
771 772 773 774
	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 已提交
775 776 777 778 779 780 781 782 783 784 785 786
}

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;
787
		printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
L
Linus Torvalds 已提交
788 789 790 791 792 793 794 795 796 797 798 799
		goto abort;
	}

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

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

A
Andre Noll 已提交
800
	ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
L
Linus Torvalds 已提交
801
abort:
802 803
	kfree(tmp1);
	kfree(tmp2);
L
Linus Torvalds 已提交
804 805 806
	return ret;
}

807 808 809 810 811 812 813

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

L
Linus Torvalds 已提交
814 815
static unsigned int calc_sb_csum(mdp_super_t * sb)
{
816 817 818
	u64 newcsum = 0;
	u32 *sb32 = (u32*)sb;
	int i;
L
Linus Torvalds 已提交
819 820 821 822
	unsigned int disk_csum, csum;

	disk_csum = sb->sb_csum;
	sb->sb_csum = 0;
823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839

	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 已提交
840
	sb->sb_csum = disk_csum;
841
#endif
L
Linus Torvalds 已提交
842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876
	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  {
877 878 879 880 881 882 883
	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,
884
						sector_t num_sectors);
L
Linus Torvalds 已提交
885 886
};

887 888 889 890 891 892 893 894 895 896
/*
 * 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)
{
897
	if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
898 899 900 901 902 903 904
		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 已提交
905 906 907 908 909 910 911 912 913 914
/*
 * 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;

	/*
915
	 * Calculate the position of the superblock (512byte sectors),
L
Linus Torvalds 已提交
916 917 918 919
	 * it's at the end of the disk.
	 *
	 * It also happens to be a multiple of 4Kb.
	 */
920
	rdev->sb_start = calc_dev_sboffset(rdev->bdev);
L
Linus Torvalds 已提交
921

922
	ret = read_disk_sb(rdev, MD_SB_BYTES);
L
Linus Torvalds 已提交
923 924 925 926 927 928 929 930 931 932 933 934 935 936
	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 ||
937 938
	    sb->minor_version < 90 ||
	    sb->minor_version > 91) {
L
Linus Torvalds 已提交
939 940 941 942 943 944 945 946 947
		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;

948
	if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
L
Linus Torvalds 已提交
949 950 951 952 953 954 955
		printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
			b);
		goto abort;
	}

	rdev->preferred_minor = sb->md_minor;
	rdev->data_offset = 0;
956
	rdev->sb_size = MD_SB_BYTES;
L
Linus Torvalds 已提交
957 958 959 960 961 962

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

963
	if (!refdev) {
L
Linus Torvalds 已提交
964
		ret = 1;
965
	} else {
L
Linus Torvalds 已提交
966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
		__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;
	}
986
	rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
987

988
	if (rdev->sectors < sb->size * 2 && sb->level > 1)
989 990 991
		/* "this cannot possibly happen" ... */
		ret = -EINVAL;

L
Linus Torvalds 已提交
992 993 994 995 996 997 998 999 1000 1001 1002
 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);
1003
	__u64 ev1 = md_event(sb);
L
Linus Torvalds 已提交
1004

1005
	rdev->raid_disk = -1;
1006 1007 1008 1009
	clear_bit(Faulty, &rdev->flags);
	clear_bit(In_sync, &rdev->flags);
	clear_bit(WriteMostly, &rdev->flags);

L
Linus Torvalds 已提交
1010 1011 1012 1013
	if (mddev->raid_disks == 0) {
		mddev->major_version = 0;
		mddev->minor_version = sb->minor_version;
		mddev->patch_version = sb->patch_version;
1014
		mddev->external = 0;
1015
		mddev->chunk_sectors = sb->chunk_size >> 9;
L
Linus Torvalds 已提交
1016 1017 1018
		mddev->ctime = sb->ctime;
		mddev->utime = sb->utime;
		mddev->level = sb->level;
1019
		mddev->clevel[0] = 0;
L
Linus Torvalds 已提交
1020 1021
		mddev->layout = sb->layout;
		mddev->raid_disks = sb->raid_disks;
A
Andre Noll 已提交
1022
		mddev->dev_sectors = sb->size * 2;
1023
		mddev->events = ev1;
1024 1025
		mddev->bitmap_info.offset = 0;
		mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
L
Linus Torvalds 已提交
1026

1027 1028 1029 1030 1031
		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;
1032
			mddev->new_chunk_sectors = sb->new_chunk >> 9;
1033 1034 1035 1036 1037
		} else {
			mddev->reshape_position = MaxSector;
			mddev->delta_disks = 0;
			mddev->new_level = mddev->level;
			mddev->new_layout = mddev->layout;
1038
			mddev->new_chunk_sectors = mddev->chunk_sectors;
1039 1040
		}

L
Linus Torvalds 已提交
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
		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;
1057 1058

		if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
1059 1060 1061
		    mddev->bitmap_info.file == NULL)
			mddev->bitmap_info.offset =
				mddev->bitmap_info.default_offset;
1062

1063
	} else if (mddev->pers == NULL) {
1064 1065
		/* Insist on good event counter while assembling, except
		 * for spares (which don't need an event count) */
L
Linus Torvalds 已提交
1066
		++ev1;
1067 1068 1069 1070
		if (sb->disks[rdev->desc_nr].state & (
			    (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
			if (ev1 < mddev->events) 
				return -EINVAL;
1071 1072 1073 1074 1075 1076
	} 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;
1077 1078 1079 1080 1081
	} else {
		if (ev1 < mddev->events)
			/* just a hot-add of a new device, leave raid_disk at -1 */
			return 0;
	}
1082

L
Linus Torvalds 已提交
1083 1084 1085 1086
	if (mddev->level != LEVEL_MULTIPATH) {
		desc = sb->disks + rdev->desc_nr;

		if (desc->state & (1<<MD_DISK_FAULTY))
1087
			set_bit(Faulty, &rdev->flags);
1088 1089
		else if (desc->state & (1<<MD_DISK_SYNC) /* &&
			    desc->raid_disk < mddev->raid_disks */) {
1090
			set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
1091
			rdev->raid_disk = desc->raid_disk;
1092 1093 1094 1095 1096 1097 1098 1099
		} 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 已提交
1100
		}
1101 1102
		if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);
1103
	} else /* MULTIPATH are always insync */
1104
		set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
	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;
1116

L
Linus Torvalds 已提交
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130

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

1131 1132
	rdev->sb_size = MD_SB_BYTES;

L
Linus Torvalds 已提交
1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
	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 已提交
1148
	sb->size = mddev->dev_sectors / 2;
L
Linus Torvalds 已提交
1149 1150
	sb->raid_disks = mddev->raid_disks;
	sb->md_minor = mddev->md_minor;
1151
	sb->not_persistent = 0;
L
Linus Torvalds 已提交
1152 1153 1154 1155 1156
	sb->utime = mddev->utime;
	sb->state = 0;
	sb->events_hi = (mddev->events>>32);
	sb->events_lo = (u32)mddev->events;

1157 1158 1159 1160 1161 1162 1163 1164
	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;
1165
		sb->new_chunk = mddev->new_chunk_sectors << 9;
1166 1167
	}
	mddev->minor_version = sb->minor_version;
L
Linus Torvalds 已提交
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
	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;
1179
	sb->chunk_size = mddev->chunk_sectors << 9;
L
Linus Torvalds 已提交
1180

1181
	if (mddev->bitmap && mddev->bitmap_info.file == NULL)
1182 1183
		sb->state |= (1<<MD_SB_BITMAP_PRESENT);

L
Linus Torvalds 已提交
1184
	sb->disks[0].state = (1<<MD_DISK_REMOVED);
1185
	list_for_each_entry(rdev2, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
1186
		mdp_disk_t *d;
1187
		int desc_nr;
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
		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)
1201
			desc_nr = rdev2->raid_disk;
L
Linus Torvalds 已提交
1202
		else
1203
			desc_nr = next_spare++;
1204
		rdev2->desc_nr = desc_nr;
L
Linus Torvalds 已提交
1205 1206 1207 1208 1209
		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);
1210
		if (is_active)
L
Linus Torvalds 已提交
1211 1212 1213
			d->raid_disk = rdev2->raid_disk;
		else
			d->raid_disk = rdev2->desc_nr; /* compatibility */
1214
		if (test_bit(Faulty, &rdev2->flags))
L
Linus Torvalds 已提交
1215
			d->state = (1<<MD_DISK_FAULTY);
1216
		else if (is_active) {
L
Linus Torvalds 已提交
1217
			d->state = (1<<MD_DISK_ACTIVE);
1218 1219
			if (test_bit(In_sync, &rdev2->flags))
				d->state |= (1<<MD_DISK_SYNC);
L
Linus Torvalds 已提交
1220 1221 1222 1223 1224 1225 1226
			active++;
			working++;
		} else {
			d->state = 0;
			spare++;
			working++;
		}
1227 1228
		if (test_bit(WriteMostly, &rdev2->flags))
			d->state |= (1<<MD_DISK_WRITEMOSTLY);
L
Linus Torvalds 已提交
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
	}
	/* 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);
}

1251 1252 1253 1254
/*
 * rdev_size_change for 0.90.0
 */
static unsigned long long
1255
super_90_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
1256
{
A
Andre Noll 已提交
1257
	if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1258
		return 0; /* component must fit device */
1259
	if (rdev->mddev->bitmap_info.offset)
1260
		return 0; /* can't move bitmap */
1261
	rdev->sb_start = calc_dev_sboffset(rdev->bdev);
1262 1263
	if (!num_sectors || num_sectors > rdev->sb_start)
		num_sectors = rdev->sb_start;
1264
	md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1265 1266
		       rdev->sb_page);
	md_super_wait(rdev->mddev);
1267
	return num_sectors / 2; /* kB for sysfs */
1268 1269 1270
}


L
Linus Torvalds 已提交
1271 1272 1273 1274
/*
 * version 1 superblock
 */

1275
static __le32 calc_sb_1_csum(struct mdp_superblock_1 * sb)
L
Linus Torvalds 已提交
1276
{
1277 1278
	__le32 disk_csum;
	u32 csum;
L
Linus Torvalds 已提交
1279 1280
	unsigned long long newcsum;
	int size = 256 + le32_to_cpu(sb->max_dev)*2;
1281
	__le32 *isuper = (__le32*)sb;
L
Linus Torvalds 已提交
1282 1283 1284 1285 1286 1287 1288 1289 1290
	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)
1291
		newcsum += le16_to_cpu(*(__le16*) isuper);
L
Linus Torvalds 已提交
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301

	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;
1302
	sector_t sb_start;
L
Linus Torvalds 已提交
1303
	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1304
	int bmask;
L
Linus Torvalds 已提交
1305 1306

	/*
1307
	 * Calculate the position of the superblock in 512byte sectors.
L
Linus Torvalds 已提交
1308 1309 1310 1311 1312 1313 1314 1315
	 * 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:
1316 1317 1318
		sb_start = rdev->bdev->bd_inode->i_size >> 9;
		sb_start -= 8*2;
		sb_start &= ~(sector_t)(4*2-1);
L
Linus Torvalds 已提交
1319 1320
		break;
	case 1:
1321
		sb_start = 0;
L
Linus Torvalds 已提交
1322 1323
		break;
	case 2:
1324
		sb_start = 8;
L
Linus Torvalds 已提交
1325 1326 1327 1328
		break;
	default:
		return -EINVAL;
	}
1329
	rdev->sb_start = sb_start;
L
Linus Torvalds 已提交
1330

1331 1332 1333 1334
	/* 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 已提交
1335 1336 1337 1338 1339 1340 1341 1342
	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 ||
1343
	    le64_to_cpu(sb->super_offset) != rdev->sb_start ||
1344
	    (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
L
Linus Torvalds 已提交
1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
		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;
	}
1357

L
Linus Torvalds 已提交
1358 1359
	rdev->preferred_minor = 0xffff;
	rdev->data_offset = le64_to_cpu(sb->data_offset);
1360
	atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
L
Linus Torvalds 已提交
1361

1362
	rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
1363
	bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1364
	if (rdev->sb_size & bmask)
1365 1366 1367
		rdev->sb_size = (rdev->sb_size | bmask) + 1;

	if (minor_version
1368
	    && rdev->data_offset < sb_start + (rdev->sb_size/512))
1369
		return -EINVAL;
1370

1371 1372 1373 1374 1375
	if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
		rdev->desc_nr = -1;
	else
		rdev->desc_nr = le32_to_cpu(sb->dev_number);

1376
	if (!refdev) {
1377
		ret = 1;
1378
	} else {
L
Linus Torvalds 已提交
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396
		__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)
1397 1398 1399
			ret = 1;
		else
			ret = 0;
L
Linus Torvalds 已提交
1400
	}
1401
	if (minor_version)
1402 1403
		rdev->sectors = (rdev->bdev->bd_inode->i_size >> 9) -
			le64_to_cpu(sb->data_offset);
L
Linus Torvalds 已提交
1404
	else
1405 1406
		rdev->sectors = rdev->sb_start;
	if (rdev->sectors < le64_to_cpu(sb->data_size))
L
Linus Torvalds 已提交
1407
		return -EINVAL;
1408 1409
	rdev->sectors = le64_to_cpu(sb->data_size);
	if (le64_to_cpu(sb->size) > rdev->sectors)
1410
		return -EINVAL;
1411
	return ret;
L
Linus Torvalds 已提交
1412 1413 1414 1415 1416
}

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

1419
	rdev->raid_disk = -1;
1420 1421 1422 1423
	clear_bit(Faulty, &rdev->flags);
	clear_bit(In_sync, &rdev->flags);
	clear_bit(WriteMostly, &rdev->flags);

L
Linus Torvalds 已提交
1424 1425 1426
	if (mddev->raid_disks == 0) {
		mddev->major_version = 1;
		mddev->patch_version = 0;
1427
		mddev->external = 0;
1428
		mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
L
Linus Torvalds 已提交
1429 1430 1431
		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);
1432
		mddev->clevel[0] = 0;
L
Linus Torvalds 已提交
1433 1434
		mddev->layout = le32_to_cpu(sb->layout);
		mddev->raid_disks = le32_to_cpu(sb->raid_disks);
A
Andre Noll 已提交
1435
		mddev->dev_sectors = le64_to_cpu(sb->size);
1436
		mddev->events = ev1;
1437 1438
		mddev->bitmap_info.offset = 0;
		mddev->bitmap_info.default_offset = 1024 >> 9;
L
Linus Torvalds 已提交
1439 1440 1441 1442 1443
		
		mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
		memcpy(mddev->uuid, sb->set_uuid, 16);

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

1445
		if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1446 1447 1448
		    mddev->bitmap_info.file == NULL )
			mddev->bitmap_info.offset =
				(__s32)le32_to_cpu(sb->bitmap_offset);
1449

1450 1451 1452 1453 1454
		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);
1455
			mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
1456 1457 1458 1459 1460
		} else {
			mddev->reshape_position = MaxSector;
			mddev->delta_disks = 0;
			mddev->new_level = mddev->level;
			mddev->new_layout = mddev->layout;
1461
			mddev->new_chunk_sectors = mddev->chunk_sectors;
1462 1463
		}

1464
	} else if (mddev->pers == NULL) {
1465 1466
		/* Insist of good event counter while assembling, except for
		 * spares (which don't need an event count) */
L
Linus Torvalds 已提交
1467
		++ev1;
1468 1469 1470 1471 1472
		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;
1473 1474 1475 1476 1477 1478
	} 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;
1479 1480 1481 1482 1483
	} else {
		if (ev1 < mddev->events)
			/* just a hot-add of a new device, leave raid_disk at -1 */
			return 0;
	}
L
Linus Torvalds 已提交
1484 1485
	if (mddev->level != LEVEL_MULTIPATH) {
		int role;
1486 1487 1488 1489 1490 1491
		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 已提交
1492 1493 1494 1495
		switch(role) {
		case 0xffff: /* spare */
			break;
		case 0xfffe: /* faulty */
1496
			set_bit(Faulty, &rdev->flags);
L
Linus Torvalds 已提交
1497 1498
			break;
		default:
1499 1500 1501 1502 1503
			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 已提交
1504 1505 1506
			rdev->raid_disk = role;
			break;
		}
1507 1508
		if (sb->devflags & WriteMostly1)
			set_bit(WriteMostly, &rdev->flags);
1509
	} else /* MULTIPATH are always insync */
1510
		set_bit(In_sync, &rdev->flags);
1511

L
Linus Torvalds 已提交
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
	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;
1526
	sb->recovery_offset = cpu_to_le64(0);
L
Linus Torvalds 已提交
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
	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);

1538
	sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
1539

1540
	sb->raid_disks = cpu_to_le32(mddev->raid_disks);
A
Andre Noll 已提交
1541
	sb->size = cpu_to_le64(mddev->dev_sectors);
1542
	sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
1543 1544
	sb->level = cpu_to_le32(mddev->level);
	sb->layout = cpu_to_le32(mddev->layout);
1545

1546 1547
	if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
		sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
1548
		sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1549
	}
1550 1551

	if (rdev->raid_disk >= 0 &&
1552
	    !test_bit(In_sync, &rdev->flags)) {
1553 1554 1555 1556
		sb->feature_map |=
			cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
		sb->recovery_offset =
			cpu_to_le64(rdev->recovery_offset);
1557 1558
	}

1559 1560 1561 1562 1563 1564
	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);
1565
		sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
1566
	}
1567

L
Linus Torvalds 已提交
1568
	max_dev = 0;
1569
	list_for_each_entry(rdev2, &mddev->disks, same_set)
L
Linus Torvalds 已提交
1570 1571
		if (rdev2->desc_nr+1 > max_dev)
			max_dev = rdev2->desc_nr+1;
1572

1573 1574
	if (max_dev > le32_to_cpu(sb->max_dev)) {
		int bmask;
1575
		sb->max_dev = cpu_to_le32(max_dev);
1576 1577 1578 1579
		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;
1580 1581 1582
	} else
		max_dev = le32_to_cpu(sb->max_dev);

L
Linus Torvalds 已提交
1583 1584 1585
	for (i=0; i<max_dev;i++)
		sb->dev_roles[i] = cpu_to_le16(0xfffe);
	
1586
	list_for_each_entry(rdev2, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
1587
		i = rdev2->desc_nr;
1588
		if (test_bit(Faulty, &rdev2->flags))
L
Linus Torvalds 已提交
1589
			sb->dev_roles[i] = cpu_to_le16(0xfffe);
1590
		else if (test_bit(In_sync, &rdev2->flags))
L
Linus Torvalds 已提交
1591
			sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1592
		else if (rdev2->raid_disk >= 0)
1593
			sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
L
Linus Torvalds 已提交
1594 1595 1596 1597 1598 1599 1600
		else
			sb->dev_roles[i] = cpu_to_le16(0xffff);
	}

	sb->sb_csum = calc_sb_1_csum(sb);
}

1601
static unsigned long long
1602
super_1_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
1603 1604
{
	struct mdp_superblock_1 *sb;
1605
	sector_t max_sectors;
A
Andre Noll 已提交
1606
	if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1607
		return 0; /* component must fit device */
1608
	if (rdev->sb_start < rdev->data_offset) {
1609
		/* minor versions 1 and 2; superblock before data */
1610 1611 1612 1613
		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;
1614
	} else if (rdev->mddev->bitmap_info.offset) {
1615 1616 1617 1618
		/* minor version 0 with bitmap we can't move */
		return 0;
	} else {
		/* minor version 0; superblock after data */
1619 1620 1621
		sector_t sb_start;
		sb_start = (rdev->bdev->bd_inode->i_size >> 9) - 8*2;
		sb_start &= ~(sector_t)(4*2 - 1);
1622
		max_sectors = rdev->sectors + sb_start - rdev->sb_start;
1623 1624
		if (!num_sectors || num_sectors > max_sectors)
			num_sectors = max_sectors;
1625
		rdev->sb_start = sb_start;
1626 1627
	}
	sb = (struct mdp_superblock_1 *) page_address(rdev->sb_page);
1628
	sb->data_size = cpu_to_le64(num_sectors);
1629
	sb->super_offset = rdev->sb_start;
1630
	sb->sb_csum = calc_sb_1_csum(sb);
1631
	md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1632 1633
		       rdev->sb_page);
	md_super_wait(rdev->mddev);
1634
	return num_sectors / 2; /* kB for sysfs */
1635
}
L
Linus Torvalds 已提交
1636

A
Adrian Bunk 已提交
1637
static struct super_type super_types[] = {
L
Linus Torvalds 已提交
1638 1639 1640
	[0] = {
		.name	= "0.90.0",
		.owner	= THIS_MODULE,
1641 1642 1643 1644
		.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 已提交
1645 1646 1647 1648
	},
	[1] = {
		.name	= "md-1",
		.owner	= THIS_MODULE,
1649 1650 1651 1652
		.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 已提交
1653 1654 1655 1656 1657
	},
};

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

1660 1661 1662
	rcu_read_lock();
	rdev_for_each_rcu(rdev, mddev1)
		rdev_for_each_rcu(rdev2, mddev2)
1663
			if (rdev->bdev->bd_contains ==
1664 1665
			    rdev2->bdev->bd_contains) {
				rcu_read_unlock();
1666
				return 1;
1667 1668
			}
	rcu_read_unlock();
L
Linus Torvalds 已提交
1669 1670 1671 1672 1673
	return 0;
}

static LIST_HEAD(pending_raid_disks);

1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728
/*
 * 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 已提交
1729 1730
{
	struct blk_integrity *bi_rdev = bdev_get_integrity(rdev->bdev);
1731
	struct blk_integrity *bi_mddev = blk_get_integrity(mddev->gendisk);
M
Martin K. Petersen 已提交
1732

1733
	if (!bi_mddev) /* nothing to do */
M
Martin K. Petersen 已提交
1734
		return;
1735
	if (rdev->raid_disk < 0) /* skip spares */
M
Martin K. Petersen 已提交
1736
		return;
1737 1738 1739 1740 1741
	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 已提交
1742
}
1743
EXPORT_SYMBOL(md_integrity_add_rdev);
M
Martin K. Petersen 已提交
1744

L
Linus Torvalds 已提交
1745 1746
static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
{
1747
	char b[BDEVNAME_SIZE];
1748
	struct kobject *ko;
1749
	char *s;
1750
	int err;
L
Linus Torvalds 已提交
1751 1752 1753 1754 1755

	if (rdev->mddev) {
		MD_BUG();
		return -EINVAL;
	}
1756 1757 1758 1759 1760

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

1761 1762 1763
	/* make sure rdev->sectors exceeds mddev->dev_sectors */
	if (rdev->sectors && (mddev->dev_sectors == 0 ||
			rdev->sectors < mddev->dev_sectors)) {
1764 1765 1766 1767 1768 1769 1770 1771
		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
1772
			mddev->dev_sectors = rdev->sectors;
1773
	}
L
Linus Torvalds 已提交
1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788

	/* 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;
	}
1789 1790 1791 1792 1793
	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;
	}
1794
	bdevname(rdev->bdev,b);
1795
	while ( (s=strchr(b, '/')) != NULL)
1796
		*s = '!';
1797

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

1801
	if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
1802
		goto fail;
1803

T
Tejun Heo 已提交
1804
	ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
N
NeilBrown 已提交
1805 1806 1807
	if (sysfs_create_link(&rdev->kobj, ko, "block"))
		/* failure here is OK */;
	rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
1808

1809
	list_add_rcu(&rdev->same_set, &mddev->disks);
1810
	bd_claim_by_disk(rdev->bdev, rdev->bdev->bd_holder, mddev->gendisk);
1811 1812 1813

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

L
Linus Torvalds 已提交
1815
	return 0;
1816 1817 1818 1819 1820

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

1823
static void md_delayed_delete(struct work_struct *ws)
1824 1825 1826
{
	mdk_rdev_t *rdev = container_of(ws, mdk_rdev_t, del_work);
	kobject_del(&rdev->kobj);
1827
	kobject_put(&rdev->kobj);
1828 1829
}

L
Linus Torvalds 已提交
1830 1831 1832 1833 1834 1835 1836
static void unbind_rdev_from_array(mdk_rdev_t * rdev)
{
	char b[BDEVNAME_SIZE];
	if (!rdev->mddev) {
		MD_BUG();
		return;
	}
1837
	bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
1838
	list_del_rcu(&rdev->same_set);
L
Linus Torvalds 已提交
1839 1840
	printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
	rdev->mddev = NULL;
1841
	sysfs_remove_link(&rdev->kobj, "block");
1842 1843
	sysfs_put(rdev->sysfs_state);
	rdev->sysfs_state = NULL;
1844
	/* We need to delay this, otherwise we can deadlock when
1845 1846
	 * writing to 'remove' to "dev/state".  We also need
	 * to delay it due to rcu usage.
1847
	 */
1848
	synchronize_rcu();
1849 1850
	INIT_WORK(&rdev->del_work, md_delayed_delete);
	kobject_get(&rdev->kobj);
1851
	schedule_work(&rdev->del_work);
L
Linus Torvalds 已提交
1852 1853 1854 1855 1856 1857 1858
}

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

1865
	bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
L
Linus Torvalds 已提交
1866 1867 1868 1869 1870
	if (IS_ERR(bdev)) {
		printk(KERN_ERR "md: could not open %s.\n",
			__bdevname(dev, b));
		return PTR_ERR(bdev);
	}
1871
	err = bd_claim(bdev, shared ? (mdk_rdev_t *)lock_rdev : rdev);
L
Linus Torvalds 已提交
1872 1873 1874
	if (err) {
		printk(KERN_ERR "md: could not bd_claim %s.\n",
			bdevname(bdev, b));
A
Al Viro 已提交
1875
		blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
L
Linus Torvalds 已提交
1876 1877
		return err;
	}
1878 1879
	if (!shared)
		set_bit(AllReserved, &rdev->flags);
L
Linus Torvalds 已提交
1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890
	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 已提交
1891
	blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
L
Linus Torvalds 已提交
1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904
}

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
1905 1906
	if (test_bit(AutoDetected, &rdev->flags))
		md_autodetect_dev(rdev->bdev->bd_dev);
L
Linus Torvalds 已提交
1907 1908
#endif
	unlock_rdev(rdev);
1909
	kobject_put(&rdev->kobj);
L
Linus Torvalds 已提交
1910 1911 1912 1913 1914 1915 1916 1917 1918 1919
}

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

1922
	rdev_for_each(rdev, tmp, mddev) {
L
Linus Torvalds 已提交
1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940
		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);
}

1941
static void print_sb_90(mdp_super_t *sb)
L
Linus Torvalds 已提交
1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971
{
	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);
1972
}
L
Linus Torvalds 已提交
1973

1974 1975 1976 1977 1978
static void print_sb_1(struct mdp_superblock_1 *sb)
{
	__u8 *uuid;

	uuid = sb->set_uuid;
1979
	printk(KERN_INFO
1980
	       "md:  SB: (V:%u) (F:0x%08x) Array-ID:<%pU>\n"
1981
	       "md:    Name: \"%s\" CT:%llu\n",
1982 1983
		le32_to_cpu(sb->major_version),
		le32_to_cpu(sb->feature_map),
1984
		uuid,
1985 1986 1987 1988 1989
		sb->set_name,
		(unsigned long long)le64_to_cpu(sb->ctime)
		       & MD_SUPERBLOCK_1_TIME_SEC_MASK);

	uuid = sb->device_uuid;
1990 1991
	printk(KERN_INFO
	       "md:       L%u SZ%llu RD:%u LO:%u CS:%u DO:%llu DS:%llu SO:%llu"
1992
			" RO:%llu\n"
1993
	       "md:     Dev:%08x UUID: %pU\n"
1994 1995
	       "md:       (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
	       "md:         (MaxDev:%u) \n",
1996 1997 1998 1999 2000 2001 2002 2003 2004 2005
		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),
2006
		uuid,
2007 2008 2009 2010 2011 2012 2013
		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 已提交
2014 2015
}

2016
static void print_rdev(mdk_rdev_t *rdev, int major_version)
L
Linus Torvalds 已提交
2017 2018
{
	char b[BDEVNAME_SIZE];
2019 2020
	printk(KERN_INFO "md: rdev %s, Sect:%08llu F:%d S:%d DN:%u\n",
		bdevname(rdev->bdev, b), (unsigned long long)rdev->sectors,
2021 2022
	        test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags),
	        rdev->desc_nr);
L
Linus Torvalds 已提交
2023
	if (rdev->sb_loaded) {
2024 2025 2026 2027 2028 2029 2030 2031 2032
		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 已提交
2033 2034 2035 2036
	} else
		printk(KERN_INFO "md: no rdev superblock!\n");
}

2037
static void md_print_devices(void)
L
Linus Torvalds 已提交
2038
{
2039
	struct list_head *tmp;
L
Linus Torvalds 已提交
2040 2041 2042 2043 2044 2045 2046 2047
	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");
2048
	for_each_mddev(mddev, tmp) {
L
Linus Torvalds 已提交
2049

2050 2051 2052 2053
		if (mddev->bitmap)
			bitmap_print_sb(mddev->bitmap);
		else
			printk("%s: ", mdname(mddev));
2054
		list_for_each_entry(rdev, &mddev->disks, same_set)
L
Linus Torvalds 已提交
2055 2056 2057
			printk("<%s>", bdevname(rdev->bdev,b));
		printk("\n");

2058
		list_for_each_entry(rdev, &mddev->disks, same_set)
2059
			print_rdev(rdev, mddev->major_version);
L
Linus Torvalds 已提交
2060 2061 2062 2063 2064 2065
	}
	printk("md:	**********************************\n");
	printk("\n");
}


2066
static void sync_sbs(mddev_t * mddev, int nospares)
L
Linus Torvalds 已提交
2067
{
2068 2069 2070 2071 2072 2073
	/* 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 已提交
2074
	mdk_rdev_t *rdev;
2075
	list_for_each_entry(rdev, &mddev->disks, same_set) {
2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
		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 已提交
2087 2088 2089
	}
}

2090
static void md_update_sb(mddev_t * mddev, int force_change)
L
Linus Torvalds 已提交
2091 2092
{
	mdk_rdev_t *rdev;
2093
	int sync_req;
2094
	int nospares = 0;
L
Linus Torvalds 已提交
2095 2096

repeat:
2097 2098 2099 2100 2101 2102 2103 2104 2105
	/* 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;

	}	
2106
	if (!mddev->persistent) {
2107
		clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2108
		clear_bit(MD_CHANGE_DEVS, &mddev->flags);
2109 2110
		if (!mddev->external)
			clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2111 2112 2113 2114
		wake_up(&mddev->sb_wait);
		return;
	}

2115
	spin_lock_irq(&mddev->write_lock);
2116

2117 2118
	mddev->utime = get_seconds();

2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
	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)
2130 2131 2132 2133 2134 2135 2136 2137 2138
		/* 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.
		 */
2139
		nospares = 0;
2140

2141
	sync_req = mddev->in_sync;
2142 2143 2144

	/* 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 */
2145
	if (nospares
2146
	    && (mddev->in_sync && mddev->recovery_cp == MaxSector)
2147 2148
	    && mddev->can_decrease_events
	    && mddev->events != 1) {
2149
		mddev->events--;
2150 2151
		mddev->can_decrease_events = 0;
	} else {
2152 2153
		/* otherwise we have to go forward and ... */
		mddev->events ++;
2154
		mddev->can_decrease_events = nospares;
2155
	}
L
Linus Torvalds 已提交
2156 2157 2158 2159 2160 2161 2162 2163 2164 2165

	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 --;
	}
2166
	sync_sbs(mddev, nospares);
2167
	spin_unlock_irq(&mddev->write_lock);
L
Linus Torvalds 已提交
2168 2169 2170 2171 2172

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

2173
	bitmap_update_sb(mddev->bitmap);
2174
	list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
2175 2176
		char b[BDEVNAME_SIZE];
		dprintk(KERN_INFO "md: ");
2177 2178
		if (rdev->sb_loaded != 1)
			continue; /* no noise on spare devices */
2179
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
2180 2181 2182
			dprintk("(skipping faulty ");

		dprintk("%s ", bdevname(rdev->bdev,b));
2183
		if (!test_bit(Faulty, &rdev->flags)) {
2184
			md_super_write(mddev,rdev,
2185
				       rdev->sb_start, rdev->sb_size,
2186 2187 2188
				       rdev->sb_page);
			dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
				bdevname(rdev->bdev,b),
2189
				(unsigned long long)rdev->sb_start);
2190
			rdev->sb_events = mddev->events;
2191

L
Linus Torvalds 已提交
2192 2193
		} else
			dprintk(")\n");
2194
		if (mddev->level == LEVEL_MULTIPATH)
L
Linus Torvalds 已提交
2195 2196 2197
			/* only need to write one superblock... */
			break;
	}
2198
	md_super_wait(mddev);
2199
	/* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
2200

2201
	spin_lock_irq(&mddev->write_lock);
2202 2203
	if (mddev->in_sync != sync_req ||
	    test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
2204
		/* have to write it out again */
2205
		spin_unlock_irq(&mddev->write_lock);
2206 2207
		goto repeat;
	}
2208
	clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2209
	spin_unlock_irq(&mddev->write_lock);
2210
	wake_up(&mddev->sb_wait);
2211 2212
	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
		sysfs_notify(&mddev->kobj, NULL, "sync_completed");
2213

L
Linus Torvalds 已提交
2214 2215
}

2216
/* words written to sysfs files may, or may not, be \n terminated.
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235
 * 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;
}

2236 2237 2238 2239 2240 2241 2242
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
2243
state_show(mdk_rdev_t *rdev, char *page)
2244 2245
{
	char *sep = "";
2246
	size_t len = 0;
2247

2248
	if (test_bit(Faulty, &rdev->flags)) {
2249 2250 2251
		len+= sprintf(page+len, "%sfaulty",sep);
		sep = ",";
	}
2252
	if (test_bit(In_sync, &rdev->flags)) {
2253 2254 2255
		len += sprintf(page+len, "%sin_sync",sep);
		sep = ",";
	}
2256 2257 2258 2259
	if (test_bit(WriteMostly, &rdev->flags)) {
		len += sprintf(page+len, "%swrite_mostly",sep);
		sep = ",";
	}
2260 2261 2262 2263
	if (test_bit(Blocked, &rdev->flags)) {
		len += sprintf(page+len, "%sblocked", sep);
		sep = ",";
	}
2264 2265
	if (!test_bit(Faulty, &rdev->flags) &&
	    !test_bit(In_sync, &rdev->flags)) {
2266 2267 2268 2269 2270 2271
		len += sprintf(page+len, "%sspare", sep);
		sep = ",";
	}
	return len+sprintf(page+len, "\n");
}

2272 2273 2274 2275 2276 2277
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
2278 2279
	 *  writemostly - sets write_mostly
	 *  -writemostly - clears write_mostly
2280 2281
	 *  blocked - sets the Blocked flag
	 *  -blocked - clears the Blocked flag
2282
	 *  insync - sets Insync providing device isn't active
2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293
	 */
	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);
2294 2295
			if (mddev->pers)
				md_update_sb(mddev, 1);
2296 2297 2298
			md_new_event(mddev);
			err = 0;
		}
2299 2300 2301 2302 2303
	} else if (cmd_match(buf, "writemostly")) {
		set_bit(WriteMostly, &rdev->flags);
		err = 0;
	} else if (cmd_match(buf, "-writemostly")) {
		clear_bit(WriteMostly, &rdev->flags);
2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
		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);

2314 2315 2316
		err = 0;
	} else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
		set_bit(In_sync, &rdev->flags);
2317
		err = 0;
2318
	}
N
NeilBrown 已提交
2319 2320
	if (!err)
		sysfs_notify_dirent_safe(rdev->sysfs_state);
2321 2322
	return err ? err : len;
}
2323 2324
static struct rdev_sysfs_entry rdev_state =
__ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store);
2325

2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343
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 =
2344
__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
2345

2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358
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;
2359 2360
	int err;
	char nm[20];
2361 2362 2363 2364 2365
	int slot = simple_strtoul(buf, &e, 10);
	if (strncmp(buf, "none", 4)==0)
		slot = -1;
	else if (e==buf || (*e && *e!= '\n'))
		return -EINVAL;
2366
	if (rdev->mddev->pers && slot == -1) {
2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384
		/* 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);
2385
		rdev->raid_disk = -1;
2386 2387
		set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
		md_wakeup_thread(rdev->mddev->thread);
2388 2389 2390
	} else if (rdev->mddev->pers) {
		mdk_rdev_t *rdev2;
		/* Activating a spare .. or possibly reactivating
2391
		 * if we ever get bitmaps working here.
2392 2393 2394 2395 2396 2397 2398 2399
		 */

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

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

2400
		list_for_each_entry(rdev2, &rdev->mddev->disks, same_set)
2401 2402 2403 2404 2405 2406 2407 2408 2409 2410
			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);
2411
		if (err) {
2412 2413
			rdev->raid_disk = -1;
			return err;
2414
		} else
N
NeilBrown 已提交
2415
			sysfs_notify_dirent_safe(rdev->sysfs_state);
2416 2417
		sprintf(nm, "rd%d", rdev->raid_disk);
		if (sysfs_create_link(&rdev->mddev->kobj, &rdev->kobj, nm))
N
NeilBrown 已提交
2418
			/* failure here is OK */;
2419
		/* don't wakeup anyone, leave that to userspace. */
2420 2421 2422 2423 2424
	} else {
		if (slot >= rdev->mddev->raid_disks)
			return -ENOSPC;
		rdev->raid_disk = slot;
		/* assume it is working */
2425 2426
		clear_bit(Faulty, &rdev->flags);
		clear_bit(WriteMostly, &rdev->flags);
2427
		set_bit(In_sync, &rdev->flags);
N
NeilBrown 已提交
2428
		sysfs_notify_dirent_safe(rdev->sysfs_state);
2429
	}
2430 2431 2432 2433 2434
	return len;
}


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

2437 2438 2439
static ssize_t
offset_show(mdk_rdev_t *rdev, char *page)
{
2440
	return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
2441 2442 2443 2444 2445 2446 2447 2448 2449
}

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;
2450
	if (rdev->mddev->pers && rdev->raid_disk >= 0)
2451
		return -EBUSY;
2452
	if (rdev->sectors && rdev->mddev->external)
2453 2454 2455
		/* Must set offset before size, so overlap checks
		 * can be sane */
		return -EBUSY;
2456 2457 2458 2459 2460
	rdev->data_offset = offset;
	return len;
}

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

2463 2464 2465
static ssize_t
rdev_size_show(mdk_rdev_t *rdev, char *page)
{
2466
	return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
2467 2468
}

2469 2470 2471 2472 2473 2474 2475 2476 2477 2478
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 已提交
2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497
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;
}

2498 2499 2500
static ssize_t
rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
{
2501
	mddev_t *my_mddev = rdev->mddev;
2502
	sector_t oldsectors = rdev->sectors;
D
Dan Williams 已提交
2503
	sector_t sectors;
2504

D
Dan Williams 已提交
2505
	if (strict_blocks_to_sectors(buf, &sectors) < 0)
N
Neil Brown 已提交
2506
		return -EINVAL;
2507
	if (my_mddev->pers && rdev->raid_disk >= 0) {
N
Neil Brown 已提交
2508
		if (my_mddev->persistent) {
2509 2510 2511
			sectors = super_types[my_mddev->major_version].
				rdev_size_change(rdev, sectors);
			if (!sectors)
2512
				return -EBUSY;
2513 2514 2515
		} else if (!sectors)
			sectors = (rdev->bdev->bd_inode->i_size >> 9) -
				rdev->data_offset;
2516
	}
2517
	if (sectors < my_mddev->dev_sectors)
2518
		return -EINVAL; /* component must fit device */
2519

2520 2521
	rdev->sectors = sectors;
	if (sectors > oldsectors && my_mddev->external) {
2522 2523
		/* need to check that all other rdevs with the same ->bdev
		 * do not overlap.  We need to unlock the mddev to avoid
2524
		 * a deadlock.  We have already changed rdev->sectors, and if
2525 2526 2527 2528
		 * we have to change it back, we will have the lock again.
		 */
		mddev_t *mddev;
		int overlap = 0;
2529
		struct list_head *tmp;
2530

2531
		mddev_unlock(my_mddev);
2532
		for_each_mddev(mddev, tmp) {
2533 2534 2535
			mdk_rdev_t *rdev2;

			mddev_lock(mddev);
2536
			list_for_each_entry(rdev2, &mddev->disks, same_set)
2537 2538 2539
				if (test_bit(AllReserved, &rdev2->flags) ||
				    (rdev->bdev == rdev2->bdev &&
				     rdev != rdev2 &&
2540
				     overlaps(rdev->data_offset, rdev->sectors,
2541
					      rdev2->data_offset,
2542
					      rdev2->sectors))) {
2543 2544 2545 2546 2547 2548 2549 2550 2551
					overlap = 1;
					break;
				}
			mddev_unlock(mddev);
			if (overlap) {
				mddev_put(mddev);
				break;
			}
		}
2552
		mddev_lock(my_mddev);
2553 2554 2555
		if (overlap) {
			/* Someone else could have slipped in a size
			 * change here, but doing so is just silly.
2556
			 * We put oldsectors back because we *know* it is
2557 2558 2559
			 * safe, and trust userspace not to race with
			 * itself
			 */
2560
			rdev->sectors = oldsectors;
2561 2562 2563
			return -EBUSY;
		}
	}
2564 2565 2566 2567
	return len;
}

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

2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605

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

2606 2607
static struct attribute *rdev_default_attrs[] = {
	&rdev_state.attr,
2608
	&rdev_errors.attr,
2609
	&rdev_slot.attr,
2610
	&rdev_offset.attr,
2611
	&rdev_size.attr,
2612
	&rdev_recovery_start.attr,
2613 2614 2615 2616 2617 2618 2619
	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);
2620 2621
	mddev_t *mddev = rdev->mddev;
	ssize_t rv;
2622 2623 2624

	if (!entry->show)
		return -EIO;
2625 2626 2627 2628 2629 2630 2631 2632 2633 2634

	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;
2635 2636 2637 2638 2639 2640 2641 2642
}

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);
2643 2644
	ssize_t rv;
	mddev_t *mddev = rdev->mddev;
2645 2646 2647

	if (!entry->store)
		return -EIO;
2648 2649
	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
2650
	rv = mddev ? mddev_lock(mddev): -EBUSY;
2651
	if (!rv) {
2652 2653 2654 2655
		if (rdev->mddev == NULL)
			rv = -EBUSY;
		else
			rv = entry->store(rdev, page, length);
2656
		mddev_unlock(mddev);
2657 2658
	}
	return rv;
2659 2660 2661 2662 2663 2664 2665
}

static void rdev_free(struct kobject *ko)
{
	mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj);
	kfree(rdev);
}
2666
static const struct sysfs_ops rdev_sysfs_ops = {
2667 2668 2669 2670 2671 2672 2673 2674 2675
	.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 已提交
2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693
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 已提交
2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710
/*
 * 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;

2711
	rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
L
Linus Torvalds 已提交
2712 2713 2714 2715 2716
	if (!rdev) {
		printk(KERN_ERR "md: could not alloc mem for new device!\n");
		return ERR_PTR(-ENOMEM);
	}

N
NeilBrown 已提交
2717
	md_rdev_init(rdev);
L
Linus Torvalds 已提交
2718 2719 2720
	if ((err = alloc_disk_sb(rdev)))
		goto abort_free;

2721
	err = lock_rdev(rdev, newdev, super_format == -2);
L
Linus Torvalds 已提交
2722 2723 2724
	if (err)
		goto abort_free;

2725
	kobject_init(&rdev->kobj, &rdev_ktype);
2726

L
Linus Torvalds 已提交
2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739
	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) {
2740 2741 2742 2743 2744
			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 已提交
2745 2746 2747 2748 2749 2750 2751 2752 2753
			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;
		}
	}
2754

L
Linus Torvalds 已提交
2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771
	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
 */


2772
static void analyze_sbs(mddev_t * mddev)
L
Linus Torvalds 已提交
2773 2774
{
	int i;
2775
	mdk_rdev_t *rdev, *freshest, *tmp;
L
Linus Torvalds 已提交
2776 2777 2778
	char b[BDEVNAME_SIZE];

	freshest = NULL;
2779
	rdev_for_each(rdev, tmp, mddev)
L
Linus Torvalds 已提交
2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799
		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;
2800
	rdev_for_each(rdev, tmp, mddev) {
2801 2802 2803
		if (mddev->max_disks &&
		    (rdev->desc_nr >= mddev->max_disks ||
		     i > mddev->max_disks)) {
2804 2805 2806 2807 2808 2809 2810
			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 已提交
2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822
		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;
2823
			set_bit(In_sync, &rdev->flags);
2824
		} else if (rdev->raid_disk >= (mddev->raid_disks - min(0, mddev->delta_disks))) {
2825 2826
			rdev->raid_disk = -1;
			clear_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
2827 2828 2829 2830
		}
	}
}

2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871
/* 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;
}


2872 2873
static void md_safemode_timeout(unsigned long data);

2874 2875 2876 2877 2878 2879 2880 2881 2882 2883
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;
2884

2885
	if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
2886 2887 2888 2889
		return -EINVAL;
	if (msec == 0)
		mddev->safemode_delay = 0;
	else {
2890
		unsigned long old_delay = mddev->safemode_delay;
2891 2892 2893
		mddev->safemode_delay = (msec*HZ)/1000;
		if (mddev->safemode_delay == 0)
			mddev->safemode_delay = 1;
2894 2895
		if (mddev->safemode_delay < old_delay)
			md_safemode_timeout((unsigned long)mddev);
2896 2897 2898 2899
	}
	return len;
}
static struct md_sysfs_entry md_safe_delay =
2900
__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
2901

2902
static ssize_t
2903
level_show(mddev_t *mddev, char *page)
2904
{
2905
	struct mdk_personality *p = mddev->pers;
2906
	if (p)
2907
		return sprintf(page, "%s\n", p->name);
2908 2909 2910 2911 2912 2913
	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;
2914 2915
}

2916 2917 2918
static ssize_t
level_store(mddev_t *mddev, const char *buf, size_t len)
{
2919
	char clevel[16];
2920
	ssize_t rv = len;
2921
	struct mdk_personality *pers;
2922
	long level;
2923
	void *priv;
2924
	mdk_rdev_t *rdev;
2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944

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

2945 2946 2947
	if (mddev->sync_thread ||
	    mddev->reshape_position != MaxSector ||
	    mddev->sysfs_active)
2948
		return -EBUSY;
2949 2950 2951 2952 2953 2954 2955 2956

	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 */
2957
	if (len == 0 || len >= sizeof(clevel))
2958
		return -EINVAL;
2959 2960
	strncpy(clevel, buf, len);
	if (clevel[len-1] == '\n')
2961
		len--;
2962 2963 2964
	clevel[len] = 0;
	if (strict_strtol(clevel, 10, &level))
		level = LEVEL_NONE;
2965

2966 2967
	if (request_module("md-%s", clevel) != 0)
		request_module("md-level-%s", clevel);
2968
	spin_lock(&pers_lock);
2969
	pers = find_pers(level, clevel);
2970 2971
	if (!pers || !try_module_get(pers->owner)) {
		spin_unlock(&pers_lock);
2972
		printk(KERN_WARNING "md: personality %s not loaded\n", clevel);
2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984
		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",
2985
		       mdname(mddev), clevel);
2986 2987 2988
		return -EINVAL;
	}

2989 2990 2991
	list_for_each_entry(rdev, &mddev->disks, same_set)
		rdev->new_raid_disk = rdev->raid_disk;

2992 2993 2994 2995 2996 2997 2998
	/* ->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;
2999
		mddev->new_chunk_sectors = mddev->chunk_sectors;
3000 3001 3002 3003
		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",
3004
		       mdname(mddev), clevel);
3005 3006 3007 3008 3009 3010
		return PTR_ERR(priv);
	}

	/* Looks like we have a winner */
	mddev_suspend(mddev);
	mddev->pers->stop(mddev);
3011 3012 3013 3014 3015 3016 3017 3018
	
	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));
3019
		mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, NULL, "sync_action");
3020 3021 3022 3023 3024 3025 3026 3027
	}		
	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;
	}

3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041
	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;
	}

3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059
	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)
3060
			clear_bit(In_sync, &rdev->flags);
3061 3062 3063 3064 3065 3066
		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));
3067
		}
3068 3069 3070
	}

	module_put(mddev->pers->owner);
3071 3072 3073 3074 3075
	mddev->pers = pers;
	mddev->private = priv;
	strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
	mddev->level = mddev->new_level;
	mddev->layout = mddev->new_layout;
3076
	mddev->chunk_sectors = mddev->new_chunk_sectors;
3077
	mddev->delta_disks = 0;
3078 3079 3080 3081 3082 3083 3084
	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);
	}
3085 3086 3087 3088 3089
	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);
3090
	sysfs_notify(&mddev->kobj, NULL, "level");
3091
	md_new_event(mddev);
3092 3093 3094 3095
	return rv;
}

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

3098 3099 3100 3101 3102

static ssize_t
layout_show(mddev_t *mddev, char *page)
{
	/* just a number, not meaningful for all levels */
3103 3104 3105 3106
	if (mddev->reshape_position != MaxSector &&
	    mddev->layout != mddev->new_layout)
		return sprintf(page, "%d (%d)\n",
			       mddev->new_layout, mddev->layout);
3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118
	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;

3119 3120
	if (mddev->pers) {
		int err;
3121
		if (mddev->pers->check_reshape == NULL)
3122
			return -EBUSY;
3123
		mddev->new_layout = n;
3124
		err = mddev->pers->check_reshape(mddev);
3125 3126
		if (err) {
			mddev->new_layout = mddev->layout;
3127
			return err;
3128
		}
3129
	} else {
3130
		mddev->new_layout = n;
3131 3132 3133
		if (mddev->reshape_position == MaxSector)
			mddev->layout = n;
	}
3134 3135 3136
	return len;
}
static struct md_sysfs_entry md_layout =
3137
__ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
3138 3139


3140
static ssize_t
3141
raid_disks_show(mddev_t *mddev, char *page)
3142
{
3143 3144
	if (mddev->raid_disks == 0)
		return 0;
3145 3146 3147 3148
	if (mddev->reshape_position != MaxSector &&
	    mddev->delta_disks != 0)
		return sprintf(page, "%d (%d)\n", mddev->raid_disks,
			       mddev->raid_disks - mddev->delta_disks);
3149 3150 3151
	return sprintf(page, "%d\n", mddev->raid_disks);
}

3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165
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);
3166 3167 3168 3169 3170
	else if (mddev->reshape_position != MaxSector) {
		int olddisks = mddev->raid_disks - mddev->delta_disks;
		mddev->delta_disks = n - olddisks;
		mddev->raid_disks = n;
	} else
3171 3172 3173 3174
		mddev->raid_disks = n;
	return rv ? rv : len;
}
static struct md_sysfs_entry md_raid_disks =
3175
__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
3176

3177 3178 3179
static ssize_t
chunk_size_show(mddev_t *mddev, char *page)
{
3180
	if (mddev->reshape_position != MaxSector &&
3181 3182 3183
	    mddev->chunk_sectors != mddev->new_chunk_sectors)
		return sprintf(page, "%d (%d)\n",
			       mddev->new_chunk_sectors << 9,
3184 3185
			       mddev->chunk_sectors << 9);
	return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196
}

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;

3197 3198
	if (mddev->pers) {
		int err;
3199
		if (mddev->pers->check_reshape == NULL)
3200
			return -EBUSY;
3201
		mddev->new_chunk_sectors = n >> 9;
3202
		err = mddev->pers->check_reshape(mddev);
3203 3204
		if (err) {
			mddev->new_chunk_sectors = mddev->chunk_sectors;
3205
			return err;
3206
		}
3207
	} else {
3208
		mddev->new_chunk_sectors = n >> 9;
3209
		if (mddev->reshape_position == MaxSector)
3210
			mddev->chunk_sectors = n >> 9;
3211
	}
3212 3213 3214
	return len;
}
static struct md_sysfs_entry md_chunk_size =
3215
__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
3216

3217 3218 3219
static ssize_t
resync_start_show(mddev_t *mddev, char *page)
{
3220 3221
	if (mddev->recovery_cp == MaxSector)
		return sprintf(page, "none\n");
3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232
	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;
3233 3234 3235
	if (cmd_match(buf, "none"))
		n = MaxSector;
	else if (!*buf || (*e && *e != '\n'))
3236 3237 3238 3239 3240 3241
		return -EINVAL;

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

3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255
/*
 * 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.
3256
 *     Writing this, if accepted, will block until array is quiescent
3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281
 * 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};
3282
static char *array_states[] = {
3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310
	"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;
3311
			else if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
3312
				st = write_pending;
3313 3314 3315 3316 3317 3318 3319 3320
			else if (mddev->safemode)
				st = active_idle;
			else
				st = active;
		}
	else {
		if (list_empty(&mddev->disks) &&
		    mddev->raid_disks == 0 &&
A
Andre Noll 已提交
3321
		    mddev->dev_sectors == 0)
3322 3323 3324 3325 3326 3327 3328
			st = clear;
		else
			st = inactive;
	}
	return sprintf(page, "%s\n", array_states[st]);
}

3329
static int do_md_stop(mddev_t * mddev, int ro, int is_open);
3330
static int md_set_readonly(mddev_t * mddev, int is_open);
3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343
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 */
3344
		if (atomic_read(&mddev->openers) > 0)
3345
			return -EBUSY;
3346
		err = do_md_stop(mddev, 0, 0);
3347 3348 3349 3350
		break;
	case inactive:
		/* stopping an active array */
		if (mddev->pers) {
3351
			if (atomic_read(&mddev->openers) > 0)
3352
				return -EBUSY;
3353
			err = do_md_stop(mddev, 2, 0);
3354 3355
		} else
			err = 0; /* already inactive */
3356 3357 3358 3359 3360
		break;
	case suspended:
		break; /* not supported yet */
	case readonly:
		if (mddev->pers)
3361
			err = md_set_readonly(mddev, 0);
3362 3363
		else {
			mddev->ro = 1;
3364
			set_disk_ro(mddev->gendisk, 1);
3365 3366 3367 3368 3369
			err = do_md_run(mddev);
		}
		break;
	case read_auto:
		if (mddev->pers) {
3370
			if (mddev->ro == 0)
3371
				err = md_set_readonly(mddev, 0);
3372
			else if (mddev->ro == 1)
3373 3374 3375 3376 3377
				err = restart_array(mddev);
			if (err == 0) {
				mddev->ro = 2;
				set_disk_ro(mddev->gendisk, 0);
			}
3378 3379 3380 3381 3382 3383 3384 3385 3386 3387
		} 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) {
3388 3389
				if (mddev->in_sync == 0) {
					mddev->in_sync = 1;
3390 3391
					if (mddev->safemode == 1)
						mddev->safemode = 0;
3392
					set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3393 3394 3395 3396
				}
				err = 0;
			} else
				err = -EBUSY;
3397
			spin_unlock_irq(&mddev->write_lock);
3398 3399
		} else
			err = -EINVAL;
3400 3401 3402 3403
		break;
	case active:
		if (mddev->pers) {
			restart_array(mddev);
3404
			clear_bit(MD_CHANGE_PENDING, &mddev->flags);
3405 3406 3407 3408
			wake_up(&mddev->sb_wait);
			err = 0;
		} else {
			mddev->ro = 0;
3409
			set_disk_ro(mddev->gendisk, 0);
3410 3411 3412 3413 3414 3415 3416 3417 3418 3419
			err = do_md_run(mddev);
		}
		break;
	case write_pending:
	case active_idle:
		/* these cannot be set */
		break;
	}
	if (err)
		return err;
3420
	else {
N
NeilBrown 已提交
3421
		sysfs_notify_dirent_safe(mddev->sysfs_state);
3422
		return len;
3423
	}
3424
}
3425 3426
static struct md_sysfs_entry md_array_state =
__ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
3427

3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450
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);

3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495
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;
		}
3496 3497 3498
	} else if (mddev->external)
		rdev = md_import_device(dev, -2, -1);
	else
3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510
		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 =
3511
__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
3512

3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531
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);
3532
		buf = skip_spaces(end);
3533 3534 3535 3536 3537 3538 3539 3540 3541
	}
	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);

3542 3543 3544
static ssize_t
size_show(mddev_t *mddev, char *page)
{
A
Andre Noll 已提交
3545 3546
	return sprintf(page, "%llu\n",
		(unsigned long long)mddev->dev_sectors / 2);
3547 3548
}

3549
static int update_size(mddev_t *mddev, sector_t num_sectors);
3550 3551 3552 3553 3554 3555 3556 3557

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 已提交
3558 3559
	sector_t sectors;
	int err = strict_blocks_to_sectors(buf, &sectors);
3560

A
Andre Noll 已提交
3561 3562
	if (err < 0)
		return err;
3563
	if (mddev->pers) {
A
Andre Noll 已提交
3564
		err = update_size(mddev, sectors);
3565
		md_update_sb(mddev, 1);
3566
	} else {
A
Andre Noll 已提交
3567 3568 3569
		if (mddev->dev_sectors == 0 ||
		    mddev->dev_sectors > sectors)
			mddev->dev_sectors = sectors;
3570 3571 3572 3573 3574 3575 3576
		else
			err = -ENOSPC;
	}
	return err ? err : len;
}

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

3579 3580

/* Metdata version.
3581 3582 3583
 * This is one of
 *   'none' for arrays with no metadata (good luck...)
 *   'external' for arrays with externally managed metadata,
3584 3585 3586 3587 3588 3589 3590 3591
 * 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);
3592 3593
	else if (mddev->external)
		return sprintf(page, "external:%s\n", mddev->metadata_type);
3594 3595 3596 3597 3598 3599 3600 3601 3602
	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;
3603 3604 3605 3606 3607 3608 3609
	/* 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))
3610 3611 3612 3613
		return -EBUSY;

	if (cmd_match(buf, "none")) {
		mddev->persistent = 0;
3614 3615 3616 3617 3618 3619
		mddev->external = 0;
		mddev->major_version = 0;
		mddev->minor_version = 90;
		return len;
	}
	if (strncmp(buf, "external:", 9) == 0) {
3620
		size_t namelen = len-9;
3621 3622 3623 3624 3625 3626 3627 3628
		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;
3629 3630 3631 3632 3633 3634 3635 3636 3637
		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);
3638
	if (e==buf || (*e && *e != '\n') )
3639
		return -EINVAL;
3640
	if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
3641 3642 3643 3644
		return -ENOENT;
	mddev->major_version = major;
	mddev->minor_version = minor;
	mddev->persistent = 1;
3645
	mddev->external = 0;
3646 3647 3648 3649
	return len;
}

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

3652
static ssize_t
3653
action_show(mddev_t *mddev, char *page)
3654
{
3655
	char *type = "idle";
3656 3657 3658
	if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
		type = "frozen";
	else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3659
	    (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))) {
3660 3661 3662
		if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
			type = "reshape";
		else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
3663 3664 3665 3666 3667 3668
			if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
				type = "resync";
			else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
				type = "check";
			else
				type = "repair";
3669
		} else if (test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
3670 3671 3672 3673 3674 3675
			type = "recover";
	}
	return sprintf(page, "%s\n", type);
}

static ssize_t
3676
action_store(mddev_t *mddev, const char *page, size_t len)
3677
{
3678 3679 3680
	if (!mddev->pers || !mddev->pers->sync_request)
		return -EINVAL;

3681 3682 3683 3684 3685 3686
	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")) {
3687 3688 3689 3690 3691 3692
		if (mddev->sync_thread) {
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
			md_unregister_thread(mddev->sync_thread);
			mddev->sync_thread = NULL;
			mddev->recovery = 0;
		}
3693 3694
	} else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
		   test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
3695
		return -EBUSY;
3696 3697 3698 3699
	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);
3700
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3701
	} else if (cmd_match(page, "reshape")) {
3702 3703 3704 3705 3706 3707
		int err;
		if (mddev->pers->start_reshape == NULL)
			return -EINVAL;
		err = mddev->pers->start_reshape(mddev);
		if (err)
			return err;
3708
		sysfs_notify(&mddev->kobj, NULL, "degraded");
3709
	} else {
3710
		if (cmd_match(page, "check"))
3711
			set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
3712
		else if (!cmd_match(page, "repair"))
3713 3714 3715 3716
			return -EINVAL;
		set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
		set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
	}
3717
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3718
	md_wakeup_thread(mddev->thread);
N
NeilBrown 已提交
3719
	sysfs_notify_dirent_safe(mddev->sysfs_action);
3720 3721 3722
	return len;
}

3723
static ssize_t
3724
mismatch_cnt_show(mddev_t *mddev, char *page)
3725 3726 3727 3728 3729
{
	return sprintf(page, "%llu\n",
		       (unsigned long long) mddev->resync_mismatches);
}

3730 3731
static struct md_sysfs_entry md_scan_mode =
__ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
3732

3733

3734
static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
3735

3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787
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);

3788 3789 3790 3791 3792 3793
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);
3794

3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824
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);

3825 3826 3827 3828
static ssize_t
sync_speed_show(mddev_t *mddev, char *page)
{
	unsigned long resync, dt, db;
3829 3830
	if (mddev->curr_resync == 0)
		return sprintf(page, "none\n");
3831 3832
	resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
	dt = (jiffies - mddev->resync_mark) / HZ;
3833
	if (!dt) dt++;
3834 3835
	db = resync - mddev->resync_mark_cnt;
	return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
3836 3837
}

3838
static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
3839 3840 3841 3842

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

3845 3846 3847
	if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
		return sprintf(page, "none\n");

3848
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
A
Andre Noll 已提交
3849
		max_sectors = mddev->resync_max_sectors;
3850
	else
A
Andre Noll 已提交
3851
		max_sectors = mddev->dev_sectors;
3852

3853
	resync = mddev->curr_resync_completed;
A
Andre Noll 已提交
3854
	return sprintf(page, "%lu / %lu\n", resync, max_sectors);
3855 3856
}

3857
static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
3858

3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876
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 */
3877
	if (mddev->chunk_sectors) {
3878
		sector_t temp = min;
3879
		if (sector_div(temp, mddev->chunk_sectors))
3880 3881 3882 3883 3884 3885 3886 3887 3888 3889
			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);

3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904
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 {
3905 3906 3907 3908
		unsigned long long max;
		if (strict_strtoull(buf, 10, &max))
			return -EINVAL;
		if (max < mddev->resync_min)
3909 3910
			return -EINVAL;
		if (max < mddev->resync_max &&
3911
		    mddev->ro == 0 &&
3912 3913 3914 3915
		    test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
			return -EBUSY;

		/* Must be a multiple of chunk_size */
3916
		if (mddev->chunk_sectors) {
3917
			sector_t temp = max;
3918
			if (sector_div(temp, mddev->chunk_sectors))
3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929
				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);

3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941
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);

3942 3943
	if (mddev->pers == NULL || 
	    mddev->pers->quiesce == NULL)
3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970
		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);

3971 3972
	if (mddev->pers == NULL ||
	    mddev->pers->quiesce == NULL)
3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987
		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);

3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010
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;
4011
	mddev->new_chunk_sectors = mddev->chunk_sectors;
4012 4013 4014 4015 4016 4017 4018
	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 已提交
4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044
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)
4045
			return -E2BIG;
D
Dan Williams 已提交
4046 4047 4048 4049 4050 4051

		mddev->external_size = 1;
	}

	mddev->array_sectors = sectors;
	set_capacity(mddev->gendisk, mddev->array_sectors);
4052 4053
	if (mddev->pers)
		revalidate_disk(mddev->gendisk);
D
Dan Williams 已提交
4054 4055 4056 4057 4058 4059 4060

	return len;
}

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

4062 4063
static struct attribute *md_default_attrs[] = {
	&md_level.attr,
4064
	&md_layout.attr,
4065
	&md_raid_disks.attr,
4066
	&md_chunk_size.attr,
4067
	&md_size.attr,
4068
	&md_resync_start.attr,
4069
	&md_metadata.attr,
4070
	&md_new_device.attr,
4071
	&md_safe_delay.attr,
4072
	&md_array_state.attr,
4073
	&md_reshape_position.attr,
D
Dan Williams 已提交
4074
	&md_array_size.attr,
4075
	&max_corr_read_errors.attr,
4076 4077 4078 4079
	NULL,
};

static struct attribute *md_redundancy_attrs[] = {
4080
	&md_scan_mode.attr,
4081
	&md_mismatches.attr,
4082 4083 4084
	&md_sync_min.attr,
	&md_sync_max.attr,
	&md_sync_speed.attr,
4085
	&md_sync_force_parallel.attr,
4086
	&md_sync_completed.attr,
4087
	&md_min_sync.attr,
4088
	&md_max_sync.attr,
4089 4090
	&md_suspend_lo.attr,
	&md_suspend_hi.attr,
4091
	&md_bitmap.attr,
4092
	&md_degraded.attr,
4093 4094
	NULL,
};
4095 4096 4097 4098 4099
static struct attribute_group md_redundancy_group = {
	.name = NULL,
	.attrs = md_redundancy_attrs,
};

4100 4101 4102 4103 4104 4105

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);
4106
	ssize_t rv;
4107 4108 4109

	if (!entry->show)
		return -EIO;
I
Ingo Molnar 已提交
4110 4111 4112 4113 4114
	rv = mddev_lock(mddev);
	if (!rv) {
		rv = entry->show(mddev, page);
		mddev_unlock(mddev);
	}
4115
	return rv;
4116 4117 4118 4119 4120 4121 4122 4123
}

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);
4124
	ssize_t rv;
4125 4126 4127

	if (!entry->store)
		return -EIO;
4128 4129
	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
I
Ingo Molnar 已提交
4130
	rv = mddev_lock(mddev);
4131 4132
	if (mddev->hold_active == UNTIL_IOCTL)
		mddev->hold_active = 0;
I
Ingo Molnar 已提交
4133 4134 4135 4136
	if (!rv) {
		rv = entry->store(mddev, page, length);
		mddev_unlock(mddev);
	}
4137
	return rv;
4138 4139 4140 4141 4142
}

static void md_free(struct kobject *ko)
{
	mddev_t *mddev = container_of(ko, mddev_t, kobj);
4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153

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

4154 4155 4156
	kfree(mddev);
}

4157
static const struct sysfs_ops md_sysfs_ops = {
4158 4159 4160 4161 4162 4163 4164 4165 4166
	.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 已提交
4167 4168
int mdp_major = 0;

4169 4170 4171 4172
static void mddev_delayed_delete(struct work_struct *ws)
{
	mddev_t *mddev = container_of(ws, mddev_t, del_work);

4173
	sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
4174 4175 4176 4177
	kobject_del(&mddev->kobj);
	kobject_put(&mddev->kobj);
}

4178
static int md_alloc(dev_t dev, char *name)
L
Linus Torvalds 已提交
4179
{
A
Arjan van de Ven 已提交
4180
	static DEFINE_MUTEX(disks_mutex);
L
Linus Torvalds 已提交
4181 4182
	mddev_t *mddev = mddev_find(dev);
	struct gendisk *disk;
4183 4184 4185
	int partitioned;
	int shift;
	int unit;
4186
	int error;
L
Linus Torvalds 已提交
4187 4188

	if (!mddev)
4189 4190 4191 4192 4193
		return -ENODEV;

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

4195 4196 4197 4198 4199
	/* wait for any previous instance if this device
	 * to be completed removed (mddev_delayed_delete).
	 */
	flush_scheduled_work();

A
Arjan van de Ven 已提交
4200
	mutex_lock(&disks_mutex);
N
NeilBrown 已提交
4201 4202 4203
	error = -EEXIST;
	if (mddev->gendisk)
		goto abort;
4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214

	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 已提交
4215
				goto abort;
4216 4217
			}
		spin_unlock(&all_mddevs_lock);
L
Linus Torvalds 已提交
4218
	}
4219

N
NeilBrown 已提交
4220
	error = -ENOMEM;
4221
	mddev->queue = blk_alloc_queue(GFP_KERNEL);
N
NeilBrown 已提交
4222 4223
	if (!mddev->queue)
		goto abort;
4224 4225
	mddev->queue->queuedata = mddev;

4226 4227 4228
	/* Can be unlocked because the queue is new: no concurrency */
	queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, mddev->queue);

4229
	blk_queue_make_request(mddev->queue, md_make_request);
4230

L
Linus Torvalds 已提交
4231 4232
	disk = alloc_disk(1 << shift);
	if (!disk) {
4233 4234
		blk_cleanup_queue(mddev->queue);
		mddev->queue = NULL;
N
NeilBrown 已提交
4235
		goto abort;
L
Linus Torvalds 已提交
4236
	}
4237
	disk->major = MAJOR(mddev->unit);
L
Linus Torvalds 已提交
4238
	disk->first_minor = unit << shift;
4239 4240 4241
	if (name)
		strcpy(disk->disk_name, name);
	else if (partitioned)
L
Linus Torvalds 已提交
4242
		sprintf(disk->disk_name, "md_d%d", unit);
4243
	else
L
Linus Torvalds 已提交
4244 4245 4246 4247
		sprintf(disk->disk_name, "md%d", unit);
	disk->fops = &md_fops;
	disk->private_data = mddev;
	disk->queue = mddev->queue;
4248
	/* Allow extended partitions.  This makes the
4249
	 * 'mdp' device redundant, but we can't really
4250 4251 4252
	 * remove it now.
	 */
	disk->flags |= GENHD_FL_EXT_DEVT;
L
Linus Torvalds 已提交
4253 4254
	add_disk(disk);
	mddev->gendisk = disk;
4255 4256
	error = kobject_init_and_add(&mddev->kobj, &md_ktype,
				     &disk_to_dev(disk)->kobj, "%s", "md");
N
NeilBrown 已提交
4257 4258 4259 4260
	if (error) {
		/* This isn't possible, but as kobject_init_and_add is marked
		 * __must_check, we must do something with the result
		 */
4261 4262
		printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
		       disk->disk_name);
N
NeilBrown 已提交
4263 4264
		error = 0;
	}
N
NeilBrown 已提交
4265 4266
	if (mddev->kobj.sd &&
	    sysfs_create_group(&mddev->kobj, &md_bitmap_group))
4267
		printk(KERN_DEBUG "pointless warning\n");
N
NeilBrown 已提交
4268 4269
 abort:
	mutex_unlock(&disks_mutex);
N
NeilBrown 已提交
4270
	if (!error && mddev->kobj.sd) {
4271
		kobject_uevent(&mddev->kobj, KOBJ_ADD);
N
NeilBrown 已提交
4272
		mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
4273
	}
4274
	mddev_put(mddev);
N
NeilBrown 已提交
4275
	return error;
4276 4277 4278 4279 4280
}

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

4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302
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 已提交
4303 4304 4305 4306
static void md_safemode_timeout(unsigned long data)
{
	mddev_t *mddev = (mddev_t *) data;

4307 4308 4309
	if (!atomic_read(&mddev->writes_pending)) {
		mddev->safemode = 1;
		if (mddev->external)
N
NeilBrown 已提交
4310
			sysfs_notify_dirent_safe(mddev->sysfs_state);
4311
	}
L
Linus Torvalds 已提交
4312 4313 4314
	md_wakeup_thread(mddev->thread);
}

4315
static int start_dirty_degraded;
L
Linus Torvalds 已提交
4316

4317
int md_run(mddev_t *mddev)
L
Linus Torvalds 已提交
4318
{
4319
	int err;
L
Linus Torvalds 已提交
4320
	mdk_rdev_t *rdev;
4321
	struct mdk_personality *pers;
L
Linus Torvalds 已提交
4322

4323 4324
	if (list_empty(&mddev->disks))
		/* cannot run an array with no devices.. */
L
Linus Torvalds 已提交
4325 4326 4327 4328
		return -EINVAL;

	if (mddev->pers)
		return -EBUSY;
4329 4330 4331
	/* Cannot run until previous stop completes properly */
	if (mddev->sysfs_active)
		return -EBUSY;
4332

L
Linus Torvalds 已提交
4333 4334 4335
	/*
	 * Analyze all RAID superblock(s)
	 */
4336 4337 4338
	if (!mddev->raid_disks) {
		if (!mddev->persistent)
			return -EINVAL;
4339
		analyze_sbs(mddev);
4340
	}
L
Linus Torvalds 已提交
4341

4342 4343 4344 4345
	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 已提交
4346 4347 4348 4349 4350 4351

	/*
	 * Drop all container device buffers, from now on
	 * the only valid external interface is through the md
	 * device.
	 */
4352
	list_for_each_entry(rdev, &mddev->disks, same_set) {
4353
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
4354 4355
			continue;
		sync_blockdev(rdev->bdev);
4356
		invalidate_bdev(rdev->bdev);
4357 4358 4359

		/* perform some consistency tests on the device.
		 * We don't want the data to overlap the metadata,
A
Andre Noll 已提交
4360
		 * Internal Bitmap issues have been handled elsewhere.
4361
		 */
4362
		if (rdev->data_offset < rdev->sb_start) {
A
Andre Noll 已提交
4363 4364
			if (mddev->dev_sectors &&
			    rdev->data_offset + mddev->dev_sectors
4365
			    > rdev->sb_start) {
4366 4367 4368 4369 4370
				printk("md: %s: data overlaps metadata\n",
				       mdname(mddev));
				return -EINVAL;
			}
		} else {
4371
			if (rdev->sb_start + rdev->sb_size/512
4372 4373 4374 4375 4376 4377
			    > rdev->data_offset) {
				printk("md: %s: metadata overlaps data\n",
				       mdname(mddev));
				return -EINVAL;
			}
		}
N
NeilBrown 已提交
4378
		sysfs_notify_dirent_safe(rdev->sysfs_state);
L
Linus Torvalds 已提交
4379 4380 4381
	}

	spin_lock(&pers_lock);
4382
	pers = find_pers(mddev->level, mddev->clevel);
4383
	if (!pers || !try_module_get(pers->owner)) {
L
Linus Torvalds 已提交
4384
		spin_unlock(&pers_lock);
4385 4386 4387 4388 4389 4390
		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 已提交
4391 4392
		return -EINVAL;
	}
4393
	mddev->pers = pers;
L
Linus Torvalds 已提交
4394
	spin_unlock(&pers_lock);
4395 4396 4397 4398
	if (mddev->level != pers->level) {
		mddev->level = pers->level;
		mddev->new_level = pers->level;
	}
4399
	strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
L
Linus Torvalds 已提交
4400

4401
	if (mddev->reshape_position != MaxSector &&
4402
	    pers->start_reshape == NULL) {
4403 4404 4405 4406 4407 4408
		/* This personality cannot handle reshaping... */
		mddev->pers = NULL;
		module_put(pers->owner);
		return -EINVAL;
	}

4409 4410 4411 4412 4413 4414 4415
	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;
4416 4417 4418

		list_for_each_entry(rdev, &mddev->disks, same_set)
			list_for_each_entry(rdev2, &mddev->disks, same_set) {
4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431
				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;
				}
			}
4432

4433 4434 4435 4436 4437 4438
		if (warned)
			printk(KERN_WARNING
			       "True protection against single-disk"
			       " failure might be compromised.\n");
	}

4439
	mddev->recovery = 0;
A
Andre Noll 已提交
4440 4441 4442
	/* may be over-ridden by personality */
	mddev->resync_max_sectors = mddev->dev_sectors;

4443
	mddev->ok_start_degraded = start_dirty_degraded;
L
Linus Torvalds 已提交
4444

4445
	if (start_readonly && mddev->ro == 0)
4446 4447
		mddev->ro = 2; /* read-only, but switch on first write */

4448
	err = mddev->pers->run(mddev);
4449 4450
	if (err)
		printk(KERN_ERR "md: pers->run() failed ...\n");
D
Dan Williams 已提交
4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461
	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) {
4462 4463 4464 4465 4466 4467 4468
		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 已提交
4469 4470 4471
	if (err) {
		module_put(mddev->pers->owner);
		mddev->pers = NULL;
4472 4473
		bitmap_destroy(mddev);
		return err;
L
Linus Torvalds 已提交
4474
	}
4475
	if (mddev->pers->sync_request) {
N
NeilBrown 已提交
4476 4477
		if (mddev->kobj.sd &&
		    sysfs_create_group(&mddev->kobj, &md_redundancy_group))
4478 4479 4480
			printk(KERN_WARNING
			       "md: cannot register extra attributes for %s\n",
			       mdname(mddev));
N
NeilBrown 已提交
4481
		mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
4482
	} else if (mddev->ro == 2) /* auto-readonly not meaningful */
4483 4484
		mddev->ro = 0;

L
Linus Torvalds 已提交
4485
 	atomic_set(&mddev->writes_pending,0);
4486 4487
	atomic_set(&mddev->max_corr_read_errors,
		   MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
L
Linus Torvalds 已提交
4488 4489 4490
	mddev->safemode = 0;
	mddev->safemode_timer.function = md_safemode_timeout;
	mddev->safemode_timer.data = (unsigned long) mddev;
4491
	mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
L
Linus Torvalds 已提交
4492
	mddev->in_sync = 1;
4493

4494
	list_for_each_entry(rdev, &mddev->disks, same_set)
4495 4496 4497
		if (rdev->raid_disk >= 0) {
			char nm[20];
			sprintf(nm, "rd%d", rdev->raid_disk);
4498
			if (sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
N
NeilBrown 已提交
4499
				/* failure here is OK */;
4500
		}
L
Linus Torvalds 已提交
4501 4502 4503
	
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	
4504 4505
	if (mddev->flags)
		md_update_sb(mddev, 0);
L
Linus Torvalds 已提交
4506

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

4510
	md_new_event(mddev);
N
NeilBrown 已提交
4511 4512
	sysfs_notify_dirent_safe(mddev->sysfs_state);
	sysfs_notify_dirent_safe(mddev->sysfs_action);
4513
	sysfs_notify(&mddev->kobj, NULL, "degraded");
L
Linus Torvalds 已提交
4514 4515
	return 0;
}
4516
EXPORT_SYMBOL_GPL(md_run);
L
Linus Torvalds 已提交
4517

4518 4519 4520 4521 4522 4523 4524
static int do_md_run(mddev_t *mddev)
{
	int err;

	err = md_run(mddev);
	if (err)
		goto out;
4525 4526 4527 4528 4529
	err = bitmap_load(mddev);
	if (err) {
		bitmap_destroy(mddev);
		goto out;
	}
4530 4531 4532 4533 4534 4535 4536
	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 已提交
4537 4538 4539 4540
static int restart_array(mddev_t *mddev)
{
	struct gendisk *disk = mddev->gendisk;

A
Andre Noll 已提交
4541
	/* Complain if it has no devices */
L
Linus Torvalds 已提交
4542
	if (list_empty(&mddev->disks))
A
Andre Noll 已提交
4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556
		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 已提交
4557
	sysfs_notify_dirent_safe(mddev->sysfs_state);
A
Andre Noll 已提交
4558
	return 0;
L
Linus Torvalds 已提交
4559 4560
}

4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577
/* 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;
}

4578
void restore_bitmap_write_access(struct file *file)
4579 4580 4581 4582 4583 4584 4585 4586
{
	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 已提交
4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608
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;
4609
	mddev->can_decrease_events = 0;
N
NeilBrown 已提交
4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626
	mddev->delta_disks = 0;
	mddev->new_level = LEVEL_NONE;
	mddev->new_layout = 0;
	mddev->new_chunk_sectors = 0;
	mddev->curr_resync = 0;
	mddev->resync_mismatches = 0;
	mddev->suspend_lo = mddev->suspend_hi = 0;
	mddev->sync_speed_min = mddev->sync_speed_max = 0;
	mddev->recovery = 0;
	mddev->in_sync = 0;
	mddev->degraded = 0;
	mddev->safemode = 0;
	mddev->bitmap_info.offset = 0;
	mddev->bitmap_info.default_offset = 0;
	mddev->bitmap_info.chunksize = 0;
	mddev->bitmap_info.daemon_sleep = 0;
	mddev->bitmap_info.max_write_behind = 0;
4627
	mddev->plug = NULL;
N
NeilBrown 已提交
4628 4629
}

4630
void md_stop_writes(mddev_t *mddev)
4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649
{
	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);
	}
}
4650
EXPORT_SYMBOL_GPL(md_stop_writes);
4651

4652
void md_stop(mddev_t *mddev)
N
NeilBrown 已提交
4653 4654 4655 4656 4657 4658
{
	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 已提交
4659
	clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
N
NeilBrown 已提交
4660
}
4661
EXPORT_SYMBOL_GPL(md_stop);
N
NeilBrown 已提交
4662

4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680
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 已提交
4681
		sysfs_notify_dirent_safe(mddev->sysfs_state);
4682 4683 4684 4685 4686 4687 4688
		err = 0;	
	}
out:
	mutex_unlock(&mddev->open_mutex);
	return err;
}

4689 4690 4691 4692
/* mode:
 *   0 - completely stop and dis-assemble array
 *   2 - stop but do not disassemble array
 */
4693
static int do_md_stop(mddev_t * mddev, int mode, int is_open)
L
Linus Torvalds 已提交
4694 4695
{
	struct gendisk *disk = mddev->gendisk;
4696
	mdk_rdev_t *rdev;
L
Linus Torvalds 已提交
4697

N
NeilBrown 已提交
4698
	mutex_lock(&mddev->open_mutex);
4699 4700
	if (atomic_read(&mddev->openers) > is_open ||
	    mddev->sysfs_active) {
4701
		printk("md: %s still in use.\n",mdname(mddev));
N
NeilBrown 已提交
4702 4703 4704
		mutex_unlock(&mddev->open_mutex);
		return -EBUSY;
	}
L
Linus Torvalds 已提交
4705

N
NeilBrown 已提交
4706
	if (mddev->pers) {
4707 4708
		if (mddev->ro)
			set_disk_ro(disk, 0);
4709

4710
		md_stop_writes(mddev);
4711 4712 4713 4714
		md_stop(mddev);
		mddev->queue->merge_bvec_fn = NULL;
		mddev->queue->unplug_fn = NULL;
		mddev->queue->backing_dev_info.congested_fn = NULL;
N
NeilBrown 已提交
4715

4716
		/* tell userspace to handle 'inactive' */
N
NeilBrown 已提交
4717
		sysfs_notify_dirent_safe(mddev->sysfs_state);
4718

4719 4720 4721 4722 4723 4724
		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);
			}
4725

4726
		set_capacity(disk, 0);
N
NeilBrown 已提交
4727
		mutex_unlock(&mddev->open_mutex);
4728
		revalidate_disk(disk);
4729

4730 4731
		if (mddev->ro)
			mddev->ro = 0;
N
NeilBrown 已提交
4732 4733
	} else
		mutex_unlock(&mddev->open_mutex);
L
Linus Torvalds 已提交
4734 4735 4736
	/*
	 * Free resources if final stop
	 */
4737
	if (mode == 0) {
L
Linus Torvalds 已提交
4738 4739
		printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));

4740
		bitmap_destroy(mddev);
4741 4742 4743 4744
		if (mddev->bitmap_info.file) {
			restore_bitmap_write_access(mddev->bitmap_info.file);
			fput(mddev->bitmap_info.file);
			mddev->bitmap_info.file = NULL;
4745
		}
4746
		mddev->bitmap_info.offset = 0;
4747

L
Linus Torvalds 已提交
4748 4749
		export_array(mddev);

N
NeilBrown 已提交
4750
		md_clean(mddev);
4751
		kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
4752 4753
		if (mddev->hold_active == UNTIL_STOP)
			mddev->hold_active = 0;
4754
	}
M
Martin K. Petersen 已提交
4755
	blk_integrity_unregister(disk);
4756
	md_new_event(mddev);
N
NeilBrown 已提交
4757
	sysfs_notify_dirent_safe(mddev->sysfs_state);
N
NeilBrown 已提交
4758
	return 0;
L
Linus Torvalds 已提交
4759 4760
}

J
Jeff Garzik 已提交
4761
#ifndef MODULE
L
Linus Torvalds 已提交
4762 4763 4764 4765 4766
static void autorun_array(mddev_t *mddev)
{
	mdk_rdev_t *rdev;
	int err;

4767
	if (list_empty(&mddev->disks))
L
Linus Torvalds 已提交
4768 4769 4770 4771
		return;

	printk(KERN_INFO "md: running: ");

4772
	list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
4773 4774 4775 4776 4777
		char b[BDEVNAME_SIZE];
		printk("<%s>", bdevname(rdev->bdev,b));
	}
	printk("\n");

4778
	err = do_md_run(mddev);
L
Linus Torvalds 已提交
4779 4780
	if (err) {
		printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
4781
		do_md_stop(mddev, 0, 0);
L
Linus Torvalds 已提交
4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798
	}
}

/*
 * 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)
{
4799
	mdk_rdev_t *rdev0, *rdev, *tmp;
L
Linus Torvalds 已提交
4800 4801 4802 4803 4804
	mddev_t *mddev;
	char b[BDEVNAME_SIZE];

	printk(KERN_INFO "md: autorun ...\n");
	while (!list_empty(&pending_raid_disks)) {
4805
		int unit;
L
Linus Torvalds 已提交
4806
		dev_t dev;
4807
		LIST_HEAD(candidates);
L
Linus Torvalds 已提交
4808 4809 4810 4811 4812 4813
		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);
4814
		rdev_for_each_list(rdev, tmp, &pending_raid_disks)
L
Linus Torvalds 已提交
4815 4816 4817 4818 4819 4820 4821 4822 4823 4824
			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.
		 */
4825 4826 4827 4828 4829 4830 4831 4832 4833
		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 已提交
4834 4835 4836 4837 4838 4839 4840
			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 已提交
4841 4842 4843 4844
		if (!mddev || !mddev->gendisk) {
			if (mddev)
				mddev_put(mddev);
			printk(KERN_ERR
L
Linus Torvalds 已提交
4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858
				"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));
4859
			mddev->persistent = 1;
4860
			rdev_for_each_list(rdev, tmp, &candidates) {
L
Linus Torvalds 已提交
4861 4862 4863 4864 4865 4866 4867 4868 4869 4870
				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...
		 */
4871
		rdev_for_each_list(rdev, tmp, &candidates) {
4872
			list_del_init(&rdev->same_set);
L
Linus Torvalds 已提交
4873
			export_rdev(rdev);
4874
		}
L
Linus Torvalds 已提交
4875 4876 4877 4878
		mddev_put(mddev);
	}
	printk(KERN_INFO "md: ... autorun DONE.\n");
}
J
Jeff Garzik 已提交
4879
#endif /* !MODULE */
L
Linus Torvalds 已提交
4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897

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

4901
	nr=working=insync=failed=spare=0;
4902
	list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
4903
		nr++;
4904
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
4905 4906 4907
			failed++;
		else {
			working++;
4908
			if (test_bit(In_sync, &rdev->flags))
4909
				insync++;	
L
Linus Torvalds 已提交
4910 4911 4912 4913 4914 4915 4916 4917 4918 4919
			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 已提交
4920 4921
	info.size          = mddev->dev_sectors / 2;
	if (info.size != mddev->dev_sectors / 2) /* overflow */
4922
		info.size = -1;
L
Linus Torvalds 已提交
4923 4924 4925 4926 4927 4928 4929 4930 4931
	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);
4932
	if (mddev->bitmap && mddev->bitmap_info.offset)
4933
		info.state = (1<<MD_SB_BITMAP_PRESENT);
4934
	info.active_disks  = insync;
L
Linus Torvalds 已提交
4935 4936 4937 4938 4939
	info.working_disks = working;
	info.failed_disks  = failed;
	info.spare_disks   = spare;

	info.layout        = mddev->layout;
4940
	info.chunk_size    = mddev->chunk_sectors << 9;
L
Linus Torvalds 已提交
4941 4942 4943 4944 4945 4946 4947

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

	return 0;
}

4948
static int get_bitmap_file(mddev_t * mddev, void __user * arg)
4949 4950 4951 4952 4953
{
	mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
	char *ptr, *buf = NULL;
	int err = -ENOMEM;

4954 4955 4956 4957
	if (md_allow_write(mddev))
		file = kmalloc(sizeof(*file), GFP_NOIO);
	else
		file = kmalloc(sizeof(*file), GFP_KERNEL);
4958

4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971
	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 已提交
4972 4973
	ptr = d_path(&mddev->bitmap->file->f_path, buf, sizeof(file->pathname));
	if (IS_ERR(ptr))
4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987
		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 已提交
4988 4989 4990 4991 4992 4993 4994 4995
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;

4996
	rdev = find_rdev_nr(mddev, info.number);
L
Linus Torvalds 已提交
4997 4998 4999 5000 5001
	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;
5002
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
5003
			info.state |= (1<<MD_DISK_FAULTY);
5004
		else if (test_bit(In_sync, &rdev->flags)) {
L
Linus Torvalds 已提交
5005 5006 5007
			info.state |= (1<<MD_DISK_ACTIVE);
			info.state |= (1<<MD_DISK_SYNC);
		}
5008 5009
		if (test_bit(WriteMostly, &rdev->flags))
			info.state |= (1<<MD_DISK_WRITEMOSTLY);
L
Linus Torvalds 已提交
5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043
	} 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);
5044
			err = super_types[mddev->major_version]
L
Linus Torvalds 已提交
5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073
				.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;
		}
5074 5075 5076 5077 5078
		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 已提交
5079 5080 5081 5082 5083 5084
		if (IS_ERR(rdev)) {
			printk(KERN_WARNING 
				"md: md_import_device returned %ld\n",
				PTR_ERR(rdev));
			return PTR_ERR(rdev);
		}
5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096
		/* 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;

5097
		clear_bit(In_sync, &rdev->flags); /* just to be sure */
5098 5099
		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);
5100 5101
		else
			clear_bit(WriteMostly, &rdev->flags);
5102

L
Linus Torvalds 已提交
5103 5104
		rdev->raid_disk = -1;
		err = bind_rdev_to_array(rdev, mddev);
5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115
		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 已提交
5116 5117
		if (err)
			export_rdev(rdev);
5118
		else
N
NeilBrown 已提交
5119
			sysfs_notify_dirent_safe(rdev->sysfs_state);
5120

5121
		md_update_sb(mddev, 1);
5122 5123
		if (mddev->degraded)
			set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
5124
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5125
		md_wakeup_thread(mddev->thread);
L
Linus Torvalds 已提交
5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139
		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;
5140
		rdev = md_import_device(dev, -1, 0);
L
Linus Torvalds 已提交
5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153
		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)
5154 5155
			if (info->state & (1<<MD_DISK_SYNC))
				set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
5156

5157 5158 5159
		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);

L
Linus Torvalds 已提交
5160 5161
		if (!mddev->persistent) {
			printk(KERN_INFO "md: nonpersistent superblock ...\n");
5162
			rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
L
Linus Torvalds 已提交
5163
		} else 
5164
			rdev->sb_start = calc_dev_sboffset(rdev->bdev);
5165
		rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
5166

5167 5168 5169 5170 5171
		err = bind_rdev_to_array(rdev, mddev);
		if (err) {
			export_rdev(rdev);
			return err;
		}
L
Linus Torvalds 已提交
5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189
	}

	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);
5190
	md_update_sb(mddev, 1);
5191
	md_new_event(mddev);
L
Linus Torvalds 已提交
5192 5193 5194

	return 0;
busy:
5195
	printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
L
Linus Torvalds 已提交
5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221
		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;
	}

5222
	rdev = md_import_device(dev, -1, 0);
L
Linus Torvalds 已提交
5223 5224 5225 5226 5227 5228 5229 5230
	if (IS_ERR(rdev)) {
		printk(KERN_WARNING 
			"md: error, md_import_device() returned %ld\n",
			PTR_ERR(rdev));
		return -EINVAL;
	}

	if (mddev->persistent)
5231
		rdev->sb_start = calc_dev_sboffset(rdev->bdev);
L
Linus Torvalds 已提交
5232
	else
5233
		rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
L
Linus Torvalds 已提交
5234

5235
	rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
5236

5237
	if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
5238 5239 5240 5241 5242 5243
		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;
	}
5244
	clear_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
5245
	rdev->desc_nr = -1;
5246
	rdev->saved_raid_disk = -1;
5247 5248 5249
	err = bind_rdev_to_array(rdev, mddev);
	if (err)
		goto abort_export;
L
Linus Torvalds 已提交
5250 5251 5252 5253 5254 5255 5256 5257

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

	rdev->raid_disk = -1;

5258
	md_update_sb(mddev, 1);
L
Linus Torvalds 已提交
5259 5260 5261 5262 5263 5264 5265

	/*
	 * 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);
5266
	md_new_event(mddev);
L
Linus Torvalds 已提交
5267 5268 5269 5270 5271 5272 5273
	return 0;

abort_export:
	export_rdev(rdev);
	return err;
}

5274 5275 5276 5277
static int set_bitmap_file(mddev_t *mddev, int fd)
{
	int err;

5278 5279 5280 5281 5282 5283 5284
	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.. */
	}
5285 5286


5287 5288 5289
	if (fd >= 0) {
		if (mddev->bitmap)
			return -EEXIST; /* cannot add when bitmap is present */
5290
		mddev->bitmap_info.file = fget(fd);
5291

5292
		if (mddev->bitmap_info.file == NULL) {
5293 5294 5295 5296 5297
			printk(KERN_ERR "%s: error: failed to get bitmap file\n",
			       mdname(mddev));
			return -EBADF;
		}

5298
		err = deny_bitmap_write_access(mddev->bitmap_info.file);
5299 5300 5301
		if (err) {
			printk(KERN_ERR "%s: error: bitmap file is already in use\n",
			       mdname(mddev));
5302 5303
			fput(mddev->bitmap_info.file);
			mddev->bitmap_info.file = NULL;
5304 5305
			return err;
		}
5306
		mddev->bitmap_info.offset = 0; /* file overrides offset */
5307 5308 5309 5310 5311
	} else if (mddev->bitmap == NULL)
		return -ENOENT; /* cannot remove what isn't there */
	err = 0;
	if (mddev->pers) {
		mddev->pers->quiesce(mddev, 1);
5312
		if (fd >= 0) {
5313
			err = bitmap_create(mddev);
5314 5315 5316
			if (!err)
				err = bitmap_load(mddev);
		}
5317
		if (fd < 0 || err) {
5318
			bitmap_destroy(mddev);
5319 5320
			fd = -1; /* make sure to put the file */
		}
5321
		mddev->pers->quiesce(mddev, 0);
5322 5323
	}
	if (fd < 0) {
5324 5325 5326
		if (mddev->bitmap_info.file) {
			restore_bitmap_write_access(mddev->bitmap_info.file);
			fput(mddev->bitmap_info.file);
5327
		}
5328
		mddev->bitmap_info.file = NULL;
5329 5330
	}

5331 5332 5333
	return err;
}

L
Linus Torvalds 已提交
5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352
/*
 * 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 ||
5353
		    info->major_version >= ARRAY_SIZE(super_types) ||
L
Linus Torvalds 已提交
5354 5355 5356 5357 5358 5359 5360 5361 5362 5363
		    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;
5364
		mddev->persistent = !info->not_persistent;
5365 5366 5367 5368
		/* ensure mddev_put doesn't delete this now that there
		 * is some minimal configuration.
		 */
		mddev->ctime         = get_seconds();
L
Linus Torvalds 已提交
5369 5370 5371 5372 5373 5374 5375 5376
		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;
5377
	mddev->clevel[0]     = 0;
A
Andre Noll 已提交
5378
	mddev->dev_sectors   = 2 * (sector_t)info->size;
L
Linus Torvalds 已提交
5379 5380 5381 5382 5383 5384 5385 5386 5387
	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;
5388
	mddev->external	     = 0;
L
Linus Torvalds 已提交
5389 5390

	mddev->layout        = info->layout;
5391
	mddev->chunk_sectors = info->chunk_size >> 9;
L
Linus Torvalds 已提交
5392 5393 5394

	mddev->max_disks     = MD_SB_DISKS;

5395 5396
	if (mddev->persistent)
		mddev->flags         = 0;
5397
	set_bit(MD_CHANGE_DEVS, &mddev->flags);
L
Linus Torvalds 已提交
5398

5399 5400
	mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
	mddev->bitmap_info.offset = 0;
5401

5402 5403
	mddev->reshape_position = MaxSector;

L
Linus Torvalds 已提交
5404 5405 5406 5407 5408
	/*
	 * Generate a 128 bit UUID
	 */
	get_random_bytes(mddev->uuid, 16);

5409
	mddev->new_level = mddev->level;
5410
	mddev->new_chunk_sectors = mddev->chunk_sectors;
5411 5412 5413
	mddev->new_layout = mddev->layout;
	mddev->delta_disks = 0;

L
Linus Torvalds 已提交
5414 5415 5416
	return 0;
}

5417 5418
void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors)
{
D
Dan Williams 已提交
5419 5420 5421 5422 5423
	WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);

	if (mddev->external_size)
		return;

5424 5425 5426 5427
	mddev->array_sectors = array_sectors;
}
EXPORT_SYMBOL(md_set_array_sectors);

5428
static int update_size(mddev_t *mddev, sector_t num_sectors)
5429
{
5430
	mdk_rdev_t *rdev;
5431
	int rv;
5432
	int fit = (num_sectors == 0);
5433 5434 5435

	if (mddev->pers->resize == NULL)
		return -EINVAL;
5436 5437 5438 5439 5440
	/* 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
5441
	 * sb_start or, if that is <data_offset, it must fit before the size
5442 5443 5444
	 * of each device.  If num_sectors is zero, we find the largest size
	 * that fits.

5445 5446 5447
	 */
	if (mddev->sync_thread)
		return -EBUSY;
5448 5449 5450 5451 5452
	if (mddev->bitmap)
		/* Sorry, cannot grow a bitmap yet, just remove it,
		 * grow, and re-add.
		 */
		return -EBUSY;
5453
	list_for_each_entry(rdev, &mddev->disks, same_set) {
5454
		sector_t avail = rdev->sectors;
5455

5456 5457 5458
		if (fit && (num_sectors == 0 || num_sectors > avail))
			num_sectors = avail;
		if (avail < num_sectors)
5459 5460
			return -ENOSPC;
	}
5461
	rv = mddev->pers->resize(mddev, num_sectors);
5462 5463
	if (!rv)
		revalidate_disk(mddev->gendisk);
5464 5465 5466
	return rv;
}

5467 5468 5469 5470
static int update_raid_disks(mddev_t *mddev, int raid_disks)
{
	int rv;
	/* change the number of raid disks */
5471
	if (mddev->pers->check_reshape == NULL)
5472 5473
		return -EINVAL;
	if (raid_disks <= 0 ||
5474
	    (mddev->max_disks && raid_disks >= mddev->max_disks))
5475
		return -EINVAL;
5476
	if (mddev->sync_thread || mddev->reshape_position != MaxSector)
5477
		return -EBUSY;
5478 5479 5480
	mddev->delta_disks = raid_disks - mddev->raid_disks;

	rv = mddev->pers->check_reshape(mddev);
5481 5482 5483 5484
	return rv;
}


L
Linus Torvalds 已提交
5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496
/*
 * 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;
5497 5498 5499
	int state = 0;

	/* calculate expected state,ignoring low bits */
5500
	if (mddev->bitmap && mddev->bitmap_info.offset)
5501
		state |= (1 << MD_SB_BITMAP_PRESENT);
L
Linus Torvalds 已提交
5502 5503 5504 5505 5506 5507 5508 5509

	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||
5510
	    mddev->chunk_sectors != info->chunk_size >> 9 ||
5511 5512 5513
	    /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
	    ((state^info->state) & 0xfffffe00)
		)
L
Linus Torvalds 已提交
5514 5515
		return -EINVAL;
	/* Check there is only one change */
A
Andre Noll 已提交
5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527
	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 已提交
5528 5529 5530 5531 5532 5533

	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.
		 */
5534
		if (mddev->pers->check_reshape == NULL)
L
Linus Torvalds 已提交
5535
			return -EINVAL;
5536 5537
		else {
			mddev->new_layout = info->layout;
5538
			rv = mddev->pers->check_reshape(mddev);
5539 5540 5541 5542
			if (rv)
				mddev->new_layout = mddev->layout;
			return rv;
		}
L
Linus Torvalds 已提交
5543
	}
A
Andre Noll 已提交
5544
	if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
5545
		rv = update_size(mddev, (sector_t)info->size * 2);
5546

5547 5548 5549
	if (mddev->raid_disks    != info->raid_disks)
		rv = update_raid_disks(mddev, info->raid_disks);

5550 5551 5552 5553 5554 5555 5556 5557 5558
	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;
5559
			if (mddev->bitmap_info.default_offset == 0)
5560
				return -EINVAL;
5561 5562
			mddev->bitmap_info.offset =
				mddev->bitmap_info.default_offset;
5563 5564
			mddev->pers->quiesce(mddev, 1);
			rv = bitmap_create(mddev);
5565 5566
			if (!rv)
				rv = bitmap_load(mddev);
5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578
			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);
5579
			mddev->bitmap_info.offset = 0;
5580 5581
		}
	}
5582
	md_update_sb(mddev, 1);
L
Linus Torvalds 已提交
5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600
	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;
}

5601 5602 5603 5604 5605 5606
/*
 * 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... ;-)
 */
5607 5608 5609 5610 5611 5612
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;
5613
	geo->cylinders = mddev->array_sectors / 8;
5614 5615 5616
	return 0;
}

A
Al Viro 已提交
5617
static int md_ioctl(struct block_device *bdev, fmode_t mode,
L
Linus Torvalds 已提交
5618 5619 5620 5621 5622
			unsigned int cmd, unsigned long arg)
{
	int err = 0;
	void __user *argp = (void __user *)arg;
	mddev_t *mddev = NULL;
5623
	int ro;
L
Linus Torvalds 已提交
5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655

	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 已提交
5656
	mddev = bdev->bd_disk->private_data;
L
Linus Torvalds 已提交
5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 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

	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:
	 */
5720
	/* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
5721
	 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
5722 5723 5724 5725
	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 已提交
5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738
		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;

5739
		case GET_BITMAP_FILE:
5740
			err = get_bitmap_file(mddev, argp);
5741 5742
			goto done_unlock;

L
Linus Torvalds 已提交
5743 5744 5745 5746 5747 5748 5749 5750 5751
		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:
5752
			err = do_md_stop(mddev, 0, 1);
L
Linus Torvalds 已提交
5753 5754 5755
			goto done_unlock;

		case STOP_ARRAY_RO:
5756
			err = md_set_readonly(mddev, 1);
L
Linus Torvalds 已提交
5757 5758
			goto done_unlock;

5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786
		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 已提交
5787 5788 5789 5790
	}

	/*
	 * The remaining ioctls are changing the state of the
5791 5792 5793 5794
	 * 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 已提交
5795
	 */
5796
	if (_IOC_TYPE(cmd) == MD_MAJOR && mddev->ro && mddev->pers) {
5797 5798
		if (mddev->ro == 2) {
			mddev->ro = 0;
N
NeilBrown 已提交
5799
			sysfs_notify_dirent_safe(mddev->sysfs_state);
5800 5801
			set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
			md_wakeup_thread(mddev->thread);
5802 5803 5804 5805
		} else {
			err = -EROFS;
			goto abort_unlock;
		}
L
Linus Torvalds 已提交
5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832
	}

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

5836 5837 5838 5839
		case SET_BITMAP_FILE:
			err = set_bitmap_file(mddev, (int)arg);
			goto done_unlock;

L
Linus Torvalds 已提交
5840 5841 5842 5843 5844 5845 5846
		default:
			err = -EINVAL;
			goto abort_unlock;
	}

done_unlock:
abort_unlock:
5847 5848 5849
	if (mddev->hold_active == UNTIL_IOCTL &&
	    err != -EINVAL)
		mddev->hold_active = 0;
L
Linus Torvalds 已提交
5850 5851 5852 5853 5854 5855 5856 5857 5858
	mddev_unlock(mddev);

	return err;
done:
	if (err)
		MD_BUG();
abort:
	return err;
}
5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877
#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 已提交
5878

A
Al Viro 已提交
5879
static int md_open(struct block_device *bdev, fmode_t mode)
L
Linus Torvalds 已提交
5880 5881 5882 5883 5884
{
	/*
	 * Succeed if we can lock the mddev, which confirms that
	 * it isn't being stopped right now.
	 */
5885
	mddev_t *mddev = mddev_find(bdev->bd_dev);
L
Linus Torvalds 已提交
5886 5887
	int err;

5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899
	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 */
		return -ERESTARTSYS;
	}
	BUG_ON(mddev != bdev->bd_disk->private_data);

N
NeilBrown 已提交
5900
	if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
L
Linus Torvalds 已提交
5901 5902 5903
		goto out;

	err = 0;
5904
	atomic_inc(&mddev->openers);
N
NeilBrown 已提交
5905
	mutex_unlock(&mddev->open_mutex);
L
Linus Torvalds 已提交
5906

5907
	check_disk_size_change(mddev->gendisk, bdev);
L
Linus Torvalds 已提交
5908 5909 5910 5911
 out:
	return err;
}

A
Al Viro 已提交
5912
static int md_release(struct gendisk *disk, fmode_t mode)
L
Linus Torvalds 已提交
5913
{
A
Al Viro 已提交
5914
 	mddev_t *mddev = disk->private_data;
L
Linus Torvalds 已提交
5915

E
Eric Sesterhenn 已提交
5916
	BUG_ON(!mddev);
5917
	atomic_dec(&mddev->openers);
L
Linus Torvalds 已提交
5918 5919 5920 5921
	mddev_put(mddev);

	return 0;
}
5922
static const struct block_device_operations md_fops =
L
Linus Torvalds 已提交
5923 5924
{
	.owner		= THIS_MODULE,
A
Al Viro 已提交
5925 5926
	.open		= md_open,
	.release	= md_release,
N
NeilBrown 已提交
5927
	.ioctl		= md_ioctl,
5928 5929 5930
#ifdef CONFIG_COMPAT
	.compat_ioctl	= md_compat_ioctl,
#endif
5931
	.getgeo		= md_getgeo,
L
Linus Torvalds 已提交
5932 5933
};

A
Adrian Bunk 已提交
5934
static int md_thread(void * arg)
L
Linus Torvalds 已提交
5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949
{
	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 已提交
5950
	allow_signal(SIGKILL);
5951
	while (!kthread_should_stop()) {
L
Linus Torvalds 已提交
5952

5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965
		/* 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 已提交
5966 5967 5968

		clear_bit(THREAD_WAKEUP, &thread->flags);

5969
		thread->run(thread->mddev);
L
Linus Torvalds 已提交
5970
	}
5971

L
Linus Torvalds 已提交
5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988
	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;

5989
	thread = kzalloc(sizeof(mdk_thread_t), GFP_KERNEL);
L
Linus Torvalds 已提交
5990 5991 5992 5993 5994 5995 5996
	if (!thread)
		return NULL;

	init_waitqueue_head(&thread->wqueue);

	thread->run = run;
	thread->mddev = mddev;
5997
	thread->timeout = MAX_SCHEDULE_TIMEOUT;
5998 5999 6000 6001
	thread->tsk = kthread_run(md_thread, thread,
				  "%s_%s",
				  mdname(thread->mddev),
				  name ?: mddev->pers->name);
6002
	if (IS_ERR(thread->tsk)) {
L
Linus Torvalds 已提交
6003 6004 6005 6006 6007 6008 6009 6010
		kfree(thread);
		return NULL;
	}
	return thread;
}

void md_unregister_thread(mdk_thread_t *thread)
{
6011 6012
	if (!thread)
		return;
6013
	dprintk("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
6014 6015

	kthread_stop(thread->tsk);
L
Linus Torvalds 已提交
6016 6017 6018 6019 6020 6021 6022 6023 6024 6025
	kfree(thread);
}

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

6026
	if (!rdev || test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
6027
		return;
6028 6029 6030

	if (mddev->external)
		set_bit(Blocked, &rdev->flags);
6031
/*
L
Linus Torvalds 已提交
6032 6033 6034 6035 6036
	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));
6037
*/
6038 6039
	if (!mddev->pers)
		return;
L
Linus Torvalds 已提交
6040 6041 6042
	if (!mddev->pers->error_handler)
		return;
	mddev->pers->error_handler(mddev,rdev);
6043 6044
	if (mddev->degraded)
		set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
N
NeilBrown 已提交
6045
	sysfs_notify_dirent_safe(rdev->sysfs_state);
L
Linus Torvalds 已提交
6046 6047 6048
	set_bit(MD_RECOVERY_INTR, &mddev->recovery);
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	md_wakeup_thread(mddev->thread);
6049 6050
	if (mddev->event_work.func)
		schedule_work(&mddev->event_work);
6051
	md_new_event_inintr(mddev);
L
Linus Torvalds 已提交
6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062
}

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

6063
	list_for_each_entry(rdev, &pending_raid_disks, same_set) {
L
Linus Torvalds 已提交
6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077
		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)
{
6078 6079 6080
	sector_t max_sectors, resync, res;
	unsigned long dt, db;
	sector_t rt;
6081 6082
	int scale;
	unsigned int per_milli;
L
Linus Torvalds 已提交
6083

6084
	resync = mddev->curr_resync - atomic_read(&mddev->recovery_active);
L
Linus Torvalds 已提交
6085 6086

	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
6087
		max_sectors = mddev->resync_max_sectors;
L
Linus Torvalds 已提交
6088
	else
6089
		max_sectors = mddev->dev_sectors;
L
Linus Torvalds 已提交
6090 6091 6092 6093

	/*
	 * Should not happen.
	 */
6094
	if (!max_sectors) {
L
Linus Torvalds 已提交
6095 6096 6097
		MD_BUG();
		return;
	}
6098
	/* Pick 'scale' such that (resync>>scale)*1000 will fit
6099
	 * in a sector_t, and (max_sectors>>scale) will fit in a
6100 6101 6102 6103 6104
	 * 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)) {
6105
		while ( max_sectors/2 > (1ULL<<(scale+32)))
6106 6107 6108
			scale++;
	}
	res = (resync>>scale)*1000;
6109
	sector_div(res, (u32)((max_sectors>>scale)+1));
6110 6111

	per_milli = res;
L
Linus Torvalds 已提交
6112
	{
6113
		int i, x = per_milli/50, y = 20-x;
L
Linus Torvalds 已提交
6114 6115 6116 6117 6118 6119 6120 6121
		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, "] ");
	}
6122
	seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
6123 6124
		   (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
		    "reshape" :
6125 6126 6127 6128 6129
		    (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
		     "check" :
		     (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
		      "resync" : "recovery"))),
		   per_milli/10, per_milli % 10,
6130 6131
		   (unsigned long long) resync/2,
		   (unsigned long long) max_sectors/2);
L
Linus Torvalds 已提交
6132 6133 6134 6135 6136

	/*
	 * dt: time from mark until now
	 * db: blocks written from mark until now
	 * rt: remaining time
6137 6138 6139 6140 6141 6142 6143 6144 6145
	 *
	 * 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 已提交
6146 6147 6148
	 */
	dt = ((jiffies - mddev->resync_mark) / HZ);
	if (!dt) dt++;
6149 6150
	db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
		- mddev->resync_mark_cnt;
L
Linus Torvalds 已提交
6151

6152 6153 6154 6155 6156 6157 6158
	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 已提交
6159

6160
	seq_printf(seq, " speed=%ldK/sec", db/2/dt);
L
Linus Torvalds 已提交
6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224
}

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

6225 6226 6227 6228
struct mdstat_info {
	int event;
};

L
Linus Torvalds 已提交
6229 6230 6231
static int md_seq_show(struct seq_file *seq, void *v)
{
	mddev_t *mddev = v;
6232
	sector_t sectors;
L
Linus Torvalds 已提交
6233
	mdk_rdev_t *rdev;
6234
	struct mdstat_info *mi = seq->private;
6235
	struct bitmap *bitmap;
L
Linus Torvalds 已提交
6236 6237

	if (v == (void*)1) {
6238
		struct mdk_personality *pers;
L
Linus Torvalds 已提交
6239 6240
		seq_printf(seq, "Personalities : ");
		spin_lock(&pers_lock);
6241 6242
		list_for_each_entry(pers, &pers_list, list)
			seq_printf(seq, "[%s] ", pers->name);
L
Linus Torvalds 已提交
6243 6244 6245

		spin_unlock(&pers_lock);
		seq_printf(seq, "\n");
6246
		mi->event = atomic_read(&md_event_count);
L
Linus Torvalds 已提交
6247 6248 6249 6250 6251 6252 6253
		return 0;
	}
	if (v == (void*)2) {
		status_unused(seq);
		return 0;
	}

I
Ingo Molnar 已提交
6254
	if (mddev_lock(mddev) < 0)
L
Linus Torvalds 已提交
6255
		return -EINTR;
I
Ingo Molnar 已提交
6256

L
Linus Torvalds 已提交
6257 6258 6259 6260
	if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
		seq_printf(seq, "%s : %sactive", mdname(mddev),
						mddev->pers ? "" : "in");
		if (mddev->pers) {
6261
			if (mddev->ro==1)
L
Linus Torvalds 已提交
6262
				seq_printf(seq, " (read-only)");
6263
			if (mddev->ro==2)
6264
				seq_printf(seq, " (auto-read-only)");
L
Linus Torvalds 已提交
6265 6266 6267
			seq_printf(seq, " %s", mddev->pers->name);
		}

6268
		sectors = 0;
6269
		list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
6270 6271 6272
			char b[BDEVNAME_SIZE];
			seq_printf(seq, " %s[%d]",
				bdevname(rdev->bdev,b), rdev->desc_nr);
6273 6274
			if (test_bit(WriteMostly, &rdev->flags))
				seq_printf(seq, "(W)");
6275
			if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
6276 6277
				seq_printf(seq, "(F)");
				continue;
6278 6279
			} else if (rdev->raid_disk < 0)
				seq_printf(seq, "(S)"); /* spare */
6280
			sectors += rdev->sectors;
L
Linus Torvalds 已提交
6281 6282 6283 6284 6285
		}

		if (!list_empty(&mddev->disks)) {
			if (mddev->pers)
				seq_printf(seq, "\n      %llu blocks",
6286 6287
					   (unsigned long long)
					   mddev->array_sectors / 2);
L
Linus Torvalds 已提交
6288 6289
			else
				seq_printf(seq, "\n      %llu blocks",
6290
					   (unsigned long long)sectors / 2);
L
Linus Torvalds 已提交
6291
		}
6292 6293 6294 6295 6296 6297 6298
		if (mddev->persistent) {
			if (mddev->major_version != 0 ||
			    mddev->minor_version != 90) {
				seq_printf(seq," super %d.%d",
					   mddev->major_version,
					   mddev->minor_version);
			}
6299 6300 6301 6302
		} else if (mddev->external)
			seq_printf(seq, " super external:%s",
				   mddev->metadata_type);
		else
6303
			seq_printf(seq, " super non-persistent");
L
Linus Torvalds 已提交
6304 6305

		if (mddev->pers) {
6306
			mddev->pers->status(seq, mddev);
L
Linus Torvalds 已提交
6307
	 		seq_printf(seq, "\n      ");
6308 6309
			if (mddev->pers->sync_request) {
				if (mddev->curr_resync > 2) {
6310
					status_resync(seq, mddev);
6311 6312 6313 6314 6315 6316
					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      ");
			}
6317 6318 6319 6320 6321 6322 6323
		} else
			seq_printf(seq, "\n       ");

		if ((bitmap = mddev->bitmap)) {
			unsigned long chunk_kb;
			unsigned long flags;
			spin_lock_irqsave(&bitmap->lock, flags);
6324
			chunk_kb = mddev->bitmap_info.chunksize >> 10;
6325 6326 6327 6328 6329 6330
			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),
6331
				chunk_kb ? chunk_kb : mddev->bitmap_info.chunksize,
6332
				chunk_kb ? "KB" : "B");
6333 6334
			if (bitmap->file) {
				seq_printf(seq, ", file: ");
6335
				seq_path(seq, &bitmap->file->f_path, " \t\n");
6336
			}
6337

6338 6339
			seq_printf(seq, "\n");
			spin_unlock_irqrestore(&bitmap->lock, flags);
L
Linus Torvalds 已提交
6340 6341 6342 6343 6344 6345 6346 6347 6348
		}

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

J
Jan Engelhardt 已提交
6349
static const struct seq_operations md_seq_ops = {
L
Linus Torvalds 已提交
6350 6351 6352 6353 6354 6355 6356 6357 6358
	.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;
6359 6360 6361
	struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL);
	if (mi == NULL)
		return -ENOMEM;
L
Linus Torvalds 已提交
6362 6363

	error = seq_open(file, &md_seq_ops);
6364 6365 6366 6367 6368 6369 6370
	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 已提交
6371 6372 6373
	return error;
}

6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389
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;
}

6390
static const struct file_operations md_seq_fops = {
6391
	.owner		= THIS_MODULE,
L
Linus Torvalds 已提交
6392 6393 6394
	.open           = md_seq_open,
	.read           = seq_read,
	.llseek         = seq_lseek,
6395
	.release	= seq_release_private,
6396
	.poll		= mdstat_poll,
L
Linus Torvalds 已提交
6397 6398
};

6399
int register_md_personality(struct mdk_personality *p)
L
Linus Torvalds 已提交
6400 6401
{
	spin_lock(&pers_lock);
6402 6403
	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 已提交
6404 6405 6406 6407
	spin_unlock(&pers_lock);
	return 0;
}

6408
int unregister_md_personality(struct mdk_personality *p)
L
Linus Torvalds 已提交
6409
{
6410
	printk(KERN_INFO "md: %s personality unregistered\n", p->name);
L
Linus Torvalds 已提交
6411
	spin_lock(&pers_lock);
6412
	list_del_init(&p->list);
L
Linus Torvalds 已提交
6413 6414 6415 6416
	spin_unlock(&pers_lock);
	return 0;
}

N
NeilBrown 已提交
6417
static int is_mddev_idle(mddev_t *mddev, int init)
L
Linus Torvalds 已提交
6418 6419 6420
{
	mdk_rdev_t * rdev;
	int idle;
N
NeilBrown 已提交
6421
	int curr_events;
L
Linus Torvalds 已提交
6422 6423

	idle = 1;
6424 6425
	rcu_read_lock();
	rdev_for_each_rcu(rdev, mddev) {
L
Linus Torvalds 已提交
6426
		struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
N
NeilBrown 已提交
6427 6428 6429
		curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
			      (int)part_stat_read(&disk->part0, sectors[1]) -
			      atomic_read(&disk->sync_io);
6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449
		/* 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.
6450
		 *
L
Linus Torvalds 已提交
6451
		 */
N
NeilBrown 已提交
6452
		if (init || curr_events - rdev->last_events > 64) {
L
Linus Torvalds 已提交
6453 6454 6455 6456
			rdev->last_events = curr_events;
			idle = 0;
		}
	}
6457
	rcu_read_unlock();
L
Linus Torvalds 已提交
6458 6459 6460 6461 6462 6463 6464 6465 6466
	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) {
6467
		set_bit(MD_RECOVERY_INTR, &mddev->recovery);
L
Linus Torvalds 已提交
6468 6469 6470 6471 6472 6473
		md_wakeup_thread(mddev->thread);
		// stop recovery, signal do_sync ....
	}
}


6474 6475
/* md_write_start(mddev, bi)
 * If we need to update some array metadata (e.g. 'active' flag
6476 6477
 * in superblock) before writing, schedule a superblock update
 * and wait for it to complete.
6478
 */
6479
void md_write_start(mddev_t *mddev, struct bio *bi)
L
Linus Torvalds 已提交
6480
{
6481
	int did_change = 0;
6482
	if (bio_data_dir(bi) != WRITE)
6483
		return;
6484

6485 6486 6487 6488 6489 6490
	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);
6491
		md_wakeup_thread(mddev->sync_thread);
6492
		did_change = 1;
6493
	}
6494
	atomic_inc(&mddev->writes_pending);
6495 6496
	if (mddev->safemode == 1)
		mddev->safemode = 0;
6497
	if (mddev->in_sync) {
6498
		spin_lock_irq(&mddev->write_lock);
6499 6500
		if (mddev->in_sync) {
			mddev->in_sync = 0;
6501
			set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6502
			set_bit(MD_CHANGE_PENDING, &mddev->flags);
6503
			md_wakeup_thread(mddev->thread);
6504
			did_change = 1;
6505
		}
6506
		spin_unlock_irq(&mddev->write_lock);
6507
	}
6508
	if (did_change)
N
NeilBrown 已提交
6509
		sysfs_notify_dirent_safe(mddev->sysfs_state);
6510 6511
	wait_event(mddev->sb_wait,
		   !test_bit(MD_CHANGE_PENDING, &mddev->flags));
L
Linus Torvalds 已提交
6512 6513 6514 6515 6516 6517 6518
}

void md_write_end(mddev_t *mddev)
{
	if (atomic_dec_and_test(&mddev->writes_pending)) {
		if (mddev->safemode == 2)
			md_wakeup_thread(mddev->thread);
6519
		else if (mddev->safemode_delay)
L
Linus Torvalds 已提交
6520 6521 6522 6523
			mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
	}
}

6524 6525 6526 6527 6528
/* 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.
6529 6530 6531
 *
 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
 * is dropped, so return -EAGAIN after notifying userspace.
6532
 */
6533
int md_allow_write(mddev_t *mddev)
6534 6535
{
	if (!mddev->pers)
6536
		return 0;
6537
	if (mddev->ro)
6538
		return 0;
6539
	if (!mddev->pers->sync_request)
6540
		return 0;
6541 6542 6543 6544 6545

	spin_lock_irq(&mddev->write_lock);
	if (mddev->in_sync) {
		mddev->in_sync = 0;
		set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6546
		set_bit(MD_CHANGE_PENDING, &mddev->flags);
6547 6548 6549 6550 6551
		if (mddev->safemode_delay &&
		    mddev->safemode == 0)
			mddev->safemode = 1;
		spin_unlock_irq(&mddev->write_lock);
		md_update_sb(mddev, 0);
N
NeilBrown 已提交
6552
		sysfs_notify_dirent_safe(mddev->sysfs_state);
6553 6554
	} else
		spin_unlock_irq(&mddev->write_lock);
6555

6556
	if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
6557 6558 6559
		return -EAGAIN;
	else
		return 0;
6560 6561 6562
}
EXPORT_SYMBOL_GPL(md_allow_write);

N
NeilBrown 已提交
6563
void md_unplug(mddev_t *mddev)
6564 6565 6566 6567 6568 6569 6570
{
	if (mddev->queue)
		blk_unplug(mddev->queue);
	if (mddev->plug)
		mddev->plug->unplug_fn(mddev->plug);
}

L
Linus Torvalds 已提交
6571 6572
#define SYNC_MARKS	10
#define	SYNC_MARK_STEP	(3*HZ)
6573
void md_do_sync(mddev_t *mddev)
L
Linus Torvalds 已提交
6574 6575 6576 6577
{
	mddev_t *mddev2;
	unsigned int currspeed = 0,
		 window;
6578
	sector_t max_sectors,j, io_sectors;
L
Linus Torvalds 已提交
6579 6580 6581 6582 6583
	unsigned long mark[SYNC_MARKS];
	sector_t mark_cnt[SYNC_MARKS];
	int last_mark,m;
	struct list_head *tmp;
	sector_t last_check;
6584
	int skipped = 0;
6585
	mdk_rdev_t *rdev;
6586
	char *desc;
L
Linus Torvalds 已提交
6587 6588 6589 6590

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

6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605
	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 已提交
6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625
	/* 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:
6626
		if (kthread_should_stop())
N
NeilBrown 已提交
6627
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
6628 6629

		if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
L
Linus Torvalds 已提交
6630
			goto skip;
6631
		for_each_mddev(mddev2, tmp) {
L
Linus Torvalds 已提交
6632 6633
			if (mddev2 == mddev)
				continue;
6634 6635 6636
			if (!mddev->parallel_resync
			&&  mddev2->curr_resync
			&&  match_mddev_units(mddev, mddev2)) {
L
Linus Torvalds 已提交
6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647
				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;
6648 6649 6650 6651 6652
				/* 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);
6653
				if (!kthread_should_stop() &&
6654
				    mddev2->curr_resync >= mddev->curr_resync) {
6655 6656
					printk(KERN_INFO "md: delaying %s of %s"
					       " until %s has finished (they"
L
Linus Torvalds 已提交
6657
					       " share one or more physical units)\n",
6658
					       desc, mdname(mddev), mdname(mddev2));
L
Linus Torvalds 已提交
6659
					mddev_put(mddev2);
6660 6661
					if (signal_pending(current))
						flush_signals(current);
L
Linus Torvalds 已提交
6662 6663 6664 6665 6666 6667 6668 6669 6670
					schedule();
					finish_wait(&resync_wait, &wq);
					goto try_again;
				}
				finish_wait(&resync_wait, &wq);
			}
		}
	} while (mddev->curr_resync < 2);

6671
	j = 0;
6672
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
L
Linus Torvalds 已提交
6673
		/* resync follows the size requested by the personality,
6674
		 * which defaults to physical size, but can be virtual size
L
Linus Torvalds 已提交
6675 6676
		 */
		max_sectors = mddev->resync_max_sectors;
6677
		mddev->resync_mismatches = 0;
6678
		/* we don't use the checkpoint if there's a bitmap */
6679 6680 6681
		if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
			j = mddev->resync_min;
		else if (!mddev->bitmap)
6682
			j = mddev->recovery_cp;
6683

6684
	} else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
A
Andre Noll 已提交
6685
		max_sectors = mddev->dev_sectors;
6686
	else {
L
Linus Torvalds 已提交
6687
		/* recovery follows the physical size of devices */
A
Andre Noll 已提交
6688
		max_sectors = mddev->dev_sectors;
6689
		j = MaxSector;
6690 6691
		rcu_read_lock();
		list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
6692 6693 6694 6695 6696
			if (rdev->raid_disk >= 0 &&
			    !test_bit(Faulty, &rdev->flags) &&
			    !test_bit(In_sync, &rdev->flags) &&
			    rdev->recovery_offset < j)
				j = rdev->recovery_offset;
6697
		rcu_read_unlock();
6698
	}
L
Linus Torvalds 已提交
6699

6700 6701 6702
	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));
6703
	printk(KERN_INFO "md: using maximum available idle IO bandwidth "
6704 6705
	       "(but not more than %d KB/sec) for %s.\n",
	       speed_max(mddev), desc);
L
Linus Torvalds 已提交
6706

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

6709
	io_sectors = 0;
L
Linus Torvalds 已提交
6710 6711
	for (m = 0; m < SYNC_MARKS; m++) {
		mark[m] = jiffies;
6712
		mark_cnt[m] = io_sectors;
L
Linus Torvalds 已提交
6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729
	}
	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 
6730 6731
		       "md: resuming %s of %s from checkpoint.\n",
		       desc, mdname(mddev));
L
Linus Torvalds 已提交
6732 6733
		mddev->curr_resync = j;
	}
6734
	mddev->curr_resync_completed = mddev->curr_resync;
L
Linus Torvalds 已提交
6735 6736

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

6739
		skipped = 0;
6740

6741 6742 6743 6744 6745 6746 6747
		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
			    )) {
6748
			/* time to update curr_resync_completed */
6749
			md_unplug(mddev);
6750 6751 6752 6753
			wait_event(mddev->recovery_wait,
				   atomic_read(&mddev->recovery_active) == 0);
			mddev->curr_resync_completed =
				mddev->curr_resync;
6754
			set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6755
			sysfs_notify(&mddev->kobj, NULL, "sync_completed");
6756
		}
6757

6758 6759 6760 6761 6762 6763 6764 6765 6766 6767
		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());
		}
6768 6769 6770 6771

		if (kthread_should_stop())
			goto interrupted;

6772
		sectors = mddev->pers->sync_request(mddev, j, &skipped,
6773
						  currspeed < speed_min(mddev));
6774
		if (sectors == 0) {
6775
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
L
Linus Torvalds 已提交
6776 6777
			goto out;
		}
6778 6779 6780 6781 6782 6783

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

L
Linus Torvalds 已提交
6784 6785
		j += sectors;
		if (j>1) mddev->curr_resync = j;
6786
		mddev->curr_mark_cnt = io_sectors;
6787 6788 6789 6790 6791
		if (last_check == 0)
			/* this is the earliers that rebuilt will be
			 * visible in /proc/mdstat
			 */
			md_new_event(mddev);
6792 6793

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

6796
		last_check = io_sectors;
L
Linus Torvalds 已提交
6797

6798
		if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
L
Linus Torvalds 已提交
6799 6800 6801 6802 6803 6804 6805 6806 6807 6808
			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;
6809
			mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
L
Linus Torvalds 已提交
6810 6811 6812 6813
			last_mark = next;
		}


6814 6815 6816
		if (kthread_should_stop())
			goto interrupted;

L
Linus Torvalds 已提交
6817 6818 6819 6820 6821 6822 6823 6824 6825

		/*
		 * 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)
		 */
6826
		md_unplug(mddev);
L
Linus Torvalds 已提交
6827 6828
		cond_resched();

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

6832 6833
		if (currspeed > speed_min(mddev)) {
			if ((currspeed > speed_max(mddev)) ||
N
NeilBrown 已提交
6834
					!is_mddev_idle(mddev, 0)) {
6835
				msleep(500);
L
Linus Torvalds 已提交
6836 6837 6838 6839
				goto repeat;
			}
		}
	}
6840
	printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc);
L
Linus Torvalds 已提交
6841 6842 6843 6844
	/*
	 * this also signals 'finished resyncing' to md_stop
	 */
 out:
6845
	md_unplug(mddev);
L
Linus Torvalds 已提交
6846 6847 6848 6849

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

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

6852
	if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
6853 6854 6855 6856 6857
	    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
6858 6859
					       "md: checkpointing %s of %s.\n",
					       desc, mdname(mddev));
6860 6861 6862 6863 6864 6865 6866
					mddev->recovery_cp = mddev->curr_resync;
				}
			} else
				mddev->recovery_cp = MaxSector;
		} else {
			if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
				mddev->curr_resync = MaxSector;
6867 6868
			rcu_read_lock();
			list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
6869
				if (rdev->raid_disk >= 0 &&
6870
				    mddev->delta_disks >= 0 &&
6871 6872 6873 6874
				    !test_bit(Faulty, &rdev->flags) &&
				    !test_bit(In_sync, &rdev->flags) &&
				    rdev->recovery_offset < mddev->curr_resync)
					rdev->recovery_offset = mddev->curr_resync;
6875
			rcu_read_unlock();
6876
		}
L
Linus Torvalds 已提交
6877
	}
6878
	set_bit(MD_CHANGE_DEVS, &mddev->flags);
L
Linus Torvalds 已提交
6879 6880

 skip:
6881 6882 6883 6884 6885 6886 6887
	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 已提交
6888
	mddev->curr_resync = 0;
6889 6890
	if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
		mddev->curr_resync_completed = 0;
6891
	sysfs_notify(&mddev->kobj, NULL, "sync_completed");
L
Linus Torvalds 已提交
6892 6893 6894
	wake_up(&resync_wait);
	set_bit(MD_RECOVERY_DONE, &mddev->recovery);
	md_wakeup_thread(mddev->thread);
6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905
	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 已提交
6906
}
6907
EXPORT_SYMBOL_GPL(md_do_sync);
L
Linus Torvalds 已提交
6908 6909


6910 6911 6912 6913 6914
static int remove_and_add_spares(mddev_t *mddev)
{
	mdk_rdev_t *rdev;
	int spares = 0;

6915 6916
	mddev->curr_resync_completed = 0;

6917
	list_for_each_entry(rdev, &mddev->disks, same_set)
6918
		if (rdev->raid_disk >= 0 &&
6919
		    !test_bit(Blocked, &rdev->flags) &&
6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931
		    (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;
			}
		}

6932
	if (mddev->degraded && ! mddev->ro && !mddev->recovery_disabled) {
6933
		list_for_each_entry(rdev, &mddev->disks, same_set) {
6934
			if (rdev->raid_disk >= 0 &&
6935 6936
			    !test_bit(In_sync, &rdev->flags) &&
			    !test_bit(Blocked, &rdev->flags))
6937
				spares++;
6938 6939 6940
			if (rdev->raid_disk < 0
			    && !test_bit(Faulty, &rdev->flags)) {
				rdev->recovery_offset = 0;
6941 6942
				if (mddev->pers->
				    hot_add_disk(mddev, rdev) == 0) {
6943 6944
					char nm[20];
					sprintf(nm, "rd%d", rdev->raid_disk);
6945 6946
					if (sysfs_create_link(&mddev->kobj,
							      &rdev->kobj, nm))
N
NeilBrown 已提交
6947
						/* failure here is OK */;
6948 6949
					spares++;
					md_new_event(mddev);
6950
					set_bit(MD_CHANGE_DEVS, &mddev->flags);
6951 6952 6953
				} else
					break;
			}
6954
		}
6955 6956 6957
	}
	return spares;
}
L
Linus Torvalds 已提交
6958 6959 6960 6961 6962 6963 6964 6965 6966 6967
/*
 * 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.
6968
 * When the thread finishes it sets MD_RECOVERY_DONE
L
Linus Torvalds 已提交
6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984
 * 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;


6985
	if (mddev->bitmap)
6986
		bitmap_daemon_work(mddev);
L
Linus Torvalds 已提交
6987 6988 6989

	if (mddev->ro)
		return;
6990 6991

	if (signal_pending(current)) {
6992
		if (mddev->pers->sync_request && !mddev->external) {
6993 6994 6995 6996 6997 6998 6999
			printk(KERN_INFO "md: %s in immediate safe mode\n",
			       mdname(mddev));
			mddev->safemode = 2;
		}
		flush_signals(current);
	}

7000 7001
	if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
		return;
L
Linus Torvalds 已提交
7002
	if ( ! (
7003
		(mddev->flags & ~ (1<<MD_CHANGE_PENDING)) ||
L
Linus Torvalds 已提交
7004
		test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
7005
		test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
7006
		(mddev->external == 0 && mddev->safemode == 1) ||
7007 7008
		(mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
		 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
L
Linus Torvalds 已提交
7009 7010
		))
		return;
7011

7012
	if (mddev_trylock(mddev)) {
7013
		int spares = 0;
7014

7015 7016 7017 7018 7019 7020 7021 7022 7023
		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;
		}

7024
		if (!mddev->external) {
7025
			int did_change = 0;
7026 7027 7028 7029 7030 7031
			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;
7032
				did_change = 1;
7033
				set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7034 7035 7036 7037
			}
			if (mddev->safemode == 1)
				mddev->safemode = 0;
			spin_unlock_irq(&mddev->write_lock);
7038
			if (did_change)
N
NeilBrown 已提交
7039
				sysfs_notify_dirent_safe(mddev->sysfs_state);
7040 7041
		}

7042 7043
		if (mddev->flags)
			md_update_sb(mddev, 0);
7044

L
Linus Torvalds 已提交
7045 7046 7047 7048 7049 7050 7051 7052 7053 7054
		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;
7055 7056
			if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
			    !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
L
Linus Torvalds 已提交
7057 7058
				/* success...*/
				/* activate any spares */
7059 7060 7061
				if (mddev->pers->spare_active(mddev))
					sysfs_notify(&mddev->kobj, NULL,
						     "degraded");
L
Linus Torvalds 已提交
7062
			}
7063 7064 7065
			if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
			    mddev->pers->finish_reshape)
				mddev->pers->finish_reshape(mddev);
7066
			md_update_sb(mddev, 1);
7067 7068 7069 7070 7071

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

L
Linus Torvalds 已提交
7075 7076 7077
			mddev->recovery = 0;
			/* flag recovery needed just to double check */
			set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
N
NeilBrown 已提交
7078
			sysfs_notify_dirent_safe(mddev->sysfs_action);
7079
			md_new_event(mddev);
L
Linus Torvalds 已提交
7080 7081
			goto unlock;
		}
7082 7083 7084 7085 7086
		/* 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);
7087 7088 7089 7090 7091
		/* 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 已提交
7092

7093 7094
		if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
			goto unlock;
L
Linus Torvalds 已提交
7095 7096 7097 7098 7099 7100 7101
		/* 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.
		 */

7102
		if (mddev->reshape_position != MaxSector) {
7103 7104
			if (mddev->pers->check_reshape == NULL ||
			    mddev->pers->check_reshape(mddev) != 0)
7105 7106 7107
				/* Cannot proceed */
				goto unlock;
			set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7108
			clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7109
		} else if ((spares = remove_and_add_spares(mddev))) {
7110 7111
			clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
			clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
7112
			clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
7113
			set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7114 7115
		} else if (mddev->recovery_cp < MaxSector) {
			set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7116
			clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7117 7118
		} else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
			/* nothing to be done ... */
L
Linus Torvalds 已提交
7119
			goto unlock;
7120

L
Linus Torvalds 已提交
7121
		if (mddev->pers->sync_request) {
7122 7123 7124 7125 7126 7127 7128
			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 已提交
7129 7130
			mddev->sync_thread = md_register_thread(md_do_sync,
								mddev,
7131
								"resync");
L
Linus Torvalds 已提交
7132 7133 7134 7135 7136 7137
			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;
7138
			} else
L
Linus Torvalds 已提交
7139
				md_wakeup_thread(mddev->sync_thread);
N
NeilBrown 已提交
7140
			sysfs_notify_dirent_safe(mddev->sysfs_action);
7141
			md_new_event(mddev);
L
Linus Torvalds 已提交
7142 7143
		}
	unlock:
7144 7145 7146 7147
		if (!mddev->sync_thread) {
			clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
			if (test_and_clear_bit(MD_RECOVERY_RECOVER,
					       &mddev->recovery))
7148
				if (mddev->sysfs_action)
N
NeilBrown 已提交
7149
					sysfs_notify_dirent_safe(mddev->sysfs_action);
7150
		}
L
Linus Torvalds 已提交
7151 7152 7153 7154
		mddev_unlock(mddev);
	}
}

7155 7156
void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
{
N
NeilBrown 已提交
7157
	sysfs_notify_dirent_safe(rdev->sysfs_state);
7158 7159 7160 7161 7162 7163 7164
	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 已提交
7165 7166
static int md_notify_reboot(struct notifier_block *this,
			    unsigned long code, void *x)
L
Linus Torvalds 已提交
7167 7168 7169 7170 7171 7172 7173 7174
{
	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");

7175
		for_each_mddev(mddev, tmp)
7176
			if (mddev_trylock(mddev)) {
7177 7178 7179 7180
				/* Force a switch to readonly even array
				 * appears to still be in use.  Hence
				 * the '100'.
				 */
7181
				md_set_readonly(mddev, 100);
7182 7183
				mddev_unlock(mddev);
			}
L
Linus Torvalds 已提交
7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194
		/*
		 * 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 已提交
7195
static struct notifier_block md_notifier = {
L
Linus Torvalds 已提交
7196 7197 7198 7199 7200 7201 7202 7203 7204
	.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));

7205
	proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
L
Linus Torvalds 已提交
7206 7207
}

A
Adrian Bunk 已提交
7208
static int __init md_init(void)
L
Linus Torvalds 已提交
7209
{
C
Christoph Hellwig 已提交
7210
	if (register_blkdev(MD_MAJOR, "md"))
L
Linus Torvalds 已提交
7211 7212
		return -1;
	if ((mdp_major=register_blkdev(0, "mdp"))<=0) {
C
Christoph Hellwig 已提交
7213
		unregister_blkdev(MD_MAJOR, "md");
L
Linus Torvalds 已提交
7214 7215
		return -1;
	}
C
Christoph Hellwig 已提交
7216
	blk_register_region(MKDEV(MD_MAJOR, 0), 1UL<<MINORBITS, THIS_MODULE,
7217 7218
			    md_probe, NULL, NULL);
	blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
L
Linus Torvalds 已提交
7219 7220 7221
			    md_probe, NULL, NULL);

	register_reboot_notifier(&md_notifier);
7222
	raid_table_header = register_sysctl_table(raid_root_table);
L
Linus Torvalds 已提交
7223 7224

	md_geninit();
7225
	return 0;
L
Linus Torvalds 已提交
7226 7227 7228 7229 7230 7231 7232 7233 7234
}


#ifndef MODULE

/*
 * Searches all registered partitions for autorun RAID arrays
 * at boot time.
 */
7235 7236 7237 7238 7239 7240

static LIST_HEAD(all_detected_devices);
struct detected_devices_node {
	struct list_head list;
	dev_t dev;
};
L
Linus Torvalds 已提交
7241 7242 7243

void md_autodetect_dev(dev_t dev)
{
7244 7245 7246 7247 7248 7249 7250 7251 7252 7253
	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 已提交
7254 7255 7256 7257 7258 7259
}


static void autostart_arrays(int part)
{
	mdk_rdev_t *rdev;
7260 7261 7262
	struct detected_devices_node *node_detected_dev;
	dev_t dev;
	int i_scanned, i_passed;
L
Linus Torvalds 已提交
7263

7264 7265
	i_scanned = 0;
	i_passed = 0;
L
Linus Torvalds 已提交
7266

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

7269 7270 7271 7272 7273 7274 7275
	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);
7276
		rdev = md_import_device(dev,0, 90);
L
Linus Torvalds 已提交
7277 7278 7279
		if (IS_ERR(rdev))
			continue;

7280
		if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
7281 7282 7283
			MD_BUG();
			continue;
		}
7284
		set_bit(AutoDetected, &rdev->flags);
L
Linus Torvalds 已提交
7285
		list_add(&rdev->same_set, &pending_raid_disks);
7286
		i_passed++;
L
Linus Torvalds 已提交
7287
	}
7288 7289 7290

	printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
						i_scanned, i_passed);
L
Linus Torvalds 已提交
7291 7292 7293 7294

	autorun_devices(part);
}

J
Jeff Garzik 已提交
7295
#endif /* !MODULE */
L
Linus Torvalds 已提交
7296 7297 7298 7299 7300

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

C
Christoph Hellwig 已提交
7302
	blk_unregister_region(MKDEV(MD_MAJOR,0), 1U << MINORBITS);
7303
	blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
L
Linus Torvalds 已提交
7304

C
Christoph Hellwig 已提交
7305
	unregister_blkdev(MD_MAJOR,"md");
L
Linus Torvalds 已提交
7306 7307 7308 7309
	unregister_blkdev(mdp_major, "mdp");
	unregister_reboot_notifier(&md_notifier);
	unregister_sysctl_table(raid_table_header);
	remove_proc_entry("mdstat", NULL);
7310
	for_each_mddev(mddev, tmp) {
L
Linus Torvalds 已提交
7311
		export_array(mddev);
7312
		mddev->hold_active = 0;
L
Linus Torvalds 已提交
7313 7314 7315
	}
}

7316
subsys_initcall(md_init);
L
Linus Torvalds 已提交
7317 7318
module_exit(md_exit)

7319 7320 7321 7322 7323 7324 7325 7326 7327 7328
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;
7329
		return 0;
7330 7331 7332 7333
	}
	return -EINVAL;
}

7334 7335
module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
7336

7337
module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
7338

L
Linus Torvalds 已提交
7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349
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");
7350
MODULE_DESCRIPTION("MD RAID framework");
7351
MODULE_ALIAS("md");
7352
MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);