aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/md/md.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/md/md.c')
-rw-r--r--drivers/md/md.c686
1 files changed, 363 insertions, 323 deletions
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 8e221a20f5d9..84acfe7d10e4 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -44,6 +44,7 @@
44#include <linux/hdreg.h> 44#include <linux/hdreg.h>
45#include <linux/proc_fs.h> 45#include <linux/proc_fs.h>
46#include <linux/random.h> 46#include <linux/random.h>
47#include <linux/module.h>
47#include <linux/reboot.h> 48#include <linux/reboot.h>
48#include <linux/file.h> 49#include <linux/file.h>
49#include <linux/compat.h> 50#include <linux/compat.h>
@@ -54,13 +55,15 @@
54#include "md.h" 55#include "md.h"
55#include "bitmap.h" 56#include "bitmap.h"
56 57
57#define DEBUG 0
58#define dprintk(x...) ((void)(DEBUG && printk(x)))
59
60#ifndef MODULE 58#ifndef MODULE
61static void autostart_arrays(int part); 59static void autostart_arrays(int part);
62#endif 60#endif
63 61
62/* pers_list is a list of registered personalities protected
63 * by pers_lock.
64 * pers_lock does extra service to protect accesses to
65 * mddev->thread when the mutex cannot be held.
66 */
64static LIST_HEAD(pers_list); 67static LIST_HEAD(pers_list);
65static DEFINE_SPINLOCK(pers_lock); 68static DEFINE_SPINLOCK(pers_lock);
66 69
@@ -93,13 +96,13 @@ static struct workqueue_struct *md_misc_wq;
93 96
94static int sysctl_speed_limit_min = 1000; 97static int sysctl_speed_limit_min = 1000;
95static int sysctl_speed_limit_max = 200000; 98static int sysctl_speed_limit_max = 200000;
96static inline int speed_min(mddev_t *mddev) 99static inline int speed_min(struct mddev *mddev)
97{ 100{
98 return mddev->sync_speed_min ? 101 return mddev->sync_speed_min ?
99 mddev->sync_speed_min : sysctl_speed_limit_min; 102 mddev->sync_speed_min : sysctl_speed_limit_min;
100} 103}
101 104
102static inline int speed_max(mddev_t *mddev) 105static inline int speed_max(struct mddev *mddev)
103{ 106{
104 return mddev->sync_speed_max ? 107 return mddev->sync_speed_max ?
105 mddev->sync_speed_max : sysctl_speed_limit_max; 108 mddev->sync_speed_max : sysctl_speed_limit_max;
@@ -155,7 +158,7 @@ static int start_readonly;
155 158
156static void mddev_bio_destructor(struct bio *bio) 159static void mddev_bio_destructor(struct bio *bio)
157{ 160{
158 mddev_t *mddev, **mddevp; 161 struct mddev *mddev, **mddevp;
159 162
160 mddevp = (void*)bio; 163 mddevp = (void*)bio;
161 mddev = mddevp[-1]; 164 mddev = mddevp[-1];
@@ -164,10 +167,10 @@ static void mddev_bio_destructor(struct bio *bio)
164} 167}
165 168
166struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs, 169struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
167 mddev_t *mddev) 170 struct mddev *mddev)
168{ 171{
169 struct bio *b; 172 struct bio *b;
170 mddev_t **mddevp; 173 struct mddev **mddevp;
171 174
172 if (!mddev || !mddev->bio_set) 175 if (!mddev || !mddev->bio_set)
173 return bio_alloc(gfp_mask, nr_iovecs); 176 return bio_alloc(gfp_mask, nr_iovecs);
@@ -184,10 +187,10 @@ struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
184EXPORT_SYMBOL_GPL(bio_alloc_mddev); 187EXPORT_SYMBOL_GPL(bio_alloc_mddev);
185 188
186struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask, 189struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
187 mddev_t *mddev) 190 struct mddev *mddev)
188{ 191{
189 struct bio *b; 192 struct bio *b;
190 mddev_t **mddevp; 193 struct mddev **mddevp;
191 194
192 if (!mddev || !mddev->bio_set) 195 if (!mddev || !mddev->bio_set)
193 return bio_clone(bio, gfp_mask); 196 return bio_clone(bio, gfp_mask);
@@ -276,7 +279,7 @@ EXPORT_SYMBOL_GPL(md_trim_bio);
276 */ 279 */
277static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters); 280static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
278static atomic_t md_event_count; 281static atomic_t md_event_count;
279void md_new_event(mddev_t *mddev) 282void md_new_event(struct mddev *mddev)
280{ 283{
281 atomic_inc(&md_event_count); 284 atomic_inc(&md_event_count);
282 wake_up(&md_event_waiters); 285 wake_up(&md_event_waiters);
@@ -286,7 +289,7 @@ EXPORT_SYMBOL_GPL(md_new_event);
286/* Alternate version that can be called from interrupts 289/* Alternate version that can be called from interrupts
287 * when calling sysfs_notify isn't needed. 290 * when calling sysfs_notify isn't needed.
288 */ 291 */
289static void md_new_event_inintr(mddev_t *mddev) 292static void md_new_event_inintr(struct mddev *mddev)
290{ 293{
291 atomic_inc(&md_event_count); 294 atomic_inc(&md_event_count);
292 wake_up(&md_event_waiters); 295 wake_up(&md_event_waiters);
@@ -307,19 +310,19 @@ static DEFINE_SPINLOCK(all_mddevs_lock);
307 * Any code which breaks out of this loop while own 310 * Any code which breaks out of this loop while own
308 * a reference to the current mddev and must mddev_put it. 311 * a reference to the current mddev and must mddev_put it.
309 */ 312 */
310#define for_each_mddev(mddev,tmp) \ 313#define for_each_mddev(_mddev,_tmp) \
311 \ 314 \
312 for (({ spin_lock(&all_mddevs_lock); \ 315 for (({ spin_lock(&all_mddevs_lock); \
313 tmp = all_mddevs.next; \ 316 _tmp = all_mddevs.next; \
314 mddev = NULL;}); \ 317 _mddev = NULL;}); \
315 ({ if (tmp != &all_mddevs) \ 318 ({ if (_tmp != &all_mddevs) \
316 mddev_get(list_entry(tmp, mddev_t, all_mddevs));\ 319 mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\
317 spin_unlock(&all_mddevs_lock); \ 320 spin_unlock(&all_mddevs_lock); \
318 if (mddev) mddev_put(mddev); \ 321 if (_mddev) mddev_put(_mddev); \
319 mddev = list_entry(tmp, mddev_t, all_mddevs); \ 322 _mddev = list_entry(_tmp, struct mddev, all_mddevs); \
320 tmp != &all_mddevs;}); \ 323 _tmp != &all_mddevs;}); \
321 ({ spin_lock(&all_mddevs_lock); \ 324 ({ spin_lock(&all_mddevs_lock); \
322 tmp = tmp->next;}) \ 325 _tmp = _tmp->next;}) \
323 ) 326 )
324 327
325 328
@@ -330,18 +333,17 @@ static DEFINE_SPINLOCK(all_mddevs_lock);
330 * call has finished, the bio has been linked into some internal structure 333 * call has finished, the bio has been linked into some internal structure
331 * and so is visible to ->quiesce(), so we don't need the refcount any more. 334 * and so is visible to ->quiesce(), so we don't need the refcount any more.
332 */ 335 */
333static int md_make_request(struct request_queue *q, struct bio *bio) 336static void md_make_request(struct request_queue *q, struct bio *bio)
334{ 337{
335 const int rw = bio_data_dir(bio); 338 const int rw = bio_data_dir(bio);
336 mddev_t *mddev = q->queuedata; 339 struct mddev *mddev = q->queuedata;
337 int rv;
338 int cpu; 340 int cpu;
339 unsigned int sectors; 341 unsigned int sectors;
340 342
341 if (mddev == NULL || mddev->pers == NULL 343 if (mddev == NULL || mddev->pers == NULL
342 || !mddev->ready) { 344 || !mddev->ready) {
343 bio_io_error(bio); 345 bio_io_error(bio);
344 return 0; 346 return;
345 } 347 }
346 smp_rmb(); /* Ensure implications of 'active' are visible */ 348 smp_rmb(); /* Ensure implications of 'active' are visible */
347 rcu_read_lock(); 349 rcu_read_lock();
@@ -366,7 +368,7 @@ static int md_make_request(struct request_queue *q, struct bio *bio)
366 * go away inside make_request 368 * go away inside make_request
367 */ 369 */
368 sectors = bio_sectors(bio); 370 sectors = bio_sectors(bio);
369 rv = mddev->pers->make_request(mddev, bio); 371 mddev->pers->make_request(mddev, bio);
370 372
371 cpu = part_stat_lock(); 373 cpu = part_stat_lock();
372 part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]); 374 part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
@@ -375,8 +377,6 @@ static int md_make_request(struct request_queue *q, struct bio *bio)
375 377
376 if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended) 378 if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
377 wake_up(&mddev->sb_wait); 379 wake_up(&mddev->sb_wait);
378
379 return rv;
380} 380}
381 381
382/* mddev_suspend makes sure no new requests are submitted 382/* mddev_suspend makes sure no new requests are submitted
@@ -385,7 +385,7 @@ static int md_make_request(struct request_queue *q, struct bio *bio)
385 * Once ->stop is called and completes, the module will be completely 385 * Once ->stop is called and completes, the module will be completely
386 * unused. 386 * unused.
387 */ 387 */
388void mddev_suspend(mddev_t *mddev) 388void mddev_suspend(struct mddev *mddev)
389{ 389{
390 BUG_ON(mddev->suspended); 390 BUG_ON(mddev->suspended);
391 mddev->suspended = 1; 391 mddev->suspended = 1;
@@ -395,7 +395,7 @@ void mddev_suspend(mddev_t *mddev)
395} 395}
396EXPORT_SYMBOL_GPL(mddev_suspend); 396EXPORT_SYMBOL_GPL(mddev_suspend);
397 397
398void mddev_resume(mddev_t *mddev) 398void mddev_resume(struct mddev *mddev)
399{ 399{
400 mddev->suspended = 0; 400 mddev->suspended = 0;
401 wake_up(&mddev->sb_wait); 401 wake_up(&mddev->sb_wait);
@@ -406,7 +406,7 @@ void mddev_resume(mddev_t *mddev)
406} 406}
407EXPORT_SYMBOL_GPL(mddev_resume); 407EXPORT_SYMBOL_GPL(mddev_resume);
408 408
409int mddev_congested(mddev_t *mddev, int bits) 409int mddev_congested(struct mddev *mddev, int bits)
410{ 410{
411 return mddev->suspended; 411 return mddev->suspended;
412} 412}
@@ -418,8 +418,8 @@ EXPORT_SYMBOL(mddev_congested);
418 418
419static void md_end_flush(struct bio *bio, int err) 419static void md_end_flush(struct bio *bio, int err)
420{ 420{
421 mdk_rdev_t *rdev = bio->bi_private; 421 struct md_rdev *rdev = bio->bi_private;
422 mddev_t *mddev = rdev->mddev; 422 struct mddev *mddev = rdev->mddev;
423 423
424 rdev_dec_pending(rdev, mddev); 424 rdev_dec_pending(rdev, mddev);
425 425
@@ -434,8 +434,8 @@ static void md_submit_flush_data(struct work_struct *ws);
434 434
435static void submit_flushes(struct work_struct *ws) 435static void submit_flushes(struct work_struct *ws)
436{ 436{
437 mddev_t *mddev = container_of(ws, mddev_t, flush_work); 437 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
438 mdk_rdev_t *rdev; 438 struct md_rdev *rdev;
439 439
440 INIT_WORK(&mddev->flush_work, md_submit_flush_data); 440 INIT_WORK(&mddev->flush_work, md_submit_flush_data);
441 atomic_set(&mddev->flush_pending, 1); 441 atomic_set(&mddev->flush_pending, 1);
@@ -467,7 +467,7 @@ static void submit_flushes(struct work_struct *ws)
467 467
468static void md_submit_flush_data(struct work_struct *ws) 468static void md_submit_flush_data(struct work_struct *ws)
469{ 469{
470 mddev_t *mddev = container_of(ws, mddev_t, flush_work); 470 struct mddev *mddev = container_of(ws, struct mddev, flush_work);
471 struct bio *bio = mddev->flush_bio; 471 struct bio *bio = mddev->flush_bio;
472 472
473 if (bio->bi_size == 0) 473 if (bio->bi_size == 0)
@@ -475,15 +475,14 @@ static void md_submit_flush_data(struct work_struct *ws)
475 bio_endio(bio, 0); 475 bio_endio(bio, 0);
476 else { 476 else {
477 bio->bi_rw &= ~REQ_FLUSH; 477 bio->bi_rw &= ~REQ_FLUSH;
478 if (mddev->pers->make_request(mddev, bio)) 478 mddev->pers->make_request(mddev, bio);
479 generic_make_request(bio);
480 } 479 }
481 480
482 mddev->flush_bio = NULL; 481 mddev->flush_bio = NULL;
483 wake_up(&mddev->sb_wait); 482 wake_up(&mddev->sb_wait);
484} 483}
485 484
486void md_flush_request(mddev_t *mddev, struct bio *bio) 485void md_flush_request(struct mddev *mddev, struct bio *bio)
487{ 486{
488 spin_lock_irq(&mddev->write_lock); 487 spin_lock_irq(&mddev->write_lock);
489 wait_event_lock_irq(mddev->sb_wait, 488 wait_event_lock_irq(mddev->sb_wait,
@@ -507,7 +506,7 @@ EXPORT_SYMBOL(md_flush_request);
507 */ 506 */
508struct md_plug_cb { 507struct md_plug_cb {
509 struct blk_plug_cb cb; 508 struct blk_plug_cb cb;
510 mddev_t *mddev; 509 struct mddev *mddev;
511}; 510};
512 511
513static void plugger_unplug(struct blk_plug_cb *cb) 512static void plugger_unplug(struct blk_plug_cb *cb)
@@ -521,7 +520,7 @@ static void plugger_unplug(struct blk_plug_cb *cb)
521/* Check that an unplug wakeup will come shortly. 520/* Check that an unplug wakeup will come shortly.
522 * If not, wakeup the md thread immediately 521 * If not, wakeup the md thread immediately
523 */ 522 */
524int mddev_check_plugged(mddev_t *mddev) 523int mddev_check_plugged(struct mddev *mddev)
525{ 524{
526 struct blk_plug *plug = current->plug; 525 struct blk_plug *plug = current->plug;
527 struct md_plug_cb *mdcb; 526 struct md_plug_cb *mdcb;
@@ -553,7 +552,7 @@ int mddev_check_plugged(mddev_t *mddev)
553} 552}
554EXPORT_SYMBOL_GPL(mddev_check_plugged); 553EXPORT_SYMBOL_GPL(mddev_check_plugged);
555 554
556static inline mddev_t *mddev_get(mddev_t *mddev) 555static inline struct mddev *mddev_get(struct mddev *mddev)
557{ 556{
558 atomic_inc(&mddev->active); 557 atomic_inc(&mddev->active);
559 return mddev; 558 return mddev;
@@ -561,7 +560,7 @@ static inline mddev_t *mddev_get(mddev_t *mddev)
561 560
562static void mddev_delayed_delete(struct work_struct *ws); 561static void mddev_delayed_delete(struct work_struct *ws);
563 562
564static void mddev_put(mddev_t *mddev) 563static void mddev_put(struct mddev *mddev)
565{ 564{
566 struct bio_set *bs = NULL; 565 struct bio_set *bs = NULL;
567 566
@@ -590,7 +589,7 @@ static void mddev_put(mddev_t *mddev)
590 bioset_free(bs); 589 bioset_free(bs);
591} 590}
592 591
593void mddev_init(mddev_t *mddev) 592void mddev_init(struct mddev *mddev)
594{ 593{
595 mutex_init(&mddev->open_mutex); 594 mutex_init(&mddev->open_mutex);
596 mutex_init(&mddev->reconfig_mutex); 595 mutex_init(&mddev->reconfig_mutex);
@@ -613,9 +612,9 @@ void mddev_init(mddev_t *mddev)
613} 612}
614EXPORT_SYMBOL_GPL(mddev_init); 613EXPORT_SYMBOL_GPL(mddev_init);
615 614
616static mddev_t * mddev_find(dev_t unit) 615static struct mddev * mddev_find(dev_t unit)
617{ 616{
618 mddev_t *mddev, *new = NULL; 617 struct mddev *mddev, *new = NULL;
619 618
620 if (unit && MAJOR(unit) != MD_MAJOR) 619 if (unit && MAJOR(unit) != MD_MAJOR)
621 unit &= ~((1<<MdpMinorShift)-1); 620 unit &= ~((1<<MdpMinorShift)-1);
@@ -687,24 +686,24 @@ static mddev_t * mddev_find(dev_t unit)
687 goto retry; 686 goto retry;
688} 687}
689 688
690static inline int mddev_lock(mddev_t * mddev) 689static inline int mddev_lock(struct mddev * mddev)
691{ 690{
692 return mutex_lock_interruptible(&mddev->reconfig_mutex); 691 return mutex_lock_interruptible(&mddev->reconfig_mutex);
693} 692}
694 693
695static inline int mddev_is_locked(mddev_t *mddev) 694static inline int mddev_is_locked(struct mddev *mddev)
696{ 695{
697 return mutex_is_locked(&mddev->reconfig_mutex); 696 return mutex_is_locked(&mddev->reconfig_mutex);
698} 697}
699 698
700static inline int mddev_trylock(mddev_t * mddev) 699static inline int mddev_trylock(struct mddev * mddev)
701{ 700{
702 return mutex_trylock(&mddev->reconfig_mutex); 701 return mutex_trylock(&mddev->reconfig_mutex);
703} 702}
704 703
705static struct attribute_group md_redundancy_group; 704static struct attribute_group md_redundancy_group;
706 705
707static void mddev_unlock(mddev_t * mddev) 706static void mddev_unlock(struct mddev * mddev)
708{ 707{
709 if (mddev->to_remove) { 708 if (mddev->to_remove) {
710 /* These cannot be removed under reconfig_mutex as 709 /* These cannot be removed under reconfig_mutex as
@@ -739,12 +738,17 @@ static void mddev_unlock(mddev_t * mddev)
739 } else 738 } else
740 mutex_unlock(&mddev->reconfig_mutex); 739 mutex_unlock(&mddev->reconfig_mutex);
741 740
741 /* As we've dropped the mutex we need a spinlock to
742 * make sure the thread doesn't disappear
743 */
744 spin_lock(&pers_lock);
742 md_wakeup_thread(mddev->thread); 745 md_wakeup_thread(mddev->thread);
746 spin_unlock(&pers_lock);
743} 747}
744 748
745static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr) 749static struct md_rdev * find_rdev_nr(struct mddev *mddev, int nr)
746{ 750{
747 mdk_rdev_t *rdev; 751 struct md_rdev *rdev;
748 752
749 list_for_each_entry(rdev, &mddev->disks, same_set) 753 list_for_each_entry(rdev, &mddev->disks, same_set)
750 if (rdev->desc_nr == nr) 754 if (rdev->desc_nr == nr)
@@ -753,9 +757,9 @@ static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
753 return NULL; 757 return NULL;
754} 758}
755 759
756static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev) 760static struct md_rdev * find_rdev(struct mddev * mddev, dev_t dev)
757{ 761{
758 mdk_rdev_t *rdev; 762 struct md_rdev *rdev;
759 763
760 list_for_each_entry(rdev, &mddev->disks, same_set) 764 list_for_each_entry(rdev, &mddev->disks, same_set)
761 if (rdev->bdev->bd_dev == dev) 765 if (rdev->bdev->bd_dev == dev)
@@ -764,9 +768,9 @@ static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
764 return NULL; 768 return NULL;
765} 769}
766 770
767static struct mdk_personality *find_pers(int level, char *clevel) 771static struct md_personality *find_pers(int level, char *clevel)
768{ 772{
769 struct mdk_personality *pers; 773 struct md_personality *pers;
770 list_for_each_entry(pers, &pers_list, list) { 774 list_for_each_entry(pers, &pers_list, list) {
771 if (level != LEVEL_NONE && pers->level == level) 775 if (level != LEVEL_NONE && pers->level == level)
772 return pers; 776 return pers;
@@ -777,13 +781,13 @@ static struct mdk_personality *find_pers(int level, char *clevel)
777} 781}
778 782
779/* return the offset of the super block in 512byte sectors */ 783/* return the offset of the super block in 512byte sectors */
780static inline sector_t calc_dev_sboffset(mdk_rdev_t *rdev) 784static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
781{ 785{
782 sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512; 786 sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
783 return MD_NEW_SIZE_SECTORS(num_sectors); 787 return MD_NEW_SIZE_SECTORS(num_sectors);
784} 788}
785 789
786static int alloc_disk_sb(mdk_rdev_t * rdev) 790static int alloc_disk_sb(struct md_rdev * rdev)
787{ 791{
788 if (rdev->sb_page) 792 if (rdev->sb_page)
789 MD_BUG(); 793 MD_BUG();
@@ -797,7 +801,7 @@ static int alloc_disk_sb(mdk_rdev_t * rdev)
797 return 0; 801 return 0;
798} 802}
799 803
800static void free_disk_sb(mdk_rdev_t * rdev) 804static void free_disk_sb(struct md_rdev * rdev)
801{ 805{
802 if (rdev->sb_page) { 806 if (rdev->sb_page) {
803 put_page(rdev->sb_page); 807 put_page(rdev->sb_page);
@@ -815,8 +819,8 @@ static void free_disk_sb(mdk_rdev_t * rdev)
815 819
816static void super_written(struct bio *bio, int error) 820static void super_written(struct bio *bio, int error)
817{ 821{
818 mdk_rdev_t *rdev = bio->bi_private; 822 struct md_rdev *rdev = bio->bi_private;
819 mddev_t *mddev = rdev->mddev; 823 struct mddev *mddev = rdev->mddev;
820 824
821 if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags)) { 825 if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags)) {
822 printk("md: super_written gets error=%d, uptodate=%d\n", 826 printk("md: super_written gets error=%d, uptodate=%d\n",
@@ -830,7 +834,7 @@ static void super_written(struct bio *bio, int error)
830 bio_put(bio); 834 bio_put(bio);
831} 835}
832 836
833void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev, 837void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
834 sector_t sector, int size, struct page *page) 838 sector_t sector, int size, struct page *page)
835{ 839{
836 /* write first size bytes of page to sector of rdev 840 /* write first size bytes of page to sector of rdev
@@ -848,10 +852,10 @@ void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
848 bio->bi_end_io = super_written; 852 bio->bi_end_io = super_written;
849 853
850 atomic_inc(&mddev->pending_writes); 854 atomic_inc(&mddev->pending_writes);
851 submit_bio(REQ_WRITE | REQ_SYNC | REQ_FLUSH | REQ_FUA, bio); 855 submit_bio(WRITE_FLUSH_FUA, bio);
852} 856}
853 857
854void md_super_wait(mddev_t *mddev) 858void md_super_wait(struct mddev *mddev)
855{ 859{
856 /* wait for all superblock writes that were scheduled to complete */ 860 /* wait for all superblock writes that were scheduled to complete */
857 DEFINE_WAIT(wq); 861 DEFINE_WAIT(wq);
@@ -869,7 +873,7 @@ static void bi_complete(struct bio *bio, int error)
869 complete((struct completion*)bio->bi_private); 873 complete((struct completion*)bio->bi_private);
870} 874}
871 875
872int sync_page_io(mdk_rdev_t *rdev, sector_t sector, int size, 876int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
873 struct page *page, int rw, bool metadata_op) 877 struct page *page, int rw, bool metadata_op)
874{ 878{
875 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev); 879 struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev);
@@ -897,7 +901,7 @@ int sync_page_io(mdk_rdev_t *rdev, sector_t sector, int size,
897} 901}
898EXPORT_SYMBOL_GPL(sync_page_io); 902EXPORT_SYMBOL_GPL(sync_page_io);
899 903
900static int read_disk_sb(mdk_rdev_t * rdev, int size) 904static int read_disk_sb(struct md_rdev * rdev, int size)
901{ 905{
902 char b[BDEVNAME_SIZE]; 906 char b[BDEVNAME_SIZE];
903 if (!rdev->sb_page) { 907 if (!rdev->sb_page) {
@@ -1004,7 +1008,7 @@ static unsigned int calc_sb_csum(mdp_super_t * sb)
1004 * We rely on user-space to write the initial superblock, and support 1008 * We rely on user-space to write the initial superblock, and support
1005 * reading and updating of superblocks. 1009 * reading and updating of superblocks.
1006 * Interface methods are: 1010 * Interface methods are:
1007 * int load_super(mdk_rdev_t *dev, mdk_rdev_t *refdev, int minor_version) 1011 * int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
1008 * loads and validates a superblock on dev. 1012 * loads and validates a superblock on dev.
1009 * if refdev != NULL, compare superblocks on both devices 1013 * if refdev != NULL, compare superblocks on both devices
1010 * Return: 1014 * Return:
@@ -1014,13 +1018,13 @@ static unsigned int calc_sb_csum(mdp_super_t * sb)
1014 * -EINVAL superblock incompatible or invalid 1018 * -EINVAL superblock incompatible or invalid
1015 * -othererror e.g. -EIO 1019 * -othererror e.g. -EIO
1016 * 1020 *
1017 * int validate_super(mddev_t *mddev, mdk_rdev_t *dev) 1021 * int validate_super(struct mddev *mddev, struct md_rdev *dev)
1018 * Verify that dev is acceptable into mddev. 1022 * Verify that dev is acceptable into mddev.
1019 * The first time, mddev->raid_disks will be 0, and data from 1023 * The first time, mddev->raid_disks will be 0, and data from
1020 * dev should be merged in. Subsequent calls check that dev 1024 * dev should be merged in. Subsequent calls check that dev
1021 * is new enough. Return 0 or -EINVAL 1025 * is new enough. Return 0 or -EINVAL
1022 * 1026 *
1023 * void sync_super(mddev_t *mddev, mdk_rdev_t *dev) 1027 * void sync_super(struct mddev *mddev, struct md_rdev *dev)
1024 * Update the superblock for rdev with data in mddev 1028 * Update the superblock for rdev with data in mddev
1025 * This does not write to disc. 1029 * This does not write to disc.
1026 * 1030 *
@@ -1029,11 +1033,11 @@ static unsigned int calc_sb_csum(mdp_super_t * sb)
1029struct super_type { 1033struct super_type {
1030 char *name; 1034 char *name;
1031 struct module *owner; 1035 struct module *owner;
1032 int (*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev, 1036 int (*load_super)(struct md_rdev *rdev, struct md_rdev *refdev,
1033 int minor_version); 1037 int minor_version);
1034 int (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev); 1038 int (*validate_super)(struct mddev *mddev, struct md_rdev *rdev);
1035 void (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev); 1039 void (*sync_super)(struct mddev *mddev, struct md_rdev *rdev);
1036 unsigned long long (*rdev_size_change)(mdk_rdev_t *rdev, 1040 unsigned long long (*rdev_size_change)(struct md_rdev *rdev,
1037 sector_t num_sectors); 1041 sector_t num_sectors);
1038}; 1042};
1039 1043
@@ -1045,7 +1049,7 @@ struct super_type {
1045 * has a bitmap. Otherwise, it returns 0. 1049 * has a bitmap. Otherwise, it returns 0.
1046 * 1050 *
1047 */ 1051 */
1048int md_check_no_bitmap(mddev_t *mddev) 1052int md_check_no_bitmap(struct mddev *mddev)
1049{ 1053{
1050 if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset) 1054 if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
1051 return 0; 1055 return 0;
@@ -1058,7 +1062,7 @@ EXPORT_SYMBOL(md_check_no_bitmap);
1058/* 1062/*
1059 * load_super for 0.90.0 1063 * load_super for 0.90.0
1060 */ 1064 */
1061static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version) 1065static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
1062{ 1066{
1063 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 1067 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1064 mdp_super_t *sb; 1068 mdp_super_t *sb;
@@ -1138,8 +1142,11 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
1138 ret = 0; 1142 ret = 0;
1139 } 1143 }
1140 rdev->sectors = rdev->sb_start; 1144 rdev->sectors = rdev->sb_start;
1145 /* Limit to 4TB as metadata cannot record more than that */
1146 if (rdev->sectors >= (2ULL << 32))
1147 rdev->sectors = (2ULL << 32) - 2;
1141 1148
1142 if (rdev->sectors < sb->size * 2 && sb->level > 1) 1149 if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
1143 /* "this cannot possibly happen" ... */ 1150 /* "this cannot possibly happen" ... */
1144 ret = -EINVAL; 1151 ret = -EINVAL;
1145 1152
@@ -1150,7 +1157,7 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
1150/* 1157/*
1151 * validate_super for 0.90.0 1158 * validate_super for 0.90.0
1152 */ 1159 */
1153static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev) 1160static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
1154{ 1161{
1155 mdp_disk_t *desc; 1162 mdp_disk_t *desc;
1156 mdp_super_t *sb = page_address(rdev->sb_page); 1163 mdp_super_t *sb = page_address(rdev->sb_page);
@@ -1173,7 +1180,7 @@ static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
1173 mddev->clevel[0] = 0; 1180 mddev->clevel[0] = 0;
1174 mddev->layout = sb->layout; 1181 mddev->layout = sb->layout;
1175 mddev->raid_disks = sb->raid_disks; 1182 mddev->raid_disks = sb->raid_disks;
1176 mddev->dev_sectors = sb->size * 2; 1183 mddev->dev_sectors = ((sector_t)sb->size) * 2;
1177 mddev->events = ev1; 1184 mddev->events = ev1;
1178 mddev->bitmap_info.offset = 0; 1185 mddev->bitmap_info.offset = 0;
1179 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9; 1186 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
@@ -1262,10 +1269,10 @@ static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
1262/* 1269/*
1263 * sync_super for 0.90.0 1270 * sync_super for 0.90.0
1264 */ 1271 */
1265static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev) 1272static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
1266{ 1273{
1267 mdp_super_t *sb; 1274 mdp_super_t *sb;
1268 mdk_rdev_t *rdev2; 1275 struct md_rdev *rdev2;
1269 int next_spare = mddev->raid_disks; 1276 int next_spare = mddev->raid_disks;
1270 1277
1271 1278
@@ -1406,7 +1413,7 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
1406 * rdev_size_change for 0.90.0 1413 * rdev_size_change for 0.90.0
1407 */ 1414 */
1408static unsigned long long 1415static unsigned long long
1409super_90_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors) 1416super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1410{ 1417{
1411 if (num_sectors && num_sectors < rdev->mddev->dev_sectors) 1418 if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1412 return 0; /* component must fit device */ 1419 return 0; /* component must fit device */
@@ -1415,6 +1422,11 @@ super_90_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
1415 rdev->sb_start = calc_dev_sboffset(rdev); 1422 rdev->sb_start = calc_dev_sboffset(rdev);
1416 if (!num_sectors || num_sectors > rdev->sb_start) 1423 if (!num_sectors || num_sectors > rdev->sb_start)
1417 num_sectors = rdev->sb_start; 1424 num_sectors = rdev->sb_start;
1425 /* Limit to 4TB as metadata cannot record more than that.
1426 * 4TB == 2^32 KB, or 2*2^32 sectors.
1427 */
1428 if (num_sectors >= (2ULL << 32))
1429 num_sectors = (2ULL << 32) - 2;
1418 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size, 1430 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1419 rdev->sb_page); 1431 rdev->sb_page);
1420 md_super_wait(rdev->mddev); 1432 md_super_wait(rdev->mddev);
@@ -1451,7 +1463,7 @@ static __le32 calc_sb_1_csum(struct mdp_superblock_1 * sb)
1451 1463
1452static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors, 1464static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
1453 int acknowledged); 1465 int acknowledged);
1454static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version) 1466static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
1455{ 1467{
1456 struct mdp_superblock_1 *sb; 1468 struct mdp_superblock_1 *sb;
1457 int ret; 1469 int ret;
@@ -1607,7 +1619,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
1607 return ret; 1619 return ret;
1608} 1620}
1609 1621
1610static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev) 1622static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
1611{ 1623{
1612 struct mdp_superblock_1 *sb = page_address(rdev->sb_page); 1624 struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
1613 __u64 ev1 = le64_to_cpu(sb->events); 1625 __u64 ev1 = le64_to_cpu(sb->events);
@@ -1708,10 +1720,10 @@ static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
1708 return 0; 1720 return 0;
1709} 1721}
1710 1722
1711static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev) 1723static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
1712{ 1724{
1713 struct mdp_superblock_1 *sb; 1725 struct mdp_superblock_1 *sb;
1714 mdk_rdev_t *rdev2; 1726 struct md_rdev *rdev2;
1715 int max_dev, i; 1727 int max_dev, i;
1716 /* make rdev->sb match mddev and rdev data. */ 1728 /* make rdev->sb match mddev and rdev data. */
1717 1729
@@ -1738,6 +1750,11 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
1738 sb->level = cpu_to_le32(mddev->level); 1750 sb->level = cpu_to_le32(mddev->level);
1739 sb->layout = cpu_to_le32(mddev->layout); 1751 sb->layout = cpu_to_le32(mddev->layout);
1740 1752
1753 if (test_bit(WriteMostly, &rdev->flags))
1754 sb->devflags |= WriteMostly1;
1755 else
1756 sb->devflags &= ~WriteMostly1;
1757
1741 if (mddev->bitmap && mddev->bitmap_info.file == NULL) { 1758 if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
1742 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset); 1759 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
1743 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET); 1760 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
@@ -1828,7 +1845,7 @@ retry:
1828} 1845}
1829 1846
1830static unsigned long long 1847static unsigned long long
1831super_1_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors) 1848super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1832{ 1849{
1833 struct mdp_superblock_1 *sb; 1850 struct mdp_superblock_1 *sb;
1834 sector_t max_sectors; 1851 sector_t max_sectors;
@@ -1882,7 +1899,7 @@ static struct super_type super_types[] = {
1882 }, 1899 },
1883}; 1900};
1884 1901
1885static void sync_super(mddev_t *mddev, mdk_rdev_t *rdev) 1902static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
1886{ 1903{
1887 if (mddev->sync_super) { 1904 if (mddev->sync_super) {
1888 mddev->sync_super(mddev, rdev); 1905 mddev->sync_super(mddev, rdev);
@@ -1894,9 +1911,9 @@ static void sync_super(mddev_t *mddev, mdk_rdev_t *rdev)
1894 super_types[mddev->major_version].sync_super(mddev, rdev); 1911 super_types[mddev->major_version].sync_super(mddev, rdev);
1895} 1912}
1896 1913
1897static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2) 1914static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
1898{ 1915{
1899 mdk_rdev_t *rdev, *rdev2; 1916 struct md_rdev *rdev, *rdev2;
1900 1917
1901 rcu_read_lock(); 1918 rcu_read_lock();
1902 rdev_for_each_rcu(rdev, mddev1) 1919 rdev_for_each_rcu(rdev, mddev1)
@@ -1919,9 +1936,9 @@ static LIST_HEAD(pending_raid_disks);
1919 * from the array. It only succeeds if all working and active component devices 1936 * from the array. It only succeeds if all working and active component devices
1920 * are integrity capable with matching profiles. 1937 * are integrity capable with matching profiles.
1921 */ 1938 */
1922int md_integrity_register(mddev_t *mddev) 1939int md_integrity_register(struct mddev *mddev)
1923{ 1940{
1924 mdk_rdev_t *rdev, *reference = NULL; 1941 struct md_rdev *rdev, *reference = NULL;
1925 1942
1926 if (list_empty(&mddev->disks)) 1943 if (list_empty(&mddev->disks))
1927 return 0; /* nothing to do */ 1944 return 0; /* nothing to do */
@@ -1966,7 +1983,7 @@ int md_integrity_register(mddev_t *mddev)
1966EXPORT_SYMBOL(md_integrity_register); 1983EXPORT_SYMBOL(md_integrity_register);
1967 1984
1968/* Disable data integrity if non-capable/non-matching disk is being added */ 1985/* Disable data integrity if non-capable/non-matching disk is being added */
1969void md_integrity_add_rdev(mdk_rdev_t *rdev, mddev_t *mddev) 1986void md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
1970{ 1987{
1971 struct blk_integrity *bi_rdev = bdev_get_integrity(rdev->bdev); 1988 struct blk_integrity *bi_rdev = bdev_get_integrity(rdev->bdev);
1972 struct blk_integrity *bi_mddev = blk_get_integrity(mddev->gendisk); 1989 struct blk_integrity *bi_mddev = blk_get_integrity(mddev->gendisk);
@@ -1983,7 +2000,7 @@ void md_integrity_add_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
1983} 2000}
1984EXPORT_SYMBOL(md_integrity_add_rdev); 2001EXPORT_SYMBOL(md_integrity_add_rdev);
1985 2002
1986static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev) 2003static int bind_rdev_to_array(struct md_rdev * rdev, struct mddev * mddev)
1987{ 2004{
1988 char b[BDEVNAME_SIZE]; 2005 char b[BDEVNAME_SIZE];
1989 struct kobject *ko; 2006 struct kobject *ko;
@@ -2063,12 +2080,12 @@ static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
2063 2080
2064static void md_delayed_delete(struct work_struct *ws) 2081static void md_delayed_delete(struct work_struct *ws)
2065{ 2082{
2066 mdk_rdev_t *rdev = container_of(ws, mdk_rdev_t, del_work); 2083 struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
2067 kobject_del(&rdev->kobj); 2084 kobject_del(&rdev->kobj);
2068 kobject_put(&rdev->kobj); 2085 kobject_put(&rdev->kobj);
2069} 2086}
2070 2087
2071static void unbind_rdev_from_array(mdk_rdev_t * rdev) 2088static void unbind_rdev_from_array(struct md_rdev * rdev)
2072{ 2089{
2073 char b[BDEVNAME_SIZE]; 2090 char b[BDEVNAME_SIZE];
2074 if (!rdev->mddev) { 2091 if (!rdev->mddev) {
@@ -2100,14 +2117,14 @@ static void unbind_rdev_from_array(mdk_rdev_t * rdev)
2100 * otherwise reused by a RAID array (or any other kernel 2117 * otherwise reused by a RAID array (or any other kernel
2101 * subsystem), by bd_claiming the device. 2118 * subsystem), by bd_claiming the device.
2102 */ 2119 */
2103static int lock_rdev(mdk_rdev_t *rdev, dev_t dev, int shared) 2120static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared)
2104{ 2121{
2105 int err = 0; 2122 int err = 0;
2106 struct block_device *bdev; 2123 struct block_device *bdev;
2107 char b[BDEVNAME_SIZE]; 2124 char b[BDEVNAME_SIZE];
2108 2125
2109 bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL, 2126 bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
2110 shared ? (mdk_rdev_t *)lock_rdev : rdev); 2127 shared ? (struct md_rdev *)lock_rdev : rdev);
2111 if (IS_ERR(bdev)) { 2128 if (IS_ERR(bdev)) {
2112 printk(KERN_ERR "md: could not open %s.\n", 2129 printk(KERN_ERR "md: could not open %s.\n",
2113 __bdevname(dev, b)); 2130 __bdevname(dev, b));
@@ -2117,7 +2134,7 @@ static int lock_rdev(mdk_rdev_t *rdev, dev_t dev, int shared)
2117 return err; 2134 return err;
2118} 2135}
2119 2136
2120static void unlock_rdev(mdk_rdev_t *rdev) 2137static void unlock_rdev(struct md_rdev *rdev)
2121{ 2138{
2122 struct block_device *bdev = rdev->bdev; 2139 struct block_device *bdev = rdev->bdev;
2123 rdev->bdev = NULL; 2140 rdev->bdev = NULL;
@@ -2128,7 +2145,7 @@ static void unlock_rdev(mdk_rdev_t *rdev)
2128 2145
2129void md_autodetect_dev(dev_t dev); 2146void md_autodetect_dev(dev_t dev);
2130 2147
2131static void export_rdev(mdk_rdev_t * rdev) 2148static void export_rdev(struct md_rdev * rdev)
2132{ 2149{
2133 char b[BDEVNAME_SIZE]; 2150 char b[BDEVNAME_SIZE];
2134 printk(KERN_INFO "md: export_rdev(%s)\n", 2151 printk(KERN_INFO "md: export_rdev(%s)\n",
@@ -2144,15 +2161,15 @@ static void export_rdev(mdk_rdev_t * rdev)
2144 kobject_put(&rdev->kobj); 2161 kobject_put(&rdev->kobj);
2145} 2162}
2146 2163
2147static void kick_rdev_from_array(mdk_rdev_t * rdev) 2164static void kick_rdev_from_array(struct md_rdev * rdev)
2148{ 2165{
2149 unbind_rdev_from_array(rdev); 2166 unbind_rdev_from_array(rdev);
2150 export_rdev(rdev); 2167 export_rdev(rdev);
2151} 2168}
2152 2169
2153static void export_array(mddev_t *mddev) 2170static void export_array(struct mddev *mddev)
2154{ 2171{
2155 mdk_rdev_t *rdev, *tmp; 2172 struct md_rdev *rdev, *tmp;
2156 2173
2157 rdev_for_each(rdev, tmp, mddev) { 2174 rdev_for_each(rdev, tmp, mddev) {
2158 if (!rdev->mddev) { 2175 if (!rdev->mddev) {
@@ -2248,7 +2265,7 @@ static void print_sb_1(struct mdp_superblock_1 *sb)
2248 ); 2265 );
2249} 2266}
2250 2267
2251static void print_rdev(mdk_rdev_t *rdev, int major_version) 2268static void print_rdev(struct md_rdev *rdev, int major_version)
2252{ 2269{
2253 char b[BDEVNAME_SIZE]; 2270 char b[BDEVNAME_SIZE];
2254 printk(KERN_INFO "md: rdev %s, Sect:%08llu F:%d S:%d DN:%u\n", 2271 printk(KERN_INFO "md: rdev %s, Sect:%08llu F:%d S:%d DN:%u\n",
@@ -2272,8 +2289,8 @@ static void print_rdev(mdk_rdev_t *rdev, int major_version)
2272static void md_print_devices(void) 2289static void md_print_devices(void)
2273{ 2290{
2274 struct list_head *tmp; 2291 struct list_head *tmp;
2275 mdk_rdev_t *rdev; 2292 struct md_rdev *rdev;
2276 mddev_t *mddev; 2293 struct mddev *mddev;
2277 char b[BDEVNAME_SIZE]; 2294 char b[BDEVNAME_SIZE];
2278 2295
2279 printk("\n"); 2296 printk("\n");
@@ -2298,7 +2315,7 @@ static void md_print_devices(void)
2298} 2315}
2299 2316
2300 2317
2301static void sync_sbs(mddev_t * mddev, int nospares) 2318static void sync_sbs(struct mddev * mddev, int nospares)
2302{ 2319{
2303 /* Update each superblock (in-memory image), but 2320 /* Update each superblock (in-memory image), but
2304 * if we are allowed to, skip spares which already 2321 * if we are allowed to, skip spares which already
@@ -2306,7 +2323,7 @@ static void sync_sbs(mddev_t * mddev, int nospares)
2306 * (which would mean they aren't being marked as dirty 2323 * (which would mean they aren't being marked as dirty
2307 * with the rest of the array) 2324 * with the rest of the array)
2308 */ 2325 */
2309 mdk_rdev_t *rdev; 2326 struct md_rdev *rdev;
2310 list_for_each_entry(rdev, &mddev->disks, same_set) { 2327 list_for_each_entry(rdev, &mddev->disks, same_set) {
2311 if (rdev->sb_events == mddev->events || 2328 if (rdev->sb_events == mddev->events ||
2312 (nospares && 2329 (nospares &&
@@ -2321,9 +2338,9 @@ static void sync_sbs(mddev_t * mddev, int nospares)
2321 } 2338 }
2322} 2339}
2323 2340
2324static void md_update_sb(mddev_t * mddev, int force_change) 2341static void md_update_sb(struct mddev * mddev, int force_change)
2325{ 2342{
2326 mdk_rdev_t *rdev; 2343 struct md_rdev *rdev;
2327 int sync_req; 2344 int sync_req;
2328 int nospares = 0; 2345 int nospares = 0;
2329 int any_badblocks_changed = 0; 2346 int any_badblocks_changed = 0;
@@ -2419,27 +2436,24 @@ repeat:
2419 sync_sbs(mddev, nospares); 2436 sync_sbs(mddev, nospares);
2420 spin_unlock_irq(&mddev->write_lock); 2437 spin_unlock_irq(&mddev->write_lock);
2421 2438
2422 dprintk(KERN_INFO 2439 pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
2423 "md: updating %s RAID superblock on device (in sync %d)\n", 2440 mdname(mddev), mddev->in_sync);
2424 mdname(mddev),mddev->in_sync);
2425 2441
2426 bitmap_update_sb(mddev->bitmap); 2442 bitmap_update_sb(mddev->bitmap);
2427 list_for_each_entry(rdev, &mddev->disks, same_set) { 2443 list_for_each_entry(rdev, &mddev->disks, same_set) {
2428 char b[BDEVNAME_SIZE]; 2444 char b[BDEVNAME_SIZE];
2429 dprintk(KERN_INFO "md: "); 2445
2430 if (rdev->sb_loaded != 1) 2446 if (rdev->sb_loaded != 1)
2431 continue; /* no noise on spare devices */ 2447 continue; /* no noise on spare devices */
2432 if (test_bit(Faulty, &rdev->flags))
2433 dprintk("(skipping faulty ");
2434 2448
2435 dprintk("%s ", bdevname(rdev->bdev,b)); 2449 if (!test_bit(Faulty, &rdev->flags) &&
2436 if (!test_bit(Faulty, &rdev->flags)) { 2450 rdev->saved_raid_disk == -1) {
2437 md_super_write(mddev,rdev, 2451 md_super_write(mddev,rdev,
2438 rdev->sb_start, rdev->sb_size, 2452 rdev->sb_start, rdev->sb_size,
2439 rdev->sb_page); 2453 rdev->sb_page);
2440 dprintk(KERN_INFO "(write) %s's sb offset: %llu\n", 2454 pr_debug("md: (write) %s's sb offset: %llu\n",
2441 bdevname(rdev->bdev,b), 2455 bdevname(rdev->bdev, b),
2442 (unsigned long long)rdev->sb_start); 2456 (unsigned long long)rdev->sb_start);
2443 rdev->sb_events = mddev->events; 2457 rdev->sb_events = mddev->events;
2444 if (rdev->badblocks.size) { 2458 if (rdev->badblocks.size) {
2445 md_super_write(mddev, rdev, 2459 md_super_write(mddev, rdev,
@@ -2449,8 +2463,12 @@ repeat:
2449 rdev->badblocks.size = 0; 2463 rdev->badblocks.size = 0;
2450 } 2464 }
2451 2465
2452 } else 2466 } else if (test_bit(Faulty, &rdev->flags))
2453 dprintk(")\n"); 2467 pr_debug("md: %s (skipping faulty)\n",
2468 bdevname(rdev->bdev, b));
2469 else
2470 pr_debug("(skipping incremental s/r ");
2471
2454 if (mddev->level == LEVEL_MULTIPATH) 2472 if (mddev->level == LEVEL_MULTIPATH)
2455 /* only need to write one superblock... */ 2473 /* only need to write one superblock... */
2456 break; 2474 break;
@@ -2504,12 +2522,12 @@ static int cmd_match(const char *cmd, const char *str)
2504 2522
2505struct rdev_sysfs_entry { 2523struct rdev_sysfs_entry {
2506 struct attribute attr; 2524 struct attribute attr;
2507 ssize_t (*show)(mdk_rdev_t *, char *); 2525 ssize_t (*show)(struct md_rdev *, char *);
2508 ssize_t (*store)(mdk_rdev_t *, const char *, size_t); 2526 ssize_t (*store)(struct md_rdev *, const char *, size_t);
2509}; 2527};
2510 2528
2511static ssize_t 2529static ssize_t
2512state_show(mdk_rdev_t *rdev, char *page) 2530state_show(struct md_rdev *rdev, char *page)
2513{ 2531{
2514 char *sep = ""; 2532 char *sep = "";
2515 size_t len = 0; 2533 size_t len = 0;
@@ -2545,7 +2563,7 @@ state_show(mdk_rdev_t *rdev, char *page)
2545} 2563}
2546 2564
2547static ssize_t 2565static ssize_t
2548state_store(mdk_rdev_t *rdev, const char *buf, size_t len) 2566state_store(struct md_rdev *rdev, const char *buf, size_t len)
2549{ 2567{
2550 /* can write 2568 /* can write
2551 * faulty - simulates an error 2569 * faulty - simulates an error
@@ -2561,12 +2579,15 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
2561 int err = -EINVAL; 2579 int err = -EINVAL;
2562 if (cmd_match(buf, "faulty") && rdev->mddev->pers) { 2580 if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2563 md_error(rdev->mddev, rdev); 2581 md_error(rdev->mddev, rdev);
2564 err = 0; 2582 if (test_bit(Faulty, &rdev->flags))
2583 err = 0;
2584 else
2585 err = -EBUSY;
2565 } else if (cmd_match(buf, "remove")) { 2586 } else if (cmd_match(buf, "remove")) {
2566 if (rdev->raid_disk >= 0) 2587 if (rdev->raid_disk >= 0)
2567 err = -EBUSY; 2588 err = -EBUSY;
2568 else { 2589 else {
2569 mddev_t *mddev = rdev->mddev; 2590 struct mddev *mddev = rdev->mddev;
2570 kick_rdev_from_array(rdev); 2591 kick_rdev_from_array(rdev);
2571 if (mddev->pers) 2592 if (mddev->pers)
2572 md_update_sb(mddev, 1); 2593 md_update_sb(mddev, 1);
@@ -2584,7 +2605,7 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
2584 err = 0; 2605 err = 0;
2585 } else if (cmd_match(buf, "-blocked")) { 2606 } else if (cmd_match(buf, "-blocked")) {
2586 if (!test_bit(Faulty, &rdev->flags) && 2607 if (!test_bit(Faulty, &rdev->flags) &&
2587 test_bit(BlockedBadBlocks, &rdev->flags)) { 2608 rdev->badblocks.unacked_exist) {
2588 /* metadata handler doesn't understand badblocks, 2609 /* metadata handler doesn't understand badblocks,
2589 * so we need to fail the device 2610 * so we need to fail the device
2590 */ 2611 */
@@ -2615,13 +2636,13 @@ static struct rdev_sysfs_entry rdev_state =
2615__ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store); 2636__ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store);
2616 2637
2617static ssize_t 2638static ssize_t
2618errors_show(mdk_rdev_t *rdev, char *page) 2639errors_show(struct md_rdev *rdev, char *page)
2619{ 2640{
2620 return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors)); 2641 return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
2621} 2642}
2622 2643
2623static ssize_t 2644static ssize_t
2624errors_store(mdk_rdev_t *rdev, const char *buf, size_t len) 2645errors_store(struct md_rdev *rdev, const char *buf, size_t len)
2625{ 2646{
2626 char *e; 2647 char *e;
2627 unsigned long n = simple_strtoul(buf, &e, 10); 2648 unsigned long n = simple_strtoul(buf, &e, 10);
@@ -2635,7 +2656,7 @@ static struct rdev_sysfs_entry rdev_errors =
2635__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store); 2656__ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
2636 2657
2637static ssize_t 2658static ssize_t
2638slot_show(mdk_rdev_t *rdev, char *page) 2659slot_show(struct md_rdev *rdev, char *page)
2639{ 2660{
2640 if (rdev->raid_disk < 0) 2661 if (rdev->raid_disk < 0)
2641 return sprintf(page, "none\n"); 2662 return sprintf(page, "none\n");
@@ -2644,7 +2665,7 @@ slot_show(mdk_rdev_t *rdev, char *page)
2644} 2665}
2645 2666
2646static ssize_t 2667static ssize_t
2647slot_store(mdk_rdev_t *rdev, const char *buf, size_t len) 2668slot_store(struct md_rdev *rdev, const char *buf, size_t len)
2648{ 2669{
2649 char *e; 2670 char *e;
2650 int err; 2671 int err;
@@ -2675,7 +2696,7 @@ slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
2675 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery); 2696 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2676 md_wakeup_thread(rdev->mddev->thread); 2697 md_wakeup_thread(rdev->mddev->thread);
2677 } else if (rdev->mddev->pers) { 2698 } else if (rdev->mddev->pers) {
2678 mdk_rdev_t *rdev2; 2699 struct md_rdev *rdev2;
2679 /* Activating a spare .. or possibly reactivating 2700 /* Activating a spare .. or possibly reactivating
2680 * if we ever get bitmaps working here. 2701 * if we ever get bitmaps working here.
2681 */ 2702 */
@@ -2702,6 +2723,7 @@ slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
2702 rdev->saved_raid_disk = slot; 2723 rdev->saved_raid_disk = slot;
2703 else 2724 else
2704 rdev->saved_raid_disk = -1; 2725 rdev->saved_raid_disk = -1;
2726 clear_bit(In_sync, &rdev->flags);
2705 err = rdev->mddev->pers-> 2727 err = rdev->mddev->pers->
2706 hot_add_disk(rdev->mddev, rdev); 2728 hot_add_disk(rdev->mddev, rdev);
2707 if (err) { 2729 if (err) {
@@ -2731,13 +2753,13 @@ static struct rdev_sysfs_entry rdev_slot =
2731__ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store); 2753__ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
2732 2754
2733static ssize_t 2755static ssize_t
2734offset_show(mdk_rdev_t *rdev, char *page) 2756offset_show(struct md_rdev *rdev, char *page)
2735{ 2757{
2736 return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset); 2758 return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
2737} 2759}
2738 2760
2739static ssize_t 2761static ssize_t
2740offset_store(mdk_rdev_t *rdev, const char *buf, size_t len) 2762offset_store(struct md_rdev *rdev, const char *buf, size_t len)
2741{ 2763{
2742 char *e; 2764 char *e;
2743 unsigned long long offset = simple_strtoull(buf, &e, 10); 2765 unsigned long long offset = simple_strtoull(buf, &e, 10);
@@ -2757,7 +2779,7 @@ static struct rdev_sysfs_entry rdev_offset =
2757__ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store); 2779__ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
2758 2780
2759static ssize_t 2781static ssize_t
2760rdev_size_show(mdk_rdev_t *rdev, char *page) 2782rdev_size_show(struct md_rdev *rdev, char *page)
2761{ 2783{
2762 return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2); 2784 return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
2763} 2785}
@@ -2792,9 +2814,9 @@ static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
2792} 2814}
2793 2815
2794static ssize_t 2816static ssize_t
2795rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len) 2817rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
2796{ 2818{
2797 mddev_t *my_mddev = rdev->mddev; 2819 struct mddev *my_mddev = rdev->mddev;
2798 sector_t oldsectors = rdev->sectors; 2820 sector_t oldsectors = rdev->sectors;
2799 sector_t sectors; 2821 sector_t sectors;
2800 2822
@@ -2820,13 +2842,13 @@ rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
2820 * a deadlock. We have already changed rdev->sectors, and if 2842 * a deadlock. We have already changed rdev->sectors, and if
2821 * we have to change it back, we will have the lock again. 2843 * we have to change it back, we will have the lock again.
2822 */ 2844 */
2823 mddev_t *mddev; 2845 struct mddev *mddev;
2824 int overlap = 0; 2846 int overlap = 0;
2825 struct list_head *tmp; 2847 struct list_head *tmp;
2826 2848
2827 mddev_unlock(my_mddev); 2849 mddev_unlock(my_mddev);
2828 for_each_mddev(mddev, tmp) { 2850 for_each_mddev(mddev, tmp) {
2829 mdk_rdev_t *rdev2; 2851 struct md_rdev *rdev2;
2830 2852
2831 mddev_lock(mddev); 2853 mddev_lock(mddev);
2832 list_for_each_entry(rdev2, &mddev->disks, same_set) 2854 list_for_each_entry(rdev2, &mddev->disks, same_set)
@@ -2863,7 +2885,7 @@ static struct rdev_sysfs_entry rdev_size =
2863__ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store); 2885__ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
2864 2886
2865 2887
2866static ssize_t recovery_start_show(mdk_rdev_t *rdev, char *page) 2888static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
2867{ 2889{
2868 unsigned long long recovery_start = rdev->recovery_offset; 2890 unsigned long long recovery_start = rdev->recovery_offset;
2869 2891
@@ -2874,7 +2896,7 @@ static ssize_t recovery_start_show(mdk_rdev_t *rdev, char *page)
2874 return sprintf(page, "%llu\n", recovery_start); 2896 return sprintf(page, "%llu\n", recovery_start);
2875} 2897}
2876 2898
2877static ssize_t recovery_start_store(mdk_rdev_t *rdev, const char *buf, size_t len) 2899static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
2878{ 2900{
2879 unsigned long long recovery_start; 2901 unsigned long long recovery_start;
2880 2902
@@ -2904,11 +2926,11 @@ badblocks_show(struct badblocks *bb, char *page, int unack);
2904static ssize_t 2926static ssize_t
2905badblocks_store(struct badblocks *bb, const char *page, size_t len, int unack); 2927badblocks_store(struct badblocks *bb, const char *page, size_t len, int unack);
2906 2928
2907static ssize_t bb_show(mdk_rdev_t *rdev, char *page) 2929static ssize_t bb_show(struct md_rdev *rdev, char *page)
2908{ 2930{
2909 return badblocks_show(&rdev->badblocks, page, 0); 2931 return badblocks_show(&rdev->badblocks, page, 0);
2910} 2932}
2911static ssize_t bb_store(mdk_rdev_t *rdev, const char *page, size_t len) 2933static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
2912{ 2934{
2913 int rv = badblocks_store(&rdev->badblocks, page, len, 0); 2935 int rv = badblocks_store(&rdev->badblocks, page, len, 0);
2914 /* Maybe that ack was all we needed */ 2936 /* Maybe that ack was all we needed */
@@ -2920,11 +2942,11 @@ static struct rdev_sysfs_entry rdev_bad_blocks =
2920__ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store); 2942__ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);
2921 2943
2922 2944
2923static ssize_t ubb_show(mdk_rdev_t *rdev, char *page) 2945static ssize_t ubb_show(struct md_rdev *rdev, char *page)
2924{ 2946{
2925 return badblocks_show(&rdev->badblocks, page, 1); 2947 return badblocks_show(&rdev->badblocks, page, 1);
2926} 2948}
2927static ssize_t ubb_store(mdk_rdev_t *rdev, const char *page, size_t len) 2949static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
2928{ 2950{
2929 return badblocks_store(&rdev->badblocks, page, len, 1); 2951 return badblocks_store(&rdev->badblocks, page, len, 1);
2930} 2952}
@@ -2946,8 +2968,8 @@ static ssize_t
2946rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page) 2968rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
2947{ 2969{
2948 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr); 2970 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
2949 mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj); 2971 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
2950 mddev_t *mddev = rdev->mddev; 2972 struct mddev *mddev = rdev->mddev;
2951 ssize_t rv; 2973 ssize_t rv;
2952 2974
2953 if (!entry->show) 2975 if (!entry->show)
@@ -2969,9 +2991,9 @@ rdev_attr_store(struct kobject *kobj, struct attribute *attr,
2969 const char *page, size_t length) 2991 const char *page, size_t length)
2970{ 2992{
2971 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr); 2993 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
2972 mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj); 2994 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
2973 ssize_t rv; 2995 ssize_t rv;
2974 mddev_t *mddev = rdev->mddev; 2996 struct mddev *mddev = rdev->mddev;
2975 2997
2976 if (!entry->store) 2998 if (!entry->store)
2977 return -EIO; 2999 return -EIO;
@@ -2990,7 +3012,7 @@ rdev_attr_store(struct kobject *kobj, struct attribute *attr,
2990 3012
2991static void rdev_free(struct kobject *ko) 3013static void rdev_free(struct kobject *ko)
2992{ 3014{
2993 mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj); 3015 struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
2994 kfree(rdev); 3016 kfree(rdev);
2995} 3017}
2996static const struct sysfs_ops rdev_sysfs_ops = { 3018static const struct sysfs_ops rdev_sysfs_ops = {
@@ -3003,7 +3025,7 @@ static struct kobj_type rdev_ktype = {
3003 .default_attrs = rdev_default_attrs, 3025 .default_attrs = rdev_default_attrs,
3004}; 3026};
3005 3027
3006int md_rdev_init(mdk_rdev_t *rdev) 3028int md_rdev_init(struct md_rdev *rdev)
3007{ 3029{
3008 rdev->desc_nr = -1; 3030 rdev->desc_nr = -1;
3009 rdev->saved_raid_disk = -1; 3031 rdev->saved_raid_disk = -1;
@@ -3046,11 +3068,11 @@ EXPORT_SYMBOL_GPL(md_rdev_init);
3046 * 3068 *
3047 * a faulty rdev _never_ has rdev->sb set. 3069 * a faulty rdev _never_ has rdev->sb set.
3048 */ 3070 */
3049static mdk_rdev_t *md_import_device(dev_t newdev, int super_format, int super_minor) 3071static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
3050{ 3072{
3051 char b[BDEVNAME_SIZE]; 3073 char b[BDEVNAME_SIZE];
3052 int err; 3074 int err;
3053 mdk_rdev_t *rdev; 3075 struct md_rdev *rdev;
3054 sector_t size; 3076 sector_t size;
3055 3077
3056 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL); 3078 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
@@ -3119,10 +3141,10 @@ abort_free:
3119 */ 3141 */
3120 3142
3121 3143
3122static void analyze_sbs(mddev_t * mddev) 3144static void analyze_sbs(struct mddev * mddev)
3123{ 3145{
3124 int i; 3146 int i;
3125 mdk_rdev_t *rdev, *freshest, *tmp; 3147 struct md_rdev *rdev, *freshest, *tmp;
3126 char b[BDEVNAME_SIZE]; 3148 char b[BDEVNAME_SIZE];
3127 3149
3128 freshest = NULL; 3150 freshest = NULL;
@@ -3222,13 +3244,13 @@ int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
3222static void md_safemode_timeout(unsigned long data); 3244static void md_safemode_timeout(unsigned long data);
3223 3245
3224static ssize_t 3246static ssize_t
3225safe_delay_show(mddev_t *mddev, char *page) 3247safe_delay_show(struct mddev *mddev, char *page)
3226{ 3248{
3227 int msec = (mddev->safemode_delay*1000)/HZ; 3249 int msec = (mddev->safemode_delay*1000)/HZ;
3228 return sprintf(page, "%d.%03d\n", msec/1000, msec%1000); 3250 return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
3229} 3251}
3230static ssize_t 3252static ssize_t
3231safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len) 3253safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
3232{ 3254{
3233 unsigned long msec; 3255 unsigned long msec;
3234 3256
@@ -3250,9 +3272,9 @@ static struct md_sysfs_entry md_safe_delay =
3250__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store); 3272__ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
3251 3273
3252static ssize_t 3274static ssize_t
3253level_show(mddev_t *mddev, char *page) 3275level_show(struct mddev *mddev, char *page)
3254{ 3276{
3255 struct mdk_personality *p = mddev->pers; 3277 struct md_personality *p = mddev->pers;
3256 if (p) 3278 if (p)
3257 return sprintf(page, "%s\n", p->name); 3279 return sprintf(page, "%s\n", p->name);
3258 else if (mddev->clevel[0]) 3280 else if (mddev->clevel[0])
@@ -3264,14 +3286,14 @@ level_show(mddev_t *mddev, char *page)
3264} 3286}
3265 3287
3266static ssize_t 3288static ssize_t
3267level_store(mddev_t *mddev, const char *buf, size_t len) 3289level_store(struct mddev *mddev, const char *buf, size_t len)
3268{ 3290{
3269 char clevel[16]; 3291 char clevel[16];
3270 ssize_t rv = len; 3292 ssize_t rv = len;
3271 struct mdk_personality *pers; 3293 struct md_personality *pers;
3272 long level; 3294 long level;
3273 void *priv; 3295 void *priv;
3274 mdk_rdev_t *rdev; 3296 struct md_rdev *rdev;
3275 3297
3276 if (mddev->pers == NULL) { 3298 if (mddev->pers == NULL) {
3277 if (len == 0) 3299 if (len == 0)
@@ -3445,7 +3467,7 @@ __ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
3445 3467
3446 3468
3447static ssize_t 3469static ssize_t
3448layout_show(mddev_t *mddev, char *page) 3470layout_show(struct mddev *mddev, char *page)
3449{ 3471{
3450 /* just a number, not meaningful for all levels */ 3472 /* just a number, not meaningful for all levels */
3451 if (mddev->reshape_position != MaxSector && 3473 if (mddev->reshape_position != MaxSector &&
@@ -3456,7 +3478,7 @@ layout_show(mddev_t *mddev, char *page)
3456} 3478}
3457 3479
3458static ssize_t 3480static ssize_t
3459layout_store(mddev_t *mddev, const char *buf, size_t len) 3481layout_store(struct mddev *mddev, const char *buf, size_t len)
3460{ 3482{
3461 char *e; 3483 char *e;
3462 unsigned long n = simple_strtoul(buf, &e, 10); 3484 unsigned long n = simple_strtoul(buf, &e, 10);
@@ -3486,7 +3508,7 @@ __ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
3486 3508
3487 3509
3488static ssize_t 3510static ssize_t
3489raid_disks_show(mddev_t *mddev, char *page) 3511raid_disks_show(struct mddev *mddev, char *page)
3490{ 3512{
3491 if (mddev->raid_disks == 0) 3513 if (mddev->raid_disks == 0)
3492 return 0; 3514 return 0;
@@ -3497,10 +3519,10 @@ raid_disks_show(mddev_t *mddev, char *page)
3497 return sprintf(page, "%d\n", mddev->raid_disks); 3519 return sprintf(page, "%d\n", mddev->raid_disks);
3498} 3520}
3499 3521
3500static int update_raid_disks(mddev_t *mddev, int raid_disks); 3522static int update_raid_disks(struct mddev *mddev, int raid_disks);
3501 3523
3502static ssize_t 3524static ssize_t
3503raid_disks_store(mddev_t *mddev, const char *buf, size_t len) 3525raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
3504{ 3526{
3505 char *e; 3527 char *e;
3506 int rv = 0; 3528 int rv = 0;
@@ -3523,7 +3545,7 @@ static struct md_sysfs_entry md_raid_disks =
3523__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store); 3545__ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
3524 3546
3525static ssize_t 3547static ssize_t
3526chunk_size_show(mddev_t *mddev, char *page) 3548chunk_size_show(struct mddev *mddev, char *page)
3527{ 3549{
3528 if (mddev->reshape_position != MaxSector && 3550 if (mddev->reshape_position != MaxSector &&
3529 mddev->chunk_sectors != mddev->new_chunk_sectors) 3551 mddev->chunk_sectors != mddev->new_chunk_sectors)
@@ -3534,7 +3556,7 @@ chunk_size_show(mddev_t *mddev, char *page)
3534} 3556}
3535 3557
3536static ssize_t 3558static ssize_t
3537chunk_size_store(mddev_t *mddev, const char *buf, size_t len) 3559chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
3538{ 3560{
3539 char *e; 3561 char *e;
3540 unsigned long n = simple_strtoul(buf, &e, 10); 3562 unsigned long n = simple_strtoul(buf, &e, 10);
@@ -3563,7 +3585,7 @@ static struct md_sysfs_entry md_chunk_size =
3563__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store); 3585__ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
3564 3586
3565static ssize_t 3587static ssize_t
3566resync_start_show(mddev_t *mddev, char *page) 3588resync_start_show(struct mddev *mddev, char *page)
3567{ 3589{
3568 if (mddev->recovery_cp == MaxSector) 3590 if (mddev->recovery_cp == MaxSector)
3569 return sprintf(page, "none\n"); 3591 return sprintf(page, "none\n");
@@ -3571,7 +3593,7 @@ resync_start_show(mddev_t *mddev, char *page)
3571} 3593}
3572 3594
3573static ssize_t 3595static ssize_t
3574resync_start_store(mddev_t *mddev, const char *buf, size_t len) 3596resync_start_store(struct mddev *mddev, const char *buf, size_t len)
3575{ 3597{
3576 char *e; 3598 char *e;
3577 unsigned long long n = simple_strtoull(buf, &e, 10); 3599 unsigned long long n = simple_strtoull(buf, &e, 10);
@@ -3641,7 +3663,7 @@ static int match_word(const char *word, char **list)
3641} 3663}
3642 3664
3643static ssize_t 3665static ssize_t
3644array_state_show(mddev_t *mddev, char *page) 3666array_state_show(struct mddev *mddev, char *page)
3645{ 3667{
3646 enum array_state st = inactive; 3668 enum array_state st = inactive;
3647 3669
@@ -3674,13 +3696,13 @@ array_state_show(mddev_t *mddev, char *page)
3674 return sprintf(page, "%s\n", array_states[st]); 3696 return sprintf(page, "%s\n", array_states[st]);
3675} 3697}
3676 3698
3677static int do_md_stop(mddev_t * mddev, int ro, int is_open); 3699static int do_md_stop(struct mddev * mddev, int ro, int is_open);
3678static int md_set_readonly(mddev_t * mddev, int is_open); 3700static int md_set_readonly(struct mddev * mddev, int is_open);
3679static int do_md_run(mddev_t * mddev); 3701static int do_md_run(struct mddev * mddev);
3680static int restart_array(mddev_t *mddev); 3702static int restart_array(struct mddev *mddev);
3681 3703
3682static ssize_t 3704static ssize_t
3683array_state_store(mddev_t *mddev, const char *buf, size_t len) 3705array_state_store(struct mddev *mddev, const char *buf, size_t len)
3684{ 3706{
3685 int err = -EINVAL; 3707 int err = -EINVAL;
3686 enum array_state st = match_word(buf, array_states); 3708 enum array_state st = match_word(buf, array_states);
@@ -3774,13 +3796,13 @@ static struct md_sysfs_entry md_array_state =
3774__ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store); 3796__ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
3775 3797
3776static ssize_t 3798static ssize_t
3777max_corrected_read_errors_show(mddev_t *mddev, char *page) { 3799max_corrected_read_errors_show(struct mddev *mddev, char *page) {
3778 return sprintf(page, "%d\n", 3800 return sprintf(page, "%d\n",
3779 atomic_read(&mddev->max_corr_read_errors)); 3801 atomic_read(&mddev->max_corr_read_errors));
3780} 3802}
3781 3803
3782static ssize_t 3804static ssize_t
3783max_corrected_read_errors_store(mddev_t *mddev, const char *buf, size_t len) 3805max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
3784{ 3806{
3785 char *e; 3807 char *e;
3786 unsigned long n = simple_strtoul(buf, &e, 10); 3808 unsigned long n = simple_strtoul(buf, &e, 10);
@@ -3797,13 +3819,13 @@ __ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
3797 max_corrected_read_errors_store); 3819 max_corrected_read_errors_store);
3798 3820
3799static ssize_t 3821static ssize_t
3800null_show(mddev_t *mddev, char *page) 3822null_show(struct mddev *mddev, char *page)
3801{ 3823{
3802 return -EINVAL; 3824 return -EINVAL;
3803} 3825}
3804 3826
3805static ssize_t 3827static ssize_t
3806new_dev_store(mddev_t *mddev, const char *buf, size_t len) 3828new_dev_store(struct mddev *mddev, const char *buf, size_t len)
3807{ 3829{
3808 /* buf must be %d:%d\n? giving major and minor numbers */ 3830 /* buf must be %d:%d\n? giving major and minor numbers */
3809 /* The new device is added to the array. 3831 /* The new device is added to the array.
@@ -3816,7 +3838,7 @@ new_dev_store(mddev_t *mddev, const char *buf, size_t len)
3816 int major = simple_strtoul(buf, &e, 10); 3838 int major = simple_strtoul(buf, &e, 10);
3817 int minor; 3839 int minor;
3818 dev_t dev; 3840 dev_t dev;
3819 mdk_rdev_t *rdev; 3841 struct md_rdev *rdev;
3820 int err; 3842 int err;
3821 3843
3822 if (!*buf || *e != ':' || !e[1] || e[1] == '\n') 3844 if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
@@ -3834,8 +3856,9 @@ new_dev_store(mddev_t *mddev, const char *buf, size_t len)
3834 rdev = md_import_device(dev, mddev->major_version, 3856 rdev = md_import_device(dev, mddev->major_version,
3835 mddev->minor_version); 3857 mddev->minor_version);
3836 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) { 3858 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
3837 mdk_rdev_t *rdev0 = list_entry(mddev->disks.next, 3859 struct md_rdev *rdev0
3838 mdk_rdev_t, same_set); 3860 = list_entry(mddev->disks.next,
3861 struct md_rdev, same_set);
3839 err = super_types[mddev->major_version] 3862 err = super_types[mddev->major_version]
3840 .load_super(rdev, rdev0, mddev->minor_version); 3863 .load_super(rdev, rdev0, mddev->minor_version);
3841 if (err < 0) 3864 if (err < 0)
@@ -3859,7 +3882,7 @@ static struct md_sysfs_entry md_new_device =
3859__ATTR(new_dev, S_IWUSR, null_show, new_dev_store); 3882__ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
3860 3883
3861static ssize_t 3884static ssize_t
3862bitmap_store(mddev_t *mddev, const char *buf, size_t len) 3885bitmap_store(struct mddev *mddev, const char *buf, size_t len)
3863{ 3886{
3864 char *end; 3887 char *end;
3865 unsigned long chunk, end_chunk; 3888 unsigned long chunk, end_chunk;
@@ -3888,16 +3911,16 @@ static struct md_sysfs_entry md_bitmap =
3888__ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store); 3911__ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
3889 3912
3890static ssize_t 3913static ssize_t
3891size_show(mddev_t *mddev, char *page) 3914size_show(struct mddev *mddev, char *page)
3892{ 3915{
3893 return sprintf(page, "%llu\n", 3916 return sprintf(page, "%llu\n",
3894 (unsigned long long)mddev->dev_sectors / 2); 3917 (unsigned long long)mddev->dev_sectors / 2);
3895} 3918}
3896 3919
3897static int update_size(mddev_t *mddev, sector_t num_sectors); 3920static int update_size(struct mddev *mddev, sector_t num_sectors);
3898 3921
3899static ssize_t 3922static ssize_t
3900size_store(mddev_t *mddev, const char *buf, size_t len) 3923size_store(struct mddev *mddev, const char *buf, size_t len)
3901{ 3924{
3902 /* If array is inactive, we can reduce the component size, but 3925 /* If array is inactive, we can reduce the component size, but
3903 * not increase it (except from 0). 3926 * not increase it (except from 0).
@@ -3932,7 +3955,7 @@ __ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
3932 * or N.M for internally known formats 3955 * or N.M for internally known formats
3933 */ 3956 */
3934static ssize_t 3957static ssize_t
3935metadata_show(mddev_t *mddev, char *page) 3958metadata_show(struct mddev *mddev, char *page)
3936{ 3959{
3937 if (mddev->persistent) 3960 if (mddev->persistent)
3938 return sprintf(page, "%d.%d\n", 3961 return sprintf(page, "%d.%d\n",
@@ -3944,7 +3967,7 @@ metadata_show(mddev_t *mddev, char *page)
3944} 3967}
3945 3968
3946static ssize_t 3969static ssize_t
3947metadata_store(mddev_t *mddev, const char *buf, size_t len) 3970metadata_store(struct mddev *mddev, const char *buf, size_t len)
3948{ 3971{
3949 int major, minor; 3972 int major, minor;
3950 char *e; 3973 char *e;
@@ -3998,7 +4021,7 @@ static struct md_sysfs_entry md_metadata =
3998__ATTR(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store); 4021__ATTR(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
3999 4022
4000static ssize_t 4023static ssize_t
4001action_show(mddev_t *mddev, char *page) 4024action_show(struct mddev *mddev, char *page)
4002{ 4025{
4003 char *type = "idle"; 4026 char *type = "idle";
4004 if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) 4027 if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
@@ -4020,10 +4043,10 @@ action_show(mddev_t *mddev, char *page)
4020 return sprintf(page, "%s\n", type); 4043 return sprintf(page, "%s\n", type);
4021} 4044}
4022 4045
4023static void reap_sync_thread(mddev_t *mddev); 4046static void reap_sync_thread(struct mddev *mddev);
4024 4047
4025static ssize_t 4048static ssize_t
4026action_store(mddev_t *mddev, const char *page, size_t len) 4049action_store(struct mddev *mddev, const char *page, size_t len)
4027{ 4050{
4028 if (!mddev->pers || !mddev->pers->sync_request) 4051 if (!mddev->pers || !mddev->pers->sync_request)
4029 return -EINVAL; 4052 return -EINVAL;
@@ -4069,7 +4092,7 @@ action_store(mddev_t *mddev, const char *page, size_t len)
4069} 4092}
4070 4093
4071static ssize_t 4094static ssize_t
4072mismatch_cnt_show(mddev_t *mddev, char *page) 4095mismatch_cnt_show(struct mddev *mddev, char *page)
4073{ 4096{
4074 return sprintf(page, "%llu\n", 4097 return sprintf(page, "%llu\n",
4075 (unsigned long long) mddev->resync_mismatches); 4098 (unsigned long long) mddev->resync_mismatches);
@@ -4082,14 +4105,14 @@ __ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
4082static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt); 4105static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
4083 4106
4084static ssize_t 4107static ssize_t
4085sync_min_show(mddev_t *mddev, char *page) 4108sync_min_show(struct mddev *mddev, char *page)
4086{ 4109{
4087 return sprintf(page, "%d (%s)\n", speed_min(mddev), 4110 return sprintf(page, "%d (%s)\n", speed_min(mddev),
4088 mddev->sync_speed_min ? "local": "system"); 4111 mddev->sync_speed_min ? "local": "system");
4089} 4112}
4090 4113
4091static ssize_t 4114static ssize_t
4092sync_min_store(mddev_t *mddev, const char *buf, size_t len) 4115sync_min_store(struct mddev *mddev, const char *buf, size_t len)
4093{ 4116{
4094 int min; 4117 int min;
4095 char *e; 4118 char *e;
@@ -4108,14 +4131,14 @@ static struct md_sysfs_entry md_sync_min =
4108__ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store); 4131__ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
4109 4132
4110static ssize_t 4133static ssize_t
4111sync_max_show(mddev_t *mddev, char *page) 4134sync_max_show(struct mddev *mddev, char *page)
4112{ 4135{
4113 return sprintf(page, "%d (%s)\n", speed_max(mddev), 4136 return sprintf(page, "%d (%s)\n", speed_max(mddev),
4114 mddev->sync_speed_max ? "local": "system"); 4137 mddev->sync_speed_max ? "local": "system");
4115} 4138}
4116 4139
4117static ssize_t 4140static ssize_t
4118sync_max_store(mddev_t *mddev, const char *buf, size_t len) 4141sync_max_store(struct mddev *mddev, const char *buf, size_t len)
4119{ 4142{
4120 int max; 4143 int max;
4121 char *e; 4144 char *e;
@@ -4134,20 +4157,20 @@ static struct md_sysfs_entry md_sync_max =
4134__ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store); 4157__ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
4135 4158
4136static ssize_t 4159static ssize_t
4137degraded_show(mddev_t *mddev, char *page) 4160degraded_show(struct mddev *mddev, char *page)
4138{ 4161{
4139 return sprintf(page, "%d\n", mddev->degraded); 4162 return sprintf(page, "%d\n", mddev->degraded);
4140} 4163}
4141static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded); 4164static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
4142 4165
4143static ssize_t 4166static ssize_t
4144sync_force_parallel_show(mddev_t *mddev, char *page) 4167sync_force_parallel_show(struct mddev *mddev, char *page)
4145{ 4168{
4146 return sprintf(page, "%d\n", mddev->parallel_resync); 4169 return sprintf(page, "%d\n", mddev->parallel_resync);
4147} 4170}
4148 4171
4149static ssize_t 4172static ssize_t
4150sync_force_parallel_store(mddev_t *mddev, const char *buf, size_t len) 4173sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
4151{ 4174{
4152 long n; 4175 long n;
4153 4176
@@ -4171,7 +4194,7 @@ __ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
4171 sync_force_parallel_show, sync_force_parallel_store); 4194 sync_force_parallel_show, sync_force_parallel_store);
4172 4195
4173static ssize_t 4196static ssize_t
4174sync_speed_show(mddev_t *mddev, char *page) 4197sync_speed_show(struct mddev *mddev, char *page)
4175{ 4198{
4176 unsigned long resync, dt, db; 4199 unsigned long resync, dt, db;
4177 if (mddev->curr_resync == 0) 4200 if (mddev->curr_resync == 0)
@@ -4186,7 +4209,7 @@ sync_speed_show(mddev_t *mddev, char *page)
4186static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed); 4209static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
4187 4210
4188static ssize_t 4211static ssize_t
4189sync_completed_show(mddev_t *mddev, char *page) 4212sync_completed_show(struct mddev *mddev, char *page)
4190{ 4213{
4191 unsigned long long max_sectors, resync; 4214 unsigned long long max_sectors, resync;
4192 4215
@@ -4205,13 +4228,13 @@ sync_completed_show(mddev_t *mddev, char *page)
4205static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed); 4228static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
4206 4229
4207static ssize_t 4230static ssize_t
4208min_sync_show(mddev_t *mddev, char *page) 4231min_sync_show(struct mddev *mddev, char *page)
4209{ 4232{
4210 return sprintf(page, "%llu\n", 4233 return sprintf(page, "%llu\n",
4211 (unsigned long long)mddev->resync_min); 4234 (unsigned long long)mddev->resync_min);
4212} 4235}
4213static ssize_t 4236static ssize_t
4214min_sync_store(mddev_t *mddev, const char *buf, size_t len) 4237min_sync_store(struct mddev *mddev, const char *buf, size_t len)
4215{ 4238{
4216 unsigned long long min; 4239 unsigned long long min;
4217 if (strict_strtoull(buf, 10, &min)) 4240 if (strict_strtoull(buf, 10, &min))
@@ -4236,7 +4259,7 @@ static struct md_sysfs_entry md_min_sync =
4236__ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store); 4259__ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
4237 4260
4238static ssize_t 4261static ssize_t
4239max_sync_show(mddev_t *mddev, char *page) 4262max_sync_show(struct mddev *mddev, char *page)
4240{ 4263{
4241 if (mddev->resync_max == MaxSector) 4264 if (mddev->resync_max == MaxSector)
4242 return sprintf(page, "max\n"); 4265 return sprintf(page, "max\n");
@@ -4245,7 +4268,7 @@ max_sync_show(mddev_t *mddev, char *page)
4245 (unsigned long long)mddev->resync_max); 4268 (unsigned long long)mddev->resync_max);
4246} 4269}
4247static ssize_t 4270static ssize_t
4248max_sync_store(mddev_t *mddev, const char *buf, size_t len) 4271max_sync_store(struct mddev *mddev, const char *buf, size_t len)
4249{ 4272{
4250 if (strncmp(buf, "max", 3) == 0) 4273 if (strncmp(buf, "max", 3) == 0)
4251 mddev->resync_max = MaxSector; 4274 mddev->resync_max = MaxSector;
@@ -4276,13 +4299,13 @@ static struct md_sysfs_entry md_max_sync =
4276__ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store); 4299__ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
4277 4300
4278static ssize_t 4301static ssize_t
4279suspend_lo_show(mddev_t *mddev, char *page) 4302suspend_lo_show(struct mddev *mddev, char *page)
4280{ 4303{
4281 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo); 4304 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
4282} 4305}
4283 4306
4284static ssize_t 4307static ssize_t
4285suspend_lo_store(mddev_t *mddev, const char *buf, size_t len) 4308suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
4286{ 4309{
4287 char *e; 4310 char *e;
4288 unsigned long long new = simple_strtoull(buf, &e, 10); 4311 unsigned long long new = simple_strtoull(buf, &e, 10);
@@ -4310,13 +4333,13 @@ __ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
4310 4333
4311 4334
4312static ssize_t 4335static ssize_t
4313suspend_hi_show(mddev_t *mddev, char *page) 4336suspend_hi_show(struct mddev *mddev, char *page)
4314{ 4337{
4315 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi); 4338 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
4316} 4339}
4317 4340
4318static ssize_t 4341static ssize_t
4319suspend_hi_store(mddev_t *mddev, const char *buf, size_t len) 4342suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
4320{ 4343{
4321 char *e; 4344 char *e;
4322 unsigned long long new = simple_strtoull(buf, &e, 10); 4345 unsigned long long new = simple_strtoull(buf, &e, 10);
@@ -4343,7 +4366,7 @@ static struct md_sysfs_entry md_suspend_hi =
4343__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store); 4366__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
4344 4367
4345static ssize_t 4368static ssize_t
4346reshape_position_show(mddev_t *mddev, char *page) 4369reshape_position_show(struct mddev *mddev, char *page)
4347{ 4370{
4348 if (mddev->reshape_position != MaxSector) 4371 if (mddev->reshape_position != MaxSector)
4349 return sprintf(page, "%llu\n", 4372 return sprintf(page, "%llu\n",
@@ -4353,7 +4376,7 @@ reshape_position_show(mddev_t *mddev, char *page)
4353} 4376}
4354 4377
4355static ssize_t 4378static ssize_t
4356reshape_position_store(mddev_t *mddev, const char *buf, size_t len) 4379reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
4357{ 4380{
4358 char *e; 4381 char *e;
4359 unsigned long long new = simple_strtoull(buf, &e, 10); 4382 unsigned long long new = simple_strtoull(buf, &e, 10);
@@ -4374,7 +4397,7 @@ __ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
4374 reshape_position_store); 4397 reshape_position_store);
4375 4398
4376static ssize_t 4399static ssize_t
4377array_size_show(mddev_t *mddev, char *page) 4400array_size_show(struct mddev *mddev, char *page)
4378{ 4401{
4379 if (mddev->external_size) 4402 if (mddev->external_size)
4380 return sprintf(page, "%llu\n", 4403 return sprintf(page, "%llu\n",
@@ -4384,7 +4407,7 @@ array_size_show(mddev_t *mddev, char *page)
4384} 4407}
4385 4408
4386static ssize_t 4409static ssize_t
4387array_size_store(mddev_t *mddev, const char *buf, size_t len) 4410array_size_store(struct mddev *mddev, const char *buf, size_t len)
4388{ 4411{
4389 sector_t sectors; 4412 sector_t sectors;
4390 4413
@@ -4459,7 +4482,7 @@ static ssize_t
4459md_attr_show(struct kobject *kobj, struct attribute *attr, char *page) 4482md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
4460{ 4483{
4461 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr); 4484 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
4462 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj); 4485 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
4463 ssize_t rv; 4486 ssize_t rv;
4464 4487
4465 if (!entry->show) 4488 if (!entry->show)
@@ -4477,7 +4500,7 @@ md_attr_store(struct kobject *kobj, struct attribute *attr,
4477 const char *page, size_t length) 4500 const char *page, size_t length)
4478{ 4501{
4479 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr); 4502 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
4480 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj); 4503 struct mddev *mddev = container_of(kobj, struct mddev, kobj);
4481 ssize_t rv; 4504 ssize_t rv;
4482 4505
4483 if (!entry->store) 4506 if (!entry->store)
@@ -4496,7 +4519,7 @@ md_attr_store(struct kobject *kobj, struct attribute *attr,
4496 4519
4497static void md_free(struct kobject *ko) 4520static void md_free(struct kobject *ko)
4498{ 4521{
4499 mddev_t *mddev = container_of(ko, mddev_t, kobj); 4522 struct mddev *mddev = container_of(ko, struct mddev, kobj);
4500 4523
4501 if (mddev->sysfs_state) 4524 if (mddev->sysfs_state)
4502 sysfs_put(mddev->sysfs_state); 4525 sysfs_put(mddev->sysfs_state);
@@ -4525,7 +4548,7 @@ int mdp_major = 0;
4525 4548
4526static void mddev_delayed_delete(struct work_struct *ws) 4549static void mddev_delayed_delete(struct work_struct *ws)
4527{ 4550{
4528 mddev_t *mddev = container_of(ws, mddev_t, del_work); 4551 struct mddev *mddev = container_of(ws, struct mddev, del_work);
4529 4552
4530 sysfs_remove_group(&mddev->kobj, &md_bitmap_group); 4553 sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
4531 kobject_del(&mddev->kobj); 4554 kobject_del(&mddev->kobj);
@@ -4535,7 +4558,7 @@ static void mddev_delayed_delete(struct work_struct *ws)
4535static int md_alloc(dev_t dev, char *name) 4558static int md_alloc(dev_t dev, char *name)
4536{ 4559{
4537 static DEFINE_MUTEX(disks_mutex); 4560 static DEFINE_MUTEX(disks_mutex);
4538 mddev_t *mddev = mddev_find(dev); 4561 struct mddev *mddev = mddev_find(dev);
4539 struct gendisk *disk; 4562 struct gendisk *disk;
4540 int partitioned; 4563 int partitioned;
4541 int shift; 4564 int shift;
@@ -4562,7 +4585,7 @@ static int md_alloc(dev_t dev, char *name)
4562 if (name) { 4585 if (name) {
4563 /* Need to ensure that 'name' is not a duplicate. 4586 /* Need to ensure that 'name' is not a duplicate.
4564 */ 4587 */
4565 mddev_t *mddev2; 4588 struct mddev *mddev2;
4566 spin_lock(&all_mddevs_lock); 4589 spin_lock(&all_mddevs_lock);
4567 4590
4568 list_for_each_entry(mddev2, &all_mddevs, all_mddevs) 4591 list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
@@ -4663,7 +4686,7 @@ static int add_named_array(const char *val, struct kernel_param *kp)
4663 4686
4664static void md_safemode_timeout(unsigned long data) 4687static void md_safemode_timeout(unsigned long data)
4665{ 4688{
4666 mddev_t *mddev = (mddev_t *) data; 4689 struct mddev *mddev = (struct mddev *) data;
4667 4690
4668 if (!atomic_read(&mddev->writes_pending)) { 4691 if (!atomic_read(&mddev->writes_pending)) {
4669 mddev->safemode = 1; 4692 mddev->safemode = 1;
@@ -4675,11 +4698,11 @@ static void md_safemode_timeout(unsigned long data)
4675 4698
4676static int start_dirty_degraded; 4699static int start_dirty_degraded;
4677 4700
4678int md_run(mddev_t *mddev) 4701int md_run(struct mddev *mddev)
4679{ 4702{
4680 int err; 4703 int err;
4681 mdk_rdev_t *rdev; 4704 struct md_rdev *rdev;
4682 struct mdk_personality *pers; 4705 struct md_personality *pers;
4683 4706
4684 if (list_empty(&mddev->disks)) 4707 if (list_empty(&mddev->disks))
4685 /* cannot run an array with no devices.. */ 4708 /* cannot run an array with no devices.. */
@@ -4743,7 +4766,7 @@ int md_run(mddev_t *mddev)
4743 4766
4744 if (mddev->bio_set == NULL) 4767 if (mddev->bio_set == NULL)
4745 mddev->bio_set = bioset_create(BIO_POOL_SIZE, 4768 mddev->bio_set = bioset_create(BIO_POOL_SIZE,
4746 sizeof(mddev_t *)); 4769 sizeof(struct mddev *));
4747 4770
4748 spin_lock(&pers_lock); 4771 spin_lock(&pers_lock);
4749 pers = find_pers(mddev->level, mddev->clevel); 4772 pers = find_pers(mddev->level, mddev->clevel);
@@ -4778,7 +4801,7 @@ int md_run(mddev_t *mddev)
4778 * configuration. 4801 * configuration.
4779 */ 4802 */
4780 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 4803 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
4781 mdk_rdev_t *rdev2; 4804 struct md_rdev *rdev2;
4782 int warned = 0; 4805 int warned = 0;
4783 4806
4784 list_for_each_entry(rdev, &mddev->disks, same_set) 4807 list_for_each_entry(rdev, &mddev->disks, same_set)
@@ -4877,7 +4900,7 @@ int md_run(mddev_t *mddev)
4877} 4900}
4878EXPORT_SYMBOL_GPL(md_run); 4901EXPORT_SYMBOL_GPL(md_run);
4879 4902
4880static int do_md_run(mddev_t *mddev) 4903static int do_md_run(struct mddev *mddev)
4881{ 4904{
4882 int err; 4905 int err;
4883 4906
@@ -4901,7 +4924,7 @@ out:
4901 return err; 4924 return err;
4902} 4925}
4903 4926
4904static int restart_array(mddev_t *mddev) 4927static int restart_array(struct mddev *mddev)
4905{ 4928{
4906 struct gendisk *disk = mddev->gendisk; 4929 struct gendisk *disk = mddev->gendisk;
4907 4930
@@ -4951,7 +4974,7 @@ void restore_bitmap_write_access(struct file *file)
4951 spin_unlock(&inode->i_lock); 4974 spin_unlock(&inode->i_lock);
4952} 4975}
4953 4976
4954static void md_clean(mddev_t *mddev) 4977static void md_clean(struct mddev *mddev)
4955{ 4978{
4956 mddev->array_sectors = 0; 4979 mddev->array_sectors = 0;
4957 mddev->external_size = 0; 4980 mddev->external_size = 0;
@@ -4994,7 +5017,7 @@ static void md_clean(mddev_t *mddev)
4994 mddev->bitmap_info.max_write_behind = 0; 5017 mddev->bitmap_info.max_write_behind = 0;
4995} 5018}
4996 5019
4997static void __md_stop_writes(mddev_t *mddev) 5020static void __md_stop_writes(struct mddev *mddev)
4998{ 5021{
4999 if (mddev->sync_thread) { 5022 if (mddev->sync_thread) {
5000 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 5023 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
@@ -5014,7 +5037,7 @@ static void __md_stop_writes(mddev_t *mddev)
5014 } 5037 }
5015} 5038}
5016 5039
5017void md_stop_writes(mddev_t *mddev) 5040void md_stop_writes(struct mddev *mddev)
5018{ 5041{
5019 mddev_lock(mddev); 5042 mddev_lock(mddev);
5020 __md_stop_writes(mddev); 5043 __md_stop_writes(mddev);
@@ -5022,7 +5045,7 @@ void md_stop_writes(mddev_t *mddev)
5022} 5045}
5023EXPORT_SYMBOL_GPL(md_stop_writes); 5046EXPORT_SYMBOL_GPL(md_stop_writes);
5024 5047
5025void md_stop(mddev_t *mddev) 5048void md_stop(struct mddev *mddev)
5026{ 5049{
5027 mddev->ready = 0; 5050 mddev->ready = 0;
5028 mddev->pers->stop(mddev); 5051 mddev->pers->stop(mddev);
@@ -5034,7 +5057,7 @@ void md_stop(mddev_t *mddev)
5034} 5057}
5035EXPORT_SYMBOL_GPL(md_stop); 5058EXPORT_SYMBOL_GPL(md_stop);
5036 5059
5037static int md_set_readonly(mddev_t *mddev, int is_open) 5060static int md_set_readonly(struct mddev *mddev, int is_open)
5038{ 5061{
5039 int err = 0; 5062 int err = 0;
5040 mutex_lock(&mddev->open_mutex); 5063 mutex_lock(&mddev->open_mutex);
@@ -5064,10 +5087,10 @@ out:
5064 * 0 - completely stop and dis-assemble array 5087 * 0 - completely stop and dis-assemble array
5065 * 2 - stop but do not disassemble array 5088 * 2 - stop but do not disassemble array
5066 */ 5089 */
5067static int do_md_stop(mddev_t * mddev, int mode, int is_open) 5090static int do_md_stop(struct mddev * mddev, int mode, int is_open)
5068{ 5091{
5069 struct gendisk *disk = mddev->gendisk; 5092 struct gendisk *disk = mddev->gendisk;
5070 mdk_rdev_t *rdev; 5093 struct md_rdev *rdev;
5071 5094
5072 mutex_lock(&mddev->open_mutex); 5095 mutex_lock(&mddev->open_mutex);
5073 if (atomic_read(&mddev->openers) > is_open || 5096 if (atomic_read(&mddev->openers) > is_open ||
@@ -5130,9 +5153,9 @@ static int do_md_stop(mddev_t * mddev, int mode, int is_open)
5130} 5153}
5131 5154
5132#ifndef MODULE 5155#ifndef MODULE
5133static void autorun_array(mddev_t *mddev) 5156static void autorun_array(struct mddev *mddev)
5134{ 5157{
5135 mdk_rdev_t *rdev; 5158 struct md_rdev *rdev;
5136 int err; 5159 int err;
5137 5160
5138 if (list_empty(&mddev->disks)) 5161 if (list_empty(&mddev->disks))
@@ -5167,8 +5190,8 @@ static void autorun_array(mddev_t *mddev)
5167 */ 5190 */
5168static void autorun_devices(int part) 5191static void autorun_devices(int part)
5169{ 5192{
5170 mdk_rdev_t *rdev0, *rdev, *tmp; 5193 struct md_rdev *rdev0, *rdev, *tmp;
5171 mddev_t *mddev; 5194 struct mddev *mddev;
5172 char b[BDEVNAME_SIZE]; 5195 char b[BDEVNAME_SIZE];
5173 5196
5174 printk(KERN_INFO "md: autorun ...\n"); 5197 printk(KERN_INFO "md: autorun ...\n");
@@ -5177,7 +5200,7 @@ static void autorun_devices(int part)
5177 dev_t dev; 5200 dev_t dev;
5178 LIST_HEAD(candidates); 5201 LIST_HEAD(candidates);
5179 rdev0 = list_entry(pending_raid_disks.next, 5202 rdev0 = list_entry(pending_raid_disks.next,
5180 mdk_rdev_t, same_set); 5203 struct md_rdev, same_set);
5181 5204
5182 printk(KERN_INFO "md: considering %s ...\n", 5205 printk(KERN_INFO "md: considering %s ...\n",
5183 bdevname(rdev0->bdev,b)); 5206 bdevname(rdev0->bdev,b));
@@ -5263,11 +5286,11 @@ static int get_version(void __user * arg)
5263 return 0; 5286 return 0;
5264} 5287}
5265 5288
5266static int get_array_info(mddev_t * mddev, void __user * arg) 5289static int get_array_info(struct mddev * mddev, void __user * arg)
5267{ 5290{
5268 mdu_array_info_t info; 5291 mdu_array_info_t info;
5269 int nr,working,insync,failed,spare; 5292 int nr,working,insync,failed,spare;
5270 mdk_rdev_t *rdev; 5293 struct md_rdev *rdev;
5271 5294
5272 nr=working=insync=failed=spare=0; 5295 nr=working=insync=failed=spare=0;
5273 list_for_each_entry(rdev, &mddev->disks, same_set) { 5296 list_for_each_entry(rdev, &mddev->disks, same_set) {
@@ -5316,7 +5339,7 @@ static int get_array_info(mddev_t * mddev, void __user * arg)
5316 return 0; 5339 return 0;
5317} 5340}
5318 5341
5319static int get_bitmap_file(mddev_t * mddev, void __user * arg) 5342static int get_bitmap_file(struct mddev * mddev, void __user * arg)
5320{ 5343{
5321 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */ 5344 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
5322 char *ptr, *buf = NULL; 5345 char *ptr, *buf = NULL;
@@ -5356,10 +5379,10 @@ out:
5356 return err; 5379 return err;
5357} 5380}
5358 5381
5359static int get_disk_info(mddev_t * mddev, void __user * arg) 5382static int get_disk_info(struct mddev * mddev, void __user * arg)
5360{ 5383{
5361 mdu_disk_info_t info; 5384 mdu_disk_info_t info;
5362 mdk_rdev_t *rdev; 5385 struct md_rdev *rdev;
5363 5386
5364 if (copy_from_user(&info, arg, sizeof(info))) 5387 if (copy_from_user(&info, arg, sizeof(info)))
5365 return -EFAULT; 5388 return -EFAULT;
@@ -5390,10 +5413,10 @@ static int get_disk_info(mddev_t * mddev, void __user * arg)
5390 return 0; 5413 return 0;
5391} 5414}
5392 5415
5393static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info) 5416static int add_new_disk(struct mddev * mddev, mdu_disk_info_t *info)
5394{ 5417{
5395 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 5418 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
5396 mdk_rdev_t *rdev; 5419 struct md_rdev *rdev;
5397 dev_t dev = MKDEV(info->major,info->minor); 5420 dev_t dev = MKDEV(info->major,info->minor);
5398 5421
5399 if (info->major != MAJOR(dev) || info->minor != MINOR(dev)) 5422 if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
@@ -5410,8 +5433,9 @@ static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
5410 return PTR_ERR(rdev); 5433 return PTR_ERR(rdev);
5411 } 5434 }
5412 if (!list_empty(&mddev->disks)) { 5435 if (!list_empty(&mddev->disks)) {
5413 mdk_rdev_t *rdev0 = list_entry(mddev->disks.next, 5436 struct md_rdev *rdev0
5414 mdk_rdev_t, same_set); 5437 = list_entry(mddev->disks.next,
5438 struct md_rdev, same_set);
5415 err = super_types[mddev->major_version] 5439 err = super_types[mddev->major_version]
5416 .load_super(rdev, rdev0, mddev->minor_version); 5440 .load_super(rdev, rdev0, mddev->minor_version);
5417 if (err < 0) { 5441 if (err < 0) {
@@ -5561,10 +5585,10 @@ static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
5561 return 0; 5585 return 0;
5562} 5586}
5563 5587
5564static int hot_remove_disk(mddev_t * mddev, dev_t dev) 5588static int hot_remove_disk(struct mddev * mddev, dev_t dev)
5565{ 5589{
5566 char b[BDEVNAME_SIZE]; 5590 char b[BDEVNAME_SIZE];
5567 mdk_rdev_t *rdev; 5591 struct md_rdev *rdev;
5568 5592
5569 rdev = find_rdev(mddev, dev); 5593 rdev = find_rdev(mddev, dev);
5570 if (!rdev) 5594 if (!rdev)
@@ -5584,11 +5608,11 @@ busy:
5584 return -EBUSY; 5608 return -EBUSY;
5585} 5609}
5586 5610
5587static int hot_add_disk(mddev_t * mddev, dev_t dev) 5611static int hot_add_disk(struct mddev * mddev, dev_t dev)
5588{ 5612{
5589 char b[BDEVNAME_SIZE]; 5613 char b[BDEVNAME_SIZE];
5590 int err; 5614 int err;
5591 mdk_rdev_t *rdev; 5615 struct md_rdev *rdev;
5592 5616
5593 if (!mddev->pers) 5617 if (!mddev->pers)
5594 return -ENODEV; 5618 return -ENODEV;
@@ -5658,7 +5682,7 @@ abort_export:
5658 return err; 5682 return err;
5659} 5683}
5660 5684
5661static int set_bitmap_file(mddev_t *mddev, int fd) 5685static int set_bitmap_file(struct mddev *mddev, int fd)
5662{ 5686{
5663 int err; 5687 int err;
5664 5688
@@ -5731,7 +5755,7 @@ static int set_bitmap_file(mddev_t *mddev, int fd)
5731 * The minor and patch _version numbers are also kept incase the 5755 * The minor and patch _version numbers are also kept incase the
5732 * super_block handler wishes to interpret them. 5756 * super_block handler wishes to interpret them.
5733 */ 5757 */
5734static int set_array_info(mddev_t * mddev, mdu_array_info_t *info) 5758static int set_array_info(struct mddev * mddev, mdu_array_info_t *info)
5735{ 5759{
5736 5760
5737 if (info->raid_disks == 0) { 5761 if (info->raid_disks == 0) {
@@ -5801,7 +5825,7 @@ static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
5801 return 0; 5825 return 0;
5802} 5826}
5803 5827
5804void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors) 5828void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
5805{ 5829{
5806 WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__); 5830 WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);
5807 5831
@@ -5812,9 +5836,9 @@ void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors)
5812} 5836}
5813EXPORT_SYMBOL(md_set_array_sectors); 5837EXPORT_SYMBOL(md_set_array_sectors);
5814 5838
5815static int update_size(mddev_t *mddev, sector_t num_sectors) 5839static int update_size(struct mddev *mddev, sector_t num_sectors)
5816{ 5840{
5817 mdk_rdev_t *rdev; 5841 struct md_rdev *rdev;
5818 int rv; 5842 int rv;
5819 int fit = (num_sectors == 0); 5843 int fit = (num_sectors == 0);
5820 5844
@@ -5850,7 +5874,7 @@ static int update_size(mddev_t *mddev, sector_t num_sectors)
5850 return rv; 5874 return rv;
5851} 5875}
5852 5876
5853static int update_raid_disks(mddev_t *mddev, int raid_disks) 5877static int update_raid_disks(struct mddev *mddev, int raid_disks)
5854{ 5878{
5855 int rv; 5879 int rv;
5856 /* change the number of raid disks */ 5880 /* change the number of raid disks */
@@ -5878,7 +5902,7 @@ static int update_raid_disks(mddev_t *mddev, int raid_disks)
5878 * Any differences that cannot be handled will cause an error. 5902 * Any differences that cannot be handled will cause an error.
5879 * Normally, only one change can be managed at a time. 5903 * Normally, only one change can be managed at a time.
5880 */ 5904 */
5881static int update_array_info(mddev_t *mddev, mdu_array_info_t *info) 5905static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
5882{ 5906{
5883 int rv = 0; 5907 int rv = 0;
5884 int cnt = 0; 5908 int cnt = 0;
@@ -5971,9 +5995,9 @@ static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
5971 return rv; 5995 return rv;
5972} 5996}
5973 5997
5974static int set_disk_faulty(mddev_t *mddev, dev_t dev) 5998static int set_disk_faulty(struct mddev *mddev, dev_t dev)
5975{ 5999{
5976 mdk_rdev_t *rdev; 6000 struct md_rdev *rdev;
5977 6001
5978 if (mddev->pers == NULL) 6002 if (mddev->pers == NULL)
5979 return -ENODEV; 6003 return -ENODEV;
@@ -5983,6 +6007,8 @@ static int set_disk_faulty(mddev_t *mddev, dev_t dev)
5983 return -ENODEV; 6007 return -ENODEV;
5984 6008
5985 md_error(mddev, rdev); 6009 md_error(mddev, rdev);
6010 if (!test_bit(Faulty, &rdev->flags))
6011 return -EBUSY;
5986 return 0; 6012 return 0;
5987} 6013}
5988 6014
@@ -5994,7 +6020,7 @@ static int set_disk_faulty(mddev_t *mddev, dev_t dev)
5994 */ 6020 */
5995static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo) 6021static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
5996{ 6022{
5997 mddev_t *mddev = bdev->bd_disk->private_data; 6023 struct mddev *mddev = bdev->bd_disk->private_data;
5998 6024
5999 geo->heads = 2; 6025 geo->heads = 2;
6000 geo->sectors = 4; 6026 geo->sectors = 4;
@@ -6007,7 +6033,7 @@ static int md_ioctl(struct block_device *bdev, fmode_t mode,
6007{ 6033{
6008 int err = 0; 6034 int err = 0;
6009 void __user *argp = (void __user *)arg; 6035 void __user *argp = (void __user *)arg;
6010 mddev_t *mddev = NULL; 6036 struct mddev *mddev = NULL;
6011 int ro; 6037 int ro;
6012 6038
6013 if (!capable(CAP_SYS_ADMIN)) 6039 if (!capable(CAP_SYS_ADMIN))
@@ -6270,7 +6296,7 @@ static int md_open(struct block_device *bdev, fmode_t mode)
6270 * Succeed if we can lock the mddev, which confirms that 6296 * Succeed if we can lock the mddev, which confirms that
6271 * it isn't being stopped right now. 6297 * it isn't being stopped right now.
6272 */ 6298 */
6273 mddev_t *mddev = mddev_find(bdev->bd_dev); 6299 struct mddev *mddev = mddev_find(bdev->bd_dev);
6274 int err; 6300 int err;
6275 6301
6276 if (mddev->gendisk != bdev->bd_disk) { 6302 if (mddev->gendisk != bdev->bd_disk) {
@@ -6299,7 +6325,7 @@ static int md_open(struct block_device *bdev, fmode_t mode)
6299 6325
6300static int md_release(struct gendisk *disk, fmode_t mode) 6326static int md_release(struct gendisk *disk, fmode_t mode)
6301{ 6327{
6302 mddev_t *mddev = disk->private_data; 6328 struct mddev *mddev = disk->private_data;
6303 6329
6304 BUG_ON(!mddev); 6330 BUG_ON(!mddev);
6305 atomic_dec(&mddev->openers); 6331 atomic_dec(&mddev->openers);
@@ -6310,14 +6336,14 @@ static int md_release(struct gendisk *disk, fmode_t mode)
6310 6336
6311static int md_media_changed(struct gendisk *disk) 6337static int md_media_changed(struct gendisk *disk)
6312{ 6338{
6313 mddev_t *mddev = disk->private_data; 6339 struct mddev *mddev = disk->private_data;
6314 6340
6315 return mddev->changed; 6341 return mddev->changed;
6316} 6342}
6317 6343
6318static int md_revalidate(struct gendisk *disk) 6344static int md_revalidate(struct gendisk *disk)
6319{ 6345{
6320 mddev_t *mddev = disk->private_data; 6346 struct mddev *mddev = disk->private_data;
6321 6347
6322 mddev->changed = 0; 6348 mddev->changed = 0;
6323 return 0; 6349 return 0;
@@ -6338,7 +6364,7 @@ static const struct block_device_operations md_fops =
6338 6364
6339static int md_thread(void * arg) 6365static int md_thread(void * arg)
6340{ 6366{
6341 mdk_thread_t *thread = arg; 6367 struct md_thread *thread = arg;
6342 6368
6343 /* 6369 /*
6344 * md_thread is a 'system-thread', it's priority should be very 6370 * md_thread is a 'system-thread', it's priority should be very
@@ -6377,21 +6403,21 @@ static int md_thread(void * arg)
6377 return 0; 6403 return 0;
6378} 6404}
6379 6405
6380void md_wakeup_thread(mdk_thread_t *thread) 6406void md_wakeup_thread(struct md_thread *thread)
6381{ 6407{
6382 if (thread) { 6408 if (thread) {
6383 dprintk("md: waking up MD thread %s.\n", thread->tsk->comm); 6409 pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
6384 set_bit(THREAD_WAKEUP, &thread->flags); 6410 set_bit(THREAD_WAKEUP, &thread->flags);
6385 wake_up(&thread->wqueue); 6411 wake_up(&thread->wqueue);
6386 } 6412 }
6387} 6413}
6388 6414
6389mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev, 6415struct md_thread *md_register_thread(void (*run) (struct mddev *), struct mddev *mddev,
6390 const char *name) 6416 const char *name)
6391{ 6417{
6392 mdk_thread_t *thread; 6418 struct md_thread *thread;
6393 6419
6394 thread = kzalloc(sizeof(mdk_thread_t), GFP_KERNEL); 6420 thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
6395 if (!thread) 6421 if (!thread)
6396 return NULL; 6422 return NULL;
6397 6423
@@ -6411,17 +6437,24 @@ mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
6411 return thread; 6437 return thread;
6412} 6438}
6413 6439
6414void md_unregister_thread(mdk_thread_t *thread) 6440void md_unregister_thread(struct md_thread **threadp)
6415{ 6441{
6442 struct md_thread *thread = *threadp;
6416 if (!thread) 6443 if (!thread)
6417 return; 6444 return;
6418 dprintk("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk)); 6445 pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
6446 /* Locking ensures that mddev_unlock does not wake_up a
6447 * non-existent thread
6448 */
6449 spin_lock(&pers_lock);
6450 *threadp = NULL;
6451 spin_unlock(&pers_lock);
6419 6452
6420 kthread_stop(thread->tsk); 6453 kthread_stop(thread->tsk);
6421 kfree(thread); 6454 kfree(thread);
6422} 6455}
6423 6456
6424void md_error(mddev_t *mddev, mdk_rdev_t *rdev) 6457void md_error(struct mddev *mddev, struct md_rdev *rdev)
6425{ 6458{
6426 if (!mddev) { 6459 if (!mddev) {
6427 MD_BUG(); 6460 MD_BUG();
@@ -6450,7 +6483,7 @@ void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
6450static void status_unused(struct seq_file *seq) 6483static void status_unused(struct seq_file *seq)
6451{ 6484{
6452 int i = 0; 6485 int i = 0;
6453 mdk_rdev_t *rdev; 6486 struct md_rdev *rdev;
6454 6487
6455 seq_printf(seq, "unused devices: "); 6488 seq_printf(seq, "unused devices: ");
6456 6489
@@ -6467,7 +6500,7 @@ static void status_unused(struct seq_file *seq)
6467} 6500}
6468 6501
6469 6502
6470static void status_resync(struct seq_file *seq, mddev_t * mddev) 6503static void status_resync(struct seq_file *seq, struct mddev * mddev)
6471{ 6504{
6472 sector_t max_sectors, resync, res; 6505 sector_t max_sectors, resync, res;
6473 unsigned long dt, db; 6506 unsigned long dt, db;
@@ -6558,7 +6591,7 @@ static void *md_seq_start(struct seq_file *seq, loff_t *pos)
6558{ 6591{
6559 struct list_head *tmp; 6592 struct list_head *tmp;
6560 loff_t l = *pos; 6593 loff_t l = *pos;
6561 mddev_t *mddev; 6594 struct mddev *mddev;
6562 6595
6563 if (l >= 0x10000) 6596 if (l >= 0x10000)
6564 return NULL; 6597 return NULL;
@@ -6569,7 +6602,7 @@ static void *md_seq_start(struct seq_file *seq, loff_t *pos)
6569 spin_lock(&all_mddevs_lock); 6602 spin_lock(&all_mddevs_lock);
6570 list_for_each(tmp,&all_mddevs) 6603 list_for_each(tmp,&all_mddevs)
6571 if (!l--) { 6604 if (!l--) {
6572 mddev = list_entry(tmp, mddev_t, all_mddevs); 6605 mddev = list_entry(tmp, struct mddev, all_mddevs);
6573 mddev_get(mddev); 6606 mddev_get(mddev);
6574 spin_unlock(&all_mddevs_lock); 6607 spin_unlock(&all_mddevs_lock);
6575 return mddev; 6608 return mddev;
@@ -6583,7 +6616,7 @@ static void *md_seq_start(struct seq_file *seq, loff_t *pos)
6583static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos) 6616static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
6584{ 6617{
6585 struct list_head *tmp; 6618 struct list_head *tmp;
6586 mddev_t *next_mddev, *mddev = v; 6619 struct mddev *next_mddev, *mddev = v;
6587 6620
6588 ++*pos; 6621 ++*pos;
6589 if (v == (void*)2) 6622 if (v == (void*)2)
@@ -6595,7 +6628,7 @@ static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
6595 else 6628 else
6596 tmp = mddev->all_mddevs.next; 6629 tmp = mddev->all_mddevs.next;
6597 if (tmp != &all_mddevs) 6630 if (tmp != &all_mddevs)
6598 next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs)); 6631 next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
6599 else { 6632 else {
6600 next_mddev = (void*)2; 6633 next_mddev = (void*)2;
6601 *pos = 0x10000; 6634 *pos = 0x10000;
@@ -6610,7 +6643,7 @@ static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
6610 6643
6611static void md_seq_stop(struct seq_file *seq, void *v) 6644static void md_seq_stop(struct seq_file *seq, void *v)
6612{ 6645{
6613 mddev_t *mddev = v; 6646 struct mddev *mddev = v;
6614 6647
6615 if (mddev && v != (void*)1 && v != (void*)2) 6648 if (mddev && v != (void*)1 && v != (void*)2)
6616 mddev_put(mddev); 6649 mddev_put(mddev);
@@ -6618,13 +6651,13 @@ static void md_seq_stop(struct seq_file *seq, void *v)
6618 6651
6619static int md_seq_show(struct seq_file *seq, void *v) 6652static int md_seq_show(struct seq_file *seq, void *v)
6620{ 6653{
6621 mddev_t *mddev = v; 6654 struct mddev *mddev = v;
6622 sector_t sectors; 6655 sector_t sectors;
6623 mdk_rdev_t *rdev; 6656 struct md_rdev *rdev;
6624 struct bitmap *bitmap; 6657 struct bitmap *bitmap;
6625 6658
6626 if (v == (void*)1) { 6659 if (v == (void*)1) {
6627 struct mdk_personality *pers; 6660 struct md_personality *pers;
6628 seq_printf(seq, "Personalities : "); 6661 seq_printf(seq, "Personalities : ");
6629 spin_lock(&pers_lock); 6662 spin_lock(&pers_lock);
6630 list_for_each_entry(pers, &pers_list, list) 6663 list_for_each_entry(pers, &pers_list, list)
@@ -6780,7 +6813,7 @@ static const struct file_operations md_seq_fops = {
6780 .poll = mdstat_poll, 6813 .poll = mdstat_poll,
6781}; 6814};
6782 6815
6783int register_md_personality(struct mdk_personality *p) 6816int register_md_personality(struct md_personality *p)
6784{ 6817{
6785 spin_lock(&pers_lock); 6818 spin_lock(&pers_lock);
6786 list_add_tail(&p->list, &pers_list); 6819 list_add_tail(&p->list, &pers_list);
@@ -6789,7 +6822,7 @@ int register_md_personality(struct mdk_personality *p)
6789 return 0; 6822 return 0;
6790} 6823}
6791 6824
6792int unregister_md_personality(struct mdk_personality *p) 6825int unregister_md_personality(struct md_personality *p)
6793{ 6826{
6794 printk(KERN_INFO "md: %s personality unregistered\n", p->name); 6827 printk(KERN_INFO "md: %s personality unregistered\n", p->name);
6795 spin_lock(&pers_lock); 6828 spin_lock(&pers_lock);
@@ -6798,9 +6831,9 @@ int unregister_md_personality(struct mdk_personality *p)
6798 return 0; 6831 return 0;
6799} 6832}
6800 6833
6801static int is_mddev_idle(mddev_t *mddev, int init) 6834static int is_mddev_idle(struct mddev *mddev, int init)
6802{ 6835{
6803 mdk_rdev_t * rdev; 6836 struct md_rdev * rdev;
6804 int idle; 6837 int idle;
6805 int curr_events; 6838 int curr_events;
6806 6839
@@ -6842,7 +6875,7 @@ static int is_mddev_idle(mddev_t *mddev, int init)
6842 return idle; 6875 return idle;
6843} 6876}
6844 6877
6845void md_done_sync(mddev_t *mddev, int blocks, int ok) 6878void md_done_sync(struct mddev *mddev, int blocks, int ok)
6846{ 6879{
6847 /* another "blocks" (512byte) blocks have been synced */ 6880 /* another "blocks" (512byte) blocks have been synced */
6848 atomic_sub(blocks, &mddev->recovery_active); 6881 atomic_sub(blocks, &mddev->recovery_active);
@@ -6860,7 +6893,7 @@ void md_done_sync(mddev_t *mddev, int blocks, int ok)
6860 * in superblock) before writing, schedule a superblock update 6893 * in superblock) before writing, schedule a superblock update
6861 * and wait for it to complete. 6894 * and wait for it to complete.
6862 */ 6895 */
6863void md_write_start(mddev_t *mddev, struct bio *bi) 6896void md_write_start(struct mddev *mddev, struct bio *bi)
6864{ 6897{
6865 int did_change = 0; 6898 int did_change = 0;
6866 if (bio_data_dir(bi) != WRITE) 6899 if (bio_data_dir(bi) != WRITE)
@@ -6895,7 +6928,7 @@ void md_write_start(mddev_t *mddev, struct bio *bi)
6895 !test_bit(MD_CHANGE_PENDING, &mddev->flags)); 6928 !test_bit(MD_CHANGE_PENDING, &mddev->flags));
6896} 6929}
6897 6930
6898void md_write_end(mddev_t *mddev) 6931void md_write_end(struct mddev *mddev)
6899{ 6932{
6900 if (atomic_dec_and_test(&mddev->writes_pending)) { 6933 if (atomic_dec_and_test(&mddev->writes_pending)) {
6901 if (mddev->safemode == 2) 6934 if (mddev->safemode == 2)
@@ -6914,7 +6947,7 @@ void md_write_end(mddev_t *mddev)
6914 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock 6947 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
6915 * is dropped, so return -EAGAIN after notifying userspace. 6948 * is dropped, so return -EAGAIN after notifying userspace.
6916 */ 6949 */
6917int md_allow_write(mddev_t *mddev) 6950int md_allow_write(struct mddev *mddev)
6918{ 6951{
6919 if (!mddev->pers) 6952 if (!mddev->pers)
6920 return 0; 6953 return 0;
@@ -6946,9 +6979,9 @@ EXPORT_SYMBOL_GPL(md_allow_write);
6946 6979
6947#define SYNC_MARKS 10 6980#define SYNC_MARKS 10
6948#define SYNC_MARK_STEP (3*HZ) 6981#define SYNC_MARK_STEP (3*HZ)
6949void md_do_sync(mddev_t *mddev) 6982void md_do_sync(struct mddev *mddev)
6950{ 6983{
6951 mddev_t *mddev2; 6984 struct mddev *mddev2;
6952 unsigned int currspeed = 0, 6985 unsigned int currspeed = 0,
6953 window; 6986 window;
6954 sector_t max_sectors,j, io_sectors; 6987 sector_t max_sectors,j, io_sectors;
@@ -6958,7 +6991,7 @@ void md_do_sync(mddev_t *mddev)
6958 struct list_head *tmp; 6991 struct list_head *tmp;
6959 sector_t last_check; 6992 sector_t last_check;
6960 int skipped = 0; 6993 int skipped = 0;
6961 mdk_rdev_t *rdev; 6994 struct md_rdev *rdev;
6962 char *desc; 6995 char *desc;
6963 6996
6964 /* just incase thread restarts... */ 6997 /* just incase thread restarts... */
@@ -7273,9 +7306,9 @@ void md_do_sync(mddev_t *mddev)
7273} 7306}
7274EXPORT_SYMBOL_GPL(md_do_sync); 7307EXPORT_SYMBOL_GPL(md_do_sync);
7275 7308
7276static int remove_and_add_spares(mddev_t *mddev) 7309static int remove_and_add_spares(struct mddev *mddev)
7277{ 7310{
7278 mdk_rdev_t *rdev; 7311 struct md_rdev *rdev;
7279 int spares = 0; 7312 int spares = 0;
7280 7313
7281 mddev->curr_resync_completed = 0; 7314 mddev->curr_resync_completed = 0;
@@ -7317,13 +7350,12 @@ static int remove_and_add_spares(mddev_t *mddev)
7317 return spares; 7350 return spares;
7318} 7351}
7319 7352
7320static void reap_sync_thread(mddev_t *mddev) 7353static void reap_sync_thread(struct mddev *mddev)
7321{ 7354{
7322 mdk_rdev_t *rdev; 7355 struct md_rdev *rdev;
7323 7356
7324 /* resync has finished, collect result */ 7357 /* resync has finished, collect result */
7325 md_unregister_thread(mddev->sync_thread); 7358 md_unregister_thread(&mddev->sync_thread);
7326 mddev->sync_thread = NULL;
7327 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) && 7359 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
7328 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) { 7360 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
7329 /* success...*/ 7361 /* success...*/
@@ -7335,15 +7367,19 @@ static void reap_sync_thread(mddev_t *mddev)
7335 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 7367 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7336 mddev->pers->finish_reshape) 7368 mddev->pers->finish_reshape)
7337 mddev->pers->finish_reshape(mddev); 7369 mddev->pers->finish_reshape(mddev);
7338 md_update_sb(mddev, 1);
7339 7370
7340 /* if array is no-longer degraded, then any saved_raid_disk 7371 /* If array is no-longer degraded, then any saved_raid_disk
7341 * information must be scrapped 7372 * information must be scrapped. Also if any device is now
7373 * In_sync we must scrape the saved_raid_disk for that device
7374 * do the superblock for an incrementally recovered device
7375 * written out.
7342 */ 7376 */
7343 if (!mddev->degraded) 7377 list_for_each_entry(rdev, &mddev->disks, same_set)
7344 list_for_each_entry(rdev, &mddev->disks, same_set) 7378 if (!mddev->degraded ||
7379 test_bit(In_sync, &rdev->flags))
7345 rdev->saved_raid_disk = -1; 7380 rdev->saved_raid_disk = -1;
7346 7381
7382 md_update_sb(mddev, 1);
7347 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery); 7383 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7348 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery); 7384 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7349 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery); 7385 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
@@ -7379,7 +7415,7 @@ static void reap_sync_thread(mddev_t *mddev)
7379 * 5/ If array is degraded, try to add spares devices 7415 * 5/ If array is degraded, try to add spares devices
7380 * 6/ If array has spares or is not in-sync, start a resync thread. 7416 * 6/ If array has spares or is not in-sync, start a resync thread.
7381 */ 7417 */
7382void md_check_recovery(mddev_t *mddev) 7418void md_check_recovery(struct mddev *mddev)
7383{ 7419{
7384 if (mddev->suspended) 7420 if (mddev->suspended)
7385 return; 7421 return;
@@ -7415,7 +7451,7 @@ void md_check_recovery(mddev_t *mddev)
7415 /* Only thing we do on a ro array is remove 7451 /* Only thing we do on a ro array is remove
7416 * failed devices. 7452 * failed devices.
7417 */ 7453 */
7418 mdk_rdev_t *rdev; 7454 struct md_rdev *rdev;
7419 list_for_each_entry(rdev, &mddev->disks, same_set) 7455 list_for_each_entry(rdev, &mddev->disks, same_set)
7420 if (rdev->raid_disk >= 0 && 7456 if (rdev->raid_disk >= 0 &&
7421 !test_bit(Blocked, &rdev->flags) && 7457 !test_bit(Blocked, &rdev->flags) &&
@@ -7539,7 +7575,7 @@ void md_check_recovery(mddev_t *mddev)
7539 } 7575 }
7540} 7576}
7541 7577
7542void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev) 7578void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
7543{ 7579{
7544 sysfs_notify_dirent_safe(rdev->sysfs_state); 7580 sysfs_notify_dirent_safe(rdev->sysfs_state);
7545 wait_event_timeout(rdev->blocked_wait, 7581 wait_event_timeout(rdev->blocked_wait,
@@ -7797,7 +7833,7 @@ static int md_set_badblocks(struct badblocks *bb, sector_t s, int sectors,
7797 return rv; 7833 return rv;
7798} 7834}
7799 7835
7800int rdev_set_badblocks(mdk_rdev_t *rdev, sector_t s, int sectors, 7836int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
7801 int acknowledged) 7837 int acknowledged)
7802{ 7838{
7803 int rv = md_set_badblocks(&rdev->badblocks, 7839 int rv = md_set_badblocks(&rdev->badblocks,
@@ -7906,7 +7942,7 @@ out:
7906 return rv; 7942 return rv;
7907} 7943}
7908 7944
7909int rdev_clear_badblocks(mdk_rdev_t *rdev, sector_t s, int sectors) 7945int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors)
7910{ 7946{
7911 return md_clear_badblocks(&rdev->badblocks, 7947 return md_clear_badblocks(&rdev->badblocks,
7912 s + rdev->data_offset, 7948 s + rdev->data_offset,
@@ -8040,13 +8076,14 @@ static int md_notify_reboot(struct notifier_block *this,
8040 unsigned long code, void *x) 8076 unsigned long code, void *x)
8041{ 8077{
8042 struct list_head *tmp; 8078 struct list_head *tmp;
8043 mddev_t *mddev; 8079 struct mddev *mddev;
8080 int need_delay = 0;
8044 8081
8045 if ((code == SYS_DOWN) || (code == SYS_HALT) || (code == SYS_POWER_OFF)) { 8082 if ((code == SYS_DOWN) || (code == SYS_HALT) || (code == SYS_POWER_OFF)) {
8046 8083
8047 printk(KERN_INFO "md: stopping all md devices.\n"); 8084 printk(KERN_INFO "md: stopping all md devices.\n");
8048 8085
8049 for_each_mddev(mddev, tmp) 8086 for_each_mddev(mddev, tmp) {
8050 if (mddev_trylock(mddev)) { 8087 if (mddev_trylock(mddev)) {
8051 /* Force a switch to readonly even array 8088 /* Force a switch to readonly even array
8052 * appears to still be in use. Hence 8089 * appears to still be in use. Hence
@@ -8055,13 +8092,16 @@ static int md_notify_reboot(struct notifier_block *this,
8055 md_set_readonly(mddev, 100); 8092 md_set_readonly(mddev, 100);
8056 mddev_unlock(mddev); 8093 mddev_unlock(mddev);
8057 } 8094 }
8095 need_delay = 1;
8096 }
8058 /* 8097 /*
8059 * certain more exotic SCSI devices are known to be 8098 * certain more exotic SCSI devices are known to be
8060 * volatile wrt too early system reboots. While the 8099 * volatile wrt too early system reboots. While the
8061 * right place to handle this issue is the given 8100 * right place to handle this issue is the given
8062 * driver, we do want to have a safe RAID driver ... 8101 * driver, we do want to have a safe RAID driver ...
8063 */ 8102 */
8064 mdelay(1000*1); 8103 if (need_delay)
8104 mdelay(1000*1);
8065 } 8105 }
8066 return NOTIFY_DONE; 8106 return NOTIFY_DONE;
8067} 8107}
@@ -8074,7 +8114,7 @@ static struct notifier_block md_notifier = {
8074 8114
8075static void md_geninit(void) 8115static void md_geninit(void)
8076{ 8116{
8077 dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t)); 8117 pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
8078 8118
8079 proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops); 8119 proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
8080} 8120}
@@ -8149,7 +8189,7 @@ void md_autodetect_dev(dev_t dev)
8149 8189
8150static void autostart_arrays(int part) 8190static void autostart_arrays(int part)
8151{ 8191{
8152 mdk_rdev_t *rdev; 8192 struct md_rdev *rdev;
8153 struct detected_devices_node *node_detected_dev; 8193 struct detected_devices_node *node_detected_dev;
8154 dev_t dev; 8194 dev_t dev;
8155 int i_scanned, i_passed; 8195 int i_scanned, i_passed;
@@ -8189,7 +8229,7 @@ static void autostart_arrays(int part)
8189 8229
8190static __exit void md_exit(void) 8230static __exit void md_exit(void)
8191{ 8231{
8192 mddev_t *mddev; 8232 struct mddev *mddev;
8193 struct list_head *tmp; 8233 struct list_head *tmp;
8194 8234
8195 blk_unregister_region(MKDEV(MD_MAJOR,0), 1U << MINORBITS); 8235 blk_unregister_region(MKDEV(MD_MAJOR,0), 1U << MINORBITS);
generated by cgit v1.2.2 (git 2.25.0) at 2025-10-09 19:01:07 -0400