xref: /openbmc/linux/drivers/md/md.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 /*
2    md.c : Multiple Devices driver for Linux
3 	  Copyright (C) 1998, 1999, 2000 Ingo Molnar
4 
5      completely rewritten, based on the MD driver code from Marc Zyngier
6 
7    Changes:
8 
9    - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
10    - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
11    - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
12    - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
13    - kmod support by: Cyrus Durgin
14    - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
15    - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
16 
17    - lots of fixes and improvements to the RAID1/RAID5 and generic
18      RAID code (such as request based resynchronization):
19 
20      Neil Brown <neilb@cse.unsw.edu.au>.
21 
22    - persistent bitmap code
23      Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
24 
25    This program is free software; you can redistribute it and/or modify
26    it under the terms of the GNU General Public License as published by
27    the Free Software Foundation; either version 2, or (at your option)
28    any later version.
29 
30    You should have received a copy of the GNU General Public License
31    (for example /usr/src/linux/COPYING); if not, write to the Free
32    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33 */
34 
35 #include <linux/module.h>
36 #include <linux/kernel.h>
37 #include <linux/kthread.h>
38 #include <linux/linkage.h>
39 #include <linux/raid/md.h>
40 #include <linux/raid/bitmap.h>
41 #include <linux/sysctl.h>
42 #include <linux/buffer_head.h> /* for invalidate_bdev */
43 #include <linux/poll.h>
44 #include <linux/mutex.h>
45 #include <linux/ctype.h>
46 #include <linux/freezer.h>
47 
48 #include <linux/init.h>
49 
50 #include <linux/file.h>
51 
52 #ifdef CONFIG_KMOD
53 #include <linux/kmod.h>
54 #endif
55 
56 #include <asm/unaligned.h>
57 
58 #define MAJOR_NR MD_MAJOR
59 #define MD_DRIVER
60 
61 /* 63 partitions with the alternate major number (mdp) */
62 #define MdpMinorShift 6
63 
64 #define DEBUG 0
65 #define dprintk(x...) ((void)(DEBUG && printk(x)))
66 
67 
68 #ifndef MODULE
69 static void autostart_arrays (int part);
70 #endif
71 
72 static LIST_HEAD(pers_list);
73 static DEFINE_SPINLOCK(pers_lock);
74 
75 static void md_print_devices(void);
76 
77 #define MD_BUG(x...) { printk("md: bug in file %s, line %d\n", __FILE__, __LINE__); md_print_devices(); }
78 
79 /*
80  * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
81  * is 1000 KB/sec, so the extra system load does not show up that much.
82  * Increase it if you want to have more _guaranteed_ speed. Note that
83  * the RAID driver will use the maximum available bandwidth if the IO
84  * subsystem is idle. There is also an 'absolute maximum' reconstruction
85  * speed limit - in case reconstruction slows down your system despite
86  * idle IO detection.
87  *
88  * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
89  * or /sys/block/mdX/md/sync_speed_{min,max}
90  */
91 
92 static int sysctl_speed_limit_min = 1000;
93 static int sysctl_speed_limit_max = 200000;
94 static inline int speed_min(mddev_t *mddev)
95 {
96 	return mddev->sync_speed_min ?
97 		mddev->sync_speed_min : sysctl_speed_limit_min;
98 }
99 
100 static inline int speed_max(mddev_t *mddev)
101 {
102 	return mddev->sync_speed_max ?
103 		mddev->sync_speed_max : sysctl_speed_limit_max;
104 }
105 
106 static struct ctl_table_header *raid_table_header;
107 
108 static ctl_table raid_table[] = {
109 	{
110 		.ctl_name	= DEV_RAID_SPEED_LIMIT_MIN,
111 		.procname	= "speed_limit_min",
112 		.data		= &sysctl_speed_limit_min,
113 		.maxlen		= sizeof(int),
114 		.mode		= S_IRUGO|S_IWUSR,
115 		.proc_handler	= &proc_dointvec,
116 	},
117 	{
118 		.ctl_name	= DEV_RAID_SPEED_LIMIT_MAX,
119 		.procname	= "speed_limit_max",
120 		.data		= &sysctl_speed_limit_max,
121 		.maxlen		= sizeof(int),
122 		.mode		= S_IRUGO|S_IWUSR,
123 		.proc_handler	= &proc_dointvec,
124 	},
125 	{ .ctl_name = 0 }
126 };
127 
128 static ctl_table raid_dir_table[] = {
129 	{
130 		.ctl_name	= DEV_RAID,
131 		.procname	= "raid",
132 		.maxlen		= 0,
133 		.mode		= S_IRUGO|S_IXUGO,
134 		.child		= raid_table,
135 	},
136 	{ .ctl_name = 0 }
137 };
138 
139 static ctl_table raid_root_table[] = {
140 	{
141 		.ctl_name	= CTL_DEV,
142 		.procname	= "dev",
143 		.maxlen		= 0,
144 		.mode		= 0555,
145 		.child		= raid_dir_table,
146 	},
147 	{ .ctl_name = 0 }
148 };
149 
150 static struct block_device_operations md_fops;
151 
152 static int start_readonly;
153 
154 /*
155  * We have a system wide 'event count' that is incremented
156  * on any 'interesting' event, and readers of /proc/mdstat
157  * can use 'poll' or 'select' to find out when the event
158  * count increases.
159  *
160  * Events are:
161  *  start array, stop array, error, add device, remove device,
162  *  start build, activate spare
163  */
164 static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
165 static atomic_t md_event_count;
166 void md_new_event(mddev_t *mddev)
167 {
168 	atomic_inc(&md_event_count);
169 	wake_up(&md_event_waiters);
170 	sysfs_notify(&mddev->kobj, NULL, "sync_action");
171 }
172 EXPORT_SYMBOL_GPL(md_new_event);
173 
174 /* Alternate version that can be called from interrupts
175  * when calling sysfs_notify isn't needed.
176  */
177 static void md_new_event_inintr(mddev_t *mddev)
178 {
179 	atomic_inc(&md_event_count);
180 	wake_up(&md_event_waiters);
181 }
182 
183 /*
184  * Enables to iterate over all existing md arrays
185  * all_mddevs_lock protects this list.
186  */
187 static LIST_HEAD(all_mddevs);
188 static DEFINE_SPINLOCK(all_mddevs_lock);
189 
190 
191 /*
192  * iterates through all used mddevs in the system.
193  * We take care to grab the all_mddevs_lock whenever navigating
194  * the list, and to always hold a refcount when unlocked.
195  * Any code which breaks out of this loop while own
196  * a reference to the current mddev and must mddev_put it.
197  */
198 #define ITERATE_MDDEV(mddev,tmp)					\
199 									\
200 	for (({ spin_lock(&all_mddevs_lock); 				\
201 		tmp = all_mddevs.next;					\
202 		mddev = NULL;});					\
203 	     ({ if (tmp != &all_mddevs)					\
204 			mddev_get(list_entry(tmp, mddev_t, all_mddevs));\
205 		spin_unlock(&all_mddevs_lock);				\
206 		if (mddev) mddev_put(mddev);				\
207 		mddev = list_entry(tmp, mddev_t, all_mddevs);		\
208 		tmp != &all_mddevs;});					\
209 	     ({ spin_lock(&all_mddevs_lock);				\
210 		tmp = tmp->next;})					\
211 		)
212 
213 
214 static int md_fail_request (request_queue_t *q, struct bio *bio)
215 {
216 	bio_io_error(bio, bio->bi_size);
217 	return 0;
218 }
219 
220 static inline mddev_t *mddev_get(mddev_t *mddev)
221 {
222 	atomic_inc(&mddev->active);
223 	return mddev;
224 }
225 
226 static void mddev_put(mddev_t *mddev)
227 {
228 	if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
229 		return;
230 	if (!mddev->raid_disks && list_empty(&mddev->disks)) {
231 		list_del(&mddev->all_mddevs);
232 		spin_unlock(&all_mddevs_lock);
233 		blk_cleanup_queue(mddev->queue);
234 		kobject_unregister(&mddev->kobj);
235 	} else
236 		spin_unlock(&all_mddevs_lock);
237 }
238 
239 static mddev_t * mddev_find(dev_t unit)
240 {
241 	mddev_t *mddev, *new = NULL;
242 
243  retry:
244 	spin_lock(&all_mddevs_lock);
245 	list_for_each_entry(mddev, &all_mddevs, all_mddevs)
246 		if (mddev->unit == unit) {
247 			mddev_get(mddev);
248 			spin_unlock(&all_mddevs_lock);
249 			kfree(new);
250 			return mddev;
251 		}
252 
253 	if (new) {
254 		list_add(&new->all_mddevs, &all_mddevs);
255 		spin_unlock(&all_mddevs_lock);
256 		return new;
257 	}
258 	spin_unlock(&all_mddevs_lock);
259 
260 	new = kzalloc(sizeof(*new), GFP_KERNEL);
261 	if (!new)
262 		return NULL;
263 
264 	new->unit = unit;
265 	if (MAJOR(unit) == MD_MAJOR)
266 		new->md_minor = MINOR(unit);
267 	else
268 		new->md_minor = MINOR(unit) >> MdpMinorShift;
269 
270 	mutex_init(&new->reconfig_mutex);
271 	INIT_LIST_HEAD(&new->disks);
272 	INIT_LIST_HEAD(&new->all_mddevs);
273 	init_timer(&new->safemode_timer);
274 	atomic_set(&new->active, 1);
275 	spin_lock_init(&new->write_lock);
276 	init_waitqueue_head(&new->sb_wait);
277 	new->reshape_position = MaxSector;
278 
279 	new->queue = blk_alloc_queue(GFP_KERNEL);
280 	if (!new->queue) {
281 		kfree(new);
282 		return NULL;
283 	}
284 	set_bit(QUEUE_FLAG_CLUSTER, &new->queue->queue_flags);
285 
286 	blk_queue_make_request(new->queue, md_fail_request);
287 
288 	goto retry;
289 }
290 
291 static inline int mddev_lock(mddev_t * mddev)
292 {
293 	return mutex_lock_interruptible(&mddev->reconfig_mutex);
294 }
295 
296 static inline int mddev_trylock(mddev_t * mddev)
297 {
298 	return mutex_trylock(&mddev->reconfig_mutex);
299 }
300 
301 static inline void mddev_unlock(mddev_t * mddev)
302 {
303 	mutex_unlock(&mddev->reconfig_mutex);
304 
305 	md_wakeup_thread(mddev->thread);
306 }
307 
308 static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
309 {
310 	mdk_rdev_t * rdev;
311 	struct list_head *tmp;
312 
313 	ITERATE_RDEV(mddev,rdev,tmp) {
314 		if (rdev->desc_nr == nr)
315 			return rdev;
316 	}
317 	return NULL;
318 }
319 
320 static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
321 {
322 	struct list_head *tmp;
323 	mdk_rdev_t *rdev;
324 
325 	ITERATE_RDEV(mddev,rdev,tmp) {
326 		if (rdev->bdev->bd_dev == dev)
327 			return rdev;
328 	}
329 	return NULL;
330 }
331 
332 static struct mdk_personality *find_pers(int level, char *clevel)
333 {
334 	struct mdk_personality *pers;
335 	list_for_each_entry(pers, &pers_list, list) {
336 		if (level != LEVEL_NONE && pers->level == level)
337 			return pers;
338 		if (strcmp(pers->name, clevel)==0)
339 			return pers;
340 	}
341 	return NULL;
342 }
343 
344 static inline sector_t calc_dev_sboffset(struct block_device *bdev)
345 {
346 	sector_t size = bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
347 	return MD_NEW_SIZE_BLOCKS(size);
348 }
349 
350 static sector_t calc_dev_size(mdk_rdev_t *rdev, unsigned chunk_size)
351 {
352 	sector_t size;
353 
354 	size = rdev->sb_offset;
355 
356 	if (chunk_size)
357 		size &= ~((sector_t)chunk_size/1024 - 1);
358 	return size;
359 }
360 
361 static int alloc_disk_sb(mdk_rdev_t * rdev)
362 {
363 	if (rdev->sb_page)
364 		MD_BUG();
365 
366 	rdev->sb_page = alloc_page(GFP_KERNEL);
367 	if (!rdev->sb_page) {
368 		printk(KERN_ALERT "md: out of memory.\n");
369 		return -EINVAL;
370 	}
371 
372 	return 0;
373 }
374 
375 static void free_disk_sb(mdk_rdev_t * rdev)
376 {
377 	if (rdev->sb_page) {
378 		put_page(rdev->sb_page);
379 		rdev->sb_loaded = 0;
380 		rdev->sb_page = NULL;
381 		rdev->sb_offset = 0;
382 		rdev->size = 0;
383 	}
384 }
385 
386 
387 static int super_written(struct bio *bio, unsigned int bytes_done, int error)
388 {
389 	mdk_rdev_t *rdev = bio->bi_private;
390 	mddev_t *mddev = rdev->mddev;
391 	if (bio->bi_size)
392 		return 1;
393 
394 	if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags)) {
395 		printk("md: super_written gets error=%d, uptodate=%d\n",
396 		       error, test_bit(BIO_UPTODATE, &bio->bi_flags));
397 		WARN_ON(test_bit(BIO_UPTODATE, &bio->bi_flags));
398 		md_error(mddev, rdev);
399 	}
400 
401 	if (atomic_dec_and_test(&mddev->pending_writes))
402 		wake_up(&mddev->sb_wait);
403 	bio_put(bio);
404 	return 0;
405 }
406 
407 static int super_written_barrier(struct bio *bio, unsigned int bytes_done, int error)
408 {
409 	struct bio *bio2 = bio->bi_private;
410 	mdk_rdev_t *rdev = bio2->bi_private;
411 	mddev_t *mddev = rdev->mddev;
412 	if (bio->bi_size)
413 		return 1;
414 
415 	if (!test_bit(BIO_UPTODATE, &bio->bi_flags) &&
416 	    error == -EOPNOTSUPP) {
417 		unsigned long flags;
418 		/* barriers don't appear to be supported :-( */
419 		set_bit(BarriersNotsupp, &rdev->flags);
420 		mddev->barriers_work = 0;
421 		spin_lock_irqsave(&mddev->write_lock, flags);
422 		bio2->bi_next = mddev->biolist;
423 		mddev->biolist = bio2;
424 		spin_unlock_irqrestore(&mddev->write_lock, flags);
425 		wake_up(&mddev->sb_wait);
426 		bio_put(bio);
427 		return 0;
428 	}
429 	bio_put(bio2);
430 	bio->bi_private = rdev;
431 	return super_written(bio, bytes_done, error);
432 }
433 
434 void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
435 		   sector_t sector, int size, struct page *page)
436 {
437 	/* write first size bytes of page to sector of rdev
438 	 * Increment mddev->pending_writes before returning
439 	 * and decrement it on completion, waking up sb_wait
440 	 * if zero is reached.
441 	 * If an error occurred, call md_error
442 	 *
443 	 * As we might need to resubmit the request if BIO_RW_BARRIER
444 	 * causes ENOTSUPP, we allocate a spare bio...
445 	 */
446 	struct bio *bio = bio_alloc(GFP_NOIO, 1);
447 	int rw = (1<<BIO_RW) | (1<<BIO_RW_SYNC);
448 
449 	bio->bi_bdev = rdev->bdev;
450 	bio->bi_sector = sector;
451 	bio_add_page(bio, page, size, 0);
452 	bio->bi_private = rdev;
453 	bio->bi_end_io = super_written;
454 	bio->bi_rw = rw;
455 
456 	atomic_inc(&mddev->pending_writes);
457 	if (!test_bit(BarriersNotsupp, &rdev->flags)) {
458 		struct bio *rbio;
459 		rw |= (1<<BIO_RW_BARRIER);
460 		rbio = bio_clone(bio, GFP_NOIO);
461 		rbio->bi_private = bio;
462 		rbio->bi_end_io = super_written_barrier;
463 		submit_bio(rw, rbio);
464 	} else
465 		submit_bio(rw, bio);
466 }
467 
468 void md_super_wait(mddev_t *mddev)
469 {
470 	/* wait for all superblock writes that were scheduled to complete.
471 	 * if any had to be retried (due to BARRIER problems), retry them
472 	 */
473 	DEFINE_WAIT(wq);
474 	for(;;) {
475 		prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
476 		if (atomic_read(&mddev->pending_writes)==0)
477 			break;
478 		while (mddev->biolist) {
479 			struct bio *bio;
480 			spin_lock_irq(&mddev->write_lock);
481 			bio = mddev->biolist;
482 			mddev->biolist = bio->bi_next ;
483 			bio->bi_next = NULL;
484 			spin_unlock_irq(&mddev->write_lock);
485 			submit_bio(bio->bi_rw, bio);
486 		}
487 		schedule();
488 	}
489 	finish_wait(&mddev->sb_wait, &wq);
490 }
491 
492 static int bi_complete(struct bio *bio, unsigned int bytes_done, int error)
493 {
494 	if (bio->bi_size)
495 		return 1;
496 
497 	complete((struct completion*)bio->bi_private);
498 	return 0;
499 }
500 
501 int sync_page_io(struct block_device *bdev, sector_t sector, int size,
502 		   struct page *page, int rw)
503 {
504 	struct bio *bio = bio_alloc(GFP_NOIO, 1);
505 	struct completion event;
506 	int ret;
507 
508 	rw |= (1 << BIO_RW_SYNC);
509 
510 	bio->bi_bdev = bdev;
511 	bio->bi_sector = sector;
512 	bio_add_page(bio, page, size, 0);
513 	init_completion(&event);
514 	bio->bi_private = &event;
515 	bio->bi_end_io = bi_complete;
516 	submit_bio(rw, bio);
517 	wait_for_completion(&event);
518 
519 	ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
520 	bio_put(bio);
521 	return ret;
522 }
523 EXPORT_SYMBOL_GPL(sync_page_io);
524 
525 static int read_disk_sb(mdk_rdev_t * rdev, int size)
526 {
527 	char b[BDEVNAME_SIZE];
528 	if (!rdev->sb_page) {
529 		MD_BUG();
530 		return -EINVAL;
531 	}
532 	if (rdev->sb_loaded)
533 		return 0;
534 
535 
536 	if (!sync_page_io(rdev->bdev, rdev->sb_offset<<1, size, rdev->sb_page, READ))
537 		goto fail;
538 	rdev->sb_loaded = 1;
539 	return 0;
540 
541 fail:
542 	printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
543 		bdevname(rdev->bdev,b));
544 	return -EINVAL;
545 }
546 
547 static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
548 {
549 	if (	(sb1->set_uuid0 == sb2->set_uuid0) &&
550 		(sb1->set_uuid1 == sb2->set_uuid1) &&
551 		(sb1->set_uuid2 == sb2->set_uuid2) &&
552 		(sb1->set_uuid3 == sb2->set_uuid3))
553 
554 		return 1;
555 
556 	return 0;
557 }
558 
559 
560 static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
561 {
562 	int ret;
563 	mdp_super_t *tmp1, *tmp2;
564 
565 	tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
566 	tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
567 
568 	if (!tmp1 || !tmp2) {
569 		ret = 0;
570 		printk(KERN_INFO "md.c: sb1 is not equal to sb2!\n");
571 		goto abort;
572 	}
573 
574 	*tmp1 = *sb1;
575 	*tmp2 = *sb2;
576 
577 	/*
578 	 * nr_disks is not constant
579 	 */
580 	tmp1->nr_disks = 0;
581 	tmp2->nr_disks = 0;
582 
583 	if (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4))
584 		ret = 0;
585 	else
586 		ret = 1;
587 
588 abort:
589 	kfree(tmp1);
590 	kfree(tmp2);
591 	return ret;
592 }
593 
594 
595 static u32 md_csum_fold(u32 csum)
596 {
597 	csum = (csum & 0xffff) + (csum >> 16);
598 	return (csum & 0xffff) + (csum >> 16);
599 }
600 
601 static unsigned int calc_sb_csum(mdp_super_t * sb)
602 {
603 	u64 newcsum = 0;
604 	u32 *sb32 = (u32*)sb;
605 	int i;
606 	unsigned int disk_csum, csum;
607 
608 	disk_csum = sb->sb_csum;
609 	sb->sb_csum = 0;
610 
611 	for (i = 0; i < MD_SB_BYTES/4 ; i++)
612 		newcsum += sb32[i];
613 	csum = (newcsum & 0xffffffff) + (newcsum>>32);
614 
615 
616 #ifdef CONFIG_ALPHA
617 	/* This used to use csum_partial, which was wrong for several
618 	 * reasons including that different results are returned on
619 	 * different architectures.  It isn't critical that we get exactly
620 	 * the same return value as before (we always csum_fold before
621 	 * testing, and that removes any differences).  However as we
622 	 * know that csum_partial always returned a 16bit value on
623 	 * alphas, do a fold to maximise conformity to previous behaviour.
624 	 */
625 	sb->sb_csum = md_csum_fold(disk_csum);
626 #else
627 	sb->sb_csum = disk_csum;
628 #endif
629 	return csum;
630 }
631 
632 
633 /*
634  * Handle superblock details.
635  * We want to be able to handle multiple superblock formats
636  * so we have a common interface to them all, and an array of
637  * different handlers.
638  * We rely on user-space to write the initial superblock, and support
639  * reading and updating of superblocks.
640  * Interface methods are:
641  *   int load_super(mdk_rdev_t *dev, mdk_rdev_t *refdev, int minor_version)
642  *      loads and validates a superblock on dev.
643  *      if refdev != NULL, compare superblocks on both devices
644  *    Return:
645  *      0 - dev has a superblock that is compatible with refdev
646  *      1 - dev has a superblock that is compatible and newer than refdev
647  *          so dev should be used as the refdev in future
648  *     -EINVAL superblock incompatible or invalid
649  *     -othererror e.g. -EIO
650  *
651  *   int validate_super(mddev_t *mddev, mdk_rdev_t *dev)
652  *      Verify that dev is acceptable into mddev.
653  *       The first time, mddev->raid_disks will be 0, and data from
654  *       dev should be merged in.  Subsequent calls check that dev
655  *       is new enough.  Return 0 or -EINVAL
656  *
657  *   void sync_super(mddev_t *mddev, mdk_rdev_t *dev)
658  *     Update the superblock for rdev with data in mddev
659  *     This does not write to disc.
660  *
661  */
662 
663 struct super_type  {
664 	char 		*name;
665 	struct module	*owner;
666 	int		(*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version);
667 	int		(*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
668 	void		(*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
669 };
670 
671 /*
672  * load_super for 0.90.0
673  */
674 static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
675 {
676 	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
677 	mdp_super_t *sb;
678 	int ret;
679 	sector_t sb_offset;
680 
681 	/*
682 	 * Calculate the position of the superblock,
683 	 * it's at the end of the disk.
684 	 *
685 	 * It also happens to be a multiple of 4Kb.
686 	 */
687 	sb_offset = calc_dev_sboffset(rdev->bdev);
688 	rdev->sb_offset = sb_offset;
689 
690 	ret = read_disk_sb(rdev, MD_SB_BYTES);
691 	if (ret) return ret;
692 
693 	ret = -EINVAL;
694 
695 	bdevname(rdev->bdev, b);
696 	sb = (mdp_super_t*)page_address(rdev->sb_page);
697 
698 	if (sb->md_magic != MD_SB_MAGIC) {
699 		printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
700 		       b);
701 		goto abort;
702 	}
703 
704 	if (sb->major_version != 0 ||
705 	    sb->minor_version < 90 ||
706 	    sb->minor_version > 91) {
707 		printk(KERN_WARNING "Bad version number %d.%d on %s\n",
708 			sb->major_version, sb->minor_version,
709 			b);
710 		goto abort;
711 	}
712 
713 	if (sb->raid_disks <= 0)
714 		goto abort;
715 
716 	if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
717 		printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
718 			b);
719 		goto abort;
720 	}
721 
722 	rdev->preferred_minor = sb->md_minor;
723 	rdev->data_offset = 0;
724 	rdev->sb_size = MD_SB_BYTES;
725 
726 	if (sb->state & (1<<MD_SB_BITMAP_PRESENT)) {
727 		if (sb->level != 1 && sb->level != 4
728 		    && sb->level != 5 && sb->level != 6
729 		    && sb->level != 10) {
730 			/* FIXME use a better test */
731 			printk(KERN_WARNING
732 			       "md: bitmaps not supported for this level.\n");
733 			goto abort;
734 		}
735 	}
736 
737 	if (sb->level == LEVEL_MULTIPATH)
738 		rdev->desc_nr = -1;
739 	else
740 		rdev->desc_nr = sb->this_disk.number;
741 
742 	if (refdev == 0)
743 		ret = 1;
744 	else {
745 		__u64 ev1, ev2;
746 		mdp_super_t *refsb = (mdp_super_t*)page_address(refdev->sb_page);
747 		if (!uuid_equal(refsb, sb)) {
748 			printk(KERN_WARNING "md: %s has different UUID to %s\n",
749 				b, bdevname(refdev->bdev,b2));
750 			goto abort;
751 		}
752 		if (!sb_equal(refsb, sb)) {
753 			printk(KERN_WARNING "md: %s has same UUID"
754 			       " but different superblock to %s\n",
755 			       b, bdevname(refdev->bdev, b2));
756 			goto abort;
757 		}
758 		ev1 = md_event(sb);
759 		ev2 = md_event(refsb);
760 		if (ev1 > ev2)
761 			ret = 1;
762 		else
763 			ret = 0;
764 	}
765 	rdev->size = calc_dev_size(rdev, sb->chunk_size);
766 
767 	if (rdev->size < sb->size && sb->level > 1)
768 		/* "this cannot possibly happen" ... */
769 		ret = -EINVAL;
770 
771  abort:
772 	return ret;
773 }
774 
775 /*
776  * validate_super for 0.90.0
777  */
778 static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
779 {
780 	mdp_disk_t *desc;
781 	mdp_super_t *sb = (mdp_super_t *)page_address(rdev->sb_page);
782 	__u64 ev1 = md_event(sb);
783 
784 	rdev->raid_disk = -1;
785 	rdev->flags = 0;
786 	if (mddev->raid_disks == 0) {
787 		mddev->major_version = 0;
788 		mddev->minor_version = sb->minor_version;
789 		mddev->patch_version = sb->patch_version;
790 		mddev->persistent = ! sb->not_persistent;
791 		mddev->chunk_size = sb->chunk_size;
792 		mddev->ctime = sb->ctime;
793 		mddev->utime = sb->utime;
794 		mddev->level = sb->level;
795 		mddev->clevel[0] = 0;
796 		mddev->layout = sb->layout;
797 		mddev->raid_disks = sb->raid_disks;
798 		mddev->size = sb->size;
799 		mddev->events = ev1;
800 		mddev->bitmap_offset = 0;
801 		mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
802 
803 		if (mddev->minor_version >= 91) {
804 			mddev->reshape_position = sb->reshape_position;
805 			mddev->delta_disks = sb->delta_disks;
806 			mddev->new_level = sb->new_level;
807 			mddev->new_layout = sb->new_layout;
808 			mddev->new_chunk = sb->new_chunk;
809 		} else {
810 			mddev->reshape_position = MaxSector;
811 			mddev->delta_disks = 0;
812 			mddev->new_level = mddev->level;
813 			mddev->new_layout = mddev->layout;
814 			mddev->new_chunk = mddev->chunk_size;
815 		}
816 
817 		if (sb->state & (1<<MD_SB_CLEAN))
818 			mddev->recovery_cp = MaxSector;
819 		else {
820 			if (sb->events_hi == sb->cp_events_hi &&
821 				sb->events_lo == sb->cp_events_lo) {
822 				mddev->recovery_cp = sb->recovery_cp;
823 			} else
824 				mddev->recovery_cp = 0;
825 		}
826 
827 		memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
828 		memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
829 		memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
830 		memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
831 
832 		mddev->max_disks = MD_SB_DISKS;
833 
834 		if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
835 		    mddev->bitmap_file == NULL)
836 			mddev->bitmap_offset = mddev->default_bitmap_offset;
837 
838 	} else if (mddev->pers == NULL) {
839 		/* Insist on good event counter while assembling */
840 		++ev1;
841 		if (ev1 < mddev->events)
842 			return -EINVAL;
843 	} else if (mddev->bitmap) {
844 		/* if adding to array with a bitmap, then we can accept an
845 		 * older device ... but not too old.
846 		 */
847 		if (ev1 < mddev->bitmap->events_cleared)
848 			return 0;
849 	} else {
850 		if (ev1 < mddev->events)
851 			/* just a hot-add of a new device, leave raid_disk at -1 */
852 			return 0;
853 	}
854 
855 	if (mddev->level != LEVEL_MULTIPATH) {
856 		desc = sb->disks + rdev->desc_nr;
857 
858 		if (desc->state & (1<<MD_DISK_FAULTY))
859 			set_bit(Faulty, &rdev->flags);
860 		else if (desc->state & (1<<MD_DISK_SYNC) /* &&
861 			    desc->raid_disk < mddev->raid_disks */) {
862 			set_bit(In_sync, &rdev->flags);
863 			rdev->raid_disk = desc->raid_disk;
864 		}
865 		if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
866 			set_bit(WriteMostly, &rdev->flags);
867 	} else /* MULTIPATH are always insync */
868 		set_bit(In_sync, &rdev->flags);
869 	return 0;
870 }
871 
872 /*
873  * sync_super for 0.90.0
874  */
875 static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
876 {
877 	mdp_super_t *sb;
878 	struct list_head *tmp;
879 	mdk_rdev_t *rdev2;
880 	int next_spare = mddev->raid_disks;
881 
882 
883 	/* make rdev->sb match mddev data..
884 	 *
885 	 * 1/ zero out disks
886 	 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
887 	 * 3/ any empty disks < next_spare become removed
888 	 *
889 	 * disks[0] gets initialised to REMOVED because
890 	 * we cannot be sure from other fields if it has
891 	 * been initialised or not.
892 	 */
893 	int i;
894 	int active=0, working=0,failed=0,spare=0,nr_disks=0;
895 
896 	rdev->sb_size = MD_SB_BYTES;
897 
898 	sb = (mdp_super_t*)page_address(rdev->sb_page);
899 
900 	memset(sb, 0, sizeof(*sb));
901 
902 	sb->md_magic = MD_SB_MAGIC;
903 	sb->major_version = mddev->major_version;
904 	sb->patch_version = mddev->patch_version;
905 	sb->gvalid_words  = 0; /* ignored */
906 	memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
907 	memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
908 	memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
909 	memcpy(&sb->set_uuid3, mddev->uuid+12,4);
910 
911 	sb->ctime = mddev->ctime;
912 	sb->level = mddev->level;
913 	sb->size  = mddev->size;
914 	sb->raid_disks = mddev->raid_disks;
915 	sb->md_minor = mddev->md_minor;
916 	sb->not_persistent = !mddev->persistent;
917 	sb->utime = mddev->utime;
918 	sb->state = 0;
919 	sb->events_hi = (mddev->events>>32);
920 	sb->events_lo = (u32)mddev->events;
921 
922 	if (mddev->reshape_position == MaxSector)
923 		sb->minor_version = 90;
924 	else {
925 		sb->minor_version = 91;
926 		sb->reshape_position = mddev->reshape_position;
927 		sb->new_level = mddev->new_level;
928 		sb->delta_disks = mddev->delta_disks;
929 		sb->new_layout = mddev->new_layout;
930 		sb->new_chunk = mddev->new_chunk;
931 	}
932 	mddev->minor_version = sb->minor_version;
933 	if (mddev->in_sync)
934 	{
935 		sb->recovery_cp = mddev->recovery_cp;
936 		sb->cp_events_hi = (mddev->events>>32);
937 		sb->cp_events_lo = (u32)mddev->events;
938 		if (mddev->recovery_cp == MaxSector)
939 			sb->state = (1<< MD_SB_CLEAN);
940 	} else
941 		sb->recovery_cp = 0;
942 
943 	sb->layout = mddev->layout;
944 	sb->chunk_size = mddev->chunk_size;
945 
946 	if (mddev->bitmap && mddev->bitmap_file == NULL)
947 		sb->state |= (1<<MD_SB_BITMAP_PRESENT);
948 
949 	sb->disks[0].state = (1<<MD_DISK_REMOVED);
950 	ITERATE_RDEV(mddev,rdev2,tmp) {
951 		mdp_disk_t *d;
952 		int desc_nr;
953 		if (rdev2->raid_disk >= 0 && test_bit(In_sync, &rdev2->flags)
954 		    && !test_bit(Faulty, &rdev2->flags))
955 			desc_nr = rdev2->raid_disk;
956 		else
957 			desc_nr = next_spare++;
958 		rdev2->desc_nr = desc_nr;
959 		d = &sb->disks[rdev2->desc_nr];
960 		nr_disks++;
961 		d->number = rdev2->desc_nr;
962 		d->major = MAJOR(rdev2->bdev->bd_dev);
963 		d->minor = MINOR(rdev2->bdev->bd_dev);
964 		if (rdev2->raid_disk >= 0 && test_bit(In_sync, &rdev2->flags)
965 		    && !test_bit(Faulty, &rdev2->flags))
966 			d->raid_disk = rdev2->raid_disk;
967 		else
968 			d->raid_disk = rdev2->desc_nr; /* compatibility */
969 		if (test_bit(Faulty, &rdev2->flags))
970 			d->state = (1<<MD_DISK_FAULTY);
971 		else if (test_bit(In_sync, &rdev2->flags)) {
972 			d->state = (1<<MD_DISK_ACTIVE);
973 			d->state |= (1<<MD_DISK_SYNC);
974 			active++;
975 			working++;
976 		} else {
977 			d->state = 0;
978 			spare++;
979 			working++;
980 		}
981 		if (test_bit(WriteMostly, &rdev2->flags))
982 			d->state |= (1<<MD_DISK_WRITEMOSTLY);
983 	}
984 	/* now set the "removed" and "faulty" bits on any missing devices */
985 	for (i=0 ; i < mddev->raid_disks ; i++) {
986 		mdp_disk_t *d = &sb->disks[i];
987 		if (d->state == 0 && d->number == 0) {
988 			d->number = i;
989 			d->raid_disk = i;
990 			d->state = (1<<MD_DISK_REMOVED);
991 			d->state |= (1<<MD_DISK_FAULTY);
992 			failed++;
993 		}
994 	}
995 	sb->nr_disks = nr_disks;
996 	sb->active_disks = active;
997 	sb->working_disks = working;
998 	sb->failed_disks = failed;
999 	sb->spare_disks = spare;
1000 
1001 	sb->this_disk = sb->disks[rdev->desc_nr];
1002 	sb->sb_csum = calc_sb_csum(sb);
1003 }
1004 
1005 /*
1006  * version 1 superblock
1007  */
1008 
1009 static __le32 calc_sb_1_csum(struct mdp_superblock_1 * sb)
1010 {
1011 	__le32 disk_csum;
1012 	u32 csum;
1013 	unsigned long long newcsum;
1014 	int size = 256 + le32_to_cpu(sb->max_dev)*2;
1015 	__le32 *isuper = (__le32*)sb;
1016 	int i;
1017 
1018 	disk_csum = sb->sb_csum;
1019 	sb->sb_csum = 0;
1020 	newcsum = 0;
1021 	for (i=0; size>=4; size -= 4 )
1022 		newcsum += le32_to_cpu(*isuper++);
1023 
1024 	if (size == 2)
1025 		newcsum += le16_to_cpu(*(__le16*) isuper);
1026 
1027 	csum = (newcsum & 0xffffffff) + (newcsum >> 32);
1028 	sb->sb_csum = disk_csum;
1029 	return cpu_to_le32(csum);
1030 }
1031 
1032 static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
1033 {
1034 	struct mdp_superblock_1 *sb;
1035 	int ret;
1036 	sector_t sb_offset;
1037 	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1038 	int bmask;
1039 
1040 	/*
1041 	 * Calculate the position of the superblock.
1042 	 * It is always aligned to a 4K boundary and
1043 	 * depeding on minor_version, it can be:
1044 	 * 0: At least 8K, but less than 12K, from end of device
1045 	 * 1: At start of device
1046 	 * 2: 4K from start of device.
1047 	 */
1048 	switch(minor_version) {
1049 	case 0:
1050 		sb_offset = rdev->bdev->bd_inode->i_size >> 9;
1051 		sb_offset -= 8*2;
1052 		sb_offset &= ~(sector_t)(4*2-1);
1053 		/* convert from sectors to K */
1054 		sb_offset /= 2;
1055 		break;
1056 	case 1:
1057 		sb_offset = 0;
1058 		break;
1059 	case 2:
1060 		sb_offset = 4;
1061 		break;
1062 	default:
1063 		return -EINVAL;
1064 	}
1065 	rdev->sb_offset = sb_offset;
1066 
1067 	/* superblock is rarely larger than 1K, but it can be larger,
1068 	 * and it is safe to read 4k, so we do that
1069 	 */
1070 	ret = read_disk_sb(rdev, 4096);
1071 	if (ret) return ret;
1072 
1073 
1074 	sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
1075 
1076 	if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
1077 	    sb->major_version != cpu_to_le32(1) ||
1078 	    le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
1079 	    le64_to_cpu(sb->super_offset) != (rdev->sb_offset<<1) ||
1080 	    (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
1081 		return -EINVAL;
1082 
1083 	if (calc_sb_1_csum(sb) != sb->sb_csum) {
1084 		printk("md: invalid superblock checksum on %s\n",
1085 			bdevname(rdev->bdev,b));
1086 		return -EINVAL;
1087 	}
1088 	if (le64_to_cpu(sb->data_size) < 10) {
1089 		printk("md: data_size too small on %s\n",
1090 		       bdevname(rdev->bdev,b));
1091 		return -EINVAL;
1092 	}
1093 	if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET)) {
1094 		if (sb->level != cpu_to_le32(1) &&
1095 		    sb->level != cpu_to_le32(4) &&
1096 		    sb->level != cpu_to_le32(5) &&
1097 		    sb->level != cpu_to_le32(6) &&
1098 		    sb->level != cpu_to_le32(10)) {
1099 			printk(KERN_WARNING
1100 			       "md: bitmaps not supported for this level.\n");
1101 			return -EINVAL;
1102 		}
1103 	}
1104 
1105 	rdev->preferred_minor = 0xffff;
1106 	rdev->data_offset = le64_to_cpu(sb->data_offset);
1107 	atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
1108 
1109 	rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
1110 	bmask = queue_hardsect_size(rdev->bdev->bd_disk->queue)-1;
1111 	if (rdev->sb_size & bmask)
1112 		rdev-> sb_size = (rdev->sb_size | bmask)+1;
1113 
1114 	if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
1115 		rdev->desc_nr = -1;
1116 	else
1117 		rdev->desc_nr = le32_to_cpu(sb->dev_number);
1118 
1119 	if (refdev == 0)
1120 		ret = 1;
1121 	else {
1122 		__u64 ev1, ev2;
1123 		struct mdp_superblock_1 *refsb =
1124 			(struct mdp_superblock_1*)page_address(refdev->sb_page);
1125 
1126 		if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1127 		    sb->level != refsb->level ||
1128 		    sb->layout != refsb->layout ||
1129 		    sb->chunksize != refsb->chunksize) {
1130 			printk(KERN_WARNING "md: %s has strangely different"
1131 				" superblock to %s\n",
1132 				bdevname(rdev->bdev,b),
1133 				bdevname(refdev->bdev,b2));
1134 			return -EINVAL;
1135 		}
1136 		ev1 = le64_to_cpu(sb->events);
1137 		ev2 = le64_to_cpu(refsb->events);
1138 
1139 		if (ev1 > ev2)
1140 			ret = 1;
1141 		else
1142 			ret = 0;
1143 	}
1144 	if (minor_version)
1145 		rdev->size = ((rdev->bdev->bd_inode->i_size>>9) - le64_to_cpu(sb->data_offset)) / 2;
1146 	else
1147 		rdev->size = rdev->sb_offset;
1148 	if (rdev->size < le64_to_cpu(sb->data_size)/2)
1149 		return -EINVAL;
1150 	rdev->size = le64_to_cpu(sb->data_size)/2;
1151 	if (le32_to_cpu(sb->chunksize))
1152 		rdev->size &= ~((sector_t)le32_to_cpu(sb->chunksize)/2 - 1);
1153 
1154 	if (le64_to_cpu(sb->size) > rdev->size*2)
1155 		return -EINVAL;
1156 	return ret;
1157 }
1158 
1159 static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
1160 {
1161 	struct mdp_superblock_1 *sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
1162 	__u64 ev1 = le64_to_cpu(sb->events);
1163 
1164 	rdev->raid_disk = -1;
1165 	rdev->flags = 0;
1166 	if (mddev->raid_disks == 0) {
1167 		mddev->major_version = 1;
1168 		mddev->patch_version = 0;
1169 		mddev->persistent = 1;
1170 		mddev->chunk_size = le32_to_cpu(sb->chunksize) << 9;
1171 		mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
1172 		mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
1173 		mddev->level = le32_to_cpu(sb->level);
1174 		mddev->clevel[0] = 0;
1175 		mddev->layout = le32_to_cpu(sb->layout);
1176 		mddev->raid_disks = le32_to_cpu(sb->raid_disks);
1177 		mddev->size = le64_to_cpu(sb->size)/2;
1178 		mddev->events = ev1;
1179 		mddev->bitmap_offset = 0;
1180 		mddev->default_bitmap_offset = 1024 >> 9;
1181 
1182 		mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1183 		memcpy(mddev->uuid, sb->set_uuid, 16);
1184 
1185 		mddev->max_disks =  (4096-256)/2;
1186 
1187 		if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1188 		    mddev->bitmap_file == NULL )
1189 			mddev->bitmap_offset = (__s32)le32_to_cpu(sb->bitmap_offset);
1190 
1191 		if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
1192 			mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1193 			mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1194 			mddev->new_level = le32_to_cpu(sb->new_level);
1195 			mddev->new_layout = le32_to_cpu(sb->new_layout);
1196 			mddev->new_chunk = le32_to_cpu(sb->new_chunk)<<9;
1197 		} else {
1198 			mddev->reshape_position = MaxSector;
1199 			mddev->delta_disks = 0;
1200 			mddev->new_level = mddev->level;
1201 			mddev->new_layout = mddev->layout;
1202 			mddev->new_chunk = mddev->chunk_size;
1203 		}
1204 
1205 	} else if (mddev->pers == NULL) {
1206 		/* Insist of good event counter while assembling */
1207 		++ev1;
1208 		if (ev1 < mddev->events)
1209 			return -EINVAL;
1210 	} else if (mddev->bitmap) {
1211 		/* If adding to array with a bitmap, then we can accept an
1212 		 * older device, but not too old.
1213 		 */
1214 		if (ev1 < mddev->bitmap->events_cleared)
1215 			return 0;
1216 	} else {
1217 		if (ev1 < mddev->events)
1218 			/* just a hot-add of a new device, leave raid_disk at -1 */
1219 			return 0;
1220 	}
1221 	if (mddev->level != LEVEL_MULTIPATH) {
1222 		int role;
1223 		role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
1224 		switch(role) {
1225 		case 0xffff: /* spare */
1226 			break;
1227 		case 0xfffe: /* faulty */
1228 			set_bit(Faulty, &rdev->flags);
1229 			break;
1230 		default:
1231 			if ((le32_to_cpu(sb->feature_map) &
1232 			     MD_FEATURE_RECOVERY_OFFSET))
1233 				rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
1234 			else
1235 				set_bit(In_sync, &rdev->flags);
1236 			rdev->raid_disk = role;
1237 			break;
1238 		}
1239 		if (sb->devflags & WriteMostly1)
1240 			set_bit(WriteMostly, &rdev->flags);
1241 	} else /* MULTIPATH are always insync */
1242 		set_bit(In_sync, &rdev->flags);
1243 
1244 	return 0;
1245 }
1246 
1247 static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
1248 {
1249 	struct mdp_superblock_1 *sb;
1250 	struct list_head *tmp;
1251 	mdk_rdev_t *rdev2;
1252 	int max_dev, i;
1253 	/* make rdev->sb match mddev and rdev data. */
1254 
1255 	sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
1256 
1257 	sb->feature_map = 0;
1258 	sb->pad0 = 0;
1259 	sb->recovery_offset = cpu_to_le64(0);
1260 	memset(sb->pad1, 0, sizeof(sb->pad1));
1261 	memset(sb->pad2, 0, sizeof(sb->pad2));
1262 	memset(sb->pad3, 0, sizeof(sb->pad3));
1263 
1264 	sb->utime = cpu_to_le64((__u64)mddev->utime);
1265 	sb->events = cpu_to_le64(mddev->events);
1266 	if (mddev->in_sync)
1267 		sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
1268 	else
1269 		sb->resync_offset = cpu_to_le64(0);
1270 
1271 	sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
1272 
1273 	sb->raid_disks = cpu_to_le32(mddev->raid_disks);
1274 	sb->size = cpu_to_le64(mddev->size<<1);
1275 
1276 	if (mddev->bitmap && mddev->bitmap_file == NULL) {
1277 		sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_offset);
1278 		sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1279 	}
1280 
1281 	if (rdev->raid_disk >= 0 &&
1282 	    !test_bit(In_sync, &rdev->flags) &&
1283 	    rdev->recovery_offset > 0) {
1284 		sb->feature_map |= cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
1285 		sb->recovery_offset = cpu_to_le64(rdev->recovery_offset);
1286 	}
1287 
1288 	if (mddev->reshape_position != MaxSector) {
1289 		sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
1290 		sb->reshape_position = cpu_to_le64(mddev->reshape_position);
1291 		sb->new_layout = cpu_to_le32(mddev->new_layout);
1292 		sb->delta_disks = cpu_to_le32(mddev->delta_disks);
1293 		sb->new_level = cpu_to_le32(mddev->new_level);
1294 		sb->new_chunk = cpu_to_le32(mddev->new_chunk>>9);
1295 	}
1296 
1297 	max_dev = 0;
1298 	ITERATE_RDEV(mddev,rdev2,tmp)
1299 		if (rdev2->desc_nr+1 > max_dev)
1300 			max_dev = rdev2->desc_nr+1;
1301 
1302 	sb->max_dev = cpu_to_le32(max_dev);
1303 	for (i=0; i<max_dev;i++)
1304 		sb->dev_roles[i] = cpu_to_le16(0xfffe);
1305 
1306 	ITERATE_RDEV(mddev,rdev2,tmp) {
1307 		i = rdev2->desc_nr;
1308 		if (test_bit(Faulty, &rdev2->flags))
1309 			sb->dev_roles[i] = cpu_to_le16(0xfffe);
1310 		else if (test_bit(In_sync, &rdev2->flags))
1311 			sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1312 		else if (rdev2->raid_disk >= 0 && rdev2->recovery_offset > 0)
1313 			sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1314 		else
1315 			sb->dev_roles[i] = cpu_to_le16(0xffff);
1316 	}
1317 
1318 	sb->sb_csum = calc_sb_1_csum(sb);
1319 }
1320 
1321 
1322 static struct super_type super_types[] = {
1323 	[0] = {
1324 		.name	= "0.90.0",
1325 		.owner	= THIS_MODULE,
1326 		.load_super	= super_90_load,
1327 		.validate_super	= super_90_validate,
1328 		.sync_super	= super_90_sync,
1329 	},
1330 	[1] = {
1331 		.name	= "md-1",
1332 		.owner	= THIS_MODULE,
1333 		.load_super	= super_1_load,
1334 		.validate_super	= super_1_validate,
1335 		.sync_super	= super_1_sync,
1336 	},
1337 };
1338 
1339 static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
1340 {
1341 	struct list_head *tmp, *tmp2;
1342 	mdk_rdev_t *rdev, *rdev2;
1343 
1344 	ITERATE_RDEV(mddev1,rdev,tmp)
1345 		ITERATE_RDEV(mddev2, rdev2, tmp2)
1346 			if (rdev->bdev->bd_contains ==
1347 			    rdev2->bdev->bd_contains)
1348 				return 1;
1349 
1350 	return 0;
1351 }
1352 
1353 static LIST_HEAD(pending_raid_disks);
1354 
1355 static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
1356 {
1357 	char b[BDEVNAME_SIZE];
1358 	struct kobject *ko;
1359 	char *s;
1360 	int err;
1361 
1362 	if (rdev->mddev) {
1363 		MD_BUG();
1364 		return -EINVAL;
1365 	}
1366 	/* make sure rdev->size exceeds mddev->size */
1367 	if (rdev->size && (mddev->size == 0 || rdev->size < mddev->size)) {
1368 		if (mddev->pers)
1369 			/* Cannot change size, so fail */
1370 			return -ENOSPC;
1371 		else
1372 			mddev->size = rdev->size;
1373 	}
1374 
1375 	/* Verify rdev->desc_nr is unique.
1376 	 * If it is -1, assign a free number, else
1377 	 * check number is not in use
1378 	 */
1379 	if (rdev->desc_nr < 0) {
1380 		int choice = 0;
1381 		if (mddev->pers) choice = mddev->raid_disks;
1382 		while (find_rdev_nr(mddev, choice))
1383 			choice++;
1384 		rdev->desc_nr = choice;
1385 	} else {
1386 		if (find_rdev_nr(mddev, rdev->desc_nr))
1387 			return -EBUSY;
1388 	}
1389 	bdevname(rdev->bdev,b);
1390 	if (kobject_set_name(&rdev->kobj, "dev-%s", b) < 0)
1391 		return -ENOMEM;
1392 	while ( (s=strchr(rdev->kobj.k_name, '/')) != NULL)
1393 		*s = '!';
1394 
1395 	rdev->mddev = mddev;
1396 	printk(KERN_INFO "md: bind<%s>\n", b);
1397 
1398 	rdev->kobj.parent = &mddev->kobj;
1399 	if ((err = kobject_add(&rdev->kobj)))
1400 		goto fail;
1401 
1402 	if (rdev->bdev->bd_part)
1403 		ko = &rdev->bdev->bd_part->kobj;
1404 	else
1405 		ko = &rdev->bdev->bd_disk->kobj;
1406 	if ((err = sysfs_create_link(&rdev->kobj, ko, "block"))) {
1407 		kobject_del(&rdev->kobj);
1408 		goto fail;
1409 	}
1410 	list_add(&rdev->same_set, &mddev->disks);
1411 	bd_claim_by_disk(rdev->bdev, rdev, mddev->gendisk);
1412 	return 0;
1413 
1414  fail:
1415 	printk(KERN_WARNING "md: failed to register dev-%s for %s\n",
1416 	       b, mdname(mddev));
1417 	return err;
1418 }
1419 
1420 static void delayed_delete(struct work_struct *ws)
1421 {
1422 	mdk_rdev_t *rdev = container_of(ws, mdk_rdev_t, del_work);
1423 	kobject_del(&rdev->kobj);
1424 }
1425 
1426 static void unbind_rdev_from_array(mdk_rdev_t * rdev)
1427 {
1428 	char b[BDEVNAME_SIZE];
1429 	if (!rdev->mddev) {
1430 		MD_BUG();
1431 		return;
1432 	}
1433 	bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
1434 	list_del_init(&rdev->same_set);
1435 	printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
1436 	rdev->mddev = NULL;
1437 	sysfs_remove_link(&rdev->kobj, "block");
1438 
1439 	/* We need to delay this, otherwise we can deadlock when
1440 	 * writing to 'remove' to "dev/state"
1441 	 */
1442 	INIT_WORK(&rdev->del_work, delayed_delete);
1443 	schedule_work(&rdev->del_work);
1444 }
1445 
1446 /*
1447  * prevent the device from being mounted, repartitioned or
1448  * otherwise reused by a RAID array (or any other kernel
1449  * subsystem), by bd_claiming the device.
1450  */
1451 static int lock_rdev(mdk_rdev_t *rdev, dev_t dev)
1452 {
1453 	int err = 0;
1454 	struct block_device *bdev;
1455 	char b[BDEVNAME_SIZE];
1456 
1457 	bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
1458 	if (IS_ERR(bdev)) {
1459 		printk(KERN_ERR "md: could not open %s.\n",
1460 			__bdevname(dev, b));
1461 		return PTR_ERR(bdev);
1462 	}
1463 	err = bd_claim(bdev, rdev);
1464 	if (err) {
1465 		printk(KERN_ERR "md: could not bd_claim %s.\n",
1466 			bdevname(bdev, b));
1467 		blkdev_put(bdev);
1468 		return err;
1469 	}
1470 	rdev->bdev = bdev;
1471 	return err;
1472 }
1473 
1474 static void unlock_rdev(mdk_rdev_t *rdev)
1475 {
1476 	struct block_device *bdev = rdev->bdev;
1477 	rdev->bdev = NULL;
1478 	if (!bdev)
1479 		MD_BUG();
1480 	bd_release(bdev);
1481 	blkdev_put(bdev);
1482 }
1483 
1484 void md_autodetect_dev(dev_t dev);
1485 
1486 static void export_rdev(mdk_rdev_t * rdev)
1487 {
1488 	char b[BDEVNAME_SIZE];
1489 	printk(KERN_INFO "md: export_rdev(%s)\n",
1490 		bdevname(rdev->bdev,b));
1491 	if (rdev->mddev)
1492 		MD_BUG();
1493 	free_disk_sb(rdev);
1494 	list_del_init(&rdev->same_set);
1495 #ifndef MODULE
1496 	md_autodetect_dev(rdev->bdev->bd_dev);
1497 #endif
1498 	unlock_rdev(rdev);
1499 	kobject_put(&rdev->kobj);
1500 }
1501 
1502 static void kick_rdev_from_array(mdk_rdev_t * rdev)
1503 {
1504 	unbind_rdev_from_array(rdev);
1505 	export_rdev(rdev);
1506 }
1507 
1508 static void export_array(mddev_t *mddev)
1509 {
1510 	struct list_head *tmp;
1511 	mdk_rdev_t *rdev;
1512 
1513 	ITERATE_RDEV(mddev,rdev,tmp) {
1514 		if (!rdev->mddev) {
1515 			MD_BUG();
1516 			continue;
1517 		}
1518 		kick_rdev_from_array(rdev);
1519 	}
1520 	if (!list_empty(&mddev->disks))
1521 		MD_BUG();
1522 	mddev->raid_disks = 0;
1523 	mddev->major_version = 0;
1524 }
1525 
1526 static void print_desc(mdp_disk_t *desc)
1527 {
1528 	printk(" DISK<N:%d,(%d,%d),R:%d,S:%d>\n", desc->number,
1529 		desc->major,desc->minor,desc->raid_disk,desc->state);
1530 }
1531 
1532 static void print_sb(mdp_super_t *sb)
1533 {
1534 	int i;
1535 
1536 	printk(KERN_INFO
1537 		"md:  SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n",
1538 		sb->major_version, sb->minor_version, sb->patch_version,
1539 		sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3,
1540 		sb->ctime);
1541 	printk(KERN_INFO "md:     L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n",
1542 		sb->level, sb->size, sb->nr_disks, sb->raid_disks,
1543 		sb->md_minor, sb->layout, sb->chunk_size);
1544 	printk(KERN_INFO "md:     UT:%08x ST:%d AD:%d WD:%d"
1545 		" FD:%d SD:%d CSUM:%08x E:%08lx\n",
1546 		sb->utime, sb->state, sb->active_disks, sb->working_disks,
1547 		sb->failed_disks, sb->spare_disks,
1548 		sb->sb_csum, (unsigned long)sb->events_lo);
1549 
1550 	printk(KERN_INFO);
1551 	for (i = 0; i < MD_SB_DISKS; i++) {
1552 		mdp_disk_t *desc;
1553 
1554 		desc = sb->disks + i;
1555 		if (desc->number || desc->major || desc->minor ||
1556 		    desc->raid_disk || (desc->state && (desc->state != 4))) {
1557 			printk("     D %2d: ", i);
1558 			print_desc(desc);
1559 		}
1560 	}
1561 	printk(KERN_INFO "md:     THIS: ");
1562 	print_desc(&sb->this_disk);
1563 
1564 }
1565 
1566 static void print_rdev(mdk_rdev_t *rdev)
1567 {
1568 	char b[BDEVNAME_SIZE];
1569 	printk(KERN_INFO "md: rdev %s, SZ:%08llu F:%d S:%d DN:%u\n",
1570 		bdevname(rdev->bdev,b), (unsigned long long)rdev->size,
1571 	        test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags),
1572 	        rdev->desc_nr);
1573 	if (rdev->sb_loaded) {
1574 		printk(KERN_INFO "md: rdev superblock:\n");
1575 		print_sb((mdp_super_t*)page_address(rdev->sb_page));
1576 	} else
1577 		printk(KERN_INFO "md: no rdev superblock!\n");
1578 }
1579 
1580 static void md_print_devices(void)
1581 {
1582 	struct list_head *tmp, *tmp2;
1583 	mdk_rdev_t *rdev;
1584 	mddev_t *mddev;
1585 	char b[BDEVNAME_SIZE];
1586 
1587 	printk("\n");
1588 	printk("md:	**********************************\n");
1589 	printk("md:	* <COMPLETE RAID STATE PRINTOUT> *\n");
1590 	printk("md:	**********************************\n");
1591 	ITERATE_MDDEV(mddev,tmp) {
1592 
1593 		if (mddev->bitmap)
1594 			bitmap_print_sb(mddev->bitmap);
1595 		else
1596 			printk("%s: ", mdname(mddev));
1597 		ITERATE_RDEV(mddev,rdev,tmp2)
1598 			printk("<%s>", bdevname(rdev->bdev,b));
1599 		printk("\n");
1600 
1601 		ITERATE_RDEV(mddev,rdev,tmp2)
1602 			print_rdev(rdev);
1603 	}
1604 	printk("md:	**********************************\n");
1605 	printk("\n");
1606 }
1607 
1608 
1609 static void sync_sbs(mddev_t * mddev, int nospares)
1610 {
1611 	/* Update each superblock (in-memory image), but
1612 	 * if we are allowed to, skip spares which already
1613 	 * have the right event counter, or have one earlier
1614 	 * (which would mean they aren't being marked as dirty
1615 	 * with the rest of the array)
1616 	 */
1617 	mdk_rdev_t *rdev;
1618 	struct list_head *tmp;
1619 
1620 	ITERATE_RDEV(mddev,rdev,tmp) {
1621 		if (rdev->sb_events == mddev->events ||
1622 		    (nospares &&
1623 		     rdev->raid_disk < 0 &&
1624 		     (rdev->sb_events&1)==0 &&
1625 		     rdev->sb_events+1 == mddev->events)) {
1626 			/* Don't update this superblock */
1627 			rdev->sb_loaded = 2;
1628 		} else {
1629 			super_types[mddev->major_version].
1630 				sync_super(mddev, rdev);
1631 			rdev->sb_loaded = 1;
1632 		}
1633 	}
1634 }
1635 
1636 static void md_update_sb(mddev_t * mddev, int force_change)
1637 {
1638 	int err;
1639 	struct list_head *tmp;
1640 	mdk_rdev_t *rdev;
1641 	int sync_req;
1642 	int nospares = 0;
1643 
1644 repeat:
1645 	spin_lock_irq(&mddev->write_lock);
1646 
1647 	set_bit(MD_CHANGE_PENDING, &mddev->flags);
1648 	if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
1649 		force_change = 1;
1650 	if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
1651 		/* just a clean<-> dirty transition, possibly leave spares alone,
1652 		 * though if events isn't the right even/odd, we will have to do
1653 		 * spares after all
1654 		 */
1655 		nospares = 1;
1656 	if (force_change)
1657 		nospares = 0;
1658 	if (mddev->degraded)
1659 		/* If the array is degraded, then skipping spares is both
1660 		 * dangerous and fairly pointless.
1661 		 * Dangerous because a device that was removed from the array
1662 		 * might have a event_count that still looks up-to-date,
1663 		 * so it can be re-added without a resync.
1664 		 * Pointless because if there are any spares to skip,
1665 		 * then a recovery will happen and soon that array won't
1666 		 * be degraded any more and the spare can go back to sleep then.
1667 		 */
1668 		nospares = 0;
1669 
1670 	sync_req = mddev->in_sync;
1671 	mddev->utime = get_seconds();
1672 
1673 	/* If this is just a dirty<->clean transition, and the array is clean
1674 	 * and 'events' is odd, we can roll back to the previous clean state */
1675 	if (nospares
1676 	    && (mddev->in_sync && mddev->recovery_cp == MaxSector)
1677 	    && (mddev->events & 1)
1678 	    && mddev->events != 1)
1679 		mddev->events--;
1680 	else {
1681 		/* otherwise we have to go forward and ... */
1682 		mddev->events ++;
1683 		if (!mddev->in_sync || mddev->recovery_cp != MaxSector) { /* not clean */
1684 			/* .. if the array isn't clean, insist on an odd 'events' */
1685 			if ((mddev->events&1)==0) {
1686 				mddev->events++;
1687 				nospares = 0;
1688 			}
1689 		} else {
1690 			/* otherwise insist on an even 'events' (for clean states) */
1691 			if ((mddev->events&1)) {
1692 				mddev->events++;
1693 				nospares = 0;
1694 			}
1695 		}
1696 	}
1697 
1698 	if (!mddev->events) {
1699 		/*
1700 		 * oops, this 64-bit counter should never wrap.
1701 		 * Either we are in around ~1 trillion A.C., assuming
1702 		 * 1 reboot per second, or we have a bug:
1703 		 */
1704 		MD_BUG();
1705 		mddev->events --;
1706 	}
1707 	sync_sbs(mddev, nospares);
1708 
1709 	/*
1710 	 * do not write anything to disk if using
1711 	 * nonpersistent superblocks
1712 	 */
1713 	if (!mddev->persistent) {
1714 		clear_bit(MD_CHANGE_PENDING, &mddev->flags);
1715 		spin_unlock_irq(&mddev->write_lock);
1716 		wake_up(&mddev->sb_wait);
1717 		return;
1718 	}
1719 	spin_unlock_irq(&mddev->write_lock);
1720 
1721 	dprintk(KERN_INFO
1722 		"md: updating %s RAID superblock on device (in sync %d)\n",
1723 		mdname(mddev),mddev->in_sync);
1724 
1725 	err = bitmap_update_sb(mddev->bitmap);
1726 	ITERATE_RDEV(mddev,rdev,tmp) {
1727 		char b[BDEVNAME_SIZE];
1728 		dprintk(KERN_INFO "md: ");
1729 		if (rdev->sb_loaded != 1)
1730 			continue; /* no noise on spare devices */
1731 		if (test_bit(Faulty, &rdev->flags))
1732 			dprintk("(skipping faulty ");
1733 
1734 		dprintk("%s ", bdevname(rdev->bdev,b));
1735 		if (!test_bit(Faulty, &rdev->flags)) {
1736 			md_super_write(mddev,rdev,
1737 				       rdev->sb_offset<<1, rdev->sb_size,
1738 				       rdev->sb_page);
1739 			dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
1740 				bdevname(rdev->bdev,b),
1741 				(unsigned long long)rdev->sb_offset);
1742 			rdev->sb_events = mddev->events;
1743 
1744 		} else
1745 			dprintk(")\n");
1746 		if (mddev->level == LEVEL_MULTIPATH)
1747 			/* only need to write one superblock... */
1748 			break;
1749 	}
1750 	md_super_wait(mddev);
1751 	/* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
1752 
1753 	spin_lock_irq(&mddev->write_lock);
1754 	if (mddev->in_sync != sync_req ||
1755 	    test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
1756 		/* have to write it out again */
1757 		spin_unlock_irq(&mddev->write_lock);
1758 		goto repeat;
1759 	}
1760 	clear_bit(MD_CHANGE_PENDING, &mddev->flags);
1761 	spin_unlock_irq(&mddev->write_lock);
1762 	wake_up(&mddev->sb_wait);
1763 
1764 }
1765 
1766 /* words written to sysfs files may, or my not, be \n terminated.
1767  * We want to accept with case. For this we use cmd_match.
1768  */
1769 static int cmd_match(const char *cmd, const char *str)
1770 {
1771 	/* See if cmd, written into a sysfs file, matches
1772 	 * str.  They must either be the same, or cmd can
1773 	 * have a trailing newline
1774 	 */
1775 	while (*cmd && *str && *cmd == *str) {
1776 		cmd++;
1777 		str++;
1778 	}
1779 	if (*cmd == '\n')
1780 		cmd++;
1781 	if (*str || *cmd)
1782 		return 0;
1783 	return 1;
1784 }
1785 
1786 struct rdev_sysfs_entry {
1787 	struct attribute attr;
1788 	ssize_t (*show)(mdk_rdev_t *, char *);
1789 	ssize_t (*store)(mdk_rdev_t *, const char *, size_t);
1790 };
1791 
1792 static ssize_t
1793 state_show(mdk_rdev_t *rdev, char *page)
1794 {
1795 	char *sep = "";
1796 	int len=0;
1797 
1798 	if (test_bit(Faulty, &rdev->flags)) {
1799 		len+= sprintf(page+len, "%sfaulty",sep);
1800 		sep = ",";
1801 	}
1802 	if (test_bit(In_sync, &rdev->flags)) {
1803 		len += sprintf(page+len, "%sin_sync",sep);
1804 		sep = ",";
1805 	}
1806 	if (test_bit(WriteMostly, &rdev->flags)) {
1807 		len += sprintf(page+len, "%swrite_mostly",sep);
1808 		sep = ",";
1809 	}
1810 	if (!test_bit(Faulty, &rdev->flags) &&
1811 	    !test_bit(In_sync, &rdev->flags)) {
1812 		len += sprintf(page+len, "%sspare", sep);
1813 		sep = ",";
1814 	}
1815 	return len+sprintf(page+len, "\n");
1816 }
1817 
1818 static ssize_t
1819 state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1820 {
1821 	/* can write
1822 	 *  faulty  - simulates and error
1823 	 *  remove  - disconnects the device
1824 	 *  writemostly - sets write_mostly
1825 	 *  -writemostly - clears write_mostly
1826 	 */
1827 	int err = -EINVAL;
1828 	if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
1829 		md_error(rdev->mddev, rdev);
1830 		err = 0;
1831 	} else if (cmd_match(buf, "remove")) {
1832 		if (rdev->raid_disk >= 0)
1833 			err = -EBUSY;
1834 		else {
1835 			mddev_t *mddev = rdev->mddev;
1836 			kick_rdev_from_array(rdev);
1837 			if (mddev->pers)
1838 				md_update_sb(mddev, 1);
1839 			md_new_event(mddev);
1840 			err = 0;
1841 		}
1842 	} else if (cmd_match(buf, "writemostly")) {
1843 		set_bit(WriteMostly, &rdev->flags);
1844 		err = 0;
1845 	} else if (cmd_match(buf, "-writemostly")) {
1846 		clear_bit(WriteMostly, &rdev->flags);
1847 		err = 0;
1848 	}
1849 	return err ? err : len;
1850 }
1851 static struct rdev_sysfs_entry rdev_state =
1852 __ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store);
1853 
1854 static ssize_t
1855 super_show(mdk_rdev_t *rdev, char *page)
1856 {
1857 	if (rdev->sb_loaded && rdev->sb_size) {
1858 		memcpy(page, page_address(rdev->sb_page), rdev->sb_size);
1859 		return rdev->sb_size;
1860 	} else
1861 		return 0;
1862 }
1863 static struct rdev_sysfs_entry rdev_super = __ATTR_RO(super);
1864 
1865 static ssize_t
1866 errors_show(mdk_rdev_t *rdev, char *page)
1867 {
1868 	return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
1869 }
1870 
1871 static ssize_t
1872 errors_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1873 {
1874 	char *e;
1875 	unsigned long n = simple_strtoul(buf, &e, 10);
1876 	if (*buf && (*e == 0 || *e == '\n')) {
1877 		atomic_set(&rdev->corrected_errors, n);
1878 		return len;
1879 	}
1880 	return -EINVAL;
1881 }
1882 static struct rdev_sysfs_entry rdev_errors =
1883 __ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
1884 
1885 static ssize_t
1886 slot_show(mdk_rdev_t *rdev, char *page)
1887 {
1888 	if (rdev->raid_disk < 0)
1889 		return sprintf(page, "none\n");
1890 	else
1891 		return sprintf(page, "%d\n", rdev->raid_disk);
1892 }
1893 
1894 static ssize_t
1895 slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1896 {
1897 	char *e;
1898 	int slot = simple_strtoul(buf, &e, 10);
1899 	if (strncmp(buf, "none", 4)==0)
1900 		slot = -1;
1901 	else if (e==buf || (*e && *e!= '\n'))
1902 		return -EINVAL;
1903 	if (rdev->mddev->pers)
1904 		/* Cannot set slot in active array (yet) */
1905 		return -EBUSY;
1906 	if (slot >= rdev->mddev->raid_disks)
1907 		return -ENOSPC;
1908 	rdev->raid_disk = slot;
1909 	/* assume it is working */
1910 	rdev->flags = 0;
1911 	set_bit(In_sync, &rdev->flags);
1912 	return len;
1913 }
1914 
1915 
1916 static struct rdev_sysfs_entry rdev_slot =
1917 __ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
1918 
1919 static ssize_t
1920 offset_show(mdk_rdev_t *rdev, char *page)
1921 {
1922 	return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
1923 }
1924 
1925 static ssize_t
1926 offset_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1927 {
1928 	char *e;
1929 	unsigned long long offset = simple_strtoull(buf, &e, 10);
1930 	if (e==buf || (*e && *e != '\n'))
1931 		return -EINVAL;
1932 	if (rdev->mddev->pers)
1933 		return -EBUSY;
1934 	rdev->data_offset = offset;
1935 	return len;
1936 }
1937 
1938 static struct rdev_sysfs_entry rdev_offset =
1939 __ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
1940 
1941 static ssize_t
1942 rdev_size_show(mdk_rdev_t *rdev, char *page)
1943 {
1944 	return sprintf(page, "%llu\n", (unsigned long long)rdev->size);
1945 }
1946 
1947 static ssize_t
1948 rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1949 {
1950 	char *e;
1951 	unsigned long long size = simple_strtoull(buf, &e, 10);
1952 	if (e==buf || (*e && *e != '\n'))
1953 		return -EINVAL;
1954 	if (rdev->mddev->pers)
1955 		return -EBUSY;
1956 	rdev->size = size;
1957 	if (size < rdev->mddev->size || rdev->mddev->size == 0)
1958 		rdev->mddev->size = size;
1959 	return len;
1960 }
1961 
1962 static struct rdev_sysfs_entry rdev_size =
1963 __ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
1964 
1965 static struct attribute *rdev_default_attrs[] = {
1966 	&rdev_state.attr,
1967 	&rdev_super.attr,
1968 	&rdev_errors.attr,
1969 	&rdev_slot.attr,
1970 	&rdev_offset.attr,
1971 	&rdev_size.attr,
1972 	NULL,
1973 };
1974 static ssize_t
1975 rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
1976 {
1977 	struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
1978 	mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
1979 
1980 	if (!entry->show)
1981 		return -EIO;
1982 	return entry->show(rdev, page);
1983 }
1984 
1985 static ssize_t
1986 rdev_attr_store(struct kobject *kobj, struct attribute *attr,
1987 	      const char *page, size_t length)
1988 {
1989 	struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
1990 	mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
1991 
1992 	if (!entry->store)
1993 		return -EIO;
1994 	if (!capable(CAP_SYS_ADMIN))
1995 		return -EACCES;
1996 	return entry->store(rdev, page, length);
1997 }
1998 
1999 static void rdev_free(struct kobject *ko)
2000 {
2001 	mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj);
2002 	kfree(rdev);
2003 }
2004 static struct sysfs_ops rdev_sysfs_ops = {
2005 	.show		= rdev_attr_show,
2006 	.store		= rdev_attr_store,
2007 };
2008 static struct kobj_type rdev_ktype = {
2009 	.release	= rdev_free,
2010 	.sysfs_ops	= &rdev_sysfs_ops,
2011 	.default_attrs	= rdev_default_attrs,
2012 };
2013 
2014 /*
2015  * Import a device. If 'super_format' >= 0, then sanity check the superblock
2016  *
2017  * mark the device faulty if:
2018  *
2019  *   - the device is nonexistent (zero size)
2020  *   - the device has no valid superblock
2021  *
2022  * a faulty rdev _never_ has rdev->sb set.
2023  */
2024 static mdk_rdev_t *md_import_device(dev_t newdev, int super_format, int super_minor)
2025 {
2026 	char b[BDEVNAME_SIZE];
2027 	int err;
2028 	mdk_rdev_t *rdev;
2029 	sector_t size;
2030 
2031 	rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
2032 	if (!rdev) {
2033 		printk(KERN_ERR "md: could not alloc mem for new device!\n");
2034 		return ERR_PTR(-ENOMEM);
2035 	}
2036 
2037 	if ((err = alloc_disk_sb(rdev)))
2038 		goto abort_free;
2039 
2040 	err = lock_rdev(rdev, newdev);
2041 	if (err)
2042 		goto abort_free;
2043 
2044 	rdev->kobj.parent = NULL;
2045 	rdev->kobj.ktype = &rdev_ktype;
2046 	kobject_init(&rdev->kobj);
2047 
2048 	rdev->desc_nr = -1;
2049 	rdev->saved_raid_disk = -1;
2050 	rdev->raid_disk = -1;
2051 	rdev->flags = 0;
2052 	rdev->data_offset = 0;
2053 	rdev->sb_events = 0;
2054 	atomic_set(&rdev->nr_pending, 0);
2055 	atomic_set(&rdev->read_errors, 0);
2056 	atomic_set(&rdev->corrected_errors, 0);
2057 
2058 	size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
2059 	if (!size) {
2060 		printk(KERN_WARNING
2061 			"md: %s has zero or unknown size, marking faulty!\n",
2062 			bdevname(rdev->bdev,b));
2063 		err = -EINVAL;
2064 		goto abort_free;
2065 	}
2066 
2067 	if (super_format >= 0) {
2068 		err = super_types[super_format].
2069 			load_super(rdev, NULL, super_minor);
2070 		if (err == -EINVAL) {
2071 			printk(KERN_WARNING
2072 				"md: %s has invalid sb, not importing!\n",
2073 				bdevname(rdev->bdev,b));
2074 			goto abort_free;
2075 		}
2076 		if (err < 0) {
2077 			printk(KERN_WARNING
2078 				"md: could not read %s's sb, not importing!\n",
2079 				bdevname(rdev->bdev,b));
2080 			goto abort_free;
2081 		}
2082 	}
2083 	INIT_LIST_HEAD(&rdev->same_set);
2084 
2085 	return rdev;
2086 
2087 abort_free:
2088 	if (rdev->sb_page) {
2089 		if (rdev->bdev)
2090 			unlock_rdev(rdev);
2091 		free_disk_sb(rdev);
2092 	}
2093 	kfree(rdev);
2094 	return ERR_PTR(err);
2095 }
2096 
2097 /*
2098  * Check a full RAID array for plausibility
2099  */
2100 
2101 
2102 static void analyze_sbs(mddev_t * mddev)
2103 {
2104 	int i;
2105 	struct list_head *tmp;
2106 	mdk_rdev_t *rdev, *freshest;
2107 	char b[BDEVNAME_SIZE];
2108 
2109 	freshest = NULL;
2110 	ITERATE_RDEV(mddev,rdev,tmp)
2111 		switch (super_types[mddev->major_version].
2112 			load_super(rdev, freshest, mddev->minor_version)) {
2113 		case 1:
2114 			freshest = rdev;
2115 			break;
2116 		case 0:
2117 			break;
2118 		default:
2119 			printk( KERN_ERR \
2120 				"md: fatal superblock inconsistency in %s"
2121 				" -- removing from array\n",
2122 				bdevname(rdev->bdev,b));
2123 			kick_rdev_from_array(rdev);
2124 		}
2125 
2126 
2127 	super_types[mddev->major_version].
2128 		validate_super(mddev, freshest);
2129 
2130 	i = 0;
2131 	ITERATE_RDEV(mddev,rdev,tmp) {
2132 		if (rdev != freshest)
2133 			if (super_types[mddev->major_version].
2134 			    validate_super(mddev, rdev)) {
2135 				printk(KERN_WARNING "md: kicking non-fresh %s"
2136 					" from array!\n",
2137 					bdevname(rdev->bdev,b));
2138 				kick_rdev_from_array(rdev);
2139 				continue;
2140 			}
2141 		if (mddev->level == LEVEL_MULTIPATH) {
2142 			rdev->desc_nr = i++;
2143 			rdev->raid_disk = rdev->desc_nr;
2144 			set_bit(In_sync, &rdev->flags);
2145 		}
2146 	}
2147 
2148 
2149 
2150 	if (mddev->recovery_cp != MaxSector &&
2151 	    mddev->level >= 1)
2152 		printk(KERN_ERR "md: %s: raid array is not clean"
2153 		       " -- starting background reconstruction\n",
2154 		       mdname(mddev));
2155 
2156 }
2157 
2158 static ssize_t
2159 safe_delay_show(mddev_t *mddev, char *page)
2160 {
2161 	int msec = (mddev->safemode_delay*1000)/HZ;
2162 	return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
2163 }
2164 static ssize_t
2165 safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len)
2166 {
2167 	int scale=1;
2168 	int dot=0;
2169 	int i;
2170 	unsigned long msec;
2171 	char buf[30];
2172 	char *e;
2173 	/* remove a period, and count digits after it */
2174 	if (len >= sizeof(buf))
2175 		return -EINVAL;
2176 	strlcpy(buf, cbuf, len);
2177 	buf[len] = 0;
2178 	for (i=0; i<len; i++) {
2179 		if (dot) {
2180 			if (isdigit(buf[i])) {
2181 				buf[i-1] = buf[i];
2182 				scale *= 10;
2183 			}
2184 			buf[i] = 0;
2185 		} else if (buf[i] == '.') {
2186 			dot=1;
2187 			buf[i] = 0;
2188 		}
2189 	}
2190 	msec = simple_strtoul(buf, &e, 10);
2191 	if (e == buf || (*e && *e != '\n'))
2192 		return -EINVAL;
2193 	msec = (msec * 1000) / scale;
2194 	if (msec == 0)
2195 		mddev->safemode_delay = 0;
2196 	else {
2197 		mddev->safemode_delay = (msec*HZ)/1000;
2198 		if (mddev->safemode_delay == 0)
2199 			mddev->safemode_delay = 1;
2200 	}
2201 	return len;
2202 }
2203 static struct md_sysfs_entry md_safe_delay =
2204 __ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
2205 
2206 static ssize_t
2207 level_show(mddev_t *mddev, char *page)
2208 {
2209 	struct mdk_personality *p = mddev->pers;
2210 	if (p)
2211 		return sprintf(page, "%s\n", p->name);
2212 	else if (mddev->clevel[0])
2213 		return sprintf(page, "%s\n", mddev->clevel);
2214 	else if (mddev->level != LEVEL_NONE)
2215 		return sprintf(page, "%d\n", mddev->level);
2216 	else
2217 		return 0;
2218 }
2219 
2220 static ssize_t
2221 level_store(mddev_t *mddev, const char *buf, size_t len)
2222 {
2223 	int rv = len;
2224 	if (mddev->pers)
2225 		return -EBUSY;
2226 	if (len == 0)
2227 		return 0;
2228 	if (len >= sizeof(mddev->clevel))
2229 		return -ENOSPC;
2230 	strncpy(mddev->clevel, buf, len);
2231 	if (mddev->clevel[len-1] == '\n')
2232 		len--;
2233 	mddev->clevel[len] = 0;
2234 	mddev->level = LEVEL_NONE;
2235 	return rv;
2236 }
2237 
2238 static struct md_sysfs_entry md_level =
2239 __ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
2240 
2241 
2242 static ssize_t
2243 layout_show(mddev_t *mddev, char *page)
2244 {
2245 	/* just a number, not meaningful for all levels */
2246 	if (mddev->reshape_position != MaxSector &&
2247 	    mddev->layout != mddev->new_layout)
2248 		return sprintf(page, "%d (%d)\n",
2249 			       mddev->new_layout, mddev->layout);
2250 	return sprintf(page, "%d\n", mddev->layout);
2251 }
2252 
2253 static ssize_t
2254 layout_store(mddev_t *mddev, const char *buf, size_t len)
2255 {
2256 	char *e;
2257 	unsigned long n = simple_strtoul(buf, &e, 10);
2258 
2259 	if (!*buf || (*e && *e != '\n'))
2260 		return -EINVAL;
2261 
2262 	if (mddev->pers)
2263 		return -EBUSY;
2264 	if (mddev->reshape_position != MaxSector)
2265 		mddev->new_layout = n;
2266 	else
2267 		mddev->layout = n;
2268 	return len;
2269 }
2270 static struct md_sysfs_entry md_layout =
2271 __ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
2272 
2273 
2274 static ssize_t
2275 raid_disks_show(mddev_t *mddev, char *page)
2276 {
2277 	if (mddev->raid_disks == 0)
2278 		return 0;
2279 	if (mddev->reshape_position != MaxSector &&
2280 	    mddev->delta_disks != 0)
2281 		return sprintf(page, "%d (%d)\n", mddev->raid_disks,
2282 			       mddev->raid_disks - mddev->delta_disks);
2283 	return sprintf(page, "%d\n", mddev->raid_disks);
2284 }
2285 
2286 static int update_raid_disks(mddev_t *mddev, int raid_disks);
2287 
2288 static ssize_t
2289 raid_disks_store(mddev_t *mddev, const char *buf, size_t len)
2290 {
2291 	char *e;
2292 	int rv = 0;
2293 	unsigned long n = simple_strtoul(buf, &e, 10);
2294 
2295 	if (!*buf || (*e && *e != '\n'))
2296 		return -EINVAL;
2297 
2298 	if (mddev->pers)
2299 		rv = update_raid_disks(mddev, n);
2300 	else if (mddev->reshape_position != MaxSector) {
2301 		int olddisks = mddev->raid_disks - mddev->delta_disks;
2302 		mddev->delta_disks = n - olddisks;
2303 		mddev->raid_disks = n;
2304 	} else
2305 		mddev->raid_disks = n;
2306 	return rv ? rv : len;
2307 }
2308 static struct md_sysfs_entry md_raid_disks =
2309 __ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
2310 
2311 static ssize_t
2312 chunk_size_show(mddev_t *mddev, char *page)
2313 {
2314 	if (mddev->reshape_position != MaxSector &&
2315 	    mddev->chunk_size != mddev->new_chunk)
2316 		return sprintf(page, "%d (%d)\n", mddev->new_chunk,
2317 			       mddev->chunk_size);
2318 	return sprintf(page, "%d\n", mddev->chunk_size);
2319 }
2320 
2321 static ssize_t
2322 chunk_size_store(mddev_t *mddev, const char *buf, size_t len)
2323 {
2324 	/* can only set chunk_size if array is not yet active */
2325 	char *e;
2326 	unsigned long n = simple_strtoul(buf, &e, 10);
2327 
2328 	if (!*buf || (*e && *e != '\n'))
2329 		return -EINVAL;
2330 
2331 	if (mddev->pers)
2332 		return -EBUSY;
2333 	else if (mddev->reshape_position != MaxSector)
2334 		mddev->new_chunk = n;
2335 	else
2336 		mddev->chunk_size = n;
2337 	return len;
2338 }
2339 static struct md_sysfs_entry md_chunk_size =
2340 __ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
2341 
2342 static ssize_t
2343 resync_start_show(mddev_t *mddev, char *page)
2344 {
2345 	return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
2346 }
2347 
2348 static ssize_t
2349 resync_start_store(mddev_t *mddev, const char *buf, size_t len)
2350 {
2351 	/* can only set chunk_size if array is not yet active */
2352 	char *e;
2353 	unsigned long long n = simple_strtoull(buf, &e, 10);
2354 
2355 	if (mddev->pers)
2356 		return -EBUSY;
2357 	if (!*buf || (*e && *e != '\n'))
2358 		return -EINVAL;
2359 
2360 	mddev->recovery_cp = n;
2361 	return len;
2362 }
2363 static struct md_sysfs_entry md_resync_start =
2364 __ATTR(resync_start, S_IRUGO|S_IWUSR, resync_start_show, resync_start_store);
2365 
2366 /*
2367  * The array state can be:
2368  *
2369  * clear
2370  *     No devices, no size, no level
2371  *     Equivalent to STOP_ARRAY ioctl
2372  * inactive
2373  *     May have some settings, but array is not active
2374  *        all IO results in error
2375  *     When written, doesn't tear down array, but just stops it
2376  * suspended (not supported yet)
2377  *     All IO requests will block. The array can be reconfigured.
2378  *     Writing this, if accepted, will block until array is quiessent
2379  * readonly
2380  *     no resync can happen.  no superblocks get written.
2381  *     write requests fail
2382  * read-auto
2383  *     like readonly, but behaves like 'clean' on a write request.
2384  *
2385  * clean - no pending writes, but otherwise active.
2386  *     When written to inactive array, starts without resync
2387  *     If a write request arrives then
2388  *       if metadata is known, mark 'dirty' and switch to 'active'.
2389  *       if not known, block and switch to write-pending
2390  *     If written to an active array that has pending writes, then fails.
2391  * active
2392  *     fully active: IO and resync can be happening.
2393  *     When written to inactive array, starts with resync
2394  *
2395  * write-pending
2396  *     clean, but writes are blocked waiting for 'active' to be written.
2397  *
2398  * active-idle
2399  *     like active, but no writes have been seen for a while (100msec).
2400  *
2401  */
2402 enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
2403 		   write_pending, active_idle, bad_word};
2404 static char *array_states[] = {
2405 	"clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
2406 	"write-pending", "active-idle", NULL };
2407 
2408 static int match_word(const char *word, char **list)
2409 {
2410 	int n;
2411 	for (n=0; list[n]; n++)
2412 		if (cmd_match(word, list[n]))
2413 			break;
2414 	return n;
2415 }
2416 
2417 static ssize_t
2418 array_state_show(mddev_t *mddev, char *page)
2419 {
2420 	enum array_state st = inactive;
2421 
2422 	if (mddev->pers)
2423 		switch(mddev->ro) {
2424 		case 1:
2425 			st = readonly;
2426 			break;
2427 		case 2:
2428 			st = read_auto;
2429 			break;
2430 		case 0:
2431 			if (mddev->in_sync)
2432 				st = clean;
2433 			else if (mddev->safemode)
2434 				st = active_idle;
2435 			else
2436 				st = active;
2437 		}
2438 	else {
2439 		if (list_empty(&mddev->disks) &&
2440 		    mddev->raid_disks == 0 &&
2441 		    mddev->size == 0)
2442 			st = clear;
2443 		else
2444 			st = inactive;
2445 	}
2446 	return sprintf(page, "%s\n", array_states[st]);
2447 }
2448 
2449 static int do_md_stop(mddev_t * mddev, int ro);
2450 static int do_md_run(mddev_t * mddev);
2451 static int restart_array(mddev_t *mddev);
2452 
2453 static ssize_t
2454 array_state_store(mddev_t *mddev, const char *buf, size_t len)
2455 {
2456 	int err = -EINVAL;
2457 	enum array_state st = match_word(buf, array_states);
2458 	switch(st) {
2459 	case bad_word:
2460 		break;
2461 	case clear:
2462 		/* stopping an active array */
2463 		if (mddev->pers) {
2464 			if (atomic_read(&mddev->active) > 1)
2465 				return -EBUSY;
2466 			err = do_md_stop(mddev, 0);
2467 		}
2468 		break;
2469 	case inactive:
2470 		/* stopping an active array */
2471 		if (mddev->pers) {
2472 			if (atomic_read(&mddev->active) > 1)
2473 				return -EBUSY;
2474 			err = do_md_stop(mddev, 2);
2475 		}
2476 		break;
2477 	case suspended:
2478 		break; /* not supported yet */
2479 	case readonly:
2480 		if (mddev->pers)
2481 			err = do_md_stop(mddev, 1);
2482 		else {
2483 			mddev->ro = 1;
2484 			err = do_md_run(mddev);
2485 		}
2486 		break;
2487 	case read_auto:
2488 		/* stopping an active array */
2489 		if (mddev->pers) {
2490 			err = do_md_stop(mddev, 1);
2491 			if (err == 0)
2492 				mddev->ro = 2; /* FIXME mark devices writable */
2493 		} else {
2494 			mddev->ro = 2;
2495 			err = do_md_run(mddev);
2496 		}
2497 		break;
2498 	case clean:
2499 		if (mddev->pers) {
2500 			restart_array(mddev);
2501 			spin_lock_irq(&mddev->write_lock);
2502 			if (atomic_read(&mddev->writes_pending) == 0) {
2503 				mddev->in_sync = 1;
2504 				set_bit(MD_CHANGE_CLEAN, &mddev->flags);
2505 			}
2506 			spin_unlock_irq(&mddev->write_lock);
2507 		} else {
2508 			mddev->ro = 0;
2509 			mddev->recovery_cp = MaxSector;
2510 			err = do_md_run(mddev);
2511 		}
2512 		break;
2513 	case active:
2514 		if (mddev->pers) {
2515 			restart_array(mddev);
2516 			clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2517 			wake_up(&mddev->sb_wait);
2518 			err = 0;
2519 		} else {
2520 			mddev->ro = 0;
2521 			err = do_md_run(mddev);
2522 		}
2523 		break;
2524 	case write_pending:
2525 	case active_idle:
2526 		/* these cannot be set */
2527 		break;
2528 	}
2529 	if (err)
2530 		return err;
2531 	else
2532 		return len;
2533 }
2534 static struct md_sysfs_entry md_array_state =
2535 __ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
2536 
2537 static ssize_t
2538 null_show(mddev_t *mddev, char *page)
2539 {
2540 	return -EINVAL;
2541 }
2542 
2543 static ssize_t
2544 new_dev_store(mddev_t *mddev, const char *buf, size_t len)
2545 {
2546 	/* buf must be %d:%d\n? giving major and minor numbers */
2547 	/* The new device is added to the array.
2548 	 * If the array has a persistent superblock, we read the
2549 	 * superblock to initialise info and check validity.
2550 	 * Otherwise, only checking done is that in bind_rdev_to_array,
2551 	 * which mainly checks size.
2552 	 */
2553 	char *e;
2554 	int major = simple_strtoul(buf, &e, 10);
2555 	int minor;
2556 	dev_t dev;
2557 	mdk_rdev_t *rdev;
2558 	int err;
2559 
2560 	if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
2561 		return -EINVAL;
2562 	minor = simple_strtoul(e+1, &e, 10);
2563 	if (*e && *e != '\n')
2564 		return -EINVAL;
2565 	dev = MKDEV(major, minor);
2566 	if (major != MAJOR(dev) ||
2567 	    minor != MINOR(dev))
2568 		return -EOVERFLOW;
2569 
2570 
2571 	if (mddev->persistent) {
2572 		rdev = md_import_device(dev, mddev->major_version,
2573 					mddev->minor_version);
2574 		if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
2575 			mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
2576 						       mdk_rdev_t, same_set);
2577 			err = super_types[mddev->major_version]
2578 				.load_super(rdev, rdev0, mddev->minor_version);
2579 			if (err < 0)
2580 				goto out;
2581 		}
2582 	} else
2583 		rdev = md_import_device(dev, -1, -1);
2584 
2585 	if (IS_ERR(rdev))
2586 		return PTR_ERR(rdev);
2587 	err = bind_rdev_to_array(rdev, mddev);
2588  out:
2589 	if (err)
2590 		export_rdev(rdev);
2591 	return err ? err : len;
2592 }
2593 
2594 static struct md_sysfs_entry md_new_device =
2595 __ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
2596 
2597 static ssize_t
2598 bitmap_store(mddev_t *mddev, const char *buf, size_t len)
2599 {
2600 	char *end;
2601 	unsigned long chunk, end_chunk;
2602 
2603 	if (!mddev->bitmap)
2604 		goto out;
2605 	/* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
2606 	while (*buf) {
2607 		chunk = end_chunk = simple_strtoul(buf, &end, 0);
2608 		if (buf == end) break;
2609 		if (*end == '-') { /* range */
2610 			buf = end + 1;
2611 			end_chunk = simple_strtoul(buf, &end, 0);
2612 			if (buf == end) break;
2613 		}
2614 		if (*end && !isspace(*end)) break;
2615 		bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
2616 		buf = end;
2617 		while (isspace(*buf)) buf++;
2618 	}
2619 	bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
2620 out:
2621 	return len;
2622 }
2623 
2624 static struct md_sysfs_entry md_bitmap =
2625 __ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
2626 
2627 static ssize_t
2628 size_show(mddev_t *mddev, char *page)
2629 {
2630 	return sprintf(page, "%llu\n", (unsigned long long)mddev->size);
2631 }
2632 
2633 static int update_size(mddev_t *mddev, unsigned long size);
2634 
2635 static ssize_t
2636 size_store(mddev_t *mddev, const char *buf, size_t len)
2637 {
2638 	/* If array is inactive, we can reduce the component size, but
2639 	 * not increase it (except from 0).
2640 	 * If array is active, we can try an on-line resize
2641 	 */
2642 	char *e;
2643 	int err = 0;
2644 	unsigned long long size = simple_strtoull(buf, &e, 10);
2645 	if (!*buf || *buf == '\n' ||
2646 	    (*e && *e != '\n'))
2647 		return -EINVAL;
2648 
2649 	if (mddev->pers) {
2650 		err = update_size(mddev, size);
2651 		md_update_sb(mddev, 1);
2652 	} else {
2653 		if (mddev->size == 0 ||
2654 		    mddev->size > size)
2655 			mddev->size = size;
2656 		else
2657 			err = -ENOSPC;
2658 	}
2659 	return err ? err : len;
2660 }
2661 
2662 static struct md_sysfs_entry md_size =
2663 __ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
2664 
2665 
2666 /* Metdata version.
2667  * This is either 'none' for arrays with externally managed metadata,
2668  * or N.M for internally known formats
2669  */
2670 static ssize_t
2671 metadata_show(mddev_t *mddev, char *page)
2672 {
2673 	if (mddev->persistent)
2674 		return sprintf(page, "%d.%d\n",
2675 			       mddev->major_version, mddev->minor_version);
2676 	else
2677 		return sprintf(page, "none\n");
2678 }
2679 
2680 static ssize_t
2681 metadata_store(mddev_t *mddev, const char *buf, size_t len)
2682 {
2683 	int major, minor;
2684 	char *e;
2685 	if (!list_empty(&mddev->disks))
2686 		return -EBUSY;
2687 
2688 	if (cmd_match(buf, "none")) {
2689 		mddev->persistent = 0;
2690 		mddev->major_version = 0;
2691 		mddev->minor_version = 90;
2692 		return len;
2693 	}
2694 	major = simple_strtoul(buf, &e, 10);
2695 	if (e==buf || *e != '.')
2696 		return -EINVAL;
2697 	buf = e+1;
2698 	minor = simple_strtoul(buf, &e, 10);
2699 	if (e==buf || (*e && *e != '\n') )
2700 		return -EINVAL;
2701 	if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
2702 		return -ENOENT;
2703 	mddev->major_version = major;
2704 	mddev->minor_version = minor;
2705 	mddev->persistent = 1;
2706 	return len;
2707 }
2708 
2709 static struct md_sysfs_entry md_metadata =
2710 __ATTR(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
2711 
2712 static ssize_t
2713 action_show(mddev_t *mddev, char *page)
2714 {
2715 	char *type = "idle";
2716 	if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
2717 	    test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) {
2718 		if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
2719 			type = "reshape";
2720 		else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
2721 			if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
2722 				type = "resync";
2723 			else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
2724 				type = "check";
2725 			else
2726 				type = "repair";
2727 		} else
2728 			type = "recover";
2729 	}
2730 	return sprintf(page, "%s\n", type);
2731 }
2732 
2733 static ssize_t
2734 action_store(mddev_t *mddev, const char *page, size_t len)
2735 {
2736 	if (!mddev->pers || !mddev->pers->sync_request)
2737 		return -EINVAL;
2738 
2739 	if (cmd_match(page, "idle")) {
2740 		if (mddev->sync_thread) {
2741 			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
2742 			md_unregister_thread(mddev->sync_thread);
2743 			mddev->sync_thread = NULL;
2744 			mddev->recovery = 0;
2745 		}
2746 	} else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
2747 		   test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
2748 		return -EBUSY;
2749 	else if (cmd_match(page, "resync") || cmd_match(page, "recover"))
2750 		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2751 	else if (cmd_match(page, "reshape")) {
2752 		int err;
2753 		if (mddev->pers->start_reshape == NULL)
2754 			return -EINVAL;
2755 		err = mddev->pers->start_reshape(mddev);
2756 		if (err)
2757 			return err;
2758 	} else {
2759 		if (cmd_match(page, "check"))
2760 			set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
2761 		else if (!cmd_match(page, "repair"))
2762 			return -EINVAL;
2763 		set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
2764 		set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
2765 	}
2766 	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2767 	md_wakeup_thread(mddev->thread);
2768 	return len;
2769 }
2770 
2771 static ssize_t
2772 mismatch_cnt_show(mddev_t *mddev, char *page)
2773 {
2774 	return sprintf(page, "%llu\n",
2775 		       (unsigned long long) mddev->resync_mismatches);
2776 }
2777 
2778 static struct md_sysfs_entry md_scan_mode =
2779 __ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
2780 
2781 
2782 static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
2783 
2784 static ssize_t
2785 sync_min_show(mddev_t *mddev, char *page)
2786 {
2787 	return sprintf(page, "%d (%s)\n", speed_min(mddev),
2788 		       mddev->sync_speed_min ? "local": "system");
2789 }
2790 
2791 static ssize_t
2792 sync_min_store(mddev_t *mddev, const char *buf, size_t len)
2793 {
2794 	int min;
2795 	char *e;
2796 	if (strncmp(buf, "system", 6)==0) {
2797 		mddev->sync_speed_min = 0;
2798 		return len;
2799 	}
2800 	min = simple_strtoul(buf, &e, 10);
2801 	if (buf == e || (*e && *e != '\n') || min <= 0)
2802 		return -EINVAL;
2803 	mddev->sync_speed_min = min;
2804 	return len;
2805 }
2806 
2807 static struct md_sysfs_entry md_sync_min =
2808 __ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
2809 
2810 static ssize_t
2811 sync_max_show(mddev_t *mddev, char *page)
2812 {
2813 	return sprintf(page, "%d (%s)\n", speed_max(mddev),
2814 		       mddev->sync_speed_max ? "local": "system");
2815 }
2816 
2817 static ssize_t
2818 sync_max_store(mddev_t *mddev, const char *buf, size_t len)
2819 {
2820 	int max;
2821 	char *e;
2822 	if (strncmp(buf, "system", 6)==0) {
2823 		mddev->sync_speed_max = 0;
2824 		return len;
2825 	}
2826 	max = simple_strtoul(buf, &e, 10);
2827 	if (buf == e || (*e && *e != '\n') || max <= 0)
2828 		return -EINVAL;
2829 	mddev->sync_speed_max = max;
2830 	return len;
2831 }
2832 
2833 static struct md_sysfs_entry md_sync_max =
2834 __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
2835 
2836 
2837 static ssize_t
2838 sync_speed_show(mddev_t *mddev, char *page)
2839 {
2840 	unsigned long resync, dt, db;
2841 	resync = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active));
2842 	dt = ((jiffies - mddev->resync_mark) / HZ);
2843 	if (!dt) dt++;
2844 	db = resync - (mddev->resync_mark_cnt);
2845 	return sprintf(page, "%ld\n", db/dt/2); /* K/sec */
2846 }
2847 
2848 static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
2849 
2850 static ssize_t
2851 sync_completed_show(mddev_t *mddev, char *page)
2852 {
2853 	unsigned long max_blocks, resync;
2854 
2855 	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
2856 		max_blocks = mddev->resync_max_sectors;
2857 	else
2858 		max_blocks = mddev->size << 1;
2859 
2860 	resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active));
2861 	return sprintf(page, "%lu / %lu\n", resync, max_blocks);
2862 }
2863 
2864 static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
2865 
2866 static ssize_t
2867 suspend_lo_show(mddev_t *mddev, char *page)
2868 {
2869 	return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
2870 }
2871 
2872 static ssize_t
2873 suspend_lo_store(mddev_t *mddev, const char *buf, size_t len)
2874 {
2875 	char *e;
2876 	unsigned long long new = simple_strtoull(buf, &e, 10);
2877 
2878 	if (mddev->pers->quiesce == NULL)
2879 		return -EINVAL;
2880 	if (buf == e || (*e && *e != '\n'))
2881 		return -EINVAL;
2882 	if (new >= mddev->suspend_hi ||
2883 	    (new > mddev->suspend_lo && new < mddev->suspend_hi)) {
2884 		mddev->suspend_lo = new;
2885 		mddev->pers->quiesce(mddev, 2);
2886 		return len;
2887 	} else
2888 		return -EINVAL;
2889 }
2890 static struct md_sysfs_entry md_suspend_lo =
2891 __ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
2892 
2893 
2894 static ssize_t
2895 suspend_hi_show(mddev_t *mddev, char *page)
2896 {
2897 	return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
2898 }
2899 
2900 static ssize_t
2901 suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
2902 {
2903 	char *e;
2904 	unsigned long long new = simple_strtoull(buf, &e, 10);
2905 
2906 	if (mddev->pers->quiesce == NULL)
2907 		return -EINVAL;
2908 	if (buf == e || (*e && *e != '\n'))
2909 		return -EINVAL;
2910 	if ((new <= mddev->suspend_lo && mddev->suspend_lo >= mddev->suspend_hi) ||
2911 	    (new > mddev->suspend_lo && new > mddev->suspend_hi)) {
2912 		mddev->suspend_hi = new;
2913 		mddev->pers->quiesce(mddev, 1);
2914 		mddev->pers->quiesce(mddev, 0);
2915 		return len;
2916 	} else
2917 		return -EINVAL;
2918 }
2919 static struct md_sysfs_entry md_suspend_hi =
2920 __ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
2921 
2922 static ssize_t
2923 reshape_position_show(mddev_t *mddev, char *page)
2924 {
2925 	if (mddev->reshape_position != MaxSector)
2926 		return sprintf(page, "%llu\n",
2927 			       (unsigned long long)mddev->reshape_position);
2928 	strcpy(page, "none\n");
2929 	return 5;
2930 }
2931 
2932 static ssize_t
2933 reshape_position_store(mddev_t *mddev, const char *buf, size_t len)
2934 {
2935 	char *e;
2936 	unsigned long long new = simple_strtoull(buf, &e, 10);
2937 	if (mddev->pers)
2938 		return -EBUSY;
2939 	if (buf == e || (*e && *e != '\n'))
2940 		return -EINVAL;
2941 	mddev->reshape_position = new;
2942 	mddev->delta_disks = 0;
2943 	mddev->new_level = mddev->level;
2944 	mddev->new_layout = mddev->layout;
2945 	mddev->new_chunk = mddev->chunk_size;
2946 	return len;
2947 }
2948 
2949 static struct md_sysfs_entry md_reshape_position =
2950 __ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
2951        reshape_position_store);
2952 
2953 
2954 static struct attribute *md_default_attrs[] = {
2955 	&md_level.attr,
2956 	&md_layout.attr,
2957 	&md_raid_disks.attr,
2958 	&md_chunk_size.attr,
2959 	&md_size.attr,
2960 	&md_resync_start.attr,
2961 	&md_metadata.attr,
2962 	&md_new_device.attr,
2963 	&md_safe_delay.attr,
2964 	&md_array_state.attr,
2965 	&md_reshape_position.attr,
2966 	NULL,
2967 };
2968 
2969 static struct attribute *md_redundancy_attrs[] = {
2970 	&md_scan_mode.attr,
2971 	&md_mismatches.attr,
2972 	&md_sync_min.attr,
2973 	&md_sync_max.attr,
2974 	&md_sync_speed.attr,
2975 	&md_sync_completed.attr,
2976 	&md_suspend_lo.attr,
2977 	&md_suspend_hi.attr,
2978 	&md_bitmap.attr,
2979 	NULL,
2980 };
2981 static struct attribute_group md_redundancy_group = {
2982 	.name = NULL,
2983 	.attrs = md_redundancy_attrs,
2984 };
2985 
2986 
2987 static ssize_t
2988 md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
2989 {
2990 	struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
2991 	mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
2992 	ssize_t rv;
2993 
2994 	if (!entry->show)
2995 		return -EIO;
2996 	rv = mddev_lock(mddev);
2997 	if (!rv) {
2998 		rv = entry->show(mddev, page);
2999 		mddev_unlock(mddev);
3000 	}
3001 	return rv;
3002 }
3003 
3004 static ssize_t
3005 md_attr_store(struct kobject *kobj, struct attribute *attr,
3006 	      const char *page, size_t length)
3007 {
3008 	struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
3009 	mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
3010 	ssize_t rv;
3011 
3012 	if (!entry->store)
3013 		return -EIO;
3014 	if (!capable(CAP_SYS_ADMIN))
3015 		return -EACCES;
3016 	rv = mddev_lock(mddev);
3017 	if (!rv) {
3018 		rv = entry->store(mddev, page, length);
3019 		mddev_unlock(mddev);
3020 	}
3021 	return rv;
3022 }
3023 
3024 static void md_free(struct kobject *ko)
3025 {
3026 	mddev_t *mddev = container_of(ko, mddev_t, kobj);
3027 	kfree(mddev);
3028 }
3029 
3030 static struct sysfs_ops md_sysfs_ops = {
3031 	.show	= md_attr_show,
3032 	.store	= md_attr_store,
3033 };
3034 static struct kobj_type md_ktype = {
3035 	.release	= md_free,
3036 	.sysfs_ops	= &md_sysfs_ops,
3037 	.default_attrs	= md_default_attrs,
3038 };
3039 
3040 int mdp_major = 0;
3041 
3042 static struct kobject *md_probe(dev_t dev, int *part, void *data)
3043 {
3044 	static DEFINE_MUTEX(disks_mutex);
3045 	mddev_t *mddev = mddev_find(dev);
3046 	struct gendisk *disk;
3047 	int partitioned = (MAJOR(dev) != MD_MAJOR);
3048 	int shift = partitioned ? MdpMinorShift : 0;
3049 	int unit = MINOR(dev) >> shift;
3050 
3051 	if (!mddev)
3052 		return NULL;
3053 
3054 	mutex_lock(&disks_mutex);
3055 	if (mddev->gendisk) {
3056 		mutex_unlock(&disks_mutex);
3057 		mddev_put(mddev);
3058 		return NULL;
3059 	}
3060 	disk = alloc_disk(1 << shift);
3061 	if (!disk) {
3062 		mutex_unlock(&disks_mutex);
3063 		mddev_put(mddev);
3064 		return NULL;
3065 	}
3066 	disk->major = MAJOR(dev);
3067 	disk->first_minor = unit << shift;
3068 	if (partitioned)
3069 		sprintf(disk->disk_name, "md_d%d", unit);
3070 	else
3071 		sprintf(disk->disk_name, "md%d", unit);
3072 	disk->fops = &md_fops;
3073 	disk->private_data = mddev;
3074 	disk->queue = mddev->queue;
3075 	add_disk(disk);
3076 	mddev->gendisk = disk;
3077 	mutex_unlock(&disks_mutex);
3078 	mddev->kobj.parent = &disk->kobj;
3079 	mddev->kobj.k_name = NULL;
3080 	snprintf(mddev->kobj.name, KOBJ_NAME_LEN, "%s", "md");
3081 	mddev->kobj.ktype = &md_ktype;
3082 	if (kobject_register(&mddev->kobj))
3083 		printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
3084 		       disk->disk_name);
3085 	return NULL;
3086 }
3087 
3088 static void md_safemode_timeout(unsigned long data)
3089 {
3090 	mddev_t *mddev = (mddev_t *) data;
3091 
3092 	mddev->safemode = 1;
3093 	md_wakeup_thread(mddev->thread);
3094 }
3095 
3096 static int start_dirty_degraded;
3097 
3098 static int do_md_run(mddev_t * mddev)
3099 {
3100 	int err;
3101 	int chunk_size;
3102 	struct list_head *tmp;
3103 	mdk_rdev_t *rdev;
3104 	struct gendisk *disk;
3105 	struct mdk_personality *pers;
3106 	char b[BDEVNAME_SIZE];
3107 
3108 	if (list_empty(&mddev->disks))
3109 		/* cannot run an array with no devices.. */
3110 		return -EINVAL;
3111 
3112 	if (mddev->pers)
3113 		return -EBUSY;
3114 
3115 	/*
3116 	 * Analyze all RAID superblock(s)
3117 	 */
3118 	if (!mddev->raid_disks)
3119 		analyze_sbs(mddev);
3120 
3121 	chunk_size = mddev->chunk_size;
3122 
3123 	if (chunk_size) {
3124 		if (chunk_size > MAX_CHUNK_SIZE) {
3125 			printk(KERN_ERR "too big chunk_size: %d > %d\n",
3126 				chunk_size, MAX_CHUNK_SIZE);
3127 			return -EINVAL;
3128 		}
3129 		/*
3130 		 * chunk-size has to be a power of 2 and multiples of PAGE_SIZE
3131 		 */
3132 		if ( (1 << ffz(~chunk_size)) != chunk_size) {
3133 			printk(KERN_ERR "chunk_size of %d not valid\n", chunk_size);
3134 			return -EINVAL;
3135 		}
3136 		if (chunk_size < PAGE_SIZE) {
3137 			printk(KERN_ERR "too small chunk_size: %d < %ld\n",
3138 				chunk_size, PAGE_SIZE);
3139 			return -EINVAL;
3140 		}
3141 
3142 		/* devices must have minimum size of one chunk */
3143 		ITERATE_RDEV(mddev,rdev,tmp) {
3144 			if (test_bit(Faulty, &rdev->flags))
3145 				continue;
3146 			if (rdev->size < chunk_size / 1024) {
3147 				printk(KERN_WARNING
3148 					"md: Dev %s smaller than chunk_size:"
3149 					" %lluk < %dk\n",
3150 					bdevname(rdev->bdev,b),
3151 					(unsigned long long)rdev->size,
3152 					chunk_size / 1024);
3153 				return -EINVAL;
3154 			}
3155 		}
3156 	}
3157 
3158 #ifdef CONFIG_KMOD
3159 	if (mddev->level != LEVEL_NONE)
3160 		request_module("md-level-%d", mddev->level);
3161 	else if (mddev->clevel[0])
3162 		request_module("md-%s", mddev->clevel);
3163 #endif
3164 
3165 	/*
3166 	 * Drop all container device buffers, from now on
3167 	 * the only valid external interface is through the md
3168 	 * device.
3169 	 * Also find largest hardsector size
3170 	 */
3171 	ITERATE_RDEV(mddev,rdev,tmp) {
3172 		if (test_bit(Faulty, &rdev->flags))
3173 			continue;
3174 		sync_blockdev(rdev->bdev);
3175 		invalidate_bdev(rdev->bdev);
3176 	}
3177 
3178 	md_probe(mddev->unit, NULL, NULL);
3179 	disk = mddev->gendisk;
3180 	if (!disk)
3181 		return -ENOMEM;
3182 
3183 	spin_lock(&pers_lock);
3184 	pers = find_pers(mddev->level, mddev->clevel);
3185 	if (!pers || !try_module_get(pers->owner)) {
3186 		spin_unlock(&pers_lock);
3187 		if (mddev->level != LEVEL_NONE)
3188 			printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
3189 			       mddev->level);
3190 		else
3191 			printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
3192 			       mddev->clevel);
3193 		return -EINVAL;
3194 	}
3195 	mddev->pers = pers;
3196 	spin_unlock(&pers_lock);
3197 	mddev->level = pers->level;
3198 	strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3199 
3200 	if (mddev->reshape_position != MaxSector &&
3201 	    pers->start_reshape == NULL) {
3202 		/* This personality cannot handle reshaping... */
3203 		mddev->pers = NULL;
3204 		module_put(pers->owner);
3205 		return -EINVAL;
3206 	}
3207 
3208 	if (pers->sync_request) {
3209 		/* Warn if this is a potentially silly
3210 		 * configuration.
3211 		 */
3212 		char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
3213 		mdk_rdev_t *rdev2;
3214 		struct list_head *tmp2;
3215 		int warned = 0;
3216 		ITERATE_RDEV(mddev, rdev, tmp) {
3217 			ITERATE_RDEV(mddev, rdev2, tmp2) {
3218 				if (rdev < rdev2 &&
3219 				    rdev->bdev->bd_contains ==
3220 				    rdev2->bdev->bd_contains) {
3221 					printk(KERN_WARNING
3222 					       "%s: WARNING: %s appears to be"
3223 					       " on the same physical disk as"
3224 					       " %s.\n",
3225 					       mdname(mddev),
3226 					       bdevname(rdev->bdev,b),
3227 					       bdevname(rdev2->bdev,b2));
3228 					warned = 1;
3229 				}
3230 			}
3231 		}
3232 		if (warned)
3233 			printk(KERN_WARNING
3234 			       "True protection against single-disk"
3235 			       " failure might be compromised.\n");
3236 	}
3237 
3238 	mddev->recovery = 0;
3239 	mddev->resync_max_sectors = mddev->size << 1; /* may be over-ridden by personality */
3240 	mddev->barriers_work = 1;
3241 	mddev->ok_start_degraded = start_dirty_degraded;
3242 
3243 	if (start_readonly)
3244 		mddev->ro = 2; /* read-only, but switch on first write */
3245 
3246 	err = mddev->pers->run(mddev);
3247 	if (!err && mddev->pers->sync_request) {
3248 		err = bitmap_create(mddev);
3249 		if (err) {
3250 			printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
3251 			       mdname(mddev), err);
3252 			mddev->pers->stop(mddev);
3253 		}
3254 	}
3255 	if (err) {
3256 		printk(KERN_ERR "md: pers->run() failed ...\n");
3257 		module_put(mddev->pers->owner);
3258 		mddev->pers = NULL;
3259 		bitmap_destroy(mddev);
3260 		return err;
3261 	}
3262 	if (mddev->pers->sync_request) {
3263 		if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
3264 			printk(KERN_WARNING
3265 			       "md: cannot register extra attributes for %s\n",
3266 			       mdname(mddev));
3267 	} else if (mddev->ro == 2) /* auto-readonly not meaningful */
3268 		mddev->ro = 0;
3269 
3270  	atomic_set(&mddev->writes_pending,0);
3271 	mddev->safemode = 0;
3272 	mddev->safemode_timer.function = md_safemode_timeout;
3273 	mddev->safemode_timer.data = (unsigned long) mddev;
3274 	mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
3275 	mddev->in_sync = 1;
3276 
3277 	ITERATE_RDEV(mddev,rdev,tmp)
3278 		if (rdev->raid_disk >= 0) {
3279 			char nm[20];
3280 			sprintf(nm, "rd%d", rdev->raid_disk);
3281 			if (sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
3282 				printk("md: cannot register %s for %s\n",
3283 				       nm, mdname(mddev));
3284 		}
3285 
3286 	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3287 
3288 	if (mddev->flags)
3289 		md_update_sb(mddev, 0);
3290 
3291 	set_capacity(disk, mddev->array_size<<1);
3292 
3293 	/* If we call blk_queue_make_request here, it will
3294 	 * re-initialise max_sectors etc which may have been
3295 	 * refined inside -> run.  So just set the bits we need to set.
3296 	 * Most initialisation happended when we called
3297 	 * blk_queue_make_request(..., md_fail_request)
3298 	 * earlier.
3299 	 */
3300 	mddev->queue->queuedata = mddev;
3301 	mddev->queue->make_request_fn = mddev->pers->make_request;
3302 
3303 	/* If there is a partially-recovered drive we need to
3304 	 * start recovery here.  If we leave it to md_check_recovery,
3305 	 * it will remove the drives and not do the right thing
3306 	 */
3307 	if (mddev->degraded && !mddev->sync_thread) {
3308 		struct list_head *rtmp;
3309 		int spares = 0;
3310 		ITERATE_RDEV(mddev,rdev,rtmp)
3311 			if (rdev->raid_disk >= 0 &&
3312 			    !test_bit(In_sync, &rdev->flags) &&
3313 			    !test_bit(Faulty, &rdev->flags))
3314 				/* complete an interrupted recovery */
3315 				spares++;
3316 		if (spares && mddev->pers->sync_request) {
3317 			mddev->recovery = 0;
3318 			set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
3319 			mddev->sync_thread = md_register_thread(md_do_sync,
3320 								mddev,
3321 								"%s_resync");
3322 			if (!mddev->sync_thread) {
3323 				printk(KERN_ERR "%s: could not start resync"
3324 				       " thread...\n",
3325 				       mdname(mddev));
3326 				/* leave the spares where they are, it shouldn't hurt */
3327 				mddev->recovery = 0;
3328 			}
3329 		}
3330 	}
3331 	md_wakeup_thread(mddev->thread);
3332 	md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
3333 
3334 	mddev->changed = 1;
3335 	md_new_event(mddev);
3336 	kobject_uevent(&mddev->gendisk->kobj, KOBJ_CHANGE);
3337 	return 0;
3338 }
3339 
3340 static int restart_array(mddev_t *mddev)
3341 {
3342 	struct gendisk *disk = mddev->gendisk;
3343 	int err;
3344 
3345 	/*
3346 	 * Complain if it has no devices
3347 	 */
3348 	err = -ENXIO;
3349 	if (list_empty(&mddev->disks))
3350 		goto out;
3351 
3352 	if (mddev->pers) {
3353 		err = -EBUSY;
3354 		if (!mddev->ro)
3355 			goto out;
3356 
3357 		mddev->safemode = 0;
3358 		mddev->ro = 0;
3359 		set_disk_ro(disk, 0);
3360 
3361 		printk(KERN_INFO "md: %s switched to read-write mode.\n",
3362 			mdname(mddev));
3363 		/*
3364 		 * Kick recovery or resync if necessary
3365 		 */
3366 		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3367 		md_wakeup_thread(mddev->thread);
3368 		md_wakeup_thread(mddev->sync_thread);
3369 		err = 0;
3370 	} else
3371 		err = -EINVAL;
3372 
3373 out:
3374 	return err;
3375 }
3376 
3377 /* similar to deny_write_access, but accounts for our holding a reference
3378  * to the file ourselves */
3379 static int deny_bitmap_write_access(struct file * file)
3380 {
3381 	struct inode *inode = file->f_mapping->host;
3382 
3383 	spin_lock(&inode->i_lock);
3384 	if (atomic_read(&inode->i_writecount) > 1) {
3385 		spin_unlock(&inode->i_lock);
3386 		return -ETXTBSY;
3387 	}
3388 	atomic_set(&inode->i_writecount, -1);
3389 	spin_unlock(&inode->i_lock);
3390 
3391 	return 0;
3392 }
3393 
3394 static void restore_bitmap_write_access(struct file *file)
3395 {
3396 	struct inode *inode = file->f_mapping->host;
3397 
3398 	spin_lock(&inode->i_lock);
3399 	atomic_set(&inode->i_writecount, 1);
3400 	spin_unlock(&inode->i_lock);
3401 }
3402 
3403 /* mode:
3404  *   0 - completely stop and dis-assemble array
3405  *   1 - switch to readonly
3406  *   2 - stop but do not disassemble array
3407  */
3408 static int do_md_stop(mddev_t * mddev, int mode)
3409 {
3410 	int err = 0;
3411 	struct gendisk *disk = mddev->gendisk;
3412 
3413 	if (mddev->pers) {
3414 		if (atomic_read(&mddev->active)>2) {
3415 			printk("md: %s still in use.\n",mdname(mddev));
3416 			return -EBUSY;
3417 		}
3418 
3419 		if (mddev->sync_thread) {
3420 			set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
3421 			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
3422 			md_unregister_thread(mddev->sync_thread);
3423 			mddev->sync_thread = NULL;
3424 		}
3425 
3426 		del_timer_sync(&mddev->safemode_timer);
3427 
3428 		invalidate_partition(disk, 0);
3429 
3430 		switch(mode) {
3431 		case 1: /* readonly */
3432 			err  = -ENXIO;
3433 			if (mddev->ro==1)
3434 				goto out;
3435 			mddev->ro = 1;
3436 			break;
3437 		case 0: /* disassemble */
3438 		case 2: /* stop */
3439 			bitmap_flush(mddev);
3440 			md_super_wait(mddev);
3441 			if (mddev->ro)
3442 				set_disk_ro(disk, 0);
3443 			blk_queue_make_request(mddev->queue, md_fail_request);
3444 			mddev->pers->stop(mddev);
3445 			mddev->queue->merge_bvec_fn = NULL;
3446 			mddev->queue->unplug_fn = NULL;
3447 			mddev->queue->issue_flush_fn = NULL;
3448 			mddev->queue->backing_dev_info.congested_fn = NULL;
3449 			if (mddev->pers->sync_request)
3450 				sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
3451 
3452 			module_put(mddev->pers->owner);
3453 			mddev->pers = NULL;
3454 
3455 			set_capacity(disk, 0);
3456 			mddev->changed = 1;
3457 
3458 			if (mddev->ro)
3459 				mddev->ro = 0;
3460 		}
3461 		if (!mddev->in_sync || mddev->flags) {
3462 			/* mark array as shutdown cleanly */
3463 			mddev->in_sync = 1;
3464 			md_update_sb(mddev, 1);
3465 		}
3466 		if (mode == 1)
3467 			set_disk_ro(disk, 1);
3468 		clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
3469 	}
3470 
3471 	/*
3472 	 * Free resources if final stop
3473 	 */
3474 	if (mode == 0) {
3475 		mdk_rdev_t *rdev;
3476 		struct list_head *tmp;
3477 
3478 		printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
3479 
3480 		bitmap_destroy(mddev);
3481 		if (mddev->bitmap_file) {
3482 			restore_bitmap_write_access(mddev->bitmap_file);
3483 			fput(mddev->bitmap_file);
3484 			mddev->bitmap_file = NULL;
3485 		}
3486 		mddev->bitmap_offset = 0;
3487 
3488 		ITERATE_RDEV(mddev,rdev,tmp)
3489 			if (rdev->raid_disk >= 0) {
3490 				char nm[20];
3491 				sprintf(nm, "rd%d", rdev->raid_disk);
3492 				sysfs_remove_link(&mddev->kobj, nm);
3493 			}
3494 
3495 		/* make sure all delayed_delete calls have finished */
3496 		flush_scheduled_work();
3497 
3498 		export_array(mddev);
3499 
3500 		mddev->array_size = 0;
3501 		mddev->size = 0;
3502 		mddev->raid_disks = 0;
3503 		mddev->recovery_cp = 0;
3504 		mddev->reshape_position = MaxSector;
3505 
3506 	} else if (mddev->pers)
3507 		printk(KERN_INFO "md: %s switched to read-only mode.\n",
3508 			mdname(mddev));
3509 	err = 0;
3510 	md_new_event(mddev);
3511 out:
3512 	return err;
3513 }
3514 
3515 #ifndef MODULE
3516 static void autorun_array(mddev_t *mddev)
3517 {
3518 	mdk_rdev_t *rdev;
3519 	struct list_head *tmp;
3520 	int err;
3521 
3522 	if (list_empty(&mddev->disks))
3523 		return;
3524 
3525 	printk(KERN_INFO "md: running: ");
3526 
3527 	ITERATE_RDEV(mddev,rdev,tmp) {
3528 		char b[BDEVNAME_SIZE];
3529 		printk("<%s>", bdevname(rdev->bdev,b));
3530 	}
3531 	printk("\n");
3532 
3533 	err = do_md_run (mddev);
3534 	if (err) {
3535 		printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
3536 		do_md_stop (mddev, 0);
3537 	}
3538 }
3539 
3540 /*
3541  * lets try to run arrays based on all disks that have arrived
3542  * until now. (those are in pending_raid_disks)
3543  *
3544  * the method: pick the first pending disk, collect all disks with
3545  * the same UUID, remove all from the pending list and put them into
3546  * the 'same_array' list. Then order this list based on superblock
3547  * update time (freshest comes first), kick out 'old' disks and
3548  * compare superblocks. If everything's fine then run it.
3549  *
3550  * If "unit" is allocated, then bump its reference count
3551  */
3552 static void autorun_devices(int part)
3553 {
3554 	struct list_head *tmp;
3555 	mdk_rdev_t *rdev0, *rdev;
3556 	mddev_t *mddev;
3557 	char b[BDEVNAME_SIZE];
3558 
3559 	printk(KERN_INFO "md: autorun ...\n");
3560 	while (!list_empty(&pending_raid_disks)) {
3561 		int unit;
3562 		dev_t dev;
3563 		LIST_HEAD(candidates);
3564 		rdev0 = list_entry(pending_raid_disks.next,
3565 					 mdk_rdev_t, same_set);
3566 
3567 		printk(KERN_INFO "md: considering %s ...\n",
3568 			bdevname(rdev0->bdev,b));
3569 		INIT_LIST_HEAD(&candidates);
3570 		ITERATE_RDEV_PENDING(rdev,tmp)
3571 			if (super_90_load(rdev, rdev0, 0) >= 0) {
3572 				printk(KERN_INFO "md:  adding %s ...\n",
3573 					bdevname(rdev->bdev,b));
3574 				list_move(&rdev->same_set, &candidates);
3575 			}
3576 		/*
3577 		 * now we have a set of devices, with all of them having
3578 		 * mostly sane superblocks. It's time to allocate the
3579 		 * mddev.
3580 		 */
3581 		if (part) {
3582 			dev = MKDEV(mdp_major,
3583 				    rdev0->preferred_minor << MdpMinorShift);
3584 			unit = MINOR(dev) >> MdpMinorShift;
3585 		} else {
3586 			dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
3587 			unit = MINOR(dev);
3588 		}
3589 		if (rdev0->preferred_minor != unit) {
3590 			printk(KERN_INFO "md: unit number in %s is bad: %d\n",
3591 			       bdevname(rdev0->bdev, b), rdev0->preferred_minor);
3592 			break;
3593 		}
3594 
3595 		md_probe(dev, NULL, NULL);
3596 		mddev = mddev_find(dev);
3597 		if (!mddev) {
3598 			printk(KERN_ERR
3599 				"md: cannot allocate memory for md drive.\n");
3600 			break;
3601 		}
3602 		if (mddev_lock(mddev))
3603 			printk(KERN_WARNING "md: %s locked, cannot run\n",
3604 			       mdname(mddev));
3605 		else if (mddev->raid_disks || mddev->major_version
3606 			 || !list_empty(&mddev->disks)) {
3607 			printk(KERN_WARNING
3608 				"md: %s already running, cannot run %s\n",
3609 				mdname(mddev), bdevname(rdev0->bdev,b));
3610 			mddev_unlock(mddev);
3611 		} else {
3612 			printk(KERN_INFO "md: created %s\n", mdname(mddev));
3613 			ITERATE_RDEV_GENERIC(candidates,rdev,tmp) {
3614 				list_del_init(&rdev->same_set);
3615 				if (bind_rdev_to_array(rdev, mddev))
3616 					export_rdev(rdev);
3617 			}
3618 			autorun_array(mddev);
3619 			mddev_unlock(mddev);
3620 		}
3621 		/* on success, candidates will be empty, on error
3622 		 * it won't...
3623 		 */
3624 		ITERATE_RDEV_GENERIC(candidates,rdev,tmp)
3625 			export_rdev(rdev);
3626 		mddev_put(mddev);
3627 	}
3628 	printk(KERN_INFO "md: ... autorun DONE.\n");
3629 }
3630 #endif /* !MODULE */
3631 
3632 static int get_version(void __user * arg)
3633 {
3634 	mdu_version_t ver;
3635 
3636 	ver.major = MD_MAJOR_VERSION;
3637 	ver.minor = MD_MINOR_VERSION;
3638 	ver.patchlevel = MD_PATCHLEVEL_VERSION;
3639 
3640 	if (copy_to_user(arg, &ver, sizeof(ver)))
3641 		return -EFAULT;
3642 
3643 	return 0;
3644 }
3645 
3646 static int get_array_info(mddev_t * mddev, void __user * arg)
3647 {
3648 	mdu_array_info_t info;
3649 	int nr,working,active,failed,spare;
3650 	mdk_rdev_t *rdev;
3651 	struct list_head *tmp;
3652 
3653 	nr=working=active=failed=spare=0;
3654 	ITERATE_RDEV(mddev,rdev,tmp) {
3655 		nr++;
3656 		if (test_bit(Faulty, &rdev->flags))
3657 			failed++;
3658 		else {
3659 			working++;
3660 			if (test_bit(In_sync, &rdev->flags))
3661 				active++;
3662 			else
3663 				spare++;
3664 		}
3665 	}
3666 
3667 	info.major_version = mddev->major_version;
3668 	info.minor_version = mddev->minor_version;
3669 	info.patch_version = MD_PATCHLEVEL_VERSION;
3670 	info.ctime         = mddev->ctime;
3671 	info.level         = mddev->level;
3672 	info.size          = mddev->size;
3673 	if (info.size != mddev->size) /* overflow */
3674 		info.size = -1;
3675 	info.nr_disks      = nr;
3676 	info.raid_disks    = mddev->raid_disks;
3677 	info.md_minor      = mddev->md_minor;
3678 	info.not_persistent= !mddev->persistent;
3679 
3680 	info.utime         = mddev->utime;
3681 	info.state         = 0;
3682 	if (mddev->in_sync)
3683 		info.state = (1<<MD_SB_CLEAN);
3684 	if (mddev->bitmap && mddev->bitmap_offset)
3685 		info.state = (1<<MD_SB_BITMAP_PRESENT);
3686 	info.active_disks  = active;
3687 	info.working_disks = working;
3688 	info.failed_disks  = failed;
3689 	info.spare_disks   = spare;
3690 
3691 	info.layout        = mddev->layout;
3692 	info.chunk_size    = mddev->chunk_size;
3693 
3694 	if (copy_to_user(arg, &info, sizeof(info)))
3695 		return -EFAULT;
3696 
3697 	return 0;
3698 }
3699 
3700 static int get_bitmap_file(mddev_t * mddev, void __user * arg)
3701 {
3702 	mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
3703 	char *ptr, *buf = NULL;
3704 	int err = -ENOMEM;
3705 
3706 	md_allow_write(mddev);
3707 
3708 	file = kmalloc(sizeof(*file), GFP_KERNEL);
3709 	if (!file)
3710 		goto out;
3711 
3712 	/* bitmap disabled, zero the first byte and copy out */
3713 	if (!mddev->bitmap || !mddev->bitmap->file) {
3714 		file->pathname[0] = '\0';
3715 		goto copy_out;
3716 	}
3717 
3718 	buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
3719 	if (!buf)
3720 		goto out;
3721 
3722 	ptr = file_path(mddev->bitmap->file, buf, sizeof(file->pathname));
3723 	if (!ptr)
3724 		goto out;
3725 
3726 	strcpy(file->pathname, ptr);
3727 
3728 copy_out:
3729 	err = 0;
3730 	if (copy_to_user(arg, file, sizeof(*file)))
3731 		err = -EFAULT;
3732 out:
3733 	kfree(buf);
3734 	kfree(file);
3735 	return err;
3736 }
3737 
3738 static int get_disk_info(mddev_t * mddev, void __user * arg)
3739 {
3740 	mdu_disk_info_t info;
3741 	unsigned int nr;
3742 	mdk_rdev_t *rdev;
3743 
3744 	if (copy_from_user(&info, arg, sizeof(info)))
3745 		return -EFAULT;
3746 
3747 	nr = info.number;
3748 
3749 	rdev = find_rdev_nr(mddev, nr);
3750 	if (rdev) {
3751 		info.major = MAJOR(rdev->bdev->bd_dev);
3752 		info.minor = MINOR(rdev->bdev->bd_dev);
3753 		info.raid_disk = rdev->raid_disk;
3754 		info.state = 0;
3755 		if (test_bit(Faulty, &rdev->flags))
3756 			info.state |= (1<<MD_DISK_FAULTY);
3757 		else if (test_bit(In_sync, &rdev->flags)) {
3758 			info.state |= (1<<MD_DISK_ACTIVE);
3759 			info.state |= (1<<MD_DISK_SYNC);
3760 		}
3761 		if (test_bit(WriteMostly, &rdev->flags))
3762 			info.state |= (1<<MD_DISK_WRITEMOSTLY);
3763 	} else {
3764 		info.major = info.minor = 0;
3765 		info.raid_disk = -1;
3766 		info.state = (1<<MD_DISK_REMOVED);
3767 	}
3768 
3769 	if (copy_to_user(arg, &info, sizeof(info)))
3770 		return -EFAULT;
3771 
3772 	return 0;
3773 }
3774 
3775 static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
3776 {
3777 	char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
3778 	mdk_rdev_t *rdev;
3779 	dev_t dev = MKDEV(info->major,info->minor);
3780 
3781 	if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
3782 		return -EOVERFLOW;
3783 
3784 	if (!mddev->raid_disks) {
3785 		int err;
3786 		/* expecting a device which has a superblock */
3787 		rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
3788 		if (IS_ERR(rdev)) {
3789 			printk(KERN_WARNING
3790 				"md: md_import_device returned %ld\n",
3791 				PTR_ERR(rdev));
3792 			return PTR_ERR(rdev);
3793 		}
3794 		if (!list_empty(&mddev->disks)) {
3795 			mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
3796 							mdk_rdev_t, same_set);
3797 			int err = super_types[mddev->major_version]
3798 				.load_super(rdev, rdev0, mddev->minor_version);
3799 			if (err < 0) {
3800 				printk(KERN_WARNING
3801 					"md: %s has different UUID to %s\n",
3802 					bdevname(rdev->bdev,b),
3803 					bdevname(rdev0->bdev,b2));
3804 				export_rdev(rdev);
3805 				return -EINVAL;
3806 			}
3807 		}
3808 		err = bind_rdev_to_array(rdev, mddev);
3809 		if (err)
3810 			export_rdev(rdev);
3811 		return err;
3812 	}
3813 
3814 	/*
3815 	 * add_new_disk can be used once the array is assembled
3816 	 * to add "hot spares".  They must already have a superblock
3817 	 * written
3818 	 */
3819 	if (mddev->pers) {
3820 		int err;
3821 		if (!mddev->pers->hot_add_disk) {
3822 			printk(KERN_WARNING
3823 				"%s: personality does not support diskops!\n",
3824 			       mdname(mddev));
3825 			return -EINVAL;
3826 		}
3827 		if (mddev->persistent)
3828 			rdev = md_import_device(dev, mddev->major_version,
3829 						mddev->minor_version);
3830 		else
3831 			rdev = md_import_device(dev, -1, -1);
3832 		if (IS_ERR(rdev)) {
3833 			printk(KERN_WARNING
3834 				"md: md_import_device returned %ld\n",
3835 				PTR_ERR(rdev));
3836 			return PTR_ERR(rdev);
3837 		}
3838 		/* set save_raid_disk if appropriate */
3839 		if (!mddev->persistent) {
3840 			if (info->state & (1<<MD_DISK_SYNC)  &&
3841 			    info->raid_disk < mddev->raid_disks)
3842 				rdev->raid_disk = info->raid_disk;
3843 			else
3844 				rdev->raid_disk = -1;
3845 		} else
3846 			super_types[mddev->major_version].
3847 				validate_super(mddev, rdev);
3848 		rdev->saved_raid_disk = rdev->raid_disk;
3849 
3850 		clear_bit(In_sync, &rdev->flags); /* just to be sure */
3851 		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
3852 			set_bit(WriteMostly, &rdev->flags);
3853 
3854 		rdev->raid_disk = -1;
3855 		err = bind_rdev_to_array(rdev, mddev);
3856 		if (!err && !mddev->pers->hot_remove_disk) {
3857 			/* If there is hot_add_disk but no hot_remove_disk
3858 			 * then added disks for geometry changes,
3859 			 * and should be added immediately.
3860 			 */
3861 			super_types[mddev->major_version].
3862 				validate_super(mddev, rdev);
3863 			err = mddev->pers->hot_add_disk(mddev, rdev);
3864 			if (err)
3865 				unbind_rdev_from_array(rdev);
3866 		}
3867 		if (err)
3868 			export_rdev(rdev);
3869 
3870 		md_update_sb(mddev, 1);
3871 		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3872 		md_wakeup_thread(mddev->thread);
3873 		return err;
3874 	}
3875 
3876 	/* otherwise, add_new_disk is only allowed
3877 	 * for major_version==0 superblocks
3878 	 */
3879 	if (mddev->major_version != 0) {
3880 		printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
3881 		       mdname(mddev));
3882 		return -EINVAL;
3883 	}
3884 
3885 	if (!(info->state & (1<<MD_DISK_FAULTY))) {
3886 		int err;
3887 		rdev = md_import_device (dev, -1, 0);
3888 		if (IS_ERR(rdev)) {
3889 			printk(KERN_WARNING
3890 				"md: error, md_import_device() returned %ld\n",
3891 				PTR_ERR(rdev));
3892 			return PTR_ERR(rdev);
3893 		}
3894 		rdev->desc_nr = info->number;
3895 		if (info->raid_disk < mddev->raid_disks)
3896 			rdev->raid_disk = info->raid_disk;
3897 		else
3898 			rdev->raid_disk = -1;
3899 
3900 		rdev->flags = 0;
3901 
3902 		if (rdev->raid_disk < mddev->raid_disks)
3903 			if (info->state & (1<<MD_DISK_SYNC))
3904 				set_bit(In_sync, &rdev->flags);
3905 
3906 		if (info->state & (1<<MD_DISK_WRITEMOSTLY))
3907 			set_bit(WriteMostly, &rdev->flags);
3908 
3909 		if (!mddev->persistent) {
3910 			printk(KERN_INFO "md: nonpersistent superblock ...\n");
3911 			rdev->sb_offset = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
3912 		} else
3913 			rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
3914 		rdev->size = calc_dev_size(rdev, mddev->chunk_size);
3915 
3916 		err = bind_rdev_to_array(rdev, mddev);
3917 		if (err) {
3918 			export_rdev(rdev);
3919 			return err;
3920 		}
3921 	}
3922 
3923 	return 0;
3924 }
3925 
3926 static int hot_remove_disk(mddev_t * mddev, dev_t dev)
3927 {
3928 	char b[BDEVNAME_SIZE];
3929 	mdk_rdev_t *rdev;
3930 
3931 	if (!mddev->pers)
3932 		return -ENODEV;
3933 
3934 	rdev = find_rdev(mddev, dev);
3935 	if (!rdev)
3936 		return -ENXIO;
3937 
3938 	if (rdev->raid_disk >= 0)
3939 		goto busy;
3940 
3941 	kick_rdev_from_array(rdev);
3942 	md_update_sb(mddev, 1);
3943 	md_new_event(mddev);
3944 
3945 	return 0;
3946 busy:
3947 	printk(KERN_WARNING "md: cannot remove active disk %s from %s ... \n",
3948 		bdevname(rdev->bdev,b), mdname(mddev));
3949 	return -EBUSY;
3950 }
3951 
3952 static int hot_add_disk(mddev_t * mddev, dev_t dev)
3953 {
3954 	char b[BDEVNAME_SIZE];
3955 	int err;
3956 	unsigned int size;
3957 	mdk_rdev_t *rdev;
3958 
3959 	if (!mddev->pers)
3960 		return -ENODEV;
3961 
3962 	if (mddev->major_version != 0) {
3963 		printk(KERN_WARNING "%s: HOT_ADD may only be used with"
3964 			" version-0 superblocks.\n",
3965 			mdname(mddev));
3966 		return -EINVAL;
3967 	}
3968 	if (!mddev->pers->hot_add_disk) {
3969 		printk(KERN_WARNING
3970 			"%s: personality does not support diskops!\n",
3971 			mdname(mddev));
3972 		return -EINVAL;
3973 	}
3974 
3975 	rdev = md_import_device (dev, -1, 0);
3976 	if (IS_ERR(rdev)) {
3977 		printk(KERN_WARNING
3978 			"md: error, md_import_device() returned %ld\n",
3979 			PTR_ERR(rdev));
3980 		return -EINVAL;
3981 	}
3982 
3983 	if (mddev->persistent)
3984 		rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
3985 	else
3986 		rdev->sb_offset =
3987 			rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
3988 
3989 	size = calc_dev_size(rdev, mddev->chunk_size);
3990 	rdev->size = size;
3991 
3992 	if (test_bit(Faulty, &rdev->flags)) {
3993 		printk(KERN_WARNING
3994 			"md: can not hot-add faulty %s disk to %s!\n",
3995 			bdevname(rdev->bdev,b), mdname(mddev));
3996 		err = -EINVAL;
3997 		goto abort_export;
3998 	}
3999 	clear_bit(In_sync, &rdev->flags);
4000 	rdev->desc_nr = -1;
4001 	rdev->saved_raid_disk = -1;
4002 	err = bind_rdev_to_array(rdev, mddev);
4003 	if (err)
4004 		goto abort_export;
4005 
4006 	/*
4007 	 * The rest should better be atomic, we can have disk failures
4008 	 * noticed in interrupt contexts ...
4009 	 */
4010 
4011 	if (rdev->desc_nr == mddev->max_disks) {
4012 		printk(KERN_WARNING "%s: can not hot-add to full array!\n",
4013 			mdname(mddev));
4014 		err = -EBUSY;
4015 		goto abort_unbind_export;
4016 	}
4017 
4018 	rdev->raid_disk = -1;
4019 
4020 	md_update_sb(mddev, 1);
4021 
4022 	/*
4023 	 * Kick recovery, maybe this spare has to be added to the
4024 	 * array immediately.
4025 	 */
4026 	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4027 	md_wakeup_thread(mddev->thread);
4028 	md_new_event(mddev);
4029 	return 0;
4030 
4031 abort_unbind_export:
4032 	unbind_rdev_from_array(rdev);
4033 
4034 abort_export:
4035 	export_rdev(rdev);
4036 	return err;
4037 }
4038 
4039 static int set_bitmap_file(mddev_t *mddev, int fd)
4040 {
4041 	int err;
4042 
4043 	if (mddev->pers) {
4044 		if (!mddev->pers->quiesce)
4045 			return -EBUSY;
4046 		if (mddev->recovery || mddev->sync_thread)
4047 			return -EBUSY;
4048 		/* we should be able to change the bitmap.. */
4049 	}
4050 
4051 
4052 	if (fd >= 0) {
4053 		if (mddev->bitmap)
4054 			return -EEXIST; /* cannot add when bitmap is present */
4055 		mddev->bitmap_file = fget(fd);
4056 
4057 		if (mddev->bitmap_file == NULL) {
4058 			printk(KERN_ERR "%s: error: failed to get bitmap file\n",
4059 			       mdname(mddev));
4060 			return -EBADF;
4061 		}
4062 
4063 		err = deny_bitmap_write_access(mddev->bitmap_file);
4064 		if (err) {
4065 			printk(KERN_ERR "%s: error: bitmap file is already in use\n",
4066 			       mdname(mddev));
4067 			fput(mddev->bitmap_file);
4068 			mddev->bitmap_file = NULL;
4069 			return err;
4070 		}
4071 		mddev->bitmap_offset = 0; /* file overrides offset */
4072 	} else if (mddev->bitmap == NULL)
4073 		return -ENOENT; /* cannot remove what isn't there */
4074 	err = 0;
4075 	if (mddev->pers) {
4076 		mddev->pers->quiesce(mddev, 1);
4077 		if (fd >= 0)
4078 			err = bitmap_create(mddev);
4079 		if (fd < 0 || err) {
4080 			bitmap_destroy(mddev);
4081 			fd = -1; /* make sure to put the file */
4082 		}
4083 		mddev->pers->quiesce(mddev, 0);
4084 	}
4085 	if (fd < 0) {
4086 		if (mddev->bitmap_file) {
4087 			restore_bitmap_write_access(mddev->bitmap_file);
4088 			fput(mddev->bitmap_file);
4089 		}
4090 		mddev->bitmap_file = NULL;
4091 	}
4092 
4093 	return err;
4094 }
4095 
4096 /*
4097  * set_array_info is used two different ways
4098  * The original usage is when creating a new array.
4099  * In this usage, raid_disks is > 0 and it together with
4100  *  level, size, not_persistent,layout,chunksize determine the
4101  *  shape of the array.
4102  *  This will always create an array with a type-0.90.0 superblock.
4103  * The newer usage is when assembling an array.
4104  *  In this case raid_disks will be 0, and the major_version field is
4105  *  use to determine which style super-blocks are to be found on the devices.
4106  *  The minor and patch _version numbers are also kept incase the
4107  *  super_block handler wishes to interpret them.
4108  */
4109 static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
4110 {
4111 
4112 	if (info->raid_disks == 0) {
4113 		/* just setting version number for superblock loading */
4114 		if (info->major_version < 0 ||
4115 		    info->major_version >= ARRAY_SIZE(super_types) ||
4116 		    super_types[info->major_version].name == NULL) {
4117 			/* maybe try to auto-load a module? */
4118 			printk(KERN_INFO
4119 				"md: superblock version %d not known\n",
4120 				info->major_version);
4121 			return -EINVAL;
4122 		}
4123 		mddev->major_version = info->major_version;
4124 		mddev->minor_version = info->minor_version;
4125 		mddev->patch_version = info->patch_version;
4126 		mddev->persistent = !info->not_persistent;
4127 		return 0;
4128 	}
4129 	mddev->major_version = MD_MAJOR_VERSION;
4130 	mddev->minor_version = MD_MINOR_VERSION;
4131 	mddev->patch_version = MD_PATCHLEVEL_VERSION;
4132 	mddev->ctime         = get_seconds();
4133 
4134 	mddev->level         = info->level;
4135 	mddev->clevel[0]     = 0;
4136 	mddev->size          = info->size;
4137 	mddev->raid_disks    = info->raid_disks;
4138 	/* don't set md_minor, it is determined by which /dev/md* was
4139 	 * openned
4140 	 */
4141 	if (info->state & (1<<MD_SB_CLEAN))
4142 		mddev->recovery_cp = MaxSector;
4143 	else
4144 		mddev->recovery_cp = 0;
4145 	mddev->persistent    = ! info->not_persistent;
4146 
4147 	mddev->layout        = info->layout;
4148 	mddev->chunk_size    = info->chunk_size;
4149 
4150 	mddev->max_disks     = MD_SB_DISKS;
4151 
4152 	mddev->flags         = 0;
4153 	set_bit(MD_CHANGE_DEVS, &mddev->flags);
4154 
4155 	mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
4156 	mddev->bitmap_offset = 0;
4157 
4158 	mddev->reshape_position = MaxSector;
4159 
4160 	/*
4161 	 * Generate a 128 bit UUID
4162 	 */
4163 	get_random_bytes(mddev->uuid, 16);
4164 
4165 	mddev->new_level = mddev->level;
4166 	mddev->new_chunk = mddev->chunk_size;
4167 	mddev->new_layout = mddev->layout;
4168 	mddev->delta_disks = 0;
4169 
4170 	return 0;
4171 }
4172 
4173 static int update_size(mddev_t *mddev, unsigned long size)
4174 {
4175 	mdk_rdev_t * rdev;
4176 	int rv;
4177 	struct list_head *tmp;
4178 	int fit = (size == 0);
4179 
4180 	if (mddev->pers->resize == NULL)
4181 		return -EINVAL;
4182 	/* The "size" is the amount of each device that is used.
4183 	 * This can only make sense for arrays with redundancy.
4184 	 * linear and raid0 always use whatever space is available
4185 	 * We can only consider changing the size if no resync
4186 	 * or reconstruction is happening, and if the new size
4187 	 * is acceptable. It must fit before the sb_offset or,
4188 	 * if that is <data_offset, it must fit before the
4189 	 * size of each device.
4190 	 * If size is zero, we find the largest size that fits.
4191 	 */
4192 	if (mddev->sync_thread)
4193 		return -EBUSY;
4194 	ITERATE_RDEV(mddev,rdev,tmp) {
4195 		sector_t avail;
4196 		avail = rdev->size * 2;
4197 
4198 		if (fit && (size == 0 || size > avail/2))
4199 			size = avail/2;
4200 		if (avail < ((sector_t)size << 1))
4201 			return -ENOSPC;
4202 	}
4203 	rv = mddev->pers->resize(mddev, (sector_t)size *2);
4204 	if (!rv) {
4205 		struct block_device *bdev;
4206 
4207 		bdev = bdget_disk(mddev->gendisk, 0);
4208 		if (bdev) {
4209 			mutex_lock(&bdev->bd_inode->i_mutex);
4210 			i_size_write(bdev->bd_inode, (loff_t)mddev->array_size << 10);
4211 			mutex_unlock(&bdev->bd_inode->i_mutex);
4212 			bdput(bdev);
4213 		}
4214 	}
4215 	return rv;
4216 }
4217 
4218 static int update_raid_disks(mddev_t *mddev, int raid_disks)
4219 {
4220 	int rv;
4221 	/* change the number of raid disks */
4222 	if (mddev->pers->check_reshape == NULL)
4223 		return -EINVAL;
4224 	if (raid_disks <= 0 ||
4225 	    raid_disks >= mddev->max_disks)
4226 		return -EINVAL;
4227 	if (mddev->sync_thread || mddev->reshape_position != MaxSector)
4228 		return -EBUSY;
4229 	mddev->delta_disks = raid_disks - mddev->raid_disks;
4230 
4231 	rv = mddev->pers->check_reshape(mddev);
4232 	return rv;
4233 }
4234 
4235 
4236 /*
4237  * update_array_info is used to change the configuration of an
4238  * on-line array.
4239  * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
4240  * fields in the info are checked against the array.
4241  * Any differences that cannot be handled will cause an error.
4242  * Normally, only one change can be managed at a time.
4243  */
4244 static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
4245 {
4246 	int rv = 0;
4247 	int cnt = 0;
4248 	int state = 0;
4249 
4250 	/* calculate expected state,ignoring low bits */
4251 	if (mddev->bitmap && mddev->bitmap_offset)
4252 		state |= (1 << MD_SB_BITMAP_PRESENT);
4253 
4254 	if (mddev->major_version != info->major_version ||
4255 	    mddev->minor_version != info->minor_version ||
4256 /*	    mddev->patch_version != info->patch_version || */
4257 	    mddev->ctime         != info->ctime         ||
4258 	    mddev->level         != info->level         ||
4259 /*	    mddev->layout        != info->layout        || */
4260 	    !mddev->persistent	 != info->not_persistent||
4261 	    mddev->chunk_size    != info->chunk_size    ||
4262 	    /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
4263 	    ((state^info->state) & 0xfffffe00)
4264 		)
4265 		return -EINVAL;
4266 	/* Check there is only one change */
4267 	if (info->size >= 0 && mddev->size != info->size) cnt++;
4268 	if (mddev->raid_disks != info->raid_disks) cnt++;
4269 	if (mddev->layout != info->layout) cnt++;
4270 	if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) cnt++;
4271 	if (cnt == 0) return 0;
4272 	if (cnt > 1) return -EINVAL;
4273 
4274 	if (mddev->layout != info->layout) {
4275 		/* Change layout
4276 		 * we don't need to do anything at the md level, the
4277 		 * personality will take care of it all.
4278 		 */
4279 		if (mddev->pers->reconfig == NULL)
4280 			return -EINVAL;
4281 		else
4282 			return mddev->pers->reconfig(mddev, info->layout, -1);
4283 	}
4284 	if (info->size >= 0 && mddev->size != info->size)
4285 		rv = update_size(mddev, info->size);
4286 
4287 	if (mddev->raid_disks    != info->raid_disks)
4288 		rv = update_raid_disks(mddev, info->raid_disks);
4289 
4290 	if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
4291 		if (mddev->pers->quiesce == NULL)
4292 			return -EINVAL;
4293 		if (mddev->recovery || mddev->sync_thread)
4294 			return -EBUSY;
4295 		if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
4296 			/* add the bitmap */
4297 			if (mddev->bitmap)
4298 				return -EEXIST;
4299 			if (mddev->default_bitmap_offset == 0)
4300 				return -EINVAL;
4301 			mddev->bitmap_offset = mddev->default_bitmap_offset;
4302 			mddev->pers->quiesce(mddev, 1);
4303 			rv = bitmap_create(mddev);
4304 			if (rv)
4305 				bitmap_destroy(mddev);
4306 			mddev->pers->quiesce(mddev, 0);
4307 		} else {
4308 			/* remove the bitmap */
4309 			if (!mddev->bitmap)
4310 				return -ENOENT;
4311 			if (mddev->bitmap->file)
4312 				return -EINVAL;
4313 			mddev->pers->quiesce(mddev, 1);
4314 			bitmap_destroy(mddev);
4315 			mddev->pers->quiesce(mddev, 0);
4316 			mddev->bitmap_offset = 0;
4317 		}
4318 	}
4319 	md_update_sb(mddev, 1);
4320 	return rv;
4321 }
4322 
4323 static int set_disk_faulty(mddev_t *mddev, dev_t dev)
4324 {
4325 	mdk_rdev_t *rdev;
4326 
4327 	if (mddev->pers == NULL)
4328 		return -ENODEV;
4329 
4330 	rdev = find_rdev(mddev, dev);
4331 	if (!rdev)
4332 		return -ENODEV;
4333 
4334 	md_error(mddev, rdev);
4335 	return 0;
4336 }
4337 
4338 static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
4339 {
4340 	mddev_t *mddev = bdev->bd_disk->private_data;
4341 
4342 	geo->heads = 2;
4343 	geo->sectors = 4;
4344 	geo->cylinders = get_capacity(mddev->gendisk) / 8;
4345 	return 0;
4346 }
4347 
4348 static int md_ioctl(struct inode *inode, struct file *file,
4349 			unsigned int cmd, unsigned long arg)
4350 {
4351 	int err = 0;
4352 	void __user *argp = (void __user *)arg;
4353 	mddev_t *mddev = NULL;
4354 
4355 	if (!capable(CAP_SYS_ADMIN))
4356 		return -EACCES;
4357 
4358 	/*
4359 	 * Commands dealing with the RAID driver but not any
4360 	 * particular array:
4361 	 */
4362 	switch (cmd)
4363 	{
4364 		case RAID_VERSION:
4365 			err = get_version(argp);
4366 			goto done;
4367 
4368 		case PRINT_RAID_DEBUG:
4369 			err = 0;
4370 			md_print_devices();
4371 			goto done;
4372 
4373 #ifndef MODULE
4374 		case RAID_AUTORUN:
4375 			err = 0;
4376 			autostart_arrays(arg);
4377 			goto done;
4378 #endif
4379 		default:;
4380 	}
4381 
4382 	/*
4383 	 * Commands creating/starting a new array:
4384 	 */
4385 
4386 	mddev = inode->i_bdev->bd_disk->private_data;
4387 
4388 	if (!mddev) {
4389 		BUG();
4390 		goto abort;
4391 	}
4392 
4393 	err = mddev_lock(mddev);
4394 	if (err) {
4395 		printk(KERN_INFO
4396 			"md: ioctl lock interrupted, reason %d, cmd %d\n",
4397 			err, cmd);
4398 		goto abort;
4399 	}
4400 
4401 	switch (cmd)
4402 	{
4403 		case SET_ARRAY_INFO:
4404 			{
4405 				mdu_array_info_t info;
4406 				if (!arg)
4407 					memset(&info, 0, sizeof(info));
4408 				else if (copy_from_user(&info, argp, sizeof(info))) {
4409 					err = -EFAULT;
4410 					goto abort_unlock;
4411 				}
4412 				if (mddev->pers) {
4413 					err = update_array_info(mddev, &info);
4414 					if (err) {
4415 						printk(KERN_WARNING "md: couldn't update"
4416 						       " array info. %d\n", err);
4417 						goto abort_unlock;
4418 					}
4419 					goto done_unlock;
4420 				}
4421 				if (!list_empty(&mddev->disks)) {
4422 					printk(KERN_WARNING
4423 					       "md: array %s already has disks!\n",
4424 					       mdname(mddev));
4425 					err = -EBUSY;
4426 					goto abort_unlock;
4427 				}
4428 				if (mddev->raid_disks) {
4429 					printk(KERN_WARNING
4430 					       "md: array %s already initialised!\n",
4431 					       mdname(mddev));
4432 					err = -EBUSY;
4433 					goto abort_unlock;
4434 				}
4435 				err = set_array_info(mddev, &info);
4436 				if (err) {
4437 					printk(KERN_WARNING "md: couldn't set"
4438 					       " array info. %d\n", err);
4439 					goto abort_unlock;
4440 				}
4441 			}
4442 			goto done_unlock;
4443 
4444 		default:;
4445 	}
4446 
4447 	/*
4448 	 * Commands querying/configuring an existing array:
4449 	 */
4450 	/* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
4451 	 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
4452 	if (!mddev->raid_disks && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
4453 			&& cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
4454 	    		&& cmd != GET_BITMAP_FILE) {
4455 		err = -ENODEV;
4456 		goto abort_unlock;
4457 	}
4458 
4459 	/*
4460 	 * Commands even a read-only array can execute:
4461 	 */
4462 	switch (cmd)
4463 	{
4464 		case GET_ARRAY_INFO:
4465 			err = get_array_info(mddev, argp);
4466 			goto done_unlock;
4467 
4468 		case GET_BITMAP_FILE:
4469 			err = get_bitmap_file(mddev, argp);
4470 			goto done_unlock;
4471 
4472 		case GET_DISK_INFO:
4473 			err = get_disk_info(mddev, argp);
4474 			goto done_unlock;
4475 
4476 		case RESTART_ARRAY_RW:
4477 			err = restart_array(mddev);
4478 			goto done_unlock;
4479 
4480 		case STOP_ARRAY:
4481 			err = do_md_stop (mddev, 0);
4482 			goto done_unlock;
4483 
4484 		case STOP_ARRAY_RO:
4485 			err = do_md_stop (mddev, 1);
4486 			goto done_unlock;
4487 
4488 	/*
4489 	 * We have a problem here : there is no easy way to give a CHS
4490 	 * virtual geometry. We currently pretend that we have a 2 heads
4491 	 * 4 sectors (with a BIG number of cylinders...). This drives
4492 	 * dosfs just mad... ;-)
4493 	 */
4494 	}
4495 
4496 	/*
4497 	 * The remaining ioctls are changing the state of the
4498 	 * superblock, so we do not allow them on read-only arrays.
4499 	 * However non-MD ioctls (e.g. get-size) will still come through
4500 	 * here and hit the 'default' below, so only disallow
4501 	 * 'md' ioctls, and switch to rw mode if started auto-readonly.
4502 	 */
4503 	if (_IOC_TYPE(cmd) == MD_MAJOR &&
4504 	    mddev->ro && mddev->pers) {
4505 		if (mddev->ro == 2) {
4506 			mddev->ro = 0;
4507 		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4508 		md_wakeup_thread(mddev->thread);
4509 
4510 		} else {
4511 			err = -EROFS;
4512 			goto abort_unlock;
4513 		}
4514 	}
4515 
4516 	switch (cmd)
4517 	{
4518 		case ADD_NEW_DISK:
4519 		{
4520 			mdu_disk_info_t info;
4521 			if (copy_from_user(&info, argp, sizeof(info)))
4522 				err = -EFAULT;
4523 			else
4524 				err = add_new_disk(mddev, &info);
4525 			goto done_unlock;
4526 		}
4527 
4528 		case HOT_REMOVE_DISK:
4529 			err = hot_remove_disk(mddev, new_decode_dev(arg));
4530 			goto done_unlock;
4531 
4532 		case HOT_ADD_DISK:
4533 			err = hot_add_disk(mddev, new_decode_dev(arg));
4534 			goto done_unlock;
4535 
4536 		case SET_DISK_FAULTY:
4537 			err = set_disk_faulty(mddev, new_decode_dev(arg));
4538 			goto done_unlock;
4539 
4540 		case RUN_ARRAY:
4541 			err = do_md_run (mddev);
4542 			goto done_unlock;
4543 
4544 		case SET_BITMAP_FILE:
4545 			err = set_bitmap_file(mddev, (int)arg);
4546 			goto done_unlock;
4547 
4548 		default:
4549 			err = -EINVAL;
4550 			goto abort_unlock;
4551 	}
4552 
4553 done_unlock:
4554 abort_unlock:
4555 	mddev_unlock(mddev);
4556 
4557 	return err;
4558 done:
4559 	if (err)
4560 		MD_BUG();
4561 abort:
4562 	return err;
4563 }
4564 
4565 static int md_open(struct inode *inode, struct file *file)
4566 {
4567 	/*
4568 	 * Succeed if we can lock the mddev, which confirms that
4569 	 * it isn't being stopped right now.
4570 	 */
4571 	mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
4572 	int err;
4573 
4574 	if ((err = mutex_lock_interruptible_nested(&mddev->reconfig_mutex, 1)))
4575 		goto out;
4576 
4577 	err = 0;
4578 	mddev_get(mddev);
4579 	mddev_unlock(mddev);
4580 
4581 	check_disk_change(inode->i_bdev);
4582  out:
4583 	return err;
4584 }
4585 
4586 static int md_release(struct inode *inode, struct file * file)
4587 {
4588  	mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
4589 
4590 	BUG_ON(!mddev);
4591 	mddev_put(mddev);
4592 
4593 	return 0;
4594 }
4595 
4596 static int md_media_changed(struct gendisk *disk)
4597 {
4598 	mddev_t *mddev = disk->private_data;
4599 
4600 	return mddev->changed;
4601 }
4602 
4603 static int md_revalidate(struct gendisk *disk)
4604 {
4605 	mddev_t *mddev = disk->private_data;
4606 
4607 	mddev->changed = 0;
4608 	return 0;
4609 }
4610 static struct block_device_operations md_fops =
4611 {
4612 	.owner		= THIS_MODULE,
4613 	.open		= md_open,
4614 	.release	= md_release,
4615 	.ioctl		= md_ioctl,
4616 	.getgeo		= md_getgeo,
4617 	.media_changed	= md_media_changed,
4618 	.revalidate_disk= md_revalidate,
4619 };
4620 
4621 static int md_thread(void * arg)
4622 {
4623 	mdk_thread_t *thread = arg;
4624 
4625 	/*
4626 	 * md_thread is a 'system-thread', it's priority should be very
4627 	 * high. We avoid resource deadlocks individually in each
4628 	 * raid personality. (RAID5 does preallocation) We also use RR and
4629 	 * the very same RT priority as kswapd, thus we will never get
4630 	 * into a priority inversion deadlock.
4631 	 *
4632 	 * we definitely have to have equal or higher priority than
4633 	 * bdflush, otherwise bdflush will deadlock if there are too
4634 	 * many dirty RAID5 blocks.
4635 	 */
4636 
4637 	current->flags |= PF_NOFREEZE;
4638 	allow_signal(SIGKILL);
4639 	while (!kthread_should_stop()) {
4640 
4641 		/* We need to wait INTERRUPTIBLE so that
4642 		 * we don't add to the load-average.
4643 		 * That means we need to be sure no signals are
4644 		 * pending
4645 		 */
4646 		if (signal_pending(current))
4647 			flush_signals(current);
4648 
4649 		wait_event_interruptible_timeout
4650 			(thread->wqueue,
4651 			 test_bit(THREAD_WAKEUP, &thread->flags)
4652 			 || kthread_should_stop(),
4653 			 thread->timeout);
4654 
4655 		clear_bit(THREAD_WAKEUP, &thread->flags);
4656 
4657 		thread->run(thread->mddev);
4658 	}
4659 
4660 	return 0;
4661 }
4662 
4663 void md_wakeup_thread(mdk_thread_t *thread)
4664 {
4665 	if (thread) {
4666 		dprintk("md: waking up MD thread %s.\n", thread->tsk->comm);
4667 		set_bit(THREAD_WAKEUP, &thread->flags);
4668 		wake_up(&thread->wqueue);
4669 	}
4670 }
4671 
4672 mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
4673 				 const char *name)
4674 {
4675 	mdk_thread_t *thread;
4676 
4677 	thread = kzalloc(sizeof(mdk_thread_t), GFP_KERNEL);
4678 	if (!thread)
4679 		return NULL;
4680 
4681 	init_waitqueue_head(&thread->wqueue);
4682 
4683 	thread->run = run;
4684 	thread->mddev = mddev;
4685 	thread->timeout = MAX_SCHEDULE_TIMEOUT;
4686 	thread->tsk = kthread_run(md_thread, thread, name, mdname(thread->mddev));
4687 	if (IS_ERR(thread->tsk)) {
4688 		kfree(thread);
4689 		return NULL;
4690 	}
4691 	return thread;
4692 }
4693 
4694 void md_unregister_thread(mdk_thread_t *thread)
4695 {
4696 	dprintk("interrupting MD-thread pid %d\n", thread->tsk->pid);
4697 
4698 	kthread_stop(thread->tsk);
4699 	kfree(thread);
4700 }
4701 
4702 void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
4703 {
4704 	if (!mddev) {
4705 		MD_BUG();
4706 		return;
4707 	}
4708 
4709 	if (!rdev || test_bit(Faulty, &rdev->flags))
4710 		return;
4711 /*
4712 	dprintk("md_error dev:%s, rdev:(%d:%d), (caller: %p,%p,%p,%p).\n",
4713 		mdname(mddev),
4714 		MAJOR(rdev->bdev->bd_dev), MINOR(rdev->bdev->bd_dev),
4715 		__builtin_return_address(0),__builtin_return_address(1),
4716 		__builtin_return_address(2),__builtin_return_address(3));
4717 */
4718 	if (!mddev->pers)
4719 		return;
4720 	if (!mddev->pers->error_handler)
4721 		return;
4722 	mddev->pers->error_handler(mddev,rdev);
4723 	set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4724 	set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4725 	md_wakeup_thread(mddev->thread);
4726 	md_new_event_inintr(mddev);
4727 }
4728 
4729 /* seq_file implementation /proc/mdstat */
4730 
4731 static void status_unused(struct seq_file *seq)
4732 {
4733 	int i = 0;
4734 	mdk_rdev_t *rdev;
4735 	struct list_head *tmp;
4736 
4737 	seq_printf(seq, "unused devices: ");
4738 
4739 	ITERATE_RDEV_PENDING(rdev,tmp) {
4740 		char b[BDEVNAME_SIZE];
4741 		i++;
4742 		seq_printf(seq, "%s ",
4743 			      bdevname(rdev->bdev,b));
4744 	}
4745 	if (!i)
4746 		seq_printf(seq, "<none>");
4747 
4748 	seq_printf(seq, "\n");
4749 }
4750 
4751 
4752 static void status_resync(struct seq_file *seq, mddev_t * mddev)
4753 {
4754 	sector_t max_blocks, resync, res;
4755 	unsigned long dt, db, rt;
4756 	int scale;
4757 	unsigned int per_milli;
4758 
4759 	resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
4760 
4761 	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
4762 		max_blocks = mddev->resync_max_sectors >> 1;
4763 	else
4764 		max_blocks = mddev->size;
4765 
4766 	/*
4767 	 * Should not happen.
4768 	 */
4769 	if (!max_blocks) {
4770 		MD_BUG();
4771 		return;
4772 	}
4773 	/* Pick 'scale' such that (resync>>scale)*1000 will fit
4774 	 * in a sector_t, and (max_blocks>>scale) will fit in a
4775 	 * u32, as those are the requirements for sector_div.
4776 	 * Thus 'scale' must be at least 10
4777 	 */
4778 	scale = 10;
4779 	if (sizeof(sector_t) > sizeof(unsigned long)) {
4780 		while ( max_blocks/2 > (1ULL<<(scale+32)))
4781 			scale++;
4782 	}
4783 	res = (resync>>scale)*1000;
4784 	sector_div(res, (u32)((max_blocks>>scale)+1));
4785 
4786 	per_milli = res;
4787 	{
4788 		int i, x = per_milli/50, y = 20-x;
4789 		seq_printf(seq, "[");
4790 		for (i = 0; i < x; i++)
4791 			seq_printf(seq, "=");
4792 		seq_printf(seq, ">");
4793 		for (i = 0; i < y; i++)
4794 			seq_printf(seq, ".");
4795 		seq_printf(seq, "] ");
4796 	}
4797 	seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
4798 		   (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
4799 		    "reshape" :
4800 		    (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
4801 		     "check" :
4802 		     (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
4803 		      "resync" : "recovery"))),
4804 		   per_milli/10, per_milli % 10,
4805 		   (unsigned long long) resync,
4806 		   (unsigned long long) max_blocks);
4807 
4808 	/*
4809 	 * We do not want to overflow, so the order of operands and
4810 	 * the * 100 / 100 trick are important. We do a +1 to be
4811 	 * safe against division by zero. We only estimate anyway.
4812 	 *
4813 	 * dt: time from mark until now
4814 	 * db: blocks written from mark until now
4815 	 * rt: remaining time
4816 	 */
4817 	dt = ((jiffies - mddev->resync_mark) / HZ);
4818 	if (!dt) dt++;
4819 	db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
4820 		- mddev->resync_mark_cnt;
4821 	rt = (dt * ((unsigned long)(max_blocks-resync) / (db/2/100+1)))/100;
4822 
4823 	seq_printf(seq, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
4824 
4825 	seq_printf(seq, " speed=%ldK/sec", db/2/dt);
4826 }
4827 
4828 static void *md_seq_start(struct seq_file *seq, loff_t *pos)
4829 {
4830 	struct list_head *tmp;
4831 	loff_t l = *pos;
4832 	mddev_t *mddev;
4833 
4834 	if (l >= 0x10000)
4835 		return NULL;
4836 	if (!l--)
4837 		/* header */
4838 		return (void*)1;
4839 
4840 	spin_lock(&all_mddevs_lock);
4841 	list_for_each(tmp,&all_mddevs)
4842 		if (!l--) {
4843 			mddev = list_entry(tmp, mddev_t, all_mddevs);
4844 			mddev_get(mddev);
4845 			spin_unlock(&all_mddevs_lock);
4846 			return mddev;
4847 		}
4848 	spin_unlock(&all_mddevs_lock);
4849 	if (!l--)
4850 		return (void*)2;/* tail */
4851 	return NULL;
4852 }
4853 
4854 static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4855 {
4856 	struct list_head *tmp;
4857 	mddev_t *next_mddev, *mddev = v;
4858 
4859 	++*pos;
4860 	if (v == (void*)2)
4861 		return NULL;
4862 
4863 	spin_lock(&all_mddevs_lock);
4864 	if (v == (void*)1)
4865 		tmp = all_mddevs.next;
4866 	else
4867 		tmp = mddev->all_mddevs.next;
4868 	if (tmp != &all_mddevs)
4869 		next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs));
4870 	else {
4871 		next_mddev = (void*)2;
4872 		*pos = 0x10000;
4873 	}
4874 	spin_unlock(&all_mddevs_lock);
4875 
4876 	if (v != (void*)1)
4877 		mddev_put(mddev);
4878 	return next_mddev;
4879 
4880 }
4881 
4882 static void md_seq_stop(struct seq_file *seq, void *v)
4883 {
4884 	mddev_t *mddev = v;
4885 
4886 	if (mddev && v != (void*)1 && v != (void*)2)
4887 		mddev_put(mddev);
4888 }
4889 
4890 struct mdstat_info {
4891 	int event;
4892 };
4893 
4894 static int md_seq_show(struct seq_file *seq, void *v)
4895 {
4896 	mddev_t *mddev = v;
4897 	sector_t size;
4898 	struct list_head *tmp2;
4899 	mdk_rdev_t *rdev;
4900 	struct mdstat_info *mi = seq->private;
4901 	struct bitmap *bitmap;
4902 
4903 	if (v == (void*)1) {
4904 		struct mdk_personality *pers;
4905 		seq_printf(seq, "Personalities : ");
4906 		spin_lock(&pers_lock);
4907 		list_for_each_entry(pers, &pers_list, list)
4908 			seq_printf(seq, "[%s] ", pers->name);
4909 
4910 		spin_unlock(&pers_lock);
4911 		seq_printf(seq, "\n");
4912 		mi->event = atomic_read(&md_event_count);
4913 		return 0;
4914 	}
4915 	if (v == (void*)2) {
4916 		status_unused(seq);
4917 		return 0;
4918 	}
4919 
4920 	if (mddev_lock(mddev) < 0)
4921 		return -EINTR;
4922 
4923 	if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
4924 		seq_printf(seq, "%s : %sactive", mdname(mddev),
4925 						mddev->pers ? "" : "in");
4926 		if (mddev->pers) {
4927 			if (mddev->ro==1)
4928 				seq_printf(seq, " (read-only)");
4929 			if (mddev->ro==2)
4930 				seq_printf(seq, "(auto-read-only)");
4931 			seq_printf(seq, " %s", mddev->pers->name);
4932 		}
4933 
4934 		size = 0;
4935 		ITERATE_RDEV(mddev,rdev,tmp2) {
4936 			char b[BDEVNAME_SIZE];
4937 			seq_printf(seq, " %s[%d]",
4938 				bdevname(rdev->bdev,b), rdev->desc_nr);
4939 			if (test_bit(WriteMostly, &rdev->flags))
4940 				seq_printf(seq, "(W)");
4941 			if (test_bit(Faulty, &rdev->flags)) {
4942 				seq_printf(seq, "(F)");
4943 				continue;
4944 			} else if (rdev->raid_disk < 0)
4945 				seq_printf(seq, "(S)"); /* spare */
4946 			size += rdev->size;
4947 		}
4948 
4949 		if (!list_empty(&mddev->disks)) {
4950 			if (mddev->pers)
4951 				seq_printf(seq, "\n      %llu blocks",
4952 					(unsigned long long)mddev->array_size);
4953 			else
4954 				seq_printf(seq, "\n      %llu blocks",
4955 					(unsigned long long)size);
4956 		}
4957 		if (mddev->persistent) {
4958 			if (mddev->major_version != 0 ||
4959 			    mddev->minor_version != 90) {
4960 				seq_printf(seq," super %d.%d",
4961 					   mddev->major_version,
4962 					   mddev->minor_version);
4963 			}
4964 		} else
4965 			seq_printf(seq, " super non-persistent");
4966 
4967 		if (mddev->pers) {
4968 			mddev->pers->status (seq, mddev);
4969 	 		seq_printf(seq, "\n      ");
4970 			if (mddev->pers->sync_request) {
4971 				if (mddev->curr_resync > 2) {
4972 					status_resync (seq, mddev);
4973 					seq_printf(seq, "\n      ");
4974 				} else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
4975 					seq_printf(seq, "\tresync=DELAYED\n      ");
4976 				else if (mddev->recovery_cp < MaxSector)
4977 					seq_printf(seq, "\tresync=PENDING\n      ");
4978 			}
4979 		} else
4980 			seq_printf(seq, "\n       ");
4981 
4982 		if ((bitmap = mddev->bitmap)) {
4983 			unsigned long chunk_kb;
4984 			unsigned long flags;
4985 			spin_lock_irqsave(&bitmap->lock, flags);
4986 			chunk_kb = bitmap->chunksize >> 10;
4987 			seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "
4988 				"%lu%s chunk",
4989 				bitmap->pages - bitmap->missing_pages,
4990 				bitmap->pages,
4991 				(bitmap->pages - bitmap->missing_pages)
4992 					<< (PAGE_SHIFT - 10),
4993 				chunk_kb ? chunk_kb : bitmap->chunksize,
4994 				chunk_kb ? "KB" : "B");
4995 			if (bitmap->file) {
4996 				seq_printf(seq, ", file: ");
4997 				seq_path(seq, bitmap->file->f_path.mnt,
4998 					 bitmap->file->f_path.dentry," \t\n");
4999 			}
5000 
5001 			seq_printf(seq, "\n");
5002 			spin_unlock_irqrestore(&bitmap->lock, flags);
5003 		}
5004 
5005 		seq_printf(seq, "\n");
5006 	}
5007 	mddev_unlock(mddev);
5008 
5009 	return 0;
5010 }
5011 
5012 static struct seq_operations md_seq_ops = {
5013 	.start  = md_seq_start,
5014 	.next   = md_seq_next,
5015 	.stop   = md_seq_stop,
5016 	.show   = md_seq_show,
5017 };
5018 
5019 static int md_seq_open(struct inode *inode, struct file *file)
5020 {
5021 	int error;
5022 	struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL);
5023 	if (mi == NULL)
5024 		return -ENOMEM;
5025 
5026 	error = seq_open(file, &md_seq_ops);
5027 	if (error)
5028 		kfree(mi);
5029 	else {
5030 		struct seq_file *p = file->private_data;
5031 		p->private = mi;
5032 		mi->event = atomic_read(&md_event_count);
5033 	}
5034 	return error;
5035 }
5036 
5037 static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
5038 {
5039 	struct seq_file *m = filp->private_data;
5040 	struct mdstat_info *mi = m->private;
5041 	int mask;
5042 
5043 	poll_wait(filp, &md_event_waiters, wait);
5044 
5045 	/* always allow read */
5046 	mask = POLLIN | POLLRDNORM;
5047 
5048 	if (mi->event != atomic_read(&md_event_count))
5049 		mask |= POLLERR | POLLPRI;
5050 	return mask;
5051 }
5052 
5053 static const struct file_operations md_seq_fops = {
5054 	.owner		= THIS_MODULE,
5055 	.open           = md_seq_open,
5056 	.read           = seq_read,
5057 	.llseek         = seq_lseek,
5058 	.release	= seq_release_private,
5059 	.poll		= mdstat_poll,
5060 };
5061 
5062 int register_md_personality(struct mdk_personality *p)
5063 {
5064 	spin_lock(&pers_lock);
5065 	list_add_tail(&p->list, &pers_list);
5066 	printk(KERN_INFO "md: %s personality registered for level %d\n", p->name, p->level);
5067 	spin_unlock(&pers_lock);
5068 	return 0;
5069 }
5070 
5071 int unregister_md_personality(struct mdk_personality *p)
5072 {
5073 	printk(KERN_INFO "md: %s personality unregistered\n", p->name);
5074 	spin_lock(&pers_lock);
5075 	list_del_init(&p->list);
5076 	spin_unlock(&pers_lock);
5077 	return 0;
5078 }
5079 
5080 static int is_mddev_idle(mddev_t *mddev)
5081 {
5082 	mdk_rdev_t * rdev;
5083 	struct list_head *tmp;
5084 	int idle;
5085 	unsigned long curr_events;
5086 
5087 	idle = 1;
5088 	ITERATE_RDEV(mddev,rdev,tmp) {
5089 		struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
5090 		curr_events = disk_stat_read(disk, sectors[0]) +
5091 				disk_stat_read(disk, sectors[1]) -
5092 				atomic_read(&disk->sync_io);
5093 		/* The difference between curr_events and last_events
5094 		 * will be affected by any new non-sync IO (making
5095 		 * curr_events bigger) and any difference in the amount of
5096 		 * in-flight syncio (making current_events bigger or smaller)
5097 		 * The amount in-flight is currently limited to
5098 		 * 32*64K in raid1/10 and 256*PAGE_SIZE in raid5/6
5099 		 * which is at most 4096 sectors.
5100 		 * These numbers are fairly fragile and should be made
5101 		 * more robust, probably by enforcing the
5102 		 * 'window size' that md_do_sync sort-of uses.
5103 		 *
5104 		 * Note: the following is an unsigned comparison.
5105 		 */
5106 		if ((long)curr_events - (long)rdev->last_events > 4096) {
5107 			rdev->last_events = curr_events;
5108 			idle = 0;
5109 		}
5110 	}
5111 	return idle;
5112 }
5113 
5114 void md_done_sync(mddev_t *mddev, int blocks, int ok)
5115 {
5116 	/* another "blocks" (512byte) blocks have been synced */
5117 	atomic_sub(blocks, &mddev->recovery_active);
5118 	wake_up(&mddev->recovery_wait);
5119 	if (!ok) {
5120 		set_bit(MD_RECOVERY_ERR, &mddev->recovery);
5121 		md_wakeup_thread(mddev->thread);
5122 		// stop recovery, signal do_sync ....
5123 	}
5124 }
5125 
5126 
5127 /* md_write_start(mddev, bi)
5128  * If we need to update some array metadata (e.g. 'active' flag
5129  * in superblock) before writing, schedule a superblock update
5130  * and wait for it to complete.
5131  */
5132 void md_write_start(mddev_t *mddev, struct bio *bi)
5133 {
5134 	if (bio_data_dir(bi) != WRITE)
5135 		return;
5136 
5137 	BUG_ON(mddev->ro == 1);
5138 	if (mddev->ro == 2) {
5139 		/* need to switch to read/write */
5140 		mddev->ro = 0;
5141 		set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5142 		md_wakeup_thread(mddev->thread);
5143 	}
5144 	atomic_inc(&mddev->writes_pending);
5145 	if (mddev->in_sync) {
5146 		spin_lock_irq(&mddev->write_lock);
5147 		if (mddev->in_sync) {
5148 			mddev->in_sync = 0;
5149 			set_bit(MD_CHANGE_CLEAN, &mddev->flags);
5150 			md_wakeup_thread(mddev->thread);
5151 		}
5152 		spin_unlock_irq(&mddev->write_lock);
5153 	}
5154 	wait_event(mddev->sb_wait, mddev->flags==0);
5155 }
5156 
5157 void md_write_end(mddev_t *mddev)
5158 {
5159 	if (atomic_dec_and_test(&mddev->writes_pending)) {
5160 		if (mddev->safemode == 2)
5161 			md_wakeup_thread(mddev->thread);
5162 		else if (mddev->safemode_delay)
5163 			mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
5164 	}
5165 }
5166 
5167 /* md_allow_write(mddev)
5168  * Calling this ensures that the array is marked 'active' so that writes
5169  * may proceed without blocking.  It is important to call this before
5170  * attempting a GFP_KERNEL allocation while holding the mddev lock.
5171  * Must be called with mddev_lock held.
5172  */
5173 void md_allow_write(mddev_t *mddev)
5174 {
5175 	if (!mddev->pers)
5176 		return;
5177 	if (mddev->ro)
5178 		return;
5179 
5180 	spin_lock_irq(&mddev->write_lock);
5181 	if (mddev->in_sync) {
5182 		mddev->in_sync = 0;
5183 		set_bit(MD_CHANGE_CLEAN, &mddev->flags);
5184 		if (mddev->safemode_delay &&
5185 		    mddev->safemode == 0)
5186 			mddev->safemode = 1;
5187 		spin_unlock_irq(&mddev->write_lock);
5188 		md_update_sb(mddev, 0);
5189 	} else
5190 		spin_unlock_irq(&mddev->write_lock);
5191 }
5192 EXPORT_SYMBOL_GPL(md_allow_write);
5193 
5194 static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
5195 
5196 #define SYNC_MARKS	10
5197 #define	SYNC_MARK_STEP	(3*HZ)
5198 void md_do_sync(mddev_t *mddev)
5199 {
5200 	mddev_t *mddev2;
5201 	unsigned int currspeed = 0,
5202 		 window;
5203 	sector_t max_sectors,j, io_sectors;
5204 	unsigned long mark[SYNC_MARKS];
5205 	sector_t mark_cnt[SYNC_MARKS];
5206 	int last_mark,m;
5207 	struct list_head *tmp;
5208 	sector_t last_check;
5209 	int skipped = 0;
5210 	struct list_head *rtmp;
5211 	mdk_rdev_t *rdev;
5212 	char *desc;
5213 
5214 	/* just incase thread restarts... */
5215 	if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
5216 		return;
5217 	if (mddev->ro) /* never try to sync a read-only array */
5218 		return;
5219 
5220 	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
5221 		if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
5222 			desc = "data-check";
5223 		else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
5224 			desc = "requested-resync";
5225 		else
5226 			desc = "resync";
5227 	} else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
5228 		desc = "reshape";
5229 	else
5230 		desc = "recovery";
5231 
5232 	/* we overload curr_resync somewhat here.
5233 	 * 0 == not engaged in resync at all
5234 	 * 2 == checking that there is no conflict with another sync
5235 	 * 1 == like 2, but have yielded to allow conflicting resync to
5236 	 *		commense
5237 	 * other == active in resync - this many blocks
5238 	 *
5239 	 * Before starting a resync we must have set curr_resync to
5240 	 * 2, and then checked that every "conflicting" array has curr_resync
5241 	 * less than ours.  When we find one that is the same or higher
5242 	 * we wait on resync_wait.  To avoid deadlock, we reduce curr_resync
5243 	 * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
5244 	 * This will mean we have to start checking from the beginning again.
5245 	 *
5246 	 */
5247 
5248 	do {
5249 		mddev->curr_resync = 2;
5250 
5251 	try_again:
5252 		if (kthread_should_stop()) {
5253 			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5254 			goto skip;
5255 		}
5256 		ITERATE_MDDEV(mddev2,tmp) {
5257 			if (mddev2 == mddev)
5258 				continue;
5259 			if (mddev2->curr_resync &&
5260 			    match_mddev_units(mddev,mddev2)) {
5261 				DEFINE_WAIT(wq);
5262 				if (mddev < mddev2 && mddev->curr_resync == 2) {
5263 					/* arbitrarily yield */
5264 					mddev->curr_resync = 1;
5265 					wake_up(&resync_wait);
5266 				}
5267 				if (mddev > mddev2 && mddev->curr_resync == 1)
5268 					/* no need to wait here, we can wait the next
5269 					 * time 'round when curr_resync == 2
5270 					 */
5271 					continue;
5272 				prepare_to_wait(&resync_wait, &wq, TASK_UNINTERRUPTIBLE);
5273 				if (!kthread_should_stop() &&
5274 				    mddev2->curr_resync >= mddev->curr_resync) {
5275 					printk(KERN_INFO "md: delaying %s of %s"
5276 					       " until %s has finished (they"
5277 					       " share one or more physical units)\n",
5278 					       desc, mdname(mddev), mdname(mddev2));
5279 					mddev_put(mddev2);
5280 					schedule();
5281 					finish_wait(&resync_wait, &wq);
5282 					goto try_again;
5283 				}
5284 				finish_wait(&resync_wait, &wq);
5285 			}
5286 		}
5287 	} while (mddev->curr_resync < 2);
5288 
5289 	j = 0;
5290 	if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
5291 		/* resync follows the size requested by the personality,
5292 		 * which defaults to physical size, but can be virtual size
5293 		 */
5294 		max_sectors = mddev->resync_max_sectors;
5295 		mddev->resync_mismatches = 0;
5296 		/* we don't use the checkpoint if there's a bitmap */
5297 		if (!mddev->bitmap &&
5298 		    !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
5299 			j = mddev->recovery_cp;
5300 	} else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
5301 		max_sectors = mddev->size << 1;
5302 	else {
5303 		/* recovery follows the physical size of devices */
5304 		max_sectors = mddev->size << 1;
5305 		j = MaxSector;
5306 		ITERATE_RDEV(mddev,rdev,rtmp)
5307 			if (rdev->raid_disk >= 0 &&
5308 			    !test_bit(Faulty, &rdev->flags) &&
5309 			    !test_bit(In_sync, &rdev->flags) &&
5310 			    rdev->recovery_offset < j)
5311 				j = rdev->recovery_offset;
5312 	}
5313 
5314 	printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
5315 	printk(KERN_INFO "md: minimum _guaranteed_  speed:"
5316 		" %d KB/sec/disk.\n", speed_min(mddev));
5317 	printk(KERN_INFO "md: using maximum available idle IO bandwidth "
5318 	       "(but not more than %d KB/sec) for %s.\n",
5319 	       speed_max(mddev), desc);
5320 
5321 	is_mddev_idle(mddev); /* this also initializes IO event counters */
5322 
5323 	io_sectors = 0;
5324 	for (m = 0; m < SYNC_MARKS; m++) {
5325 		mark[m] = jiffies;
5326 		mark_cnt[m] = io_sectors;
5327 	}
5328 	last_mark = 0;
5329 	mddev->resync_mark = mark[last_mark];
5330 	mddev->resync_mark_cnt = mark_cnt[last_mark];
5331 
5332 	/*
5333 	 * Tune reconstruction:
5334 	 */
5335 	window = 32*(PAGE_SIZE/512);
5336 	printk(KERN_INFO "md: using %dk window, over a total of %llu blocks.\n",
5337 		window/2,(unsigned long long) max_sectors/2);
5338 
5339 	atomic_set(&mddev->recovery_active, 0);
5340 	init_waitqueue_head(&mddev->recovery_wait);
5341 	last_check = 0;
5342 
5343 	if (j>2) {
5344 		printk(KERN_INFO
5345 		       "md: resuming %s of %s from checkpoint.\n",
5346 		       desc, mdname(mddev));
5347 		mddev->curr_resync = j;
5348 	}
5349 
5350 	while (j < max_sectors) {
5351 		sector_t sectors;
5352 
5353 		skipped = 0;
5354 		sectors = mddev->pers->sync_request(mddev, j, &skipped,
5355 					    currspeed < speed_min(mddev));
5356 		if (sectors == 0) {
5357 			set_bit(MD_RECOVERY_ERR, &mddev->recovery);
5358 			goto out;
5359 		}
5360 
5361 		if (!skipped) { /* actual IO requested */
5362 			io_sectors += sectors;
5363 			atomic_add(sectors, &mddev->recovery_active);
5364 		}
5365 
5366 		j += sectors;
5367 		if (j>1) mddev->curr_resync = j;
5368 		mddev->curr_mark_cnt = io_sectors;
5369 		if (last_check == 0)
5370 			/* this is the earliers that rebuilt will be
5371 			 * visible in /proc/mdstat
5372 			 */
5373 			md_new_event(mddev);
5374 
5375 		if (last_check + window > io_sectors || j == max_sectors)
5376 			continue;
5377 
5378 		last_check = io_sectors;
5379 
5380 		if (test_bit(MD_RECOVERY_INTR, &mddev->recovery) ||
5381 		    test_bit(MD_RECOVERY_ERR, &mddev->recovery))
5382 			break;
5383 
5384 	repeat:
5385 		if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
5386 			/* step marks */
5387 			int next = (last_mark+1) % SYNC_MARKS;
5388 
5389 			mddev->resync_mark = mark[next];
5390 			mddev->resync_mark_cnt = mark_cnt[next];
5391 			mark[next] = jiffies;
5392 			mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
5393 			last_mark = next;
5394 		}
5395 
5396 
5397 		if (kthread_should_stop()) {
5398 			/*
5399 			 * got a signal, exit.
5400 			 */
5401 			printk(KERN_INFO
5402 				"md: md_do_sync() got signal ... exiting\n");
5403 			set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5404 			goto out;
5405 		}
5406 
5407 		/*
5408 		 * this loop exits only if either when we are slower than
5409 		 * the 'hard' speed limit, or the system was IO-idle for
5410 		 * a jiffy.
5411 		 * the system might be non-idle CPU-wise, but we only care
5412 		 * about not overloading the IO subsystem. (things like an
5413 		 * e2fsck being done on the RAID array should execute fast)
5414 		 */
5415 		mddev->queue->unplug_fn(mddev->queue);
5416 		cond_resched();
5417 
5418 		currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
5419 			/((jiffies-mddev->resync_mark)/HZ +1) +1;
5420 
5421 		if (currspeed > speed_min(mddev)) {
5422 			if ((currspeed > speed_max(mddev)) ||
5423 					!is_mddev_idle(mddev)) {
5424 				msleep(500);
5425 				goto repeat;
5426 			}
5427 		}
5428 	}
5429 	printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc);
5430 	/*
5431 	 * this also signals 'finished resyncing' to md_stop
5432 	 */
5433  out:
5434 	mddev->queue->unplug_fn(mddev->queue);
5435 
5436 	wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
5437 
5438 	/* tell personality that we are finished */
5439 	mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
5440 
5441 	if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
5442 	    !test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
5443 	    mddev->curr_resync > 2) {
5444 		if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
5445 			if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
5446 				if (mddev->curr_resync >= mddev->recovery_cp) {
5447 					printk(KERN_INFO
5448 					       "md: checkpointing %s of %s.\n",
5449 					       desc, mdname(mddev));
5450 					mddev->recovery_cp = mddev->curr_resync;
5451 				}
5452 			} else
5453 				mddev->recovery_cp = MaxSector;
5454 		} else {
5455 			if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
5456 				mddev->curr_resync = MaxSector;
5457 			ITERATE_RDEV(mddev,rdev,rtmp)
5458 				if (rdev->raid_disk >= 0 &&
5459 				    !test_bit(Faulty, &rdev->flags) &&
5460 				    !test_bit(In_sync, &rdev->flags) &&
5461 				    rdev->recovery_offset < mddev->curr_resync)
5462 					rdev->recovery_offset = mddev->curr_resync;
5463 		}
5464 	}
5465 	set_bit(MD_CHANGE_DEVS, &mddev->flags);
5466 
5467  skip:
5468 	mddev->curr_resync = 0;
5469 	wake_up(&resync_wait);
5470 	set_bit(MD_RECOVERY_DONE, &mddev->recovery);
5471 	md_wakeup_thread(mddev->thread);
5472 }
5473 EXPORT_SYMBOL_GPL(md_do_sync);
5474 
5475 
5476 static int remove_and_add_spares(mddev_t *mddev)
5477 {
5478 	mdk_rdev_t *rdev;
5479 	struct list_head *rtmp;
5480 	int spares = 0;
5481 
5482 	ITERATE_RDEV(mddev,rdev,rtmp)
5483 		if (rdev->raid_disk >= 0 &&
5484 		    (test_bit(Faulty, &rdev->flags) ||
5485 		     ! test_bit(In_sync, &rdev->flags)) &&
5486 		    atomic_read(&rdev->nr_pending)==0) {
5487 			if (mddev->pers->hot_remove_disk(
5488 				    mddev, rdev->raid_disk)==0) {
5489 				char nm[20];
5490 				sprintf(nm,"rd%d", rdev->raid_disk);
5491 				sysfs_remove_link(&mddev->kobj, nm);
5492 				rdev->raid_disk = -1;
5493 			}
5494 		}
5495 
5496 	if (mddev->degraded) {
5497 		ITERATE_RDEV(mddev,rdev,rtmp)
5498 			if (rdev->raid_disk < 0
5499 			    && !test_bit(Faulty, &rdev->flags)) {
5500 				rdev->recovery_offset = 0;
5501 				if (mddev->pers->hot_add_disk(mddev,rdev)) {
5502 					char nm[20];
5503 					sprintf(nm, "rd%d", rdev->raid_disk);
5504 					if (sysfs_create_link(&mddev->kobj,
5505 							      &rdev->kobj, nm))
5506 						printk(KERN_WARNING
5507 						       "md: cannot register "
5508 						       "%s for %s\n",
5509 						       nm, mdname(mddev));
5510 					spares++;
5511 					md_new_event(mddev);
5512 				} else
5513 					break;
5514 			}
5515 	}
5516 	return spares;
5517 }
5518 /*
5519  * This routine is regularly called by all per-raid-array threads to
5520  * deal with generic issues like resync and super-block update.
5521  * Raid personalities that don't have a thread (linear/raid0) do not
5522  * need this as they never do any recovery or update the superblock.
5523  *
5524  * It does not do any resync itself, but rather "forks" off other threads
5525  * to do that as needed.
5526  * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
5527  * "->recovery" and create a thread at ->sync_thread.
5528  * When the thread finishes it sets MD_RECOVERY_DONE (and might set MD_RECOVERY_ERR)
5529  * and wakeups up this thread which will reap the thread and finish up.
5530  * This thread also removes any faulty devices (with nr_pending == 0).
5531  *
5532  * The overall approach is:
5533  *  1/ if the superblock needs updating, update it.
5534  *  2/ If a recovery thread is running, don't do anything else.
5535  *  3/ If recovery has finished, clean up, possibly marking spares active.
5536  *  4/ If there are any faulty devices, remove them.
5537  *  5/ If array is degraded, try to add spares devices
5538  *  6/ If array has spares or is not in-sync, start a resync thread.
5539  */
5540 void md_check_recovery(mddev_t *mddev)
5541 {
5542 	mdk_rdev_t *rdev;
5543 	struct list_head *rtmp;
5544 
5545 
5546 	if (mddev->bitmap)
5547 		bitmap_daemon_work(mddev->bitmap);
5548 
5549 	if (mddev->ro)
5550 		return;
5551 
5552 	if (signal_pending(current)) {
5553 		if (mddev->pers->sync_request) {
5554 			printk(KERN_INFO "md: %s in immediate safe mode\n",
5555 			       mdname(mddev));
5556 			mddev->safemode = 2;
5557 		}
5558 		flush_signals(current);
5559 	}
5560 
5561 	if ( ! (
5562 		mddev->flags ||
5563 		test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
5564 		test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
5565 		(mddev->safemode == 1) ||
5566 		(mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
5567 		 && !mddev->in_sync && mddev->recovery_cp == MaxSector)
5568 		))
5569 		return;
5570 
5571 	if (mddev_trylock(mddev)) {
5572 		int spares = 0;
5573 
5574 		spin_lock_irq(&mddev->write_lock);
5575 		if (mddev->safemode && !atomic_read(&mddev->writes_pending) &&
5576 		    !mddev->in_sync && mddev->recovery_cp == MaxSector) {
5577 			mddev->in_sync = 1;
5578 			set_bit(MD_CHANGE_CLEAN, &mddev->flags);
5579 		}
5580 		if (mddev->safemode == 1)
5581 			mddev->safemode = 0;
5582 		spin_unlock_irq(&mddev->write_lock);
5583 
5584 		if (mddev->flags)
5585 			md_update_sb(mddev, 0);
5586 
5587 
5588 		if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
5589 		    !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
5590 			/* resync/recovery still happening */
5591 			clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5592 			goto unlock;
5593 		}
5594 		if (mddev->sync_thread) {
5595 			/* resync has finished, collect result */
5596 			md_unregister_thread(mddev->sync_thread);
5597 			mddev->sync_thread = NULL;
5598 			if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
5599 			    !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
5600 				/* success...*/
5601 				/* activate any spares */
5602 				mddev->pers->spare_active(mddev);
5603 			}
5604 			md_update_sb(mddev, 1);
5605 
5606 			/* if array is no-longer degraded, then any saved_raid_disk
5607 			 * information must be scrapped
5608 			 */
5609 			if (!mddev->degraded)
5610 				ITERATE_RDEV(mddev,rdev,rtmp)
5611 					rdev->saved_raid_disk = -1;
5612 
5613 			mddev->recovery = 0;
5614 			/* flag recovery needed just to double check */
5615 			set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5616 			md_new_event(mddev);
5617 			goto unlock;
5618 		}
5619 		/* Clear some bits that don't mean anything, but
5620 		 * might be left set
5621 		 */
5622 		clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5623 		clear_bit(MD_RECOVERY_ERR, &mddev->recovery);
5624 		clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
5625 		clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
5626 
5627 		if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
5628 			goto unlock;
5629 		/* no recovery is running.
5630 		 * remove any failed drives, then
5631 		 * add spares if possible.
5632 		 * Spare are also removed and re-added, to allow
5633 		 * the personality to fail the re-add.
5634 		 */
5635 
5636 		if (mddev->reshape_position != MaxSector) {
5637 			if (mddev->pers->check_reshape(mddev) != 0)
5638 				/* Cannot proceed */
5639 				goto unlock;
5640 			set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
5641 		} else if ((spares = remove_and_add_spares(mddev))) {
5642 			clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
5643 			clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
5644 		} else if (mddev->recovery_cp < MaxSector) {
5645 			set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
5646 		} else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
5647 			/* nothing to be done ... */
5648 			goto unlock;
5649 
5650 		if (mddev->pers->sync_request) {
5651 			set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
5652 			if (spares && mddev->bitmap && ! mddev->bitmap->file) {
5653 				/* We are adding a device or devices to an array
5654 				 * which has the bitmap stored on all devices.
5655 				 * So make sure all bitmap pages get written
5656 				 */
5657 				bitmap_write_all(mddev->bitmap);
5658 			}
5659 			mddev->sync_thread = md_register_thread(md_do_sync,
5660 								mddev,
5661 								"%s_resync");
5662 			if (!mddev->sync_thread) {
5663 				printk(KERN_ERR "%s: could not start resync"
5664 					" thread...\n",
5665 					mdname(mddev));
5666 				/* leave the spares where they are, it shouldn't hurt */
5667 				mddev->recovery = 0;
5668 			} else
5669 				md_wakeup_thread(mddev->sync_thread);
5670 			md_new_event(mddev);
5671 		}
5672 	unlock:
5673 		mddev_unlock(mddev);
5674 	}
5675 }
5676 
5677 static int md_notify_reboot(struct notifier_block *this,
5678 			    unsigned long code, void *x)
5679 {
5680 	struct list_head *tmp;
5681 	mddev_t *mddev;
5682 
5683 	if ((code == SYS_DOWN) || (code == SYS_HALT) || (code == SYS_POWER_OFF)) {
5684 
5685 		printk(KERN_INFO "md: stopping all md devices.\n");
5686 
5687 		ITERATE_MDDEV(mddev,tmp)
5688 			if (mddev_trylock(mddev)) {
5689 				do_md_stop (mddev, 1);
5690 				mddev_unlock(mddev);
5691 			}
5692 		/*
5693 		 * certain more exotic SCSI devices are known to be
5694 		 * volatile wrt too early system reboots. While the
5695 		 * right place to handle this issue is the given
5696 		 * driver, we do want to have a safe RAID driver ...
5697 		 */
5698 		mdelay(1000*1);
5699 	}
5700 	return NOTIFY_DONE;
5701 }
5702 
5703 static struct notifier_block md_notifier = {
5704 	.notifier_call	= md_notify_reboot,
5705 	.next		= NULL,
5706 	.priority	= INT_MAX, /* before any real devices */
5707 };
5708 
5709 static void md_geninit(void)
5710 {
5711 	struct proc_dir_entry *p;
5712 
5713 	dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
5714 
5715 	p = create_proc_entry("mdstat", S_IRUGO, NULL);
5716 	if (p)
5717 		p->proc_fops = &md_seq_fops;
5718 }
5719 
5720 static int __init md_init(void)
5721 {
5722 	if (register_blkdev(MAJOR_NR, "md"))
5723 		return -1;
5724 	if ((mdp_major=register_blkdev(0, "mdp"))<=0) {
5725 		unregister_blkdev(MAJOR_NR, "md");
5726 		return -1;
5727 	}
5728 	blk_register_region(MKDEV(MAJOR_NR, 0), 1UL<<MINORBITS, THIS_MODULE,
5729 			    md_probe, NULL, NULL);
5730 	blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
5731 			    md_probe, NULL, NULL);
5732 
5733 	register_reboot_notifier(&md_notifier);
5734 	raid_table_header = register_sysctl_table(raid_root_table);
5735 
5736 	md_geninit();
5737 	return (0);
5738 }
5739 
5740 
5741 #ifndef MODULE
5742 
5743 /*
5744  * Searches all registered partitions for autorun RAID arrays
5745  * at boot time.
5746  */
5747 static dev_t detected_devices[128];
5748 static int dev_cnt;
5749 
5750 void md_autodetect_dev(dev_t dev)
5751 {
5752 	if (dev_cnt >= 0 && dev_cnt < 127)
5753 		detected_devices[dev_cnt++] = dev;
5754 }
5755 
5756 
5757 static void autostart_arrays(int part)
5758 {
5759 	mdk_rdev_t *rdev;
5760 	int i;
5761 
5762 	printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
5763 
5764 	for (i = 0; i < dev_cnt; i++) {
5765 		dev_t dev = detected_devices[i];
5766 
5767 		rdev = md_import_device(dev,0, 0);
5768 		if (IS_ERR(rdev))
5769 			continue;
5770 
5771 		if (test_bit(Faulty, &rdev->flags)) {
5772 			MD_BUG();
5773 			continue;
5774 		}
5775 		list_add(&rdev->same_set, &pending_raid_disks);
5776 	}
5777 	dev_cnt = 0;
5778 
5779 	autorun_devices(part);
5780 }
5781 
5782 #endif /* !MODULE */
5783 
5784 static __exit void md_exit(void)
5785 {
5786 	mddev_t *mddev;
5787 	struct list_head *tmp;
5788 
5789 	blk_unregister_region(MKDEV(MAJOR_NR,0), 1U << MINORBITS);
5790 	blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
5791 
5792 	unregister_blkdev(MAJOR_NR,"md");
5793 	unregister_blkdev(mdp_major, "mdp");
5794 	unregister_reboot_notifier(&md_notifier);
5795 	unregister_sysctl_table(raid_table_header);
5796 	remove_proc_entry("mdstat", NULL);
5797 	ITERATE_MDDEV(mddev,tmp) {
5798 		struct gendisk *disk = mddev->gendisk;
5799 		if (!disk)
5800 			continue;
5801 		export_array(mddev);
5802 		del_gendisk(disk);
5803 		put_disk(disk);
5804 		mddev->gendisk = NULL;
5805 		mddev_put(mddev);
5806 	}
5807 }
5808 
5809 module_init(md_init)
5810 module_exit(md_exit)
5811 
5812 static int get_ro(char *buffer, struct kernel_param *kp)
5813 {
5814 	return sprintf(buffer, "%d", start_readonly);
5815 }
5816 static int set_ro(const char *val, struct kernel_param *kp)
5817 {
5818 	char *e;
5819 	int num = simple_strtoul(val, &e, 10);
5820 	if (*val && (*e == '\0' || *e == '\n')) {
5821 		start_readonly = num;
5822 		return 0;
5823 	}
5824 	return -EINVAL;
5825 }
5826 
5827 module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
5828 module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
5829 
5830 
5831 EXPORT_SYMBOL(register_md_personality);
5832 EXPORT_SYMBOL(unregister_md_personality);
5833 EXPORT_SYMBOL(md_error);
5834 EXPORT_SYMBOL(md_done_sync);
5835 EXPORT_SYMBOL(md_write_start);
5836 EXPORT_SYMBOL(md_write_end);
5837 EXPORT_SYMBOL(md_register_thread);
5838 EXPORT_SYMBOL(md_unregister_thread);
5839 EXPORT_SYMBOL(md_wakeup_thread);
5840 EXPORT_SYMBOL(md_check_recovery);
5841 MODULE_LICENSE("GPL");
5842 MODULE_ALIAS("md");
5843 MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);
5844