Subject: [PATCH 0/3] dm-mpath: dynamic load balancers (v1)
Subsystems (2)
Hi,
The patch-set adds the following 2 dynamic load balancers:
o dm-queue-length: queue-length oriented dynamic load balancer
o dm-service-time: service-time oriented dynamic load balancer
This patch-set can be applied on top of 2.6.29-rc8. No dependencies on Alasdair's linux-next patches.
NOTE:
While the patches compile and work with the current bio-based dm, for them to *properly* work, the request-based dm patches should be applied, too.
See <http://lkml.org/lkml/2008/9/12/100> for why request-based dm improves multipath load balancing.
Summary of the patch-set:
1/3: dm-mpath: interface change for dynamic load balancers 2/3: dm-mpath: add queue-length oriented dynamic load balancer 3/3: dm-mpath: add service-time oriented dynamic load balancer
drivers/md/Kconfig | 18 ++ drivers/md/Makefile | 2 drivers/md/dm-mpath.c | 28 ++- drivers/md/dm-path-selector.h | 8 - drivers/md/dm-queue-length.c | 257 +++++++++++++++++++++++++++++++++++ drivers/md/dm-round-robin.c | 2 drivers/md/dm-service-time.c | 301 ++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 603 insertions(+), 13 deletions(-)
Thanks,
Kiyoshi Ueda
PATCH 1/3 dm-mpath: interface change for dynamic load balancers
This patch changes the dm path selector interface for dynamic load balancers:
o adding a new hook, start_io()
o adding 'nr_bytes' parameter to select_path()/start_io()/end_io() to pass the size of the I/O
start_io() is called when a target driver actually submits I/O to the selected path.
Path selectors can use it to start accounting of the I/O. (e.g. counting the number of in-flight I/Os.)
The start_io hook is based on the patch posted by Stefan Bader:
https://www.redhat.com/archives/dm-devel/2005-October/msg00050.html
nr_bytes, the size of the I/O, is used by path selectors for size-based decision.
dm-service-time uses it to estimate service time, for example. (Added the nr_bytes member to dm_mpath_io instead of using existing
details.bi_size, since request-based dm patch deletes it.)
--- drivers/md/dm-mpath.c | 28 ++++++++++++++++++---------- drivers/md/dm-path-selector.h | 8 ++++++-- drivers/md/dm-round-robin.c | 2 +- 3 files changed, 25 insertions(+), 13 deletions(-)
drivers/md/dm-mpath.c +18 -10
@@ -103,6 +103,7 @@ struct multipath {struct dm_mpath_io {struct pgpath *pgpath;struct dm_bio_details details; +size_t nr_bytes; };typedef int (*action_fn ) (struct pgpath *pgpath);
@@ -251,11 +252,12 @@ static void __switch_pg(struct multipath m->pg_init_count =0 ; } -static int __choose_path_in_pg (struct multipath *m,struct priority_group *pg) +static int __choose_path_in_pg (struct multipath *m,struct priority_group *pg, +size_t nr_bytes) {struct dm_path *path; - path = pg->ps.type->select_path (&pg->ps, &m->repeat_count); + path = pg->ps.type->select_path (&pg->ps, &m->repeat_count, nr_bytes);if (!path)return -ENXIO ;
@@ -267,7 +269,7 @@ static int __choose_path_in_pg(struct mureturn 0 ; } -static void __choose_pgpath (struct multipath *m) +static void __choose_pgpath (struct multipath *m,size_t nr_bytes) {struct priority_group *pg;unsigned bypassed =1 ;
@@ -279,12 +281,12 @@ static void __choose_pgpath(struct multiif (m->next_pg) { pg = m->next_pg; m->next_pg =NULL ; -if (!__choose_path_in_pg (m, pg)) +if (!__choose_path_in_pg (m, pg, nr_bytes))return ; }/* Don't change PG until it has no remaining paths */ -if (m->current_pg && !__choose_path_in_pg (m, m->current_pg)) +if (m->current_pg && !__choose_path_in_pg (m, m->current_pg, nr_bytes))return ;/*
@@ -296,7 +298,7 @@ static void __choose_pgpath(struct multilist_for_each_entry (pg, &m->priority_groups, list) {if (pg->bypassed == bypassed)continue ; -if (!__choose_path_in_pg (m, pg)) +if (!__choose_path_in_pg (m, pg, nr_bytes))return ; } }while (bypassed--);
@@ -327,6 +329,7 @@ static int map_io(struct multipath *m, s struct dm_mpath_io *mpio, unsigned was_queued) { int r = DM_MAPIO_REMAPPED; +size_t nr_bytes = bio->bi_size;unsigned long flags;struct pgpath *pgpath;
@@ -335,7 +338,7 @@ static int map_io(struct multipath *m, s/* Do we need to select a new pgpath? */ if (!m->current_pgpath || (!m->queue_io && (m->repeat_count && --m->repeat_count ==0 ))) -__choose_pgpath (m); +__choose_pgpath (m, nr_bytes); pgpath = m->current_pgpath;
@@ -360,6 +363,11 @@ static int map_io(struct multipath *m, s r = -EIO ;/* Failed */ mpio->pgpath = pgpath; + mpio->nr_bytes = nr_bytes; + +if (r ==DM_MAPIO_REMAPPED && pgpath->pg->ps.type->start_io) + pgpath->pg->ps.type->start_io (&pgpath->pg->ps, &pgpath->path, + nr_bytes);spin_unlock_irqrestore (&m->lock, flags);
@@ -438,7 +446,7 @@ static void process_queued_ios(struct wo goto out;if (!m->current_pgpath) -__choose_pgpath (m); +__choose_pgpath (m,0 ); pgpath = m->current_pgpath;
@@ -1196,7 +1204,7 @@ static int multipath_end_io(struct dm_taif (pgpath) { ps = &pgpath->pg->ps;if (ps->type->end_io) - ps->type->end_io (ps, &pgpath->path); + ps->type->end_io (ps, &pgpath->path, mpio->nr_bytes); }if (r !=DM_ENDIO_INCOMPLETE )mempool_free (mpio, m->mpio_pool);
@@ -1412,7 +1420,7 @@ static int multipath_ioctl(struct dm_tarspin_lock_irqsave (&m->lock, flags);if (!m->current_pgpath) -__choose_pgpath (m); +__choose_pgpath (m,0 );if (m->current_pgpath) { bdev = m->current_pgpath->path.dev->bdev;
drivers/md/dm-path-selector.h +6 -2
@@ -56,7 +56,8 @@ struct path_selector_type {* the path fails. */ struct dm_path *(*select_path) (struct path_selector *ps, -unsigned *repeat_count); +unsigned *repeat_count, +size_t nr_bytes);/* * Notify the selector that a path has failed.
@@ -75,7 +76,10 @@ struct path_selector_type {int (*status) (struct path_selector *ps,struct dm_path *path,status_type_t type,char *result,unsigned int maxlen); -int (*end_io) (struct path_selector *ps,struct dm_path *path); +int (*start_io) (struct path_selector *ps,struct dm_path *path, +size_t nr_bytes); +int (*end_io) (struct path_selector *ps,struct dm_path *path, +size_t nr_bytes); };/* Register a path selector */
drivers/md/dm-round-robin.c +1 -1
@@ -161,7 +161,7 @@ static int rr_reinstate_path(struct path }static struct dm_path *rr_select_path (struct path_selector *ps, -unsigned *repeat_count) +unsigned *repeat_count,size_t nr_bytes) {struct selector *s = (struct selector *) ps->context;struct path_info *pi =NULL ;
PATCH 2/3 dm-mpath: add queue-length oriented dynamic load balancer
In reply to Kiyoshi UedaThis patch adds a dynamic load balancer, dm-queue-length, which balances the number of in-flight I/Os.
The code is based on the patch posted by Stefan Bader:
https://www.redhat.com/archives/dm-devel/2005-October/msg00050.html
--- drivers/md/Kconfig | 9 + drivers/md/Makefile | 1 drivers/md/dm-queue-length.c | 257 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 267 insertions(+)
drivers/md/dm-queue-length.c new file +257 -0
@@ -0,0 +1,257 @@ +/* +* Copyright (C) 2004-2005 IBM Corp. All Rights Reserved. +* Copyright (C) 2006-2009 NEC Corporation. +* +* dm-queue-length.c +* +* Module Author: Stefan Bader, IBM +* Modified by: Kiyoshi Ueda, NEC +* +* This file is released under the GPL. +* +* queue-length path selector, which chooses a path with the least number of +* in-flight I/Os. +*/ + +#include "dm.h" +#include "dm-path-selector.h" + +#include <linux/slab.h> +#include <linux/ctype.h> +#include <linux/errno.h> +#include <linux/module.h> +#include <asm/atomic.h> + +#define DM_MSG_PREFIX "multipath queue-length" +#define QL_MIN_IO 128 +#define QL_VERSION "0.1.0" + +struct selector { +struct list_head valid_paths; +struct list_head failed_paths; +}; + +struct path_info { +struct list_head list; +struct dm_path *path; +unsigned int repeat_count; +atomic_t qlen; +}; + +static struct selector *alloc_selector (void ) +{ +struct selector *s =kmalloc (sizeof (*s),GFP_KERNEL ); + +if (s) { +INIT_LIST_HEAD (&s->valid_paths); +INIT_LIST_HEAD (&s->failed_paths); + } + +return s; +} + +static int ql_create (struct path_selector *ps,unsigned argc,char **argv) +{ +struct selector *s =alloc_selector (); + +if (!s) +return -ENOMEM ; + + ps->context = s; +return 0 ; +} + +static void ql_free_paths (struct list_head *paths) +{ +struct path_info *pi, *next; + +list_for_each_entry_safe (pi, next, paths, list) { +list_del (&pi->list); +kfree (pi); + } +} + +static void ql_destroy (struct path_selector *ps) +{ +struct selector *s = (struct selector *) ps->context; + +ql_free_paths (&s->valid_paths); +ql_free_paths (&s->failed_paths); +kfree (s); + ps->context =NULL ; +} + +static int ql_status (struct path_selector *ps,struct dm_path *path, +status_type_t type,char *result,unsigned int maxlen) +{ +int sz =0 ; +struct path_info *pi; + +/* When called with (path == NULL), return selector status/args. */ +if (!path) +DMEMIT ("0 " ); +else { + pi = path->pscontext; + +switch (type) { +case STATUSTYPE_INFO : +DMEMIT ("%u " ,atomic_read (&pi->qlen)); +break ; +case STATUSTYPE_TABLE : +DMEMIT ("%u " , pi->repeat_count); +break ; + } + } + +return sz; +} + +static int ql_add_path (struct path_selector *ps,struct dm_path *path, +int argc,char **argv,char **error) +{ +struct selector *s = (struct selector *) ps->context; +struct path_info *pi; +unsigned int repeat_count =QL_MIN_IO ; + +/* Parse the arguments */ +if (argc >1 ) { + *error ="queue-length ps: incorrect number of arguments" ; +return -EINVAL ; + } + +/* First path argument is number of I/Os before switching path. */ +if ((argc ==1 ) && (sscanf (argv[0 ],"%u" , &repeat_count) !=1 )) { + *error ="queue-length ps: invalid repeat count" ; +return -EINVAL ; + } + +/* Allocate the path information structure */ + pi =kmalloc (sizeof (*pi),GFP_KERNEL ); +if (!pi) { + *error ="queue-length ps: Error allocating path information" ; +return -ENOMEM ; + } + + pi->path = path; + pi->repeat_count = repeat_count; +atomic_set (&pi->qlen,0 ); + + path->pscontext = pi; + +list_add_tail (&pi->list, &s->valid_paths); + +return 0 ; +} + +static void ql_fail_path (struct path_selector *ps,struct dm_path *path) +{ +struct selector *s = (struct selector *) ps->context; +struct path_info *pi = path->pscontext; + +list_move (&pi->list, &s->failed_paths); +} + +static int ql_reinstate_path (struct path_selector *ps,struct dm_path *path) +{ +struct selector *s = (struct selector *) ps->context; +struct path_info *pi = path->pscontext; + +list_move_tail (&pi->list, &s->valid_paths); + +return 0 ; +} + +static struct dm_path *ql_select_path (struct path_selector *ps, +unsigned *repeat_count,size_t nr_bytes) +{ +struct selector *s = (struct selector *) ps->context; +struct path_info *pi =NULL , *best =NULL ; + +if (list_empty (&s->valid_paths)) +return NULL ; + +/* Change preferred (first in list) path to evenly balance. */ +list_move_tail (s->valid_paths.next, &s->valid_paths); + +list_for_each_entry (pi, &s->valid_paths, list) { +if (!best || + (atomic_read (&pi->qlen) <atomic_read (&best->qlen))) + best = pi; + +if (!atomic_read (&best->qlen)) +break ; + } + +if (!best) +return NULL ; + + *repeat_count = best->repeat_count; + +return best->path; +} + +static int ql_start_io (struct path_selector *ps,struct dm_path *path, +size_t nr_bytes) +{ +struct path_info *pi = path->pscontext; + +atomic_inc (&pi->qlen); + +return 0 ; +} + +static int ql_end_io (struct path_selector *ps,struct dm_path *path, +size_t nr_bytes) +{ +struct path_info *pi = path->pscontext; + +atomic_dec (&pi->qlen); + +return 0 ; +} + +static struct path_selector_type ql_ps = { + .name ="queue-length" , + .module =THIS_MODULE , + .table_args =1 , + .info_args =1 , + .create = ql_create, + .destroy = ql_destroy, + .status = ql_status, + .add_path = ql_add_path, + .fail_path = ql_fail_path, + .reinstate_path = ql_reinstate_path, + .select_path = ql_select_path, + .start_io = ql_start_io, + .end_io = ql_end_io, +}; + +static int __init dm_ql_init (void ) +{ +int r =dm_register_path_selector (&ql_ps); + +if (r <0 ) +DMERR ("register failed %d" , r); + +DMINFO ("version " QL_VERSION " loaded" ); + +return r; +} + +static void __exit dm_ql_exit(void) +{ +int r =dm_unregister_path_selector (&ql_ps); + +if (r <0 ) +DMERR ("unregister failed %d" , r); +} + +module_init (dm_ql_init); +module_exit (dm_ql_exit); + +MODULE_AUTHOR ("Stefan Bader <Stefan.Bader at de.ibm.com>" ); +MODULE_DESCRIPTION ( +"(C) Copyright IBM Corp. 2004,2005 All Rights Reserved.\n" +DM_NAME " path selector to balance the number of in-flight I/Os" +); +MODULE_LICENSE ("GPL" );
drivers/md/Makefile +1 -0
@@ -34,6 +34,7 @@ obj-$(CONFIG_BLK_DEV_DM) += dm-mod.o obj-$(CONFIG_DM_CRYPT) += dm-crypt.o obj-$(CONFIG_DM_DELAY) += dm-delay.o obj-$(CONFIG_DM_MULTIPATH) += dm-multipath.o dm-round-robin.o +obj-$(CONFIG_DM_MULTIPATH_QL) += dm-queue-length.o obj-$(CONFIG_DM_SNAPSHOT) += dm-snapshot.o obj-$(CONFIG_DM_MIRROR) += dm-mirror.o dm-log.o dm-region-hash.o obj-$(CONFIG_DM_ZERO) += dm-zero.o
drivers/md/Kconfig +9 -0
@@ -274,6 +274,15 @@ config DM_MULTIPATH ---help--- Allow volume managers to support multipath hardware. +config DM_MULTIPATH_QL + tristate "I/O Path Selector based on the number of in-flight I/Os" + depends on DM_MULTIPATH + ---help--- + This path selector is a dynamic load balancer which selects + a path having the least number of in-flight I/Os. + + If unsure, say N. + config DM_DELAY tristate "I/O delaying target (EXPERIMENTAL)" depends on BLK_DEV_DM && EXPERIMENTAL
PATCH 3/3 dm-mpath: add service-time oriented dynamic load balancer
In reply to Kiyoshi UedaThis patch adds a service time oriented dynamic load balancer, dm-service-time, which selects a path with the shortest estimated service time for the incoming I/O.
The service time is estimated by dividing the in-flight I/O size with performance value of each path.
The performance value can be given as a table argument at the table loading time. If no performance value is given, all paths are recognized as equal performance.
--- drivers/md/Kconfig | 9 + drivers/md/Makefile | 1 drivers/md/dm-service-time.c | 301 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 311 insertions(+)
drivers/md/dm-service-time.c new file +301 -0
@@ -0,0 +1,301 @@ +/* +* Copyright (C) 2007-2009 NEC Corporation. All Rights Reserved. +* +* Module Author: Kiyoshi Ueda +* +* This file is released under the GPL. +* +* Throughput oriented path selector. +*/ + +#include "dm.h" +#include "dm-path-selector.h" + +#define DM_MSG_PREFIX "multipath service-time" +#define ST_MIN_IO 1 +#define ST_VERSION "0.1.0" + +struct selector { +struct list_head valid_paths; +struct list_head failed_paths; +}; + +struct path_info { +struct list_head list; +struct dm_path *path; +unsigned int repeat_count; +size_t perf; +atomic_t in_flight_size;/* Total size of in-flight I/Os */ +}; + +static struct selector *alloc_selector (void ) +{ +struct selector *s =kmalloc (sizeof (*s),GFP_KERNEL ); + +if (s) { +INIT_LIST_HEAD (&s->valid_paths); +INIT_LIST_HEAD (&s->failed_paths); + } + +return s; +} + +static int st_create (struct path_selector *ps,unsigned argc,char **argv) +{ +struct selector *s =alloc_selector (); + +if (!s) +return -ENOMEM ; + + ps->context = s; +return 0 ; +} + +static void free_paths (struct list_head *paths) +{ +struct path_info *pi, *next; + +list_for_each_entry_safe (pi, next, paths, list) { +list_del (&pi->list); +kfree (pi); + } +} + +static void st_destroy (struct path_selector *ps) +{ +struct selector *s = (struct selector *) ps->context; + +free_paths (&s->valid_paths); +free_paths (&s->failed_paths); +kfree (s); + ps->context =NULL ; +} + +static int st_status (struct path_selector *ps,struct dm_path *path, +status_type_t type,char *result,unsigned int maxlen) +{ +int sz =0 ; +struct path_info *pi; + +if (!path) +DMEMIT ("0 " ); +else { + pi = path->pscontext; + +switch (type) { +case STATUSTYPE_INFO : +DMEMIT ("%u %lu " ,atomic_read (&pi->in_flight_size), + pi->perf); +break ; +case STATUSTYPE_TABLE : +DMEMIT ("%u %lu " , pi->repeat_count, pi->perf); +break ; + } + } + +return sz; +} + +static int st_add_path (struct path_selector *ps,struct dm_path *path, +int argc,char **argv,char **error) +{ +struct selector *s = (struct selector *) ps->context; +struct path_info *pi; +unsigned int repeat_count =ST_MIN_IO ; +size_t perf =1 ; + +if (argc >2 ) { + *error ="service-time ps: incorrect number of arguments" ; +return -EINVAL ; + } + +/* First path argument is number of I/Os before switching path. */ +if ((argc >0 ) && (sscanf (argv[0 ],"%u" , &repeat_count) !=1 )) { + *error ="service-time ps: invalid repeat count" ; +return -EINVAL ; + } + +/* +* Second path argument is a relative performance value. +* If 0 is given, the path isn't used while other paths having +* a positive value are available. +*/ +if ((argc ==2 ) && (sscanf (argv[1 ],"%lu" , &perf) !=1 )) { + *error ="service-time ps: invalid performance value" ; +return -EINVAL ; + } + +/* allocate the path */ + pi =kmalloc (sizeof (*pi),GFP_KERNEL ); +if (!pi) { + *error ="service-time ps: Error allocating path context" ; +return -ENOMEM ; + } + + pi->path = path; + pi->repeat_count = repeat_count; + pi->perf = perf; +atomic_set (&pi->in_flight_size,0 ); + + path->pscontext = pi; + +list_add_tail (&pi->list, &s->valid_paths); + +return 0 ; +} + +static void st_fail_path (struct path_selector *ps,struct dm_path *path) +{ +struct selector *s = (struct selector *) ps->context; +struct path_info *pi = path->pscontext; + +list_move (&pi->list, &s->failed_paths); +} + +static int st_reinstate_path (struct path_selector *ps,struct dm_path *path) +{ +struct selector *s = (struct selector *) ps->context; +struct path_info *pi = path->pscontext; + +list_move_tail (&pi->list, &s->valid_paths); + +return 0 ; +} + +/* +* Returns: +* < 0 : pi1 is better +* 0 : no difference between pi1 and pi2 +* > 0 : pi2 is better +*/ +static int st_compare_load (struct path_info *pi1,struct path_info *pi2, +size_t incoming) +{ +size_t sz1, sz2; + + sz1 =atomic_read (&pi1->in_flight_size); + sz2 =atomic_read (&pi2->in_flight_size); + +/* +* Case 1: Both have same performace value. Choose less loaded path. +*/ +if (pi1->perf == pi2->perf) +return sz1 - sz2; + +/* +* Case 2a: Both have same load. Choose higher performance path. +* Case 2b: One path has no performance value. Choose the other one. +*/ +if (sz1 == sz2 || !pi1->perf || !pi2->perf) +return pi2->perf - pi1->perf; + +/* +* Case 3: Calculate service time. Choose faster path. +* if ((sz1+incoming)/pi1->perf < (sz2+incoming)/pi2->perf) pi1 +* if ((sz1+incoming)/pi1->perf > (sz2+incoming)/pi2->perf) pi2 +*/ + sz1 += incoming; + sz2 += incoming; +while (sz1 && sz2 && (sz1 < pi1->perf) && (sz2 < pi2->perf)) { +/* Size is not big enough to compare by division. Shift up */ + sz1 <<=2 ; + sz2 <<=2 ; + } +do_div (sz1, pi1->perf); +do_div (sz2, pi2->perf); + +if (sz1 != sz2) +return sz1 - sz2; + +/* +* Case 4: Service time is equal. Choose higher performance path. +*/ +return pi2->perf - pi1->perf; +} + +static struct dm_path *st_select_path (struct path_selector *ps, +unsigned *repeat_count,size_t nr_bytes) +{ +struct selector *s = (struct selector *) ps->context; +struct path_info *pi =NULL , *best =NULL ; + +if (list_empty (&s->valid_paths)) +return NULL ; + +/* Change preferred (first in list) path to evenly balance. */ +list_move_tail (s->valid_paths.next, &s->valid_paths); + +list_for_each_entry (pi, &s->valid_paths, list) +if (!best || (st_compare_load (pi, best, nr_bytes) <0 )) + best = pi; + +if (!best) +return NULL ; + + *repeat_count = best->repeat_count; + +return best->path; +} + +static int st_start_io (struct path_selector *ps,struct dm_path *path, +size_t nr_bytes) +{ +struct path_info *pi = path->pscontext; + +atomic_add (nr_bytes, &pi->in_flight_size); + +return 0 ; +} + +static int st_end_io (struct path_selector *ps,struct dm_path *path, +size_t nr_bytes) +{ +struct path_info *pi = path->pscontext; + +atomic_sub (nr_bytes, &pi->in_flight_size); + +return 0 ; +} + +static struct path_selector_type st_ps = { + .name ="service-time" , + .module =THIS_MODULE , + .table_args =2 , + .info_args =2 , + .create = st_create, + .destroy = st_destroy, + .status = st_status, + .add_path = st_add_path, + .fail_path = st_fail_path, + .reinstate_path = st_reinstate_path, + .select_path = st_select_path, + .start_io = st_start_io, + .end_io = st_end_io, +}; + +static int __init dm_st_init (void ) +{ +int r =dm_register_path_selector (&st_ps); + +if (r <0 ) +DMERR ("register failed %d" , r); + +DMINFO ("version " ST_VERSION " loaded" ); + +return r; +} + +static void __exit dm_st_exit(void) +{ +int r =dm_unregister_path_selector (&st_ps); + +if (r <0 ) +DMERR ("unregister failed %d" , r); +} + +module_init (dm_st_init); +module_exit (dm_st_exit); + +MODULE_DESCRIPTION (DM_NAME " throughput oriented path selector" ); +MODULE_AUTHOR ("Kiyoshi Ueda <[email protected]>" ); +MODULE_LICENSE ("GPL" );
drivers/md/Makefile +1 -0
@@ -35,6 +35,7 @@ obj-$(CONFIG_DM_CRYPT) += dm-crypt.o obj-$(CONFIG_DM_DELAY) += dm-delay.o obj-$(CONFIG_DM_MULTIPATH) += dm-multipath.o dm-round-robin.o obj-$(CONFIG_DM_MULTIPATH_QL) += dm-queue-length.o +obj-$(CONFIG_DM_MULTIPATH_ST) += dm-service-time.o obj-$(CONFIG_DM_SNAPSHOT) += dm-snapshot.o obj-$(CONFIG_DM_MIRROR) += dm-mirror.o dm-log.o dm-region-hash.o obj-$(CONFIG_DM_ZERO) += dm-zero.o
drivers/md/Kconfig +9 -0
@@ -283,6 +283,15 @@ config DM_MULTIPATH_QL If unsure, say N. +config DM_MULTIPATH_ST + tristate "I/O Path Selector based on the service time" + depends on DM_MULTIPATH + ---help--- + This path selector is a dynamic load balancer which selects + a path to complete the incoming I/O with the shortest time. + + If unsure, say N. + config DM_DELAY tristate "I/O delaying target (EXPERIMENTAL)" depends on BLK_DEV_DM && EXPERIMENTAL