From 480f41061c3442a39824591c4767ab6bdbe860f9 Mon Sep 17 00:00:00 2001 From: Alexander Viro Date: Thu, 4 Jul 2002 08:53:33 -0700 Subject: [PATCH] raid kdev_t cleanups (part 1) * ->error_handler() switched to struct block_device *. * md_sync_acct() switched to struct block_device *. * raid5 struct disk_info ->dev is gone - we use ->bdev everywhere. * bunch of kdev_same() when we have corresponding struct block_device * and can simply compare them is removed from drivers/md/*.c --- include/linux/raid/md.h | 2 +- include/linux/raid/md_k.h | 2 +- include/linux/raid/raid5.h | 1 - 3 files changed, 2 insertions(+), 3 deletions(-) (limited to 'include/linux/raid') diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h index 19ebeb0a4988..6dfe08ccfbfe 100644 --- a/include/linux/raid/md.h +++ b/include/linux/raid/md.h @@ -77,7 +77,7 @@ extern void md_wakeup_thread(mdk_thread_t *thread); extern void md_interrupt_thread (mdk_thread_t *thread); extern void md_update_sb (mddev_t *mddev); extern void md_done_sync(mddev_t *mddev, int blocks, int ok); -extern void md_sync_acct(kdev_t dev, unsigned long nr_sectors); +extern void md_sync_acct(struct block_device *bdev, unsigned long nr_sectors); extern int md_error (mddev_t *mddev, struct block_device *bdev); extern int md_run_setup(void); diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h index e238bd222ea2..69282d99a9eb 100644 --- a/include/linux/raid/md_k.h +++ b/include/linux/raid/md_k.h @@ -213,7 +213,7 @@ struct mdk_personality_s int (*run)(mddev_t *mddev); int (*stop)(mddev_t *mddev); int (*status)(char *page, mddev_t *mddev); - int (*error_handler)(mddev_t *mddev, kdev_t dev); + int (*error_handler)(mddev_t *mddev, struct block_device *bdev); /* * Some personalities (RAID-1, RAID-5) can have disks hot-added and diff --git a/include/linux/raid/raid5.h b/include/linux/raid/raid5.h index e14864259ffd..7f8beb8acdaa 100644 --- a/include/linux/raid/raid5.h +++ b/include/linux/raid/raid5.h @@ -192,7 +192,6 @@ struct stripe_head { struct disk_info { - kdev_t dev; struct block_device *bdev; int operational; int number; -- cgit v1.2.3 From f3ddcd6baa20805fea6fe560471f91b0b24fa2e5 Mon Sep 17 00:00:00 2001 From: Alexander Viro Date: Thu, 4 Jul 2002 08:53:39 -0700 Subject: [PATCH] raid ->diskop() splitup * ->diskop() split into individual methods; prototypes cleaned up. In particular, handling of hot_add_disk() gets mdk_rdev_t * of the component we are adding as an argument instead of playing the games with major/minor. Code cleaned up. --- drivers/md/md.c | 29 ++-- drivers/md/multipath.c | 423 ++++++++++++++++++++++---------------------- drivers/md/raid1.c | 424 ++++++++++++++++++++++---------------------- drivers/md/raid5.c | 434 +++++++++++++++++++++------------------------- fs/partitions/check.c | 7 +- include/linux/raid/md_k.h | 27 +-- 6 files changed, 632 insertions(+), 712 deletions(-) (limited to 'include/linux/raid') diff --git a/drivers/md/md.c b/drivers/md/md.c index 433b3c578cb6..c050810ab535 100644 --- a/drivers/md/md.c +++ b/drivers/md/md.c @@ -1741,8 +1741,7 @@ static int do_md_stop(mddev_t * mddev, int ro) md_unregister_thread(mddev->sync_thread); mddev->sync_thread = NULL; if (mddev->spare) { - mddev->pers->diskop(mddev, &mddev->spare, - DISKOP_SPARE_INACTIVE); + mddev->pers->spare_inactive(mddev); mddev->spare = NULL; } } @@ -2250,7 +2249,7 @@ static int hot_remove_disk(mddev_t * mddev, kdev_t dev) printk(KERN_INFO "md: trying to remove %s from md%d ... \n", partition_name(dev), mdidx(mddev)); - if (!mddev->pers->diskop) { + if (!mddev->pers->hot_remove_disk) { printk(KERN_WARNING "md%d: personality does not support diskops!\n", mdidx(mddev)); return -EINVAL; @@ -2274,7 +2273,7 @@ static int hot_remove_disk(mddev_t * mddev, kdev_t dev) return -EINVAL; } - err = mddev->pers->diskop(mddev, &disk, DISKOP_HOT_REMOVE_DISK); + err = mddev->pers->hot_remove_disk(mddev, disk->number); if (err == -EBUSY) { MD_BUG(); goto busy; @@ -2308,7 +2307,7 @@ static int hot_add_disk(mddev_t * mddev, kdev_t dev) printk(KERN_INFO "md: trying to hot-add %s to md%d ... \n", partition_name(dev), mdidx(mddev)); - if (!mddev->pers->diskop) { + if (!mddev->pers->hot_add_disk) { printk(KERN_WARNING "md%d: personality does not support diskops!\n", mdidx(mddev)); return -EINVAL; @@ -2388,7 +2387,7 @@ static int hot_add_disk(mddev_t * mddev, kdev_t dev) disk->major = major(dev); disk->minor = minor(dev); - if (mddev->pers->diskop(mddev, &disk, DISKOP_HOT_ADD_DISK)) { + if (mddev->pers->hot_add_disk(mddev, disk, rdev)) { MD_BUG(); err = -EINVAL; goto abort_unbind_export; @@ -3370,7 +3369,7 @@ void md_do_recovery(void *data) ITERATE_MDDEV(mddev,tmp) if (mddev_lock(mddev)==0) { sb = mddev->sb; - if (!sb || !mddev->pers || !mddev->pers->diskop || mddev->ro) + if (!sb || !mddev->pers || mddev->ro) goto unlock; if (mddev->recovery_running > 0) /* resync/recovery still happening */ @@ -3384,16 +3383,19 @@ void md_do_recovery(void *data) * If we were doing a reconstruction, * we need to retrieve the spare */ + if (!mddev->pers->spare_inactive) + goto unlock; if (mddev->spare) { - mddev->pers->diskop(mddev, &mddev->spare, - DISKOP_SPARE_INACTIVE); + mddev->pers->spare_inactive(mddev); mddev->spare = NULL; } } else { + if (!mddev->pers->spare_active) + goto unlock; /* success...*/ if (mddev->spare) { - mddev->pers->diskop(mddev, &mddev->spare, - DISKOP_SPARE_ACTIVE); + mddev->pers->spare_active(mddev, + &mddev->spare); mark_disk_sync(mddev->spare); mark_disk_active(mddev->spare); sb->active_disks++; @@ -3432,12 +3434,13 @@ void md_do_recovery(void *data) if (!mddev->sync_thread) { printk(KERN_ERR "md%d: could not start resync thread...\n", mdidx(mddev)); if (mddev->spare) - mddev->pers->diskop(mddev, &mddev->spare, DISKOP_SPARE_INACTIVE); + mddev->pers->spare_inactive(mddev); mddev->spare = NULL; mddev->recovery_running = 0; } else { if (mddev->spare) - mddev->pers->diskop(mddev, &mddev->spare, DISKOP_SPARE_WRITE); + mddev->pers->spare_write(mddev, + mddev->spare->number); mddev->recovery_running = 1; md_wakeup_thread(mddev->sync_thread); } diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c index 87cfa0735212..97e6fc1d52de 100644 --- a/drivers/md/multipath.c +++ b/drivers/md/multipath.c @@ -55,9 +55,8 @@ static mdk_personality_t multipath_personality; static spinlock_t retry_list_lock = SPIN_LOCK_UNLOCKED; struct multipath_bh *multipath_retry_list = NULL, **multipath_retry_tail; -static int multipath_diskop(mddev_t *mddev, mdp_disk_t **d, int state); - - +static int multipath_spare_write(mddev_t *, int); +static int multipath_spare_active(mddev_t *mddev, mdp_disk_t **d); static struct multipath_bh *multipath_alloc_mpbh(multipath_conf_t *conf) { @@ -366,11 +365,11 @@ static int multipath_error (mddev_t *mddev, struct block_device *bdev) spare = get_spare(mddev); if (spare) { - err = multipath_diskop(mddev, &spare, DISKOP_SPARE_WRITE); + err = multipath_spare_write(mddev, spare->number); printk("got DISKOP_SPARE_WRITE err: %d. (spare_faulty(): %d)\n", err, disk_faulty(spare)); } if (!err && !disk_faulty(spare)) { - multipath_diskop(mddev, &spare, DISKOP_SPARE_ACTIVE); + multipath_spare_active(mddev, &spare); mark_disk_sync(spare); mark_disk_active(spare); sb->active_disks++; @@ -410,255 +409,238 @@ static void print_multipath_conf (multipath_conf_t *conf) } } -static int multipath_diskop(mddev_t *mddev, mdp_disk_t **d, int state) +/* + * Find the spare disk ... (can only be in the 'high' area of the array) + */ +static struct multipath_info *find_spare(mddev_t *mddev, int number) { - int err = 0; - int i, failed_disk=-1, spare_disk=-1, removed_disk=-1, added_disk=-1; multipath_conf_t *conf = mddev->private; - struct multipath_info *tmp, *sdisk, *fdisk, *rdisk, *adisk; - mdp_super_t *sb = mddev->sb; - mdp_disk_t *failed_desc, *spare_desc, *added_desc; - mdk_rdev_t *spare_rdev, *failed_rdev; - struct block_device *bdev; + int i; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + struct multipath_info *p = conf->multipaths + i; + if (p->spare && p->number == number) + return p; + } + return NULL; +} + +static int multipath_spare_inactive(mddev_t *mddev) +{ + multipath_conf_t *conf = mddev->private; + struct multipath_info *p; + int err = 0; print_multipath_conf(conf); spin_lock_irq(&conf->device_lock); - /* - * find the disk ... - */ - switch (state) { - - case DISKOP_SPARE_ACTIVE: + p = find_spare(mddev, mddev->spare->number); + if (p) { + p->operational = 0; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); - /* - * Find the failed disk within the MULTIPATH configuration ... - * (this can only be in the first conf->working_disks part) - */ - for (i = 0; i < conf->raid_disks; i++) { - tmp = conf->multipaths + i; - if ((!tmp->operational && !tmp->spare) || - !tmp->used_slot) { - failed_disk = i; - break; - } - } - /* - * When we activate a spare disk we _must_ have a disk in - * the lower (active) part of the array to replace. - */ - if ((failed_disk == -1) || (failed_disk >= conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; - } - /* fall through */ + print_multipath_conf(conf); + return err; +} - case DISKOP_SPARE_WRITE: - case DISKOP_SPARE_INACTIVE: +static int multipath_spare_write(mddev_t *mddev, int number) +{ + multipath_conf_t *conf = mddev->private; + struct multipath_info *p; + int err = 0; - /* - * Find the spare disk ... (can only be in the 'high' - * area of the array) - */ - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->multipaths + i; - if (tmp->spare && tmp->number == (*d)->number) { - spare_disk = i; - break; - } - } - if (spare_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; - - case DISKOP_HOT_REMOVE_DISK: - - for (i = 0; i < MD_SB_DISKS; i++) { - tmp = conf->multipaths + i; - if (tmp->used_slot && (tmp->number == (*d)->number)) { - if (tmp->operational) { - printk(KERN_ERR "hot-remove-disk, slot %d is identified to be the requested disk (number %d), but is still operational!\n", i, (*d)->number); - err = -EBUSY; - goto abort; - } - removed_disk = i; - break; - } - } - if (removed_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; + print_multipath_conf(conf); + spin_lock_irq(&conf->device_lock); + p = find_spare(mddev, number); + if (p) { + p->operational = 1; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); - case DISKOP_HOT_ADD_DISK: + print_multipath_conf(conf); + return err; +} - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->multipaths + i; - if (!tmp->used_slot) { - added_disk = i; - break; - } - } - if (added_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; - } +static int multipath_spare_active(mddev_t *mddev, mdp_disk_t **d) +{ + int err = 0; + int i, failed_disk=-1, spare_disk=-1; + multipath_conf_t *conf = mddev->private; + struct multipath_info *tmp, *sdisk, *fdisk; + mdp_super_t *sb = mddev->sb; + mdp_disk_t *failed_desc, *spare_desc; + mdk_rdev_t *spare_rdev, *failed_rdev; - switch (state) { + print_multipath_conf(conf); + spin_lock_irq(&conf->device_lock); /* - * Switch the spare disk to write-only mode: + * Find the failed disk within the MULTIPATH configuration ... + * (this can only be in the first conf->working_disks part) */ - case DISKOP_SPARE_WRITE: - sdisk = conf->multipaths + spare_disk; - sdisk->operational = 1; - break; + for (i = 0; i < conf->raid_disks; i++) { + tmp = conf->multipaths + i; + if ((!tmp->operational && !tmp->spare) || + !tmp->used_slot) { + failed_disk = i; + break; + } + } /* - * Deactivate a spare disk: + * When we activate a spare disk we _must_ have a disk in + * the lower (active) part of the array to replace. */ - case DISKOP_SPARE_INACTIVE: - sdisk = conf->multipaths + spare_disk; - sdisk->operational = 0; - break; + if (failed_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } /* - * Activate (mark read-write) the (now sync) spare disk, - * which means we switch it's 'raid position' (->raid_disk) - * with the failed disk. (only the first 'conf->nr_disks' - * slots are used for 'real' disks and we must preserve this - * property) + * Find the spare disk ... (can only be in the 'high' + * area of the array) */ - case DISKOP_SPARE_ACTIVE: - sdisk = conf->multipaths + spare_disk; - fdisk = conf->multipaths + failed_disk; - - spare_desc = &sb->disks[sdisk->number]; - failed_desc = &sb->disks[fdisk->number]; - - if (spare_desc != *d) { - MD_BUG(); - err = 1; - goto abort; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + tmp = conf->multipaths + i; + if (tmp->spare && tmp->number == (*d)->number) { + spare_disk = i; + break; } + } + if (spare_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } - if (spare_desc->raid_disk != sdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - if (sdisk->raid_disk != spare_disk) { - MD_BUG(); - err = 1; - goto abort; - } + sdisk = conf->multipaths + spare_disk; + fdisk = conf->multipaths + failed_disk; - if (failed_desc->raid_disk != fdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } + spare_desc = &sb->disks[sdisk->number]; + failed_desc = &sb->disks[fdisk->number]; - if (fdisk->raid_disk != failed_disk) { - MD_BUG(); - err = 1; - goto abort; - } + if (spare_desc != *d || spare_desc->raid_disk != sdisk->raid_disk || + sdisk->raid_disk != spare_disk || fdisk->raid_disk != failed_disk || + failed_desc->raid_disk != fdisk->raid_disk) { + MD_BUG(); + err = 1; + goto abort; + } - /* - * do the switch finally - */ - spare_rdev = find_rdev_nr(mddev, spare_desc->number); - failed_rdev = find_rdev_nr(mddev, failed_desc->number); - xchg_values(spare_rdev->desc_nr, failed_rdev->desc_nr); - spare_rdev->alias_device = 0; - failed_rdev->alias_device = 1; + /* + * do the switch finally + */ + spare_rdev = find_rdev_nr(mddev, spare_desc->number); + failed_rdev = find_rdev_nr(mddev, failed_desc->number); + xchg_values(spare_rdev->desc_nr, failed_rdev->desc_nr); + spare_rdev->alias_device = 0; + failed_rdev->alias_device = 1; - xchg_values(*spare_desc, *failed_desc); - xchg_values(*fdisk, *sdisk); + xchg_values(*spare_desc, *failed_desc); + xchg_values(*fdisk, *sdisk); - /* - * (careful, 'failed' and 'spare' are switched from now on) - * - * we want to preserve linear numbering and we want to - * give the proper raid_disk number to the now activated - * disk. (this means we switch back these values) - */ - - xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); - xchg_values(sdisk->raid_disk, fdisk->raid_disk); - xchg_values(spare_desc->number, failed_desc->number); - xchg_values(sdisk->number, fdisk->number); + /* + * (careful, 'failed' and 'spare' are switched from now on) + * + * we want to preserve linear numbering and we want to + * give the proper raid_disk number to the now activated + * disk. (this means we switch back these values) + */ - *d = failed_desc; + xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); + xchg_values(sdisk->raid_disk, fdisk->raid_disk); + xchg_values(spare_desc->number, failed_desc->number); + xchg_values(sdisk->number, fdisk->number); - if (!sdisk->bdev) - sdisk->used_slot = 0; - /* - * this really activates the spare. - */ - fdisk->spare = 0; + *d = failed_desc; - /* - * if we activate a spare, we definitely replace a - * non-operational disk slot in the 'low' area of - * the disk array. - */ + if (!sdisk->bdev) + sdisk->used_slot = 0; + /* + * this really activates the spare. + */ + fdisk->spare = 0; - conf->working_disks++; + /* + * if we activate a spare, we definitely replace a + * non-operational disk slot in the 'low' area of + * the disk array. + */ - break; + conf->working_disks++; +abort: + spin_unlock_irq(&conf->device_lock); - case DISKOP_HOT_REMOVE_DISK: - rdisk = conf->multipaths + removed_disk; + print_multipath_conf(conf); + return err; +} - if (rdisk->spare && (removed_disk < conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; - } - bdev = rdisk->bdev; - rdisk->dev = NODEV; - rdisk->bdev = NULL; - rdisk->used_slot = 0; - conf->nr_disks--; - bdput(bdev); - break; - - case DISKOP_HOT_ADD_DISK: - adisk = conf->multipaths + added_disk; - added_desc = *d; - - if (added_disk != added_desc->number) { - MD_BUG(); - err = 1; - goto abort; +static int multipath_add_disk(mddev_t *mddev, mdp_disk_t *added_desc, + mdk_rdev_t *rdev) +{ + multipath_conf_t *conf = mddev->private; + int err = 1; + int i; + + print_multipath_conf(conf); + spin_lock_irq(&conf->device_lock); + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + struct multipath_info *p = conf->multipaths + i; + if (!p->used_slot) { + if (added_desc->number != i) + break; + p->number = added_desc->number; + p->raid_disk = added_desc->raid_disk; + p->dev = rdev->dev; + p->bdev = rdev->bdev; + p->operational = 0; + p->spare = 1; + p->used_slot = 1; + conf->nr_disks++; + err = 0; + break; } + } + if (err) + MD_BUG(); + spin_unlock_irq(&conf->device_lock); - adisk->number = added_desc->number; - adisk->raid_disk = added_desc->raid_disk; - adisk->dev = mk_kdev(added_desc->major,added_desc->minor); - /* it will be held open by rdev */ - adisk->bdev = bdget(kdev_t_to_nr(adisk->dev)); + print_multipath_conf(conf); + return err; +} - adisk->operational = 0; - adisk->spare = 1; - adisk->used_slot = 1; - conf->nr_disks++; +static int multipath_remove_disk(mddev_t *mddev, int number) +{ + multipath_conf_t *conf = mddev->private; + int err = 1; + int i; - break; + print_multipath_conf(conf); + spin_lock_irq(&conf->device_lock); - default: - MD_BUG(); - err = 1; - goto abort; + for (i = 0; i < MD_SB_DISKS; i++) { + struct multipath_info *p = conf->multipaths + i; + if (p->used_slot && (p->number == number)) { + if (p->operational) { + printk(KERN_ERR "hot-remove-disk, slot %d is identified to be the requested disk (number %d), but is still operational!\n", i, number); + err = -EBUSY; + goto abort; + } + if (p->spare && i < conf->raid_disks) + break; + p->dev = NODEV; + p->bdev = NULL; + p->used_slot = 0; + conf->nr_disks--; + err = 0; + break; + } } + if (err) + MD_BUG(); abort: spin_unlock_irq(&conf->device_lock); @@ -666,7 +648,6 @@ abort: return err; } - #define IO_ERROR KERN_ALERT \ "multipath: %s: unrecoverable IO read error for block %lu\n" @@ -1074,7 +1055,11 @@ static mdk_personality_t multipath_personality= stop: multipath_stop, status: multipath_status, error_handler: multipath_error, - diskop: multipath_diskop, + hot_add_disk: multipath_add_disk, + hot_remove_disk:multipath_remove_disk, + spare_inactive: multipath_spare_inactive, + spare_active: multipath_spare_active, + spare_write: multipath_spare_write, }; static int __init multipath_init (void) diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c index b996922b3347..76e2de202458 100644 --- a/drivers/md/raid1.c +++ b/drivers/md/raid1.c @@ -658,263 +658,244 @@ static void close_sync(conf_t *conf) conf->r1buf_pool = NULL; } -static int diskop(mddev_t *mddev, mdp_disk_t **d, int state) +static mirror_info_t *find_spare(mddev_t *mddev, int number) +{ + conf_t *conf = mddev->private; + int i; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + mirror_info_t *p = conf->mirrors + i; + if (p->spare && p->number == number) + return p; + } + return NULL; +} + +static int raid1_spare_active(mddev_t *mddev, mdp_disk_t **d) { int err = 0; - int i, failed_disk = -1, spare_disk = -1, removed_disk = -1, added_disk = -1; + int i, failed_disk = -1, spare_disk = -1; conf_t *conf = mddev->private; - mirror_info_t *tmp, *sdisk, *fdisk, *rdisk, *adisk; + mirror_info_t *tmp, *sdisk, *fdisk; mdp_super_t *sb = mddev->sb; - mdp_disk_t *failed_desc, *spare_desc, *added_desc; + mdp_disk_t *failed_desc, *spare_desc; mdk_rdev_t *spare_rdev, *failed_rdev; - struct block_device *bdev; print_conf(conf); spin_lock_irq(&conf->device_lock); /* - * find the disk ... + * Find the failed disk within the RAID1 configuration ... + * (this can only be in the first conf->working_disks part) */ - switch (state) { - - case DISKOP_SPARE_ACTIVE: - - /* - * Find the failed disk within the RAID1 configuration ... - * (this can only be in the first conf->working_disks part) - */ - for (i = 0; i < conf->raid_disks; i++) { - tmp = conf->mirrors + i; - if ((!tmp->operational && !tmp->spare) || - !tmp->used_slot) { - failed_disk = i; - break; - } + for (i = 0; i < conf->raid_disks; i++) { + tmp = conf->mirrors + i; + if ((!tmp->operational && !tmp->spare) || + !tmp->used_slot) { + failed_disk = i; + break; } - /* - * When we activate a spare disk we _must_ have a disk in - * the lower (active) part of the array to replace. - */ - if ((failed_disk == -1) || (failed_disk >= conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; + } + /* + * When we activate a spare disk we _must_ have a disk in + * the lower (active) part of the array to replace. + */ + if (failed_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } + /* + * Find the spare disk ... (can only be in the 'high' + * area of the array) + */ + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + tmp = conf->mirrors + i; + if (tmp->spare && tmp->number == (*d)->number) { + spare_disk = i; + break; } - /* fall through */ - - case DISKOP_SPARE_WRITE: - case DISKOP_SPARE_INACTIVE: + } + if (spare_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } - /* - * Find the spare disk ... (can only be in the 'high' - * area of the array) - */ - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->mirrors + i; - if (tmp->spare && tmp->number == (*d)->number) { - spare_disk = i; - break; - } - } - if (spare_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; - - case DISKOP_HOT_REMOVE_DISK: - - for (i = 0; i < MD_SB_DISKS; i++) { - tmp = conf->mirrors + i; - if (tmp->used_slot && (tmp->number == (*d)->number)) { - if (tmp->operational) { - err = -EBUSY; - goto abort; - } - removed_disk = i; - break; - } - } - if (removed_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; + sdisk = conf->mirrors + spare_disk; + fdisk = conf->mirrors + failed_disk; - case DISKOP_HOT_ADD_DISK: + spare_desc = &sb->disks[sdisk->number]; + failed_desc = &sb->disks[fdisk->number]; - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->mirrors + i; - if (!tmp->used_slot) { - added_disk = i; - break; - } - } - if (added_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; + if (spare_desc != *d || spare_desc->raid_disk != sdisk->raid_disk || + sdisk->raid_disk != spare_disk || fdisk->raid_disk != failed_disk || + failed_desc->raid_disk != fdisk->raid_disk) { + MD_BUG(); + err = 1; + goto abort; } - switch (state) { - /* - * Switch the spare disk to write-only mode: - */ - case DISKOP_SPARE_WRITE: - sdisk = conf->mirrors + spare_disk; - sdisk->operational = 1; - sdisk->write_only = 1; - break; /* - * Deactivate a spare disk: + * do the switch finally */ - case DISKOP_SPARE_INACTIVE: - sdisk = conf->mirrors + spare_disk; - sdisk->operational = 0; - sdisk->write_only = 0; - break; + spare_rdev = find_rdev_nr(mddev, spare_desc->number); + failed_rdev = find_rdev_nr(mddev, failed_desc->number); + /* - * Activate (mark read-write) the (now sync) spare disk, - * which means we switch it's 'raid position' (->raid_disk) - * with the failed disk. (only the first 'conf->nr_disks' - * slots are used for 'real' disks and we must preserve this - * property) + * There must be a spare_rdev, but there may not be a + * failed_rdev. That slot might be empty... */ - case DISKOP_SPARE_ACTIVE: - sdisk = conf->mirrors + spare_disk; - fdisk = conf->mirrors + failed_disk; - - spare_desc = &sb->disks[sdisk->number]; - failed_desc = &sb->disks[fdisk->number]; - - if (spare_desc != *d) { - MD_BUG(); - err = 1; - goto abort; - } + spare_rdev->desc_nr = failed_desc->number; + if (failed_rdev) + failed_rdev->desc_nr = spare_desc->number; - if (spare_desc->raid_disk != sdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - if (sdisk->raid_disk != spare_disk) { - MD_BUG(); - err = 1; - goto abort; - } + xchg_values(*spare_desc, *failed_desc); + xchg_values(*fdisk, *sdisk); - if (failed_desc->raid_disk != fdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - if (fdisk->raid_disk != failed_disk) { - MD_BUG(); - err = 1; - goto abort; - } + /* + * (careful, 'failed' and 'spare' are switched from now on) + * + * we want to preserve linear numbering and we want to + * give the proper raid_disk number to the now activated + * disk. (this means we switch back these values) + */ + xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); + xchg_values(sdisk->raid_disk, fdisk->raid_disk); + xchg_values(spare_desc->number, failed_desc->number); + xchg_values(sdisk->number, fdisk->number); - /* - * do the switch finally - */ - spare_rdev = find_rdev_nr(mddev, spare_desc->number); - failed_rdev = find_rdev_nr(mddev, failed_desc->number); + *d = failed_desc; - /* - * There must be a spare_rdev, but there may not be a - * failed_rdev. That slot might be empty... - */ - spare_rdev->desc_nr = failed_desc->number; - if (failed_rdev) - failed_rdev->desc_nr = spare_desc->number; + if (!sdisk->bdev) + sdisk->used_slot = 0; + /* + * this really activates the spare. + */ + fdisk->spare = 0; + fdisk->write_only = 0; - xchg_values(*spare_desc, *failed_desc); - xchg_values(*fdisk, *sdisk); + /* + * if we activate a spare, we definitely replace a + * non-operational disk slot in the 'low' area of + * the disk array. + */ - /* - * (careful, 'failed' and 'spare' are switched from now on) - * - * we want to preserve linear numbering and we want to - * give the proper raid_disk number to the now activated - * disk. (this means we switch back these values) - */ - xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); - xchg_values(sdisk->raid_disk, fdisk->raid_disk); - xchg_values(spare_desc->number, failed_desc->number); - xchg_values(sdisk->number, fdisk->number); + conf->working_disks++; +abort: + spin_unlock_irq(&conf->device_lock); - *d = failed_desc; + print_conf(conf); + return err; +} - if (!sdisk->bdev) - sdisk->used_slot = 0; - /* - * this really activates the spare. - */ - fdisk->spare = 0; - fdisk->write_only = 0; +static int raid1_spare_inactive(mddev_t *mddev) +{ + conf_t *conf = mddev->private; + mirror_info_t *p; + int err = 0; - /* - * if we activate a spare, we definitely replace a - * non-operational disk slot in the 'low' area of - * the disk array. - */ + print_conf(conf); + spin_lock_irq(&conf->device_lock); + p = find_spare(mddev, mddev->spare->number); + if (p) { + p->operational = 0; + p->write_only = 0; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); + print_conf(conf); + return err; +} - conf->working_disks++; +static int raid1_spare_write(mddev_t *mddev, int number) +{ + conf_t *conf = mddev->private; + mirror_info_t *p; + int err = 0; - break; + print_conf(conf); + spin_lock_irq(&conf->device_lock); + p = find_spare(mddev, number); + if (p) { + p->operational = 1; + p->write_only = 1; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); + print_conf(conf); + return err; +} - case DISKOP_HOT_REMOVE_DISK: - rdisk = conf->mirrors + removed_disk; +static int raid1_add_disk(mddev_t *mddev, mdp_disk_t *added_desc, + mdk_rdev_t *rdev) +{ + conf_t *conf = mddev->private; + int err = 1; + int i; - if (rdisk->spare && (removed_disk < conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; - } - bdev = rdisk->bdev; - rdisk->dev = NODEV; - rdisk->bdev = NULL; - rdisk->used_slot = 0; - conf->nr_disks--; - bdput(bdev); - break; - - case DISKOP_HOT_ADD_DISK: - adisk = conf->mirrors + added_disk; - added_desc = *d; - - if (added_disk != added_desc->number) { - MD_BUG(); - err = 1; - goto abort; + print_conf(conf); + spin_lock_irq(&conf->device_lock); + /* + * find the disk ... + */ + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + mirror_info_t *p = conf->mirrors + i; + if (!p->used_slot) { + if (added_desc->number != i) + break; + p->number = added_desc->number; + p->raid_disk = added_desc->raid_disk; + p->dev = rdev->dev; + /* it will be held open by rdev */ + p->bdev = rdev->bdev; + p->operational = 0; + p->write_only = 0; + p->spare = 1; + p->used_slot = 1; + p->head_position = 0; + conf->nr_disks++; + err = 0; + break; } + } + if (err) + MD_BUG(); + spin_unlock_irq(&conf->device_lock); - adisk->number = added_desc->number; - adisk->raid_disk = added_desc->raid_disk; - adisk->dev = mk_kdev(added_desc->major, added_desc->minor); - /* it will be held open by rdev */ - adisk->bdev = bdget(kdev_t_to_nr(adisk->dev)); - - adisk->operational = 0; - adisk->write_only = 0; - adisk->spare = 1; - adisk->used_slot = 1; - adisk->head_position = 0; - conf->nr_disks++; + print_conf(conf); + return err; +} - break; +static int raid1_remove_disk(mddev_t *mddev, int number) +{ + conf_t *conf = mddev->private; + int err = 1; + int i; - default: - MD_BUG(); - err = 1; - goto abort; + print_conf(conf); + spin_lock_irq(&conf->device_lock); + for (i = 0; i < MD_SB_DISKS; i++) { + mirror_info_t *p = conf->mirrors + i; + if (p->used_slot && (p->number == number)) { + if (p->operational) { + err = -EBUSY; + goto abort; + } + if (p->spare && (i < conf->raid_disks)) + break; + p->dev = NODEV; + p->bdev = NULL; + p->used_slot = 0; + conf->nr_disks--; + err = 0; + break; + } } + if (err) + MD_BUG(); abort: spin_unlock_irq(&conf->device_lock); @@ -922,7 +903,6 @@ abort: return err; } - #define IO_ERROR KERN_ALERT \ "raid1: %s: unrecoverable I/O read error for block %lu\n" @@ -1495,7 +1475,11 @@ static mdk_personality_t raid1_personality = stop: stop, status: status, error_handler: error, - diskop: diskop, + hot_add_disk: raid1_add_disk, + hot_remove_disk:raid1_remove_disk, + spare_write: raid1_spare_write, + spare_inactive: raid1_spare_inactive, + spare_active: raid1_spare_active, sync_request: sync_request }; diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c index 7e3581804db1..5218dfabbc01 100644 --- a/drivers/md/raid5.c +++ b/drivers/md/raid5.c @@ -1694,276 +1694,242 @@ static void print_raid5_conf (raid5_conf_t *conf) } } -static int diskop(mddev_t *mddev, mdp_disk_t **d, int state) +static struct disk_info *find_spare(mddev_t *mddev, int number) +{ + raid5_conf_t *conf = mddev->private; + int i; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + struct disk_info *p = conf->disks + i; + if (p->spare && p->number == number) + return p; + } + return NULL; +} + +static int raid5_spare_active(mddev_t *mddev, mdp_disk_t **d) { int err = 0; - int i, failed_disk=-1, spare_disk=-1, removed_disk=-1, added_disk=-1; + int i, failed_disk=-1, spare_disk=-1; raid5_conf_t *conf = mddev->private; - struct disk_info *tmp, *sdisk, *fdisk, *rdisk, *adisk; + struct disk_info *tmp, *sdisk, *fdisk; mdp_super_t *sb = mddev->sb; - mdp_disk_t *failed_desc, *spare_desc, *added_desc; + mdp_disk_t *failed_desc, *spare_desc; mdk_rdev_t *spare_rdev, *failed_rdev; print_raid5_conf(conf); spin_lock_irq(&conf->device_lock); + for (i = 0; i < conf->raid_disks; i++) { + tmp = conf->disks + i; + if ((!tmp->operational && !tmp->spare) || + !tmp->used_slot) { + failed_disk = i; + break; + } + } + if (failed_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } /* - * find the disk ... + * Find the spare disk ... (can only be in the 'high' + * area of the array) */ - switch (state) { - - case DISKOP_SPARE_ACTIVE: - - /* - * Find the failed disk within the RAID5 configuration ... - * (this can only be in the first conf->raid_disks part) - */ - for (i = 0; i < conf->raid_disks; i++) { - tmp = conf->disks + i; - if ((!tmp->operational && !tmp->spare) || - !tmp->used_slot) { - failed_disk = i; - break; - } - } - /* - * When we activate a spare disk we _must_ have a disk in - * the lower (active) part of the array to replace. - */ - if ((failed_disk == -1) || (failed_disk >= conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; - } - /* fall through */ - - case DISKOP_SPARE_WRITE: - case DISKOP_SPARE_INACTIVE: - - /* - * Find the spare disk ... (can only be in the 'high' - * area of the array) - */ - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->disks + i; - if (tmp->spare && tmp->number == (*d)->number) { - spare_disk = i; - break; - } - } - if (spare_disk == -1) { - MD_BUG(); - err = 1; - goto abort; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + tmp = conf->disks + i; + if (tmp->spare && tmp->number == (*d)->number) { + spare_disk = i; + break; } - break; - - case DISKOP_HOT_REMOVE_DISK: + } + if (spare_disk == -1) { + MD_BUG(); + err = 1; + goto abort; + } - for (i = 0; i < MD_SB_DISKS; i++) { - tmp = conf->disks + i; - if (tmp->used_slot && (tmp->number == (*d)->number)) { - if (tmp->operational) { - err = -EBUSY; - goto abort; - } - removed_disk = i; - break; - } - } - if (removed_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; + if (!conf->spare) { + MD_BUG(); + err = 1; + goto abort; + } + sdisk = conf->disks + spare_disk; + fdisk = conf->disks + failed_disk; - case DISKOP_HOT_ADD_DISK: + spare_desc = &sb->disks[sdisk->number]; + failed_desc = &sb->disks[fdisk->number]; - for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { - tmp = conf->disks + i; - if (!tmp->used_slot) { - added_disk = i; - break; - } - } - if (added_disk == -1) { - MD_BUG(); - err = 1; - goto abort; - } - break; + if (spare_desc != *d || spare_desc->raid_disk != sdisk->raid_disk || + sdisk->raid_disk != spare_disk || fdisk->raid_disk != failed_disk || + failed_desc->raid_disk != fdisk->raid_disk) { + MD_BUG(); + err = 1; + goto abort; } - switch (state) { /* - * Switch the spare disk to write-only mode: + * do the switch finally */ - case DISKOP_SPARE_WRITE: - if (conf->spare) { - MD_BUG(); - err = 1; - goto abort; - } - sdisk = conf->disks + spare_disk; - sdisk->operational = 1; - sdisk->write_only = 1; - conf->spare = sdisk; - break; - /* - * Deactivate a spare disk: + spare_rdev = find_rdev_nr(mddev, spare_desc->number); + failed_rdev = find_rdev_nr(mddev, failed_desc->number); + + /* There must be a spare_rdev, but there may not be a + * failed_rdev. That slot might be empty... */ - case DISKOP_SPARE_INACTIVE: - sdisk = conf->disks + spare_disk; - sdisk->operational = 0; - sdisk->write_only = 0; - /* - * Was the spare being resynced? - */ - if (conf->spare == sdisk) - conf->spare = NULL; - break; + spare_rdev->desc_nr = failed_desc->number; + if (failed_rdev) + failed_rdev->desc_nr = spare_desc->number; + + xchg_values(*spare_desc, *failed_desc); + xchg_values(*fdisk, *sdisk); + /* - * Activate (mark read-write) the (now sync) spare disk, - * which means we switch it's 'raid position' (->raid_disk) - * with the failed disk. (only the first 'conf->raid_disks' - * slots are used for 'real' disks and we must preserve this - * property) + * (careful, 'failed' and 'spare' are switched from now on) + * + * we want to preserve linear numbering and we want to + * give the proper raid_disk number to the now activated + * disk. (this means we switch back these values) */ - case DISKOP_SPARE_ACTIVE: - if (!conf->spare) { - MD_BUG(); - err = 1; - goto abort; - } - sdisk = conf->disks + spare_disk; - fdisk = conf->disks + failed_disk; - spare_desc = &sb->disks[sdisk->number]; - failed_desc = &sb->disks[fdisk->number]; + xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); + xchg_values(sdisk->raid_disk, fdisk->raid_disk); + xchg_values(spare_desc->number, failed_desc->number); + xchg_values(sdisk->number, fdisk->number); - if (spare_desc != *d) { - MD_BUG(); - err = 1; - goto abort; - } + *d = failed_desc; - if (spare_desc->raid_disk != sdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - if (sdisk->raid_disk != spare_disk) { - MD_BUG(); - err = 1; - goto abort; - } + if (!sdisk->bdev) + sdisk->used_slot = 0; - if (failed_desc->raid_disk != fdisk->raid_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - if (fdisk->raid_disk != failed_disk) { - MD_BUG(); - err = 1; - goto abort; - } - - /* - * do the switch finally - */ - spare_rdev = find_rdev_nr(mddev, spare_desc->number); - failed_rdev = find_rdev_nr(mddev, failed_desc->number); - - /* There must be a spare_rdev, but there may not be a - * failed_rdev. That slot might be empty... - */ - spare_rdev->desc_nr = failed_desc->number; - if (failed_rdev) - failed_rdev->desc_nr = spare_desc->number; - - xchg_values(*spare_desc, *failed_desc); - xchg_values(*fdisk, *sdisk); + /* + * this really activates the spare. + */ + fdisk->spare = 0; + fdisk->write_only = 0; - /* - * (careful, 'failed' and 'spare' are switched from now on) - * - * we want to preserve linear numbering and we want to - * give the proper raid_disk number to the now activated - * disk. (this means we switch back these values) - */ - - xchg_values(spare_desc->raid_disk, failed_desc->raid_disk); - xchg_values(sdisk->raid_disk, fdisk->raid_disk); - xchg_values(spare_desc->number, failed_desc->number); - xchg_values(sdisk->number, fdisk->number); + /* + * if we activate a spare, we definitely replace a + * non-operational disk slot in the 'low' area of + * the disk array. + */ + conf->failed_disks--; + conf->working_disks++; + conf->spare = NULL; +abort: + spin_unlock_irq(&conf->device_lock); + print_raid5_conf(conf); + return err; +} - *d = failed_desc; +static int raid5_spare_inactive(mddev_t *mddev) +{ + raid5_conf_t *conf = mddev->private; + struct disk_info *p; + int err = 0; - if (!sdisk->bdev) - sdisk->used_slot = 0; + print_raid5_conf(conf); + spin_lock_irq(&conf->device_lock); + p = find_spare(mddev, mddev->spare->number); + if (p) { + p->operational = 0; + p->write_only = 0; + if (conf->spare == p) + conf->spare = NULL; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); + print_raid5_conf(conf); + return err; +} - /* - * this really activates the spare. - */ - fdisk->spare = 0; - fdisk->write_only = 0; +static int raid5_spare_write(mddev_t *mddev, int number) +{ + raid5_conf_t *conf = mddev->private; + struct disk_info *p; + int err = 0; - /* - * if we activate a spare, we definitely replace a - * non-operational disk slot in the 'low' area of - * the disk array. - */ - conf->failed_disks--; - conf->working_disks++; - conf->spare = NULL; + print_raid5_conf(conf); + spin_lock_irq(&conf->device_lock); + p = find_spare(mddev, number); + if (p && !conf->spare) { + p->operational = 1; + p->write_only = 1; + conf->spare = p; + } else { + MD_BUG(); + err = 1; + } + spin_unlock_irq(&conf->device_lock); + print_raid5_conf(conf); + return err; +} - break; +static int raid5_remove_disk(mddev_t *mddev, int number) +{ + raid5_conf_t *conf = mddev->private; + int err = 1; + int i; - case DISKOP_HOT_REMOVE_DISK: - rdisk = conf->disks + removed_disk; + print_raid5_conf(conf); + spin_lock_irq(&conf->device_lock); - if (rdisk->spare && (removed_disk < conf->raid_disks)) { - MD_BUG(); - err = 1; - goto abort; + for (i = 0; i < MD_SB_DISKS; i++) { + struct disk_info *p = conf->disks + i; + if (p->used_slot && p->number == number) { + if (p->operational) { + err = -EBUSY; + goto abort; + } + if (p->spare && i < conf->raid_disks) + break; + p->bdev = NULL; + p->used_slot = 0; + err = 0; + break; } - rdisk->bdev = NULL; - rdisk->used_slot = 0; + } + if (err) + MD_BUG(); +abort: + spin_unlock_irq(&conf->device_lock); + print_raid5_conf(conf); + return err; +} - break; +static int raid5_add_disk(mddev_t *mddev, mdp_disk_t *added_desc, + mdk_rdev_t *rdev) +{ + raid5_conf_t *conf = mddev->private; + int err = 1; + int i; - case DISKOP_HOT_ADD_DISK: - adisk = conf->disks + added_disk; - added_desc = *d; + print_raid5_conf(conf); + spin_lock_irq(&conf->device_lock); + /* + * find the disk ... + */ - if (added_disk != added_desc->number) { - MD_BUG(); - err = 1; - goto abort; + for (i = conf->raid_disks; i < MD_SB_DISKS; i++) { + struct disk_info *p = conf->disks + i; + if (!p->used_slot) { + if (added_desc->number != i) + break; + p->number = added_desc->number; + p->raid_disk = added_desc->raid_disk; + /* it will be held open by rdev */ + p->bdev = rdev->bdev; + p->operational = 0; + p->write_only = 0; + p->spare = 1; + p->used_slot = 1; + err = 0; + break; } - - adisk->number = added_desc->number; - adisk->raid_disk = added_desc->raid_disk; - /* it will be held open by rdev */ - adisk->bdev = bdget(MKDEV(added_desc->major,added_desc->minor)); - - adisk->operational = 0; - adisk->write_only = 0; - adisk->spare = 1; - adisk->used_slot = 1; - - - break; - - default: - MD_BUG(); - err = 1; - goto abort; } -abort: + if (err) + MD_BUG(); spin_unlock_irq(&conf->device_lock); print_raid5_conf(conf); return err; @@ -1977,7 +1943,11 @@ static mdk_personality_t raid5_personality= stop: stop, status: status, error_handler: error, - diskop: diskop, + hot_add_disk: raid5_add_disk, + hot_remove_disk:raid5_remove_disk, + spare_write: raid5_spare_write, + spare_inactive: raid5_spare_inactive, + spare_active: raid5_spare_active, sync_request: sync_request }; diff --git a/fs/partitions/check.c b/fs/partitions/check.c index 3137aa78fea6..2c5ef516b1c5 100644 --- a/fs/partitions/check.c +++ b/fs/partitions/check.c @@ -13,14 +13,9 @@ * Added needed MAJORS for new pairs, {hdi,hdj}, {hdk,hdl} */ -#include +#include #include -#include -#include -#include #include -#include -#include #include /* for invalidate_bdev() */ #include "check.h" diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h index 69282d99a9eb..7b02c3c82a33 100644 --- a/include/linux/raid/md_k.h +++ b/include/linux/raid/md_k.h @@ -160,16 +160,6 @@ struct mdk_rdev_s int desc_nr; /* descriptor index in the superblock */ }; - -/* - * disk operations in a working array: - */ -#define DISKOP_SPARE_INACTIVE 0 -#define DISKOP_SPARE_WRITE 1 -#define DISKOP_SPARE_ACTIVE 2 -#define DISKOP_HOT_REMOVE_DISK 3 -#define DISKOP_HOT_ADD_DISK 4 - typedef struct mdk_personality_s mdk_personality_t; struct mddev_s @@ -214,18 +204,11 @@ struct mdk_personality_s int (*stop)(mddev_t *mddev); int (*status)(char *page, mddev_t *mddev); int (*error_handler)(mddev_t *mddev, struct block_device *bdev); - -/* - * Some personalities (RAID-1, RAID-5) can have disks hot-added and - * hot-removed. Hot removal is different from failure. (failure marks - * a disk inactive, but the disk is still part of the array) The interface - * to such operations is the 'pers->diskop()' function, can be NULL. - * - * the diskop function can change the pointer pointing to the incoming - * descriptor, but must do so very carefully. (currently only - * SPARE_ACTIVE expects such a change) - */ - int (*diskop) (mddev_t *mddev, mdp_disk_t **descriptor, int state); + int (*hot_add_disk) (mddev_t *mddev, mdp_disk_t *descriptor, mdk_rdev_t *rdev); + int (*hot_remove_disk) (mddev_t *mddev, int number); + int (*spare_write) (mddev_t *mddev, int number); + int (*spare_inactive) (mddev_t *mddev); + int (*spare_active) (mddev_t *mddev, mdp_disk_t **descriptor); int (*sync_request)(mddev_t *mddev, sector_t sector_nr, int go_faster); }; -- cgit v1.2.3 From 881c3bc1a70c9aaf69d0b0ca115b706ba7ededc3 Mon Sep 17 00:00:00 2001 From: Alexander Viro Date: Thu, 4 Jul 2002 08:53:44 -0700 Subject: [PATCH] raid kdev_t cleanups - part 2 * a bunch of callers of partition_name() are calling bdev_partition_name(), * the last users of raid1 and multipath ->dev are gone; so are the fields in question. --- drivers/md/multipath.c | 15 ++++++--------- drivers/md/raid1.c | 22 ++++++++-------------- drivers/md/raid5.c | 21 +++++++++------------ include/linux/raid/md.h | 2 +- include/linux/raid/multipath.h | 1 - include/linux/raid/raid1.h | 1 - 6 files changed, 24 insertions(+), 38 deletions(-) (limited to 'include/linux/raid') diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c index 97e6fc1d52de..ac08a9a90611 100644 --- a/drivers/md/multipath.c +++ b/drivers/md/multipath.c @@ -312,7 +312,7 @@ static void mark_disk_bad (mddev_t *mddev, int failed) mddev->sb_dirty = 1; md_wakeup_thread(conf->thread); conf->working_disks--; - printk (DISK_FAILED, partition_name (multipath->dev), + printk (DISK_FAILED, bdev_partition_name (multipath->bdev), conf->working_disks); } @@ -405,7 +405,7 @@ static void print_multipath_conf (multipath_conf_t *conf) printk(" disk%d, s:%d, o:%d, n:%d rd:%d us:%d dev:%s\n", i, tmp->spare,tmp->operational, tmp->number,tmp->raid_disk,tmp->used_slot, - partition_name(tmp->dev)); + bdev_partition_name(tmp->bdev)); } } @@ -594,7 +594,6 @@ static int multipath_add_disk(mddev_t *mddev, mdp_disk_t *added_desc, break; p->number = added_desc->number; p->raid_disk = added_desc->raid_disk; - p->dev = rdev->dev; p->bdev = rdev->bdev; p->operational = 0; p->spare = 1; @@ -631,7 +630,6 @@ static int multipath_remove_disk(mddev_t *mddev, int number) } if (p->spare && i < conf->raid_disks) break; - p->dev = NODEV; p->bdev = NULL; p->used_slot = 0; conf->nr_disks--; @@ -853,7 +851,7 @@ static int multipath_run (mddev_t *mddev) if (rdev->faulty) { /* this is a "should never happen" case and if it */ /* ever does happen, a continue; won't help */ - printk(ERRORS, partition_name(rdev->dev)); + printk(ERRORS, bdev_partition_name(rdev->bdev)); continue; } else { /* this is a "should never happen" case and if it */ @@ -873,7 +871,7 @@ static int multipath_run (mddev_t *mddev) disk = conf->multipaths + disk_idx; if (!disk_sync(desc)) - printk(NOT_IN_SYNC, partition_name(rdev->dev)); + printk(NOT_IN_SYNC, bdev_partition_name(rdev->bdev)); /* * Mark all disks as spare to start with, then pick our @@ -882,7 +880,6 @@ static int multipath_run (mddev_t *mddev) */ disk->number = desc->number; disk->raid_disk = desc->raid_disk; - disk->dev = rdev->dev; disk->bdev = rdev->bdev; atomic_inc(&rdev->bdev->bd_count); disk->operational = 0; @@ -892,7 +889,7 @@ static int multipath_run (mddev_t *mddev) if (disk_active(desc)) { if(!conf->working_disks) { - printk(OPERATIONAL, partition_name(rdev->dev), + printk(OPERATIONAL, bdev_partition_name(rdev->bdev), desc->raid_disk); disk->operational = 1; disk->spare = 0; @@ -909,7 +906,7 @@ static int multipath_run (mddev_t *mddev) if(!conf->working_disks && num_rdevs) { desc = &sb->disks[def_rdev->desc_nr]; disk = conf->multipaths + desc->raid_disk; - printk(OPERATIONAL, partition_name(def_rdev->dev), + printk(OPERATIONAL, bdev_partition_name(def_rdev->bdev), disk->raid_disk); disk->operational = 1; disk->spare = 0; diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c index 76e2de202458..088993cf5165 100644 --- a/drivers/md/raid1.c +++ b/drivers/md/raid1.c @@ -589,7 +589,7 @@ static void mark_disk_bad(mddev_t *mddev, int failed) md_wakeup_thread(conf->thread); if (!mirror->write_only) conf->working_disks--; - printk(DISK_FAILED, partition_name(mirror->dev), conf->working_disks); + printk(DISK_FAILED, bdev_partition_name(mirror->bdev), conf->working_disks); } static int error(mddev_t *mddev, struct block_device *bdev) @@ -640,7 +640,7 @@ static void print_conf(conf_t *conf) printk(" disk %d, s:%d, o:%d, n:%d rd:%d us:%d dev:%s\n", i, tmp->spare, tmp->operational, tmp->number, tmp->raid_disk, tmp->used_slot, - partition_name(tmp->dev)); + bdev_partition_name(tmp->bdev)); } } @@ -848,7 +848,6 @@ static int raid1_add_disk(mddev_t *mddev, mdp_disk_t *added_desc, break; p->number = added_desc->number; p->raid_disk = added_desc->raid_disk; - p->dev = rdev->dev; /* it will be held open by rdev */ p->bdev = rdev->bdev; p->operational = 0; @@ -886,7 +885,6 @@ static int raid1_remove_disk(mddev_t *mddev, int number) } if (p->spare && (i < conf->raid_disks)) break; - p->dev = NODEV; p->bdev = NULL; p->used_slot = 0; conf->nr_disks--; @@ -1284,7 +1282,7 @@ static int run(mddev_t *mddev) ITERATE_RDEV(mddev, rdev, tmp) { if (rdev->faulty) { - printk(ERRORS, partition_name(rdev->dev)); + printk(ERRORS, bdev_partition_name(rdev->bdev)); } else { if (!rdev->sb) { MD_BUG(); @@ -1302,7 +1300,6 @@ static int run(mddev_t *mddev) if (disk_faulty(descriptor)) { disk->number = descriptor->number; disk->raid_disk = disk_idx; - disk->dev = rdev->dev; disk->bdev = rdev->bdev; atomic_inc(&rdev->bdev->bd_count); disk->operational = 0; @@ -1315,27 +1312,26 @@ static int run(mddev_t *mddev) if (disk_active(descriptor)) { if (!disk_sync(descriptor)) { printk(NOT_IN_SYNC, - partition_name(rdev->dev)); + bdev_partition_name(rdev->bdev)); continue; } if ((descriptor->number > MD_SB_DISKS) || (disk_idx > sb->raid_disks)) { printk(INCONSISTENT, - partition_name(rdev->dev)); + bdev_partition_name(rdev->bdev)); continue; } if (disk->operational) { printk(ALREADY_RUNNING, - partition_name(rdev->dev), + bdev_partition_name(rdev->bdev), disk_idx); continue; } - printk(OPERATIONAL, partition_name(rdev->dev), + printk(OPERATIONAL, bdev_partition_name(rdev->bdev), disk_idx); disk->number = descriptor->number; disk->raid_disk = disk_idx; - disk->dev = rdev->dev; disk->bdev = rdev->bdev; atomic_inc(&rdev->bdev->bd_count); disk->operational = 1; @@ -1348,10 +1344,9 @@ static int run(mddev_t *mddev) /* * Must be a spare disk .. */ - printk(SPARE, partition_name(rdev->dev)); + printk(SPARE, bdev_partition_name(rdev->bdev)); disk->number = descriptor->number; disk->raid_disk = disk_idx; - disk->dev = rdev->dev; disk->bdev = rdev->bdev; atomic_inc(&rdev->bdev->bd_count); disk->operational = 0; @@ -1385,7 +1380,6 @@ static int run(mddev_t *mddev) !disk->used_slot) { disk->number = descriptor->number; disk->raid_disk = disk_idx; - disk->dev = NODEV; disk->bdev = NULL; disk->operational = 0; disk->write_only = 0; diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c index 5218dfabbc01..5d0af20344cc 100644 --- a/drivers/md/raid5.c +++ b/drivers/md/raid5.c @@ -441,7 +441,6 @@ static void raid5_build_block (struct stripe_head *sh, int i) static int error(mddev_t *mddev, struct block_device *bdev) { - kdev_t dev = to_kdev_t(bdev->bd_dev); raid5_conf_t *conf = (raid5_conf_t *) mddev->private; mdp_super_t *sb = mddev->sb; struct disk_info *disk; @@ -467,7 +466,7 @@ static int error(mddev_t *mddev, struct block_device *bdev) printk (KERN_ALERT "raid5: Disk failure on %s, disabling device." " Operation continuing on %d devices\n", - partition_name (dev), conf->working_disks); + bdev_partition_name(bdev), conf->working_disks); } return 0; } @@ -479,7 +478,7 @@ static int error(mddev_t *mddev, struct block_device *bdev) if (disk->bdev == bdev) { printk (KERN_ALERT "raid5: Disk failure on spare %s\n", - partition_name (dev)); + bdev_partition_name (bdev)); if (!conf->spare->operational) { /* probably a SET_DISK_FAULTY ioctl */ return -EIO; @@ -1429,7 +1428,7 @@ static int run (mddev_t *mddev) disk = conf->disks + raid_disk; if (disk_faulty(desc)) { - printk(KERN_ERR "raid5: disabled device %s (errors detected)\n", partition_name(rdev->dev)); + printk(KERN_ERR "raid5: disabled device %s (errors detected)\n", bdev_partition_name(rdev->bdev)); if (!rdev->faulty) { MD_BUG(); goto abort; @@ -1446,19 +1445,19 @@ static int run (mddev_t *mddev) } if (disk_active(desc)) { if (!disk_sync(desc)) { - printk(KERN_ERR "raid5: disabled device %s (not in sync)\n", partition_name(rdev->dev)); + printk(KERN_ERR "raid5: disabled device %s (not in sync)\n", bdev_partition_name(rdev->bdev)); MD_BUG(); goto abort; } if (raid_disk > sb->raid_disks) { - printk(KERN_ERR "raid5: disabled device %s (inconsistent descriptor)\n", partition_name(rdev->dev)); + printk(KERN_ERR "raid5: disabled device %s (inconsistent descriptor)\n", bdev_partition_name(rdev->bdev)); continue; } if (disk->operational) { - printk(KERN_ERR "raid5: disabled device %s (device %d already operational)\n", partition_name(rdev->dev), raid_disk); + printk(KERN_ERR "raid5: disabled device %s (device %d already operational)\n", bdev_partition_name(rdev->bdev), raid_disk); continue; } - printk(KERN_INFO "raid5: device %s operational as raid disk %d\n", partition_name(rdev->dev), raid_disk); + printk(KERN_INFO "raid5: device %s operational as raid disk %d\n", bdev_partition_name(rdev->bdev), raid_disk); disk->number = desc->number; disk->raid_disk = raid_disk; @@ -1471,7 +1470,7 @@ static int run (mddev_t *mddev) /* * Must be a spare disk .. */ - printk(KERN_INFO "raid5: spare disk %s\n", partition_name(rdev->dev)); + printk(KERN_INFO "raid5: spare disk %s\n", bdev_partition_name(rdev->bdev)); disk->number = desc->number; disk->raid_disk = raid_disk; disk->bdev = rdev->bdev; @@ -1688,9 +1687,7 @@ static void print_raid5_conf (raid5_conf_t *conf) printk(" disk %d, s:%d, o:%d, n:%d rd:%d us:%d dev:%s\n", i, tmp->spare,tmp->operational, tmp->number,tmp->raid_disk,tmp->used_slot, - partition_name(tmp->bdev ? - to_kdev_t(tmp->bdev->bd_dev): - NODEV)); + bdev_partition_name(tmp->bdev)); } } diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h index 6dfe08ccfbfe..280092c6e95b 100644 --- a/include/linux/raid/md.h +++ b/include/linux/raid/md.h @@ -66,7 +66,7 @@ extern struct hd_struct md_hd_struct[MAX_MD_DEVS]; extern char * partition_name (kdev_t dev); extern inline char * bdev_partition_name (struct block_device *bdev) { - return partition_name(to_kdev_t(bdev->bd_dev)); + return partition_name(bdev ? to_kdev_t(bdev->bd_dev) : NODEV); } extern int register_md_personality (int p_num, mdk_personality_t *p); extern int unregister_md_personality (int p_num); diff --git a/include/linux/raid/multipath.h b/include/linux/raid/multipath.h index 9c9cdc77fa05..e4f3e6189b7b 100644 --- a/include/linux/raid/multipath.h +++ b/include/linux/raid/multipath.h @@ -6,7 +6,6 @@ struct multipath_info { int number; int raid_disk; - kdev_t dev; struct block_device *bdev; /* diff --git a/include/linux/raid/raid1.h b/include/linux/raid/raid1.h index f9f02ab19bd3..f63d68e55c11 100644 --- a/include/linux/raid/raid1.h +++ b/include/linux/raid/raid1.h @@ -8,7 +8,6 @@ typedef struct mirror_info mirror_info_t; struct mirror_info { int number; int raid_disk; - kdev_t dev; struct block_device *bdev; sector_t head_position; atomic_t nr_pending; -- cgit v1.2.3 From dc5d0e468b264f2c36789ffd5fe5551cd72f387d Mon Sep 17 00:00:00 2001 From: Alexander Viro Date: Thu, 4 Jul 2002 08:53:54 -0700 Subject: [PATCH] raid kdev_t cleanups - part 3 * ->dev killed for md/linear.c (same as previous parts) --- drivers/md/linear.c | 7 +++---- include/linux/raid/linear.h | 1 - 2 files changed, 3 insertions(+), 5 deletions(-) (limited to 'include/linux/raid') diff --git a/drivers/md/linear.c b/drivers/md/linear.c index d8f29104dacf..daeeb075182c 100644 --- a/drivers/md/linear.c +++ b/drivers/md/linear.c @@ -60,7 +60,6 @@ static int linear_run (mddev_t *mddev) goto out; } - disk->dev = rdev->dev; disk->bdev = rdev->bdev; atomic_inc(&rdev->bdev->bd_count); disk->size = rdev->size; @@ -163,7 +162,7 @@ static int linear_make_request (request_queue_t *q, struct bio *bio) if (block >= (tmp_dev->size + tmp_dev->offset) || block < tmp_dev->offset) { - printk ("linear_make_request: Block %ld out of bounds on dev %s size %ld offset %ld\n", block, kdevname(tmp_dev->dev), tmp_dev->size, tmp_dev->offset); + printk ("linear_make_request: Block %ld out of bounds on dev %s size %ld offset %ld\n", block, bdevname(tmp_dev->bdev), tmp_dev->size, tmp_dev->offset); bio_io_error(bio); return 0; } @@ -186,11 +185,11 @@ static int linear_status (char *page, mddev_t *mddev) for (j = 0; j < conf->nr_zones; j++) { sz += sprintf(page+sz, "[%s", - partition_name(conf->hash_table[j].dev0->dev)); + bdev_partition_name(conf->hash_table[j].dev0->bdev)); if (conf->hash_table[j].dev1) sz += sprintf(page+sz, "/%s] ", - partition_name(conf->hash_table[j].dev1->dev)); + bdev_partition_name(conf->hash_table[j].dev1->bdev)); else sz += sprintf(page+sz, "] "); } diff --git a/include/linux/raid/linear.h b/include/linux/raid/linear.h index 56e7c06e1086..dfb588a60ea6 100644 --- a/include/linux/raid/linear.h +++ b/include/linux/raid/linear.h @@ -4,7 +4,6 @@ #include struct dev_info { - kdev_t dev; struct block_device *bdev; unsigned long size; unsigned long offset; -- cgit v1.2.3