1 files changed, 128 insertions, 50 deletions

diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index 32d0b878eccc..826bce7343b3 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -69,6 +69,7 @@ struct multipath {
         struct list_head priority_groups;
         unsigned pg_init_required;      /* pg_init needs calling? */
         unsigned pg_init_in_progress;   /* Only one pg_init allowed at once */
+        wait_queue_head_t pg_init_wait; /* Wait for pg_init completion */
 
         unsigned nr_valid_paths;        /* Total number of usable paths */
         struct pgpath *current_pgpath;
@@ -93,6 +94,8 @@ struct multipath {
          * can resubmit bios on error.
          */
         mempool_t *mpio_pool;
+
+        struct mutex work_mutex;
 };
 
 /*
@@ -198,6 +201,8 @@ static struct multipath *alloc_multipath(struct dm_target *ti)
                 m->queue_io = 1;
                 INIT_WORK(&m->process_queued_ios, process_queued_ios);
                 INIT_WORK(&m->trigger_event, trigger_event);
+                init_waitqueue_head(&m->pg_init_wait);
+                mutex_init(&m->work_mutex);
                 m->mpio_pool = mempool_create_slab_pool(MIN_IOS, _mpio_cache);
                 if (!m->mpio_pool) {
                         kfree(m);
@@ -230,6 +235,21 @@ static void free_multipath(struct multipath *m)
  * Path selection
  *-----------------------------------------------*/
 
+static void __pg_init_all_paths(struct multipath *m)
+{
+        struct pgpath *pgpath;
+
+        m->pg_init_count++;
+        m->pg_init_required = 0;
+        list_for_each_entry(pgpath, &m->current_pg->pgpaths, list) {
+                /* Skip failed paths */
+                if (!pgpath->is_active)
+                        continue;
+                if (queue_work(kmpath_handlerd, &pgpath->activate_path))
+                        m->pg_init_in_progress++;
+        }
+}
+
 static void __switch_pg(struct multipath *m, struct pgpath *pgpath)
 {
         m->current_pg = pgpath->pg;
@@ -434,7 +454,7 @@ static void process_queued_ios(struct work_struct *work)
 {
         struct multipath *m =
                 container_of(work, struct multipath, process_queued_ios);
-        struct pgpath *pgpath = NULL, *tmp;
+        struct pgpath *pgpath = NULL;
         unsigned must_queue = 1;
         unsigned long flags;
 
@@ -452,14 +472,9 @@ static void process_queued_ios(struct work_struct *work)
             (!pgpath && !m->queue_if_no_path))
                 must_queue = 0;
 
-        if (m->pg_init_required && !m->pg_init_in_progress && pgpath) {
-                m->pg_init_count++;
-                m->pg_init_required = 0;
-                list_for_each_entry(tmp, &pgpath->pg->pgpaths, list) {
-                        if (queue_work(kmpath_handlerd, &tmp->activate_path))
-                                m->pg_init_in_progress++;
-                }
-        }
+        if (m->pg_init_required && !m->pg_init_in_progress && pgpath)
+                __pg_init_all_paths(m);
+
 out:
         spin_unlock_irqrestore(&m->lock, flags);
         if (!must_queue)
@@ -592,8 +607,8 @@ static struct pgpath *parse_path(struct arg_set *as, struct path_selector *ps,
         if (!p)
                 return ERR_PTR(-ENOMEM);
 
-        r = dm_get_device(ti, shift(as), ti->begin, ti->len,
-                          dm_table_get_mode(ti->table), &p->path.dev);
+        r = dm_get_device(ti, shift(as), dm_table_get_mode(ti->table),
+                          &p->path.dev);
         if (r) {
                 ti->error = "error getting device";
                 goto bad;
@@ -885,13 +900,43 @@ static int multipath_ctr(struct dm_target *ti, unsigned int argc,
         return r;
 }
 
-static void multipath_dtr(struct dm_target *ti)
+static void multipath_wait_for_pg_init_completion(struct multipath *m)
 {
-        struct multipath *m = (struct multipath *) ti->private;
+        DECLARE_WAITQUEUE(wait, current);
+        unsigned long flags;
+
+        add_wait_queue(&m->pg_init_wait, &wait);
 
+        while (1) {
+                set_current_state(TASK_UNINTERRUPTIBLE);
+
+                spin_lock_irqsave(&m->lock, flags);
+                if (!m->pg_init_in_progress) {
+                        spin_unlock_irqrestore(&m->lock, flags);
+                        break;
+                }
+                spin_unlock_irqrestore(&m->lock, flags);
+
+                io_schedule();
+        }
+        set_current_state(TASK_RUNNING);
+
+        remove_wait_queue(&m->pg_init_wait, &wait);
+}
+
+static void flush_multipath_work(struct multipath *m)
+{
         flush_workqueue(kmpath_handlerd);
+        multipath_wait_for_pg_init_completion(m);
         flush_workqueue(kmultipathd);
         flush_scheduled_work();
+}
+
+static void multipath_dtr(struct dm_target *ti)
+{
+        struct multipath *m = ti->private;
+
+        flush_multipath_work(m);
         free_multipath(m);
 }
 
@@ -1116,9 +1161,9 @@ static int pg_init_limit_reached(struct multipath *m, struct pgpath *pgpath)
         return limit_reached;
 }
 
-static void pg_init_done(struct dm_path *path, int errors)
+static void pg_init_done(void *data, int errors)
 {
-        struct pgpath *pgpath = path_to_pgpath(path);
+        struct pgpath *pgpath = data;
         struct priority_group *pg = pgpath->pg;
         struct multipath *m = pg->m;
         unsigned long flags;
@@ -1132,8 +1177,8 @@ static void pg_init_done(struct dm_path *path, int errors)
                         errors = 0;
                         break;
                 }
-                DMERR("Cannot failover device because scsi_dh_%s was not "
-                      "loaded.", m->hw_handler_name);
+                DMERR("Could not failover the device: Handler scsi_dh_%s "
+                      "Error %d.", m->hw_handler_name, errors);
                 /*
                  * Fail path for now, so we do not ping pong
                  */
@@ -1170,25 +1215,34 @@ static void pg_init_done(struct dm_path *path, int errors)
                         m->current_pgpath = NULL;
                         m->current_pg = NULL;
                 }
-        } else if (!m->pg_init_required) {
-                m->queue_io = 0;
+        } else if (!m->pg_init_required)
                 pg->bypassed = 0;
-        }
 
-        m->pg_init_in_progress--;
-        if (!m->pg_init_in_progress)
-                queue_work(kmultipathd, &m->process_queued_ios);
+        if (--m->pg_init_in_progress)
+                /* Activations of other paths are still on going */
+                goto out;
+
+        if (!m->pg_init_required)
+                m->queue_io = 0;
+
+        queue_work(kmultipathd, &m->process_queued_ios);
+
+        /*
+         * Wake up any thread waiting to suspend.
+         */
+        wake_up(&m->pg_init_wait);
+
+out:
         spin_unlock_irqrestore(&m->lock, flags);
 }
 
 static void activate_path(struct work_struct *work)
 {
-        int ret;
         struct pgpath *pgpath =
                 container_of(work, struct pgpath, activate_path);
 
-        ret = scsi_dh_activate(bdev_get_queue(pgpath->path.dev->bdev));
-        pg_init_done(&pgpath->path, ret);
+        scsi_dh_activate(bdev_get_queue(pgpath->path.dev->bdev),
+                                pg_init_done, pgpath);
 }
 
 /*
@@ -1261,6 +1315,15 @@ static void multipath_presuspend(struct dm_target *ti)
         queue_if_no_path(m, 0, 1);
 }
 
+static void multipath_postsuspend(struct dm_target *ti)
+{
+        struct multipath *m = ti->private;
+
+        mutex_lock(&m->work_mutex);
+        flush_multipath_work(m);
+        mutex_unlock(&m->work_mutex);
+}
+
 /*
  * Restore the queue_if_no_path setting.
  */
@@ -1397,51 +1460,65 @@ static int multipath_status(struct dm_target *ti, status_type_t type,
 
 static int multipath_message(struct dm_target *ti, unsigned argc, char **argv)
 {
-        int r;
+        int r = -EINVAL;
         struct dm_dev *dev;
         struct multipath *m = (struct multipath *) ti->private;
         action_fn action;
 
+        mutex_lock(&m->work_mutex);
+
+        if (dm_suspended(ti)) {
+                r = -EBUSY;
+                goto out;
+        }
+
         if (argc == 1) {
-                if (!strnicmp(argv[0], MESG_STR("queue_if_no_path")))
-                        return queue_if_no_path(m, 1, 0);
-                else if (!strnicmp(argv[0], MESG_STR("fail_if_no_path")))
-                        return queue_if_no_path(m, 0, 0);
+                if (!strnicmp(argv[0], MESG_STR("queue_if_no_path"))) {
+                        r = queue_if_no_path(m, 1, 0);
+                        goto out;
+                } else if (!strnicmp(argv[0], MESG_STR("fail_if_no_path"))) {
+                        r = queue_if_no_path(m, 0, 0);
+                        goto out;
+                }
         }
 
-        if (argc != 2)
-                goto error;
+        if (argc != 2) {
+                DMWARN("Unrecognised multipath message received.");
+                goto out;
+        }
 
-        if (!strnicmp(argv[0], MESG_STR("disable_group")))
-                return bypass_pg_num(m, argv[1], 1);
-        else if (!strnicmp(argv[0], MESG_STR("enable_group")))
-                return bypass_pg_num(m, argv[1], 0);
-        else if (!strnicmp(argv[0], MESG_STR("switch_group")))
-                return switch_pg_num(m, argv[1]);
-        else if (!strnicmp(argv[0], MESG_STR("reinstate_path")))
+        if (!strnicmp(argv[0], MESG_STR("disable_group"))) {
+                r = bypass_pg_num(m, argv[1], 1);
+                goto out;
+        } else if (!strnicmp(argv[0], MESG_STR("enable_group"))) {
+                r = bypass_pg_num(m, argv[1], 0);
+                goto out;
+        } else if (!strnicmp(argv[0], MESG_STR("switch_group"))) {
+                r = switch_pg_num(m, argv[1]);
+                goto out;
+        } else if (!strnicmp(argv[0], MESG_STR("reinstate_path")))
                 action = reinstate_path;
         else if (!strnicmp(argv[0], MESG_STR("fail_path")))
                 action = fail_path;
-        else
-                goto error;
+        else {
+                DMWARN("Unrecognised multipath message received.");
+                goto out;
+        }
 
-        r = dm_get_device(ti, argv[1], ti->begin, ti->len,
-                          dm_table_get_mode(ti->table), &dev);
+        r = dm_get_device(ti, argv[1], dm_table_get_mode(ti->table), &dev);
         if (r) {
                 DMWARN("message: error getting device %s",
                        argv[1]);
-                return -EINVAL;
+                goto out;
         }
 
         r = action_dev(m, dev, action);
 
         dm_put_device(ti, dev);
 
+out:
+        mutex_unlock(&m->work_mutex);
         return r;
-
-error:
-        DMWARN("Unrecognised multipath message received.");
-        return -EINVAL;
 }
 
 static int multipath_ioctl(struct dm_target *ti, unsigned int cmd,
@@ -1567,13 +1644,14 @@ out:
  *---------------------------------------------------------------*/
 static struct target_type multipath_target = {
         .name = "multipath",
-        .version = {1, 1, 0},
+        .version = {1, 1, 1},
         .module = THIS_MODULE,
         .ctr = multipath_ctr,
         .dtr = multipath_dtr,
         .map_rq = multipath_map,
         .rq_end_io = multipath_end_io,
         .presuspend = multipath_presuspend,
+        .postsuspend = multipath_postsuspend,
         .resume = multipath_resume,
         .status = multipath_status,
         .message = multipath_message,