2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2003 Sistina Software Limited.
|
|
|
|
* Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
|
|
|
|
*
|
|
|
|
* This file is released under the GPL.
|
|
|
|
*/
|
|
|
|
|
2008-10-21 23:44:59 +07:00
|
|
|
#include <linux/device-mapper.h>
|
|
|
|
|
2013-09-13 05:06:12 +07:00
|
|
|
#include "dm.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
#include "dm-path-selector.h"
|
2007-10-20 04:48:02 +07:00
|
|
|
#include "dm-uevent.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#include <linux/ctype.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/mempool.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/workqueue.h>
|
2012-06-03 06:29:58 +07:00
|
|
|
#include <linux/delay.h>
|
2008-05-02 04:50:11 +07:00
|
|
|
#include <scsi/scsi_dh.h>
|
2011-07-27 06:09:06 +07:00
|
|
|
#include <linux/atomic.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-26 14:27:35 +07:00
|
|
|
#define DM_MSG_PREFIX "multipath"
|
2011-01-14 03:00:01 +07:00
|
|
|
#define DM_PG_INIT_DELAY_MSECS 2000
|
|
|
|
#define DM_PG_INIT_DELAY_DEFAULT ((unsigned) -1)
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Path properties */
|
|
|
|
struct pgpath {
|
|
|
|
struct list_head list;
|
|
|
|
|
|
|
|
struct priority_group *pg; /* Owning PG */
|
2008-10-10 19:36:58 +07:00
|
|
|
unsigned is_active; /* Path status */
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned fail_count; /* Cumulative failure count */
|
|
|
|
|
2006-12-08 17:36:33 +07:00
|
|
|
struct dm_path path;
|
2011-01-14 03:00:01 +07:00
|
|
|
struct delayed_work activate_path;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
#define path_to_pgpath(__pgp) container_of((__pgp), struct pgpath, path)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Paths are grouped into Priority Groups and numbered from 1 upwards.
|
|
|
|
* Each has a path selector which controls which path gets used.
|
|
|
|
*/
|
|
|
|
struct priority_group {
|
|
|
|
struct list_head list;
|
|
|
|
|
|
|
|
struct multipath *m; /* Owning multipath instance */
|
|
|
|
struct path_selector ps;
|
|
|
|
|
|
|
|
unsigned pg_num; /* Reference number */
|
|
|
|
unsigned bypassed; /* Temporarily bypass this PG? */
|
|
|
|
|
|
|
|
unsigned nr_pgpaths; /* Number of paths in PG */
|
|
|
|
struct list_head pgpaths;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Multipath context */
|
|
|
|
struct multipath {
|
|
|
|
struct list_head list;
|
|
|
|
struct dm_target *ti;
|
|
|
|
|
2008-05-02 04:50:11 +07:00
|
|
|
const char *hw_handler_name;
|
2009-08-04 02:42:45 +07:00
|
|
|
char *hw_handler_params;
|
2011-01-14 03:00:01 +07:00
|
|
|
|
2012-06-03 06:29:43 +07:00
|
|
|
spinlock_t lock;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned nr_priority_groups;
|
|
|
|
struct list_head priority_groups;
|
2011-01-14 03:00:01 +07:00
|
|
|
|
|
|
|
wait_queue_head_t pg_init_wait; /* Wait for pg_init completion */
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned pg_init_required; /* pg_init needs calling? */
|
2005-07-13 05:53:04 +07:00
|
|
|
unsigned pg_init_in_progress; /* Only one pg_init allowed at once */
|
2011-01-14 03:00:01 +07:00
|
|
|
unsigned pg_init_delay_retry; /* Delay pg_init retry? */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
unsigned nr_valid_paths; /* Total number of usable paths */
|
|
|
|
struct pgpath *current_pgpath;
|
|
|
|
struct priority_group *current_pg;
|
|
|
|
struct priority_group *next_pg; /* Switch to this PG if set */
|
|
|
|
unsigned repeat_count; /* I/Os left before calling PS again */
|
|
|
|
|
2012-06-03 06:29:43 +07:00
|
|
|
unsigned queue_io:1; /* Must we queue all I/O? */
|
|
|
|
unsigned queue_if_no_path:1; /* Queue I/O if last path fails? */
|
|
|
|
unsigned saved_queue_if_no_path:1; /* Saved state during suspension */
|
2012-07-27 21:08:04 +07:00
|
|
|
unsigned retain_attached_hw_handler:1; /* If there's already a hw_handler present, don't change it. */
|
2013-10-30 10:26:38 +07:00
|
|
|
unsigned pg_init_disabled:1; /* pg_init is not currently allowed */
|
2012-06-03 06:29:43 +07:00
|
|
|
|
2007-10-20 04:47:53 +07:00
|
|
|
unsigned pg_init_retries; /* Number of times to retry pg_init */
|
|
|
|
unsigned pg_init_count; /* Number of times pg_init called */
|
2011-01-14 03:00:01 +07:00
|
|
|
unsigned pg_init_delay_msecs; /* Number of msecs before pg_init retry */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
struct work_struct trigger_event;
|
|
|
|
|
|
|
|
/*
|
2007-07-12 23:26:32 +07:00
|
|
|
* We must use a mempool of dm_mpath_io structs so that we
|
2005-04-17 05:20:36 +07:00
|
|
|
* can resubmit bios on error.
|
|
|
|
*/
|
|
|
|
mempool_t *mpio_pool;
|
2009-12-11 06:52:21 +07:00
|
|
|
|
|
|
|
struct mutex work_mutex;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Context information attached to each bio we process.
|
|
|
|
*/
|
2007-07-12 23:26:32 +07:00
|
|
|
struct dm_mpath_io {
|
2005-04-17 05:20:36 +07:00
|
|
|
struct pgpath *pgpath;
|
2009-06-22 16:12:27 +07:00
|
|
|
size_t nr_bytes;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef int (*action_fn) (struct pgpath *pgpath);
|
|
|
|
|
2006-12-07 11:33:20 +07:00
|
|
|
static struct kmem_cache *_mpio_cache;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-05-02 04:50:22 +07:00
|
|
|
static struct workqueue_struct *kmultipathd, *kmpath_handlerd;
|
2006-11-22 21:57:56 +07:00
|
|
|
static void trigger_event(struct work_struct *work);
|
2008-05-02 04:50:22 +07:00
|
|
|
static void activate_path(struct work_struct *work);
|
2014-02-28 21:33:44 +07:00
|
|
|
static int __pgpath_busy(struct pgpath *pgpath);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
/*-----------------------------------------------
|
|
|
|
* Allocation routines
|
|
|
|
*-----------------------------------------------*/
|
|
|
|
|
|
|
|
static struct pgpath *alloc_pgpath(void)
|
|
|
|
{
|
2006-10-03 15:15:34 +07:00
|
|
|
struct pgpath *pgpath = kzalloc(sizeof(*pgpath), GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-08-29 14:36:09 +07:00
|
|
|
if (pgpath) {
|
2008-10-10 19:36:58 +07:00
|
|
|
pgpath->is_active = 1;
|
2011-01-14 03:00:01 +07:00
|
|
|
INIT_DELAYED_WORK(&pgpath->activate_path, activate_path);
|
2008-08-29 14:36:09 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return pgpath;
|
|
|
|
}
|
|
|
|
|
2007-07-12 23:26:32 +07:00
|
|
|
static void free_pgpath(struct pgpath *pgpath)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
kfree(pgpath);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct priority_group *alloc_priority_group(void)
|
|
|
|
{
|
|
|
|
struct priority_group *pg;
|
|
|
|
|
2006-10-03 15:15:34 +07:00
|
|
|
pg = kzalloc(sizeof(*pg), GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-10-03 15:15:34 +07:00
|
|
|
if (pg)
|
|
|
|
INIT_LIST_HEAD(&pg->pgpaths);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return pg;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_pgpaths(struct list_head *pgpaths, struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct pgpath *pgpath, *tmp;
|
2008-07-18 07:49:02 +07:00
|
|
|
struct multipath *m = ti->private;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
list_for_each_entry_safe(pgpath, tmp, pgpaths, list) {
|
|
|
|
list_del(&pgpath->list);
|
2008-07-18 07:49:02 +07:00
|
|
|
if (m->hw_handler_name)
|
|
|
|
scsi_dh_detach(bdev_get_queue(pgpath->path.dev->bdev));
|
2005-04-17 05:20:36 +07:00
|
|
|
dm_put_device(ti, pgpath->path.dev);
|
|
|
|
free_pgpath(pgpath);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_priority_group(struct priority_group *pg,
|
|
|
|
struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct path_selector *ps = &pg->ps;
|
|
|
|
|
|
|
|
if (ps->type) {
|
|
|
|
ps->type->destroy(ps);
|
|
|
|
dm_put_path_selector(ps->type);
|
|
|
|
}
|
|
|
|
|
|
|
|
free_pgpaths(&pg->pgpaths, ti);
|
|
|
|
kfree(pg);
|
|
|
|
}
|
|
|
|
|
2006-10-03 15:15:33 +07:00
|
|
|
static struct multipath *alloc_multipath(struct dm_target *ti)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct multipath *m;
|
2013-09-13 05:06:12 +07:00
|
|
|
unsigned min_ios = dm_get_reserved_rq_based_ios();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-10-03 15:15:34 +07:00
|
|
|
m = kzalloc(sizeof(*m), GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (m) {
|
|
|
|
INIT_LIST_HEAD(&m->priority_groups);
|
|
|
|
spin_lock_init(&m->lock);
|
|
|
|
m->queue_io = 1;
|
2011-01-14 03:00:01 +07:00
|
|
|
m->pg_init_delay_msecs = DM_PG_INIT_DELAY_DEFAULT;
|
2006-11-22 21:57:56 +07:00
|
|
|
INIT_WORK(&m->trigger_event, trigger_event);
|
2010-03-06 09:32:13 +07:00
|
|
|
init_waitqueue_head(&m->pg_init_wait);
|
2009-12-11 06:52:21 +07:00
|
|
|
mutex_init(&m->work_mutex);
|
2013-09-13 05:06:12 +07:00
|
|
|
m->mpio_pool = mempool_create_slab_pool(min_ios, _mpio_cache);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!m->mpio_pool) {
|
|
|
|
kfree(m);
|
|
|
|
return NULL;
|
|
|
|
}
|
2006-10-03 15:15:33 +07:00
|
|
|
m->ti = ti;
|
|
|
|
ti->private = m;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return m;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_multipath(struct multipath *m)
|
|
|
|
{
|
|
|
|
struct priority_group *pg, *tmp;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(pg, tmp, &m->priority_groups, list) {
|
|
|
|
list_del(&pg->list);
|
|
|
|
free_priority_group(pg, m->ti);
|
|
|
|
}
|
|
|
|
|
2008-05-02 04:50:11 +07:00
|
|
|
kfree(m->hw_handler_name);
|
2009-08-04 02:42:45 +07:00
|
|
|
kfree(m->hw_handler_params);
|
2005-04-17 05:20:36 +07:00
|
|
|
mempool_destroy(m->mpio_pool);
|
|
|
|
kfree(m);
|
|
|
|
}
|
|
|
|
|
2012-03-29 00:41:25 +07:00
|
|
|
static int set_mapinfo(struct multipath *m, union map_info *info)
|
|
|
|
{
|
|
|
|
struct dm_mpath_io *mpio;
|
|
|
|
|
|
|
|
mpio = mempool_alloc(m->mpio_pool, GFP_ATOMIC);
|
|
|
|
if (!mpio)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
memset(mpio, 0, sizeof(*mpio));
|
|
|
|
info->ptr = mpio;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void clear_mapinfo(struct multipath *m, union map_info *info)
|
|
|
|
{
|
|
|
|
struct dm_mpath_io *mpio = info->ptr;
|
|
|
|
|
|
|
|
info->ptr = NULL;
|
|
|
|
mempool_free(mpio, m->mpio_pool);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*-----------------------------------------------
|
|
|
|
* Path selection
|
|
|
|
*-----------------------------------------------*/
|
|
|
|
|
dm mpath: remove process_queued_ios()
process_queued_ios() has served 3 functions:
1) select pg and pgpath if none is selected
2) start pg_init if requested
3) dispatch queued IOs when pg is ready
Basically, a call to queue_work(process_queued_ios) can be replaced by
dm_table_run_md_queue_async(), which runs request queue and ends up
calling map_io(), which does 1), 2) and 3).
Exception is when !pg_ready() (which means either pg_init is running or
requested), then multipath_busy() prevents map_io() being called from
request_fn.
If pg_init is running, it should be ok as long as pg_init_done() does
the right thing when pg_init is completed, I.e.: restart pg_init if
!pg_ready() or call dm_table_run_md_queue_async() to kick map_io().
If pg_init is requested, we have to make sure the request is detected
and pg_init will be started. pg_init is requested in 3 places:
a) __choose_pgpath() in map_io()
b) __choose_pgpath() in multipath_ioctl()
c) pg_init retry in pg_init_done()
a) is ok because map_io() calls __pg_init_all_paths(), which does 2).
b) needs a call to __pg_init_all_paths(), which does 2).
c) needs a call to __pg_init_all_paths(), which does 2).
So this patch removes process_queued_ios() and ensures that
__pg_init_all_paths() is called at the appropriate locations.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
2014-02-28 21:33:45 +07:00
|
|
|
static int __pg_init_all_paths(struct multipath *m)
|
2010-03-06 09:32:18 +07:00
|
|
|
{
|
|
|
|
struct pgpath *pgpath;
|
2011-01-14 03:00:01 +07:00
|
|
|
unsigned long pg_init_delay = 0;
|
2010-03-06 09:32:18 +07:00
|
|
|
|
2014-02-28 21:33:42 +07:00
|
|
|
if (m->pg_init_in_progress || m->pg_init_disabled)
|
dm mpath: remove process_queued_ios()
process_queued_ios() has served 3 functions:
1) select pg and pgpath if none is selected
2) start pg_init if requested
3) dispatch queued IOs when pg is ready
Basically, a call to queue_work(process_queued_ios) can be replaced by
dm_table_run_md_queue_async(), which runs request queue and ends up
calling map_io(), which does 1), 2) and 3).
Exception is when !pg_ready() (which means either pg_init is running or
requested), then multipath_busy() prevents map_io() being called from
request_fn.
If pg_init is running, it should be ok as long as pg_init_done() does
the right thing when pg_init is completed, I.e.: restart pg_init if
!pg_ready() or call dm_table_run_md_queue_async() to kick map_io().
If pg_init is requested, we have to make sure the request is detected
and pg_init will be started. pg_init is requested in 3 places:
a) __choose_pgpath() in map_io()
b) __choose_pgpath() in multipath_ioctl()
c) pg_init retry in pg_init_done()
a) is ok because map_io() calls __pg_init_all_paths(), which does 2).
b) needs a call to __pg_init_all_paths(), which does 2).
c) needs a call to __pg_init_all_paths(), which does 2).
So this patch removes process_queued_ios() and ensures that
__pg_init_all_paths() is called at the appropriate locations.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
2014-02-28 21:33:45 +07:00
|
|
|
return 0;
|
2014-02-28 21:33:42 +07:00
|
|
|
|
2010-03-06 09:32:18 +07:00
|
|
|
m->pg_init_count++;
|
|
|
|
m->pg_init_required = 0;
|
dm mpath: remove process_queued_ios()
process_queued_ios() has served 3 functions:
1) select pg and pgpath if none is selected
2) start pg_init if requested
3) dispatch queued IOs when pg is ready
Basically, a call to queue_work(process_queued_ios) can be replaced by
dm_table_run_md_queue_async(), which runs request queue and ends up
calling map_io(), which does 1), 2) and 3).
Exception is when !pg_ready() (which means either pg_init is running or
requested), then multipath_busy() prevents map_io() being called from
request_fn.
If pg_init is running, it should be ok as long as pg_init_done() does
the right thing when pg_init is completed, I.e.: restart pg_init if
!pg_ready() or call dm_table_run_md_queue_async() to kick map_io().
If pg_init is requested, we have to make sure the request is detected
and pg_init will be started. pg_init is requested in 3 places:
a) __choose_pgpath() in map_io()
b) __choose_pgpath() in multipath_ioctl()
c) pg_init retry in pg_init_done()
a) is ok because map_io() calls __pg_init_all_paths(), which does 2).
b) needs a call to __pg_init_all_paths(), which does 2).
c) needs a call to __pg_init_all_paths(), which does 2).
So this patch removes process_queued_ios() and ensures that
__pg_init_all_paths() is called at the appropriate locations.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
2014-02-28 21:33:45 +07:00
|
|
|
|
|
|
|
/* Check here to reset pg_init_required */
|
|
|
|
if (!m->current_pg)
|
|
|
|
return 0;
|
|
|
|
|
2011-01-14 03:00:01 +07:00
|
|
|
if (m->pg_init_delay_retry)
|
|
|
|
pg_init_delay = msecs_to_jiffies(m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT ?
|
|
|
|
m->pg_init_delay_msecs : DM_PG_INIT_DELAY_MSECS);
|
2010-03-06 09:32:18 +07:00
|
|
|
list_for_each_entry(pgpath, &m->current_pg->pgpaths, list) {
|
|
|
|
/* Skip failed paths */
|
|
|
|
if (!pgpath->is_active)
|
|
|
|
continue;
|
2011-01-14 03:00:01 +07:00
|
|
|
if (queue_delayed_work(kmpath_handlerd, &pgpath->activate_path,
|
|
|
|
pg_init_delay))
|
2010-03-06 09:32:18 +07:00
|
|
|
m->pg_init_in_progress++;
|
|
|
|
}
|
dm mpath: remove process_queued_ios()
process_queued_ios() has served 3 functions:
1) select pg and pgpath if none is selected
2) start pg_init if requested
3) dispatch queued IOs when pg is ready
Basically, a call to queue_work(process_queued_ios) can be replaced by
dm_table_run_md_queue_async(), which runs request queue and ends up
calling map_io(), which does 1), 2) and 3).
Exception is when !pg_ready() (which means either pg_init is running or
requested), then multipath_busy() prevents map_io() being called from
request_fn.
If pg_init is running, it should be ok as long as pg_init_done() does
the right thing when pg_init is completed, I.e.: restart pg_init if
!pg_ready() or call dm_table_run_md_queue_async() to kick map_io().
If pg_init is requested, we have to make sure the request is detected
and pg_init will be started. pg_init is requested in 3 places:
a) __choose_pgpath() in map_io()
b) __choose_pgpath() in multipath_ioctl()
c) pg_init retry in pg_init_done()
a) is ok because map_io() calls __pg_init_all_paths(), which does 2).
b) needs a call to __pg_init_all_paths(), which does 2).
c) needs a call to __pg_init_all_paths(), which does 2).
So this patch removes process_queued_ios() and ensures that
__pg_init_all_paths() is called at the appropriate locations.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
2014-02-28 21:33:45 +07:00
|
|
|
return m->pg_init_in_progress;
|
2010-03-06 09:32:18 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static void __switch_pg(struct multipath *m, struct pgpath *pgpath)
|
|
|
|
{
|
|
|
|
m->current_pg = pgpath->pg;
|
|
|
|
|
|
|
|
/* Must we initialise the PG first, and queue I/O till it's ready? */
|
2008-05-02 04:50:11 +07:00
|
|
|
if (m->hw_handler_name) {
|
2005-04-17 05:20:36 +07:00
|
|
|
m->pg_init_required = 1;
|
|
|
|
m->queue_io = 1;
|
|
|
|
} else {
|
|
|
|
m->pg_init_required = 0;
|
|
|
|
m->queue_io = 0;
|
|
|
|
}
|
2007-10-20 04:47:53 +07:00
|
|
|
|
|
|
|
m->pg_init_count = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2009-06-22 16:12:27 +07:00
|
|
|
static int __choose_path_in_pg(struct multipath *m, struct priority_group *pg,
|
|
|
|
size_t nr_bytes)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-12-08 17:36:33 +07:00
|
|
|
struct dm_path *path;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-06-22 16:12:27 +07:00
|
|
|
path = pg->ps.type->select_path(&pg->ps, &m->repeat_count, nr_bytes);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!path)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
m->current_pgpath = path_to_pgpath(path);
|
|
|
|
|
|
|
|
if (m->current_pg != pg)
|
|
|
|
__switch_pg(m, m->current_pgpath);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-22 16:12:27 +07:00
|
|
|
static void __choose_pgpath(struct multipath *m, size_t nr_bytes)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct priority_group *pg;
|
|
|
|
unsigned bypassed = 1;
|
|
|
|
|
|
|
|
if (!m->nr_valid_paths)
|
|
|
|
goto failed;
|
|
|
|
|
|
|
|
/* Were we instructed to switch PG? */
|
|
|
|
if (m->next_pg) {
|
|
|
|
pg = m->next_pg;
|
|
|
|
m->next_pg = NULL;
|
2009-06-22 16:12:27 +07:00
|
|
|
if (!__choose_path_in_pg(m, pg, nr_bytes))
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Don't change PG until it has no remaining paths */
|
2009-06-22 16:12:27 +07:00
|
|
|
if (m->current_pg && !__choose_path_in_pg(m, m->current_pg, nr_bytes))
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Loop through priority groups until we find a valid path.
|
|
|
|
* First time we skip PGs marked 'bypassed'.
|
2012-06-03 06:29:45 +07:00
|
|
|
* Second time we only try the ones we skipped, but set
|
|
|
|
* pg_init_delay_retry so we do not hammer controllers.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
do {
|
|
|
|
list_for_each_entry(pg, &m->priority_groups, list) {
|
|
|
|
if (pg->bypassed == bypassed)
|
|
|
|
continue;
|
2012-06-03 06:29:45 +07:00
|
|
|
if (!__choose_path_in_pg(m, pg, nr_bytes)) {
|
|
|
|
if (!bypassed)
|
|
|
|
m->pg_init_delay_retry = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
2012-06-03 06:29:45 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
} while (bypassed--);
|
|
|
|
|
|
|
|
failed:
|
|
|
|
m->current_pgpath = NULL;
|
|
|
|
m->current_pg = NULL;
|
|
|
|
}
|
|
|
|
|
2006-12-08 17:41:10 +07:00
|
|
|
/*
|
|
|
|
* Check whether bios must be queued in the device-mapper core rather
|
|
|
|
* than here in the target.
|
|
|
|
*
|
|
|
|
* m->lock must be held on entry.
|
|
|
|
*
|
|
|
|
* If m->queue_if_no_path and m->saved_queue_if_no_path hold the
|
|
|
|
* same value then we are not between multipath_presuspend()
|
|
|
|
* and multipath_resume() calls and we have no need to check
|
|
|
|
* for the DMF_NOFLUSH_SUSPENDING flag.
|
|
|
|
*/
|
|
|
|
static int __must_push_back(struct multipath *m)
|
|
|
|
{
|
2014-02-28 21:33:44 +07:00
|
|
|
return (m->queue_if_no_path ||
|
|
|
|
(m->queue_if_no_path != m->saved_queue_if_no_path &&
|
|
|
|
dm_noflush_suspending(m->ti)));
|
2006-12-08 17:41:10 +07:00
|
|
|
}
|
|
|
|
|
2014-02-28 21:33:44 +07:00
|
|
|
#define pg_ready(m) (!(m)->queue_io && !(m)->pg_init_required)
|
|
|
|
|
2014-02-28 21:33:47 +07:00
|
|
|
/*
|
|
|
|
* Map cloned requests
|
|
|
|
*/
|
|
|
|
static int multipath_map(struct dm_target *ti, struct request *clone,
|
|
|
|
union map_info *map_context)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2014-02-28 21:33:47 +07:00
|
|
|
struct multipath *m = (struct multipath *) ti->private;
|
2014-02-28 21:33:46 +07:00
|
|
|
int r = DM_MAPIO_REQUEUE;
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
size_t nr_bytes = blk_rq_bytes(clone);
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
|
|
|
struct pgpath *pgpath;
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
struct block_device *bdev;
|
2014-02-28 21:33:46 +07:00
|
|
|
struct dm_mpath_io *mpio;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
|
|
|
|
/* Do we need to select a new pgpath? */
|
|
|
|
if (!m->current_pgpath ||
|
|
|
|
(!m->queue_io && (m->repeat_count && --m->repeat_count == 0)))
|
2009-06-22 16:12:27 +07:00
|
|
|
__choose_pgpath(m, nr_bytes);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
pgpath = m->current_pgpath;
|
|
|
|
|
2014-02-28 21:33:48 +07:00
|
|
|
if (!pgpath) {
|
|
|
|
if (!__must_push_back(m))
|
|
|
|
r = -EIO; /* Failed */
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
if (!pg_ready(m)) {
|
2014-02-28 21:33:46 +07:00
|
|
|
__pg_init_all_paths(m);
|
2014-02-28 21:33:48 +07:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
if (set_mapinfo(m, map_context) < 0)
|
|
|
|
/* ENOMEM, requeue */
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
bdev = pgpath->path.dev->bdev;
|
|
|
|
clone->q = bdev_get_queue(bdev);
|
|
|
|
clone->rq_disk = bdev->bd_disk;
|
|
|
|
clone->cmd_flags |= REQ_FAILFAST_TRANSPORT;
|
|
|
|
mpio = map_context->ptr;
|
|
|
|
mpio->pgpath = pgpath;
|
|
|
|
mpio->nr_bytes = nr_bytes;
|
|
|
|
if (pgpath->pg->ps.type->start_io)
|
|
|
|
pgpath->pg->ps.type->start_io(&pgpath->pg->ps,
|
|
|
|
&pgpath->path,
|
|
|
|
nr_bytes);
|
|
|
|
r = DM_MAPIO_REMAPPED;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-02-28 21:33:46 +07:00
|
|
|
out_unlock:
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we run out of usable paths, should we queue I/O or error it?
|
|
|
|
*/
|
2005-09-28 11:45:45 +07:00
|
|
|
static int queue_if_no_path(struct multipath *m, unsigned queue_if_no_path,
|
|
|
|
unsigned save_old_value)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
|
2005-09-28 11:45:45 +07:00
|
|
|
if (save_old_value)
|
|
|
|
m->saved_queue_if_no_path = m->queue_if_no_path;
|
|
|
|
else
|
|
|
|
m->saved_queue_if_no_path = queue_if_no_path;
|
2005-04-17 05:20:36 +07:00
|
|
|
m->queue_if_no_path = queue_if_no_path;
|
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
|
2014-05-26 19:45:39 +07:00
|
|
|
if (!queue_if_no_path)
|
|
|
|
dm_table_run_md_queue_async(m->ti->table);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* An event is triggered whenever a path is taken out of use.
|
|
|
|
* Includes path failure and PG bypass.
|
|
|
|
*/
|
2006-11-22 21:57:56 +07:00
|
|
|
static void trigger_event(struct work_struct *work)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-11-22 21:57:56 +07:00
|
|
|
struct multipath *m =
|
|
|
|
container_of(work, struct multipath, trigger_event);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
dm_table_event(m->ti->table);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* Constructor/argument parsing:
|
|
|
|
* <#multipath feature args> [<arg>]*
|
|
|
|
* <#hw_handler args> [hw_handler [<arg>]*]
|
|
|
|
* <#priority groups>
|
|
|
|
* <initial priority group>
|
|
|
|
* [<selector> <#selector args> [<arg>]*
|
|
|
|
* <#paths> <#per-path selector args>
|
|
|
|
* [<path> [<arg>]* ]+ ]+
|
|
|
|
*---------------------------------------------------------------*/
|
2011-08-02 18:32:04 +07:00
|
|
|
static int parse_path_selector(struct dm_arg_set *as, struct priority_group *pg,
|
2005-04-17 05:20:36 +07:00
|
|
|
struct dm_target *ti)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
struct path_selector_type *pst;
|
|
|
|
unsigned ps_argc;
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
static struct dm_arg _args[] = {
|
2006-06-26 14:27:35 +07:00
|
|
|
{0, 1024, "invalid number of path selector args"},
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
pst = dm_get_path_selector(dm_shift_arg(as));
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!pst) {
|
2006-06-26 14:27:35 +07:00
|
|
|
ti->error = "unknown path selector type";
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
r = dm_read_arg_group(_args, as, &ps_argc, &ti->error);
|
2008-07-21 18:00:24 +07:00
|
|
|
if (r) {
|
|
|
|
dm_put_path_selector(pst);
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
2008-07-21 18:00:24 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
r = pst->create(&pg->ps, ps_argc, as->argv);
|
|
|
|
if (r) {
|
|
|
|
dm_put_path_selector(pst);
|
2006-06-26 14:27:35 +07:00
|
|
|
ti->error = "path selector constructor failed";
|
2005-04-17 05:20:36 +07:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
pg->ps.type = pst;
|
2011-08-02 18:32:04 +07:00
|
|
|
dm_consume_args(as, ps_argc);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
static struct pgpath *parse_path(struct dm_arg_set *as, struct path_selector *ps,
|
2005-04-17 05:20:36 +07:00
|
|
|
struct dm_target *ti)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
struct pgpath *p;
|
2008-07-18 07:49:02 +07:00
|
|
|
struct multipath *m = ti->private;
|
2012-07-27 21:08:04 +07:00
|
|
|
struct request_queue *q = NULL;
|
|
|
|
const char *attached_handler_name;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* we need at least a path arg */
|
|
|
|
if (as->argc < 1) {
|
2006-06-26 14:27:35 +07:00
|
|
|
ti->error = "no device given";
|
2008-10-10 19:36:57 +07:00
|
|
|
return ERR_PTR(-EINVAL);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
p = alloc_pgpath();
|
|
|
|
if (!p)
|
2008-10-10 19:36:57 +07:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
r = dm_get_device(ti, dm_shift_arg(as), dm_table_get_mode(ti->table),
|
2010-03-06 09:32:27 +07:00
|
|
|
&p->path.dev);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (r) {
|
2006-06-26 14:27:35 +07:00
|
|
|
ti->error = "error getting device";
|
2005-04-17 05:20:36 +07:00
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
2012-07-27 21:08:04 +07:00
|
|
|
if (m->retain_attached_hw_handler || m->hw_handler_name)
|
|
|
|
q = bdev_get_queue(p->path.dev->bdev);
|
|
|
|
|
|
|
|
if (m->retain_attached_hw_handler) {
|
|
|
|
attached_handler_name = scsi_dh_attached_handler_name(q, GFP_KERNEL);
|
|
|
|
if (attached_handler_name) {
|
|
|
|
/*
|
|
|
|
* Reset hw_handler_name to match the attached handler
|
|
|
|
* and clear any hw_handler_params associated with the
|
|
|
|
* ignored handler.
|
|
|
|
*
|
|
|
|
* NB. This modifies the table line to show the actual
|
|
|
|
* handler instead of the original table passed in.
|
|
|
|
*/
|
|
|
|
kfree(m->hw_handler_name);
|
|
|
|
m->hw_handler_name = attached_handler_name;
|
|
|
|
|
|
|
|
kfree(m->hw_handler_params);
|
|
|
|
m->hw_handler_params = NULL;
|
|
|
|
}
|
|
|
|
}
|
2009-06-22 16:12:11 +07:00
|
|
|
|
2012-07-27 21:08:04 +07:00
|
|
|
if (m->hw_handler_name) {
|
|
|
|
/*
|
|
|
|
* Increments scsi_dh reference, even when using an
|
|
|
|
* already-attached handler.
|
|
|
|
*/
|
2009-06-22 16:12:11 +07:00
|
|
|
r = scsi_dh_attach(q, m->hw_handler_name);
|
|
|
|
if (r == -EBUSY) {
|
|
|
|
/*
|
2012-07-27 21:08:04 +07:00
|
|
|
* Already attached to different hw_handler:
|
2009-06-22 16:12:11 +07:00
|
|
|
* try to reattach with correct one.
|
|
|
|
*/
|
|
|
|
scsi_dh_detach(q);
|
|
|
|
r = scsi_dh_attach(q, m->hw_handler_name);
|
|
|
|
}
|
|
|
|
|
2008-07-18 07:49:02 +07:00
|
|
|
if (r < 0) {
|
2009-06-22 16:12:11 +07:00
|
|
|
ti->error = "error attaching hardware handler";
|
2008-07-18 07:49:02 +07:00
|
|
|
dm_put_device(ti, p->path.dev);
|
|
|
|
goto bad;
|
|
|
|
}
|
2009-08-04 02:42:45 +07:00
|
|
|
|
|
|
|
if (m->hw_handler_params) {
|
|
|
|
r = scsi_dh_set_params(q, m->hw_handler_params);
|
|
|
|
if (r < 0) {
|
|
|
|
ti->error = "unable to set hardware "
|
|
|
|
"handler parameters";
|
|
|
|
scsi_dh_detach(q);
|
|
|
|
dm_put_device(ti, p->path.dev);
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
}
|
2008-07-18 07:49:02 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
r = ps->type->add_path(ps, &p->path, as->argc, as->argv, &ti->error);
|
|
|
|
if (r) {
|
|
|
|
dm_put_device(ti, p->path.dev);
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
return p;
|
|
|
|
|
|
|
|
bad:
|
|
|
|
free_pgpath(p);
|
2008-10-10 19:36:57 +07:00
|
|
|
return ERR_PTR(r);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
static struct priority_group *parse_priority_group(struct dm_arg_set *as,
|
2006-10-03 15:15:33 +07:00
|
|
|
struct multipath *m)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2011-08-02 18:32:04 +07:00
|
|
|
static struct dm_arg _args[] = {
|
2006-06-26 14:27:35 +07:00
|
|
|
{1, 1024, "invalid number of paths"},
|
|
|
|
{0, 1024, "invalid number of selector args"}
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
int r;
|
2011-08-02 18:32:04 +07:00
|
|
|
unsigned i, nr_selector_args, nr_args;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct priority_group *pg;
|
2006-10-03 15:15:33 +07:00
|
|
|
struct dm_target *ti = m->ti;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (as->argc < 2) {
|
|
|
|
as->argc = 0;
|
2008-10-10 19:36:57 +07:00
|
|
|
ti->error = "not enough priority group arguments";
|
|
|
|
return ERR_PTR(-EINVAL);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
pg = alloc_priority_group();
|
|
|
|
if (!pg) {
|
2006-06-26 14:27:35 +07:00
|
|
|
ti->error = "couldn't allocate priority group";
|
2008-10-10 19:36:57 +07:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
pg->m = m;
|
|
|
|
|
|
|
|
r = parse_path_selector(as, pg, ti);
|
|
|
|
if (r)
|
|
|
|
goto bad;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* read the paths
|
|
|
|
*/
|
2011-08-02 18:32:04 +07:00
|
|
|
r = dm_read_arg(_args, as, &pg->nr_pgpaths, &ti->error);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (r)
|
|
|
|
goto bad;
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
r = dm_read_arg(_args + 1, as, &nr_selector_args, &ti->error);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (r)
|
|
|
|
goto bad;
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
nr_args = 1 + nr_selector_args;
|
2005-04-17 05:20:36 +07:00
|
|
|
for (i = 0; i < pg->nr_pgpaths; i++) {
|
|
|
|
struct pgpath *pgpath;
|
2011-08-02 18:32:04 +07:00
|
|
|
struct dm_arg_set path_args;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
if (as->argc < nr_args) {
|
2008-07-21 18:00:30 +07:00
|
|
|
ti->error = "not enough path parameters";
|
2010-08-12 10:13:49 +07:00
|
|
|
r = -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
goto bad;
|
2008-07-21 18:00:30 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
path_args.argc = nr_args;
|
2005-04-17 05:20:36 +07:00
|
|
|
path_args.argv = as->argv;
|
|
|
|
|
|
|
|
pgpath = parse_path(&path_args, &pg->ps, ti);
|
2008-10-10 19:36:57 +07:00
|
|
|
if (IS_ERR(pgpath)) {
|
|
|
|
r = PTR_ERR(pgpath);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto bad;
|
2008-10-10 19:36:57 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
pgpath->pg = pg;
|
|
|
|
list_add_tail(&pgpath->list, &pg->pgpaths);
|
2011-08-02 18:32:04 +07:00
|
|
|
dm_consume_args(as, nr_args);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return pg;
|
|
|
|
|
|
|
|
bad:
|
|
|
|
free_priority_group(pg, ti);
|
2008-10-10 19:36:57 +07:00
|
|
|
return ERR_PTR(r);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
static int parse_hw_handler(struct dm_arg_set *as, struct multipath *m)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned hw_argc;
|
2009-08-04 02:42:45 +07:00
|
|
|
int ret;
|
2006-10-03 15:15:33 +07:00
|
|
|
struct dm_target *ti = m->ti;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
static struct dm_arg _args[] = {
|
2006-06-26 14:27:35 +07:00
|
|
|
{0, 1024, "invalid number of hardware handler args"},
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
if (dm_read_arg_group(_args, as, &hw_argc, &ti->error))
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!hw_argc)
|
|
|
|
return 0;
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
m->hw_handler_name = kstrdup(dm_shift_arg(as), GFP_KERNEL);
|
2012-05-12 07:43:21 +07:00
|
|
|
if (!try_then_request_module(scsi_dh_handler_exist(m->hw_handler_name),
|
|
|
|
"scsi_dh_%s", m->hw_handler_name)) {
|
2006-06-26 14:27:35 +07:00
|
|
|
ti->error = "unknown hardware handler type";
|
2009-08-04 02:42:45 +07:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto fail;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-11-14 06:39:06 +07:00
|
|
|
|
2009-08-04 02:42:45 +07:00
|
|
|
if (hw_argc > 1) {
|
|
|
|
char *p;
|
|
|
|
int i, j, len = 4;
|
|
|
|
|
|
|
|
for (i = 0; i <= hw_argc - 2; i++)
|
|
|
|
len += strlen(as->argv[i]) + 1;
|
|
|
|
p = m->hw_handler_params = kzalloc(len, GFP_KERNEL);
|
|
|
|
if (!p) {
|
|
|
|
ti->error = "memory allocation failed";
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
j = sprintf(p, "%d", hw_argc - 1);
|
|
|
|
for (i = 0, p+=j+1; i <= hw_argc - 2; i++, p+=j+1)
|
|
|
|
j = sprintf(p, "%s", as->argv[i]);
|
|
|
|
}
|
2011-08-02 18:32:04 +07:00
|
|
|
dm_consume_args(as, hw_argc - 1);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return 0;
|
2009-08-04 02:42:45 +07:00
|
|
|
fail:
|
|
|
|
kfree(m->hw_handler_name);
|
|
|
|
m->hw_handler_name = NULL;
|
|
|
|
return ret;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
static int parse_features(struct dm_arg_set *as, struct multipath *m)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int r;
|
|
|
|
unsigned argc;
|
2006-10-03 15:15:33 +07:00
|
|
|
struct dm_target *ti = m->ti;
|
2011-08-02 18:32:04 +07:00
|
|
|
const char *arg_name;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
static struct dm_arg _args[] = {
|
2012-07-27 21:08:04 +07:00
|
|
|
{0, 6, "invalid number of feature args"},
|
2007-10-20 04:47:53 +07:00
|
|
|
{1, 50, "pg_init_retries must be between 1 and 50"},
|
2011-01-14 03:00:01 +07:00
|
|
|
{0, 60000, "pg_init_delay_msecs must be between 0 and 60000"},
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
r = dm_read_arg_group(_args, as, &argc, &ti->error);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (r)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!argc)
|
|
|
|
return 0;
|
|
|
|
|
2007-10-20 04:47:53 +07:00
|
|
|
do {
|
2011-08-02 18:32:04 +07:00
|
|
|
arg_name = dm_shift_arg(as);
|
2007-10-20 04:47:53 +07:00
|
|
|
argc--;
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
if (!strcasecmp(arg_name, "queue_if_no_path")) {
|
2007-10-20 04:47:53 +07:00
|
|
|
r = queue_if_no_path(m, 1, 0);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-07-27 21:08:04 +07:00
|
|
|
if (!strcasecmp(arg_name, "retain_attached_hw_handler")) {
|
|
|
|
m->retain_attached_hw_handler = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
if (!strcasecmp(arg_name, "pg_init_retries") &&
|
2007-10-20 04:47:53 +07:00
|
|
|
(argc >= 1)) {
|
2011-08-02 18:32:04 +07:00
|
|
|
r = dm_read_arg(_args + 1, as, &m->pg_init_retries, &ti->error);
|
2007-10-20 04:47:53 +07:00
|
|
|
argc--;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
if (!strcasecmp(arg_name, "pg_init_delay_msecs") &&
|
2011-01-14 03:00:01 +07:00
|
|
|
(argc >= 1)) {
|
2011-08-02 18:32:04 +07:00
|
|
|
r = dm_read_arg(_args + 2, as, &m->pg_init_delay_msecs, &ti->error);
|
2011-01-14 03:00:01 +07:00
|
|
|
argc--;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
ti->error = "Unrecognised multipath feature request";
|
2007-10-20 04:47:53 +07:00
|
|
|
r = -EINVAL;
|
|
|
|
} while (argc && !r);
|
|
|
|
|
|
|
|
return r;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int multipath_ctr(struct dm_target *ti, unsigned int argc,
|
|
|
|
char **argv)
|
|
|
|
{
|
2011-08-02 18:32:04 +07:00
|
|
|
/* target arguments */
|
|
|
|
static struct dm_arg _args[] = {
|
2011-03-24 20:54:33 +07:00
|
|
|
{0, 1024, "invalid number of priority groups"},
|
|
|
|
{0, 1024, "invalid initial priority group number"},
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
int r;
|
|
|
|
struct multipath *m;
|
2011-08-02 18:32:04 +07:00
|
|
|
struct dm_arg_set as;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned pg_count = 0;
|
|
|
|
unsigned next_pg_num;
|
|
|
|
|
|
|
|
as.argc = argc;
|
|
|
|
as.argv = argv;
|
|
|
|
|
2006-10-03 15:15:33 +07:00
|
|
|
m = alloc_multipath(ti);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!m) {
|
2006-06-26 14:27:35 +07:00
|
|
|
ti->error = "can't allocate multipath";
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2006-10-03 15:15:33 +07:00
|
|
|
r = parse_features(&as, m);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (r)
|
|
|
|
goto bad;
|
|
|
|
|
2006-10-03 15:15:33 +07:00
|
|
|
r = parse_hw_handler(&as, m);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (r)
|
|
|
|
goto bad;
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
r = dm_read_arg(_args, &as, &m->nr_priority_groups, &ti->error);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (r)
|
|
|
|
goto bad;
|
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
r = dm_read_arg(_args + 1, &as, &next_pg_num, &ti->error);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (r)
|
|
|
|
goto bad;
|
|
|
|
|
2011-03-24 20:54:33 +07:00
|
|
|
if ((!m->nr_priority_groups && next_pg_num) ||
|
|
|
|
(m->nr_priority_groups && !next_pg_num)) {
|
|
|
|
ti->error = "invalid initial priority group";
|
|
|
|
r = -EINVAL;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* parse the priority groups */
|
|
|
|
while (as.argc) {
|
|
|
|
struct priority_group *pg;
|
|
|
|
|
2006-10-03 15:15:33 +07:00
|
|
|
pg = parse_priority_group(&as, m);
|
2008-10-10 19:36:57 +07:00
|
|
|
if (IS_ERR(pg)) {
|
|
|
|
r = PTR_ERR(pg);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
m->nr_valid_paths += pg->nr_pgpaths;
|
|
|
|
list_add_tail(&pg->list, &m->priority_groups);
|
|
|
|
pg_count++;
|
|
|
|
pg->pg_num = pg_count;
|
|
|
|
if (!--next_pg_num)
|
|
|
|
m->next_pg = pg;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pg_count != m->nr_priority_groups) {
|
2006-06-26 14:27:35 +07:00
|
|
|
ti->error = "priority group count mismatch";
|
2005-04-17 05:20:36 +07:00
|
|
|
r = -EINVAL;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
2013-03-02 05:45:47 +07:00
|
|
|
ti->num_flush_bios = 1;
|
|
|
|
ti->num_discard_bios = 1;
|
2013-05-10 20:37:16 +07:00
|
|
|
ti->num_write_same_bios = 1;
|
2009-06-22 16:12:24 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
bad:
|
|
|
|
free_multipath(m);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2010-03-06 09:32:13 +07:00
|
|
|
static void multipath_wait_for_pg_init_completion(struct multipath *m)
|
|
|
|
{
|
|
|
|
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)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2013-10-30 10:26:38 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
m->pg_init_disabled = 1;
|
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
|
2008-05-02 04:50:22 +07:00
|
|
|
flush_workqueue(kmpath_handlerd);
|
2010-03-06 09:32:13 +07:00
|
|
|
multipath_wait_for_pg_init_completion(m);
|
2005-07-13 05:53:02 +07:00
|
|
|
flush_workqueue(kmultipathd);
|
2012-08-21 04:51:24 +07:00
|
|
|
flush_work(&m->trigger_event);
|
2013-10-30 10:26:38 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
m->pg_init_disabled = 0;
|
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
2009-12-11 06:52:19 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void multipath_dtr(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct multipath *m = ti->private;
|
|
|
|
|
2010-03-06 09:32:13 +07:00
|
|
|
flush_multipath_work(m);
|
2005-04-17 05:20:36 +07:00
|
|
|
free_multipath(m);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Take a path out of use.
|
|
|
|
*/
|
|
|
|
static int fail_path(struct pgpath *pgpath)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct multipath *m = pgpath->pg->m;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
|
2008-10-10 19:36:58 +07:00
|
|
|
if (!pgpath->is_active)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
|
2006-06-26 14:27:35 +07:00
|
|
|
DMWARN("Failing path %s.", pgpath->path.dev->name);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
pgpath->pg->ps.type->fail_path(&pgpath->pg->ps, &pgpath->path);
|
2008-10-10 19:36:58 +07:00
|
|
|
pgpath->is_active = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
pgpath->fail_count++;
|
|
|
|
|
|
|
|
m->nr_valid_paths--;
|
|
|
|
|
|
|
|
if (pgpath == m->current_pgpath)
|
|
|
|
m->current_pgpath = NULL;
|
|
|
|
|
2007-10-20 04:48:02 +07:00
|
|
|
dm_path_uevent(DM_UEVENT_PATH_FAILED, m->ti,
|
|
|
|
pgpath->path.dev->name, m->nr_valid_paths);
|
|
|
|
|
2009-01-06 10:05:13 +07:00
|
|
|
schedule_work(&m->trigger_event);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reinstate a previously-failed path
|
|
|
|
*/
|
|
|
|
static int reinstate_path(struct pgpath *pgpath)
|
|
|
|
{
|
2014-05-26 19:45:39 +07:00
|
|
|
int r = 0, run_queue = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
|
|
|
struct multipath *m = pgpath->pg->m;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
|
2008-10-10 19:36:58 +07:00
|
|
|
if (pgpath->is_active)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
|
2008-07-21 18:00:31 +07:00
|
|
|
if (!pgpath->pg->ps.type->reinstate_path) {
|
2005-04-17 05:20:36 +07:00
|
|
|
DMWARN("Reinstate path not supported by path selector %s",
|
|
|
|
pgpath->pg->ps.type->name);
|
|
|
|
r = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = pgpath->pg->ps.type->reinstate_path(&pgpath->pg->ps, &pgpath->path);
|
|
|
|
if (r)
|
|
|
|
goto out;
|
|
|
|
|
2008-10-10 19:36:58 +07:00
|
|
|
pgpath->is_active = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-02-28 21:33:44 +07:00
|
|
|
if (!m->nr_valid_paths++) {
|
2009-06-22 16:12:12 +07:00
|
|
|
m->current_pgpath = NULL;
|
2014-05-26 19:45:39 +07:00
|
|
|
run_queue = 1;
|
2009-06-22 16:12:12 +07:00
|
|
|
} else if (m->hw_handler_name && (m->current_pg == pgpath->pg)) {
|
2011-01-14 03:00:01 +07:00
|
|
|
if (queue_work(kmpath_handlerd, &pgpath->activate_path.work))
|
2009-06-22 16:12:12 +07:00
|
|
|
m->pg_init_in_progress++;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-20 04:48:02 +07:00
|
|
|
dm_path_uevent(DM_UEVENT_PATH_REINSTATED, m->ti,
|
|
|
|
pgpath->path.dev->name, m->nr_valid_paths);
|
|
|
|
|
2009-01-06 10:05:13 +07:00
|
|
|
schedule_work(&m->trigger_event);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
2014-05-26 19:45:39 +07:00
|
|
|
if (run_queue)
|
|
|
|
dm_table_run_md_queue_async(m->ti->table);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fail or reinstate all paths that match the provided struct dm_dev.
|
|
|
|
*/
|
|
|
|
static int action_dev(struct multipath *m, struct dm_dev *dev,
|
|
|
|
action_fn action)
|
|
|
|
{
|
2011-03-24 20:54:31 +07:00
|
|
|
int r = -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct pgpath *pgpath;
|
|
|
|
struct priority_group *pg;
|
|
|
|
|
|
|
|
list_for_each_entry(pg, &m->priority_groups, list) {
|
|
|
|
list_for_each_entry(pgpath, &pg->pgpaths, list) {
|
|
|
|
if (pgpath->path.dev == dev)
|
|
|
|
r = action(pgpath);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Temporarily try to avoid having to use the specified PG
|
|
|
|
*/
|
|
|
|
static void bypass_pg(struct multipath *m, struct priority_group *pg,
|
|
|
|
int bypassed)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
|
|
|
|
pg->bypassed = bypassed;
|
|
|
|
m->current_pgpath = NULL;
|
|
|
|
m->current_pg = NULL;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
|
2009-01-06 10:05:13 +07:00
|
|
|
schedule_work(&m->trigger_event);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Switch to using the specified PG from the next I/O that gets mapped
|
|
|
|
*/
|
|
|
|
static int switch_pg_num(struct multipath *m, const char *pgstr)
|
|
|
|
{
|
|
|
|
struct priority_group *pg;
|
|
|
|
unsigned pgnum;
|
|
|
|
unsigned long flags;
|
dm: reject trailing characters in sccanf input
Device mapper uses sscanf to convert arguments to numbers. The problem is that
the way we use it ignores additional unmatched characters in the scanned string.
For example, this `if (sscanf(string, "%d", &number) == 1)' will match a number,
but also it will match number with some garbage appended, like "123abc".
As a result, device mapper accepts garbage after some numbers. For example
the command `dmsetup create vg1-new --table "0 16384 linear 254:1bla 34816bla"'
will pass without an error.
This patch fixes all sscanf uses in device mapper. It appends "%c" with
a pointer to a dummy character variable to every sscanf statement.
The construct `if (sscanf(string, "%d%c", &number, &dummy) == 1)' succeeds
only if string is a null-terminated number (optionally preceded by some
whitespace characters). If there is some character appended after the number,
sscanf matches "%c", writes the character to the dummy variable and returns 2.
We check the return value for 1 and consequently reject numbers with some
garbage appended.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2012-03-29 00:41:26 +07:00
|
|
|
char dummy;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
dm: reject trailing characters in sccanf input
Device mapper uses sscanf to convert arguments to numbers. The problem is that
the way we use it ignores additional unmatched characters in the scanned string.
For example, this `if (sscanf(string, "%d", &number) == 1)' will match a number,
but also it will match number with some garbage appended, like "123abc".
As a result, device mapper accepts garbage after some numbers. For example
the command `dmsetup create vg1-new --table "0 16384 linear 254:1bla 34816bla"'
will pass without an error.
This patch fixes all sscanf uses in device mapper. It appends "%c" with
a pointer to a dummy character variable to every sscanf statement.
The construct `if (sscanf(string, "%d%c", &number, &dummy) == 1)' succeeds
only if string is a null-terminated number (optionally preceded by some
whitespace characters). If there is some character appended after the number,
sscanf matches "%c", writes the character to the dummy variable and returns 2.
We check the return value for 1 and consequently reject numbers with some
garbage appended.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2012-03-29 00:41:26 +07:00
|
|
|
if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
|
2005-04-17 05:20:36 +07:00
|
|
|
(pgnum > m->nr_priority_groups)) {
|
|
|
|
DMWARN("invalid PG number supplied to switch_pg_num");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
list_for_each_entry(pg, &m->priority_groups, list) {
|
|
|
|
pg->bypassed = 0;
|
|
|
|
if (--pgnum)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
m->current_pgpath = NULL;
|
|
|
|
m->current_pg = NULL;
|
|
|
|
m->next_pg = pg;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
|
2009-01-06 10:05:13 +07:00
|
|
|
schedule_work(&m->trigger_event);
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set/clear bypassed status of a PG.
|
|
|
|
* PGs are numbered upwards from 1 in the order they were declared.
|
|
|
|
*/
|
|
|
|
static int bypass_pg_num(struct multipath *m, const char *pgstr, int bypassed)
|
|
|
|
{
|
|
|
|
struct priority_group *pg;
|
|
|
|
unsigned pgnum;
|
dm: reject trailing characters in sccanf input
Device mapper uses sscanf to convert arguments to numbers. The problem is that
the way we use it ignores additional unmatched characters in the scanned string.
For example, this `if (sscanf(string, "%d", &number) == 1)' will match a number,
but also it will match number with some garbage appended, like "123abc".
As a result, device mapper accepts garbage after some numbers. For example
the command `dmsetup create vg1-new --table "0 16384 linear 254:1bla 34816bla"'
will pass without an error.
This patch fixes all sscanf uses in device mapper. It appends "%c" with
a pointer to a dummy character variable to every sscanf statement.
The construct `if (sscanf(string, "%d%c", &number, &dummy) == 1)' succeeds
only if string is a null-terminated number (optionally preceded by some
whitespace characters). If there is some character appended after the number,
sscanf matches "%c", writes the character to the dummy variable and returns 2.
We check the return value for 1 and consequently reject numbers with some
garbage appended.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2012-03-29 00:41:26 +07:00
|
|
|
char dummy;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
dm: reject trailing characters in sccanf input
Device mapper uses sscanf to convert arguments to numbers. The problem is that
the way we use it ignores additional unmatched characters in the scanned string.
For example, this `if (sscanf(string, "%d", &number) == 1)' will match a number,
but also it will match number with some garbage appended, like "123abc".
As a result, device mapper accepts garbage after some numbers. For example
the command `dmsetup create vg1-new --table "0 16384 linear 254:1bla 34816bla"'
will pass without an error.
This patch fixes all sscanf uses in device mapper. It appends "%c" with
a pointer to a dummy character variable to every sscanf statement.
The construct `if (sscanf(string, "%d%c", &number, &dummy) == 1)' succeeds
only if string is a null-terminated number (optionally preceded by some
whitespace characters). If there is some character appended after the number,
sscanf matches "%c", writes the character to the dummy variable and returns 2.
We check the return value for 1 and consequently reject numbers with some
garbage appended.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2012-03-29 00:41:26 +07:00
|
|
|
if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
|
2005-04-17 05:20:36 +07:00
|
|
|
(pgnum > m->nr_priority_groups)) {
|
|
|
|
DMWARN("invalid PG number supplied to bypass_pg");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(pg, &m->priority_groups, list) {
|
|
|
|
if (!--pgnum)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
bypass_pg(m, pg, bypassed);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-20 04:47:53 +07:00
|
|
|
/*
|
|
|
|
* Should we retry pg_init immediately?
|
|
|
|
*/
|
|
|
|
static int pg_init_limit_reached(struct multipath *m, struct pgpath *pgpath)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int limit_reached = 0;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
|
2013-10-30 10:26:38 +07:00
|
|
|
if (m->pg_init_count <= m->pg_init_retries && !m->pg_init_disabled)
|
2007-10-20 04:47:53 +07:00
|
|
|
m->pg_init_required = 1;
|
|
|
|
else
|
|
|
|
limit_reached = 1;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
|
|
|
|
return limit_reached;
|
|
|
|
}
|
|
|
|
|
2009-10-21 23:22:46 +07:00
|
|
|
static void pg_init_done(void *data, int errors)
|
2008-05-02 04:50:11 +07:00
|
|
|
{
|
2010-03-06 09:29:45 +07:00
|
|
|
struct pgpath *pgpath = data;
|
2008-05-02 04:50:11 +07:00
|
|
|
struct priority_group *pg = pgpath->pg;
|
|
|
|
struct multipath *m = pg->m;
|
|
|
|
unsigned long flags;
|
2011-01-14 03:00:01 +07:00
|
|
|
unsigned delay_retry = 0;
|
2008-05-02 04:50:11 +07:00
|
|
|
|
|
|
|
/* device or driver problems */
|
|
|
|
switch (errors) {
|
|
|
|
case SCSI_DH_OK:
|
|
|
|
break;
|
|
|
|
case SCSI_DH_NOSYS:
|
|
|
|
if (!m->hw_handler_name) {
|
|
|
|
errors = 0;
|
|
|
|
break;
|
|
|
|
}
|
2010-03-06 09:29:49 +07:00
|
|
|
DMERR("Could not failover the device: Handler scsi_dh_%s "
|
|
|
|
"Error %d.", m->hw_handler_name, errors);
|
2008-05-02 04:50:11 +07:00
|
|
|
/*
|
|
|
|
* Fail path for now, so we do not ping pong
|
|
|
|
*/
|
|
|
|
fail_path(pgpath);
|
|
|
|
break;
|
|
|
|
case SCSI_DH_DEV_TEMP_BUSY:
|
|
|
|
/*
|
|
|
|
* Probably doing something like FW upgrade on the
|
|
|
|
* controller so try the other pg.
|
|
|
|
*/
|
|
|
|
bypass_pg(m, pg, 1);
|
|
|
|
break;
|
|
|
|
case SCSI_DH_RETRY:
|
2011-01-14 03:00:01 +07:00
|
|
|
/* Wait before retrying. */
|
|
|
|
delay_retry = 1;
|
2008-05-02 04:50:11 +07:00
|
|
|
case SCSI_DH_IMM_RETRY:
|
|
|
|
case SCSI_DH_RES_TEMP_UNAVAIL:
|
|
|
|
if (pg_init_limit_reached(m, pgpath))
|
|
|
|
fail_path(pgpath);
|
|
|
|
errors = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* We probably do not want to fail the path for a device
|
|
|
|
* error, but this is what the old dm did. In future
|
|
|
|
* patches we can do more advanced handling.
|
|
|
|
*/
|
|
|
|
fail_path(pgpath);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
if (errors) {
|
2009-06-22 16:12:12 +07:00
|
|
|
if (pgpath == m->current_pgpath) {
|
|
|
|
DMERR("Could not failover device. Error %d.", errors);
|
|
|
|
m->current_pgpath = NULL;
|
|
|
|
m->current_pg = NULL;
|
|
|
|
}
|
2010-03-06 09:30:02 +07:00
|
|
|
} else if (!m->pg_init_required)
|
2008-05-02 04:50:11 +07:00
|
|
|
pg->bypassed = 0;
|
|
|
|
|
2010-03-06 09:30:02 +07:00
|
|
|
if (--m->pg_init_in_progress)
|
|
|
|
/* Activations of other paths are still on going */
|
|
|
|
goto out;
|
|
|
|
|
dm mpath: remove process_queued_ios()
process_queued_ios() has served 3 functions:
1) select pg and pgpath if none is selected
2) start pg_init if requested
3) dispatch queued IOs when pg is ready
Basically, a call to queue_work(process_queued_ios) can be replaced by
dm_table_run_md_queue_async(), which runs request queue and ends up
calling map_io(), which does 1), 2) and 3).
Exception is when !pg_ready() (which means either pg_init is running or
requested), then multipath_busy() prevents map_io() being called from
request_fn.
If pg_init is running, it should be ok as long as pg_init_done() does
the right thing when pg_init is completed, I.e.: restart pg_init if
!pg_ready() or call dm_table_run_md_queue_async() to kick map_io().
If pg_init is requested, we have to make sure the request is detected
and pg_init will be started. pg_init is requested in 3 places:
a) __choose_pgpath() in map_io()
b) __choose_pgpath() in multipath_ioctl()
c) pg_init retry in pg_init_done()
a) is ok because map_io() calls __pg_init_all_paths(), which does 2).
b) needs a call to __pg_init_all_paths(), which does 2).
c) needs a call to __pg_init_all_paths(), which does 2).
So this patch removes process_queued_ios() and ensures that
__pg_init_all_paths() is called at the appropriate locations.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
2014-02-28 21:33:45 +07:00
|
|
|
if (m->pg_init_required) {
|
|
|
|
m->pg_init_delay_retry = delay_retry;
|
|
|
|
if (__pg_init_all_paths(m))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
m->queue_io = 0;
|
2010-03-06 09:30:02 +07:00
|
|
|
|
2010-03-06 09:32:13 +07:00
|
|
|
/*
|
|
|
|
* Wake up any thread waiting to suspend.
|
|
|
|
*/
|
|
|
|
wake_up(&m->pg_init_wait);
|
|
|
|
|
2010-03-06 09:30:02 +07:00
|
|
|
out:
|
2008-05-02 04:50:11 +07:00
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-05-02 04:50:22 +07:00
|
|
|
static void activate_path(struct work_struct *work)
|
|
|
|
{
|
2009-06-22 16:12:12 +07:00
|
|
|
struct pgpath *pgpath =
|
2011-01-14 03:00:01 +07:00
|
|
|
container_of(work, struct pgpath, activate_path.work);
|
2008-05-02 04:50:22 +07:00
|
|
|
|
2014-02-28 21:33:49 +07:00
|
|
|
if (pgpath->is_active)
|
|
|
|
scsi_dh_activate(bdev_get_queue(pgpath->path.dev->bdev),
|
|
|
|
pg_init_done, pgpath);
|
|
|
|
else
|
|
|
|
pg_init_done(pgpath, SCSI_DH_DEV_OFFLINED);
|
2008-05-02 04:50:22 +07:00
|
|
|
}
|
|
|
|
|
2013-07-01 20:16:26 +07:00
|
|
|
static int noretry_error(int error)
|
|
|
|
{
|
|
|
|
switch (error) {
|
|
|
|
case -EOPNOTSUPP:
|
|
|
|
case -EREMOTEIO:
|
|
|
|
case -EILSEQ:
|
|
|
|
case -ENODATA:
|
2013-09-13 12:54:30 +07:00
|
|
|
case -ENOSPC:
|
2013-07-01 20:16:26 +07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Anything else could be a path failure, so should be retried */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* end_io handling
|
|
|
|
*/
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
static int do_end_io(struct multipath *m, struct request *clone,
|
2007-07-12 23:26:32 +07:00
|
|
|
int error, struct dm_mpath_io *mpio)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
/*
|
|
|
|
* We don't queue any clone request inside the multipath target
|
|
|
|
* during end I/O handling, since those clone requests don't have
|
|
|
|
* bio clones. If we queue them inside the multipath target,
|
|
|
|
* we need to make bio clones, that requires memory allocation.
|
|
|
|
* (See drivers/md/dm.c:end_clone_bio() about why the clone requests
|
|
|
|
* don't have bio clones.)
|
|
|
|
* Instead of queueing the clone request here, we queue the original
|
|
|
|
* request into dm core, which will remake a clone request and
|
|
|
|
* clone bios for it and resubmit it later.
|
|
|
|
*/
|
|
|
|
int r = DM_ENDIO_REQUEUE;
|
2005-11-22 12:32:35 +07:00
|
|
|
unsigned long flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
if (!error && !clone->errors)
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0; /* I/O complete */
|
|
|
|
|
2014-06-03 02:50:06 +07:00
|
|
|
if (noretry_error(error))
|
2010-08-12 10:14:32 +07:00
|
|
|
return error;
|
|
|
|
|
2008-05-02 04:50:11 +07:00
|
|
|
if (mpio->pgpath)
|
|
|
|
fail_path(mpio->pgpath);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-11-22 12:32:35 +07:00
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
2011-01-18 16:13:12 +07:00
|
|
|
if (!m->nr_valid_paths) {
|
|
|
|
if (!m->queue_if_no_path) {
|
|
|
|
if (!__must_push_back(m))
|
|
|
|
r = -EIO;
|
|
|
|
} else {
|
|
|
|
if (error == -EBADE)
|
|
|
|
r = error;
|
|
|
|
}
|
|
|
|
}
|
2005-11-22 12:32:35 +07:00
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
return r;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
static int multipath_end_io(struct dm_target *ti, struct request *clone,
|
2005-04-17 05:20:36 +07:00
|
|
|
int error, union map_info *map_context)
|
|
|
|
{
|
2007-07-12 23:26:32 +07:00
|
|
|
struct multipath *m = ti->private;
|
|
|
|
struct dm_mpath_io *mpio = map_context->ptr;
|
2012-10-12 22:59:42 +07:00
|
|
|
struct pgpath *pgpath;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct path_selector *ps;
|
|
|
|
int r;
|
|
|
|
|
2012-03-29 00:41:25 +07:00
|
|
|
BUG_ON(!mpio);
|
|
|
|
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
r = do_end_io(m, clone, error, mpio);
|
2012-10-12 22:59:42 +07:00
|
|
|
pgpath = mpio->pgpath;
|
2005-04-17 05:20:36 +07:00
|
|
|
if (pgpath) {
|
|
|
|
ps = &pgpath->pg->ps;
|
|
|
|
if (ps->type->end_io)
|
2009-06-22 16:12:27 +07:00
|
|
|
ps->type->end_io(ps, &pgpath->path, mpio->nr_bytes);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2012-03-29 00:41:25 +07:00
|
|
|
clear_mapinfo(m, map_context);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Suspend can't complete until all the I/O is processed so if
|
2005-07-13 05:53:03 +07:00
|
|
|
* the last path fails we must error any remaining I/O.
|
|
|
|
* Note that if the freeze_bdev fails while suspending, the
|
|
|
|
* queue_if_no_path state is lost - userspace should reset it.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
static void multipath_presuspend(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct multipath *m = (struct multipath *) ti->private;
|
|
|
|
|
2005-09-28 11:45:45 +07:00
|
|
|
queue_if_no_path(m, 0, 1);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2009-12-11 06:52:19 +07:00
|
|
|
static void multipath_postsuspend(struct dm_target *ti)
|
|
|
|
{
|
2009-12-11 06:52:21 +07:00
|
|
|
struct multipath *m = ti->private;
|
|
|
|
|
|
|
|
mutex_lock(&m->work_mutex);
|
2010-03-06 09:32:13 +07:00
|
|
|
flush_multipath_work(m);
|
2009-12-11 06:52:21 +07:00
|
|
|
mutex_unlock(&m->work_mutex);
|
2009-12-11 06:52:19 +07:00
|
|
|
}
|
|
|
|
|
2005-07-13 05:53:03 +07:00
|
|
|
/*
|
|
|
|
* Restore the queue_if_no_path setting.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
static void multipath_resume(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct multipath *m = (struct multipath *) ti->private;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
2005-07-13 05:53:03 +07:00
|
|
|
m->queue_if_no_path = m->saved_queue_if_no_path;
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Info output has the following format:
|
|
|
|
* num_multipath_feature_args [multipath_feature_args]*
|
|
|
|
* num_handler_status_args [handler_status_args]*
|
|
|
|
* num_groups init_group_number
|
|
|
|
* [A|D|E num_ps_status_args [ps_status_args]*
|
|
|
|
* num_paths num_selector_args
|
|
|
|
* [path_dev A|F fail_count [selector_args]* ]+ ]+
|
|
|
|
*
|
|
|
|
* Table output has the following format (identical to the constructor string):
|
|
|
|
* num_feature_args [features_args]*
|
|
|
|
* num_handler_args hw_handler [hw_handler_args]*
|
|
|
|
* num_groups init_group_number
|
|
|
|
* [priority selector-name num_ps_args [ps_args]*
|
|
|
|
* num_paths num_selector_args [path_dev [selector_args]* ]+ ]+
|
|
|
|
*/
|
2013-03-02 05:45:44 +07:00
|
|
|
static void multipath_status(struct dm_target *ti, status_type_t type,
|
|
|
|
unsigned status_flags, char *result, unsigned maxlen)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int sz = 0;
|
|
|
|
unsigned long flags;
|
|
|
|
struct multipath *m = (struct multipath *) ti->private;
|
|
|
|
struct priority_group *pg;
|
|
|
|
struct pgpath *p;
|
|
|
|
unsigned pg_num;
|
|
|
|
char state;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
|
|
|
|
/* Features */
|
|
|
|
if (type == STATUSTYPE_INFO)
|
2014-02-28 21:33:44 +07:00
|
|
|
DMEMIT("2 %u %u ", m->queue_io, m->pg_init_count);
|
2007-10-20 04:47:53 +07:00
|
|
|
else {
|
|
|
|
DMEMIT("%u ", m->queue_if_no_path +
|
2011-01-14 03:00:01 +07:00
|
|
|
(m->pg_init_retries > 0) * 2 +
|
2012-07-27 21:08:04 +07:00
|
|
|
(m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT) * 2 +
|
|
|
|
m->retain_attached_hw_handler);
|
2007-10-20 04:47:53 +07:00
|
|
|
if (m->queue_if_no_path)
|
|
|
|
DMEMIT("queue_if_no_path ");
|
|
|
|
if (m->pg_init_retries)
|
|
|
|
DMEMIT("pg_init_retries %u ", m->pg_init_retries);
|
2011-01-14 03:00:01 +07:00
|
|
|
if (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT)
|
|
|
|
DMEMIT("pg_init_delay_msecs %u ", m->pg_init_delay_msecs);
|
2012-07-27 21:08:04 +07:00
|
|
|
if (m->retain_attached_hw_handler)
|
|
|
|
DMEMIT("retain_attached_hw_handler ");
|
2007-10-20 04:47:53 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-05-02 04:50:11 +07:00
|
|
|
if (!m->hw_handler_name || type == STATUSTYPE_INFO)
|
2005-04-17 05:20:36 +07:00
|
|
|
DMEMIT("0 ");
|
|
|
|
else
|
2008-05-02 04:50:11 +07:00
|
|
|
DMEMIT("1 %s ", m->hw_handler_name);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
DMEMIT("%u ", m->nr_priority_groups);
|
|
|
|
|
|
|
|
if (m->next_pg)
|
|
|
|
pg_num = m->next_pg->pg_num;
|
|
|
|
else if (m->current_pg)
|
|
|
|
pg_num = m->current_pg->pg_num;
|
|
|
|
else
|
2011-03-24 20:54:33 +07:00
|
|
|
pg_num = (m->nr_priority_groups ? 1 : 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
DMEMIT("%u ", pg_num);
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case STATUSTYPE_INFO:
|
|
|
|
list_for_each_entry(pg, &m->priority_groups, list) {
|
|
|
|
if (pg->bypassed)
|
|
|
|
state = 'D'; /* Disabled */
|
|
|
|
else if (pg == m->current_pg)
|
|
|
|
state = 'A'; /* Currently Active */
|
|
|
|
else
|
|
|
|
state = 'E'; /* Enabled */
|
|
|
|
|
|
|
|
DMEMIT("%c ", state);
|
|
|
|
|
|
|
|
if (pg->ps.type->status)
|
|
|
|
sz += pg->ps.type->status(&pg->ps, NULL, type,
|
|
|
|
result + sz,
|
|
|
|
maxlen - sz);
|
|
|
|
else
|
|
|
|
DMEMIT("0 ");
|
|
|
|
|
|
|
|
DMEMIT("%u %u ", pg->nr_pgpaths,
|
|
|
|
pg->ps.type->info_args);
|
|
|
|
|
|
|
|
list_for_each_entry(p, &pg->pgpaths, list) {
|
|
|
|
DMEMIT("%s %s %u ", p->path.dev->name,
|
2008-10-10 19:36:58 +07:00
|
|
|
p->is_active ? "A" : "F",
|
2005-04-17 05:20:36 +07:00
|
|
|
p->fail_count);
|
|
|
|
if (pg->ps.type->status)
|
|
|
|
sz += pg->ps.type->status(&pg->ps,
|
|
|
|
&p->path, type, result + sz,
|
|
|
|
maxlen - sz);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case STATUSTYPE_TABLE:
|
|
|
|
list_for_each_entry(pg, &m->priority_groups, list) {
|
|
|
|
DMEMIT("%s ", pg->ps.type->name);
|
|
|
|
|
|
|
|
if (pg->ps.type->status)
|
|
|
|
sz += pg->ps.type->status(&pg->ps, NULL, type,
|
|
|
|
result + sz,
|
|
|
|
maxlen - sz);
|
|
|
|
else
|
|
|
|
DMEMIT("0 ");
|
|
|
|
|
|
|
|
DMEMIT("%u %u ", pg->nr_pgpaths,
|
|
|
|
pg->ps.type->table_args);
|
|
|
|
|
|
|
|
list_for_each_entry(p, &pg->pgpaths, list) {
|
|
|
|
DMEMIT("%s ", p->path.dev->name);
|
|
|
|
if (pg->ps.type->status)
|
|
|
|
sz += pg->ps.type->status(&pg->ps,
|
|
|
|
&p->path, type, result + sz,
|
|
|
|
maxlen - sz);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int multipath_message(struct dm_target *ti, unsigned argc, char **argv)
|
|
|
|
{
|
2009-12-11 06:52:21 +07:00
|
|
|
int r = -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct dm_dev *dev;
|
|
|
|
struct multipath *m = (struct multipath *) ti->private;
|
|
|
|
action_fn action;
|
|
|
|
|
2009-12-11 06:52:21 +07:00
|
|
|
mutex_lock(&m->work_mutex);
|
|
|
|
|
2009-12-11 06:52:27 +07:00
|
|
|
if (dm_suspended(ti)) {
|
|
|
|
r = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (argc == 1) {
|
2011-08-02 18:32:04 +07:00
|
|
|
if (!strcasecmp(argv[0], "queue_if_no_path")) {
|
2009-12-11 06:52:21 +07:00
|
|
|
r = queue_if_no_path(m, 1, 0);
|
|
|
|
goto out;
|
2011-08-02 18:32:04 +07:00
|
|
|
} else if (!strcasecmp(argv[0], "fail_if_no_path")) {
|
2009-12-11 06:52:21 +07:00
|
|
|
r = queue_if_no_path(m, 0, 0);
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2009-12-11 06:52:21 +07:00
|
|
|
if (argc != 2) {
|
2014-01-29 23:52:45 +07:00
|
|
|
DMWARN("Invalid multipath message arguments. Expected 2 arguments, got %d.", argc);
|
2009-12-11 06:52:21 +07:00
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-08-02 18:32:04 +07:00
|
|
|
if (!strcasecmp(argv[0], "disable_group")) {
|
2009-12-11 06:52:21 +07:00
|
|
|
r = bypass_pg_num(m, argv[1], 1);
|
|
|
|
goto out;
|
2011-08-02 18:32:04 +07:00
|
|
|
} else if (!strcasecmp(argv[0], "enable_group")) {
|
2009-12-11 06:52:21 +07:00
|
|
|
r = bypass_pg_num(m, argv[1], 0);
|
|
|
|
goto out;
|
2011-08-02 18:32:04 +07:00
|
|
|
} else if (!strcasecmp(argv[0], "switch_group")) {
|
2009-12-11 06:52:21 +07:00
|
|
|
r = switch_pg_num(m, argv[1]);
|
|
|
|
goto out;
|
2011-08-02 18:32:04 +07:00
|
|
|
} else if (!strcasecmp(argv[0], "reinstate_path"))
|
2005-04-17 05:20:36 +07:00
|
|
|
action = reinstate_path;
|
2011-08-02 18:32:04 +07:00
|
|
|
else if (!strcasecmp(argv[0], "fail_path"))
|
2005-04-17 05:20:36 +07:00
|
|
|
action = fail_path;
|
2009-12-11 06:52:21 +07:00
|
|
|
else {
|
2014-01-29 23:52:45 +07:00
|
|
|
DMWARN("Unrecognised multipath message received: %s", argv[0]);
|
2009-12-11 06:52:21 +07:00
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-03-06 09:32:27 +07:00
|
|
|
r = dm_get_device(ti, argv[1], dm_table_get_mode(ti->table), &dev);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (r) {
|
2006-06-26 14:27:35 +07:00
|
|
|
DMWARN("message: error getting device %s",
|
2005-04-17 05:20:36 +07:00
|
|
|
argv[1]);
|
2009-12-11 06:52:21 +07:00
|
|
|
goto out;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
r = action_dev(m, dev, action);
|
|
|
|
|
|
|
|
dm_put_device(ti, dev);
|
|
|
|
|
2009-12-11 06:52:21 +07:00
|
|
|
out:
|
|
|
|
mutex_unlock(&m->work_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2007-08-29 09:15:59 +07:00
|
|
|
static int multipath_ioctl(struct dm_target *ti, unsigned int cmd,
|
2006-10-03 15:15:20 +07:00
|
|
|
unsigned long arg)
|
|
|
|
{
|
2012-06-03 06:29:58 +07:00
|
|
|
struct multipath *m = ti->private;
|
2012-09-27 05:45:41 +07:00
|
|
|
struct pgpath *pgpath;
|
2012-06-03 06:29:58 +07:00
|
|
|
struct block_device *bdev;
|
|
|
|
fmode_t mode;
|
2006-10-03 15:15:20 +07:00
|
|
|
unsigned long flags;
|
2012-06-03 06:29:58 +07:00
|
|
|
int r;
|
|
|
|
|
|
|
|
bdev = NULL;
|
|
|
|
mode = 0;
|
|
|
|
r = 0;
|
2006-10-03 15:15:20 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
|
|
|
|
if (!m->current_pgpath)
|
2009-06-22 16:12:27 +07:00
|
|
|
__choose_pgpath(m, 0);
|
2006-10-03 15:15:20 +07:00
|
|
|
|
2012-09-27 05:45:41 +07:00
|
|
|
pgpath = m->current_pgpath;
|
|
|
|
|
|
|
|
if (pgpath) {
|
|
|
|
bdev = pgpath->path.dev->bdev;
|
|
|
|
mode = pgpath->path.dev->mode;
|
2006-10-03 15:15:22 +07:00
|
|
|
}
|
2006-10-03 15:15:20 +07:00
|
|
|
|
2012-09-27 05:45:41 +07:00
|
|
|
if ((pgpath && m->queue_io) || (!pgpath && m->queue_if_no_path))
|
2013-07-11 05:41:15 +07:00
|
|
|
r = -ENOTCONN;
|
2006-10-03 15:15:20 +07:00
|
|
|
else if (!bdev)
|
|
|
|
r = -EIO;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
|
2012-01-12 22:01:29 +07:00
|
|
|
/*
|
|
|
|
* Only pass ioctls through if the device sizes match exactly.
|
|
|
|
*/
|
2014-02-26 16:07:04 +07:00
|
|
|
if (!bdev || ti->len != i_size_read(bdev->bd_inode) >> SECTOR_SHIFT) {
|
|
|
|
int err = scsi_verify_blk_ioctl(NULL, cmd);
|
|
|
|
if (err)
|
|
|
|
r = err;
|
|
|
|
}
|
2012-01-12 22:01:29 +07:00
|
|
|
|
dm mpath: remove process_queued_ios()
process_queued_ios() has served 3 functions:
1) select pg and pgpath if none is selected
2) start pg_init if requested
3) dispatch queued IOs when pg is ready
Basically, a call to queue_work(process_queued_ios) can be replaced by
dm_table_run_md_queue_async(), which runs request queue and ends up
calling map_io(), which does 1), 2) and 3).
Exception is when !pg_ready() (which means either pg_init is running or
requested), then multipath_busy() prevents map_io() being called from
request_fn.
If pg_init is running, it should be ok as long as pg_init_done() does
the right thing when pg_init is completed, I.e.: restart pg_init if
!pg_ready() or call dm_table_run_md_queue_async() to kick map_io().
If pg_init is requested, we have to make sure the request is detected
and pg_init will be started. pg_init is requested in 3 places:
a) __choose_pgpath() in map_io()
b) __choose_pgpath() in multipath_ioctl()
c) pg_init retry in pg_init_done()
a) is ok because map_io() calls __pg_init_all_paths(), which does 2).
b) needs a call to __pg_init_all_paths(), which does 2).
c) needs a call to __pg_init_all_paths(), which does 2).
So this patch removes process_queued_ios() and ensures that
__pg_init_all_paths() is called at the appropriate locations.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
2014-02-28 21:33:45 +07:00
|
|
|
if (r == -ENOTCONN && !fatal_signal_pending(current)) {
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
if (!m->current_pg) {
|
|
|
|
/* Path status changed, redo selection */
|
|
|
|
__choose_pgpath(m, 0);
|
|
|
|
}
|
|
|
|
if (m->pg_init_required)
|
|
|
|
__pg_init_all_paths(m);
|
2014-05-14 00:49:39 +07:00
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
2014-05-26 19:45:39 +07:00
|
|
|
dm_table_run_md_queue_async(m->ti->table);
|
dm mpath: remove process_queued_ios()
process_queued_ios() has served 3 functions:
1) select pg and pgpath if none is selected
2) start pg_init if requested
3) dispatch queued IOs when pg is ready
Basically, a call to queue_work(process_queued_ios) can be replaced by
dm_table_run_md_queue_async(), which runs request queue and ends up
calling map_io(), which does 1), 2) and 3).
Exception is when !pg_ready() (which means either pg_init is running or
requested), then multipath_busy() prevents map_io() being called from
request_fn.
If pg_init is running, it should be ok as long as pg_init_done() does
the right thing when pg_init is completed, I.e.: restart pg_init if
!pg_ready() or call dm_table_run_md_queue_async() to kick map_io().
If pg_init is requested, we have to make sure the request is detected
and pg_init will be started. pg_init is requested in 3 places:
a) __choose_pgpath() in map_io()
b) __choose_pgpath() in multipath_ioctl()
c) pg_init retry in pg_init_done()
a) is ok because map_io() calls __pg_init_all_paths(), which does 2).
b) needs a call to __pg_init_all_paths(), which does 2).
c) needs a call to __pg_init_all_paths(), which does 2).
So this patch removes process_queued_ios() and ensures that
__pg_init_all_paths() is called at the appropriate locations.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
2014-02-28 21:33:45 +07:00
|
|
|
}
|
2012-06-03 06:29:58 +07:00
|
|
|
|
2007-08-30 07:34:12 +07:00
|
|
|
return r ? : __blkdev_driver_ioctl(bdev, mode, cmd, arg);
|
2006-10-03 15:15:20 +07:00
|
|
|
}
|
|
|
|
|
2009-06-22 16:12:33 +07:00
|
|
|
static int multipath_iterate_devices(struct dm_target *ti,
|
|
|
|
iterate_devices_callout_fn fn, void *data)
|
|
|
|
{
|
|
|
|
struct multipath *m = ti->private;
|
|
|
|
struct priority_group *pg;
|
|
|
|
struct pgpath *p;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
list_for_each_entry(pg, &m->priority_groups, list) {
|
|
|
|
list_for_each_entry(p, &pg->pgpaths, list) {
|
2009-07-24 02:30:42 +07:00
|
|
|
ret = fn(ti, p->path.dev, ti->begin, ti->len, data);
|
2009-06-22 16:12:33 +07:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
static int __pgpath_busy(struct pgpath *pgpath)
|
|
|
|
{
|
|
|
|
struct request_queue *q = bdev_get_queue(pgpath->path.dev->bdev);
|
|
|
|
|
|
|
|
return dm_underlying_device_busy(q);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We return "busy", only when we can map I/Os but underlying devices
|
|
|
|
* are busy (so even if we map I/Os now, the I/Os will wait on
|
|
|
|
* the underlying queue).
|
|
|
|
* In other words, if we want to kill I/Os or queue them inside us
|
|
|
|
* due to map unavailability, we don't return "busy". Otherwise,
|
|
|
|
* dm core won't give us the I/Os and we can't do what we want.
|
|
|
|
*/
|
|
|
|
static int multipath_busy(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
int busy = 0, has_active = 0;
|
|
|
|
struct multipath *m = ti->private;
|
|
|
|
struct priority_group *pg;
|
|
|
|
struct pgpath *pgpath;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&m->lock, flags);
|
|
|
|
|
2013-10-01 16:49:56 +07:00
|
|
|
/* pg_init in progress, requeue until done */
|
2014-02-28 21:33:44 +07:00
|
|
|
if (!pg_ready(m)) {
|
2013-10-01 16:49:56 +07:00
|
|
|
busy = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
/* Guess which priority_group will be used at next mapping time */
|
|
|
|
if (unlikely(!m->current_pgpath && m->next_pg))
|
|
|
|
pg = m->next_pg;
|
|
|
|
else if (likely(m->current_pg))
|
|
|
|
pg = m->current_pg;
|
|
|
|
else
|
|
|
|
/*
|
|
|
|
* We don't know which pg will be used at next mapping time.
|
|
|
|
* We don't call __choose_pgpath() here to avoid to trigger
|
|
|
|
* pg_init just by busy checking.
|
|
|
|
* So we don't know whether underlying devices we will be using
|
|
|
|
* at next mapping time are busy or not. Just try mapping.
|
|
|
|
*/
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is one non-busy active path at least, the path selector
|
|
|
|
* will be able to select it. So we consider such a pg as not busy.
|
|
|
|
*/
|
|
|
|
busy = 1;
|
|
|
|
list_for_each_entry(pgpath, &pg->pgpaths, list)
|
|
|
|
if (pgpath->is_active) {
|
|
|
|
has_active = 1;
|
|
|
|
|
|
|
|
if (!__pgpath_busy(pgpath)) {
|
|
|
|
busy = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!has_active)
|
|
|
|
/*
|
|
|
|
* No active path in this pg, so this pg won't be used and
|
|
|
|
* the current_pg will be changed at next mapping time.
|
|
|
|
* We need to try mapping to determine it.
|
|
|
|
*/
|
|
|
|
busy = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&m->lock, flags);
|
|
|
|
|
|
|
|
return busy;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* Module setup
|
|
|
|
*---------------------------------------------------------------*/
|
|
|
|
static struct target_type multipath_target = {
|
|
|
|
.name = "multipath",
|
2014-02-28 21:33:44 +07:00
|
|
|
.version = {1, 7, 0},
|
2005-04-17 05:20:36 +07:00
|
|
|
.module = THIS_MODULE,
|
|
|
|
.ctr = multipath_ctr,
|
|
|
|
.dtr = multipath_dtr,
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
.map_rq = multipath_map,
|
|
|
|
.rq_end_io = multipath_end_io,
|
2005-04-17 05:20:36 +07:00
|
|
|
.presuspend = multipath_presuspend,
|
2009-12-11 06:52:19 +07:00
|
|
|
.postsuspend = multipath_postsuspend,
|
2005-04-17 05:20:36 +07:00
|
|
|
.resume = multipath_resume,
|
|
|
|
.status = multipath_status,
|
|
|
|
.message = multipath_message,
|
2006-10-03 15:15:20 +07:00
|
|
|
.ioctl = multipath_ioctl,
|
2009-06-22 16:12:33 +07:00
|
|
|
.iterate_devices = multipath_iterate_devices,
|
dm mpath: change to be request based
This patch converts dm-multipath target to request-based from bio-based.
Basically, the patch just converts the I/O unit from struct bio
to struct request.
In the course of the conversion, it also changes the I/O queueing
mechanism. The change in the I/O queueing is described in details
as follows.
I/O queueing mechanism change
-----------------------------
In I/O submission, map_io(), there is no mechanism change from
bio-based, since the clone request is ready for retry as it is.
However, in I/O complition, do_end_io(), there is a mechanism change
from bio-based, since the clone request is not ready for retry.
In do_end_io() of bio-based, the clone bio has all needed memory
for resubmission. So the target driver can queue it and resubmit
it later without memory allocations.
The mechanism has almost no overhead.
On the other hand, in do_end_io() of request-based, the clone request
doesn't have clone bios, so the target driver can't resubmit it
as it is. To resubmit the clone request, memory allocation for
clone bios is needed, and it takes some overheads.
To avoid the overheads just for queueing, the target driver doesn't
queue the clone request inside itself.
Instead, the target driver asks dm core for queueing and remapping
the original request of the clone request, since the overhead for
queueing is just a freeing memory for the clone request.
As a result, the target driver doesn't need to record/restore
the information of the original request for resubmitting
the clone request. So dm_bio_details in dm_mpath_io is removed.
multipath_busy()
---------------------
The target driver returns "busy", only when the following case:
o The target driver will map I/Os, if map() function is called
and
o The mapped I/Os will wait on underlying device's queue due to
their congestions, if map() function is called now.
In other cases, the target driver doesn't return "busy".
Otherwise, dm core will keep the I/Os and the target driver can't
do what it wants.
(e.g. the target driver can't map I/Os now, so wants to kill I/Os.)
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Acked-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 16:12:37 +07:00
|
|
|
.busy = multipath_busy,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init dm_multipath_init(void)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
|
|
|
/* allocate a slab for the dm_ios */
|
2007-07-12 23:26:32 +07:00
|
|
|
_mpio_cache = KMEM_CACHE(dm_mpath_io, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!_mpio_cache)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
r = dm_register_target(&multipath_target);
|
|
|
|
if (r < 0) {
|
2007-07-12 23:27:01 +07:00
|
|
|
DMERR("register failed %d", r);
|
2005-04-17 05:20:36 +07:00
|
|
|
kmem_cache_destroy(_mpio_cache);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-01-14 02:59:57 +07:00
|
|
|
kmultipathd = alloc_workqueue("kmpathd", WQ_MEM_RECLAIM, 0);
|
2005-05-06 06:16:07 +07:00
|
|
|
if (!kmultipathd) {
|
2007-07-12 23:27:01 +07:00
|
|
|
DMERR("failed to create workqueue kmpathd");
|
2005-05-06 06:16:07 +07:00
|
|
|
dm_unregister_target(&multipath_target);
|
|
|
|
kmem_cache_destroy(_mpio_cache);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2008-05-02 04:50:22 +07:00
|
|
|
/*
|
|
|
|
* A separate workqueue is used to handle the device handlers
|
|
|
|
* to avoid overloading existing workqueue. Overloading the
|
|
|
|
* old workqueue would also create a bottleneck in the
|
|
|
|
* path of the storage hardware device activation.
|
|
|
|
*/
|
2011-01-14 02:59:57 +07:00
|
|
|
kmpath_handlerd = alloc_ordered_workqueue("kmpath_handlerd",
|
|
|
|
WQ_MEM_RECLAIM);
|
2008-05-02 04:50:22 +07:00
|
|
|
if (!kmpath_handlerd) {
|
|
|
|
DMERR("failed to create workqueue kmpath_handlerd");
|
|
|
|
destroy_workqueue(kmultipathd);
|
|
|
|
dm_unregister_target(&multipath_target);
|
|
|
|
kmem_cache_destroy(_mpio_cache);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2006-06-26 14:27:35 +07:00
|
|
|
DMINFO("version %u.%u.%u loaded",
|
2005-04-17 05:20:36 +07:00
|
|
|
multipath_target.version[0], multipath_target.version[1],
|
|
|
|
multipath_target.version[2]);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit dm_multipath_exit(void)
|
|
|
|
{
|
2008-05-02 04:50:22 +07:00
|
|
|
destroy_workqueue(kmpath_handlerd);
|
2005-05-06 06:16:07 +07:00
|
|
|
destroy_workqueue(kmultipathd);
|
|
|
|
|
2009-01-06 10:04:58 +07:00
|
|
|
dm_unregister_target(&multipath_target);
|
2005-04-17 05:20:36 +07:00
|
|
|
kmem_cache_destroy(_mpio_cache);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(dm_multipath_init);
|
|
|
|
module_exit(dm_multipath_exit);
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION(DM_NAME " multipath target");
|
|
|
|
MODULE_AUTHOR("Sistina Software <dm-devel@redhat.com>");
|
|
|
|
MODULE_LICENSE("GPL");
|