Commit 409c57f3 authored by NeilBrown's avatar NeilBrown

md: enable suspend/resume of md devices.

To be able to change the 'level' of an md/raid array, we need to
suspend the device so that no requests are active - then move some
pointers around etc.

The code already keeps counts of active requests and the ->quiesce
function can be used to wait until those counts hit zero.
However the quiesce function blocks new requests once they are all
ready 'inside' the personality module, and that is too late if we want
to replace the personality modules.

So make all md requests come in through a common md_make_request
function that keeps track of how many requests have entered the
modules but may not yet be on the internal reference counts.
Allow md_make_request to be blocked when we want to suspend the
device, and make it possible to wait for all those in-transit requests
to be added to internal lists so that ->quiesce can wait for them.

There is still a problem that when a request completes, we drop the
ref count inside the personality code so there is a short time between
when the refcount hits zero, and when the personality code is no
longer being used.
The personality code never blocks (schedule or spinlock) between
dropping the refcount and exiting the routine, so this should be safe
(as put_module calls synchronize_sched() before unmapping the module
code).
Signed-off-by: default avatarNeilBrown <neilb@suse.de>
parent e0cf8f04
...@@ -201,12 +201,68 @@ static DEFINE_SPINLOCK(all_mddevs_lock); ...@@ -201,12 +201,68 @@ static DEFINE_SPINLOCK(all_mddevs_lock);
) )
static int md_fail_request(struct request_queue *q, struct bio *bio) /* Rather than calling directly into the personality make_request function,
* IO requests come here first so that we can check if the device is
* being suspended pending a reconfiguration.
* We hold a refcount over the call to ->make_request. By the time that
* call has finished, the bio has been linked into some internal structure
* and so is visible to ->quiesce(), so we don't need the refcount any more.
*/
static int md_make_request(struct request_queue *q, struct bio *bio)
{ {
bio_io_error(bio); mddev_t *mddev = q->queuedata;
return 0; int rv;
if (mddev == NULL || mddev->pers == NULL) {
bio_io_error(bio);
return 0;
}
rcu_read_lock();
if (mddev->suspended) {
DEFINE_WAIT(__wait);
for (;;) {
prepare_to_wait(&mddev->sb_wait, &__wait,
TASK_UNINTERRUPTIBLE);
if (!mddev->suspended)
break;
rcu_read_unlock();
schedule();
rcu_read_lock();
}
finish_wait(&mddev->sb_wait, &__wait);
}
atomic_inc(&mddev->active_io);
rcu_read_unlock();
rv = mddev->pers->make_request(q, bio);
if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
wake_up(&mddev->sb_wait);
return rv;
} }
static void mddev_suspend(mddev_t *mddev)
{
BUG_ON(mddev->suspended);
mddev->suspended = 1;
synchronize_rcu();
wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
mddev->pers->quiesce(mddev, 1);
md_unregister_thread(mddev->thread);
mddev->thread = NULL;
/* we now know that no code is executing in the personality module,
* except possibly the tail end of a ->bi_end_io function, but that
* is certain to complete before the module has a chance to get
* unloaded
*/
}
static void mddev_resume(mddev_t *mddev)
{
mddev->suspended = 0;
wake_up(&mddev->sb_wait);
mddev->pers->quiesce(mddev, 0);
}
static inline mddev_t *mddev_get(mddev_t *mddev) static inline mddev_t *mddev_get(mddev_t *mddev)
{ {
atomic_inc(&mddev->active); atomic_inc(&mddev->active);
...@@ -314,6 +370,7 @@ static mddev_t * mddev_find(dev_t unit) ...@@ -314,6 +370,7 @@ static mddev_t * mddev_find(dev_t unit)
init_timer(&new->safemode_timer); init_timer(&new->safemode_timer);
atomic_set(&new->active, 1); atomic_set(&new->active, 1);
atomic_set(&new->openers, 0); atomic_set(&new->openers, 0);
atomic_set(&new->active_io, 0);
spin_lock_init(&new->write_lock); spin_lock_init(&new->write_lock);
init_waitqueue_head(&new->sb_wait); init_waitqueue_head(&new->sb_wait);
init_waitqueue_head(&new->recovery_wait); init_waitqueue_head(&new->recovery_wait);
...@@ -3632,10 +3689,12 @@ static int md_alloc(dev_t dev, char *name) ...@@ -3632,10 +3689,12 @@ static int md_alloc(dev_t dev, char *name)
mddev_put(mddev); mddev_put(mddev);
return -ENOMEM; return -ENOMEM;
} }
mddev->queue->queuedata = mddev;
/* Can be unlocked because the queue is new: no concurrency */ /* Can be unlocked because the queue is new: no concurrency */
queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, mddev->queue); queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, mddev->queue);
blk_queue_make_request(mddev->queue, md_fail_request); blk_queue_make_request(mddev->queue, md_make_request);
disk = alloc_disk(1 << shift); disk = alloc_disk(1 << shift);
if (!disk) { if (!disk) {
...@@ -3938,16 +3997,6 @@ static int do_md_run(mddev_t * mddev) ...@@ -3938,16 +3997,6 @@ static int do_md_run(mddev_t * mddev)
set_capacity(disk, mddev->array_sectors); set_capacity(disk, mddev->array_sectors);
/* If we call blk_queue_make_request here, it will
* re-initialise max_sectors etc which may have been
* refined inside -> run. So just set the bits we need to set.
* Most initialisation happended when we called
* blk_queue_make_request(..., md_fail_request)
* earlier.
*/
mddev->queue->queuedata = mddev;
mddev->queue->make_request_fn = mddev->pers->make_request;
/* If there is a partially-recovered drive we need to /* If there is a partially-recovered drive we need to
* start recovery here. If we leave it to md_check_recovery, * start recovery here. If we leave it to md_check_recovery,
* it will remove the drives and not do the right thing * it will remove the drives and not do the right thing
...@@ -4077,7 +4126,7 @@ static int do_md_stop(mddev_t * mddev, int mode, int is_open) ...@@ -4077,7 +4126,7 @@ static int do_md_stop(mddev_t * mddev, int mode, int is_open)
md_super_wait(mddev); md_super_wait(mddev);
if (mddev->ro) if (mddev->ro)
set_disk_ro(disk, 0); set_disk_ro(disk, 0);
blk_queue_make_request(mddev->queue, md_fail_request);
mddev->pers->stop(mddev); mddev->pers->stop(mddev);
mddev->queue->merge_bvec_fn = NULL; mddev->queue->merge_bvec_fn = NULL;
mddev->queue->unplug_fn = NULL; mddev->queue->unplug_fn = NULL;
......
...@@ -119,6 +119,8 @@ struct mddev_s ...@@ -119,6 +119,8 @@ struct mddev_s
#define MD_CHANGE_CLEAN 1 /* transition to or from 'clean' */ #define MD_CHANGE_CLEAN 1 /* transition to or from 'clean' */
#define MD_CHANGE_PENDING 2 /* superblock update in progress */ #define MD_CHANGE_PENDING 2 /* superblock update in progress */
int suspended;
atomic_t active_io;
int ro; int ro;
struct gendisk *gendisk; struct gendisk *gendisk;
......
...@@ -2092,6 +2092,9 @@ static int stop(mddev_t *mddev) ...@@ -2092,6 +2092,9 @@ static int stop(mddev_t *mddev)
/* need to kick something here to make sure I/O goes? */ /* need to kick something here to make sure I/O goes? */
} }
raise_barrier(conf);
lower_barrier(conf);
md_unregister_thread(mddev->thread); md_unregister_thread(mddev->thread);
mddev->thread = NULL; mddev->thread = NULL;
blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/ blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
......
...@@ -2211,6 +2211,9 @@ static int stop(mddev_t *mddev) ...@@ -2211,6 +2211,9 @@ static int stop(mddev_t *mddev)
{ {
conf_t *conf = mddev_to_conf(mddev); conf_t *conf = mddev_to_conf(mddev);
raise_barrier(conf, 0);
lower_barrier(conf);
md_unregister_thread(mddev->thread); md_unregister_thread(mddev->thread);
mddev->thread = NULL; mddev->thread = NULL;
blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/ blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment