blob: 7b6b0f0f831a443b0bd947628bca643b821c8b95 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 Patocka586e80e2008-10-21 17:44:59 +01008#include <linux/device-mapper.h>
9
Mike Snitzerf4790822013-09-12 18:06:12 -040010#include "dm.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include "dm-path-selector.h"
Mike Andersonb15546f2007-10-19 22:48:02 +010012#include "dm-uevent.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070013
14#include <linux/ctype.h>
15#include <linux/init.h>
16#include <linux/mempool.h>
17#include <linux/module.h>
18#include <linux/pagemap.h>
19#include <linux/slab.h>
20#include <linux/time.h>
21#include <linux/workqueue.h>
Mikulas Patocka35991652012-06-03 00:29:58 +010022#include <linux/delay.h>
Chandra Seetharamancfae5c92008-05-01 14:50:11 -070023#include <scsi/scsi_dh.h>
Arun Sharma600634972011-07-26 16:09:06 -070024#include <linux/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
Alasdair G Kergon72d94862006-06-26 00:27:35 -070026#define DM_MSG_PREFIX "multipath"
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +000027#define DM_PG_INIT_DELAY_MSECS 2000
28#define DM_PG_INIT_DELAY_DEFAULT ((unsigned) -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30/* Path properties */
31struct pgpath {
32 struct list_head list;
33
34 struct priority_group *pg; /* Owning PG */
Kiyoshi Ueda66800732008-10-10 13:36:58 +010035 unsigned is_active; /* Path status */
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 unsigned fail_count; /* Cumulative failure count */
37
Josef "Jeff" Sipekc922d5f2006-12-08 02:36:33 -080038 struct dm_path path;
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +000039 struct delayed_work activate_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040};
41
42#define path_to_pgpath(__pgp) container_of((__pgp), struct pgpath, path)
43
44/*
45 * Paths are grouped into Priority Groups and numbered from 1 upwards.
46 * Each has a path selector which controls which path gets used.
47 */
48struct priority_group {
49 struct list_head list;
50
51 struct multipath *m; /* Owning multipath instance */
52 struct path_selector ps;
53
54 unsigned pg_num; /* Reference number */
55 unsigned bypassed; /* Temporarily bypass this PG? */
56
57 unsigned nr_pgpaths; /* Number of paths in PG */
58 struct list_head pgpaths;
59};
60
61/* Multipath context */
62struct multipath {
63 struct list_head list;
64 struct dm_target *ti;
65
Chandra Seetharamancfae5c92008-05-01 14:50:11 -070066 const char *hw_handler_name;
Chandra Seetharaman2bfd2e12009-08-03 12:42:45 -070067 char *hw_handler_params;
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +000068
Mike Snitzer1fbdd2b2012-06-03 00:29:43 +010069 spinlock_t lock;
70
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 unsigned nr_priority_groups;
72 struct list_head priority_groups;
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +000073
74 wait_queue_head_t pg_init_wait; /* Wait for pg_init completion */
75
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 unsigned pg_init_required; /* pg_init needs calling? */
Alasdair G Kergonc3cd4f62005-07-12 15:53:04 -070077 unsigned pg_init_in_progress; /* Only one pg_init allowed at once */
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +000078 unsigned pg_init_delay_retry; /* Delay pg_init retry? */
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80 unsigned nr_valid_paths; /* Total number of usable paths */
81 struct pgpath *current_pgpath;
82 struct priority_group *current_pg;
83 struct priority_group *next_pg; /* Switch to this PG if set */
84 unsigned repeat_count; /* I/Os left before calling PS again */
85
Mike Snitzer1fbdd2b2012-06-03 00:29:43 +010086 unsigned queue_io:1; /* Must we queue all I/O? */
87 unsigned queue_if_no_path:1; /* Queue I/O if last path fails? */
88 unsigned saved_queue_if_no_path:1; /* Saved state during suspension */
Mike Snitzera58a9352012-07-27 15:08:04 +010089 unsigned retain_attached_hw_handler:1; /* If there's already a hw_handler present, don't change it. */
Shiva Krishna Merla954a73d2013-10-30 03:26:38 +000090 unsigned pg_init_disabled:1; /* pg_init is not currently allowed */
Mike Snitzer1fbdd2b2012-06-03 00:29:43 +010091
Dave Wysochanskic9e45582007-10-19 22:47:53 +010092 unsigned pg_init_retries; /* Number of times to retry pg_init */
93 unsigned pg_init_count; /* Number of times pg_init called */
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +000094 unsigned pg_init_delay_msecs; /* Number of msecs before pg_init retry */
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 struct work_struct trigger_event;
97
98 /*
Alasdair G Kergon028867a2007-07-12 17:26:32 +010099 * We must use a mempool of dm_mpath_io structs so that we
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 * can resubmit bios on error.
101 */
102 mempool_t *mpio_pool;
Mike Anderson6380f262009-12-10 23:52:21 +0000103
104 struct mutex work_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105};
106
107/*
108 * Context information attached to each bio we process.
109 */
Alasdair G Kergon028867a2007-07-12 17:26:32 +0100110struct dm_mpath_io {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 struct pgpath *pgpath;
Kiyoshi Ueda02ab8232009-06-22 10:12:27 +0100112 size_t nr_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113};
114
115typedef int (*action_fn) (struct pgpath *pgpath);
116
Christoph Lametere18b8902006-12-06 20:33:20 -0800117static struct kmem_cache *_mpio_cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
Chandra Seetharamanbab7cfc2008-05-01 14:50:22 -0700119static struct workqueue_struct *kmultipathd, *kmpath_handlerd;
David Howellsc4028952006-11-22 14:57:56 +0000120static void trigger_event(struct work_struct *work);
Chandra Seetharamanbab7cfc2008-05-01 14:50:22 -0700121static void activate_path(struct work_struct *work);
Hannes Reineckee8099172014-02-28 15:33:44 +0100122static int __pgpath_busy(struct pgpath *pgpath);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124
125/*-----------------------------------------------
126 * Allocation routines
127 *-----------------------------------------------*/
128
129static struct pgpath *alloc_pgpath(void)
130{
Micha³ Miros³awe69fae52006-10-03 01:15:34 -0700131 struct pgpath *pgpath = kzalloc(sizeof(*pgpath), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Mike Anderson224cb3e2008-08-29 09:36:09 +0200133 if (pgpath) {
Kiyoshi Ueda66800732008-10-10 13:36:58 +0100134 pgpath->is_active = 1;
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +0000135 INIT_DELAYED_WORK(&pgpath->activate_path, activate_path);
Mike Anderson224cb3e2008-08-29 09:36:09 +0200136 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
138 return pgpath;
139}
140
Alasdair G Kergon028867a2007-07-12 17:26:32 +0100141static void free_pgpath(struct pgpath *pgpath)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142{
143 kfree(pgpath);
144}
145
146static struct priority_group *alloc_priority_group(void)
147{
148 struct priority_group *pg;
149
Micha³ Miros³awe69fae52006-10-03 01:15:34 -0700150 pg = kzalloc(sizeof(*pg), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
Micha³ Miros³awe69fae52006-10-03 01:15:34 -0700152 if (pg)
153 INIT_LIST_HEAD(&pg->pgpaths);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155 return pg;
156}
157
158static void free_pgpaths(struct list_head *pgpaths, struct dm_target *ti)
159{
160 struct pgpath *pgpath, *tmp;
Hannes Reineckeae11b1b2008-07-17 17:49:02 -0700161 struct multipath *m = ti->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
163 list_for_each_entry_safe(pgpath, tmp, pgpaths, list) {
164 list_del(&pgpath->list);
Hannes Reineckeae11b1b2008-07-17 17:49:02 -0700165 if (m->hw_handler_name)
166 scsi_dh_detach(bdev_get_queue(pgpath->path.dev->bdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 dm_put_device(ti, pgpath->path.dev);
168 free_pgpath(pgpath);
169 }
170}
171
172static void free_priority_group(struct priority_group *pg,
173 struct dm_target *ti)
174{
175 struct path_selector *ps = &pg->ps;
176
177 if (ps->type) {
178 ps->type->destroy(ps);
179 dm_put_path_selector(ps->type);
180 }
181
182 free_pgpaths(&pg->pgpaths, ti);
183 kfree(pg);
184}
185
Micha³ Miros³aw28f16c22006-10-03 01:15:33 -0700186static struct multipath *alloc_multipath(struct dm_target *ti)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187{
188 struct multipath *m;
Mike Snitzerf4790822013-09-12 18:06:12 -0400189 unsigned min_ios = dm_get_reserved_rq_based_ios();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
Micha³ Miros³awe69fae52006-10-03 01:15:34 -0700191 m = kzalloc(sizeof(*m), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 if (m) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 INIT_LIST_HEAD(&m->priority_groups);
194 spin_lock_init(&m->lock);
195 m->queue_io = 1;
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +0000196 m->pg_init_delay_msecs = DM_PG_INIT_DELAY_DEFAULT;
David Howellsc4028952006-11-22 14:57:56 +0000197 INIT_WORK(&m->trigger_event, trigger_event);
Kiyoshi Ueda2bded7b2010-03-06 02:32:13 +0000198 init_waitqueue_head(&m->pg_init_wait);
Mike Anderson6380f262009-12-10 23:52:21 +0000199 mutex_init(&m->work_mutex);
Mike Snitzerf4790822013-09-12 18:06:12 -0400200 m->mpio_pool = mempool_create_slab_pool(min_ios, _mpio_cache);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 if (!m->mpio_pool) {
202 kfree(m);
203 return NULL;
204 }
Micha³ Miros³aw28f16c22006-10-03 01:15:33 -0700205 m->ti = ti;
206 ti->private = m;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 }
208
209 return m;
210}
211
212static void free_multipath(struct multipath *m)
213{
214 struct priority_group *pg, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
216 list_for_each_entry_safe(pg, tmp, &m->priority_groups, list) {
217 list_del(&pg->list);
218 free_priority_group(pg, m->ti);
219 }
220
Chandra Seetharamancfae5c92008-05-01 14:50:11 -0700221 kfree(m->hw_handler_name);
Chandra Seetharaman2bfd2e12009-08-03 12:42:45 -0700222 kfree(m->hw_handler_params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 mempool_destroy(m->mpio_pool);
224 kfree(m);
225}
226
Jun'ichi Nomura466891f2012-03-28 18:41:25 +0100227static int set_mapinfo(struct multipath *m, union map_info *info)
228{
229 struct dm_mpath_io *mpio;
230
231 mpio = mempool_alloc(m->mpio_pool, GFP_ATOMIC);
232 if (!mpio)
233 return -ENOMEM;
234
235 memset(mpio, 0, sizeof(*mpio));
236 info->ptr = mpio;
237
238 return 0;
239}
240
241static void clear_mapinfo(struct multipath *m, union map_info *info)
242{
243 struct dm_mpath_io *mpio = info->ptr;
244
245 info->ptr = NULL;
246 mempool_free(mpio, m->mpio_pool);
247}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
249/*-----------------------------------------------
250 * Path selection
251 *-----------------------------------------------*/
252
Hannes Reinecke3e9f1be2014-02-28 15:33:45 +0100253static int __pg_init_all_paths(struct multipath *m)
Kiyoshi Uedafb612642010-03-06 02:32:18 +0000254{
255 struct pgpath *pgpath;
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +0000256 unsigned long pg_init_delay = 0;
Kiyoshi Uedafb612642010-03-06 02:32:18 +0000257
Hannes Reinecke17f4ff42014-02-28 15:33:42 +0100258 if (m->pg_init_in_progress || m->pg_init_disabled)
Hannes Reinecke3e9f1be2014-02-28 15:33:45 +0100259 return 0;
Hannes Reinecke17f4ff42014-02-28 15:33:42 +0100260
Kiyoshi Uedafb612642010-03-06 02:32:18 +0000261 m->pg_init_count++;
262 m->pg_init_required = 0;
Hannes Reinecke3e9f1be2014-02-28 15:33:45 +0100263
264 /* Check here to reset pg_init_required */
265 if (!m->current_pg)
266 return 0;
267
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +0000268 if (m->pg_init_delay_retry)
269 pg_init_delay = msecs_to_jiffies(m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT ?
270 m->pg_init_delay_msecs : DM_PG_INIT_DELAY_MSECS);
Kiyoshi Uedafb612642010-03-06 02:32:18 +0000271 list_for_each_entry(pgpath, &m->current_pg->pgpaths, list) {
272 /* Skip failed paths */
273 if (!pgpath->is_active)
274 continue;
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +0000275 if (queue_delayed_work(kmpath_handlerd, &pgpath->activate_path,
276 pg_init_delay))
Kiyoshi Uedafb612642010-03-06 02:32:18 +0000277 m->pg_init_in_progress++;
278 }
Hannes Reinecke3e9f1be2014-02-28 15:33:45 +0100279 return m->pg_init_in_progress;
Kiyoshi Uedafb612642010-03-06 02:32:18 +0000280}
281
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282static void __switch_pg(struct multipath *m, struct pgpath *pgpath)
283{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 m->current_pg = pgpath->pg;
285
286 /* Must we initialise the PG first, and queue I/O till it's ready? */
Chandra Seetharamancfae5c92008-05-01 14:50:11 -0700287 if (m->hw_handler_name) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 m->pg_init_required = 1;
289 m->queue_io = 1;
290 } else {
291 m->pg_init_required = 0;
292 m->queue_io = 0;
293 }
Dave Wysochanskic9e45582007-10-19 22:47:53 +0100294
295 m->pg_init_count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296}
297
Kiyoshi Ueda02ab8232009-06-22 10:12:27 +0100298static int __choose_path_in_pg(struct multipath *m, struct priority_group *pg,
299 size_t nr_bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300{
Josef "Jeff" Sipekc922d5f2006-12-08 02:36:33 -0800301 struct dm_path *path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Kiyoshi Ueda02ab8232009-06-22 10:12:27 +0100303 path = pg->ps.type->select_path(&pg->ps, &m->repeat_count, nr_bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 if (!path)
305 return -ENXIO;
306
307 m->current_pgpath = path_to_pgpath(path);
308
309 if (m->current_pg != pg)
310 __switch_pg(m, m->current_pgpath);
311
312 return 0;
313}
314
Kiyoshi Ueda02ab8232009-06-22 10:12:27 +0100315static void __choose_pgpath(struct multipath *m, size_t nr_bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316{
317 struct priority_group *pg;
318 unsigned bypassed = 1;
319
Benjamin Marzinski1f271972014-08-13 13:53:42 -0500320 if (!m->nr_valid_paths) {
321 m->queue_io = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 goto failed;
Benjamin Marzinski1f271972014-08-13 13:53:42 -0500323 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
325 /* Were we instructed to switch PG? */
326 if (m->next_pg) {
327 pg = m->next_pg;
328 m->next_pg = NULL;
Kiyoshi Ueda02ab8232009-06-22 10:12:27 +0100329 if (!__choose_path_in_pg(m, pg, nr_bytes))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 return;
331 }
332
333 /* Don't change PG until it has no remaining paths */
Kiyoshi Ueda02ab8232009-06-22 10:12:27 +0100334 if (m->current_pg && !__choose_path_in_pg(m, m->current_pg, nr_bytes))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 return;
336
337 /*
338 * Loop through priority groups until we find a valid path.
339 * First time we skip PGs marked 'bypassed'.
Mike Christief220fd42012-06-03 00:29:45 +0100340 * Second time we only try the ones we skipped, but set
341 * pg_init_delay_retry so we do not hammer controllers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 */
343 do {
344 list_for_each_entry(pg, &m->priority_groups, list) {
345 if (pg->bypassed == bypassed)
346 continue;
Mike Christief220fd42012-06-03 00:29:45 +0100347 if (!__choose_path_in_pg(m, pg, nr_bytes)) {
348 if (!bypassed)
349 m->pg_init_delay_retry = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 return;
Mike Christief220fd42012-06-03 00:29:45 +0100351 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 }
353 } while (bypassed--);
354
355failed:
356 m->current_pgpath = NULL;
357 m->current_pg = NULL;
358}
359
Kiyoshi Ueda45e15722006-12-08 02:41:10 -0800360/*
361 * Check whether bios must be queued in the device-mapper core rather
362 * than here in the target.
363 *
364 * m->lock must be held on entry.
365 *
366 * If m->queue_if_no_path and m->saved_queue_if_no_path hold the
367 * same value then we are not between multipath_presuspend()
368 * and multipath_resume() calls and we have no need to check
369 * for the DMF_NOFLUSH_SUSPENDING flag.
370 */
371static int __must_push_back(struct multipath *m)
372{
Hannes Reineckee8099172014-02-28 15:33:44 +0100373 return (m->queue_if_no_path ||
374 (m->queue_if_no_path != m->saved_queue_if_no_path &&
375 dm_noflush_suspending(m->ti)));
Kiyoshi Ueda45e15722006-12-08 02:41:10 -0800376}
377
Hannes Reinecke36fcffc2014-02-28 15:33:47 +0100378/*
379 * Map cloned requests
380 */
381static int multipath_map(struct dm_target *ti, struct request *clone,
382 union map_info *map_context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383{
Hannes Reinecke36fcffc2014-02-28 15:33:47 +0100384 struct multipath *m = (struct multipath *) ti->private;
Hannes Reineckee3bde042014-02-28 15:33:46 +0100385 int r = DM_MAPIO_REQUEUE;
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +0100386 size_t nr_bytes = blk_rq_bytes(clone);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 unsigned long flags;
388 struct pgpath *pgpath;
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +0100389 struct block_device *bdev;
Hannes Reineckee3bde042014-02-28 15:33:46 +0100390 struct dm_mpath_io *mpio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
392 spin_lock_irqsave(&m->lock, flags);
393
394 /* Do we need to select a new pgpath? */
395 if (!m->current_pgpath ||
396 (!m->queue_io && (m->repeat_count && --m->repeat_count == 0)))
Kiyoshi Ueda02ab8232009-06-22 10:12:27 +0100397 __choose_pgpath(m, nr_bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
399 pgpath = m->current_pgpath;
400
Mike Snitzer9bf59a62014-02-28 15:33:48 +0100401 if (!pgpath) {
402 if (!__must_push_back(m))
403 r = -EIO; /* Failed */
404 goto out_unlock;
Mike Snitzer6afbc012014-07-08 11:55:09 -0400405 } else if (m->queue_io || m->pg_init_required) {
Hannes Reineckee3bde042014-02-28 15:33:46 +0100406 __pg_init_all_paths(m);
Mike Snitzer9bf59a62014-02-28 15:33:48 +0100407 goto out_unlock;
408 }
Mike Snitzer6afbc012014-07-08 11:55:09 -0400409
Mike Snitzer9bf59a62014-02-28 15:33:48 +0100410 if (set_mapinfo(m, map_context) < 0)
411 /* ENOMEM, requeue */
412 goto out_unlock;
413
414 bdev = pgpath->path.dev->bdev;
415 clone->q = bdev_get_queue(bdev);
416 clone->rq_disk = bdev->bd_disk;
417 clone->cmd_flags |= REQ_FAILFAST_TRANSPORT;
418 mpio = map_context->ptr;
419 mpio->pgpath = pgpath;
420 mpio->nr_bytes = nr_bytes;
421 if (pgpath->pg->ps.type->start_io)
422 pgpath->pg->ps.type->start_io(&pgpath->pg->ps,
423 &pgpath->path,
424 nr_bytes);
425 r = DM_MAPIO_REMAPPED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
Hannes Reineckee3bde042014-02-28 15:33:46 +0100427out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 spin_unlock_irqrestore(&m->lock, flags);
429
430 return r;
431}
432
433/*
434 * If we run out of usable paths, should we queue I/O or error it?
435 */
Alasdair G Kergon485ef692005-09-27 21:45:45 -0700436static int queue_if_no_path(struct multipath *m, unsigned queue_if_no_path,
437 unsigned save_old_value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
439 unsigned long flags;
440
441 spin_lock_irqsave(&m->lock, flags);
442
Alasdair G Kergon485ef692005-09-27 21:45:45 -0700443 if (save_old_value)
444 m->saved_queue_if_no_path = m->queue_if_no_path;
445 else
446 m->saved_queue_if_no_path = queue_if_no_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 m->queue_if_no_path = queue_if_no_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 spin_unlock_irqrestore(&m->lock, flags);
449
Hannes Reinecke63d832c2014-05-26 14:45:39 +0200450 if (!queue_if_no_path)
451 dm_table_run_md_queue_async(m->ti->table);
452
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return 0;
454}
455
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456/*
457 * An event is triggered whenever a path is taken out of use.
458 * Includes path failure and PG bypass.
459 */
David Howellsc4028952006-11-22 14:57:56 +0000460static void trigger_event(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461{
David Howellsc4028952006-11-22 14:57:56 +0000462 struct multipath *m =
463 container_of(work, struct multipath, trigger_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465 dm_table_event(m->ti->table);
466}
467
468/*-----------------------------------------------------------------
469 * Constructor/argument parsing:
470 * <#multipath feature args> [<arg>]*
471 * <#hw_handler args> [hw_handler [<arg>]*]
472 * <#priority groups>
473 * <initial priority group>
474 * [<selector> <#selector args> [<arg>]*
475 * <#paths> <#per-path selector args>
476 * [<path> [<arg>]* ]+ ]+
477 *---------------------------------------------------------------*/
Mike Snitzer498f0102011-08-02 12:32:04 +0100478static int parse_path_selector(struct dm_arg_set *as, struct priority_group *pg,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 struct dm_target *ti)
480{
481 int r;
482 struct path_selector_type *pst;
483 unsigned ps_argc;
484
Mike Snitzer498f0102011-08-02 12:32:04 +0100485 static struct dm_arg _args[] = {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700486 {0, 1024, "invalid number of path selector args"},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 };
488
Mike Snitzer498f0102011-08-02 12:32:04 +0100489 pst = dm_get_path_selector(dm_shift_arg(as));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 if (!pst) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700491 ti->error = "unknown path selector type";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 return -EINVAL;
493 }
494
Mike Snitzer498f0102011-08-02 12:32:04 +0100495 r = dm_read_arg_group(_args, as, &ps_argc, &ti->error);
Mikulas Patocka371b2e32008-07-21 12:00:24 +0100496 if (r) {
497 dm_put_path_selector(pst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 return -EINVAL;
Mikulas Patocka371b2e32008-07-21 12:00:24 +0100499 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501 r = pst->create(&pg->ps, ps_argc, as->argv);
502 if (r) {
503 dm_put_path_selector(pst);
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700504 ti->error = "path selector constructor failed";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 return r;
506 }
507
508 pg->ps.type = pst;
Mike Snitzer498f0102011-08-02 12:32:04 +0100509 dm_consume_args(as, ps_argc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
511 return 0;
512}
513
Mike Snitzer498f0102011-08-02 12:32:04 +0100514static struct pgpath *parse_path(struct dm_arg_set *as, struct path_selector *ps,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 struct dm_target *ti)
516{
517 int r;
518 struct pgpath *p;
Hannes Reineckeae11b1b2008-07-17 17:49:02 -0700519 struct multipath *m = ti->private;
Mike Snitzera58a9352012-07-27 15:08:04 +0100520 struct request_queue *q = NULL;
521 const char *attached_handler_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
523 /* we need at least a path arg */
524 if (as->argc < 1) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700525 ti->error = "no device given";
Benjamin Marzinski01460f32008-10-10 13:36:57 +0100526 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 }
528
529 p = alloc_pgpath();
530 if (!p)
Benjamin Marzinski01460f32008-10-10 13:36:57 +0100531 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
Mike Snitzer498f0102011-08-02 12:32:04 +0100533 r = dm_get_device(ti, dm_shift_arg(as), dm_table_get_mode(ti->table),
Nikanth Karthikesan8215d6e2010-03-06 02:32:27 +0000534 &p->path.dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 if (r) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700536 ti->error = "error getting device";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 goto bad;
538 }
539
Mike Snitzera58a9352012-07-27 15:08:04 +0100540 if (m->retain_attached_hw_handler || m->hw_handler_name)
541 q = bdev_get_queue(p->path.dev->bdev);
Hannes Reineckea0cf7ea2009-06-22 10:12:11 +0100542
Mike Snitzera58a9352012-07-27 15:08:04 +0100543 if (m->retain_attached_hw_handler) {
544 attached_handler_name = scsi_dh_attached_handler_name(q, GFP_KERNEL);
545 if (attached_handler_name) {
546 /*
547 * Reset hw_handler_name to match the attached handler
548 * and clear any hw_handler_params associated with the
549 * ignored handler.
550 *
551 * NB. This modifies the table line to show the actual
552 * handler instead of the original table passed in.
553 */
554 kfree(m->hw_handler_name);
555 m->hw_handler_name = attached_handler_name;
556
557 kfree(m->hw_handler_params);
558 m->hw_handler_params = NULL;
559 }
560 }
561
562 if (m->hw_handler_name) {
563 /*
564 * Increments scsi_dh reference, even when using an
565 * already-attached handler.
566 */
Hannes Reineckea0cf7ea2009-06-22 10:12:11 +0100567 r = scsi_dh_attach(q, m->hw_handler_name);
568 if (r == -EBUSY) {
569 /*
Mike Snitzera58a9352012-07-27 15:08:04 +0100570 * Already attached to different hw_handler:
Hannes Reineckea0cf7ea2009-06-22 10:12:11 +0100571 * try to reattach with correct one.
572 */
573 scsi_dh_detach(q);
574 r = scsi_dh_attach(q, m->hw_handler_name);
575 }
576
Hannes Reineckeae11b1b2008-07-17 17:49:02 -0700577 if (r < 0) {
Hannes Reineckea0cf7ea2009-06-22 10:12:11 +0100578 ti->error = "error attaching hardware handler";
Hannes Reineckeae11b1b2008-07-17 17:49:02 -0700579 dm_put_device(ti, p->path.dev);
580 goto bad;
581 }
Chandra Seetharaman2bfd2e12009-08-03 12:42:45 -0700582
583 if (m->hw_handler_params) {
584 r = scsi_dh_set_params(q, m->hw_handler_params);
585 if (r < 0) {
586 ti->error = "unable to set hardware "
587 "handler parameters";
588 scsi_dh_detach(q);
589 dm_put_device(ti, p->path.dev);
590 goto bad;
591 }
592 }
Hannes Reineckeae11b1b2008-07-17 17:49:02 -0700593 }
594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 r = ps->type->add_path(ps, &p->path, as->argc, as->argv, &ti->error);
596 if (r) {
597 dm_put_device(ti, p->path.dev);
598 goto bad;
599 }
600
601 return p;
602
603 bad:
604 free_pgpath(p);
Benjamin Marzinski01460f32008-10-10 13:36:57 +0100605 return ERR_PTR(r);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606}
607
Mike Snitzer498f0102011-08-02 12:32:04 +0100608static struct priority_group *parse_priority_group(struct dm_arg_set *as,
Micha³ Miros³aw28f16c22006-10-03 01:15:33 -0700609 struct multipath *m)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610{
Mike Snitzer498f0102011-08-02 12:32:04 +0100611 static struct dm_arg _args[] = {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700612 {1, 1024, "invalid number of paths"},
613 {0, 1024, "invalid number of selector args"}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 };
615
616 int r;
Mike Snitzer498f0102011-08-02 12:32:04 +0100617 unsigned i, nr_selector_args, nr_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 struct priority_group *pg;
Micha³ Miros³aw28f16c22006-10-03 01:15:33 -0700619 struct dm_target *ti = m->ti;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
621 if (as->argc < 2) {
622 as->argc = 0;
Benjamin Marzinski01460f32008-10-10 13:36:57 +0100623 ti->error = "not enough priority group arguments";
624 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 }
626
627 pg = alloc_priority_group();
628 if (!pg) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700629 ti->error = "couldn't allocate priority group";
Benjamin Marzinski01460f32008-10-10 13:36:57 +0100630 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 }
632 pg->m = m;
633
634 r = parse_path_selector(as, pg, ti);
635 if (r)
636 goto bad;
637
638 /*
639 * read the paths
640 */
Mike Snitzer498f0102011-08-02 12:32:04 +0100641 r = dm_read_arg(_args, as, &pg->nr_pgpaths, &ti->error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 if (r)
643 goto bad;
644
Mike Snitzer498f0102011-08-02 12:32:04 +0100645 r = dm_read_arg(_args + 1, as, &nr_selector_args, &ti->error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 if (r)
647 goto bad;
648
Mike Snitzer498f0102011-08-02 12:32:04 +0100649 nr_args = 1 + nr_selector_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 for (i = 0; i < pg->nr_pgpaths; i++) {
651 struct pgpath *pgpath;
Mike Snitzer498f0102011-08-02 12:32:04 +0100652 struct dm_arg_set path_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Mike Snitzer498f0102011-08-02 12:32:04 +0100654 if (as->argc < nr_args) {
Mikulas Patocka148acff2008-07-21 12:00:30 +0100655 ti->error = "not enough path parameters";
Alasdair G Kergon6bbf79a2010-08-12 04:13:49 +0100656 r = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 goto bad;
Mikulas Patocka148acff2008-07-21 12:00:30 +0100658 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
Mike Snitzer498f0102011-08-02 12:32:04 +0100660 path_args.argc = nr_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 path_args.argv = as->argv;
662
663 pgpath = parse_path(&path_args, &pg->ps, ti);
Benjamin Marzinski01460f32008-10-10 13:36:57 +0100664 if (IS_ERR(pgpath)) {
665 r = PTR_ERR(pgpath);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 goto bad;
Benjamin Marzinski01460f32008-10-10 13:36:57 +0100667 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
669 pgpath->pg = pg;
670 list_add_tail(&pgpath->list, &pg->pgpaths);
Mike Snitzer498f0102011-08-02 12:32:04 +0100671 dm_consume_args(as, nr_args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 }
673
674 return pg;
675
676 bad:
677 free_priority_group(pg, ti);
Benjamin Marzinski01460f32008-10-10 13:36:57 +0100678 return ERR_PTR(r);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679}
680
Mike Snitzer498f0102011-08-02 12:32:04 +0100681static int parse_hw_handler(struct dm_arg_set *as, struct multipath *m)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 unsigned hw_argc;
Chandra Seetharaman2bfd2e12009-08-03 12:42:45 -0700684 int ret;
Micha³ Miros³aw28f16c22006-10-03 01:15:33 -0700685 struct dm_target *ti = m->ti;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
Mike Snitzer498f0102011-08-02 12:32:04 +0100687 static struct dm_arg _args[] = {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700688 {0, 1024, "invalid number of hardware handler args"},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 };
690
Mike Snitzer498f0102011-08-02 12:32:04 +0100691 if (dm_read_arg_group(_args, as, &hw_argc, &ti->error))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 return -EINVAL;
693
694 if (!hw_argc)
695 return 0;
696
Mike Snitzer498f0102011-08-02 12:32:04 +0100697 m->hw_handler_name = kstrdup(dm_shift_arg(as), GFP_KERNEL);
Mike Snitzer510193a2012-05-12 01:43:21 +0100698 if (!try_then_request_module(scsi_dh_handler_exist(m->hw_handler_name),
699 "scsi_dh_%s", m->hw_handler_name)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700700 ti->error = "unknown hardware handler type";
Chandra Seetharaman2bfd2e12009-08-03 12:42:45 -0700701 ret = -EINVAL;
702 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 }
Chandra Seetharaman14e98c52008-11-13 23:39:06 +0000704
Chandra Seetharaman2bfd2e12009-08-03 12:42:45 -0700705 if (hw_argc > 1) {
706 char *p;
707 int i, j, len = 4;
708
709 for (i = 0; i <= hw_argc - 2; i++)
710 len += strlen(as->argv[i]) + 1;
711 p = m->hw_handler_params = kzalloc(len, GFP_KERNEL);
712 if (!p) {
713 ti->error = "memory allocation failed";
714 ret = -ENOMEM;
715 goto fail;
716 }
717 j = sprintf(p, "%d", hw_argc - 1);
718 for (i = 0, p+=j+1; i <= hw_argc - 2; i++, p+=j+1)
719 j = sprintf(p, "%s", as->argv[i]);
720 }
Mike Snitzer498f0102011-08-02 12:32:04 +0100721 dm_consume_args(as, hw_argc - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
723 return 0;
Chandra Seetharaman2bfd2e12009-08-03 12:42:45 -0700724fail:
725 kfree(m->hw_handler_name);
726 m->hw_handler_name = NULL;
727 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728}
729
Mike Snitzer498f0102011-08-02 12:32:04 +0100730static int parse_features(struct dm_arg_set *as, struct multipath *m)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731{
732 int r;
733 unsigned argc;
Micha³ Miros³aw28f16c22006-10-03 01:15:33 -0700734 struct dm_target *ti = m->ti;
Mike Snitzer498f0102011-08-02 12:32:04 +0100735 const char *arg_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
Mike Snitzer498f0102011-08-02 12:32:04 +0100737 static struct dm_arg _args[] = {
Mike Snitzera58a9352012-07-27 15:08:04 +0100738 {0, 6, "invalid number of feature args"},
Dave Wysochanskic9e45582007-10-19 22:47:53 +0100739 {1, 50, "pg_init_retries must be between 1 and 50"},
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +0000740 {0, 60000, "pg_init_delay_msecs must be between 0 and 60000"},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 };
742
Mike Snitzer498f0102011-08-02 12:32:04 +0100743 r = dm_read_arg_group(_args, as, &argc, &ti->error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 if (r)
745 return -EINVAL;
746
747 if (!argc)
748 return 0;
749
Dave Wysochanskic9e45582007-10-19 22:47:53 +0100750 do {
Mike Snitzer498f0102011-08-02 12:32:04 +0100751 arg_name = dm_shift_arg(as);
Dave Wysochanskic9e45582007-10-19 22:47:53 +0100752 argc--;
753
Mike Snitzer498f0102011-08-02 12:32:04 +0100754 if (!strcasecmp(arg_name, "queue_if_no_path")) {
Dave Wysochanskic9e45582007-10-19 22:47:53 +0100755 r = queue_if_no_path(m, 1, 0);
756 continue;
757 }
758
Mike Snitzera58a9352012-07-27 15:08:04 +0100759 if (!strcasecmp(arg_name, "retain_attached_hw_handler")) {
760 m->retain_attached_hw_handler = 1;
761 continue;
762 }
763
Mike Snitzer498f0102011-08-02 12:32:04 +0100764 if (!strcasecmp(arg_name, "pg_init_retries") &&
Dave Wysochanskic9e45582007-10-19 22:47:53 +0100765 (argc >= 1)) {
Mike Snitzer498f0102011-08-02 12:32:04 +0100766 r = dm_read_arg(_args + 1, as, &m->pg_init_retries, &ti->error);
Dave Wysochanskic9e45582007-10-19 22:47:53 +0100767 argc--;
768 continue;
769 }
770
Mike Snitzer498f0102011-08-02 12:32:04 +0100771 if (!strcasecmp(arg_name, "pg_init_delay_msecs") &&
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +0000772 (argc >= 1)) {
Mike Snitzer498f0102011-08-02 12:32:04 +0100773 r = dm_read_arg(_args + 2, as, &m->pg_init_delay_msecs, &ti->error);
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +0000774 argc--;
775 continue;
776 }
777
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 ti->error = "Unrecognised multipath feature request";
Dave Wysochanskic9e45582007-10-19 22:47:53 +0100779 r = -EINVAL;
780 } while (argc && !r);
781
782 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783}
784
785static int multipath_ctr(struct dm_target *ti, unsigned int argc,
786 char **argv)
787{
Mike Snitzer498f0102011-08-02 12:32:04 +0100788 /* target arguments */
789 static struct dm_arg _args[] = {
Mike Snitzera490a072011-03-24 13:54:33 +0000790 {0, 1024, "invalid number of priority groups"},
791 {0, 1024, "invalid initial priority group number"},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 };
793
794 int r;
795 struct multipath *m;
Mike Snitzer498f0102011-08-02 12:32:04 +0100796 struct dm_arg_set as;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 unsigned pg_count = 0;
798 unsigned next_pg_num;
799
800 as.argc = argc;
801 as.argv = argv;
802
Micha³ Miros³aw28f16c22006-10-03 01:15:33 -0700803 m = alloc_multipath(ti);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 if (!m) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700805 ti->error = "can't allocate multipath";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 return -EINVAL;
807 }
808
Micha³ Miros³aw28f16c22006-10-03 01:15:33 -0700809 r = parse_features(&as, m);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 if (r)
811 goto bad;
812
Micha³ Miros³aw28f16c22006-10-03 01:15:33 -0700813 r = parse_hw_handler(&as, m);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 if (r)
815 goto bad;
816
Mike Snitzer498f0102011-08-02 12:32:04 +0100817 r = dm_read_arg(_args, &as, &m->nr_priority_groups, &ti->error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 if (r)
819 goto bad;
820
Mike Snitzer498f0102011-08-02 12:32:04 +0100821 r = dm_read_arg(_args + 1, &as, &next_pg_num, &ti->error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 if (r)
823 goto bad;
824
Mike Snitzera490a072011-03-24 13:54:33 +0000825 if ((!m->nr_priority_groups && next_pg_num) ||
826 (m->nr_priority_groups && !next_pg_num)) {
827 ti->error = "invalid initial priority group";
828 r = -EINVAL;
829 goto bad;
830 }
831
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 /* parse the priority groups */
833 while (as.argc) {
834 struct priority_group *pg;
835
Micha³ Miros³aw28f16c22006-10-03 01:15:33 -0700836 pg = parse_priority_group(&as, m);
Benjamin Marzinski01460f32008-10-10 13:36:57 +0100837 if (IS_ERR(pg)) {
838 r = PTR_ERR(pg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 goto bad;
840 }
841
842 m->nr_valid_paths += pg->nr_pgpaths;
843 list_add_tail(&pg->list, &m->priority_groups);
844 pg_count++;
845 pg->pg_num = pg_count;
846 if (!--next_pg_num)
847 m->next_pg = pg;
848 }
849
850 if (pg_count != m->nr_priority_groups) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700851 ti->error = "priority group count mismatch";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 r = -EINVAL;
853 goto bad;
854 }
855
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000856 ti->num_flush_bios = 1;
857 ti->num_discard_bios = 1;
Mike Snitzer042bcef2013-05-10 14:37:16 +0100858 ti->num_write_same_bios = 1;
Mikulas Patocka86279212009-06-22 10:12:24 +0100859
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 return 0;
861
862 bad:
863 free_multipath(m);
864 return r;
865}
866
Kiyoshi Ueda2bded7b2010-03-06 02:32:13 +0000867static void multipath_wait_for_pg_init_completion(struct multipath *m)
868{
869 DECLARE_WAITQUEUE(wait, current);
870 unsigned long flags;
871
872 add_wait_queue(&m->pg_init_wait, &wait);
873
874 while (1) {
875 set_current_state(TASK_UNINTERRUPTIBLE);
876
877 spin_lock_irqsave(&m->lock, flags);
878 if (!m->pg_init_in_progress) {
879 spin_unlock_irqrestore(&m->lock, flags);
880 break;
881 }
882 spin_unlock_irqrestore(&m->lock, flags);
883
884 io_schedule();
885 }
886 set_current_state(TASK_RUNNING);
887
888 remove_wait_queue(&m->pg_init_wait, &wait);
889}
890
891static void flush_multipath_work(struct multipath *m)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892{
Shiva Krishna Merla954a73d2013-10-30 03:26:38 +0000893 unsigned long flags;
894
895 spin_lock_irqsave(&m->lock, flags);
896 m->pg_init_disabled = 1;
897 spin_unlock_irqrestore(&m->lock, flags);
898
Chandra Seetharamanbab7cfc2008-05-01 14:50:22 -0700899 flush_workqueue(kmpath_handlerd);
Kiyoshi Ueda2bded7b2010-03-06 02:32:13 +0000900 multipath_wait_for_pg_init_completion(m);
Alasdair G Kergona044d012005-07-12 15:53:02 -0700901 flush_workqueue(kmultipathd);
Tejun Heo43829732012-08-20 14:51:24 -0700902 flush_work(&m->trigger_event);
Shiva Krishna Merla954a73d2013-10-30 03:26:38 +0000903
904 spin_lock_irqsave(&m->lock, flags);
905 m->pg_init_disabled = 0;
906 spin_unlock_irqrestore(&m->lock, flags);
Kiyoshi Ueda6df400a2009-12-10 23:52:19 +0000907}
908
909static void multipath_dtr(struct dm_target *ti)
910{
911 struct multipath *m = ti->private;
912
Kiyoshi Ueda2bded7b2010-03-06 02:32:13 +0000913 flush_multipath_work(m);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 free_multipath(m);
915}
916
917/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 * Take a path out of use.
919 */
920static int fail_path(struct pgpath *pgpath)
921{
922 unsigned long flags;
923 struct multipath *m = pgpath->pg->m;
924
925 spin_lock_irqsave(&m->lock, flags);
926
Kiyoshi Ueda66800732008-10-10 13:36:58 +0100927 if (!pgpath->is_active)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 goto out;
929
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700930 DMWARN("Failing path %s.", pgpath->path.dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
932 pgpath->pg->ps.type->fail_path(&pgpath->pg->ps, &pgpath->path);
Kiyoshi Ueda66800732008-10-10 13:36:58 +0100933 pgpath->is_active = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 pgpath->fail_count++;
935
936 m->nr_valid_paths--;
937
938 if (pgpath == m->current_pgpath)
939 m->current_pgpath = NULL;
940
Mike Andersonb15546f2007-10-19 22:48:02 +0100941 dm_path_uevent(DM_UEVENT_PATH_FAILED, m->ti,
942 pgpath->path.dev->name, m->nr_valid_paths);
943
Alasdair G Kergonfe9cf302009-01-06 03:05:13 +0000944 schedule_work(&m->trigger_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
946out:
947 spin_unlock_irqrestore(&m->lock, flags);
948
949 return 0;
950}
951
952/*
953 * Reinstate a previously-failed path
954 */
955static int reinstate_path(struct pgpath *pgpath)
956{
Hannes Reinecke63d832c2014-05-26 14:45:39 +0200957 int r = 0, run_queue = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 unsigned long flags;
959 struct multipath *m = pgpath->pg->m;
960
961 spin_lock_irqsave(&m->lock, flags);
962
Kiyoshi Ueda66800732008-10-10 13:36:58 +0100963 if (pgpath->is_active)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 goto out;
965
Alasdair G Kergondef052d2008-07-21 12:00:31 +0100966 if (!pgpath->pg->ps.type->reinstate_path) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 DMWARN("Reinstate path not supported by path selector %s",
968 pgpath->pg->ps.type->name);
969 r = -EINVAL;
970 goto out;
971 }
972
973 r = pgpath->pg->ps.type->reinstate_path(&pgpath->pg->ps, &pgpath->path);
974 if (r)
975 goto out;
976
Kiyoshi Ueda66800732008-10-10 13:36:58 +0100977 pgpath->is_active = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
Hannes Reineckee8099172014-02-28 15:33:44 +0100979 if (!m->nr_valid_paths++) {
Chandra Seetharamane54f77d2009-06-22 10:12:12 +0100980 m->current_pgpath = NULL;
Hannes Reinecke63d832c2014-05-26 14:45:39 +0200981 run_queue = 1;
Chandra Seetharamane54f77d2009-06-22 10:12:12 +0100982 } else if (m->hw_handler_name && (m->current_pg == pgpath->pg)) {
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +0000983 if (queue_work(kmpath_handlerd, &pgpath->activate_path.work))
Chandra Seetharamane54f77d2009-06-22 10:12:12 +0100984 m->pg_init_in_progress++;
985 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
Mike Andersonb15546f2007-10-19 22:48:02 +0100987 dm_path_uevent(DM_UEVENT_PATH_REINSTATED, m->ti,
988 pgpath->path.dev->name, m->nr_valid_paths);
989
Alasdair G Kergonfe9cf302009-01-06 03:05:13 +0000990 schedule_work(&m->trigger_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991
992out:
993 spin_unlock_irqrestore(&m->lock, flags);
Hannes Reinecke63d832c2014-05-26 14:45:39 +0200994 if (run_queue)
995 dm_table_run_md_queue_async(m->ti->table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996
997 return r;
998}
999
1000/*
1001 * Fail or reinstate all paths that match the provided struct dm_dev.
1002 */
1003static int action_dev(struct multipath *m, struct dm_dev *dev,
1004 action_fn action)
1005{
Mike Snitzer19040c02011-03-24 13:54:31 +00001006 int r = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 struct pgpath *pgpath;
1008 struct priority_group *pg;
1009
1010 list_for_each_entry(pg, &m->priority_groups, list) {
1011 list_for_each_entry(pgpath, &pg->pgpaths, list) {
1012 if (pgpath->path.dev == dev)
1013 r = action(pgpath);
1014 }
1015 }
1016
1017 return r;
1018}
1019
1020/*
1021 * Temporarily try to avoid having to use the specified PG
1022 */
1023static void bypass_pg(struct multipath *m, struct priority_group *pg,
1024 int bypassed)
1025{
1026 unsigned long flags;
1027
1028 spin_lock_irqsave(&m->lock, flags);
1029
1030 pg->bypassed = bypassed;
1031 m->current_pgpath = NULL;
1032 m->current_pg = NULL;
1033
1034 spin_unlock_irqrestore(&m->lock, flags);
1035
Alasdair G Kergonfe9cf302009-01-06 03:05:13 +00001036 schedule_work(&m->trigger_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037}
1038
1039/*
1040 * Switch to using the specified PG from the next I/O that gets mapped
1041 */
1042static int switch_pg_num(struct multipath *m, const char *pgstr)
1043{
1044 struct priority_group *pg;
1045 unsigned pgnum;
1046 unsigned long flags;
Mikulas Patocka31998ef2012-03-28 18:41:26 +01001047 char dummy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048
Mikulas Patocka31998ef2012-03-28 18:41:26 +01001049 if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 (pgnum > m->nr_priority_groups)) {
1051 DMWARN("invalid PG number supplied to switch_pg_num");
1052 return -EINVAL;
1053 }
1054
1055 spin_lock_irqsave(&m->lock, flags);
1056 list_for_each_entry(pg, &m->priority_groups, list) {
1057 pg->bypassed = 0;
1058 if (--pgnum)
1059 continue;
1060
1061 m->current_pgpath = NULL;
1062 m->current_pg = NULL;
1063 m->next_pg = pg;
1064 }
1065 spin_unlock_irqrestore(&m->lock, flags);
1066
Alasdair G Kergonfe9cf302009-01-06 03:05:13 +00001067 schedule_work(&m->trigger_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 return 0;
1069}
1070
1071/*
1072 * Set/clear bypassed status of a PG.
1073 * PGs are numbered upwards from 1 in the order they were declared.
1074 */
1075static int bypass_pg_num(struct multipath *m, const char *pgstr, int bypassed)
1076{
1077 struct priority_group *pg;
1078 unsigned pgnum;
Mikulas Patocka31998ef2012-03-28 18:41:26 +01001079 char dummy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
Mikulas Patocka31998ef2012-03-28 18:41:26 +01001081 if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 (pgnum > m->nr_priority_groups)) {
1083 DMWARN("invalid PG number supplied to bypass_pg");
1084 return -EINVAL;
1085 }
1086
1087 list_for_each_entry(pg, &m->priority_groups, list) {
1088 if (!--pgnum)
1089 break;
1090 }
1091
1092 bypass_pg(m, pg, bypassed);
1093 return 0;
1094}
1095
1096/*
Dave Wysochanskic9e45582007-10-19 22:47:53 +01001097 * Should we retry pg_init immediately?
1098 */
1099static int pg_init_limit_reached(struct multipath *m, struct pgpath *pgpath)
1100{
1101 unsigned long flags;
1102 int limit_reached = 0;
1103
1104 spin_lock_irqsave(&m->lock, flags);
1105
Shiva Krishna Merla954a73d2013-10-30 03:26:38 +00001106 if (m->pg_init_count <= m->pg_init_retries && !m->pg_init_disabled)
Dave Wysochanskic9e45582007-10-19 22:47:53 +01001107 m->pg_init_required = 1;
1108 else
1109 limit_reached = 1;
1110
1111 spin_unlock_irqrestore(&m->lock, flags);
1112
1113 return limit_reached;
1114}
1115
Chandra Seetharaman3ae31f62009-10-21 09:22:46 -07001116static void pg_init_done(void *data, int errors)
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001117{
Moger, Babu83c0d5d2010-03-06 02:29:45 +00001118 struct pgpath *pgpath = data;
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001119 struct priority_group *pg = pgpath->pg;
1120 struct multipath *m = pg->m;
1121 unsigned long flags;
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +00001122 unsigned delay_retry = 0;
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001123
1124 /* device or driver problems */
1125 switch (errors) {
1126 case SCSI_DH_OK:
1127 break;
1128 case SCSI_DH_NOSYS:
1129 if (!m->hw_handler_name) {
1130 errors = 0;
1131 break;
1132 }
Moger, Babuf7b934c2010-03-06 02:29:49 +00001133 DMERR("Could not failover the device: Handler scsi_dh_%s "
1134 "Error %d.", m->hw_handler_name, errors);
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001135 /*
1136 * Fail path for now, so we do not ping pong
1137 */
1138 fail_path(pgpath);
1139 break;
1140 case SCSI_DH_DEV_TEMP_BUSY:
1141 /*
1142 * Probably doing something like FW upgrade on the
1143 * controller so try the other pg.
1144 */
1145 bypass_pg(m, pg, 1);
1146 break;
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001147 case SCSI_DH_RETRY:
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +00001148 /* Wait before retrying. */
1149 delay_retry = 1;
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001150 case SCSI_DH_IMM_RETRY:
1151 case SCSI_DH_RES_TEMP_UNAVAIL:
1152 if (pg_init_limit_reached(m, pgpath))
1153 fail_path(pgpath);
1154 errors = 0;
1155 break;
1156 default:
1157 /*
1158 * We probably do not want to fail the path for a device
1159 * error, but this is what the old dm did. In future
1160 * patches we can do more advanced handling.
1161 */
1162 fail_path(pgpath);
1163 }
1164
1165 spin_lock_irqsave(&m->lock, flags);
1166 if (errors) {
Chandra Seetharamane54f77d2009-06-22 10:12:12 +01001167 if (pgpath == m->current_pgpath) {
1168 DMERR("Could not failover device. Error %d.", errors);
1169 m->current_pgpath = NULL;
1170 m->current_pg = NULL;
1171 }
Kiyoshi Uedad0259bf2010-03-06 02:30:02 +00001172 } else if (!m->pg_init_required)
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001173 pg->bypassed = 0;
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001174
Kiyoshi Uedad0259bf2010-03-06 02:30:02 +00001175 if (--m->pg_init_in_progress)
1176 /* Activations of other paths are still on going */
1177 goto out;
1178
Hannes Reinecke3e9f1be2014-02-28 15:33:45 +01001179 if (m->pg_init_required) {
1180 m->pg_init_delay_retry = delay_retry;
1181 if (__pg_init_all_paths(m))
1182 goto out;
1183 }
1184 m->queue_io = 0;
Kiyoshi Uedad0259bf2010-03-06 02:30:02 +00001185
Kiyoshi Ueda2bded7b2010-03-06 02:32:13 +00001186 /*
1187 * Wake up any thread waiting to suspend.
1188 */
1189 wake_up(&m->pg_init_wait);
1190
Kiyoshi Uedad0259bf2010-03-06 02:30:02 +00001191out:
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001192 spin_unlock_irqrestore(&m->lock, flags);
1193}
1194
Chandra Seetharamanbab7cfc2008-05-01 14:50:22 -07001195static void activate_path(struct work_struct *work)
1196{
Chandra Seetharamane54f77d2009-06-22 10:12:12 +01001197 struct pgpath *pgpath =
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +00001198 container_of(work, struct pgpath, activate_path.work);
Chandra Seetharamanbab7cfc2008-05-01 14:50:22 -07001199
Hannes Reinecke3a017502014-02-28 15:33:49 +01001200 if (pgpath->is_active)
1201 scsi_dh_activate(bdev_get_queue(pgpath->path.dev->bdev),
1202 pg_init_done, pgpath);
1203 else
1204 pg_init_done(pgpath, SCSI_DH_DEV_OFFLINED);
Chandra Seetharamanbab7cfc2008-05-01 14:50:22 -07001205}
1206
Hannes Reinecke7e782af2013-07-01 15:16:26 +02001207static int noretry_error(int error)
1208{
1209 switch (error) {
1210 case -EOPNOTSUPP:
1211 case -EREMOTEIO:
1212 case -EILSEQ:
1213 case -ENODATA:
Jun'ichi Nomuracc9d3c32013-09-13 14:54:30 +09001214 case -ENOSPC:
Hannes Reinecke7e782af2013-07-01 15:16:26 +02001215 return 1;
1216 }
1217
1218 /* Anything else could be a path failure, so should be retried */
1219 return 0;
1220}
1221
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222/*
1223 * end_io handling
1224 */
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +01001225static int do_end_io(struct multipath *m, struct request *clone,
Alasdair G Kergon028867a2007-07-12 17:26:32 +01001226 int error, struct dm_mpath_io *mpio)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227{
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +01001228 /*
1229 * We don't queue any clone request inside the multipath target
1230 * during end I/O handling, since those clone requests don't have
1231 * bio clones. If we queue them inside the multipath target,
1232 * we need to make bio clones, that requires memory allocation.
1233 * (See drivers/md/dm.c:end_clone_bio() about why the clone requests
1234 * don't have bio clones.)
1235 * Instead of queueing the clone request here, we queue the original
1236 * request into dm core, which will remake a clone request and
1237 * clone bios for it and resubmit it later.
1238 */
1239 int r = DM_ENDIO_REQUEUE;
Stefan Bader640eb3b2005-11-21 21:32:35 -08001240 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +01001242 if (!error && !clone->errors)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 return 0; /* I/O complete */
1244
Mike Snitzer7eee4ae2014-06-02 15:50:06 -04001245 if (noretry_error(error))
Mike Snitzer959eb4e2010-08-12 04:14:32 +01001246 return error;
1247
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001248 if (mpio->pgpath)
1249 fail_path(mpio->pgpath);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250
Stefan Bader640eb3b2005-11-21 21:32:35 -08001251 spin_lock_irqsave(&m->lock, flags);
Hannes Reinecke751b2a72011-01-18 10:13:12 +01001252 if (!m->nr_valid_paths) {
1253 if (!m->queue_if_no_path) {
1254 if (!__must_push_back(m))
1255 r = -EIO;
1256 } else {
1257 if (error == -EBADE)
1258 r = error;
1259 }
1260 }
Stefan Bader640eb3b2005-11-21 21:32:35 -08001261 spin_unlock_irqrestore(&m->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +01001263 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264}
1265
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +01001266static int multipath_end_io(struct dm_target *ti, struct request *clone,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 int error, union map_info *map_context)
1268{
Alasdair G Kergon028867a2007-07-12 17:26:32 +01001269 struct multipath *m = ti->private;
1270 struct dm_mpath_io *mpio = map_context->ptr;
Wei Yongjuna71a2612012-10-12 16:59:42 +01001271 struct pgpath *pgpath;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 struct path_selector *ps;
1273 int r;
1274
Jun'ichi Nomura466891f2012-03-28 18:41:25 +01001275 BUG_ON(!mpio);
1276
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +01001277 r = do_end_io(m, clone, error, mpio);
Wei Yongjuna71a2612012-10-12 16:59:42 +01001278 pgpath = mpio->pgpath;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 if (pgpath) {
1280 ps = &pgpath->pg->ps;
1281 if (ps->type->end_io)
Kiyoshi Ueda02ab8232009-06-22 10:12:27 +01001282 ps->type->end_io(ps, &pgpath->path, mpio->nr_bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 }
Jun'ichi Nomura466891f2012-03-28 18:41:25 +01001284 clear_mapinfo(m, map_context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
1286 return r;
1287}
1288
1289/*
1290 * Suspend can't complete until all the I/O is processed so if
Alasdair G Kergon436d4102005-07-12 15:53:03 -07001291 * the last path fails we must error any remaining I/O.
1292 * Note that if the freeze_bdev fails while suspending, the
1293 * queue_if_no_path state is lost - userspace should reset it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 */
1295static void multipath_presuspend(struct dm_target *ti)
1296{
1297 struct multipath *m = (struct multipath *) ti->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
Alasdair G Kergon485ef692005-09-27 21:45:45 -07001299 queue_if_no_path(m, 0, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300}
1301
Kiyoshi Ueda6df400a2009-12-10 23:52:19 +00001302static void multipath_postsuspend(struct dm_target *ti)
1303{
Mike Anderson6380f262009-12-10 23:52:21 +00001304 struct multipath *m = ti->private;
1305
1306 mutex_lock(&m->work_mutex);
Kiyoshi Ueda2bded7b2010-03-06 02:32:13 +00001307 flush_multipath_work(m);
Mike Anderson6380f262009-12-10 23:52:21 +00001308 mutex_unlock(&m->work_mutex);
Kiyoshi Ueda6df400a2009-12-10 23:52:19 +00001309}
1310
Alasdair G Kergon436d4102005-07-12 15:53:03 -07001311/*
1312 * Restore the queue_if_no_path setting.
1313 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314static void multipath_resume(struct dm_target *ti)
1315{
1316 struct multipath *m = (struct multipath *) ti->private;
1317 unsigned long flags;
1318
1319 spin_lock_irqsave(&m->lock, flags);
Alasdair G Kergon436d4102005-07-12 15:53:03 -07001320 m->queue_if_no_path = m->saved_queue_if_no_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 spin_unlock_irqrestore(&m->lock, flags);
1322}
1323
1324/*
1325 * Info output has the following format:
1326 * num_multipath_feature_args [multipath_feature_args]*
1327 * num_handler_status_args [handler_status_args]*
1328 * num_groups init_group_number
1329 * [A|D|E num_ps_status_args [ps_status_args]*
1330 * num_paths num_selector_args
1331 * [path_dev A|F fail_count [selector_args]* ]+ ]+
1332 *
1333 * Table output has the following format (identical to the constructor string):
1334 * num_feature_args [features_args]*
1335 * num_handler_args hw_handler [hw_handler_args]*
1336 * num_groups init_group_number
1337 * [priority selector-name num_ps_args [ps_args]*
1338 * num_paths num_selector_args [path_dev [selector_args]* ]+ ]+
1339 */
Mikulas Patockafd7c0922013-03-01 22:45:44 +00001340static void multipath_status(struct dm_target *ti, status_type_t type,
1341 unsigned status_flags, char *result, unsigned maxlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342{
1343 int sz = 0;
1344 unsigned long flags;
1345 struct multipath *m = (struct multipath *) ti->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 struct priority_group *pg;
1347 struct pgpath *p;
1348 unsigned pg_num;
1349 char state;
1350
1351 spin_lock_irqsave(&m->lock, flags);
1352
1353 /* Features */
1354 if (type == STATUSTYPE_INFO)
Hannes Reineckee8099172014-02-28 15:33:44 +01001355 DMEMIT("2 %u %u ", m->queue_io, m->pg_init_count);
Dave Wysochanskic9e45582007-10-19 22:47:53 +01001356 else {
1357 DMEMIT("%u ", m->queue_if_no_path +
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +00001358 (m->pg_init_retries > 0) * 2 +
Mike Snitzera58a9352012-07-27 15:08:04 +01001359 (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT) * 2 +
1360 m->retain_attached_hw_handler);
Dave Wysochanskic9e45582007-10-19 22:47:53 +01001361 if (m->queue_if_no_path)
1362 DMEMIT("queue_if_no_path ");
1363 if (m->pg_init_retries)
1364 DMEMIT("pg_init_retries %u ", m->pg_init_retries);
Chandra Seetharaman4e2d19e2011-01-13 20:00:01 +00001365 if (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT)
1366 DMEMIT("pg_init_delay_msecs %u ", m->pg_init_delay_msecs);
Mike Snitzera58a9352012-07-27 15:08:04 +01001367 if (m->retain_attached_hw_handler)
1368 DMEMIT("retain_attached_hw_handler ");
Dave Wysochanskic9e45582007-10-19 22:47:53 +01001369 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001371 if (!m->hw_handler_name || type == STATUSTYPE_INFO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 DMEMIT("0 ");
1373 else
Chandra Seetharamancfae5c92008-05-01 14:50:11 -07001374 DMEMIT("1 %s ", m->hw_handler_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
1376 DMEMIT("%u ", m->nr_priority_groups);
1377
1378 if (m->next_pg)
1379 pg_num = m->next_pg->pg_num;
1380 else if (m->current_pg)
1381 pg_num = m->current_pg->pg_num;
1382 else
Mike Snitzera490a072011-03-24 13:54:33 +00001383 pg_num = (m->nr_priority_groups ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384
1385 DMEMIT("%u ", pg_num);
1386
1387 switch (type) {
1388 case STATUSTYPE_INFO:
1389 list_for_each_entry(pg, &m->priority_groups, list) {
1390 if (pg->bypassed)
1391 state = 'D'; /* Disabled */
1392 else if (pg == m->current_pg)
1393 state = 'A'; /* Currently Active */
1394 else
1395 state = 'E'; /* Enabled */
1396
1397 DMEMIT("%c ", state);
1398
1399 if (pg->ps.type->status)
1400 sz += pg->ps.type->status(&pg->ps, NULL, type,
1401 result + sz,
1402 maxlen - sz);
1403 else
1404 DMEMIT("0 ");
1405
1406 DMEMIT("%u %u ", pg->nr_pgpaths,
1407 pg->ps.type->info_args);
1408
1409 list_for_each_entry(p, &pg->pgpaths, list) {
1410 DMEMIT("%s %s %u ", p->path.dev->name,
Kiyoshi Ueda66800732008-10-10 13:36:58 +01001411 p->is_active ? "A" : "F",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 p->fail_count);
1413 if (pg->ps.type->status)
1414 sz += pg->ps.type->status(&pg->ps,
1415 &p->path, type, result + sz,
1416 maxlen - sz);
1417 }
1418 }
1419 break;
1420
1421 case STATUSTYPE_TABLE:
1422 list_for_each_entry(pg, &m->priority_groups, list) {
1423 DMEMIT("%s ", pg->ps.type->name);
1424
1425 if (pg->ps.type->status)
1426 sz += pg->ps.type->status(&pg->ps, NULL, type,
1427 result + sz,
1428 maxlen - sz);
1429 else
1430 DMEMIT("0 ");
1431
1432 DMEMIT("%u %u ", pg->nr_pgpaths,
1433 pg->ps.type->table_args);
1434
1435 list_for_each_entry(p, &pg->pgpaths, list) {
1436 DMEMIT("%s ", p->path.dev->name);
1437 if (pg->ps.type->status)
1438 sz += pg->ps.type->status(&pg->ps,
1439 &p->path, type, result + sz,
1440 maxlen - sz);
1441 }
1442 }
1443 break;
1444 }
1445
1446 spin_unlock_irqrestore(&m->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447}
1448
1449static int multipath_message(struct dm_target *ti, unsigned argc, char **argv)
1450{
Mike Anderson6380f262009-12-10 23:52:21 +00001451 int r = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 struct dm_dev *dev;
1453 struct multipath *m = (struct multipath *) ti->private;
1454 action_fn action;
1455
Mike Anderson6380f262009-12-10 23:52:21 +00001456 mutex_lock(&m->work_mutex);
1457
Kiyoshi Uedac2f3d242009-12-10 23:52:27 +00001458 if (dm_suspended(ti)) {
1459 r = -EBUSY;
1460 goto out;
1461 }
1462
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 if (argc == 1) {
Mike Snitzer498f0102011-08-02 12:32:04 +01001464 if (!strcasecmp(argv[0], "queue_if_no_path")) {
Mike Anderson6380f262009-12-10 23:52:21 +00001465 r = queue_if_no_path(m, 1, 0);
1466 goto out;
Mike Snitzer498f0102011-08-02 12:32:04 +01001467 } else if (!strcasecmp(argv[0], "fail_if_no_path")) {
Mike Anderson6380f262009-12-10 23:52:21 +00001468 r = queue_if_no_path(m, 0, 0);
1469 goto out;
1470 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 }
1472
Mike Anderson6380f262009-12-10 23:52:21 +00001473 if (argc != 2) {
Jose Castilloa356e422014-01-29 17:52:45 +01001474 DMWARN("Invalid multipath message arguments. Expected 2 arguments, got %d.", argc);
Mike Anderson6380f262009-12-10 23:52:21 +00001475 goto out;
1476 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477
Mike Snitzer498f0102011-08-02 12:32:04 +01001478 if (!strcasecmp(argv[0], "disable_group")) {
Mike Anderson6380f262009-12-10 23:52:21 +00001479 r = bypass_pg_num(m, argv[1], 1);
1480 goto out;
Mike Snitzer498f0102011-08-02 12:32:04 +01001481 } else if (!strcasecmp(argv[0], "enable_group")) {
Mike Anderson6380f262009-12-10 23:52:21 +00001482 r = bypass_pg_num(m, argv[1], 0);
1483 goto out;
Mike Snitzer498f0102011-08-02 12:32:04 +01001484 } else if (!strcasecmp(argv[0], "switch_group")) {
Mike Anderson6380f262009-12-10 23:52:21 +00001485 r = switch_pg_num(m, argv[1]);
1486 goto out;
Mike Snitzer498f0102011-08-02 12:32:04 +01001487 } else if (!strcasecmp(argv[0], "reinstate_path"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 action = reinstate_path;
Mike Snitzer498f0102011-08-02 12:32:04 +01001489 else if (!strcasecmp(argv[0], "fail_path"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 action = fail_path;
Mike Anderson6380f262009-12-10 23:52:21 +00001491 else {
Jose Castilloa356e422014-01-29 17:52:45 +01001492 DMWARN("Unrecognised multipath message received: %s", argv[0]);
Mike Anderson6380f262009-12-10 23:52:21 +00001493 goto out;
1494 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495
Nikanth Karthikesan8215d6e2010-03-06 02:32:27 +00001496 r = dm_get_device(ti, argv[1], dm_table_get_mode(ti->table), &dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 if (r) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -07001498 DMWARN("message: error getting device %s",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 argv[1]);
Mike Anderson6380f262009-12-10 23:52:21 +00001500 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 }
1502
1503 r = action_dev(m, dev, action);
1504
1505 dm_put_device(ti, dev);
1506
Mike Anderson6380f262009-12-10 23:52:21 +00001507out:
1508 mutex_unlock(&m->work_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510}
1511
Al Viro647b3d02007-08-28 22:15:59 -04001512static int multipath_ioctl(struct dm_target *ti, unsigned int cmd,
Milan Broz9af4aa32006-10-03 01:15:20 -07001513 unsigned long arg)
1514{
Mikulas Patocka35991652012-06-03 00:29:58 +01001515 struct multipath *m = ti->private;
Mike Snitzer7ba10aa2012-09-26 23:45:41 +01001516 struct pgpath *pgpath;
Mikulas Patocka35991652012-06-03 00:29:58 +01001517 struct block_device *bdev;
1518 fmode_t mode;
Milan Broz9af4aa32006-10-03 01:15:20 -07001519 unsigned long flags;
Mikulas Patocka35991652012-06-03 00:29:58 +01001520 int r;
1521
Mikulas Patocka35991652012-06-03 00:29:58 +01001522 bdev = NULL;
1523 mode = 0;
1524 r = 0;
Milan Broz9af4aa32006-10-03 01:15:20 -07001525
1526 spin_lock_irqsave(&m->lock, flags);
1527
1528 if (!m->current_pgpath)
Kiyoshi Ueda02ab8232009-06-22 10:12:27 +01001529 __choose_pgpath(m, 0);
Milan Broz9af4aa32006-10-03 01:15:20 -07001530
Mike Snitzer7ba10aa2012-09-26 23:45:41 +01001531 pgpath = m->current_pgpath;
1532
1533 if (pgpath) {
1534 bdev = pgpath->path.dev->bdev;
1535 mode = pgpath->path.dev->mode;
Milan Broze90dae12006-10-03 01:15:22 -07001536 }
Milan Broz9af4aa32006-10-03 01:15:20 -07001537
Mike Snitzer7ba10aa2012-09-26 23:45:41 +01001538 if ((pgpath && m->queue_io) || (!pgpath && m->queue_if_no_path))
Hannes Reinecke6c182cd2013-07-10 23:41:15 +01001539 r = -ENOTCONN;
Milan Broz9af4aa32006-10-03 01:15:20 -07001540 else if (!bdev)
1541 r = -EIO;
1542
1543 spin_unlock_irqrestore(&m->lock, flags);
1544
Paolo Bonziniec8013b2012-01-12 16:01:29 +01001545 /*
1546 * Only pass ioctls through if the device sizes match exactly.
1547 */
Hannes Reineckea1989b32014-02-26 10:07:04 +01001548 if (!bdev || ti->len != i_size_read(bdev->bd_inode) >> SECTOR_SHIFT) {
1549 int err = scsi_verify_blk_ioctl(NULL, cmd);
1550 if (err)
1551 r = err;
1552 }
Paolo Bonziniec8013b2012-01-12 16:01:29 +01001553
Hannes Reinecke3e9f1be2014-02-28 15:33:45 +01001554 if (r == -ENOTCONN && !fatal_signal_pending(current)) {
1555 spin_lock_irqsave(&m->lock, flags);
1556 if (!m->current_pg) {
1557 /* Path status changed, redo selection */
1558 __choose_pgpath(m, 0);
1559 }
1560 if (m->pg_init_required)
1561 __pg_init_all_paths(m);
Mike Snitzer4cdd2ad2014-05-13 13:49:39 -04001562 spin_unlock_irqrestore(&m->lock, flags);
Hannes Reinecke63d832c2014-05-26 14:45:39 +02001563 dm_table_run_md_queue_async(m->ti->table);
Hannes Reinecke3e9f1be2014-02-28 15:33:45 +01001564 }
Mikulas Patocka35991652012-06-03 00:29:58 +01001565
Al Viro633a08b2007-08-29 20:34:12 -04001566 return r ? : __blkdev_driver_ioctl(bdev, mode, cmd, arg);
Milan Broz9af4aa32006-10-03 01:15:20 -07001567}
1568
Mike Snitzeraf4874e2009-06-22 10:12:33 +01001569static int multipath_iterate_devices(struct dm_target *ti,
1570 iterate_devices_callout_fn fn, void *data)
1571{
1572 struct multipath *m = ti->private;
1573 struct priority_group *pg;
1574 struct pgpath *p;
1575 int ret = 0;
1576
1577 list_for_each_entry(pg, &m->priority_groups, list) {
1578 list_for_each_entry(p, &pg->pgpaths, list) {
Mike Snitzer5dea2712009-07-23 20:30:42 +01001579 ret = fn(ti, p->path.dev, ti->begin, ti->len, data);
Mike Snitzeraf4874e2009-06-22 10:12:33 +01001580 if (ret)
1581 goto out;
1582 }
1583 }
1584
1585out:
1586 return ret;
1587}
1588
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +01001589static int __pgpath_busy(struct pgpath *pgpath)
1590{
1591 struct request_queue *q = bdev_get_queue(pgpath->path.dev->bdev);
1592
1593 return dm_underlying_device_busy(q);
1594}
1595
1596/*
1597 * We return "busy", only when we can map I/Os but underlying devices
1598 * are busy (so even if we map I/Os now, the I/Os will wait on
1599 * the underlying queue).
1600 * In other words, if we want to kill I/Os or queue them inside us
1601 * due to map unavailability, we don't return "busy". Otherwise,
1602 * dm core won't give us the I/Os and we can't do what we want.
1603 */
1604static int multipath_busy(struct dm_target *ti)
1605{
1606 int busy = 0, has_active = 0;
1607 struct multipath *m = ti->private;
1608 struct priority_group *pg;
1609 struct pgpath *pgpath;
1610 unsigned long flags;
1611
1612 spin_lock_irqsave(&m->lock, flags);
1613
Jun'ichi Nomura7a7a3b42014-07-08 00:55:14 +00001614 /* pg_init in progress or no paths available */
1615 if (m->pg_init_in_progress ||
1616 (!m->nr_valid_paths && m->queue_if_no_path)) {
Hannes Reineckeb63349a2013-10-01 11:49:56 +02001617 busy = 1;
1618 goto out;
1619 }
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +01001620 /* Guess which priority_group will be used at next mapping time */
1621 if (unlikely(!m->current_pgpath && m->next_pg))
1622 pg = m->next_pg;
1623 else if (likely(m->current_pg))
1624 pg = m->current_pg;
1625 else
1626 /*
1627 * We don't know which pg will be used at next mapping time.
1628 * We don't call __choose_pgpath() here to avoid to trigger
1629 * pg_init just by busy checking.
1630 * So we don't know whether underlying devices we will be using
1631 * at next mapping time are busy or not. Just try mapping.
1632 */
1633 goto out;
1634
1635 /*
1636 * If there is one non-busy active path at least, the path selector
1637 * will be able to select it. So we consider such a pg as not busy.
1638 */
1639 busy = 1;
1640 list_for_each_entry(pgpath, &pg->pgpaths, list)
1641 if (pgpath->is_active) {
1642 has_active = 1;
1643
1644 if (!__pgpath_busy(pgpath)) {
1645 busy = 0;
1646 break;
1647 }
1648 }
1649
1650 if (!has_active)
1651 /*
1652 * No active path in this pg, so this pg won't be used and
1653 * the current_pg will be changed at next mapping time.
1654 * We need to try mapping to determine it.
1655 */
1656 busy = 0;
1657
1658out:
1659 spin_unlock_irqrestore(&m->lock, flags);
1660
1661 return busy;
1662}
1663
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664/*-----------------------------------------------------------------
1665 * Module setup
1666 *---------------------------------------------------------------*/
1667static struct target_type multipath_target = {
1668 .name = "multipath",
Hannes Reineckee8099172014-02-28 15:33:44 +01001669 .version = {1, 7, 0},
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 .module = THIS_MODULE,
1671 .ctr = multipath_ctr,
1672 .dtr = multipath_dtr,
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +01001673 .map_rq = multipath_map,
1674 .rq_end_io = multipath_end_io,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 .presuspend = multipath_presuspend,
Kiyoshi Ueda6df400a2009-12-10 23:52:19 +00001676 .postsuspend = multipath_postsuspend,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 .resume = multipath_resume,
1678 .status = multipath_status,
1679 .message = multipath_message,
Milan Broz9af4aa32006-10-03 01:15:20 -07001680 .ioctl = multipath_ioctl,
Mike Snitzeraf4874e2009-06-22 10:12:33 +01001681 .iterate_devices = multipath_iterate_devices,
Kiyoshi Uedaf40c67f2009-06-22 10:12:37 +01001682 .busy = multipath_busy,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683};
1684
1685static int __init dm_multipath_init(void)
1686{
1687 int r;
1688
1689 /* allocate a slab for the dm_ios */
Alasdair G Kergon028867a2007-07-12 17:26:32 +01001690 _mpio_cache = KMEM_CACHE(dm_mpath_io, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 if (!_mpio_cache)
1692 return -ENOMEM;
1693
1694 r = dm_register_target(&multipath_target);
1695 if (r < 0) {
Alasdair G Kergon0cd33122007-07-12 17:27:01 +01001696 DMERR("register failed %d", r);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 kmem_cache_destroy(_mpio_cache);
1698 return -EINVAL;
1699 }
1700
Tejun Heo4d4d66a2011-01-13 19:59:57 +00001701 kmultipathd = alloc_workqueue("kmpathd", WQ_MEM_RECLAIM, 0);
Alasdair G Kergonc5573082005-05-05 16:16:07 -07001702 if (!kmultipathd) {
Alasdair G Kergon0cd33122007-07-12 17:27:01 +01001703 DMERR("failed to create workqueue kmpathd");
Alasdair G Kergonc5573082005-05-05 16:16:07 -07001704 dm_unregister_target(&multipath_target);
1705 kmem_cache_destroy(_mpio_cache);
1706 return -ENOMEM;
1707 }
1708
Chandra Seetharamanbab7cfc2008-05-01 14:50:22 -07001709 /*
1710 * A separate workqueue is used to handle the device handlers
1711 * to avoid overloading existing workqueue. Overloading the
1712 * old workqueue would also create a bottleneck in the
1713 * path of the storage hardware device activation.
1714 */
Tejun Heo4d4d66a2011-01-13 19:59:57 +00001715 kmpath_handlerd = alloc_ordered_workqueue("kmpath_handlerd",
1716 WQ_MEM_RECLAIM);
Chandra Seetharamanbab7cfc2008-05-01 14:50:22 -07001717 if (!kmpath_handlerd) {
1718 DMERR("failed to create workqueue kmpath_handlerd");
1719 destroy_workqueue(kmultipathd);
1720 dm_unregister_target(&multipath_target);
1721 kmem_cache_destroy(_mpio_cache);
1722 return -ENOMEM;
1723 }
1724
Alasdair G Kergon72d94862006-06-26 00:27:35 -07001725 DMINFO("version %u.%u.%u loaded",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 multipath_target.version[0], multipath_target.version[1],
1727 multipath_target.version[2]);
1728
1729 return r;
1730}
1731
1732static void __exit dm_multipath_exit(void)
1733{
Chandra Seetharamanbab7cfc2008-05-01 14:50:22 -07001734 destroy_workqueue(kmpath_handlerd);
Alasdair G Kergonc5573082005-05-05 16:16:07 -07001735 destroy_workqueue(kmultipathd);
1736
Mikulas Patocka10d3bd02009-01-06 03:04:58 +00001737 dm_unregister_target(&multipath_target);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 kmem_cache_destroy(_mpio_cache);
1739}
1740
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741module_init(dm_multipath_init);
1742module_exit(dm_multipath_exit);
1743
1744MODULE_DESCRIPTION(DM_NAME " multipath target");
1745MODULE_AUTHOR("Sistina Software <dm-devel@redhat.com>");
1746MODULE_LICENSE("GPL");