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

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

   Changes:

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

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

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

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

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

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

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

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

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

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

67 68
static void md_print_devices(void);

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

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

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

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

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

static struct ctl_table_header *raid_table_header;

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

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

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

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

150 151
static int start_readonly;

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

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

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

	bio_free(bio, mddev->bio_set);
}

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

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

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

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

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

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

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

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

	return b;
}
EXPORT_SYMBOL_GPL(bio_clone_mddev);

218 219 220 221 222 223 224 225 226 227
/*
 * We have a system wide 'event count' that is incremented
 * on any 'interesting' event, and readers of /proc/mdstat
 * can use 'poll' or 'select' to find out when the event
 * count increases.
 *
 * Events are:
 *  start array, stop array, error, add device, remove device,
 *  start build, activate spare
 */
228
static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
229
static atomic_t md_event_count;
230
void md_new_event(mddev_t *mddev)
231 232 233 234
{
	atomic_inc(&md_event_count);
	wake_up(&md_event_waiters);
}
235
EXPORT_SYMBOL_GPL(md_new_event);
236

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

L
Linus Torvalds 已提交
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
/*
 * Enables to iterate over all existing md arrays
 * all_mddevs_lock protects this list.
 */
static LIST_HEAD(all_mddevs);
static DEFINE_SPINLOCK(all_mddevs_lock);


/*
 * iterates through all used mddevs in the system.
 * We take care to grab the all_mddevs_lock whenever navigating
 * the list, and to always hold a refcount when unlocked.
 * Any code which breaks out of this loop while own
 * a reference to the current mddev and must mddev_put it.
 */
261
#define for_each_mddev(mddev,tmp)					\
L
Linus Torvalds 已提交
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
									\
	for (({ spin_lock(&all_mddevs_lock); 				\
		tmp = all_mddevs.next;					\
		mddev = NULL;});					\
	     ({ if (tmp != &all_mddevs)					\
			mddev_get(list_entry(tmp, mddev_t, all_mddevs));\
		spin_unlock(&all_mddevs_lock);				\
		if (mddev) mddev_put(mddev);				\
		mddev = list_entry(tmp, mddev_t, all_mddevs);		\
		tmp != &all_mddevs;});					\
	     ({ spin_lock(&all_mddevs_lock);				\
		tmp = tmp->next;})					\
		)


277 278 279 280 281 282 283 284
/* Rather than calling directly into the personality make_request function,
 * IO requests come here first so that we can check if the device is
 * being suspended pending a reconfiguration.
 * We hold a refcount over the call to ->make_request.  By the time that
 * call has finished, the bio has been linked into some internal structure
 * and so is visible to ->quiesce(), so we don't need the refcount any more.
 */
static int md_make_request(struct request_queue *q, struct bio *bio)
L
Linus Torvalds 已提交
285
{
286
	const int rw = bio_data_dir(bio);
287 288
	mddev_t *mddev = q->queuedata;
	int rv;
289 290
	int cpu;

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

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

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

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

	return rv;
}

326 327 328 329 330 331
/* 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.
 */
332
void mddev_suspend(mddev_t *mddev)
333 334 335 336 337 338 339
{
	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);
}
340
EXPORT_SYMBOL_GPL(mddev_suspend);
341

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

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

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

T
Tejun Heo 已提交
360
static void md_end_flush(struct bio *bio, int err)
361 362 363 364 365 366 367
{
	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 已提交
368
		/* The pre-request flush has finished */
T
Tejun Heo 已提交
369
		queue_work(md_wq, &mddev->flush_work);
370 371 372 373
	}
	bio_put(bio);
}

T
Tejun Heo 已提交
374
static void submit_flushes(mddev_t *mddev)
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389
{
	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();
390
			bi = bio_alloc_mddev(GFP_KERNEL, 0, mddev);
T
Tejun Heo 已提交
391
			bi->bi_end_io = md_end_flush;
392 393 394
			bi->bi_private = rdev;
			bi->bi_bdev = rdev->bdev;
			atomic_inc(&mddev->flush_pending);
T
Tejun Heo 已提交
395
			submit_bio(WRITE_FLUSH, bi);
396 397 398 399 400 401
			rcu_read_lock();
			rdev_dec_pending(rdev, mddev);
		}
	rcu_read_unlock();
}

T
Tejun Heo 已提交
402
static void md_submit_flush_data(struct work_struct *ws)
403
{
T
Tejun Heo 已提交
404 405
	mddev_t *mddev = container_of(ws, mddev_t, flush_work);
	struct bio *bio = mddev->flush_bio;
406 407 408

	atomic_set(&mddev->flush_pending, 1);

T
Tejun Heo 已提交
409
	if (bio->bi_size == 0)
410 411 412
		/* an empty barrier - all done */
		bio_endio(bio, 0);
	else {
T
Tejun Heo 已提交
413
		bio->bi_rw &= ~REQ_FLUSH;
414
		if (mddev->pers->make_request(mddev, bio))
415 416 417
			generic_make_request(bio);
	}
	if (atomic_dec_and_test(&mddev->flush_pending)) {
T
Tejun Heo 已提交
418
		mddev->flush_bio = NULL;
419 420 421 422
		wake_up(&mddev->sb_wait);
	}
}

T
Tejun Heo 已提交
423
void md_flush_request(mddev_t *mddev, struct bio *bio)
424 425 426
{
	spin_lock_irq(&mddev->write_lock);
	wait_event_lock_irq(mddev->sb_wait,
T
Tejun Heo 已提交
427
			    !mddev->flush_bio,
428
			    mddev->write_lock, /*nothing*/);
T
Tejun Heo 已提交
429
	mddev->flush_bio = bio;
430 431 432
	spin_unlock_irq(&mddev->write_lock);

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

T
Tejun Heo 已提交
435
	submit_flushes(mddev);
436 437

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

442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
/* 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 已提交
487 488 489 490 491 492
static inline mddev_t *mddev_get(mddev_t *mddev)
{
	atomic_inc(&mddev->active);
	return mddev;
}

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

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

L
Linus Torvalds 已提交
499 500
	if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
		return;
501
	if (!mddev->raid_disks && list_empty(&mddev->disks) &&
502 503 504
	    mddev->ctime == 0 && !mddev->hold_active) {
		/* Array is not configured at all, and not held active,
		 * so destroy it */
L
Linus Torvalds 已提交
505
		list_del(&mddev->all_mddevs);
506 507
		bs = mddev->bio_set;
		mddev->bio_set = NULL;
508
		if (mddev->gendisk) {
T
Tejun Heo 已提交
509 510 511 512
			/* We did a probe so need to clean up.  Call
			 * queue_work inside the spinlock so that
			 * flush_workqueue() after mddev_find will
			 * succeed in waiting for the work to be done.
513 514
			 */
			INIT_WORK(&mddev->del_work, mddev_delayed_delete);
T
Tejun Heo 已提交
515
			queue_work(md_misc_wq, &mddev->del_work);
516 517 518 519
		} else
			kfree(mddev);
	}
	spin_unlock(&all_mddevs_lock);
520 521
	if (bs)
		bioset_free(bs);
L
Linus Torvalds 已提交
522 523
}

524
void mddev_init(mddev_t *mddev)
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
{
	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;
}
544
EXPORT_SYMBOL_GPL(mddev_init);
545

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

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

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

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

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

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

	goto retry;
}

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

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

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

632 633
static struct attribute_group md_redundancy_group;

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

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

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

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

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

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

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

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

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

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

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

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");
721
		return -ENOMEM;
L
Linus Torvalds 已提交
722 723 724 725 726 727 728 729
	}

	return 0;
}

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


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

744 745 746 747
	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));
748
		md_error(mddev, rdev);
749
	}
750

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

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
	 */
765
	struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, mddev);
766 767 768 769 770 771

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

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

void md_super_wait(mddev_t *mddev)
{
T
Tejun Heo 已提交
780
	/* wait for all superblock writes that were scheduled to complete */
781 782 783 784 785 786 787 788
	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);
789 790
}

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

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

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

805
	bio->bi_bdev = rdev->bdev;
L
Linus Torvalds 已提交
806 807 808 809 810 811 812 813 814 815 816 817
	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;
}
818
EXPORT_SYMBOL_GPL(sync_page_io);
L
Linus Torvalds 已提交
819

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


831
	if (!sync_page_io(rdev, rdev->sb_start, size, rdev->sb_page, READ))
L
Linus Torvalds 已提交
832 833 834 835 836 837 838 839 840 841 842 843
		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 已提交
844 845 846 847
	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 已提交
848 849 850 851 852 853 854 855 856 857 858 859
}

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

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

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

A
Andre Noll 已提交
873
	ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
L
Linus Torvalds 已提交
874
abort:
875 876
	kfree(tmp1);
	kfree(tmp2);
L
Linus Torvalds 已提交
877 878 879
	return ret;
}

880 881 882 883 884 885 886

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

L
Linus Torvalds 已提交
887 888
static unsigned int calc_sb_csum(mdp_super_t * sb)
{
889 890 891
	u64 newcsum = 0;
	u32 *sb32 = (u32*)sb;
	int i;
L
Linus Torvalds 已提交
892 893 894 895
	unsigned int disk_csum, csum;

	disk_csum = sb->sb_csum;
	sb->sb_csum = 0;
896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912

	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 已提交
913
	sb->sb_csum = disk_csum;
914
#endif
L
Linus Torvalds 已提交
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949
	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  {
950 951 952 953 954 955 956
	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,
957
						sector_t num_sectors);
L
Linus Torvalds 已提交
958 959
};

960 961 962 963 964 965 966 967 968 969
/*
 * 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)
{
970
	if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
971 972 973 974 975 976 977
		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 已提交
978 979 980 981 982 983 984 985 986 987
/*
 * 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;

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

995
	ret = read_disk_sb(rdev, MD_SB_BYTES);
L
Linus Torvalds 已提交
996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
	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 ||
1010 1011
	    sb->minor_version < 90 ||
	    sb->minor_version > 91) {
L
Linus Torvalds 已提交
1012 1013 1014 1015 1016 1017 1018 1019 1020
		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;

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

	rdev->preferred_minor = sb->md_minor;
	rdev->data_offset = 0;
1029
	rdev->sb_size = MD_SB_BYTES;
L
Linus Torvalds 已提交
1030 1031 1032 1033 1034 1035

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

1036
	if (!refdev) {
L
Linus Torvalds 已提交
1037
		ret = 1;
1038
	} else {
L
Linus Torvalds 已提交
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
		__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;
	}
1059
	rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
1060

1061
	if (rdev->sectors < sb->size * 2 && sb->level > 1)
1062 1063 1064
		/* "this cannot possibly happen" ... */
		ret = -EINVAL;

L
Linus Torvalds 已提交
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
 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);
1076
	__u64 ev1 = md_event(sb);
L
Linus Torvalds 已提交
1077

1078
	rdev->raid_disk = -1;
1079 1080 1081 1082
	clear_bit(Faulty, &rdev->flags);
	clear_bit(In_sync, &rdev->flags);
	clear_bit(WriteMostly, &rdev->flags);

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

1100 1101 1102 1103 1104
		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;
1105
			mddev->new_chunk_sectors = sb->new_chunk >> 9;
1106 1107 1108 1109 1110
		} else {
			mddev->reshape_position = MaxSector;
			mddev->delta_disks = 0;
			mddev->new_level = mddev->level;
			mddev->new_layout = mddev->layout;
1111
			mddev->new_chunk_sectors = mddev->chunk_sectors;
1112 1113
		}

L
Linus Torvalds 已提交
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
		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;
1130 1131

		if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
1132 1133 1134
		    mddev->bitmap_info.file == NULL)
			mddev->bitmap_info.offset =
				mddev->bitmap_info.default_offset;
1135

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

L
Linus Torvalds 已提交
1156 1157 1158 1159
	if (mddev->level != LEVEL_MULTIPATH) {
		desc = sb->disks + rdev->desc_nr;

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

L
Linus Torvalds 已提交
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203

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

1204 1205
	rdev->sb_size = MD_SB_BYTES;

L
Linus Torvalds 已提交
1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
	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 已提交
1221
	sb->size = mddev->dev_sectors / 2;
L
Linus Torvalds 已提交
1222 1223
	sb->raid_disks = mddev->raid_disks;
	sb->md_minor = mddev->md_minor;
1224
	sb->not_persistent = 0;
L
Linus Torvalds 已提交
1225 1226 1227 1228 1229
	sb->utime = mddev->utime;
	sb->state = 0;
	sb->events_hi = (mddev->events>>32);
	sb->events_lo = (u32)mddev->events;

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

1254
	if (mddev->bitmap && mddev->bitmap_info.file == NULL)
1255 1256
		sb->state |= (1<<MD_SB_BITMAP_PRESENT);

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

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


L
Linus Torvalds 已提交
1344 1345 1346 1347
/*
 * version 1 superblock
 */

1348
static __le32 calc_sb_1_csum(struct mdp_superblock_1 * sb)
L
Linus Torvalds 已提交
1349
{
1350 1351
	__le32 disk_csum;
	u32 csum;
L
Linus Torvalds 已提交
1352 1353
	unsigned long long newcsum;
	int size = 256 + le32_to_cpu(sb->max_dev)*2;
1354
	__le32 *isuper = (__le32*)sb;
L
Linus Torvalds 已提交
1355 1356 1357 1358 1359 1360 1361 1362 1363
	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)
1364
		newcsum += le16_to_cpu(*(__le16*) isuper);
L
Linus Torvalds 已提交
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374

	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;
1375
	sector_t sb_start;
L
Linus Torvalds 已提交
1376
	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1377
	int bmask;
L
Linus Torvalds 已提交
1378 1379

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

1404 1405 1406 1407
	/* 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 已提交
1408 1409 1410 1411 1412 1413 1414 1415
	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 ||
1416
	    le64_to_cpu(sb->super_offset) != rdev->sb_start ||
1417
	    (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
L
Linus Torvalds 已提交
1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
		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;
	}
1430

L
Linus Torvalds 已提交
1431 1432
	rdev->preferred_minor = 0xffff;
	rdev->data_offset = le64_to_cpu(sb->data_offset);
1433
	atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
L
Linus Torvalds 已提交
1434

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

	if (minor_version
1441
	    && rdev->data_offset < sb_start + (rdev->sb_size/512))
1442
		return -EINVAL;
1443

1444 1445 1446 1447 1448
	if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
		rdev->desc_nr = -1;
	else
		rdev->desc_nr = le32_to_cpu(sb->dev_number);

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

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

1492
	rdev->raid_disk = -1;
1493 1494 1495 1496
	clear_bit(Faulty, &rdev->flags);
	clear_bit(In_sync, &rdev->flags);
	clear_bit(WriteMostly, &rdev->flags);

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

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

1518
		if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1519 1520 1521
		    mddev->bitmap_info.file == NULL )
			mddev->bitmap_info.offset =
				(__s32)le32_to_cpu(sb->bitmap_offset);
1522

1523 1524 1525 1526 1527
		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);
1528
			mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
1529 1530 1531 1532 1533
		} else {
			mddev->reshape_position = MaxSector;
			mddev->delta_disks = 0;
			mddev->new_level = mddev->level;
			mddev->new_layout = mddev->layout;
1534
			mddev->new_chunk_sectors = mddev->chunk_sectors;
1535 1536
		}

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

L
Linus Torvalds 已提交
1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
	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;
1599
	sb->recovery_offset = cpu_to_le64(0);
L
Linus Torvalds 已提交
1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610
	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);

1611
	sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
1612

1613
	sb->raid_disks = cpu_to_le32(mddev->raid_disks);
A
Andre Noll 已提交
1614
	sb->size = cpu_to_le64(mddev->dev_sectors);
1615
	sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
1616 1617
	sb->level = cpu_to_le32(mddev->level);
	sb->layout = cpu_to_le32(mddev->layout);
1618

1619 1620
	if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
		sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
1621
		sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1622
	}
1623 1624

	if (rdev->raid_disk >= 0 &&
1625
	    !test_bit(In_sync, &rdev->flags)) {
1626 1627 1628 1629
		sb->feature_map |=
			cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
		sb->recovery_offset =
			cpu_to_le64(rdev->recovery_offset);
1630 1631
	}

1632 1633 1634 1635 1636 1637
	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);
1638
		sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
1639
	}
1640

L
Linus Torvalds 已提交
1641
	max_dev = 0;
1642
	list_for_each_entry(rdev2, &mddev->disks, same_set)
L
Linus Torvalds 已提交
1643 1644
		if (rdev2->desc_nr+1 > max_dev)
			max_dev = rdev2->desc_nr+1;
1645

1646 1647
	if (max_dev > le32_to_cpu(sb->max_dev)) {
		int bmask;
1648
		sb->max_dev = cpu_to_le32(max_dev);
1649 1650 1651 1652
		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;
1653 1654 1655
	} else
		max_dev = le32_to_cpu(sb->max_dev);

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

	sb->sb_csum = calc_sb_1_csum(sb);
}

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

A
Adrian Bunk 已提交
1710
static struct super_type super_types[] = {
L
Linus Torvalds 已提交
1711 1712 1713
	[0] = {
		.name	= "0.90.0",
		.owner	= THIS_MODULE,
1714 1715 1716 1717
		.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 已提交
1718 1719 1720 1721
	},
	[1] = {
		.name	= "md-1",
		.owner	= THIS_MODULE,
1722 1723 1724 1725
		.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 已提交
1726 1727 1728 1729 1730
	},
};

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

1733 1734 1735
	rcu_read_lock();
	rdev_for_each_rcu(rdev, mddev1)
		rdev_for_each_rcu(rdev2, mddev2)
1736
			if (rdev->bdev->bd_contains ==
1737 1738
			    rdev2->bdev->bd_contains) {
				rcu_read_unlock();
1739
				return 1;
1740 1741
			}
	rcu_read_unlock();
L
Linus Torvalds 已提交
1742 1743 1744 1745 1746
	return 0;
}

static LIST_HEAD(pending_raid_disks);

1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
/*
 * 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 已提交
1802 1803
{
	struct blk_integrity *bi_rdev = bdev_get_integrity(rdev->bdev);
1804
	struct blk_integrity *bi_mddev = blk_get_integrity(mddev->gendisk);
M
Martin K. Petersen 已提交
1805

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

L
Linus Torvalds 已提交
1818 1819
static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
{
1820
	char b[BDEVNAME_SIZE];
1821
	struct kobject *ko;
1822
	char *s;
1823
	int err;
L
Linus Torvalds 已提交
1824 1825 1826 1827 1828

	if (rdev->mddev) {
		MD_BUG();
		return -EINVAL;
	}
1829 1830 1831 1832 1833

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

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

	/* 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;
	}
1862 1863 1864 1865 1866
	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;
	}
1867
	bdevname(rdev->bdev,b);
1868
	while ( (s=strchr(b, '/')) != NULL)
1869
		*s = '!';
1870

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

1874
	if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
1875
		goto fail;
1876

T
Tejun Heo 已提交
1877
	ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
N
NeilBrown 已提交
1878 1879 1880
	if (sysfs_create_link(&rdev->kobj, ko, "block"))
		/* failure here is OK */;
	rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
1881

1882
	list_add_rcu(&rdev->same_set, &mddev->disks);
1883
	bd_claim_by_disk(rdev->bdev, rdev->bdev->bd_holder, mddev->gendisk);
1884 1885 1886

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

L
Linus Torvalds 已提交
1888
	return 0;
1889 1890 1891 1892 1893

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

1896
static void md_delayed_delete(struct work_struct *ws)
1897 1898 1899
{
	mdk_rdev_t *rdev = container_of(ws, mdk_rdev_t, del_work);
	kobject_del(&rdev->kobj);
1900
	kobject_put(&rdev->kobj);
1901 1902
}

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

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

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

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
1978 1979
	if (test_bit(AutoDetected, &rdev->flags))
		md_autodetect_dev(rdev->bdev->bd_dev);
L
Linus Torvalds 已提交
1980 1981
#endif
	unlock_rdev(rdev);
1982
	kobject_put(&rdev->kobj);
L
Linus Torvalds 已提交
1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
}

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

1995
	rdev_for_each(rdev, tmp, mddev) {
L
Linus Torvalds 已提交
1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013
		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);
}

2014
static void print_sb_90(mdp_super_t *sb)
L
Linus Torvalds 已提交
2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044
{
	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);
2045
}
L
Linus Torvalds 已提交
2046

2047 2048 2049 2050 2051
static void print_sb_1(struct mdp_superblock_1 *sb)
{
	__u8 *uuid;

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

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

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

2110
static void md_print_devices(void)
L
Linus Torvalds 已提交
2111
{
2112
	struct list_head *tmp;
L
Linus Torvalds 已提交
2113 2114 2115 2116 2117 2118 2119 2120
	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");
2121
	for_each_mddev(mddev, tmp) {
L
Linus Torvalds 已提交
2122

2123 2124 2125 2126
		if (mddev->bitmap)
			bitmap_print_sb(mddev->bitmap);
		else
			printk("%s: ", mdname(mddev));
2127
		list_for_each_entry(rdev, &mddev->disks, same_set)
L
Linus Torvalds 已提交
2128 2129 2130
			printk("<%s>", bdevname(rdev->bdev,b));
		printk("\n");

2131
		list_for_each_entry(rdev, &mddev->disks, same_set)
2132
			print_rdev(rdev, mddev->major_version);
L
Linus Torvalds 已提交
2133 2134 2135 2136 2137 2138
	}
	printk("md:	**********************************\n");
	printk("\n");
}


2139
static void sync_sbs(mddev_t * mddev, int nospares)
L
Linus Torvalds 已提交
2140
{
2141 2142 2143 2144 2145 2146
	/* 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 已提交
2147
	mdk_rdev_t *rdev;
2148
	list_for_each_entry(rdev, &mddev->disks, same_set) {
2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159
		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 已提交
2160 2161 2162
	}
}

2163
static void md_update_sb(mddev_t * mddev, int force_change)
L
Linus Torvalds 已提交
2164 2165
{
	mdk_rdev_t *rdev;
2166
	int sync_req;
2167
	int nospares = 0;
L
Linus Torvalds 已提交
2168 2169

repeat:
2170 2171 2172 2173 2174 2175 2176 2177 2178
	/* 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;

	}	
2179
	if (!mddev->persistent) {
2180
		clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2181
		clear_bit(MD_CHANGE_DEVS, &mddev->flags);
2182 2183
		if (!mddev->external)
			clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2184 2185 2186 2187
		wake_up(&mddev->sb_wait);
		return;
	}

2188
	spin_lock_irq(&mddev->write_lock);
2189

2190 2191
	mddev->utime = get_seconds();

2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
	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)
2203 2204 2205 2206 2207 2208 2209 2210 2211
		/* 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.
		 */
2212
		nospares = 0;
2213

2214
	sync_req = mddev->in_sync;
2215 2216 2217

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

	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 --;
	}
2239
	sync_sbs(mddev, nospares);
2240
	spin_unlock_irq(&mddev->write_lock);
L
Linus Torvalds 已提交
2241 2242 2243 2244 2245

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

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

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

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

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

L
Linus Torvalds 已提交
2287 2288
}

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

2309 2310 2311 2312 2313 2314 2315
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
2316
state_show(mdk_rdev_t *rdev, char *page)
2317 2318
{
	char *sep = "";
2319
	size_t len = 0;
2320

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

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

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

2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416
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 =
2417
__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
2418

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

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

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

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


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

2510 2511 2512
static ssize_t
offset_show(mdk_rdev_t *rdev, char *page)
{
2513
	return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
2514 2515 2516 2517 2518 2519 2520 2521 2522
}

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;
2523
	if (rdev->mddev->pers && rdev->raid_disk >= 0)
2524
		return -EBUSY;
2525
	if (rdev->sectors && rdev->mddev->external)
2526 2527 2528
		/* Must set offset before size, so overlap checks
		 * can be sane */
		return -EBUSY;
2529 2530 2531 2532 2533
	rdev->data_offset = offset;
	return len;
}

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

2536 2537 2538
static ssize_t
rdev_size_show(mdk_rdev_t *rdev, char *page)
{
2539
	return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
2540 2541
}

2542 2543 2544 2545 2546 2547 2548 2549 2550 2551
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 已提交
2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570
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;
}

2571 2572 2573
static ssize_t
rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
{
2574
	mddev_t *my_mddev = rdev->mddev;
2575
	sector_t oldsectors = rdev->sectors;
D
Dan Williams 已提交
2576
	sector_t sectors;
2577

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

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

2604
		mddev_unlock(my_mddev);
2605
		for_each_mddev(mddev, tmp) {
2606 2607 2608
			mdk_rdev_t *rdev2;

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

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

2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678

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

2679 2680
static struct attribute *rdev_default_attrs[] = {
	&rdev_state.attr,
2681
	&rdev_errors.attr,
2682
	&rdev_slot.attr,
2683
	&rdev_offset.attr,
2684
	&rdev_size.attr,
2685
	&rdev_recovery_start.attr,
2686 2687 2688 2689 2690 2691 2692
	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);
2693 2694
	mddev_t *mddev = rdev->mddev;
	ssize_t rv;
2695 2696 2697

	if (!entry->show)
		return -EIO;
2698 2699 2700 2701 2702 2703 2704 2705 2706 2707

	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;
2708 2709 2710 2711 2712 2713 2714 2715
}

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);
2716 2717
	ssize_t rv;
	mddev_t *mddev = rdev->mddev;
2718 2719 2720

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

static void rdev_free(struct kobject *ko)
{
	mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj);
	kfree(rdev);
}
2739
static const struct sysfs_ops rdev_sysfs_ops = {
2740 2741 2742 2743 2744 2745 2746 2747 2748
	.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 已提交
2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766
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 已提交
2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783
/*
 * 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;

2784
	rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
L
Linus Torvalds 已提交
2785 2786 2787 2788 2789
	if (!rdev) {
		printk(KERN_ERR "md: could not alloc mem for new device!\n");
		return ERR_PTR(-ENOMEM);
	}

N
NeilBrown 已提交
2790
	md_rdev_init(rdev);
L
Linus Torvalds 已提交
2791 2792 2793
	if ((err = alloc_disk_sb(rdev)))
		goto abort_free;

2794
	err = lock_rdev(rdev, newdev, super_format == -2);
L
Linus Torvalds 已提交
2795 2796 2797
	if (err)
		goto abort_free;

2798
	kobject_init(&rdev->kobj, &rdev_ktype);
2799

L
Linus Torvalds 已提交
2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812
	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) {
2813 2814 2815 2816 2817
			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 已提交
2818 2819 2820 2821 2822 2823 2824 2825 2826
			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;
		}
	}
2827

L
Linus Torvalds 已提交
2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844
	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
 */


2845
static void analyze_sbs(mddev_t * mddev)
L
Linus Torvalds 已提交
2846 2847
{
	int i;
2848
	mdk_rdev_t *rdev, *freshest, *tmp;
L
Linus Torvalds 已提交
2849 2850 2851
	char b[BDEVNAME_SIZE];

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

2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944
/* 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;
}


2945 2946
static void md_safemode_timeout(unsigned long data);

2947 2948 2949 2950 2951 2952 2953 2954 2955 2956
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;
2957

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

2975
static ssize_t
2976
level_show(mddev_t *mddev, char *page)
2977
{
2978
	struct mdk_personality *p = mddev->pers;
2979
	if (p)
2980
		return sprintf(page, "%s\n", p->name);
2981 2982 2983 2984 2985 2986
	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;
2987 2988
}

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

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

3018 3019 3020
	if (mddev->sync_thread ||
	    mddev->reshape_position != MaxSector ||
	    mddev->sysfs_active)
3021
		return -EBUSY;
3022 3023 3024 3025 3026 3027 3028 3029

	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 */
3030
	if (len == 0 || len >= sizeof(clevel))
3031
		return -EINVAL;
3032 3033
	strncpy(clevel, buf, len);
	if (clevel[len-1] == '\n')
3034
		len--;
3035 3036 3037
	clevel[len] = 0;
	if (strict_strtol(clevel, 10, &level))
		level = LEVEL_NONE;
3038

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

3062 3063 3064
	list_for_each_entry(rdev, &mddev->disks, same_set)
		rdev->new_raid_disk = rdev->raid_disk;

3065 3066 3067 3068 3069 3070 3071
	/* ->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;
3072
		mddev->new_chunk_sectors = mddev->chunk_sectors;
3073 3074 3075 3076
		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",
3077
		       mdname(mddev), clevel);
3078 3079 3080 3081 3082 3083
		return PTR_ERR(priv);
	}

	/* Looks like we have a winner */
	mddev_suspend(mddev);
	mddev->pers->stop(mddev);
3084 3085 3086 3087 3088 3089 3090 3091
	
	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));
3092
		mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, NULL, "sync_action");
3093 3094 3095 3096 3097 3098 3099 3100
	}		
	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;
	}

3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114
	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;
	}

3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132
	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)
3133
			clear_bit(In_sync, &rdev->flags);
3134 3135 3136 3137 3138 3139
		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));
3140
		}
3141 3142 3143
	}

	module_put(mddev->pers->owner);
3144 3145 3146 3147 3148
	mddev->pers = pers;
	mddev->private = priv;
	strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
	mddev->level = mddev->new_level;
	mddev->layout = mddev->new_layout;
3149
	mddev->chunk_sectors = mddev->new_chunk_sectors;
3150
	mddev->delta_disks = 0;
3151 3152 3153 3154 3155 3156 3157
	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);
	}
3158 3159 3160 3161 3162
	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);
3163
	sysfs_notify(&mddev->kobj, NULL, "level");
3164
	md_new_event(mddev);
3165 3166 3167 3168
	return rv;
}

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

3171 3172 3173 3174 3175

static ssize_t
layout_show(mddev_t *mddev, char *page)
{
	/* just a number, not meaningful for all levels */
3176 3177 3178 3179
	if (mddev->reshape_position != MaxSector &&
	    mddev->layout != mddev->new_layout)
		return sprintf(page, "%d (%d)\n",
			       mddev->new_layout, mddev->layout);
3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191
	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;

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


3213
static ssize_t
3214
raid_disks_show(mddev_t *mddev, char *page)
3215
{
3216 3217
	if (mddev->raid_disks == 0)
		return 0;
3218 3219 3220 3221
	if (mddev->reshape_position != MaxSector &&
	    mddev->delta_disks != 0)
		return sprintf(page, "%d (%d)\n", mddev->raid_disks,
			       mddev->raid_disks - mddev->delta_disks);
3222 3223 3224
	return sprintf(page, "%d\n", mddev->raid_disks);
}

3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238
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);
3239 3240 3241 3242 3243
	else if (mddev->reshape_position != MaxSector) {
		int olddisks = mddev->raid_disks - mddev->delta_disks;
		mddev->delta_disks = n - olddisks;
		mddev->raid_disks = n;
	} else
3244 3245 3246 3247
		mddev->raid_disks = n;
	return rv ? rv : len;
}
static struct md_sysfs_entry md_raid_disks =
3248
__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
3249

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

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;

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

3290 3291 3292
static ssize_t
resync_start_show(mddev_t *mddev, char *page)
{
3293 3294
	if (mddev->recovery_cp == MaxSector)
		return sprintf(page, "none\n");
3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305
	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;
3306 3307 3308
	if (cmd_match(buf, "none"))
		n = MaxSector;
	else if (!*buf || (*e && *e != '\n'))
3309 3310 3311 3312 3313 3314
		return -EINVAL;

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

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

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

3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523
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);

3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568
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;
		}
3569 3570 3571
	} else if (mddev->external)
		rdev = md_import_device(dev, -2, -1);
	else
3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583
		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 =
3584
__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
3585

3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604
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);
3605
		buf = skip_spaces(end);
3606 3607 3608 3609 3610 3611 3612 3613 3614
	}
	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);

3615 3616 3617
static ssize_t
size_show(mddev_t *mddev, char *page)
{
A
Andre Noll 已提交
3618 3619
	return sprintf(page, "%llu\n",
		(unsigned long long)mddev->dev_sectors / 2);
3620 3621
}

3622
static int update_size(mddev_t *mddev, sector_t num_sectors);
3623 3624 3625 3626 3627 3628 3629 3630

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 已提交
3631 3632
	sector_t sectors;
	int err = strict_blocks_to_sectors(buf, &sectors);
3633

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

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

3652 3653

/* Metdata version.
3654 3655 3656
 * This is one of
 *   'none' for arrays with no metadata (good luck...)
 *   'external' for arrays with externally managed metadata,
3657 3658 3659 3660 3661 3662 3663 3664
 * 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);
3665 3666
	else if (mddev->external)
		return sprintf(page, "external:%s\n", mddev->metadata_type);
3667 3668 3669 3670 3671 3672 3673 3674 3675
	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;
3676 3677 3678 3679 3680 3681 3682
	/* 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))
3683 3684 3685 3686
		return -EBUSY;

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

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

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

static ssize_t
3749
action_store(mddev_t *mddev, const char *page, size_t len)
3750
{
3751 3752 3753
	if (!mddev->pers || !mddev->pers->sync_request)
		return -EINVAL;

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

3796
static ssize_t
3797
mismatch_cnt_show(mddev_t *mddev, char *page)
3798 3799 3800 3801 3802
{
	return sprintf(page, "%llu\n",
		       (unsigned long long) mddev->resync_mismatches);
}

3803 3804
static struct md_sysfs_entry md_scan_mode =
__ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
3805

3806

3807
static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
3808

3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860
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);

3861 3862 3863 3864 3865 3866
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);
3867

3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897
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);

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

3911
static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
3912 3913 3914 3915

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

3918 3919 3920
	if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
		return sprintf(page, "none\n");

3921
	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
A
Andre Noll 已提交
3922
		max_sectors = mddev->resync_max_sectors;
3923
	else
A
Andre Noll 已提交
3924
		max_sectors = mddev->dev_sectors;
3925

3926
	resync = mddev->curr_resync_completed;
A
Andre Noll 已提交
3927
	return sprintf(page, "%lu / %lu\n", resync, max_sectors);
3928 3929
}

3930
static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
3931

3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949
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 */
3950
	if (mddev->chunk_sectors) {
3951
		sector_t temp = min;
3952
		if (sector_div(temp, mddev->chunk_sectors))
3953 3954 3955 3956 3957 3958 3959 3960 3961 3962
			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);

3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977
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 {
3978 3979 3980 3981
		unsigned long long max;
		if (strict_strtoull(buf, 10, &max))
			return -EINVAL;
		if (max < mddev->resync_min)
3982 3983
			return -EINVAL;
		if (max < mddev->resync_max &&
3984
		    mddev->ro == 0 &&
3985 3986 3987 3988
		    test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
			return -EBUSY;

		/* Must be a multiple of chunk_size */
3989
		if (mddev->chunk_sectors) {
3990
			sector_t temp = max;
3991
			if (sector_div(temp, mddev->chunk_sectors))
3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002
				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);

4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014
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);

4015 4016
	if (mddev->pers == NULL || 
	    mddev->pers->quiesce == NULL)
4017 4018 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
		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);

4044 4045
	if (mddev->pers == NULL ||
	    mddev->pers->quiesce == NULL)
4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060
		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);

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

		mddev->external_size = 1;
	}

	mddev->array_sectors = sectors;
	set_capacity(mddev->gendisk, mddev->array_sectors);
4125 4126
	if (mddev->pers)
		revalidate_disk(mddev->gendisk);
D
Dan Williams 已提交
4127 4128 4129 4130 4131 4132 4133

	return len;
}

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

4135 4136
static struct attribute *md_default_attrs[] = {
	&md_level.attr,
4137
	&md_layout.attr,
4138
	&md_raid_disks.attr,
4139
	&md_chunk_size.attr,
4140
	&md_size.attr,
4141
	&md_resync_start.attr,
4142
	&md_metadata.attr,
4143
	&md_new_device.attr,
4144
	&md_safe_delay.attr,
4145
	&md_array_state.attr,
4146
	&md_reshape_position.attr,
D
Dan Williams 已提交
4147
	&md_array_size.attr,
4148
	&max_corr_read_errors.attr,
4149 4150 4151 4152
	NULL,
};

static struct attribute *md_redundancy_attrs[] = {
4153
	&md_scan_mode.attr,
4154
	&md_mismatches.attr,
4155 4156 4157
	&md_sync_min.attr,
	&md_sync_max.attr,
	&md_sync_speed.attr,
4158
	&md_sync_force_parallel.attr,
4159
	&md_sync_completed.attr,
4160
	&md_min_sync.attr,
4161
	&md_max_sync.attr,
4162 4163
	&md_suspend_lo.attr,
	&md_suspend_hi.attr,
4164
	&md_bitmap.attr,
4165
	&md_degraded.attr,
4166 4167
	NULL,
};
4168 4169 4170 4171 4172
static struct attribute_group md_redundancy_group = {
	.name = NULL,
	.attrs = md_redundancy_attrs,
};

4173 4174 4175 4176 4177 4178

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);
4179
	ssize_t rv;
4180 4181 4182

	if (!entry->show)
		return -EIO;
I
Ingo Molnar 已提交
4183 4184 4185 4186 4187
	rv = mddev_lock(mddev);
	if (!rv) {
		rv = entry->show(mddev, page);
		mddev_unlock(mddev);
	}
4188
	return rv;
4189 4190 4191 4192 4193 4194 4195 4196
}

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);
4197
	ssize_t rv;
4198 4199 4200

	if (!entry->store)
		return -EIO;
4201 4202
	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
I
Ingo Molnar 已提交
4203
	rv = mddev_lock(mddev);
4204 4205
	if (mddev->hold_active == UNTIL_IOCTL)
		mddev->hold_active = 0;
I
Ingo Molnar 已提交
4206 4207 4208 4209
	if (!rv) {
		rv = entry->store(mddev, page, length);
		mddev_unlock(mddev);
	}
4210
	return rv;
4211 4212 4213 4214 4215
}

static void md_free(struct kobject *ko)
{
	mddev_t *mddev = container_of(ko, mddev_t, kobj);
4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226

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

4227 4228 4229
	kfree(mddev);
}

4230
static const struct sysfs_ops md_sysfs_ops = {
4231 4232 4233 4234 4235 4236 4237 4238 4239
	.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 已提交
4240 4241
int mdp_major = 0;

4242 4243 4244 4245
static void mddev_delayed_delete(struct work_struct *ws)
{
	mddev_t *mddev = container_of(ws, mddev_t, del_work);

4246
	sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
4247 4248 4249 4250
	kobject_del(&mddev->kobj);
	kobject_put(&mddev->kobj);
}

4251
static int md_alloc(dev_t dev, char *name)
L
Linus Torvalds 已提交
4252
{
A
Arjan van de Ven 已提交
4253
	static DEFINE_MUTEX(disks_mutex);
L
Linus Torvalds 已提交
4254 4255
	mddev_t *mddev = mddev_find(dev);
	struct gendisk *disk;
4256 4257 4258
	int partitioned;
	int shift;
	int unit;
4259
	int error;
L
Linus Torvalds 已提交
4260 4261

	if (!mddev)
4262 4263 4264 4265 4266
		return -ENODEV;

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

T
Tejun Heo 已提交
4268 4269
	/* wait for any previous instance of this device to be
	 * completely removed (mddev_delayed_delete).
4270
	 */
T
Tejun Heo 已提交
4271
	flush_workqueue(md_misc_wq);
4272

A
Arjan van de Ven 已提交
4273
	mutex_lock(&disks_mutex);
N
NeilBrown 已提交
4274 4275 4276
	error = -EEXIST;
	if (mddev->gendisk)
		goto abort;
4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287

	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 已提交
4288
				goto abort;
4289 4290
			}
		spin_unlock(&all_mddevs_lock);
L
Linus Torvalds 已提交
4291
	}
4292

N
NeilBrown 已提交
4293
	error = -ENOMEM;
4294
	mddev->queue = blk_alloc_queue(GFP_KERNEL);
N
NeilBrown 已提交
4295 4296
	if (!mddev->queue)
		goto abort;
4297 4298
	mddev->queue->queuedata = mddev;

4299 4300 4301
	/* Can be unlocked because the queue is new: no concurrency */
	queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, mddev->queue);

4302
	blk_queue_make_request(mddev->queue, md_make_request);
4303

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

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

4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375
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 已提交
4376 4377 4378 4379
static void md_safemode_timeout(unsigned long data)
{
	mddev_t *mddev = (mddev_t *) data;

4380 4381 4382
	if (!atomic_read(&mddev->writes_pending)) {
		mddev->safemode = 1;
		if (mddev->external)
N
NeilBrown 已提交
4383
			sysfs_notify_dirent_safe(mddev->sysfs_state);
4384
	}
L
Linus Torvalds 已提交
4385 4386 4387
	md_wakeup_thread(mddev->thread);
}

4388
static int start_dirty_degraded;
L
Linus Torvalds 已提交
4389

4390
int md_run(mddev_t *mddev)
L
Linus Torvalds 已提交
4391
{
4392
	int err;
L
Linus Torvalds 已提交
4393
	mdk_rdev_t *rdev;
4394
	struct mdk_personality *pers;
L
Linus Torvalds 已提交
4395

4396 4397
	if (list_empty(&mddev->disks))
		/* cannot run an array with no devices.. */
L
Linus Torvalds 已提交
4398 4399 4400 4401
		return -EINVAL;

	if (mddev->pers)
		return -EBUSY;
4402 4403 4404
	/* Cannot run until previous stop completes properly */
	if (mddev->sysfs_active)
		return -EBUSY;
4405

L
Linus Torvalds 已提交
4406 4407 4408
	/*
	 * Analyze all RAID superblock(s)
	 */
4409 4410 4411
	if (!mddev->raid_disks) {
		if (!mddev->persistent)
			return -EINVAL;
4412
		analyze_sbs(mddev);
4413
	}
L
Linus Torvalds 已提交
4414

4415 4416 4417 4418
	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 已提交
4419 4420 4421 4422 4423 4424

	/*
	 * Drop all container device buffers, from now on
	 * the only valid external interface is through the md
	 * device.
	 */
4425
	list_for_each_entry(rdev, &mddev->disks, same_set) {
4426
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
4427 4428
			continue;
		sync_blockdev(rdev->bdev);
4429
		invalidate_bdev(rdev->bdev);
4430 4431 4432

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

4454 4455 4456
	if (mddev->bio_set == NULL)
		mddev->bio_set = bioset_create(BIO_POOL_SIZE, sizeof(mddev));

L
Linus Torvalds 已提交
4457
	spin_lock(&pers_lock);
4458
	pers = find_pers(mddev->level, mddev->clevel);
4459
	if (!pers || !try_module_get(pers->owner)) {
L
Linus Torvalds 已提交
4460
		spin_unlock(&pers_lock);
4461 4462 4463 4464 4465 4466
		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 已提交
4467 4468
		return -EINVAL;
	}
4469
	mddev->pers = pers;
L
Linus Torvalds 已提交
4470
	spin_unlock(&pers_lock);
4471 4472 4473 4474
	if (mddev->level != pers->level) {
		mddev->level = pers->level;
		mddev->new_level = pers->level;
	}
4475
	strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
L
Linus Torvalds 已提交
4476

4477
	if (mddev->reshape_position != MaxSector &&
4478
	    pers->start_reshape == NULL) {
4479 4480 4481 4482 4483 4484
		/* This personality cannot handle reshaping... */
		mddev->pers = NULL;
		module_put(pers->owner);
		return -EINVAL;
	}

4485 4486 4487 4488 4489 4490 4491
	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;
4492 4493 4494

		list_for_each_entry(rdev, &mddev->disks, same_set)
			list_for_each_entry(rdev2, &mddev->disks, same_set) {
4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507
				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;
				}
			}
4508

4509 4510 4511 4512 4513 4514
		if (warned)
			printk(KERN_WARNING
			       "True protection against single-disk"
			       " failure might be compromised.\n");
	}

4515
	mddev->recovery = 0;
A
Andre Noll 已提交
4516 4517 4518
	/* may be over-ridden by personality */
	mddev->resync_max_sectors = mddev->dev_sectors;

4519
	mddev->ok_start_degraded = start_dirty_degraded;
L
Linus Torvalds 已提交
4520

4521
	if (start_readonly && mddev->ro == 0)
4522 4523
		mddev->ro = 2; /* read-only, but switch on first write */

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

L
Linus Torvalds 已提交
4561
 	atomic_set(&mddev->writes_pending,0);
4562 4563
	atomic_set(&mddev->max_corr_read_errors,
		   MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
L
Linus Torvalds 已提交
4564 4565 4566
	mddev->safemode = 0;
	mddev->safemode_timer.function = md_safemode_timeout;
	mddev->safemode_timer.data = (unsigned long) mddev;
4567
	mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
L
Linus Torvalds 已提交
4568
	mddev->in_sync = 1;
4569

4570
	list_for_each_entry(rdev, &mddev->disks, same_set)
4571 4572 4573
		if (rdev->raid_disk >= 0) {
			char nm[20];
			sprintf(nm, "rd%d", rdev->raid_disk);
4574
			if (sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
N
NeilBrown 已提交
4575
				/* failure here is OK */;
4576
		}
L
Linus Torvalds 已提交
4577 4578 4579
	
	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
	
4580 4581
	if (mddev->flags)
		md_update_sb(mddev, 0);
L
Linus Torvalds 已提交
4582

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

4586
	md_new_event(mddev);
N
NeilBrown 已提交
4587 4588
	sysfs_notify_dirent_safe(mddev->sysfs_state);
	sysfs_notify_dirent_safe(mddev->sysfs_action);
4589
	sysfs_notify(&mddev->kobj, NULL, "degraded");
L
Linus Torvalds 已提交
4590 4591
	return 0;
}
4592
EXPORT_SYMBOL_GPL(md_run);
L
Linus Torvalds 已提交
4593

4594 4595 4596 4597 4598 4599 4600
static int do_md_run(mddev_t *mddev)
{
	int err;

	err = md_run(mddev);
	if (err)
		goto out;
4601 4602 4603 4604 4605
	err = bitmap_load(mddev);
	if (err) {
		bitmap_destroy(mddev);
		goto out;
	}
4606 4607 4608 4609 4610 4611 4612
	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 已提交
4613 4614 4615 4616
static int restart_array(mddev_t *mddev)
{
	struct gendisk *disk = mddev->gendisk;

A
Andre Noll 已提交
4617
	/* Complain if it has no devices */
L
Linus Torvalds 已提交
4618
	if (list_empty(&mddev->disks))
A
Andre Noll 已提交
4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632
		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 已提交
4633
	sysfs_notify_dirent_safe(mddev->sysfs_state);
A
Andre Noll 已提交
4634
	return 0;
L
Linus Torvalds 已提交
4635 4636
}

4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653
/* 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;
}

4654
void restore_bitmap_write_access(struct file *file)
4655 4656 4657 4658 4659 4660 4661 4662
{
	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 已提交
4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684
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;
4685
	mddev->can_decrease_events = 0;
N
NeilBrown 已提交
4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702
	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;
4703
	mddev->plug = NULL;
N
NeilBrown 已提交
4704 4705
}

4706
void md_stop_writes(mddev_t *mddev)
4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725
{
	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);
	}
}
4726
EXPORT_SYMBOL_GPL(md_stop_writes);
4727

4728
void md_stop(mddev_t *mddev)
N
NeilBrown 已提交
4729 4730 4731 4732 4733 4734
{
	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 已提交
4735
	clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
N
NeilBrown 已提交
4736
}
4737
EXPORT_SYMBOL_GPL(md_stop);
N
NeilBrown 已提交
4738

4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756
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 已提交
4757
		sysfs_notify_dirent_safe(mddev->sysfs_state);
4758 4759 4760 4761 4762 4763 4764
		err = 0;	
	}
out:
	mutex_unlock(&mddev->open_mutex);
	return err;
}

4765 4766 4767 4768
/* mode:
 *   0 - completely stop and dis-assemble array
 *   2 - stop but do not disassemble array
 */
4769
static int do_md_stop(mddev_t * mddev, int mode, int is_open)
L
Linus Torvalds 已提交
4770 4771
{
	struct gendisk *disk = mddev->gendisk;
4772
	mdk_rdev_t *rdev;
L
Linus Torvalds 已提交
4773

N
NeilBrown 已提交
4774
	mutex_lock(&mddev->open_mutex);
4775 4776
	if (atomic_read(&mddev->openers) > is_open ||
	    mddev->sysfs_active) {
4777
		printk("md: %s still in use.\n",mdname(mddev));
N
NeilBrown 已提交
4778 4779 4780
		mutex_unlock(&mddev->open_mutex);
		return -EBUSY;
	}
L
Linus Torvalds 已提交
4781

N
NeilBrown 已提交
4782
	if (mddev->pers) {
4783 4784
		if (mddev->ro)
			set_disk_ro(disk, 0);
4785

4786
		md_stop_writes(mddev);
4787 4788 4789 4790
		md_stop(mddev);
		mddev->queue->merge_bvec_fn = NULL;
		mddev->queue->unplug_fn = NULL;
		mddev->queue->backing_dev_info.congested_fn = NULL;
N
NeilBrown 已提交
4791

4792
		/* tell userspace to handle 'inactive' */
N
NeilBrown 已提交
4793
		sysfs_notify_dirent_safe(mddev->sysfs_state);
4794

4795 4796 4797 4798 4799 4800
		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);
			}
4801

4802
		set_capacity(disk, 0);
N
NeilBrown 已提交
4803
		mutex_unlock(&mddev->open_mutex);
4804
		revalidate_disk(disk);
4805

4806 4807
		if (mddev->ro)
			mddev->ro = 0;
N
NeilBrown 已提交
4808 4809
	} else
		mutex_unlock(&mddev->open_mutex);
L
Linus Torvalds 已提交
4810 4811 4812
	/*
	 * Free resources if final stop
	 */
4813
	if (mode == 0) {
L
Linus Torvalds 已提交
4814 4815
		printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));

4816
		bitmap_destroy(mddev);
4817 4818 4819 4820
		if (mddev->bitmap_info.file) {
			restore_bitmap_write_access(mddev->bitmap_info.file);
			fput(mddev->bitmap_info.file);
			mddev->bitmap_info.file = NULL;
4821
		}
4822
		mddev->bitmap_info.offset = 0;
4823

L
Linus Torvalds 已提交
4824 4825
		export_array(mddev);

N
NeilBrown 已提交
4826
		md_clean(mddev);
4827
		kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
4828 4829
		if (mddev->hold_active == UNTIL_STOP)
			mddev->hold_active = 0;
4830
	}
M
Martin K. Petersen 已提交
4831
	blk_integrity_unregister(disk);
4832
	md_new_event(mddev);
N
NeilBrown 已提交
4833
	sysfs_notify_dirent_safe(mddev->sysfs_state);
N
NeilBrown 已提交
4834
	return 0;
L
Linus Torvalds 已提交
4835 4836
}

J
Jeff Garzik 已提交
4837
#ifndef MODULE
L
Linus Torvalds 已提交
4838 4839 4840 4841 4842
static void autorun_array(mddev_t *mddev)
{
	mdk_rdev_t *rdev;
	int err;

4843
	if (list_empty(&mddev->disks))
L
Linus Torvalds 已提交
4844 4845 4846 4847
		return;

	printk(KERN_INFO "md: running: ");

4848
	list_for_each_entry(rdev, &mddev->disks, same_set) {
L
Linus Torvalds 已提交
4849 4850 4851 4852 4853
		char b[BDEVNAME_SIZE];
		printk("<%s>", bdevname(rdev->bdev,b));
	}
	printk("\n");

4854
	err = do_md_run(mddev);
L
Linus Torvalds 已提交
4855 4856
	if (err) {
		printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
4857
		do_md_stop(mddev, 0, 0);
L
Linus Torvalds 已提交
4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874
	}
}

/*
 * 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)
{
4875
	mdk_rdev_t *rdev0, *rdev, *tmp;
L
Linus Torvalds 已提交
4876 4877 4878 4879 4880
	mddev_t *mddev;
	char b[BDEVNAME_SIZE];

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

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

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

	info.layout        = mddev->layout;
5016
	info.chunk_size    = mddev->chunk_sectors << 9;
L
Linus Torvalds 已提交
5017 5018 5019 5020 5021 5022 5023

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

	return 0;
}

5024
static int get_bitmap_file(mddev_t * mddev, void __user * arg)
5025 5026 5027 5028 5029
{
	mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
	char *ptr, *buf = NULL;
	int err = -ENOMEM;

5030 5031 5032 5033
	if (md_allow_write(mddev))
		file = kmalloc(sizeof(*file), GFP_NOIO);
	else
		file = kmalloc(sizeof(*file), GFP_KERNEL);
5034

5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047
	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 已提交
5048 5049
	ptr = d_path(&mddev->bitmap->file->f_path, buf, sizeof(file->pathname));
	if (IS_ERR(ptr))
5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063
		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 已提交
5064 5065 5066 5067 5068 5069 5070 5071
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;

5072
	rdev = find_rdev_nr(mddev, info.number);
L
Linus Torvalds 已提交
5073 5074 5075 5076 5077
	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;
5078
		if (test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
5079
			info.state |= (1<<MD_DISK_FAULTY);
5080
		else if (test_bit(In_sync, &rdev->flags)) {
L
Linus Torvalds 已提交
5081 5082 5083
			info.state |= (1<<MD_DISK_ACTIVE);
			info.state |= (1<<MD_DISK_SYNC);
		}
5084 5085
		if (test_bit(WriteMostly, &rdev->flags))
			info.state |= (1<<MD_DISK_WRITEMOSTLY);
L
Linus Torvalds 已提交
5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119
	} 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);
5120
			err = super_types[mddev->major_version]
L
Linus Torvalds 已提交
5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149
				.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;
		}
5150 5151 5152 5153 5154
		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 已提交
5155 5156 5157 5158 5159 5160
		if (IS_ERR(rdev)) {
			printk(KERN_WARNING 
				"md: md_import_device returned %ld\n",
				PTR_ERR(rdev));
			return PTR_ERR(rdev);
		}
5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172
		/* 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;

5173
		clear_bit(In_sync, &rdev->flags); /* just to be sure */
5174 5175
		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);
5176 5177
		else
			clear_bit(WriteMostly, &rdev->flags);
5178

L
Linus Torvalds 已提交
5179 5180
		rdev->raid_disk = -1;
		err = bind_rdev_to_array(rdev, mddev);
5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191
		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 已提交
5192 5193
		if (err)
			export_rdev(rdev);
5194
		else
N
NeilBrown 已提交
5195
			sysfs_notify_dirent_safe(rdev->sysfs_state);
5196

5197
		md_update_sb(mddev, 1);
5198 5199
		if (mddev->degraded)
			set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
5200
		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5201
		md_wakeup_thread(mddev->thread);
L
Linus Torvalds 已提交
5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215
		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;
5216
		rdev = md_import_device(dev, -1, 0);
L
Linus Torvalds 已提交
5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229
		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)
5230 5231
			if (info->state & (1<<MD_DISK_SYNC))
				set_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
5232

5233 5234 5235
		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
			set_bit(WriteMostly, &rdev->flags);

L
Linus Torvalds 已提交
5236 5237
		if (!mddev->persistent) {
			printk(KERN_INFO "md: nonpersistent superblock ...\n");
5238
			rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
L
Linus Torvalds 已提交
5239
		} else 
5240
			rdev->sb_start = calc_dev_sboffset(rdev->bdev);
5241
		rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
5242

5243 5244 5245 5246 5247
		err = bind_rdev_to_array(rdev, mddev);
		if (err) {
			export_rdev(rdev);
			return err;
		}
L
Linus Torvalds 已提交
5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265
	}

	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);
5266
	md_update_sb(mddev, 1);
5267
	md_new_event(mddev);
L
Linus Torvalds 已提交
5268 5269 5270

	return 0;
busy:
5271
	printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
L
Linus Torvalds 已提交
5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297
		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;
	}

5298
	rdev = md_import_device(dev, -1, 0);
L
Linus Torvalds 已提交
5299 5300 5301 5302 5303 5304 5305 5306
	if (IS_ERR(rdev)) {
		printk(KERN_WARNING 
			"md: error, md_import_device() returned %ld\n",
			PTR_ERR(rdev));
		return -EINVAL;
	}

	if (mddev->persistent)
5307
		rdev->sb_start = calc_dev_sboffset(rdev->bdev);
L
Linus Torvalds 已提交
5308
	else
5309
		rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
L
Linus Torvalds 已提交
5310

5311
	rdev->sectors = rdev->sb_start;
L
Linus Torvalds 已提交
5312

5313
	if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
5314 5315 5316 5317 5318 5319
		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;
	}
5320
	clear_bit(In_sync, &rdev->flags);
L
Linus Torvalds 已提交
5321
	rdev->desc_nr = -1;
5322
	rdev->saved_raid_disk = -1;
5323 5324 5325
	err = bind_rdev_to_array(rdev, mddev);
	if (err)
		goto abort_export;
L
Linus Torvalds 已提交
5326 5327 5328 5329 5330 5331 5332 5333

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

	rdev->raid_disk = -1;

5334
	md_update_sb(mddev, 1);
L
Linus Torvalds 已提交
5335 5336 5337 5338 5339 5340 5341

	/*
	 * 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);
5342
	md_new_event(mddev);
L
Linus Torvalds 已提交
5343 5344 5345 5346 5347 5348 5349
	return 0;

abort_export:
	export_rdev(rdev);
	return err;
}

5350 5351 5352 5353
static int set_bitmap_file(mddev_t *mddev, int fd)
{
	int err;

5354 5355 5356 5357 5358 5359 5360
	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.. */
	}
5361 5362


5363 5364 5365
	if (fd >= 0) {
		if (mddev->bitmap)
			return -EEXIST; /* cannot add when bitmap is present */
5366
		mddev->bitmap_info.file = fget(fd);
5367

5368
		if (mddev->bitmap_info.file == NULL) {
5369 5370 5371 5372 5373
			printk(KERN_ERR "%s: error: failed to get bitmap file\n",
			       mdname(mddev));
			return -EBADF;
		}

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

5407 5408 5409
	return err;
}

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

	mddev->layout        = info->layout;
5467
	mddev->chunk_sectors = info->chunk_size >> 9;
L
Linus Torvalds 已提交
5468 5469 5470

	mddev->max_disks     = MD_SB_DISKS;

5471 5472
	if (mddev->persistent)
		mddev->flags         = 0;
5473
	set_bit(MD_CHANGE_DEVS, &mddev->flags);
L
Linus Torvalds 已提交
5474

5475 5476
	mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
	mddev->bitmap_info.offset = 0;
5477

5478 5479
	mddev->reshape_position = MaxSector;

L
Linus Torvalds 已提交
5480 5481 5482 5483 5484
	/*
	 * Generate a 128 bit UUID
	 */
	get_random_bytes(mddev->uuid, 16);

5485
	mddev->new_level = mddev->level;
5486
	mddev->new_chunk_sectors = mddev->chunk_sectors;
5487 5488 5489
	mddev->new_layout = mddev->layout;
	mddev->delta_disks = 0;

L
Linus Torvalds 已提交
5490 5491 5492
	return 0;
}

5493 5494
void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors)
{
D
Dan Williams 已提交
5495 5496 5497 5498 5499
	WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);

	if (mddev->external_size)
		return;

5500 5501 5502 5503
	mddev->array_sectors = array_sectors;
}
EXPORT_SYMBOL(md_set_array_sectors);

5504
static int update_size(mddev_t *mddev, sector_t num_sectors)
5505
{
5506
	mdk_rdev_t *rdev;
5507
	int rv;
5508
	int fit = (num_sectors == 0);
5509 5510 5511

	if (mddev->pers->resize == NULL)
		return -EINVAL;
5512 5513 5514 5515 5516
	/* 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
5517
	 * sb_start or, if that is <data_offset, it must fit before the size
5518 5519 5520
	 * of each device.  If num_sectors is zero, we find the largest size
	 * that fits.

5521 5522 5523
	 */
	if (mddev->sync_thread)
		return -EBUSY;
5524 5525 5526 5527 5528
	if (mddev->bitmap)
		/* Sorry, cannot grow a bitmap yet, just remove it,
		 * grow, and re-add.
		 */
		return -EBUSY;
5529
	list_for_each_entry(rdev, &mddev->disks, same_set) {
5530
		sector_t avail = rdev->sectors;
5531

5532 5533 5534
		if (fit && (num_sectors == 0 || num_sectors > avail))
			num_sectors = avail;
		if (avail < num_sectors)
5535 5536
			return -ENOSPC;
	}
5537
	rv = mddev->pers->resize(mddev, num_sectors);
5538 5539
	if (!rv)
		revalidate_disk(mddev->gendisk);
5540 5541 5542
	return rv;
}

5543 5544 5545 5546
static int update_raid_disks(mddev_t *mddev, int raid_disks)
{
	int rv;
	/* change the number of raid disks */
5547
	if (mddev->pers->check_reshape == NULL)
5548 5549
		return -EINVAL;
	if (raid_disks <= 0 ||
5550
	    (mddev->max_disks && raid_disks >= mddev->max_disks))
5551
		return -EINVAL;
5552
	if (mddev->sync_thread || mddev->reshape_position != MaxSector)
5553
		return -EBUSY;
5554 5555 5556
	mddev->delta_disks = raid_disks - mddev->raid_disks;

	rv = mddev->pers->check_reshape(mddev);
5557 5558 5559 5560
	return rv;
}


L
Linus Torvalds 已提交
5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572
/*
 * 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;
5573 5574 5575
	int state = 0;

	/* calculate expected state,ignoring low bits */
5576
	if (mddev->bitmap && mddev->bitmap_info.offset)
5577
		state |= (1 << MD_SB_BITMAP_PRESENT);
L
Linus Torvalds 已提交
5578 5579 5580 5581 5582 5583 5584 5585

	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||
5586
	    mddev->chunk_sectors != info->chunk_size >> 9 ||
5587 5588 5589
	    /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
	    ((state^info->state) & 0xfffffe00)
		)
L
Linus Torvalds 已提交
5590 5591
		return -EINVAL;
	/* Check there is only one change */
A
Andre Noll 已提交
5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603
	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 已提交
5604 5605 5606 5607 5608 5609

	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.
		 */
5610
		if (mddev->pers->check_reshape == NULL)
L
Linus Torvalds 已提交
5611
			return -EINVAL;
5612 5613
		else {
			mddev->new_layout = info->layout;
5614
			rv = mddev->pers->check_reshape(mddev);
5615 5616 5617 5618
			if (rv)
				mddev->new_layout = mddev->layout;
			return rv;
		}
L
Linus Torvalds 已提交
5619
	}
A
Andre Noll 已提交
5620
	if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
5621
		rv = update_size(mddev, (sector_t)info->size * 2);
5622

5623 5624 5625
	if (mddev->raid_disks    != info->raid_disks)
		rv = update_raid_disks(mddev, info->raid_disks);

5626 5627 5628 5629 5630 5631 5632 5633 5634
	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;
5635
			if (mddev->bitmap_info.default_offset == 0)
5636
				return -EINVAL;
5637 5638
			mddev->bitmap_info.offset =
				mddev->bitmap_info.default_offset;
5639 5640
			mddev->pers->quiesce(mddev, 1);
			rv = bitmap_create(mddev);
5641 5642
			if (!rv)
				rv = bitmap_load(mddev);
5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654
			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);
5655
			mddev->bitmap_info.offset = 0;
5656 5657
		}
	}
5658
	md_update_sb(mddev, 1);
L
Linus Torvalds 已提交
5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676
	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;
}

5677 5678 5679 5680 5681 5682
/*
 * 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... ;-)
 */
5683 5684 5685 5686 5687 5688
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;
5689
	geo->cylinders = mddev->array_sectors / 8;
5690 5691 5692
	return 0;
}

A
Al Viro 已提交
5693
static int md_ioctl(struct block_device *bdev, fmode_t mode,
L
Linus Torvalds 已提交
5694 5695 5696 5697 5698
			unsigned int cmd, unsigned long arg)
{
	int err = 0;
	void __user *argp = (void __user *)arg;
	mddev_t *mddev = NULL;
5699
	int ro;
L
Linus Torvalds 已提交
5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731

	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 已提交
5732
	mddev = bdev->bd_disk->private_data;
L
Linus Torvalds 已提交
5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795

	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:
	 */
5796
	/* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
5797
	 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
5798 5799 5800 5801
	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 已提交
5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814
		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;

5815
		case GET_BITMAP_FILE:
5816
			err = get_bitmap_file(mddev, argp);
5817 5818
			goto done_unlock;

L
Linus Torvalds 已提交
5819 5820 5821 5822 5823 5824 5825 5826 5827
		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:
5828
			err = do_md_stop(mddev, 0, 1);
L
Linus Torvalds 已提交
5829 5830 5831
			goto done_unlock;

		case STOP_ARRAY_RO:
5832
			err = md_set_readonly(mddev, 1);
L
Linus Torvalds 已提交
5833 5834
			goto done_unlock;

5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862
		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 已提交
5863 5864 5865 5866
	}

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

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

5912 5913 5914 5915
		case SET_BITMAP_FILE:
			err = set_bitmap_file(mddev, (int)arg);
			goto done_unlock;

L
Linus Torvalds 已提交
5916 5917 5918 5919 5920 5921 5922
		default:
			err = -EINVAL;
			goto abort_unlock;
	}

done_unlock:
abort_unlock:
5923 5924 5925
	if (mddev->hold_active == UNTIL_IOCTL &&
	    err != -EINVAL)
		mddev->hold_active = 0;
L
Linus Torvalds 已提交
5926 5927 5928 5929 5930 5931 5932 5933 5934
	mddev_unlock(mddev);

	return err;
done:
	if (err)
		MD_BUG();
abort:
	return err;
}
5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953
#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 已提交
5954

A
Al Viro 已提交
5955
static int md_open(struct block_device *bdev, fmode_t mode)
L
Linus Torvalds 已提交
5956 5957 5958 5959 5960
{
	/*
	 * Succeed if we can lock the mddev, which confirms that
	 * it isn't being stopped right now.
	 */
5961
	mddev_t *mddev = mddev_find(bdev->bd_dev);
L
Linus Torvalds 已提交
5962 5963
	int err;

5964 5965 5966 5967 5968 5969
	if (mddev->gendisk != bdev->bd_disk) {
		/* we are racing with mddev_put which is discarding this
		 * bd_disk.
		 */
		mddev_put(mddev);
		/* Wait until bdev->bd_disk is definitely gone */
T
Tejun Heo 已提交
5970
		flush_workqueue(md_misc_wq);
5971 5972 5973 5974 5975
		/* Then retry the open from the top */
		return -ERESTARTSYS;
	}
	BUG_ON(mddev != bdev->bd_disk->private_data);

N
NeilBrown 已提交
5976
	if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
L
Linus Torvalds 已提交
5977 5978 5979
		goto out;

	err = 0;
5980
	atomic_inc(&mddev->openers);
N
NeilBrown 已提交
5981
	mutex_unlock(&mddev->open_mutex);
L
Linus Torvalds 已提交
5982

5983
	check_disk_size_change(mddev->gendisk, bdev);
L
Linus Torvalds 已提交
5984 5985 5986 5987
 out:
	return err;
}

A
Al Viro 已提交
5988
static int md_release(struct gendisk *disk, fmode_t mode)
L
Linus Torvalds 已提交
5989
{
A
Al Viro 已提交
5990
 	mddev_t *mddev = disk->private_data;
L
Linus Torvalds 已提交
5991

E
Eric Sesterhenn 已提交
5992
	BUG_ON(!mddev);
5993
	atomic_dec(&mddev->openers);
L
Linus Torvalds 已提交
5994 5995 5996 5997
	mddev_put(mddev);

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

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

6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041
		/* 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 已提交
6042 6043 6044

		clear_bit(THREAD_WAKEUP, &thread->flags);

6045
		thread->run(thread->mddev);
L
Linus Torvalds 已提交
6046
	}
6047

L
Linus Torvalds 已提交
6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064
	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;

6065
	thread = kzalloc(sizeof(mdk_thread_t), GFP_KERNEL);
L
Linus Torvalds 已提交
6066 6067 6068 6069 6070 6071 6072
	if (!thread)
		return NULL;

	init_waitqueue_head(&thread->wqueue);

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

void md_unregister_thread(mdk_thread_t *thread)
{
6087 6088
	if (!thread)
		return;
6089
	dprintk("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
6090 6091

	kthread_stop(thread->tsk);
L
Linus Torvalds 已提交
6092 6093 6094 6095 6096 6097 6098 6099 6100 6101
	kfree(thread);
}

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

6102
	if (!rdev || test_bit(Faulty, &rdev->flags))
L
Linus Torvalds 已提交
6103
		return;
6104 6105 6106

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

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

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

6160
	resync = mddev->curr_resync - atomic_read(&mddev->recovery_active);
L
Linus Torvalds 已提交
6161 6162

	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
6163
		max_sectors = mddev->resync_max_sectors;
L
Linus Torvalds 已提交
6164
	else
6165
		max_sectors = mddev->dev_sectors;
L
Linus Torvalds 已提交
6166 6167 6168 6169

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

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

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

6228 6229 6230 6231 6232 6233 6234
	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 已提交
6235

6236
	seq_printf(seq, " speed=%ldK/sec", db/2/dt);
L
Linus Torvalds 已提交
6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300
}

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

6301 6302 6303 6304
struct mdstat_info {
	int event;
};

L
Linus Torvalds 已提交
6305 6306 6307
static int md_seq_show(struct seq_file *seq, void *v)
{
	mddev_t *mddev = v;
6308
	sector_t sectors;
L
Linus Torvalds 已提交
6309
	mdk_rdev_t *rdev;
6310
	struct mdstat_info *mi = seq->private;
6311
	struct bitmap *bitmap;
L
Linus Torvalds 已提交
6312 6313

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

		spin_unlock(&pers_lock);
		seq_printf(seq, "\n");
6322
		mi->event = atomic_read(&md_event_count);
L
Linus Torvalds 已提交
6323 6324 6325 6326 6327 6328 6329
		return 0;
	}
	if (v == (void*)2) {
		status_unused(seq);
		return 0;
	}

I
Ingo Molnar 已提交
6330
	if (mddev_lock(mddev) < 0)
L
Linus Torvalds 已提交
6331
		return -EINTR;
I
Ingo Molnar 已提交
6332

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

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

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

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

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

6414 6415
			seq_printf(seq, "\n");
			spin_unlock_irqrestore(&bitmap->lock, flags);
L
Linus Torvalds 已提交
6416 6417 6418 6419 6420 6421 6422 6423 6424
		}

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

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

	error = seq_open(file, &md_seq_ops);
6440 6441 6442 6443 6444 6445 6446
	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 已提交
6447 6448 6449
	return error;
}

6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465
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;
}

6466
static const struct file_operations md_seq_fops = {
6467
	.owner		= THIS_MODULE,
L
Linus Torvalds 已提交
6468 6469 6470
	.open           = md_seq_open,
	.read           = seq_read,
	.llseek         = seq_lseek,
6471
	.release	= seq_release_private,
6472
	.poll		= mdstat_poll,
L
Linus Torvalds 已提交
6473 6474
};

6475
int register_md_personality(struct mdk_personality *p)
L
Linus Torvalds 已提交
6476 6477
{
	spin_lock(&pers_lock);
6478 6479
	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 已提交
6480 6481 6482 6483
	spin_unlock(&pers_lock);
	return 0;
}

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

N
NeilBrown 已提交
6493
static int is_mddev_idle(mddev_t *mddev, int init)
L
Linus Torvalds 已提交
6494 6495 6496
{
	mdk_rdev_t * rdev;
	int idle;
N
NeilBrown 已提交
6497
	int curr_events;
L
Linus Torvalds 已提交
6498 6499

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


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

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

void md_write_end(mddev_t *mddev)
{
	if (atomic_dec_and_test(&mddev->writes_pending)) {
		if (mddev->safemode == 2)
			md_wakeup_thread(mddev->thread);
6595
		else if (mddev->safemode_delay)
L
Linus Torvalds 已提交
6596 6597 6598 6599
			mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
	}
}

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

	spin_lock_irq(&mddev->write_lock);
	if (mddev->in_sync) {
		mddev->in_sync = 0;
		set_bit(MD_CHANGE_CLEAN, &mddev->flags);
6622
		set_bit(MD_CHANGE_PENDING, &mddev->flags);
6623 6624 6625 6626 6627
		if (mddev->safemode_delay &&
		    mddev->safemode == 0)
			mddev->safemode = 1;
		spin_unlock_irq(&mddev->write_lock);
		md_update_sb(mddev, 0);
N
NeilBrown 已提交
6628
		sysfs_notify_dirent_safe(mddev->sysfs_state);
6629 6630
	} else
		spin_unlock_irq(&mddev->write_lock);
6631

6632
	if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
6633 6634 6635
		return -EAGAIN;
	else
		return 0;
6636 6637 6638
}
EXPORT_SYMBOL_GPL(md_allow_write);

N
NeilBrown 已提交
6639
void md_unplug(mddev_t *mddev)
6640 6641 6642 6643 6644 6645 6646
{
	if (mddev->queue)
		blk_unplug(mddev->queue);
	if (mddev->plug)
		mddev->plug->unplug_fn(mddev->plug);
}

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

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

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

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

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

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

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

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

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

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

6815
		skipped = 0;
6816

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

6834 6835 6836 6837 6838 6839 6840 6841 6842 6843
		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());
		}
6844 6845 6846 6847

		if (kthread_should_stop())
			goto interrupted;

6848
		sectors = mddev->pers->sync_request(mddev, j, &skipped,
6849
						  currspeed < speed_min(mddev));
6850
		if (sectors == 0) {
6851
			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
L
Linus Torvalds 已提交
6852 6853
			goto out;
		}
6854 6855 6856 6857 6858 6859

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

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

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

6872
		last_check = io_sectors;
L
Linus Torvalds 已提交
6873

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


6890 6891 6892
		if (kthread_should_stop())
			goto interrupted;

L
Linus Torvalds 已提交
6893 6894 6895 6896 6897 6898 6899 6900 6901

		/*
		 * 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)
		 */
6902
		md_unplug(mddev);
L
Linus Torvalds 已提交
6903 6904
		cond_resched();

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

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

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

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

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

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


6986 6987 6988 6989 6990
static int remove_and_add_spares(mddev_t *mddev)
{
	mdk_rdev_t *rdev;
	int spares = 0;

6991 6992
	mddev->curr_resync_completed = 0;

6993
	list_for_each_entry(rdev, &mddev->disks, same_set)
6994
		if (rdev->raid_disk >= 0 &&
6995
		    !test_bit(Blocked, &rdev->flags) &&
6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007
		    (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;
			}
		}

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


7061
	if (mddev->bitmap)
7062
		bitmap_daemon_work(mddev);
L
Linus Torvalds 已提交
7063 7064 7065

	if (mddev->ro)
		return;
7066 7067

	if (signal_pending(current)) {
7068
		if (mddev->pers->sync_request && !mddev->external) {
7069 7070 7071 7072 7073 7074 7075
			printk(KERN_INFO "md: %s in immediate safe mode\n",
			       mdname(mddev));
			mddev->safemode = 2;
		}
		flush_signals(current);
	}

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

7088
	if (mddev_trylock(mddev)) {
7089
		int spares = 0;
7090

7091 7092 7093 7094 7095 7096 7097 7098 7099
		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;
		}

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

7118 7119
		if (mddev->flags)
			md_update_sb(mddev, 0);
7120

L
Linus Torvalds 已提交
7121 7122 7123 7124 7125 7126 7127 7128 7129 7130
		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;
7131 7132
			if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
			    !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
L
Linus Torvalds 已提交
7133 7134
				/* success...*/
				/* activate any spares */
7135 7136 7137
				if (mddev->pers->spare_active(mddev))
					sysfs_notify(&mddev->kobj, NULL,
						     "degraded");
L
Linus Torvalds 已提交
7138
			}
7139 7140 7141
			if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
			    mddev->pers->finish_reshape)
				mddev->pers->finish_reshape(mddev);
7142
			md_update_sb(mddev, 1);
7143 7144 7145 7146 7147

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

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

7169 7170
		if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
			goto unlock;
L
Linus Torvalds 已提交
7171 7172 7173 7174 7175 7176 7177
		/* 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.
		 */

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

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

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

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

7281
	proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
L
Linus Torvalds 已提交
7282 7283
}

A
Adrian Bunk 已提交
7284
static int __init md_init(void)
L
Linus Torvalds 已提交
7285
{
T
Tejun Heo 已提交
7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302
	int ret = -ENOMEM;

	md_wq = alloc_workqueue("md", WQ_RESCUER, 0);
	if (!md_wq)
		goto err_wq;

	md_misc_wq = alloc_workqueue("md_misc", 0, 0);
	if (!md_misc_wq)
		goto err_misc_wq;

	if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
		goto err_md;

	if ((ret = register_blkdev(0, "mdp")) < 0)
		goto err_mdp;
	mdp_major = ret;

C
Christoph Hellwig 已提交
7303
	blk_register_region(MKDEV(MD_MAJOR, 0), 1UL<<MINORBITS, THIS_MODULE,
7304 7305
			    md_probe, NULL, NULL);
	blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
L
Linus Torvalds 已提交
7306 7307 7308
			    md_probe, NULL, NULL);

	register_reboot_notifier(&md_notifier);
7309
	raid_table_header = register_sysctl_table(raid_root_table);
L
Linus Torvalds 已提交
7310 7311

	md_geninit();
7312
	return 0;
L
Linus Torvalds 已提交
7313

T
Tejun Heo 已提交
7314 7315 7316 7317 7318 7319 7320 7321 7322
err_mdp:
	unregister_blkdev(MD_MAJOR, "md");
err_md:
	destroy_workqueue(md_misc_wq);
err_misc_wq:
	destroy_workqueue(md_wq);
err_wq:
	return ret;
}
L
Linus Torvalds 已提交
7323 7324 7325 7326 7327 7328 7329

#ifndef MODULE

/*
 * Searches all registered partitions for autorun RAID arrays
 * at boot time.
 */
7330 7331 7332 7333 7334 7335

static LIST_HEAD(all_detected_devices);
struct detected_devices_node {
	struct list_head list;
	dev_t dev;
};
L
Linus Torvalds 已提交
7336 7337 7338

void md_autodetect_dev(dev_t dev)
{
7339 7340 7341 7342 7343 7344 7345 7346 7347 7348
	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 已提交
7349 7350 7351 7352 7353 7354
}


static void autostart_arrays(int part)
{
	mdk_rdev_t *rdev;
7355 7356 7357
	struct detected_devices_node *node_detected_dev;
	dev_t dev;
	int i_scanned, i_passed;
L
Linus Torvalds 已提交
7358

7359 7360
	i_scanned = 0;
	i_passed = 0;
L
Linus Torvalds 已提交
7361

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

7364 7365 7366 7367 7368 7369 7370
	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);
7371
		rdev = md_import_device(dev,0, 90);
L
Linus Torvalds 已提交
7372 7373 7374
		if (IS_ERR(rdev))
			continue;

7375
		if (test_bit(Faulty, &rdev->flags)) {
L
Linus Torvalds 已提交
7376 7377 7378
			MD_BUG();
			continue;
		}
7379
		set_bit(AutoDetected, &rdev->flags);
L
Linus Torvalds 已提交
7380
		list_add(&rdev->same_set, &pending_raid_disks);
7381
		i_passed++;
L
Linus Torvalds 已提交
7382
	}
7383 7384 7385

	printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
						i_scanned, i_passed);
L
Linus Torvalds 已提交
7386 7387 7388 7389

	autorun_devices(part);
}

J
Jeff Garzik 已提交
7390
#endif /* !MODULE */
L
Linus Torvalds 已提交
7391 7392 7393 7394 7395

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

C
Christoph Hellwig 已提交
7397
	blk_unregister_region(MKDEV(MD_MAJOR,0), 1U << MINORBITS);
7398
	blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
L
Linus Torvalds 已提交
7399

C
Christoph Hellwig 已提交
7400
	unregister_blkdev(MD_MAJOR,"md");
L
Linus Torvalds 已提交
7401 7402 7403 7404
	unregister_blkdev(mdp_major, "mdp");
	unregister_reboot_notifier(&md_notifier);
	unregister_sysctl_table(raid_table_header);
	remove_proc_entry("mdstat", NULL);
7405
	for_each_mddev(mddev, tmp) {
L
Linus Torvalds 已提交
7406
		export_array(mddev);
7407
		mddev->hold_active = 0;
L
Linus Torvalds 已提交
7408
	}
T
Tejun Heo 已提交
7409 7410
	destroy_workqueue(md_misc_wq);
	destroy_workqueue(md_wq);
L
Linus Torvalds 已提交
7411 7412
}

7413
subsys_initcall(md_init);
L
Linus Torvalds 已提交
7414 7415
module_exit(md_exit)

7416 7417 7418 7419 7420 7421 7422 7423 7424 7425
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;
7426
		return 0;
7427 7428 7429 7430
	}
	return -EINVAL;
}

7431 7432
module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
7433

7434
module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
7435

L
Linus Torvalds 已提交
7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446
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");
7447
MODULE_DESCRIPTION("MD RAID framework");
7448
MODULE_ALIAS("md");
7449
MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);