Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2003 Sistina Software Limited. |
| 3 | * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved. |
| 4 | * |
| 5 | * This file is released under the GPL. |
| 6 | */ |
| 7 | |
Mikulas Patocka | 586e80e | 2008-10-21 17:44:59 +0100 | [diff] [blame] | 8 | #include <linux/device-mapper.h> |
| 9 | |
Mike Snitzer | f479082 | 2013-09-12 18:06:12 -0400 | [diff] [blame] | 10 | #include "dm.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | #include "dm-path-selector.h" |
Mike Anderson | b15546f | 2007-10-19 22:48:02 +0100 | [diff] [blame] | 12 | #include "dm-uevent.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | |
Mike Snitzer | e5863d9 | 2014-12-17 21:08:12 -0500 | [diff] [blame] | 14 | #include <linux/blkdev.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <linux/ctype.h> |
| 16 | #include <linux/init.h> |
| 17 | #include <linux/mempool.h> |
| 18 | #include <linux/module.h> |
| 19 | #include <linux/pagemap.h> |
| 20 | #include <linux/slab.h> |
| 21 | #include <linux/time.h> |
| 22 | #include <linux/workqueue.h> |
Mikulas Patocka | 3599165 | 2012-06-03 00:29:58 +0100 | [diff] [blame] | 23 | #include <linux/delay.h> |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 24 | #include <scsi/scsi_dh.h> |
Arun Sharma | 60063497 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 25 | #include <linux/atomic.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 27 | #define DM_MSG_PREFIX "multipath" |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 28 | #define DM_PG_INIT_DELAY_MSECS 2000 |
| 29 | #define DM_PG_INIT_DELAY_DEFAULT ((unsigned) -1) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | |
| 31 | /* Path properties */ |
| 32 | struct pgpath { |
| 33 | struct list_head list; |
| 34 | |
| 35 | struct priority_group *pg; /* Owning PG */ |
Kiyoshi Ueda | 6680073 | 2008-10-10 13:36:58 +0100 | [diff] [blame] | 36 | unsigned is_active; /* Path status */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | unsigned fail_count; /* Cumulative failure count */ |
| 38 | |
Josef "Jeff" Sipek | c922d5f | 2006-12-08 02:36:33 -0800 | [diff] [blame] | 39 | struct dm_path path; |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 40 | struct delayed_work activate_path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | }; |
| 42 | |
| 43 | #define path_to_pgpath(__pgp) container_of((__pgp), struct pgpath, path) |
| 44 | |
| 45 | /* |
| 46 | * Paths are grouped into Priority Groups and numbered from 1 upwards. |
| 47 | * Each has a path selector which controls which path gets used. |
| 48 | */ |
| 49 | struct priority_group { |
| 50 | struct list_head list; |
| 51 | |
| 52 | struct multipath *m; /* Owning multipath instance */ |
| 53 | struct path_selector ps; |
| 54 | |
| 55 | unsigned pg_num; /* Reference number */ |
| 56 | unsigned bypassed; /* Temporarily bypass this PG? */ |
| 57 | |
| 58 | unsigned nr_pgpaths; /* Number of paths in PG */ |
| 59 | struct list_head pgpaths; |
| 60 | }; |
| 61 | |
| 62 | /* Multipath context */ |
| 63 | struct multipath { |
| 64 | struct list_head list; |
| 65 | struct dm_target *ti; |
| 66 | |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 67 | const char *hw_handler_name; |
Chandra Seetharaman | 2bfd2e1 | 2009-08-03 12:42:45 -0700 | [diff] [blame] | 68 | char *hw_handler_params; |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 69 | |
Mike Snitzer | 1fbdd2b | 2012-06-03 00:29:43 +0100 | [diff] [blame] | 70 | spinlock_t lock; |
| 71 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | unsigned nr_priority_groups; |
| 73 | struct list_head priority_groups; |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 74 | |
| 75 | wait_queue_head_t pg_init_wait; /* Wait for pg_init completion */ |
| 76 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | unsigned pg_init_required; /* pg_init needs calling? */ |
Alasdair G Kergon | c3cd4f6 | 2005-07-12 15:53:04 -0700 | [diff] [blame] | 78 | unsigned pg_init_in_progress; /* Only one pg_init allowed at once */ |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 79 | unsigned pg_init_delay_retry; /* Delay pg_init retry? */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | |
| 81 | unsigned nr_valid_paths; /* Total number of usable paths */ |
| 82 | struct pgpath *current_pgpath; |
| 83 | struct priority_group *current_pg; |
| 84 | struct priority_group *next_pg; /* Switch to this PG if set */ |
| 85 | unsigned repeat_count; /* I/Os left before calling PS again */ |
| 86 | |
Mike Snitzer | 1fbdd2b | 2012-06-03 00:29:43 +0100 | [diff] [blame] | 87 | unsigned queue_io:1; /* Must we queue all I/O? */ |
| 88 | unsigned queue_if_no_path:1; /* Queue I/O if last path fails? */ |
| 89 | unsigned saved_queue_if_no_path:1; /* Saved state during suspension */ |
Mike Snitzer | a58a935 | 2012-07-27 15:08:04 +0100 | [diff] [blame] | 90 | unsigned retain_attached_hw_handler:1; /* If there's already a hw_handler present, don't change it. */ |
Shiva Krishna Merla | 954a73d | 2013-10-30 03:26:38 +0000 | [diff] [blame] | 91 | unsigned pg_init_disabled:1; /* pg_init is not currently allowed */ |
Mike Snitzer | 1fbdd2b | 2012-06-03 00:29:43 +0100 | [diff] [blame] | 92 | |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 93 | unsigned pg_init_retries; /* Number of times to retry pg_init */ |
| 94 | unsigned pg_init_count; /* Number of times pg_init called */ |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 95 | unsigned pg_init_delay_msecs; /* Number of msecs before pg_init retry */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | struct work_struct trigger_event; |
| 98 | |
| 99 | /* |
Alasdair G Kergon | 028867a | 2007-07-12 17:26:32 +0100 | [diff] [blame] | 100 | * We must use a mempool of dm_mpath_io structs so that we |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | * can resubmit bios on error. |
| 102 | */ |
| 103 | mempool_t *mpio_pool; |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 104 | |
| 105 | struct mutex work_mutex; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | }; |
| 107 | |
| 108 | /* |
| 109 | * Context information attached to each bio we process. |
| 110 | */ |
Alasdair G Kergon | 028867a | 2007-07-12 17:26:32 +0100 | [diff] [blame] | 111 | struct dm_mpath_io { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | struct pgpath *pgpath; |
Kiyoshi Ueda | 02ab823 | 2009-06-22 10:12:27 +0100 | [diff] [blame] | 113 | size_t nr_bytes; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | }; |
| 115 | |
| 116 | typedef int (*action_fn) (struct pgpath *pgpath); |
| 117 | |
Christoph Lameter | e18b890 | 2006-12-06 20:33:20 -0800 | [diff] [blame] | 118 | static struct kmem_cache *_mpio_cache; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | |
Chandra Seetharaman | bab7cfc | 2008-05-01 14:50:22 -0700 | [diff] [blame] | 120 | static struct workqueue_struct *kmultipathd, *kmpath_handlerd; |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 121 | static void trigger_event(struct work_struct *work); |
Chandra Seetharaman | bab7cfc | 2008-05-01 14:50:22 -0700 | [diff] [blame] | 122 | static void activate_path(struct work_struct *work); |
Hannes Reinecke | e809917 | 2014-02-28 15:33:44 +0100 | [diff] [blame] | 123 | static int __pgpath_busy(struct pgpath *pgpath); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | |
| 125 | |
| 126 | /*----------------------------------------------- |
| 127 | * Allocation routines |
| 128 | *-----------------------------------------------*/ |
| 129 | |
| 130 | static struct pgpath *alloc_pgpath(void) |
| 131 | { |
Micha³ Miros³aw | e69fae5 | 2006-10-03 01:15:34 -0700 | [diff] [blame] | 132 | struct pgpath *pgpath = kzalloc(sizeof(*pgpath), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | |
Mike Anderson | 224cb3e | 2008-08-29 09:36:09 +0200 | [diff] [blame] | 134 | if (pgpath) { |
Kiyoshi Ueda | 6680073 | 2008-10-10 13:36:58 +0100 | [diff] [blame] | 135 | pgpath->is_active = 1; |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 136 | INIT_DELAYED_WORK(&pgpath->activate_path, activate_path); |
Mike Anderson | 224cb3e | 2008-08-29 09:36:09 +0200 | [diff] [blame] | 137 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | |
| 139 | return pgpath; |
| 140 | } |
| 141 | |
Alasdair G Kergon | 028867a | 2007-07-12 17:26:32 +0100 | [diff] [blame] | 142 | static void free_pgpath(struct pgpath *pgpath) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | { |
| 144 | kfree(pgpath); |
| 145 | } |
| 146 | |
| 147 | static struct priority_group *alloc_priority_group(void) |
| 148 | { |
| 149 | struct priority_group *pg; |
| 150 | |
Micha³ Miros³aw | e69fae5 | 2006-10-03 01:15:34 -0700 | [diff] [blame] | 151 | pg = kzalloc(sizeof(*pg), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 152 | |
Micha³ Miros³aw | e69fae5 | 2006-10-03 01:15:34 -0700 | [diff] [blame] | 153 | if (pg) |
| 154 | INIT_LIST_HEAD(&pg->pgpaths); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | |
| 156 | return pg; |
| 157 | } |
| 158 | |
| 159 | static void free_pgpaths(struct list_head *pgpaths, struct dm_target *ti) |
| 160 | { |
| 161 | struct pgpath *pgpath, *tmp; |
Hannes Reinecke | ae11b1b | 2008-07-17 17:49:02 -0700 | [diff] [blame] | 162 | struct multipath *m = ti->private; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | |
| 164 | list_for_each_entry_safe(pgpath, tmp, pgpaths, list) { |
| 165 | list_del(&pgpath->list); |
Hannes Reinecke | ae11b1b | 2008-07-17 17:49:02 -0700 | [diff] [blame] | 166 | if (m->hw_handler_name) |
| 167 | scsi_dh_detach(bdev_get_queue(pgpath->path.dev->bdev)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | dm_put_device(ti, pgpath->path.dev); |
| 169 | free_pgpath(pgpath); |
| 170 | } |
| 171 | } |
| 172 | |
| 173 | static void free_priority_group(struct priority_group *pg, |
| 174 | struct dm_target *ti) |
| 175 | { |
| 176 | struct path_selector *ps = &pg->ps; |
| 177 | |
| 178 | if (ps->type) { |
| 179 | ps->type->destroy(ps); |
| 180 | dm_put_path_selector(ps->type); |
| 181 | } |
| 182 | |
| 183 | free_pgpaths(&pg->pgpaths, ti); |
| 184 | kfree(pg); |
| 185 | } |
| 186 | |
Micha³ Miros³aw | 28f16c2 | 2006-10-03 01:15:33 -0700 | [diff] [blame] | 187 | static struct multipath *alloc_multipath(struct dm_target *ti) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | { |
| 189 | struct multipath *m; |
Mike Snitzer | f479082 | 2013-09-12 18:06:12 -0400 | [diff] [blame] | 190 | unsigned min_ios = dm_get_reserved_rq_based_ios(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 191 | |
Micha³ Miros³aw | e69fae5 | 2006-10-03 01:15:34 -0700 | [diff] [blame] | 192 | m = kzalloc(sizeof(*m), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 193 | if (m) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | INIT_LIST_HEAD(&m->priority_groups); |
| 195 | spin_lock_init(&m->lock); |
| 196 | m->queue_io = 1; |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 197 | m->pg_init_delay_msecs = DM_PG_INIT_DELAY_DEFAULT; |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 198 | INIT_WORK(&m->trigger_event, trigger_event); |
Kiyoshi Ueda | 2bded7b | 2010-03-06 02:32:13 +0000 | [diff] [blame] | 199 | init_waitqueue_head(&m->pg_init_wait); |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 200 | mutex_init(&m->work_mutex); |
Mike Snitzer | f479082 | 2013-09-12 18:06:12 -0400 | [diff] [blame] | 201 | m->mpio_pool = mempool_create_slab_pool(min_ios, _mpio_cache); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | if (!m->mpio_pool) { |
| 203 | kfree(m); |
| 204 | return NULL; |
| 205 | } |
Micha³ Miros³aw | 28f16c2 | 2006-10-03 01:15:33 -0700 | [diff] [blame] | 206 | m->ti = ti; |
| 207 | ti->private = m; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | } |
| 209 | |
| 210 | return m; |
| 211 | } |
| 212 | |
| 213 | static void free_multipath(struct multipath *m) |
| 214 | { |
| 215 | struct priority_group *pg, *tmp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | |
| 217 | list_for_each_entry_safe(pg, tmp, &m->priority_groups, list) { |
| 218 | list_del(&pg->list); |
| 219 | free_priority_group(pg, m->ti); |
| 220 | } |
| 221 | |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 222 | kfree(m->hw_handler_name); |
Chandra Seetharaman | 2bfd2e1 | 2009-08-03 12:42:45 -0700 | [diff] [blame] | 223 | kfree(m->hw_handler_params); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 224 | mempool_destroy(m->mpio_pool); |
| 225 | kfree(m); |
| 226 | } |
| 227 | |
Jun'ichi Nomura | 466891f | 2012-03-28 18:41:25 +0100 | [diff] [blame] | 228 | static int set_mapinfo(struct multipath *m, union map_info *info) |
| 229 | { |
| 230 | struct dm_mpath_io *mpio; |
| 231 | |
| 232 | mpio = mempool_alloc(m->mpio_pool, GFP_ATOMIC); |
| 233 | if (!mpio) |
| 234 | return -ENOMEM; |
| 235 | |
| 236 | memset(mpio, 0, sizeof(*mpio)); |
| 237 | info->ptr = mpio; |
| 238 | |
| 239 | return 0; |
| 240 | } |
| 241 | |
| 242 | static void clear_mapinfo(struct multipath *m, union map_info *info) |
| 243 | { |
| 244 | struct dm_mpath_io *mpio = info->ptr; |
| 245 | |
| 246 | info->ptr = NULL; |
| 247 | mempool_free(mpio, m->mpio_pool); |
| 248 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | |
| 250 | /*----------------------------------------------- |
| 251 | * Path selection |
| 252 | *-----------------------------------------------*/ |
| 253 | |
Hannes Reinecke | 3e9f1be | 2014-02-28 15:33:45 +0100 | [diff] [blame] | 254 | static int __pg_init_all_paths(struct multipath *m) |
Kiyoshi Ueda | fb61264 | 2010-03-06 02:32:18 +0000 | [diff] [blame] | 255 | { |
| 256 | struct pgpath *pgpath; |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 257 | unsigned long pg_init_delay = 0; |
Kiyoshi Ueda | fb61264 | 2010-03-06 02:32:18 +0000 | [diff] [blame] | 258 | |
Hannes Reinecke | 17f4ff4 | 2014-02-28 15:33:42 +0100 | [diff] [blame] | 259 | if (m->pg_init_in_progress || m->pg_init_disabled) |
Hannes Reinecke | 3e9f1be | 2014-02-28 15:33:45 +0100 | [diff] [blame] | 260 | return 0; |
Hannes Reinecke | 17f4ff4 | 2014-02-28 15:33:42 +0100 | [diff] [blame] | 261 | |
Kiyoshi Ueda | fb61264 | 2010-03-06 02:32:18 +0000 | [diff] [blame] | 262 | m->pg_init_count++; |
| 263 | m->pg_init_required = 0; |
Hannes Reinecke | 3e9f1be | 2014-02-28 15:33:45 +0100 | [diff] [blame] | 264 | |
| 265 | /* Check here to reset pg_init_required */ |
| 266 | if (!m->current_pg) |
| 267 | return 0; |
| 268 | |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 269 | if (m->pg_init_delay_retry) |
| 270 | pg_init_delay = msecs_to_jiffies(m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT ? |
| 271 | m->pg_init_delay_msecs : DM_PG_INIT_DELAY_MSECS); |
Kiyoshi Ueda | fb61264 | 2010-03-06 02:32:18 +0000 | [diff] [blame] | 272 | list_for_each_entry(pgpath, &m->current_pg->pgpaths, list) { |
| 273 | /* Skip failed paths */ |
| 274 | if (!pgpath->is_active) |
| 275 | continue; |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 276 | if (queue_delayed_work(kmpath_handlerd, &pgpath->activate_path, |
| 277 | pg_init_delay)) |
Kiyoshi Ueda | fb61264 | 2010-03-06 02:32:18 +0000 | [diff] [blame] | 278 | m->pg_init_in_progress++; |
| 279 | } |
Hannes Reinecke | 3e9f1be | 2014-02-28 15:33:45 +0100 | [diff] [blame] | 280 | return m->pg_init_in_progress; |
Kiyoshi Ueda | fb61264 | 2010-03-06 02:32:18 +0000 | [diff] [blame] | 281 | } |
| 282 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 283 | static void __switch_pg(struct multipath *m, struct pgpath *pgpath) |
| 284 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 285 | m->current_pg = pgpath->pg; |
| 286 | |
| 287 | /* Must we initialise the PG first, and queue I/O till it's ready? */ |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 288 | if (m->hw_handler_name) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 289 | m->pg_init_required = 1; |
| 290 | m->queue_io = 1; |
| 291 | } else { |
| 292 | m->pg_init_required = 0; |
| 293 | m->queue_io = 0; |
| 294 | } |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 295 | |
| 296 | m->pg_init_count = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 297 | } |
| 298 | |
Kiyoshi Ueda | 02ab823 | 2009-06-22 10:12:27 +0100 | [diff] [blame] | 299 | static int __choose_path_in_pg(struct multipath *m, struct priority_group *pg, |
| 300 | size_t nr_bytes) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 301 | { |
Josef "Jeff" Sipek | c922d5f | 2006-12-08 02:36:33 -0800 | [diff] [blame] | 302 | struct dm_path *path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | |
Kiyoshi Ueda | 02ab823 | 2009-06-22 10:12:27 +0100 | [diff] [blame] | 304 | path = pg->ps.type->select_path(&pg->ps, &m->repeat_count, nr_bytes); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 305 | if (!path) |
| 306 | return -ENXIO; |
| 307 | |
| 308 | m->current_pgpath = path_to_pgpath(path); |
| 309 | |
| 310 | if (m->current_pg != pg) |
| 311 | __switch_pg(m, m->current_pgpath); |
| 312 | |
| 313 | return 0; |
| 314 | } |
| 315 | |
Kiyoshi Ueda | 02ab823 | 2009-06-22 10:12:27 +0100 | [diff] [blame] | 316 | static void __choose_pgpath(struct multipath *m, size_t nr_bytes) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 317 | { |
| 318 | struct priority_group *pg; |
| 319 | unsigned bypassed = 1; |
| 320 | |
Benjamin Marzinski | 1f27197 | 2014-08-13 13:53:42 -0500 | [diff] [blame] | 321 | if (!m->nr_valid_paths) { |
| 322 | m->queue_io = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 323 | goto failed; |
Benjamin Marzinski | 1f27197 | 2014-08-13 13:53:42 -0500 | [diff] [blame] | 324 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 325 | |
| 326 | /* Were we instructed to switch PG? */ |
| 327 | if (m->next_pg) { |
| 328 | pg = m->next_pg; |
| 329 | m->next_pg = NULL; |
Kiyoshi Ueda | 02ab823 | 2009-06-22 10:12:27 +0100 | [diff] [blame] | 330 | if (!__choose_path_in_pg(m, pg, nr_bytes)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | return; |
| 332 | } |
| 333 | |
| 334 | /* Don't change PG until it has no remaining paths */ |
Kiyoshi Ueda | 02ab823 | 2009-06-22 10:12:27 +0100 | [diff] [blame] | 335 | if (m->current_pg && !__choose_path_in_pg(m, m->current_pg, nr_bytes)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 336 | return; |
| 337 | |
| 338 | /* |
| 339 | * Loop through priority groups until we find a valid path. |
| 340 | * First time we skip PGs marked 'bypassed'. |
Mike Christie | f220fd4 | 2012-06-03 00:29:45 +0100 | [diff] [blame] | 341 | * Second time we only try the ones we skipped, but set |
| 342 | * pg_init_delay_retry so we do not hammer controllers. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | */ |
| 344 | do { |
| 345 | list_for_each_entry(pg, &m->priority_groups, list) { |
| 346 | if (pg->bypassed == bypassed) |
| 347 | continue; |
Mike Christie | f220fd4 | 2012-06-03 00:29:45 +0100 | [diff] [blame] | 348 | if (!__choose_path_in_pg(m, pg, nr_bytes)) { |
| 349 | if (!bypassed) |
| 350 | m->pg_init_delay_retry = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | return; |
Mike Christie | f220fd4 | 2012-06-03 00:29:45 +0100 | [diff] [blame] | 352 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | } |
| 354 | } while (bypassed--); |
| 355 | |
| 356 | failed: |
| 357 | m->current_pgpath = NULL; |
| 358 | m->current_pg = NULL; |
| 359 | } |
| 360 | |
Kiyoshi Ueda | 45e1572 | 2006-12-08 02:41:10 -0800 | [diff] [blame] | 361 | /* |
| 362 | * Check whether bios must be queued in the device-mapper core rather |
| 363 | * than here in the target. |
| 364 | * |
| 365 | * m->lock must be held on entry. |
| 366 | * |
| 367 | * If m->queue_if_no_path and m->saved_queue_if_no_path hold the |
| 368 | * same value then we are not between multipath_presuspend() |
| 369 | * and multipath_resume() calls and we have no need to check |
| 370 | * for the DMF_NOFLUSH_SUSPENDING flag. |
| 371 | */ |
| 372 | static int __must_push_back(struct multipath *m) |
| 373 | { |
Hannes Reinecke | e809917 | 2014-02-28 15:33:44 +0100 | [diff] [blame] | 374 | return (m->queue_if_no_path || |
| 375 | (m->queue_if_no_path != m->saved_queue_if_no_path && |
| 376 | dm_noflush_suspending(m->ti))); |
Kiyoshi Ueda | 45e1572 | 2006-12-08 02:41:10 -0800 | [diff] [blame] | 377 | } |
| 378 | |
Hannes Reinecke | 36fcffc | 2014-02-28 15:33:47 +0100 | [diff] [blame] | 379 | /* |
| 380 | * Map cloned requests |
| 381 | */ |
Mike Snitzer | e5863d9 | 2014-12-17 21:08:12 -0500 | [diff] [blame] | 382 | static int __multipath_map(struct dm_target *ti, struct request *clone, |
| 383 | union map_info *map_context, |
| 384 | struct request *rq, struct request **__clone) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | { |
Hannes Reinecke | 36fcffc | 2014-02-28 15:33:47 +0100 | [diff] [blame] | 386 | struct multipath *m = (struct multipath *) ti->private; |
Hannes Reinecke | e3bde04 | 2014-02-28 15:33:46 +0100 | [diff] [blame] | 387 | int r = DM_MAPIO_REQUEUE; |
Mike Snitzer | e5863d9 | 2014-12-17 21:08:12 -0500 | [diff] [blame] | 388 | size_t nr_bytes = clone ? blk_rq_bytes(clone) : blk_rq_bytes(rq); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | struct pgpath *pgpath; |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 390 | struct block_device *bdev; |
Hannes Reinecke | e3bde04 | 2014-02-28 15:33:46 +0100 | [diff] [blame] | 391 | struct dm_mpath_io *mpio; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 392 | |
Keith Busch | 2eb6e1e | 2014-10-17 17:46:36 -0600 | [diff] [blame] | 393 | spin_lock_irq(&m->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 394 | |
| 395 | /* Do we need to select a new pgpath? */ |
| 396 | if (!m->current_pgpath || |
| 397 | (!m->queue_io && (m->repeat_count && --m->repeat_count == 0))) |
Kiyoshi Ueda | 02ab823 | 2009-06-22 10:12:27 +0100 | [diff] [blame] | 398 | __choose_pgpath(m, nr_bytes); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 399 | |
| 400 | pgpath = m->current_pgpath; |
| 401 | |
Mike Snitzer | 9bf59a6 | 2014-02-28 15:33:48 +0100 | [diff] [blame] | 402 | if (!pgpath) { |
| 403 | if (!__must_push_back(m)) |
| 404 | r = -EIO; /* Failed */ |
| 405 | goto out_unlock; |
Mike Snitzer | 6afbc01 | 2014-07-08 11:55:09 -0400 | [diff] [blame] | 406 | } else if (m->queue_io || m->pg_init_required) { |
Hannes Reinecke | e3bde04 | 2014-02-28 15:33:46 +0100 | [diff] [blame] | 407 | __pg_init_all_paths(m); |
Mike Snitzer | 9bf59a6 | 2014-02-28 15:33:48 +0100 | [diff] [blame] | 408 | goto out_unlock; |
| 409 | } |
Mike Snitzer | 6afbc01 | 2014-07-08 11:55:09 -0400 | [diff] [blame] | 410 | |
Mike Snitzer | 9bf59a6 | 2014-02-28 15:33:48 +0100 | [diff] [blame] | 411 | if (set_mapinfo(m, map_context) < 0) |
| 412 | /* ENOMEM, requeue */ |
| 413 | goto out_unlock; |
| 414 | |
Mike Snitzer | 9bf59a6 | 2014-02-28 15:33:48 +0100 | [diff] [blame] | 415 | mpio = map_context->ptr; |
| 416 | mpio->pgpath = pgpath; |
| 417 | mpio->nr_bytes = nr_bytes; |
Keith Busch | 2eb6e1e | 2014-10-17 17:46:36 -0600 | [diff] [blame] | 418 | |
| 419 | bdev = pgpath->path.dev->bdev; |
| 420 | |
Keith Busch | 2eb6e1e | 2014-10-17 17:46:36 -0600 | [diff] [blame] | 421 | spin_unlock_irq(&m->lock); |
| 422 | |
Mike Snitzer | e5863d9 | 2014-12-17 21:08:12 -0500 | [diff] [blame] | 423 | if (clone) { |
| 424 | /* Old request-based interface: allocated clone is passed in */ |
| 425 | clone->q = bdev_get_queue(bdev); |
| 426 | clone->rq_disk = bdev->bd_disk; |
| 427 | clone->cmd_flags |= REQ_FAILFAST_TRANSPORT; |
| 428 | } else { |
| 429 | /* blk-mq request-based interface */ |
| 430 | *__clone = blk_get_request(bdev_get_queue(bdev), |
| 431 | rq_data_dir(rq), GFP_KERNEL); |
| 432 | if (IS_ERR(*__clone)) |
| 433 | /* ENOMEM, requeue */ |
| 434 | return r; |
| 435 | (*__clone)->bio = (*__clone)->biotail = NULL; |
| 436 | (*__clone)->rq_disk = bdev->bd_disk; |
| 437 | (*__clone)->cmd_flags |= REQ_FAILFAST_TRANSPORT; |
| 438 | } |
| 439 | |
Mike Snitzer | 9bf59a6 | 2014-02-28 15:33:48 +0100 | [diff] [blame] | 440 | if (pgpath->pg->ps.type->start_io) |
| 441 | pgpath->pg->ps.type->start_io(&pgpath->pg->ps, |
| 442 | &pgpath->path, |
| 443 | nr_bytes); |
Keith Busch | 2eb6e1e | 2014-10-17 17:46:36 -0600 | [diff] [blame] | 444 | return DM_MAPIO_REMAPPED; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 445 | |
Hannes Reinecke | e3bde04 | 2014-02-28 15:33:46 +0100 | [diff] [blame] | 446 | out_unlock: |
Keith Busch | 2eb6e1e | 2014-10-17 17:46:36 -0600 | [diff] [blame] | 447 | spin_unlock_irq(&m->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 448 | |
| 449 | return r; |
| 450 | } |
| 451 | |
Mike Snitzer | e5863d9 | 2014-12-17 21:08:12 -0500 | [diff] [blame] | 452 | static int multipath_map(struct dm_target *ti, struct request *clone, |
| 453 | union map_info *map_context) |
| 454 | { |
| 455 | return __multipath_map(ti, clone, map_context, NULL, NULL); |
| 456 | } |
| 457 | |
| 458 | static int multipath_clone_and_map(struct dm_target *ti, struct request *rq, |
| 459 | union map_info *map_context, |
| 460 | struct request **clone) |
| 461 | { |
| 462 | return __multipath_map(ti, NULL, map_context, rq, clone); |
| 463 | } |
| 464 | |
| 465 | static void multipath_release_clone(struct request *clone) |
| 466 | { |
| 467 | blk_put_request(clone); |
| 468 | } |
| 469 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 470 | /* |
| 471 | * If we run out of usable paths, should we queue I/O or error it? |
| 472 | */ |
Alasdair G Kergon | 485ef69 | 2005-09-27 21:45:45 -0700 | [diff] [blame] | 473 | static int queue_if_no_path(struct multipath *m, unsigned queue_if_no_path, |
| 474 | unsigned save_old_value) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 475 | { |
| 476 | unsigned long flags; |
| 477 | |
| 478 | spin_lock_irqsave(&m->lock, flags); |
| 479 | |
Alasdair G Kergon | 485ef69 | 2005-09-27 21:45:45 -0700 | [diff] [blame] | 480 | if (save_old_value) |
| 481 | m->saved_queue_if_no_path = m->queue_if_no_path; |
| 482 | else |
| 483 | m->saved_queue_if_no_path = queue_if_no_path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 484 | m->queue_if_no_path = queue_if_no_path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 485 | spin_unlock_irqrestore(&m->lock, flags); |
| 486 | |
Hannes Reinecke | 63d832c | 2014-05-26 14:45:39 +0200 | [diff] [blame] | 487 | if (!queue_if_no_path) |
| 488 | dm_table_run_md_queue_async(m->ti->table); |
| 489 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 490 | return 0; |
| 491 | } |
| 492 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 493 | /* |
| 494 | * An event is triggered whenever a path is taken out of use. |
| 495 | * Includes path failure and PG bypass. |
| 496 | */ |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 497 | static void trigger_event(struct work_struct *work) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 498 | { |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 499 | struct multipath *m = |
| 500 | container_of(work, struct multipath, trigger_event); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | |
| 502 | dm_table_event(m->ti->table); |
| 503 | } |
| 504 | |
| 505 | /*----------------------------------------------------------------- |
| 506 | * Constructor/argument parsing: |
| 507 | * <#multipath feature args> [<arg>]* |
| 508 | * <#hw_handler args> [hw_handler [<arg>]*] |
| 509 | * <#priority groups> |
| 510 | * <initial priority group> |
| 511 | * [<selector> <#selector args> [<arg>]* |
| 512 | * <#paths> <#per-path selector args> |
| 513 | * [<path> [<arg>]* ]+ ]+ |
| 514 | *---------------------------------------------------------------*/ |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 515 | static int parse_path_selector(struct dm_arg_set *as, struct priority_group *pg, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 516 | struct dm_target *ti) |
| 517 | { |
| 518 | int r; |
| 519 | struct path_selector_type *pst; |
| 520 | unsigned ps_argc; |
| 521 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 522 | static struct dm_arg _args[] = { |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 523 | {0, 1024, "invalid number of path selector args"}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 524 | }; |
| 525 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 526 | pst = dm_get_path_selector(dm_shift_arg(as)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 527 | if (!pst) { |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 528 | ti->error = "unknown path selector type"; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 529 | return -EINVAL; |
| 530 | } |
| 531 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 532 | r = dm_read_arg_group(_args, as, &ps_argc, &ti->error); |
Mikulas Patocka | 371b2e3 | 2008-07-21 12:00:24 +0100 | [diff] [blame] | 533 | if (r) { |
| 534 | dm_put_path_selector(pst); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 535 | return -EINVAL; |
Mikulas Patocka | 371b2e3 | 2008-07-21 12:00:24 +0100 | [diff] [blame] | 536 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 537 | |
| 538 | r = pst->create(&pg->ps, ps_argc, as->argv); |
| 539 | if (r) { |
| 540 | dm_put_path_selector(pst); |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 541 | ti->error = "path selector constructor failed"; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 542 | return r; |
| 543 | } |
| 544 | |
| 545 | pg->ps.type = pst; |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 546 | dm_consume_args(as, ps_argc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 547 | |
| 548 | return 0; |
| 549 | } |
| 550 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 551 | static struct pgpath *parse_path(struct dm_arg_set *as, struct path_selector *ps, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 552 | struct dm_target *ti) |
| 553 | { |
| 554 | int r; |
| 555 | struct pgpath *p; |
Hannes Reinecke | ae11b1b | 2008-07-17 17:49:02 -0700 | [diff] [blame] | 556 | struct multipath *m = ti->private; |
Mike Snitzer | a58a935 | 2012-07-27 15:08:04 +0100 | [diff] [blame] | 557 | struct request_queue *q = NULL; |
| 558 | const char *attached_handler_name; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 559 | |
| 560 | /* we need at least a path arg */ |
| 561 | if (as->argc < 1) { |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 562 | ti->error = "no device given"; |
Benjamin Marzinski | 01460f3 | 2008-10-10 13:36:57 +0100 | [diff] [blame] | 563 | return ERR_PTR(-EINVAL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 564 | } |
| 565 | |
| 566 | p = alloc_pgpath(); |
| 567 | if (!p) |
Benjamin Marzinski | 01460f3 | 2008-10-10 13:36:57 +0100 | [diff] [blame] | 568 | return ERR_PTR(-ENOMEM); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 569 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 570 | r = dm_get_device(ti, dm_shift_arg(as), dm_table_get_mode(ti->table), |
Nikanth Karthikesan | 8215d6e | 2010-03-06 02:32:27 +0000 | [diff] [blame] | 571 | &p->path.dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 572 | if (r) { |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 573 | ti->error = "error getting device"; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 574 | goto bad; |
| 575 | } |
| 576 | |
Mike Snitzer | a58a935 | 2012-07-27 15:08:04 +0100 | [diff] [blame] | 577 | if (m->retain_attached_hw_handler || m->hw_handler_name) |
| 578 | q = bdev_get_queue(p->path.dev->bdev); |
Hannes Reinecke | a0cf7ea | 2009-06-22 10:12:11 +0100 | [diff] [blame] | 579 | |
Mike Snitzer | a58a935 | 2012-07-27 15:08:04 +0100 | [diff] [blame] | 580 | if (m->retain_attached_hw_handler) { |
| 581 | attached_handler_name = scsi_dh_attached_handler_name(q, GFP_KERNEL); |
| 582 | if (attached_handler_name) { |
| 583 | /* |
| 584 | * Reset hw_handler_name to match the attached handler |
| 585 | * and clear any hw_handler_params associated with the |
| 586 | * ignored handler. |
| 587 | * |
| 588 | * NB. This modifies the table line to show the actual |
| 589 | * handler instead of the original table passed in. |
| 590 | */ |
| 591 | kfree(m->hw_handler_name); |
| 592 | m->hw_handler_name = attached_handler_name; |
| 593 | |
| 594 | kfree(m->hw_handler_params); |
| 595 | m->hw_handler_params = NULL; |
| 596 | } |
| 597 | } |
| 598 | |
| 599 | if (m->hw_handler_name) { |
| 600 | /* |
| 601 | * Increments scsi_dh reference, even when using an |
| 602 | * already-attached handler. |
| 603 | */ |
Hannes Reinecke | a0cf7ea | 2009-06-22 10:12:11 +0100 | [diff] [blame] | 604 | r = scsi_dh_attach(q, m->hw_handler_name); |
| 605 | if (r == -EBUSY) { |
| 606 | /* |
Mike Snitzer | a58a935 | 2012-07-27 15:08:04 +0100 | [diff] [blame] | 607 | * Already attached to different hw_handler: |
Hannes Reinecke | a0cf7ea | 2009-06-22 10:12:11 +0100 | [diff] [blame] | 608 | * try to reattach with correct one. |
| 609 | */ |
| 610 | scsi_dh_detach(q); |
| 611 | r = scsi_dh_attach(q, m->hw_handler_name); |
| 612 | } |
| 613 | |
Hannes Reinecke | ae11b1b | 2008-07-17 17:49:02 -0700 | [diff] [blame] | 614 | if (r < 0) { |
Hannes Reinecke | a0cf7ea | 2009-06-22 10:12:11 +0100 | [diff] [blame] | 615 | ti->error = "error attaching hardware handler"; |
Hannes Reinecke | ae11b1b | 2008-07-17 17:49:02 -0700 | [diff] [blame] | 616 | dm_put_device(ti, p->path.dev); |
| 617 | goto bad; |
| 618 | } |
Chandra Seetharaman | 2bfd2e1 | 2009-08-03 12:42:45 -0700 | [diff] [blame] | 619 | |
| 620 | if (m->hw_handler_params) { |
| 621 | r = scsi_dh_set_params(q, m->hw_handler_params); |
| 622 | if (r < 0) { |
| 623 | ti->error = "unable to set hardware " |
| 624 | "handler parameters"; |
| 625 | scsi_dh_detach(q); |
| 626 | dm_put_device(ti, p->path.dev); |
| 627 | goto bad; |
| 628 | } |
| 629 | } |
Hannes Reinecke | ae11b1b | 2008-07-17 17:49:02 -0700 | [diff] [blame] | 630 | } |
| 631 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 632 | r = ps->type->add_path(ps, &p->path, as->argc, as->argv, &ti->error); |
| 633 | if (r) { |
| 634 | dm_put_device(ti, p->path.dev); |
| 635 | goto bad; |
| 636 | } |
| 637 | |
| 638 | return p; |
| 639 | |
| 640 | bad: |
| 641 | free_pgpath(p); |
Benjamin Marzinski | 01460f3 | 2008-10-10 13:36:57 +0100 | [diff] [blame] | 642 | return ERR_PTR(r); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 643 | } |
| 644 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 645 | static struct priority_group *parse_priority_group(struct dm_arg_set *as, |
Micha³ Miros³aw | 28f16c2 | 2006-10-03 01:15:33 -0700 | [diff] [blame] | 646 | struct multipath *m) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 647 | { |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 648 | static struct dm_arg _args[] = { |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 649 | {1, 1024, "invalid number of paths"}, |
| 650 | {0, 1024, "invalid number of selector args"} |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 651 | }; |
| 652 | |
| 653 | int r; |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 654 | unsigned i, nr_selector_args, nr_args; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 655 | struct priority_group *pg; |
Micha³ Miros³aw | 28f16c2 | 2006-10-03 01:15:33 -0700 | [diff] [blame] | 656 | struct dm_target *ti = m->ti; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 657 | |
| 658 | if (as->argc < 2) { |
| 659 | as->argc = 0; |
Benjamin Marzinski | 01460f3 | 2008-10-10 13:36:57 +0100 | [diff] [blame] | 660 | ti->error = "not enough priority group arguments"; |
| 661 | return ERR_PTR(-EINVAL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 662 | } |
| 663 | |
| 664 | pg = alloc_priority_group(); |
| 665 | if (!pg) { |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 666 | ti->error = "couldn't allocate priority group"; |
Benjamin Marzinski | 01460f3 | 2008-10-10 13:36:57 +0100 | [diff] [blame] | 667 | return ERR_PTR(-ENOMEM); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 668 | } |
| 669 | pg->m = m; |
| 670 | |
| 671 | r = parse_path_selector(as, pg, ti); |
| 672 | if (r) |
| 673 | goto bad; |
| 674 | |
| 675 | /* |
| 676 | * read the paths |
| 677 | */ |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 678 | r = dm_read_arg(_args, as, &pg->nr_pgpaths, &ti->error); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 679 | if (r) |
| 680 | goto bad; |
| 681 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 682 | r = dm_read_arg(_args + 1, as, &nr_selector_args, &ti->error); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 683 | if (r) |
| 684 | goto bad; |
| 685 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 686 | nr_args = 1 + nr_selector_args; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 687 | for (i = 0; i < pg->nr_pgpaths; i++) { |
| 688 | struct pgpath *pgpath; |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 689 | struct dm_arg_set path_args; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 690 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 691 | if (as->argc < nr_args) { |
Mikulas Patocka | 148acff | 2008-07-21 12:00:30 +0100 | [diff] [blame] | 692 | ti->error = "not enough path parameters"; |
Alasdair G Kergon | 6bbf79a | 2010-08-12 04:13:49 +0100 | [diff] [blame] | 693 | r = -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 694 | goto bad; |
Mikulas Patocka | 148acff | 2008-07-21 12:00:30 +0100 | [diff] [blame] | 695 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 696 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 697 | path_args.argc = nr_args; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 698 | path_args.argv = as->argv; |
| 699 | |
| 700 | pgpath = parse_path(&path_args, &pg->ps, ti); |
Benjamin Marzinski | 01460f3 | 2008-10-10 13:36:57 +0100 | [diff] [blame] | 701 | if (IS_ERR(pgpath)) { |
| 702 | r = PTR_ERR(pgpath); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 703 | goto bad; |
Benjamin Marzinski | 01460f3 | 2008-10-10 13:36:57 +0100 | [diff] [blame] | 704 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 705 | |
| 706 | pgpath->pg = pg; |
| 707 | list_add_tail(&pgpath->list, &pg->pgpaths); |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 708 | dm_consume_args(as, nr_args); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 709 | } |
| 710 | |
| 711 | return pg; |
| 712 | |
| 713 | bad: |
| 714 | free_priority_group(pg, ti); |
Benjamin Marzinski | 01460f3 | 2008-10-10 13:36:57 +0100 | [diff] [blame] | 715 | return ERR_PTR(r); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 716 | } |
| 717 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 718 | static int parse_hw_handler(struct dm_arg_set *as, struct multipath *m) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 719 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 720 | unsigned hw_argc; |
Chandra Seetharaman | 2bfd2e1 | 2009-08-03 12:42:45 -0700 | [diff] [blame] | 721 | int ret; |
Micha³ Miros³aw | 28f16c2 | 2006-10-03 01:15:33 -0700 | [diff] [blame] | 722 | struct dm_target *ti = m->ti; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 723 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 724 | static struct dm_arg _args[] = { |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 725 | {0, 1024, "invalid number of hardware handler args"}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 726 | }; |
| 727 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 728 | if (dm_read_arg_group(_args, as, &hw_argc, &ti->error)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 729 | return -EINVAL; |
| 730 | |
| 731 | if (!hw_argc) |
| 732 | return 0; |
| 733 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 734 | m->hw_handler_name = kstrdup(dm_shift_arg(as), GFP_KERNEL); |
Mike Snitzer | 510193a | 2012-05-12 01:43:21 +0100 | [diff] [blame] | 735 | if (!try_then_request_module(scsi_dh_handler_exist(m->hw_handler_name), |
| 736 | "scsi_dh_%s", m->hw_handler_name)) { |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 737 | ti->error = "unknown hardware handler type"; |
Chandra Seetharaman | 2bfd2e1 | 2009-08-03 12:42:45 -0700 | [diff] [blame] | 738 | ret = -EINVAL; |
| 739 | goto fail; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 740 | } |
Chandra Seetharaman | 14e98c5 | 2008-11-13 23:39:06 +0000 | [diff] [blame] | 741 | |
Chandra Seetharaman | 2bfd2e1 | 2009-08-03 12:42:45 -0700 | [diff] [blame] | 742 | if (hw_argc > 1) { |
| 743 | char *p; |
| 744 | int i, j, len = 4; |
| 745 | |
| 746 | for (i = 0; i <= hw_argc - 2; i++) |
| 747 | len += strlen(as->argv[i]) + 1; |
| 748 | p = m->hw_handler_params = kzalloc(len, GFP_KERNEL); |
| 749 | if (!p) { |
| 750 | ti->error = "memory allocation failed"; |
| 751 | ret = -ENOMEM; |
| 752 | goto fail; |
| 753 | } |
| 754 | j = sprintf(p, "%d", hw_argc - 1); |
| 755 | for (i = 0, p+=j+1; i <= hw_argc - 2; i++, p+=j+1) |
| 756 | j = sprintf(p, "%s", as->argv[i]); |
| 757 | } |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 758 | dm_consume_args(as, hw_argc - 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 759 | |
| 760 | return 0; |
Chandra Seetharaman | 2bfd2e1 | 2009-08-03 12:42:45 -0700 | [diff] [blame] | 761 | fail: |
| 762 | kfree(m->hw_handler_name); |
| 763 | m->hw_handler_name = NULL; |
| 764 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 765 | } |
| 766 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 767 | static int parse_features(struct dm_arg_set *as, struct multipath *m) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 768 | { |
| 769 | int r; |
| 770 | unsigned argc; |
Micha³ Miros³aw | 28f16c2 | 2006-10-03 01:15:33 -0700 | [diff] [blame] | 771 | struct dm_target *ti = m->ti; |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 772 | const char *arg_name; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 773 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 774 | static struct dm_arg _args[] = { |
Mike Snitzer | a58a935 | 2012-07-27 15:08:04 +0100 | [diff] [blame] | 775 | {0, 6, "invalid number of feature args"}, |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 776 | {1, 50, "pg_init_retries must be between 1 and 50"}, |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 777 | {0, 60000, "pg_init_delay_msecs must be between 0 and 60000"}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 778 | }; |
| 779 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 780 | r = dm_read_arg_group(_args, as, &argc, &ti->error); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 781 | if (r) |
| 782 | return -EINVAL; |
| 783 | |
| 784 | if (!argc) |
| 785 | return 0; |
| 786 | |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 787 | do { |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 788 | arg_name = dm_shift_arg(as); |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 789 | argc--; |
| 790 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 791 | if (!strcasecmp(arg_name, "queue_if_no_path")) { |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 792 | r = queue_if_no_path(m, 1, 0); |
| 793 | continue; |
| 794 | } |
| 795 | |
Mike Snitzer | a58a935 | 2012-07-27 15:08:04 +0100 | [diff] [blame] | 796 | if (!strcasecmp(arg_name, "retain_attached_hw_handler")) { |
| 797 | m->retain_attached_hw_handler = 1; |
| 798 | continue; |
| 799 | } |
| 800 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 801 | if (!strcasecmp(arg_name, "pg_init_retries") && |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 802 | (argc >= 1)) { |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 803 | r = dm_read_arg(_args + 1, as, &m->pg_init_retries, &ti->error); |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 804 | argc--; |
| 805 | continue; |
| 806 | } |
| 807 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 808 | if (!strcasecmp(arg_name, "pg_init_delay_msecs") && |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 809 | (argc >= 1)) { |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 810 | r = dm_read_arg(_args + 2, as, &m->pg_init_delay_msecs, &ti->error); |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 811 | argc--; |
| 812 | continue; |
| 813 | } |
| 814 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 815 | ti->error = "Unrecognised multipath feature request"; |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 816 | r = -EINVAL; |
| 817 | } while (argc && !r); |
| 818 | |
| 819 | return r; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 820 | } |
| 821 | |
| 822 | static int multipath_ctr(struct dm_target *ti, unsigned int argc, |
| 823 | char **argv) |
| 824 | { |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 825 | /* target arguments */ |
| 826 | static struct dm_arg _args[] = { |
Mike Snitzer | a490a07 | 2011-03-24 13:54:33 +0000 | [diff] [blame] | 827 | {0, 1024, "invalid number of priority groups"}, |
| 828 | {0, 1024, "invalid initial priority group number"}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 829 | }; |
| 830 | |
| 831 | int r; |
| 832 | struct multipath *m; |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 833 | struct dm_arg_set as; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 834 | unsigned pg_count = 0; |
| 835 | unsigned next_pg_num; |
| 836 | |
| 837 | as.argc = argc; |
| 838 | as.argv = argv; |
| 839 | |
Micha³ Miros³aw | 28f16c2 | 2006-10-03 01:15:33 -0700 | [diff] [blame] | 840 | m = alloc_multipath(ti); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 841 | if (!m) { |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 842 | ti->error = "can't allocate multipath"; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 843 | return -EINVAL; |
| 844 | } |
| 845 | |
Micha³ Miros³aw | 28f16c2 | 2006-10-03 01:15:33 -0700 | [diff] [blame] | 846 | r = parse_features(&as, m); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 847 | if (r) |
| 848 | goto bad; |
| 849 | |
Micha³ Miros³aw | 28f16c2 | 2006-10-03 01:15:33 -0700 | [diff] [blame] | 850 | r = parse_hw_handler(&as, m); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 851 | if (r) |
| 852 | goto bad; |
| 853 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 854 | r = dm_read_arg(_args, &as, &m->nr_priority_groups, &ti->error); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 855 | if (r) |
| 856 | goto bad; |
| 857 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 858 | r = dm_read_arg(_args + 1, &as, &next_pg_num, &ti->error); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 859 | if (r) |
| 860 | goto bad; |
| 861 | |
Mike Snitzer | a490a07 | 2011-03-24 13:54:33 +0000 | [diff] [blame] | 862 | if ((!m->nr_priority_groups && next_pg_num) || |
| 863 | (m->nr_priority_groups && !next_pg_num)) { |
| 864 | ti->error = "invalid initial priority group"; |
| 865 | r = -EINVAL; |
| 866 | goto bad; |
| 867 | } |
| 868 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 869 | /* parse the priority groups */ |
| 870 | while (as.argc) { |
| 871 | struct priority_group *pg; |
| 872 | |
Micha³ Miros³aw | 28f16c2 | 2006-10-03 01:15:33 -0700 | [diff] [blame] | 873 | pg = parse_priority_group(&as, m); |
Benjamin Marzinski | 01460f3 | 2008-10-10 13:36:57 +0100 | [diff] [blame] | 874 | if (IS_ERR(pg)) { |
| 875 | r = PTR_ERR(pg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 876 | goto bad; |
| 877 | } |
| 878 | |
| 879 | m->nr_valid_paths += pg->nr_pgpaths; |
| 880 | list_add_tail(&pg->list, &m->priority_groups); |
| 881 | pg_count++; |
| 882 | pg->pg_num = pg_count; |
| 883 | if (!--next_pg_num) |
| 884 | m->next_pg = pg; |
| 885 | } |
| 886 | |
| 887 | if (pg_count != m->nr_priority_groups) { |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 888 | ti->error = "priority group count mismatch"; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 889 | r = -EINVAL; |
| 890 | goto bad; |
| 891 | } |
| 892 | |
Alasdair G Kergon | 55a62ee | 2013-03-01 22:45:47 +0000 | [diff] [blame] | 893 | ti->num_flush_bios = 1; |
| 894 | ti->num_discard_bios = 1; |
Mike Snitzer | 042bcef | 2013-05-10 14:37:16 +0100 | [diff] [blame] | 895 | ti->num_write_same_bios = 1; |
Mikulas Patocka | 8627921 | 2009-06-22 10:12:24 +0100 | [diff] [blame] | 896 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 897 | return 0; |
| 898 | |
| 899 | bad: |
| 900 | free_multipath(m); |
| 901 | return r; |
| 902 | } |
| 903 | |
Kiyoshi Ueda | 2bded7b | 2010-03-06 02:32:13 +0000 | [diff] [blame] | 904 | static void multipath_wait_for_pg_init_completion(struct multipath *m) |
| 905 | { |
| 906 | DECLARE_WAITQUEUE(wait, current); |
| 907 | unsigned long flags; |
| 908 | |
| 909 | add_wait_queue(&m->pg_init_wait, &wait); |
| 910 | |
| 911 | while (1) { |
| 912 | set_current_state(TASK_UNINTERRUPTIBLE); |
| 913 | |
| 914 | spin_lock_irqsave(&m->lock, flags); |
| 915 | if (!m->pg_init_in_progress) { |
| 916 | spin_unlock_irqrestore(&m->lock, flags); |
| 917 | break; |
| 918 | } |
| 919 | spin_unlock_irqrestore(&m->lock, flags); |
| 920 | |
| 921 | io_schedule(); |
| 922 | } |
| 923 | set_current_state(TASK_RUNNING); |
| 924 | |
| 925 | remove_wait_queue(&m->pg_init_wait, &wait); |
| 926 | } |
| 927 | |
| 928 | static void flush_multipath_work(struct multipath *m) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 929 | { |
Shiva Krishna Merla | 954a73d | 2013-10-30 03:26:38 +0000 | [diff] [blame] | 930 | unsigned long flags; |
| 931 | |
| 932 | spin_lock_irqsave(&m->lock, flags); |
| 933 | m->pg_init_disabled = 1; |
| 934 | spin_unlock_irqrestore(&m->lock, flags); |
| 935 | |
Chandra Seetharaman | bab7cfc | 2008-05-01 14:50:22 -0700 | [diff] [blame] | 936 | flush_workqueue(kmpath_handlerd); |
Kiyoshi Ueda | 2bded7b | 2010-03-06 02:32:13 +0000 | [diff] [blame] | 937 | multipath_wait_for_pg_init_completion(m); |
Alasdair G Kergon | a044d01 | 2005-07-12 15:53:02 -0700 | [diff] [blame] | 938 | flush_workqueue(kmultipathd); |
Tejun Heo | 4382973 | 2012-08-20 14:51:24 -0700 | [diff] [blame] | 939 | flush_work(&m->trigger_event); |
Shiva Krishna Merla | 954a73d | 2013-10-30 03:26:38 +0000 | [diff] [blame] | 940 | |
| 941 | spin_lock_irqsave(&m->lock, flags); |
| 942 | m->pg_init_disabled = 0; |
| 943 | spin_unlock_irqrestore(&m->lock, flags); |
Kiyoshi Ueda | 6df400a | 2009-12-10 23:52:19 +0000 | [diff] [blame] | 944 | } |
| 945 | |
| 946 | static void multipath_dtr(struct dm_target *ti) |
| 947 | { |
| 948 | struct multipath *m = ti->private; |
| 949 | |
Kiyoshi Ueda | 2bded7b | 2010-03-06 02:32:13 +0000 | [diff] [blame] | 950 | flush_multipath_work(m); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 951 | free_multipath(m); |
| 952 | } |
| 953 | |
| 954 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 955 | * Take a path out of use. |
| 956 | */ |
| 957 | static int fail_path(struct pgpath *pgpath) |
| 958 | { |
| 959 | unsigned long flags; |
| 960 | struct multipath *m = pgpath->pg->m; |
| 961 | |
| 962 | spin_lock_irqsave(&m->lock, flags); |
| 963 | |
Kiyoshi Ueda | 6680073 | 2008-10-10 13:36:58 +0100 | [diff] [blame] | 964 | if (!pgpath->is_active) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 965 | goto out; |
| 966 | |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 967 | DMWARN("Failing path %s.", pgpath->path.dev->name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 968 | |
| 969 | pgpath->pg->ps.type->fail_path(&pgpath->pg->ps, &pgpath->path); |
Kiyoshi Ueda | 6680073 | 2008-10-10 13:36:58 +0100 | [diff] [blame] | 970 | pgpath->is_active = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 971 | pgpath->fail_count++; |
| 972 | |
| 973 | m->nr_valid_paths--; |
| 974 | |
| 975 | if (pgpath == m->current_pgpath) |
| 976 | m->current_pgpath = NULL; |
| 977 | |
Mike Anderson | b15546f | 2007-10-19 22:48:02 +0100 | [diff] [blame] | 978 | dm_path_uevent(DM_UEVENT_PATH_FAILED, m->ti, |
| 979 | pgpath->path.dev->name, m->nr_valid_paths); |
| 980 | |
Alasdair G Kergon | fe9cf30 | 2009-01-06 03:05:13 +0000 | [diff] [blame] | 981 | schedule_work(&m->trigger_event); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 982 | |
| 983 | out: |
| 984 | spin_unlock_irqrestore(&m->lock, flags); |
| 985 | |
| 986 | return 0; |
| 987 | } |
| 988 | |
| 989 | /* |
| 990 | * Reinstate a previously-failed path |
| 991 | */ |
| 992 | static int reinstate_path(struct pgpath *pgpath) |
| 993 | { |
Hannes Reinecke | 63d832c | 2014-05-26 14:45:39 +0200 | [diff] [blame] | 994 | int r = 0, run_queue = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 995 | unsigned long flags; |
| 996 | struct multipath *m = pgpath->pg->m; |
| 997 | |
| 998 | spin_lock_irqsave(&m->lock, flags); |
| 999 | |
Kiyoshi Ueda | 6680073 | 2008-10-10 13:36:58 +0100 | [diff] [blame] | 1000 | if (pgpath->is_active) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1001 | goto out; |
| 1002 | |
Alasdair G Kergon | def052d | 2008-07-21 12:00:31 +0100 | [diff] [blame] | 1003 | if (!pgpath->pg->ps.type->reinstate_path) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1004 | DMWARN("Reinstate path not supported by path selector %s", |
| 1005 | pgpath->pg->ps.type->name); |
| 1006 | r = -EINVAL; |
| 1007 | goto out; |
| 1008 | } |
| 1009 | |
| 1010 | r = pgpath->pg->ps.type->reinstate_path(&pgpath->pg->ps, &pgpath->path); |
| 1011 | if (r) |
| 1012 | goto out; |
| 1013 | |
Kiyoshi Ueda | 6680073 | 2008-10-10 13:36:58 +0100 | [diff] [blame] | 1014 | pgpath->is_active = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1015 | |
Hannes Reinecke | e809917 | 2014-02-28 15:33:44 +0100 | [diff] [blame] | 1016 | if (!m->nr_valid_paths++) { |
Chandra Seetharaman | e54f77d | 2009-06-22 10:12:12 +0100 | [diff] [blame] | 1017 | m->current_pgpath = NULL; |
Hannes Reinecke | 63d832c | 2014-05-26 14:45:39 +0200 | [diff] [blame] | 1018 | run_queue = 1; |
Chandra Seetharaman | e54f77d | 2009-06-22 10:12:12 +0100 | [diff] [blame] | 1019 | } else if (m->hw_handler_name && (m->current_pg == pgpath->pg)) { |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 1020 | if (queue_work(kmpath_handlerd, &pgpath->activate_path.work)) |
Chandra Seetharaman | e54f77d | 2009-06-22 10:12:12 +0100 | [diff] [blame] | 1021 | m->pg_init_in_progress++; |
| 1022 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1023 | |
Mike Anderson | b15546f | 2007-10-19 22:48:02 +0100 | [diff] [blame] | 1024 | dm_path_uevent(DM_UEVENT_PATH_REINSTATED, m->ti, |
| 1025 | pgpath->path.dev->name, m->nr_valid_paths); |
| 1026 | |
Alasdair G Kergon | fe9cf30 | 2009-01-06 03:05:13 +0000 | [diff] [blame] | 1027 | schedule_work(&m->trigger_event); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1028 | |
| 1029 | out: |
| 1030 | spin_unlock_irqrestore(&m->lock, flags); |
Hannes Reinecke | 63d832c | 2014-05-26 14:45:39 +0200 | [diff] [blame] | 1031 | if (run_queue) |
| 1032 | dm_table_run_md_queue_async(m->ti->table); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1033 | |
| 1034 | return r; |
| 1035 | } |
| 1036 | |
| 1037 | /* |
| 1038 | * Fail or reinstate all paths that match the provided struct dm_dev. |
| 1039 | */ |
| 1040 | static int action_dev(struct multipath *m, struct dm_dev *dev, |
| 1041 | action_fn action) |
| 1042 | { |
Mike Snitzer | 19040c0 | 2011-03-24 13:54:31 +0000 | [diff] [blame] | 1043 | int r = -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1044 | struct pgpath *pgpath; |
| 1045 | struct priority_group *pg; |
| 1046 | |
| 1047 | list_for_each_entry(pg, &m->priority_groups, list) { |
| 1048 | list_for_each_entry(pgpath, &pg->pgpaths, list) { |
| 1049 | if (pgpath->path.dev == dev) |
| 1050 | r = action(pgpath); |
| 1051 | } |
| 1052 | } |
| 1053 | |
| 1054 | return r; |
| 1055 | } |
| 1056 | |
| 1057 | /* |
| 1058 | * Temporarily try to avoid having to use the specified PG |
| 1059 | */ |
| 1060 | static void bypass_pg(struct multipath *m, struct priority_group *pg, |
| 1061 | int bypassed) |
| 1062 | { |
| 1063 | unsigned long flags; |
| 1064 | |
| 1065 | spin_lock_irqsave(&m->lock, flags); |
| 1066 | |
| 1067 | pg->bypassed = bypassed; |
| 1068 | m->current_pgpath = NULL; |
| 1069 | m->current_pg = NULL; |
| 1070 | |
| 1071 | spin_unlock_irqrestore(&m->lock, flags); |
| 1072 | |
Alasdair G Kergon | fe9cf30 | 2009-01-06 03:05:13 +0000 | [diff] [blame] | 1073 | schedule_work(&m->trigger_event); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1074 | } |
| 1075 | |
| 1076 | /* |
| 1077 | * Switch to using the specified PG from the next I/O that gets mapped |
| 1078 | */ |
| 1079 | static int switch_pg_num(struct multipath *m, const char *pgstr) |
| 1080 | { |
| 1081 | struct priority_group *pg; |
| 1082 | unsigned pgnum; |
| 1083 | unsigned long flags; |
Mikulas Patocka | 31998ef | 2012-03-28 18:41:26 +0100 | [diff] [blame] | 1084 | char dummy; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1085 | |
Mikulas Patocka | 31998ef | 2012-03-28 18:41:26 +0100 | [diff] [blame] | 1086 | if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum || |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1087 | (pgnum > m->nr_priority_groups)) { |
| 1088 | DMWARN("invalid PG number supplied to switch_pg_num"); |
| 1089 | return -EINVAL; |
| 1090 | } |
| 1091 | |
| 1092 | spin_lock_irqsave(&m->lock, flags); |
| 1093 | list_for_each_entry(pg, &m->priority_groups, list) { |
| 1094 | pg->bypassed = 0; |
| 1095 | if (--pgnum) |
| 1096 | continue; |
| 1097 | |
| 1098 | m->current_pgpath = NULL; |
| 1099 | m->current_pg = NULL; |
| 1100 | m->next_pg = pg; |
| 1101 | } |
| 1102 | spin_unlock_irqrestore(&m->lock, flags); |
| 1103 | |
Alasdair G Kergon | fe9cf30 | 2009-01-06 03:05:13 +0000 | [diff] [blame] | 1104 | schedule_work(&m->trigger_event); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1105 | return 0; |
| 1106 | } |
| 1107 | |
| 1108 | /* |
| 1109 | * Set/clear bypassed status of a PG. |
| 1110 | * PGs are numbered upwards from 1 in the order they were declared. |
| 1111 | */ |
| 1112 | static int bypass_pg_num(struct multipath *m, const char *pgstr, int bypassed) |
| 1113 | { |
| 1114 | struct priority_group *pg; |
| 1115 | unsigned pgnum; |
Mikulas Patocka | 31998ef | 2012-03-28 18:41:26 +0100 | [diff] [blame] | 1116 | char dummy; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1117 | |
Mikulas Patocka | 31998ef | 2012-03-28 18:41:26 +0100 | [diff] [blame] | 1118 | if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum || |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1119 | (pgnum > m->nr_priority_groups)) { |
| 1120 | DMWARN("invalid PG number supplied to bypass_pg"); |
| 1121 | return -EINVAL; |
| 1122 | } |
| 1123 | |
| 1124 | list_for_each_entry(pg, &m->priority_groups, list) { |
| 1125 | if (!--pgnum) |
| 1126 | break; |
| 1127 | } |
| 1128 | |
| 1129 | bypass_pg(m, pg, bypassed); |
| 1130 | return 0; |
| 1131 | } |
| 1132 | |
| 1133 | /* |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 1134 | * Should we retry pg_init immediately? |
| 1135 | */ |
| 1136 | static int pg_init_limit_reached(struct multipath *m, struct pgpath *pgpath) |
| 1137 | { |
| 1138 | unsigned long flags; |
| 1139 | int limit_reached = 0; |
| 1140 | |
| 1141 | spin_lock_irqsave(&m->lock, flags); |
| 1142 | |
Shiva Krishna Merla | 954a73d | 2013-10-30 03:26:38 +0000 | [diff] [blame] | 1143 | if (m->pg_init_count <= m->pg_init_retries && !m->pg_init_disabled) |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 1144 | m->pg_init_required = 1; |
| 1145 | else |
| 1146 | limit_reached = 1; |
| 1147 | |
| 1148 | spin_unlock_irqrestore(&m->lock, flags); |
| 1149 | |
| 1150 | return limit_reached; |
| 1151 | } |
| 1152 | |
Chandra Seetharaman | 3ae31f6 | 2009-10-21 09:22:46 -0700 | [diff] [blame] | 1153 | static void pg_init_done(void *data, int errors) |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1154 | { |
Moger, Babu | 83c0d5d | 2010-03-06 02:29:45 +0000 | [diff] [blame] | 1155 | struct pgpath *pgpath = data; |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1156 | struct priority_group *pg = pgpath->pg; |
| 1157 | struct multipath *m = pg->m; |
| 1158 | unsigned long flags; |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 1159 | unsigned delay_retry = 0; |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1160 | |
| 1161 | /* device or driver problems */ |
| 1162 | switch (errors) { |
| 1163 | case SCSI_DH_OK: |
| 1164 | break; |
| 1165 | case SCSI_DH_NOSYS: |
| 1166 | if (!m->hw_handler_name) { |
| 1167 | errors = 0; |
| 1168 | break; |
| 1169 | } |
Moger, Babu | f7b934c | 2010-03-06 02:29:49 +0000 | [diff] [blame] | 1170 | DMERR("Could not failover the device: Handler scsi_dh_%s " |
| 1171 | "Error %d.", m->hw_handler_name, errors); |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1172 | /* |
| 1173 | * Fail path for now, so we do not ping pong |
| 1174 | */ |
| 1175 | fail_path(pgpath); |
| 1176 | break; |
| 1177 | case SCSI_DH_DEV_TEMP_BUSY: |
| 1178 | /* |
| 1179 | * Probably doing something like FW upgrade on the |
| 1180 | * controller so try the other pg. |
| 1181 | */ |
| 1182 | bypass_pg(m, pg, 1); |
| 1183 | break; |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1184 | case SCSI_DH_RETRY: |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 1185 | /* Wait before retrying. */ |
| 1186 | delay_retry = 1; |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1187 | case SCSI_DH_IMM_RETRY: |
| 1188 | case SCSI_DH_RES_TEMP_UNAVAIL: |
| 1189 | if (pg_init_limit_reached(m, pgpath)) |
| 1190 | fail_path(pgpath); |
| 1191 | errors = 0; |
| 1192 | break; |
| 1193 | default: |
| 1194 | /* |
| 1195 | * We probably do not want to fail the path for a device |
| 1196 | * error, but this is what the old dm did. In future |
| 1197 | * patches we can do more advanced handling. |
| 1198 | */ |
| 1199 | fail_path(pgpath); |
| 1200 | } |
| 1201 | |
| 1202 | spin_lock_irqsave(&m->lock, flags); |
| 1203 | if (errors) { |
Chandra Seetharaman | e54f77d | 2009-06-22 10:12:12 +0100 | [diff] [blame] | 1204 | if (pgpath == m->current_pgpath) { |
| 1205 | DMERR("Could not failover device. Error %d.", errors); |
| 1206 | m->current_pgpath = NULL; |
| 1207 | m->current_pg = NULL; |
| 1208 | } |
Kiyoshi Ueda | d0259bf | 2010-03-06 02:30:02 +0000 | [diff] [blame] | 1209 | } else if (!m->pg_init_required) |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1210 | pg->bypassed = 0; |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1211 | |
Kiyoshi Ueda | d0259bf | 2010-03-06 02:30:02 +0000 | [diff] [blame] | 1212 | if (--m->pg_init_in_progress) |
| 1213 | /* Activations of other paths are still on going */ |
| 1214 | goto out; |
| 1215 | |
Hannes Reinecke | 3e9f1be | 2014-02-28 15:33:45 +0100 | [diff] [blame] | 1216 | if (m->pg_init_required) { |
| 1217 | m->pg_init_delay_retry = delay_retry; |
| 1218 | if (__pg_init_all_paths(m)) |
| 1219 | goto out; |
| 1220 | } |
| 1221 | m->queue_io = 0; |
Kiyoshi Ueda | d0259bf | 2010-03-06 02:30:02 +0000 | [diff] [blame] | 1222 | |
Kiyoshi Ueda | 2bded7b | 2010-03-06 02:32:13 +0000 | [diff] [blame] | 1223 | /* |
| 1224 | * Wake up any thread waiting to suspend. |
| 1225 | */ |
| 1226 | wake_up(&m->pg_init_wait); |
| 1227 | |
Kiyoshi Ueda | d0259bf | 2010-03-06 02:30:02 +0000 | [diff] [blame] | 1228 | out: |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1229 | spin_unlock_irqrestore(&m->lock, flags); |
| 1230 | } |
| 1231 | |
Chandra Seetharaman | bab7cfc | 2008-05-01 14:50:22 -0700 | [diff] [blame] | 1232 | static void activate_path(struct work_struct *work) |
| 1233 | { |
Chandra Seetharaman | e54f77d | 2009-06-22 10:12:12 +0100 | [diff] [blame] | 1234 | struct pgpath *pgpath = |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 1235 | container_of(work, struct pgpath, activate_path.work); |
Chandra Seetharaman | bab7cfc | 2008-05-01 14:50:22 -0700 | [diff] [blame] | 1236 | |
Hannes Reinecke | 3a01750 | 2014-02-28 15:33:49 +0100 | [diff] [blame] | 1237 | if (pgpath->is_active) |
| 1238 | scsi_dh_activate(bdev_get_queue(pgpath->path.dev->bdev), |
| 1239 | pg_init_done, pgpath); |
| 1240 | else |
| 1241 | pg_init_done(pgpath, SCSI_DH_DEV_OFFLINED); |
Chandra Seetharaman | bab7cfc | 2008-05-01 14:50:22 -0700 | [diff] [blame] | 1242 | } |
| 1243 | |
Hannes Reinecke | 7e782af | 2013-07-01 15:16:26 +0200 | [diff] [blame] | 1244 | static int noretry_error(int error) |
| 1245 | { |
| 1246 | switch (error) { |
| 1247 | case -EOPNOTSUPP: |
| 1248 | case -EREMOTEIO: |
| 1249 | case -EILSEQ: |
| 1250 | case -ENODATA: |
Jun'ichi Nomura | cc9d3c3 | 2013-09-13 14:54:30 +0900 | [diff] [blame] | 1251 | case -ENOSPC: |
Hannes Reinecke | 7e782af | 2013-07-01 15:16:26 +0200 | [diff] [blame] | 1252 | return 1; |
| 1253 | } |
| 1254 | |
| 1255 | /* Anything else could be a path failure, so should be retried */ |
| 1256 | return 0; |
| 1257 | } |
| 1258 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1259 | /* |
| 1260 | * end_io handling |
| 1261 | */ |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 1262 | static int do_end_io(struct multipath *m, struct request *clone, |
Alasdair G Kergon | 028867a | 2007-07-12 17:26:32 +0100 | [diff] [blame] | 1263 | int error, struct dm_mpath_io *mpio) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1264 | { |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 1265 | /* |
| 1266 | * We don't queue any clone request inside the multipath target |
| 1267 | * during end I/O handling, since those clone requests don't have |
| 1268 | * bio clones. If we queue them inside the multipath target, |
| 1269 | * we need to make bio clones, that requires memory allocation. |
| 1270 | * (See drivers/md/dm.c:end_clone_bio() about why the clone requests |
| 1271 | * don't have bio clones.) |
| 1272 | * Instead of queueing the clone request here, we queue the original |
| 1273 | * request into dm core, which will remake a clone request and |
| 1274 | * clone bios for it and resubmit it later. |
| 1275 | */ |
| 1276 | int r = DM_ENDIO_REQUEUE; |
Stefan Bader | 640eb3b | 2005-11-21 21:32:35 -0800 | [diff] [blame] | 1277 | unsigned long flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1278 | |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 1279 | if (!error && !clone->errors) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1280 | return 0; /* I/O complete */ |
| 1281 | |
Mike Snitzer | 7eee4ae | 2014-06-02 15:50:06 -0400 | [diff] [blame] | 1282 | if (noretry_error(error)) |
Mike Snitzer | 959eb4e | 2010-08-12 04:14:32 +0100 | [diff] [blame] | 1283 | return error; |
| 1284 | |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1285 | if (mpio->pgpath) |
| 1286 | fail_path(mpio->pgpath); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1287 | |
Stefan Bader | 640eb3b | 2005-11-21 21:32:35 -0800 | [diff] [blame] | 1288 | spin_lock_irqsave(&m->lock, flags); |
Hannes Reinecke | 751b2a7 | 2011-01-18 10:13:12 +0100 | [diff] [blame] | 1289 | if (!m->nr_valid_paths) { |
| 1290 | if (!m->queue_if_no_path) { |
| 1291 | if (!__must_push_back(m)) |
| 1292 | r = -EIO; |
| 1293 | } else { |
| 1294 | if (error == -EBADE) |
| 1295 | r = error; |
| 1296 | } |
| 1297 | } |
Stefan Bader | 640eb3b | 2005-11-21 21:32:35 -0800 | [diff] [blame] | 1298 | spin_unlock_irqrestore(&m->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1299 | |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 1300 | return r; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1301 | } |
| 1302 | |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 1303 | static int multipath_end_io(struct dm_target *ti, struct request *clone, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1304 | int error, union map_info *map_context) |
| 1305 | { |
Alasdair G Kergon | 028867a | 2007-07-12 17:26:32 +0100 | [diff] [blame] | 1306 | struct multipath *m = ti->private; |
| 1307 | struct dm_mpath_io *mpio = map_context->ptr; |
Wei Yongjun | a71a261 | 2012-10-12 16:59:42 +0100 | [diff] [blame] | 1308 | struct pgpath *pgpath; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1309 | struct path_selector *ps; |
| 1310 | int r; |
| 1311 | |
Jun'ichi Nomura | 466891f | 2012-03-28 18:41:25 +0100 | [diff] [blame] | 1312 | BUG_ON(!mpio); |
| 1313 | |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 1314 | r = do_end_io(m, clone, error, mpio); |
Wei Yongjun | a71a261 | 2012-10-12 16:59:42 +0100 | [diff] [blame] | 1315 | pgpath = mpio->pgpath; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1316 | if (pgpath) { |
| 1317 | ps = &pgpath->pg->ps; |
| 1318 | if (ps->type->end_io) |
Kiyoshi Ueda | 02ab823 | 2009-06-22 10:12:27 +0100 | [diff] [blame] | 1319 | ps->type->end_io(ps, &pgpath->path, mpio->nr_bytes); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1320 | } |
Jun'ichi Nomura | 466891f | 2012-03-28 18:41:25 +0100 | [diff] [blame] | 1321 | clear_mapinfo(m, map_context); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1322 | |
| 1323 | return r; |
| 1324 | } |
| 1325 | |
| 1326 | /* |
| 1327 | * Suspend can't complete until all the I/O is processed so if |
Alasdair G Kergon | 436d410 | 2005-07-12 15:53:03 -0700 | [diff] [blame] | 1328 | * the last path fails we must error any remaining I/O. |
| 1329 | * Note that if the freeze_bdev fails while suspending, the |
| 1330 | * queue_if_no_path state is lost - userspace should reset it. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1331 | */ |
| 1332 | static void multipath_presuspend(struct dm_target *ti) |
| 1333 | { |
| 1334 | struct multipath *m = (struct multipath *) ti->private; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1335 | |
Alasdair G Kergon | 485ef69 | 2005-09-27 21:45:45 -0700 | [diff] [blame] | 1336 | queue_if_no_path(m, 0, 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1337 | } |
| 1338 | |
Kiyoshi Ueda | 6df400a | 2009-12-10 23:52:19 +0000 | [diff] [blame] | 1339 | static void multipath_postsuspend(struct dm_target *ti) |
| 1340 | { |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1341 | struct multipath *m = ti->private; |
| 1342 | |
| 1343 | mutex_lock(&m->work_mutex); |
Kiyoshi Ueda | 2bded7b | 2010-03-06 02:32:13 +0000 | [diff] [blame] | 1344 | flush_multipath_work(m); |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1345 | mutex_unlock(&m->work_mutex); |
Kiyoshi Ueda | 6df400a | 2009-12-10 23:52:19 +0000 | [diff] [blame] | 1346 | } |
| 1347 | |
Alasdair G Kergon | 436d410 | 2005-07-12 15:53:03 -0700 | [diff] [blame] | 1348 | /* |
| 1349 | * Restore the queue_if_no_path setting. |
| 1350 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1351 | static void multipath_resume(struct dm_target *ti) |
| 1352 | { |
| 1353 | struct multipath *m = (struct multipath *) ti->private; |
| 1354 | unsigned long flags; |
| 1355 | |
| 1356 | spin_lock_irqsave(&m->lock, flags); |
Alasdair G Kergon | 436d410 | 2005-07-12 15:53:03 -0700 | [diff] [blame] | 1357 | m->queue_if_no_path = m->saved_queue_if_no_path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1358 | spin_unlock_irqrestore(&m->lock, flags); |
| 1359 | } |
| 1360 | |
| 1361 | /* |
| 1362 | * Info output has the following format: |
| 1363 | * num_multipath_feature_args [multipath_feature_args]* |
| 1364 | * num_handler_status_args [handler_status_args]* |
| 1365 | * num_groups init_group_number |
| 1366 | * [A|D|E num_ps_status_args [ps_status_args]* |
| 1367 | * num_paths num_selector_args |
| 1368 | * [path_dev A|F fail_count [selector_args]* ]+ ]+ |
| 1369 | * |
| 1370 | * Table output has the following format (identical to the constructor string): |
| 1371 | * num_feature_args [features_args]* |
| 1372 | * num_handler_args hw_handler [hw_handler_args]* |
| 1373 | * num_groups init_group_number |
| 1374 | * [priority selector-name num_ps_args [ps_args]* |
| 1375 | * num_paths num_selector_args [path_dev [selector_args]* ]+ ]+ |
| 1376 | */ |
Mikulas Patocka | fd7c092 | 2013-03-01 22:45:44 +0000 | [diff] [blame] | 1377 | static void multipath_status(struct dm_target *ti, status_type_t type, |
| 1378 | unsigned status_flags, char *result, unsigned maxlen) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1379 | { |
| 1380 | int sz = 0; |
| 1381 | unsigned long flags; |
| 1382 | struct multipath *m = (struct multipath *) ti->private; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1383 | struct priority_group *pg; |
| 1384 | struct pgpath *p; |
| 1385 | unsigned pg_num; |
| 1386 | char state; |
| 1387 | |
| 1388 | spin_lock_irqsave(&m->lock, flags); |
| 1389 | |
| 1390 | /* Features */ |
| 1391 | if (type == STATUSTYPE_INFO) |
Hannes Reinecke | e809917 | 2014-02-28 15:33:44 +0100 | [diff] [blame] | 1392 | DMEMIT("2 %u %u ", m->queue_io, m->pg_init_count); |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 1393 | else { |
| 1394 | DMEMIT("%u ", m->queue_if_no_path + |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 1395 | (m->pg_init_retries > 0) * 2 + |
Mike Snitzer | a58a935 | 2012-07-27 15:08:04 +0100 | [diff] [blame] | 1396 | (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT) * 2 + |
| 1397 | m->retain_attached_hw_handler); |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 1398 | if (m->queue_if_no_path) |
| 1399 | DMEMIT("queue_if_no_path "); |
| 1400 | if (m->pg_init_retries) |
| 1401 | DMEMIT("pg_init_retries %u ", m->pg_init_retries); |
Chandra Seetharaman | 4e2d19e | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 1402 | if (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT) |
| 1403 | DMEMIT("pg_init_delay_msecs %u ", m->pg_init_delay_msecs); |
Mike Snitzer | a58a935 | 2012-07-27 15:08:04 +0100 | [diff] [blame] | 1404 | if (m->retain_attached_hw_handler) |
| 1405 | DMEMIT("retain_attached_hw_handler "); |
Dave Wysochanski | c9e4558 | 2007-10-19 22:47:53 +0100 | [diff] [blame] | 1406 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1407 | |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1408 | if (!m->hw_handler_name || type == STATUSTYPE_INFO) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1409 | DMEMIT("0 "); |
| 1410 | else |
Chandra Seetharaman | cfae5c9 | 2008-05-01 14:50:11 -0700 | [diff] [blame] | 1411 | DMEMIT("1 %s ", m->hw_handler_name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1412 | |
| 1413 | DMEMIT("%u ", m->nr_priority_groups); |
| 1414 | |
| 1415 | if (m->next_pg) |
| 1416 | pg_num = m->next_pg->pg_num; |
| 1417 | else if (m->current_pg) |
| 1418 | pg_num = m->current_pg->pg_num; |
| 1419 | else |
Mike Snitzer | a490a07 | 2011-03-24 13:54:33 +0000 | [diff] [blame] | 1420 | pg_num = (m->nr_priority_groups ? 1 : 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1421 | |
| 1422 | DMEMIT("%u ", pg_num); |
| 1423 | |
| 1424 | switch (type) { |
| 1425 | case STATUSTYPE_INFO: |
| 1426 | list_for_each_entry(pg, &m->priority_groups, list) { |
| 1427 | if (pg->bypassed) |
| 1428 | state = 'D'; /* Disabled */ |
| 1429 | else if (pg == m->current_pg) |
| 1430 | state = 'A'; /* Currently Active */ |
| 1431 | else |
| 1432 | state = 'E'; /* Enabled */ |
| 1433 | |
| 1434 | DMEMIT("%c ", state); |
| 1435 | |
| 1436 | if (pg->ps.type->status) |
| 1437 | sz += pg->ps.type->status(&pg->ps, NULL, type, |
| 1438 | result + sz, |
| 1439 | maxlen - sz); |
| 1440 | else |
| 1441 | DMEMIT("0 "); |
| 1442 | |
| 1443 | DMEMIT("%u %u ", pg->nr_pgpaths, |
| 1444 | pg->ps.type->info_args); |
| 1445 | |
| 1446 | list_for_each_entry(p, &pg->pgpaths, list) { |
| 1447 | DMEMIT("%s %s %u ", p->path.dev->name, |
Kiyoshi Ueda | 6680073 | 2008-10-10 13:36:58 +0100 | [diff] [blame] | 1448 | p->is_active ? "A" : "F", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1449 | p->fail_count); |
| 1450 | if (pg->ps.type->status) |
| 1451 | sz += pg->ps.type->status(&pg->ps, |
| 1452 | &p->path, type, result + sz, |
| 1453 | maxlen - sz); |
| 1454 | } |
| 1455 | } |
| 1456 | break; |
| 1457 | |
| 1458 | case STATUSTYPE_TABLE: |
| 1459 | list_for_each_entry(pg, &m->priority_groups, list) { |
| 1460 | DMEMIT("%s ", pg->ps.type->name); |
| 1461 | |
| 1462 | if (pg->ps.type->status) |
| 1463 | sz += pg->ps.type->status(&pg->ps, NULL, type, |
| 1464 | result + sz, |
| 1465 | maxlen - sz); |
| 1466 | else |
| 1467 | DMEMIT("0 "); |
| 1468 | |
| 1469 | DMEMIT("%u %u ", pg->nr_pgpaths, |
| 1470 | pg->ps.type->table_args); |
| 1471 | |
| 1472 | list_for_each_entry(p, &pg->pgpaths, list) { |
| 1473 | DMEMIT("%s ", p->path.dev->name); |
| 1474 | if (pg->ps.type->status) |
| 1475 | sz += pg->ps.type->status(&pg->ps, |
| 1476 | &p->path, type, result + sz, |
| 1477 | maxlen - sz); |
| 1478 | } |
| 1479 | } |
| 1480 | break; |
| 1481 | } |
| 1482 | |
| 1483 | spin_unlock_irqrestore(&m->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1484 | } |
| 1485 | |
| 1486 | static int multipath_message(struct dm_target *ti, unsigned argc, char **argv) |
| 1487 | { |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1488 | int r = -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1489 | struct dm_dev *dev; |
| 1490 | struct multipath *m = (struct multipath *) ti->private; |
| 1491 | action_fn action; |
| 1492 | |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1493 | mutex_lock(&m->work_mutex); |
| 1494 | |
Kiyoshi Ueda | c2f3d24 | 2009-12-10 23:52:27 +0000 | [diff] [blame] | 1495 | if (dm_suspended(ti)) { |
| 1496 | r = -EBUSY; |
| 1497 | goto out; |
| 1498 | } |
| 1499 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1500 | if (argc == 1) { |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 1501 | if (!strcasecmp(argv[0], "queue_if_no_path")) { |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1502 | r = queue_if_no_path(m, 1, 0); |
| 1503 | goto out; |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 1504 | } else if (!strcasecmp(argv[0], "fail_if_no_path")) { |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1505 | r = queue_if_no_path(m, 0, 0); |
| 1506 | goto out; |
| 1507 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1508 | } |
| 1509 | |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1510 | if (argc != 2) { |
Jose Castillo | a356e42 | 2014-01-29 17:52:45 +0100 | [diff] [blame] | 1511 | DMWARN("Invalid multipath message arguments. Expected 2 arguments, got %d.", argc); |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1512 | goto out; |
| 1513 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1514 | |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 1515 | if (!strcasecmp(argv[0], "disable_group")) { |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1516 | r = bypass_pg_num(m, argv[1], 1); |
| 1517 | goto out; |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 1518 | } else if (!strcasecmp(argv[0], "enable_group")) { |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1519 | r = bypass_pg_num(m, argv[1], 0); |
| 1520 | goto out; |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 1521 | } else if (!strcasecmp(argv[0], "switch_group")) { |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1522 | r = switch_pg_num(m, argv[1]); |
| 1523 | goto out; |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 1524 | } else if (!strcasecmp(argv[0], "reinstate_path")) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1525 | action = reinstate_path; |
Mike Snitzer | 498f010 | 2011-08-02 12:32:04 +0100 | [diff] [blame] | 1526 | else if (!strcasecmp(argv[0], "fail_path")) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1527 | action = fail_path; |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1528 | else { |
Jose Castillo | a356e42 | 2014-01-29 17:52:45 +0100 | [diff] [blame] | 1529 | DMWARN("Unrecognised multipath message received: %s", argv[0]); |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1530 | goto out; |
| 1531 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1532 | |
Nikanth Karthikesan | 8215d6e | 2010-03-06 02:32:27 +0000 | [diff] [blame] | 1533 | r = dm_get_device(ti, argv[1], dm_table_get_mode(ti->table), &dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1534 | if (r) { |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 1535 | DMWARN("message: error getting device %s", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1536 | argv[1]); |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1537 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1538 | } |
| 1539 | |
| 1540 | r = action_dev(m, dev, action); |
| 1541 | |
| 1542 | dm_put_device(ti, dev); |
| 1543 | |
Mike Anderson | 6380f26 | 2009-12-10 23:52:21 +0000 | [diff] [blame] | 1544 | out: |
| 1545 | mutex_unlock(&m->work_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1546 | return r; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1547 | } |
| 1548 | |
Al Viro | 647b3d0 | 2007-08-28 22:15:59 -0400 | [diff] [blame] | 1549 | static int multipath_ioctl(struct dm_target *ti, unsigned int cmd, |
Milan Broz | 9af4aa3 | 2006-10-03 01:15:20 -0700 | [diff] [blame] | 1550 | unsigned long arg) |
| 1551 | { |
Mikulas Patocka | 3599165 | 2012-06-03 00:29:58 +0100 | [diff] [blame] | 1552 | struct multipath *m = ti->private; |
Mike Snitzer | 7ba10aa | 2012-09-26 23:45:41 +0100 | [diff] [blame] | 1553 | struct pgpath *pgpath; |
Mikulas Patocka | 3599165 | 2012-06-03 00:29:58 +0100 | [diff] [blame] | 1554 | struct block_device *bdev; |
| 1555 | fmode_t mode; |
Milan Broz | 9af4aa3 | 2006-10-03 01:15:20 -0700 | [diff] [blame] | 1556 | unsigned long flags; |
Mikulas Patocka | 3599165 | 2012-06-03 00:29:58 +0100 | [diff] [blame] | 1557 | int r; |
| 1558 | |
Mikulas Patocka | 3599165 | 2012-06-03 00:29:58 +0100 | [diff] [blame] | 1559 | bdev = NULL; |
| 1560 | mode = 0; |
| 1561 | r = 0; |
Milan Broz | 9af4aa3 | 2006-10-03 01:15:20 -0700 | [diff] [blame] | 1562 | |
| 1563 | spin_lock_irqsave(&m->lock, flags); |
| 1564 | |
| 1565 | if (!m->current_pgpath) |
Kiyoshi Ueda | 02ab823 | 2009-06-22 10:12:27 +0100 | [diff] [blame] | 1566 | __choose_pgpath(m, 0); |
Milan Broz | 9af4aa3 | 2006-10-03 01:15:20 -0700 | [diff] [blame] | 1567 | |
Mike Snitzer | 7ba10aa | 2012-09-26 23:45:41 +0100 | [diff] [blame] | 1568 | pgpath = m->current_pgpath; |
| 1569 | |
| 1570 | if (pgpath) { |
| 1571 | bdev = pgpath->path.dev->bdev; |
| 1572 | mode = pgpath->path.dev->mode; |
Milan Broz | e90dae1 | 2006-10-03 01:15:22 -0700 | [diff] [blame] | 1573 | } |
Milan Broz | 9af4aa3 | 2006-10-03 01:15:20 -0700 | [diff] [blame] | 1574 | |
Mike Snitzer | 7ba10aa | 2012-09-26 23:45:41 +0100 | [diff] [blame] | 1575 | if ((pgpath && m->queue_io) || (!pgpath && m->queue_if_no_path)) |
Hannes Reinecke | 6c182cd | 2013-07-10 23:41:15 +0100 | [diff] [blame] | 1576 | r = -ENOTCONN; |
Milan Broz | 9af4aa3 | 2006-10-03 01:15:20 -0700 | [diff] [blame] | 1577 | else if (!bdev) |
| 1578 | r = -EIO; |
| 1579 | |
| 1580 | spin_unlock_irqrestore(&m->lock, flags); |
| 1581 | |
Paolo Bonzini | ec8013b | 2012-01-12 16:01:29 +0100 | [diff] [blame] | 1582 | /* |
| 1583 | * Only pass ioctls through if the device sizes match exactly. |
| 1584 | */ |
Hannes Reinecke | a1989b3 | 2014-02-26 10:07:04 +0100 | [diff] [blame] | 1585 | if (!bdev || ti->len != i_size_read(bdev->bd_inode) >> SECTOR_SHIFT) { |
| 1586 | int err = scsi_verify_blk_ioctl(NULL, cmd); |
| 1587 | if (err) |
| 1588 | r = err; |
| 1589 | } |
Paolo Bonzini | ec8013b | 2012-01-12 16:01:29 +0100 | [diff] [blame] | 1590 | |
Hannes Reinecke | 3e9f1be | 2014-02-28 15:33:45 +0100 | [diff] [blame] | 1591 | if (r == -ENOTCONN && !fatal_signal_pending(current)) { |
| 1592 | spin_lock_irqsave(&m->lock, flags); |
| 1593 | if (!m->current_pg) { |
| 1594 | /* Path status changed, redo selection */ |
| 1595 | __choose_pgpath(m, 0); |
| 1596 | } |
| 1597 | if (m->pg_init_required) |
| 1598 | __pg_init_all_paths(m); |
Mike Snitzer | 4cdd2ad | 2014-05-13 13:49:39 -0400 | [diff] [blame] | 1599 | spin_unlock_irqrestore(&m->lock, flags); |
Hannes Reinecke | 63d832c | 2014-05-26 14:45:39 +0200 | [diff] [blame] | 1600 | dm_table_run_md_queue_async(m->ti->table); |
Hannes Reinecke | 3e9f1be | 2014-02-28 15:33:45 +0100 | [diff] [blame] | 1601 | } |
Mikulas Patocka | 3599165 | 2012-06-03 00:29:58 +0100 | [diff] [blame] | 1602 | |
Al Viro | 633a08b | 2007-08-29 20:34:12 -0400 | [diff] [blame] | 1603 | return r ? : __blkdev_driver_ioctl(bdev, mode, cmd, arg); |
Milan Broz | 9af4aa3 | 2006-10-03 01:15:20 -0700 | [diff] [blame] | 1604 | } |
| 1605 | |
Mike Snitzer | af4874e | 2009-06-22 10:12:33 +0100 | [diff] [blame] | 1606 | static int multipath_iterate_devices(struct dm_target *ti, |
| 1607 | iterate_devices_callout_fn fn, void *data) |
| 1608 | { |
| 1609 | struct multipath *m = ti->private; |
| 1610 | struct priority_group *pg; |
| 1611 | struct pgpath *p; |
| 1612 | int ret = 0; |
| 1613 | |
| 1614 | list_for_each_entry(pg, &m->priority_groups, list) { |
| 1615 | list_for_each_entry(p, &pg->pgpaths, list) { |
Mike Snitzer | 5dea271 | 2009-07-23 20:30:42 +0100 | [diff] [blame] | 1616 | ret = fn(ti, p->path.dev, ti->begin, ti->len, data); |
Mike Snitzer | af4874e | 2009-06-22 10:12:33 +0100 | [diff] [blame] | 1617 | if (ret) |
| 1618 | goto out; |
| 1619 | } |
| 1620 | } |
| 1621 | |
| 1622 | out: |
| 1623 | return ret; |
| 1624 | } |
| 1625 | |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 1626 | static int __pgpath_busy(struct pgpath *pgpath) |
| 1627 | { |
| 1628 | struct request_queue *q = bdev_get_queue(pgpath->path.dev->bdev); |
| 1629 | |
| 1630 | return dm_underlying_device_busy(q); |
| 1631 | } |
| 1632 | |
| 1633 | /* |
| 1634 | * We return "busy", only when we can map I/Os but underlying devices |
| 1635 | * are busy (so even if we map I/Os now, the I/Os will wait on |
| 1636 | * the underlying queue). |
| 1637 | * In other words, if we want to kill I/Os or queue them inside us |
| 1638 | * due to map unavailability, we don't return "busy". Otherwise, |
| 1639 | * dm core won't give us the I/Os and we can't do what we want. |
| 1640 | */ |
| 1641 | static int multipath_busy(struct dm_target *ti) |
| 1642 | { |
| 1643 | int busy = 0, has_active = 0; |
| 1644 | struct multipath *m = ti->private; |
| 1645 | struct priority_group *pg; |
| 1646 | struct pgpath *pgpath; |
| 1647 | unsigned long flags; |
| 1648 | |
| 1649 | spin_lock_irqsave(&m->lock, flags); |
| 1650 | |
Jun'ichi Nomura | 7a7a3b4 | 2014-07-08 00:55:14 +0000 | [diff] [blame] | 1651 | /* pg_init in progress or no paths available */ |
| 1652 | if (m->pg_init_in_progress || |
| 1653 | (!m->nr_valid_paths && m->queue_if_no_path)) { |
Hannes Reinecke | b63349a | 2013-10-01 11:49:56 +0200 | [diff] [blame] | 1654 | busy = 1; |
| 1655 | goto out; |
| 1656 | } |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 1657 | /* Guess which priority_group will be used at next mapping time */ |
| 1658 | if (unlikely(!m->current_pgpath && m->next_pg)) |
| 1659 | pg = m->next_pg; |
| 1660 | else if (likely(m->current_pg)) |
| 1661 | pg = m->current_pg; |
| 1662 | else |
| 1663 | /* |
| 1664 | * We don't know which pg will be used at next mapping time. |
| 1665 | * We don't call __choose_pgpath() here to avoid to trigger |
| 1666 | * pg_init just by busy checking. |
| 1667 | * So we don't know whether underlying devices we will be using |
| 1668 | * at next mapping time are busy or not. Just try mapping. |
| 1669 | */ |
| 1670 | goto out; |
| 1671 | |
| 1672 | /* |
| 1673 | * If there is one non-busy active path at least, the path selector |
| 1674 | * will be able to select it. So we consider such a pg as not busy. |
| 1675 | */ |
| 1676 | busy = 1; |
| 1677 | list_for_each_entry(pgpath, &pg->pgpaths, list) |
| 1678 | if (pgpath->is_active) { |
| 1679 | has_active = 1; |
| 1680 | |
| 1681 | if (!__pgpath_busy(pgpath)) { |
| 1682 | busy = 0; |
| 1683 | break; |
| 1684 | } |
| 1685 | } |
| 1686 | |
| 1687 | if (!has_active) |
| 1688 | /* |
| 1689 | * No active path in this pg, so this pg won't be used and |
| 1690 | * the current_pg will be changed at next mapping time. |
| 1691 | * We need to try mapping to determine it. |
| 1692 | */ |
| 1693 | busy = 0; |
| 1694 | |
| 1695 | out: |
| 1696 | spin_unlock_irqrestore(&m->lock, flags); |
| 1697 | |
| 1698 | return busy; |
| 1699 | } |
| 1700 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1701 | /*----------------------------------------------------------------- |
| 1702 | * Module setup |
| 1703 | *---------------------------------------------------------------*/ |
| 1704 | static struct target_type multipath_target = { |
| 1705 | .name = "multipath", |
Mike Snitzer | e5863d9 | 2014-12-17 21:08:12 -0500 | [diff] [blame] | 1706 | .version = {1, 8, 0}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1707 | .module = THIS_MODULE, |
| 1708 | .ctr = multipath_ctr, |
| 1709 | .dtr = multipath_dtr, |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 1710 | .map_rq = multipath_map, |
Mike Snitzer | e5863d9 | 2014-12-17 21:08:12 -0500 | [diff] [blame] | 1711 | .clone_and_map_rq = multipath_clone_and_map, |
| 1712 | .release_clone_rq = multipath_release_clone, |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 1713 | .rq_end_io = multipath_end_io, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1714 | .presuspend = multipath_presuspend, |
Kiyoshi Ueda | 6df400a | 2009-12-10 23:52:19 +0000 | [diff] [blame] | 1715 | .postsuspend = multipath_postsuspend, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1716 | .resume = multipath_resume, |
| 1717 | .status = multipath_status, |
| 1718 | .message = multipath_message, |
Milan Broz | 9af4aa3 | 2006-10-03 01:15:20 -0700 | [diff] [blame] | 1719 | .ioctl = multipath_ioctl, |
Mike Snitzer | af4874e | 2009-06-22 10:12:33 +0100 | [diff] [blame] | 1720 | .iterate_devices = multipath_iterate_devices, |
Kiyoshi Ueda | f40c67f | 2009-06-22 10:12:37 +0100 | [diff] [blame] | 1721 | .busy = multipath_busy, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1722 | }; |
| 1723 | |
| 1724 | static int __init dm_multipath_init(void) |
| 1725 | { |
| 1726 | int r; |
| 1727 | |
| 1728 | /* allocate a slab for the dm_ios */ |
Alasdair G Kergon | 028867a | 2007-07-12 17:26:32 +0100 | [diff] [blame] | 1729 | _mpio_cache = KMEM_CACHE(dm_mpath_io, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1730 | if (!_mpio_cache) |
| 1731 | return -ENOMEM; |
| 1732 | |
| 1733 | r = dm_register_target(&multipath_target); |
| 1734 | if (r < 0) { |
Alasdair G Kergon | 0cd3312 | 2007-07-12 17:27:01 +0100 | [diff] [blame] | 1735 | DMERR("register failed %d", r); |
Johannes Thumshirn | ff658e9 | 2015-01-11 12:45:23 +0100 | [diff] [blame] | 1736 | r = -EINVAL; |
| 1737 | goto bad_register_target; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1738 | } |
| 1739 | |
Tejun Heo | 4d4d66a | 2011-01-13 19:59:57 +0000 | [diff] [blame] | 1740 | kmultipathd = alloc_workqueue("kmpathd", WQ_MEM_RECLAIM, 0); |
Alasdair G Kergon | c557308 | 2005-05-05 16:16:07 -0700 | [diff] [blame] | 1741 | if (!kmultipathd) { |
Alasdair G Kergon | 0cd3312 | 2007-07-12 17:27:01 +0100 | [diff] [blame] | 1742 | DMERR("failed to create workqueue kmpathd"); |
Johannes Thumshirn | ff658e9 | 2015-01-11 12:45:23 +0100 | [diff] [blame] | 1743 | r = -ENOMEM; |
| 1744 | goto bad_alloc_kmultipathd; |
Alasdair G Kergon | c557308 | 2005-05-05 16:16:07 -0700 | [diff] [blame] | 1745 | } |
| 1746 | |
Chandra Seetharaman | bab7cfc | 2008-05-01 14:50:22 -0700 | [diff] [blame] | 1747 | /* |
| 1748 | * A separate workqueue is used to handle the device handlers |
| 1749 | * to avoid overloading existing workqueue. Overloading the |
| 1750 | * old workqueue would also create a bottleneck in the |
| 1751 | * path of the storage hardware device activation. |
| 1752 | */ |
Tejun Heo | 4d4d66a | 2011-01-13 19:59:57 +0000 | [diff] [blame] | 1753 | kmpath_handlerd = alloc_ordered_workqueue("kmpath_handlerd", |
| 1754 | WQ_MEM_RECLAIM); |
Chandra Seetharaman | bab7cfc | 2008-05-01 14:50:22 -0700 | [diff] [blame] | 1755 | if (!kmpath_handlerd) { |
| 1756 | DMERR("failed to create workqueue kmpath_handlerd"); |
Johannes Thumshirn | ff658e9 | 2015-01-11 12:45:23 +0100 | [diff] [blame] | 1757 | r = -ENOMEM; |
| 1758 | goto bad_alloc_kmpath_handlerd; |
Chandra Seetharaman | bab7cfc | 2008-05-01 14:50:22 -0700 | [diff] [blame] | 1759 | } |
| 1760 | |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 1761 | DMINFO("version %u.%u.%u loaded", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1762 | multipath_target.version[0], multipath_target.version[1], |
| 1763 | multipath_target.version[2]); |
| 1764 | |
Johannes Thumshirn | ff658e9 | 2015-01-11 12:45:23 +0100 | [diff] [blame] | 1765 | return 0; |
| 1766 | |
| 1767 | bad_alloc_kmpath_handlerd: |
| 1768 | destroy_workqueue(kmultipathd); |
| 1769 | bad_alloc_kmultipathd: |
| 1770 | dm_unregister_target(&multipath_target); |
| 1771 | bad_register_target: |
| 1772 | kmem_cache_destroy(_mpio_cache); |
| 1773 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1774 | return r; |
| 1775 | } |
| 1776 | |
| 1777 | static void __exit dm_multipath_exit(void) |
| 1778 | { |
Chandra Seetharaman | bab7cfc | 2008-05-01 14:50:22 -0700 | [diff] [blame] | 1779 | destroy_workqueue(kmpath_handlerd); |
Alasdair G Kergon | c557308 | 2005-05-05 16:16:07 -0700 | [diff] [blame] | 1780 | destroy_workqueue(kmultipathd); |
| 1781 | |
Mikulas Patocka | 10d3bd0 | 2009-01-06 03:04:58 +0000 | [diff] [blame] | 1782 | dm_unregister_target(&multipath_target); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1783 | kmem_cache_destroy(_mpio_cache); |
| 1784 | } |
| 1785 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1786 | module_init(dm_multipath_init); |
| 1787 | module_exit(dm_multipath_exit); |
| 1788 | |
| 1789 | MODULE_DESCRIPTION(DM_NAME " multipath target"); |
| 1790 | MODULE_AUTHOR("Sistina Software <dm-devel@redhat.com>"); |
| 1791 | MODULE_LICENSE("GPL"); |