dm-mpath.c 41.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/*
 * Copyright (C) 2003 Sistina Software Limited.
 * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
 *
 * This file is released under the GPL.
 */

8 9
#include <linux/device-mapper.h>

10
#include "dm.h"
L
Linus Torvalds 已提交
11
#include "dm-path-selector.h"
M
Mike Anderson 已提交
12
#include "dm-uevent.h"
L
Linus Torvalds 已提交
13

14
#include <linux/blkdev.h>
L
Linus Torvalds 已提交
15 16 17 18 19 20 21 22
#include <linux/ctype.h>
#include <linux/init.h>
#include <linux/mempool.h>
#include <linux/module.h>
#include <linux/pagemap.h>
#include <linux/slab.h>
#include <linux/time.h>
#include <linux/workqueue.h>
23
#include <linux/delay.h>
24
#include <scsi/scsi_dh.h>
A
Arun Sharma 已提交
25
#include <linux/atomic.h>
L
Linus Torvalds 已提交
26

27
#define DM_MSG_PREFIX "multipath"
28 29
#define DM_PG_INIT_DELAY_MSECS 2000
#define DM_PG_INIT_DELAY_DEFAULT ((unsigned) -1)
L
Linus Torvalds 已提交
30 31 32 33 34 35

/* Path properties */
struct pgpath {
	struct list_head list;

	struct priority_group *pg;	/* Owning PG */
36
	unsigned is_active;		/* Path status */
L
Linus Torvalds 已提交
37 38
	unsigned fail_count;		/* Cumulative failure count */

39
	struct dm_path path;
40
	struct delayed_work activate_path;
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
};

#define path_to_pgpath(__pgp) container_of((__pgp), struct pgpath, path)

/*
 * Paths are grouped into Priority Groups and numbered from 1 upwards.
 * Each has a path selector which controls which path gets used.
 */
struct priority_group {
	struct list_head list;

	struct multipath *m;		/* Owning multipath instance */
	struct path_selector ps;

	unsigned pg_num;		/* Reference number */
	unsigned bypassed;		/* Temporarily bypass this PG? */

	unsigned nr_pgpaths;		/* Number of paths in PG */
	struct list_head pgpaths;
};

/* Multipath context */
struct multipath {
	struct list_head list;
	struct dm_target *ti;

67
	const char *hw_handler_name;
68
	char *hw_handler_params;
69

70 71
	spinlock_t lock;

L
Linus Torvalds 已提交
72 73
	unsigned nr_priority_groups;
	struct list_head priority_groups;
74 75 76

	wait_queue_head_t pg_init_wait;	/* Wait for pg_init completion */

L
Linus Torvalds 已提交
77
	unsigned pg_init_required;	/* pg_init needs calling? */
78
	unsigned pg_init_in_progress;	/* Only one pg_init allowed at once */
79
	unsigned pg_init_delay_retry;	/* Delay pg_init retry? */
L
Linus Torvalds 已提交
80 81 82 83 84 85 86

	unsigned nr_valid_paths;	/* Total number of usable paths */
	struct pgpath *current_pgpath;
	struct priority_group *current_pg;
	struct priority_group *next_pg;	/* Switch to this PG if set */
	unsigned repeat_count;		/* I/Os left before calling PS again */

87 88 89
	unsigned queue_io:1;		/* Must we queue all I/O? */
	unsigned queue_if_no_path:1;	/* Queue I/O if last path fails? */
	unsigned saved_queue_if_no_path:1; /* Saved state during suspension */
90
	unsigned retain_attached_hw_handler:1; /* If there's already a hw_handler present, don't change it. */
91
	unsigned pg_init_disabled:1;	/* pg_init is not currently allowed */
92

D
Dave Wysochanski 已提交
93 94
	unsigned pg_init_retries;	/* Number of times to retry pg_init */
	unsigned pg_init_count;		/* Number of times pg_init called */
95
	unsigned pg_init_delay_msecs;	/* Number of msecs before pg_init retry */
L
Linus Torvalds 已提交
96 97 98 99

	struct work_struct trigger_event;

	/*
A
Alasdair G Kergon 已提交
100
	 * We must use a mempool of dm_mpath_io structs so that we
L
Linus Torvalds 已提交
101 102 103
	 * can resubmit bios on error.
	 */
	mempool_t *mpio_pool;
104 105

	struct mutex work_mutex;
L
Linus Torvalds 已提交
106 107 108 109 110
};

/*
 * Context information attached to each bio we process.
 */
A
Alasdair G Kergon 已提交
111
struct dm_mpath_io {
L
Linus Torvalds 已提交
112
	struct pgpath *pgpath;
113
	size_t nr_bytes;
L
Linus Torvalds 已提交
114 115 116 117
};

typedef int (*action_fn) (struct pgpath *pgpath);

118
static struct kmem_cache *_mpio_cache;
L
Linus Torvalds 已提交
119

120
static struct workqueue_struct *kmultipathd, *kmpath_handlerd;
D
David Howells 已提交
121
static void trigger_event(struct work_struct *work);
122
static void activate_path(struct work_struct *work);
123
static int __pgpath_busy(struct pgpath *pgpath);
L
Linus Torvalds 已提交
124 125 126 127 128 129 130 131


/*-----------------------------------------------
 * Allocation routines
 *-----------------------------------------------*/

static struct pgpath *alloc_pgpath(void)
{
M
Micha³ Miros³aw 已提交
132
	struct pgpath *pgpath = kzalloc(sizeof(*pgpath), GFP_KERNEL);
L
Linus Torvalds 已提交
133

134
	if (pgpath) {
135
		pgpath->is_active = 1;
136
		INIT_DELAYED_WORK(&pgpath->activate_path, activate_path);
137
	}
L
Linus Torvalds 已提交
138 139 140 141

	return pgpath;
}

A
Alasdair G Kergon 已提交
142
static void free_pgpath(struct pgpath *pgpath)
L
Linus Torvalds 已提交
143 144 145 146 147 148 149 150
{
	kfree(pgpath);
}

static struct priority_group *alloc_priority_group(void)
{
	struct priority_group *pg;

M
Micha³ Miros³aw 已提交
151
	pg = kzalloc(sizeof(*pg), GFP_KERNEL);
L
Linus Torvalds 已提交
152

M
Micha³ Miros³aw 已提交
153 154
	if (pg)
		INIT_LIST_HEAD(&pg->pgpaths);
L
Linus Torvalds 已提交
155 156 157 158 159 160 161

	return pg;
}

static void free_pgpaths(struct list_head *pgpaths, struct dm_target *ti)
{
	struct pgpath *pgpath, *tmp;
162
	struct multipath *m = ti->private;
L
Linus Torvalds 已提交
163 164 165

	list_for_each_entry_safe(pgpath, tmp, pgpaths, list) {
		list_del(&pgpath->list);
166 167
		if (m->hw_handler_name)
			scsi_dh_detach(bdev_get_queue(pgpath->path.dev->bdev));
L
Linus Torvalds 已提交
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
		dm_put_device(ti, pgpath->path.dev);
		free_pgpath(pgpath);
	}
}

static void free_priority_group(struct priority_group *pg,
				struct dm_target *ti)
{
	struct path_selector *ps = &pg->ps;

	if (ps->type) {
		ps->type->destroy(ps);
		dm_put_path_selector(ps->type);
	}

	free_pgpaths(&pg->pgpaths, ti);
	kfree(pg);
}

M
Micha³ Miros³aw 已提交
187
static struct multipath *alloc_multipath(struct dm_target *ti)
L
Linus Torvalds 已提交
188 189
{
	struct multipath *m;
190
	unsigned min_ios = dm_get_reserved_rq_based_ios();
L
Linus Torvalds 已提交
191

M
Micha³ Miros³aw 已提交
192
	m = kzalloc(sizeof(*m), GFP_KERNEL);
L
Linus Torvalds 已提交
193 194 195 196
	if (m) {
		INIT_LIST_HEAD(&m->priority_groups);
		spin_lock_init(&m->lock);
		m->queue_io = 1;
197
		m->pg_init_delay_msecs = DM_PG_INIT_DELAY_DEFAULT;
D
David Howells 已提交
198
		INIT_WORK(&m->trigger_event, trigger_event);
199
		init_waitqueue_head(&m->pg_init_wait);
200
		mutex_init(&m->work_mutex);
201
		m->mpio_pool = mempool_create_slab_pool(min_ios, _mpio_cache);
L
Linus Torvalds 已提交
202 203 204 205
		if (!m->mpio_pool) {
			kfree(m);
			return NULL;
		}
M
Micha³ Miros³aw 已提交
206 207
		m->ti = ti;
		ti->private = m;
L
Linus Torvalds 已提交
208 209 210 211 212 213 214 215 216 217 218 219 220 221
	}

	return m;
}

static void free_multipath(struct multipath *m)
{
	struct priority_group *pg, *tmp;

	list_for_each_entry_safe(pg, tmp, &m->priority_groups, list) {
		list_del(&pg->list);
		free_priority_group(pg, m->ti);
	}

222
	kfree(m->hw_handler_name);
223
	kfree(m->hw_handler_params);
L
Linus Torvalds 已提交
224 225 226 227
	mempool_destroy(m->mpio_pool);
	kfree(m);
}

228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
static int set_mapinfo(struct multipath *m, union map_info *info)
{
	struct dm_mpath_io *mpio;

	mpio = mempool_alloc(m->mpio_pool, GFP_ATOMIC);
	if (!mpio)
		return -ENOMEM;

	memset(mpio, 0, sizeof(*mpio));
	info->ptr = mpio;

	return 0;
}

static void clear_mapinfo(struct multipath *m, union map_info *info)
{
	struct dm_mpath_io *mpio = info->ptr;

	info->ptr = NULL;
	mempool_free(mpio, m->mpio_pool);
}
L
Linus Torvalds 已提交
249 250 251 252 253

/*-----------------------------------------------
 * Path selection
 *-----------------------------------------------*/

254
static int __pg_init_all_paths(struct multipath *m)
K
Kiyoshi Ueda 已提交
255 256
{
	struct pgpath *pgpath;
257
	unsigned long pg_init_delay = 0;
K
Kiyoshi Ueda 已提交
258

259
	if (m->pg_init_in_progress || m->pg_init_disabled)
260
		return 0;
261

K
Kiyoshi Ueda 已提交
262 263
	m->pg_init_count++;
	m->pg_init_required = 0;
264 265 266 267 268

	/* Check here to reset pg_init_required */
	if (!m->current_pg)
		return 0;

269 270 271
	if (m->pg_init_delay_retry)
		pg_init_delay = msecs_to_jiffies(m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT ?
						 m->pg_init_delay_msecs : DM_PG_INIT_DELAY_MSECS);
K
Kiyoshi Ueda 已提交
272 273 274 275
	list_for_each_entry(pgpath, &m->current_pg->pgpaths, list) {
		/* Skip failed paths */
		if (!pgpath->is_active)
			continue;
276 277
		if (queue_delayed_work(kmpath_handlerd, &pgpath->activate_path,
				       pg_init_delay))
K
Kiyoshi Ueda 已提交
278 279
			m->pg_init_in_progress++;
	}
280
	return m->pg_init_in_progress;
K
Kiyoshi Ueda 已提交
281 282
}

L
Linus Torvalds 已提交
283 284 285 286 287
static void __switch_pg(struct multipath *m, struct pgpath *pgpath)
{
	m->current_pg = pgpath->pg;

	/* Must we initialise the PG first, and queue I/O till it's ready? */
288
	if (m->hw_handler_name) {
L
Linus Torvalds 已提交
289 290 291 292 293 294
		m->pg_init_required = 1;
		m->queue_io = 1;
	} else {
		m->pg_init_required = 0;
		m->queue_io = 0;
	}
D
Dave Wysochanski 已提交
295 296

	m->pg_init_count = 0;
L
Linus Torvalds 已提交
297 298
}

299 300
static int __choose_path_in_pg(struct multipath *m, struct priority_group *pg,
			       size_t nr_bytes)
L
Linus Torvalds 已提交
301
{
302
	struct dm_path *path;
L
Linus Torvalds 已提交
303

304
	path = pg->ps.type->select_path(&pg->ps, &m->repeat_count, nr_bytes);
L
Linus Torvalds 已提交
305 306 307 308 309 310 311 312 313 314 315
	if (!path)
		return -ENXIO;

	m->current_pgpath = path_to_pgpath(path);

	if (m->current_pg != pg)
		__switch_pg(m, m->current_pgpath);

	return 0;
}

316
static void __choose_pgpath(struct multipath *m, size_t nr_bytes)
L
Linus Torvalds 已提交
317 318 319 320
{
	struct priority_group *pg;
	unsigned bypassed = 1;

321 322
	if (!m->nr_valid_paths) {
		m->queue_io = 0;
L
Linus Torvalds 已提交
323
		goto failed;
324
	}
L
Linus Torvalds 已提交
325 326 327 328 329

	/* Were we instructed to switch PG? */
	if (m->next_pg) {
		pg = m->next_pg;
		m->next_pg = NULL;
330
		if (!__choose_path_in_pg(m, pg, nr_bytes))
L
Linus Torvalds 已提交
331 332 333 334
			return;
	}

	/* Don't change PG until it has no remaining paths */
335
	if (m->current_pg && !__choose_path_in_pg(m, m->current_pg, nr_bytes))
L
Linus Torvalds 已提交
336 337 338 339 340
		return;

	/*
	 * Loop through priority groups until we find a valid path.
	 * First time we skip PGs marked 'bypassed'.
341 342
	 * Second time we only try the ones we skipped, but set
	 * pg_init_delay_retry so we do not hammer controllers.
L
Linus Torvalds 已提交
343 344 345 346 347
	 */
	do {
		list_for_each_entry(pg, &m->priority_groups, list) {
			if (pg->bypassed == bypassed)
				continue;
348 349 350
			if (!__choose_path_in_pg(m, pg, nr_bytes)) {
				if (!bypassed)
					m->pg_init_delay_retry = 1;
L
Linus Torvalds 已提交
351
				return;
352
			}
L
Linus Torvalds 已提交
353 354 355 356 357 358 359 360
		}
	} while (bypassed--);

failed:
	m->current_pgpath = NULL;
	m->current_pg = NULL;
}

361 362 363 364 365 366 367 368 369 370 371 372 373
/*
 * Check whether bios must be queued in the device-mapper core rather
 * than here in the target.
 *
 * m->lock must be held on entry.
 *
 * If m->queue_if_no_path and m->saved_queue_if_no_path hold the
 * same value then we are not between multipath_presuspend()
 * and multipath_resume() calls and we have no need to check
 * for the DMF_NOFLUSH_SUSPENDING flag.
 */
static int __must_push_back(struct multipath *m)
{
374 375 376
	return (m->queue_if_no_path ||
		(m->queue_if_no_path != m->saved_queue_if_no_path &&
		 dm_noflush_suspending(m->ti)));
377 378
}

H
Hannes Reinecke 已提交
379 380 381
/*
 * Map cloned requests
 */
382 383 384
static int __multipath_map(struct dm_target *ti, struct request *clone,
			   union map_info *map_context,
			   struct request *rq, struct request **__clone)
L
Linus Torvalds 已提交
385
{
H
Hannes Reinecke 已提交
386
	struct multipath *m = (struct multipath *) ti->private;
387
	int r = DM_MAPIO_REQUEUE;
388
	size_t nr_bytes = clone ? blk_rq_bytes(clone) : blk_rq_bytes(rq);
L
Linus Torvalds 已提交
389
	struct pgpath *pgpath;
390
	struct block_device *bdev;
391
	struct dm_mpath_io *mpio;
L
Linus Torvalds 已提交
392

393
	spin_lock_irq(&m->lock);
L
Linus Torvalds 已提交
394 395 396 397

	/* Do we need to select a new pgpath? */
	if (!m->current_pgpath ||
	    (!m->queue_io && (m->repeat_count && --m->repeat_count == 0)))
398
		__choose_pgpath(m, nr_bytes);
L
Linus Torvalds 已提交
399 400 401

	pgpath = m->current_pgpath;

402 403 404 405
	if (!pgpath) {
		if (!__must_push_back(m))
			r = -EIO;	/* Failed */
		goto out_unlock;
406
	} else if (m->queue_io || m->pg_init_required) {
407
		__pg_init_all_paths(m);
408 409
		goto out_unlock;
	}
410

411 412 413 414
	if (set_mapinfo(m, map_context) < 0)
		/* ENOMEM, requeue */
		goto out_unlock;

415 416 417 418
	mpio = map_context->ptr;
	mpio->pgpath = pgpath;
	mpio->nr_bytes = nr_bytes;

419
	bdev = pgpath->path.dev->bdev;
420 421 422

	spin_unlock_irq(&m->lock);

423 424 425 426 427 428 429 430
	if (clone) {
		/* Old request-based interface: allocated clone is passed in */
		clone->q = bdev_get_queue(bdev);
		clone->rq_disk = bdev->bd_disk;
		clone->cmd_flags |= REQ_FAILFAST_TRANSPORT;
	} else {
		/* blk-mq request-based interface */
		*__clone = blk_get_request(bdev_get_queue(bdev),
431
					   rq_data_dir(rq), GFP_ATOMIC);
432 433 434 435 436 437 438 439
		if (IS_ERR(*__clone))
			/* ENOMEM, requeue */
			return r;
		(*__clone)->bio = (*__clone)->biotail = NULL;
		(*__clone)->rq_disk = bdev->bd_disk;
		(*__clone)->cmd_flags |= REQ_FAILFAST_TRANSPORT;
	}

440 441 442 443
	if (pgpath->pg->ps.type->start_io)
		pgpath->pg->ps.type->start_io(&pgpath->pg->ps,
					      &pgpath->path,
					      nr_bytes);
444
	return DM_MAPIO_REMAPPED;
L
Linus Torvalds 已提交
445

446
out_unlock:
447
	spin_unlock_irq(&m->lock);
L
Linus Torvalds 已提交
448 449 450 451

	return r;
}

452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
static int multipath_map(struct dm_target *ti, struct request *clone,
			 union map_info *map_context)
{
	return __multipath_map(ti, clone, map_context, NULL, NULL);
}

static int multipath_clone_and_map(struct dm_target *ti, struct request *rq,
				   union map_info *map_context,
				   struct request **clone)
{
	return __multipath_map(ti, NULL, map_context, rq, clone);
}

static void multipath_release_clone(struct request *clone)
{
	blk_put_request(clone);
}

L
Linus Torvalds 已提交
470 471 472
/*
 * If we run out of usable paths, should we queue I/O or error it?
 */
473 474
static int queue_if_no_path(struct multipath *m, unsigned queue_if_no_path,
			    unsigned save_old_value)
L
Linus Torvalds 已提交
475 476 477 478 479
{
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);

480 481 482 483
	if (save_old_value)
		m->saved_queue_if_no_path = m->queue_if_no_path;
	else
		m->saved_queue_if_no_path = queue_if_no_path;
L
Linus Torvalds 已提交
484 485 486
	m->queue_if_no_path = queue_if_no_path;
	spin_unlock_irqrestore(&m->lock, flags);

487 488 489
	if (!queue_if_no_path)
		dm_table_run_md_queue_async(m->ti->table);

L
Linus Torvalds 已提交
490 491 492 493 494 495 496
	return 0;
}

/*
 * An event is triggered whenever a path is taken out of use.
 * Includes path failure and PG bypass.
 */
D
David Howells 已提交
497
static void trigger_event(struct work_struct *work)
L
Linus Torvalds 已提交
498
{
D
David Howells 已提交
499 500
	struct multipath *m =
		container_of(work, struct multipath, trigger_event);
L
Linus Torvalds 已提交
501 502 503 504 505 506 507 508 509 510 511 512 513 514

	dm_table_event(m->ti->table);
}

/*-----------------------------------------------------------------
 * Constructor/argument parsing:
 * <#multipath feature args> [<arg>]*
 * <#hw_handler args> [hw_handler [<arg>]*]
 * <#priority groups>
 * <initial priority group>
 *     [<selector> <#selector args> [<arg>]*
 *      <#paths> <#per-path selector args>
 *         [<path> [<arg>]* ]+ ]+
 *---------------------------------------------------------------*/
515
static int parse_path_selector(struct dm_arg_set *as, struct priority_group *pg,
L
Linus Torvalds 已提交
516 517 518 519 520 521
			       struct dm_target *ti)
{
	int r;
	struct path_selector_type *pst;
	unsigned ps_argc;

522
	static struct dm_arg _args[] = {
523
		{0, 1024, "invalid number of path selector args"},
L
Linus Torvalds 已提交
524 525
	};

526
	pst = dm_get_path_selector(dm_shift_arg(as));
L
Linus Torvalds 已提交
527
	if (!pst) {
528
		ti->error = "unknown path selector type";
L
Linus Torvalds 已提交
529 530 531
		return -EINVAL;
	}

532
	r = dm_read_arg_group(_args, as, &ps_argc, &ti->error);
533 534
	if (r) {
		dm_put_path_selector(pst);
L
Linus Torvalds 已提交
535
		return -EINVAL;
536
	}
L
Linus Torvalds 已提交
537 538 539 540

	r = pst->create(&pg->ps, ps_argc, as->argv);
	if (r) {
		dm_put_path_selector(pst);
541
		ti->error = "path selector constructor failed";
L
Linus Torvalds 已提交
542 543 544 545
		return r;
	}

	pg->ps.type = pst;
546
	dm_consume_args(as, ps_argc);
L
Linus Torvalds 已提交
547 548 549 550

	return 0;
}

551
static struct pgpath *parse_path(struct dm_arg_set *as, struct path_selector *ps,
L
Linus Torvalds 已提交
552 553 554 555
			       struct dm_target *ti)
{
	int r;
	struct pgpath *p;
556
	struct multipath *m = ti->private;
557 558
	struct request_queue *q = NULL;
	const char *attached_handler_name;
L
Linus Torvalds 已提交
559 560 561

	/* we need at least a path arg */
	if (as->argc < 1) {
562
		ti->error = "no device given";
563
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
564 565 566 567
	}

	p = alloc_pgpath();
	if (!p)
568
		return ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
569

570
	r = dm_get_device(ti, dm_shift_arg(as), dm_table_get_mode(ti->table),
571
			  &p->path.dev);
L
Linus Torvalds 已提交
572
	if (r) {
573
		ti->error = "error getting device";
L
Linus Torvalds 已提交
574 575 576
		goto bad;
	}

577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
	if (m->retain_attached_hw_handler || m->hw_handler_name)
		q = bdev_get_queue(p->path.dev->bdev);

	if (m->retain_attached_hw_handler) {
		attached_handler_name = scsi_dh_attached_handler_name(q, GFP_KERNEL);
		if (attached_handler_name) {
			/*
			 * Reset hw_handler_name to match the attached handler
			 * and clear any hw_handler_params associated with the
			 * ignored handler.
			 *
			 * NB. This modifies the table line to show the actual
			 * handler instead of the original table passed in.
			 */
			kfree(m->hw_handler_name);
			m->hw_handler_name = attached_handler_name;

			kfree(m->hw_handler_params);
			m->hw_handler_params = NULL;
		}
	}
598

599 600 601 602 603
	if (m->hw_handler_name) {
		/*
		 * Increments scsi_dh reference, even when using an
		 * already-attached handler.
		 */
604 605 606
		r = scsi_dh_attach(q, m->hw_handler_name);
		if (r == -EBUSY) {
			/*
607
			 * Already attached to different hw_handler:
608 609 610 611 612 613
			 * try to reattach with correct one.
			 */
			scsi_dh_detach(q);
			r = scsi_dh_attach(q, m->hw_handler_name);
		}

614
		if (r < 0) {
615
			ti->error = "error attaching hardware handler";
616 617 618
			dm_put_device(ti, p->path.dev);
			goto bad;
		}
619 620 621 622 623 624 625 626 627 628 629

		if (m->hw_handler_params) {
			r = scsi_dh_set_params(q, m->hw_handler_params);
			if (r < 0) {
				ti->error = "unable to set hardware "
							"handler parameters";
				scsi_dh_detach(q);
				dm_put_device(ti, p->path.dev);
				goto bad;
			}
		}
630 631
	}

L
Linus Torvalds 已提交
632 633 634 635 636 637 638 639 640 641
	r = ps->type->add_path(ps, &p->path, as->argc, as->argv, &ti->error);
	if (r) {
		dm_put_device(ti, p->path.dev);
		goto bad;
	}

	return p;

 bad:
	free_pgpath(p);
642
	return ERR_PTR(r);
L
Linus Torvalds 已提交
643 644
}

645
static struct priority_group *parse_priority_group(struct dm_arg_set *as,
M
Micha³ Miros³aw 已提交
646
						   struct multipath *m)
L
Linus Torvalds 已提交
647
{
648
	static struct dm_arg _args[] = {
649 650
		{1, 1024, "invalid number of paths"},
		{0, 1024, "invalid number of selector args"}
L
Linus Torvalds 已提交
651 652 653
	};

	int r;
654
	unsigned i, nr_selector_args, nr_args;
L
Linus Torvalds 已提交
655
	struct priority_group *pg;
M
Micha³ Miros³aw 已提交
656
	struct dm_target *ti = m->ti;
L
Linus Torvalds 已提交
657 658 659

	if (as->argc < 2) {
		as->argc = 0;
660 661
		ti->error = "not enough priority group arguments";
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
662 663 664 665
	}

	pg = alloc_priority_group();
	if (!pg) {
666
		ti->error = "couldn't allocate priority group";
667
		return ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
668 669 670 671 672 673 674 675 676 677
	}
	pg->m = m;

	r = parse_path_selector(as, pg, ti);
	if (r)
		goto bad;

	/*
	 * read the paths
	 */
678
	r = dm_read_arg(_args, as, &pg->nr_pgpaths, &ti->error);
L
Linus Torvalds 已提交
679 680 681
	if (r)
		goto bad;

682
	r = dm_read_arg(_args + 1, as, &nr_selector_args, &ti->error);
L
Linus Torvalds 已提交
683 684 685
	if (r)
		goto bad;

686
	nr_args = 1 + nr_selector_args;
L
Linus Torvalds 已提交
687 688
	for (i = 0; i < pg->nr_pgpaths; i++) {
		struct pgpath *pgpath;
689
		struct dm_arg_set path_args;
L
Linus Torvalds 已提交
690

691
		if (as->argc < nr_args) {
692
			ti->error = "not enough path parameters";
693
			r = -EINVAL;
L
Linus Torvalds 已提交
694
			goto bad;
695
		}
L
Linus Torvalds 已提交
696

697
		path_args.argc = nr_args;
L
Linus Torvalds 已提交
698 699 700
		path_args.argv = as->argv;

		pgpath = parse_path(&path_args, &pg->ps, ti);
701 702
		if (IS_ERR(pgpath)) {
			r = PTR_ERR(pgpath);
L
Linus Torvalds 已提交
703
			goto bad;
704
		}
L
Linus Torvalds 已提交
705 706 707

		pgpath->pg = pg;
		list_add_tail(&pgpath->list, &pg->pgpaths);
708
		dm_consume_args(as, nr_args);
L
Linus Torvalds 已提交
709 710 711 712 713 714
	}

	return pg;

 bad:
	free_priority_group(pg, ti);
715
	return ERR_PTR(r);
L
Linus Torvalds 已提交
716 717
}

718
static int parse_hw_handler(struct dm_arg_set *as, struct multipath *m)
L
Linus Torvalds 已提交
719 720
{
	unsigned hw_argc;
721
	int ret;
M
Micha³ Miros³aw 已提交
722
	struct dm_target *ti = m->ti;
L
Linus Torvalds 已提交
723

724
	static struct dm_arg _args[] = {
725
		{0, 1024, "invalid number of hardware handler args"},
L
Linus Torvalds 已提交
726 727
	};

728
	if (dm_read_arg_group(_args, as, &hw_argc, &ti->error))
L
Linus Torvalds 已提交
729 730 731 732 733
		return -EINVAL;

	if (!hw_argc)
		return 0;

734
	m->hw_handler_name = kstrdup(dm_shift_arg(as), GFP_KERNEL);
735 736
	if (!try_then_request_module(scsi_dh_handler_exist(m->hw_handler_name),
				     "scsi_dh_%s", m->hw_handler_name)) {
737
		ti->error = "unknown hardware handler type";
738 739
		ret = -EINVAL;
		goto fail;
L
Linus Torvalds 已提交
740
	}
741

742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757
	if (hw_argc > 1) {
		char *p;
		int i, j, len = 4;

		for (i = 0; i <= hw_argc - 2; i++)
			len += strlen(as->argv[i]) + 1;
		p = m->hw_handler_params = kzalloc(len, GFP_KERNEL);
		if (!p) {
			ti->error = "memory allocation failed";
			ret = -ENOMEM;
			goto fail;
		}
		j = sprintf(p, "%d", hw_argc - 1);
		for (i = 0, p+=j+1; i <= hw_argc - 2; i++, p+=j+1)
			j = sprintf(p, "%s", as->argv[i]);
	}
758
	dm_consume_args(as, hw_argc - 1);
L
Linus Torvalds 已提交
759 760

	return 0;
761 762 763 764
fail:
	kfree(m->hw_handler_name);
	m->hw_handler_name = NULL;
	return ret;
L
Linus Torvalds 已提交
765 766
}

767
static int parse_features(struct dm_arg_set *as, struct multipath *m)
L
Linus Torvalds 已提交
768 769 770
{
	int r;
	unsigned argc;
M
Micha³ Miros³aw 已提交
771
	struct dm_target *ti = m->ti;
772
	const char *arg_name;
L
Linus Torvalds 已提交
773

774
	static struct dm_arg _args[] = {
775
		{0, 6, "invalid number of feature args"},
D
Dave Wysochanski 已提交
776
		{1, 50, "pg_init_retries must be between 1 and 50"},
777
		{0, 60000, "pg_init_delay_msecs must be between 0 and 60000"},
L
Linus Torvalds 已提交
778 779
	};

780
	r = dm_read_arg_group(_args, as, &argc, &ti->error);
L
Linus Torvalds 已提交
781 782 783 784 785 786
	if (r)
		return -EINVAL;

	if (!argc)
		return 0;

D
Dave Wysochanski 已提交
787
	do {
788
		arg_name = dm_shift_arg(as);
D
Dave Wysochanski 已提交
789 790
		argc--;

791
		if (!strcasecmp(arg_name, "queue_if_no_path")) {
D
Dave Wysochanski 已提交
792 793 794 795
			r = queue_if_no_path(m, 1, 0);
			continue;
		}

796 797 798 799 800
		if (!strcasecmp(arg_name, "retain_attached_hw_handler")) {
			m->retain_attached_hw_handler = 1;
			continue;
		}

801
		if (!strcasecmp(arg_name, "pg_init_retries") &&
D
Dave Wysochanski 已提交
802
		    (argc >= 1)) {
803
			r = dm_read_arg(_args + 1, as, &m->pg_init_retries, &ti->error);
D
Dave Wysochanski 已提交
804 805 806 807
			argc--;
			continue;
		}

808
		if (!strcasecmp(arg_name, "pg_init_delay_msecs") &&
809
		    (argc >= 1)) {
810
			r = dm_read_arg(_args + 2, as, &m->pg_init_delay_msecs, &ti->error);
811 812 813 814
			argc--;
			continue;
		}

L
Linus Torvalds 已提交
815
		ti->error = "Unrecognised multipath feature request";
D
Dave Wysochanski 已提交
816 817 818 819
		r = -EINVAL;
	} while (argc && !r);

	return r;
L
Linus Torvalds 已提交
820 821 822 823 824
}

static int multipath_ctr(struct dm_target *ti, unsigned int argc,
			 char **argv)
{
825 826
	/* target arguments */
	static struct dm_arg _args[] = {
827 828
		{0, 1024, "invalid number of priority groups"},
		{0, 1024, "invalid initial priority group number"},
L
Linus Torvalds 已提交
829 830 831 832
	};

	int r;
	struct multipath *m;
833
	struct dm_arg_set as;
L
Linus Torvalds 已提交
834 835 836 837 838 839
	unsigned pg_count = 0;
	unsigned next_pg_num;

	as.argc = argc;
	as.argv = argv;

M
Micha³ Miros³aw 已提交
840
	m = alloc_multipath(ti);
L
Linus Torvalds 已提交
841
	if (!m) {
842
		ti->error = "can't allocate multipath";
L
Linus Torvalds 已提交
843 844 845
		return -EINVAL;
	}

M
Micha³ Miros³aw 已提交
846
	r = parse_features(&as, m);
L
Linus Torvalds 已提交
847 848 849
	if (r)
		goto bad;

M
Micha³ Miros³aw 已提交
850
	r = parse_hw_handler(&as, m);
L
Linus Torvalds 已提交
851 852 853
	if (r)
		goto bad;

854
	r = dm_read_arg(_args, &as, &m->nr_priority_groups, &ti->error);
L
Linus Torvalds 已提交
855 856 857
	if (r)
		goto bad;

858
	r = dm_read_arg(_args + 1, &as, &next_pg_num, &ti->error);
L
Linus Torvalds 已提交
859 860 861
	if (r)
		goto bad;

862 863 864 865 866 867 868
	if ((!m->nr_priority_groups && next_pg_num) ||
	    (m->nr_priority_groups && !next_pg_num)) {
		ti->error = "invalid initial priority group";
		r = -EINVAL;
		goto bad;
	}

L
Linus Torvalds 已提交
869 870 871 872
	/* parse the priority groups */
	while (as.argc) {
		struct priority_group *pg;

M
Micha³ Miros³aw 已提交
873
		pg = parse_priority_group(&as, m);
874 875
		if (IS_ERR(pg)) {
			r = PTR_ERR(pg);
L
Linus Torvalds 已提交
876 877 878 879 880 881 882 883 884 885 886 887
			goto bad;
		}

		m->nr_valid_paths += pg->nr_pgpaths;
		list_add_tail(&pg->list, &m->priority_groups);
		pg_count++;
		pg->pg_num = pg_count;
		if (!--next_pg_num)
			m->next_pg = pg;
	}

	if (pg_count != m->nr_priority_groups) {
888
		ti->error = "priority group count mismatch";
L
Linus Torvalds 已提交
889 890 891 892
		r = -EINVAL;
		goto bad;
	}

893 894
	ti->num_flush_bios = 1;
	ti->num_discard_bios = 1;
895
	ti->num_write_same_bios = 1;
M
Mikulas Patocka 已提交
896

L
Linus Torvalds 已提交
897 898 899 900 901 902 903
	return 0;

 bad:
	free_multipath(m);
	return r;
}

904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928
static void multipath_wait_for_pg_init_completion(struct multipath *m)
{
	DECLARE_WAITQUEUE(wait, current);
	unsigned long flags;

	add_wait_queue(&m->pg_init_wait, &wait);

	while (1) {
		set_current_state(TASK_UNINTERRUPTIBLE);

		spin_lock_irqsave(&m->lock, flags);
		if (!m->pg_init_in_progress) {
			spin_unlock_irqrestore(&m->lock, flags);
			break;
		}
		spin_unlock_irqrestore(&m->lock, flags);

		io_schedule();
	}
	set_current_state(TASK_RUNNING);

	remove_wait_queue(&m->pg_init_wait, &wait);
}

static void flush_multipath_work(struct multipath *m)
L
Linus Torvalds 已提交
929
{
930 931 932 933 934 935
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);
	m->pg_init_disabled = 1;
	spin_unlock_irqrestore(&m->lock, flags);

936
	flush_workqueue(kmpath_handlerd);
937
	multipath_wait_for_pg_init_completion(m);
938
	flush_workqueue(kmultipathd);
939
	flush_work(&m->trigger_event);
940 941 942 943

	spin_lock_irqsave(&m->lock, flags);
	m->pg_init_disabled = 0;
	spin_unlock_irqrestore(&m->lock, flags);
944 945 946 947 948 949
}

static void multipath_dtr(struct dm_target *ti)
{
	struct multipath *m = ti->private;

950
	flush_multipath_work(m);
L
Linus Torvalds 已提交
951 952 953 954 955 956 957 958 959 960 961 962 963
	free_multipath(m);
}

/*
 * Take a path out of use.
 */
static int fail_path(struct pgpath *pgpath)
{
	unsigned long flags;
	struct multipath *m = pgpath->pg->m;

	spin_lock_irqsave(&m->lock, flags);

964
	if (!pgpath->is_active)
L
Linus Torvalds 已提交
965 966
		goto out;

967
	DMWARN("Failing path %s.", pgpath->path.dev->name);
L
Linus Torvalds 已提交
968 969

	pgpath->pg->ps.type->fail_path(&pgpath->pg->ps, &pgpath->path);
970
	pgpath->is_active = 0;
L
Linus Torvalds 已提交
971 972 973 974 975 976 977
	pgpath->fail_count++;

	m->nr_valid_paths--;

	if (pgpath == m->current_pgpath)
		m->current_pgpath = NULL;

M
Mike Anderson 已提交
978 979 980
	dm_path_uevent(DM_UEVENT_PATH_FAILED, m->ti,
		      pgpath->path.dev->name, m->nr_valid_paths);

981
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
982 983 984 985 986 987 988 989 990 991 992 993

out:
	spin_unlock_irqrestore(&m->lock, flags);

	return 0;
}

/*
 * Reinstate a previously-failed path
 */
static int reinstate_path(struct pgpath *pgpath)
{
994
	int r = 0, run_queue = 0;
L
Linus Torvalds 已提交
995 996 997 998 999
	unsigned long flags;
	struct multipath *m = pgpath->pg->m;

	spin_lock_irqsave(&m->lock, flags);

1000
	if (pgpath->is_active)
L
Linus Torvalds 已提交
1001 1002
		goto out;

1003
	if (!pgpath->pg->ps.type->reinstate_path) {
L
Linus Torvalds 已提交
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
		DMWARN("Reinstate path not supported by path selector %s",
		       pgpath->pg->ps.type->name);
		r = -EINVAL;
		goto out;
	}

	r = pgpath->pg->ps.type->reinstate_path(&pgpath->pg->ps, &pgpath->path);
	if (r)
		goto out;

1014
	pgpath->is_active = 1;
L
Linus Torvalds 已提交
1015

1016
	if (!m->nr_valid_paths++) {
1017
		m->current_pgpath = NULL;
1018
		run_queue = 1;
1019
	} else if (m->hw_handler_name && (m->current_pg == pgpath->pg)) {
1020
		if (queue_work(kmpath_handlerd, &pgpath->activate_path.work))
1021 1022
			m->pg_init_in_progress++;
	}
L
Linus Torvalds 已提交
1023

M
Mike Anderson 已提交
1024 1025 1026
	dm_path_uevent(DM_UEVENT_PATH_REINSTATED, m->ti,
		      pgpath->path.dev->name, m->nr_valid_paths);

1027
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1028 1029 1030

out:
	spin_unlock_irqrestore(&m->lock, flags);
1031 1032
	if (run_queue)
		dm_table_run_md_queue_async(m->ti->table);
L
Linus Torvalds 已提交
1033 1034 1035 1036 1037 1038 1039 1040 1041 1042

	return r;
}

/*
 * Fail or reinstate all paths that match the provided struct dm_dev.
 */
static int action_dev(struct multipath *m, struct dm_dev *dev,
		      action_fn action)
{
1043
	int r = -EINVAL;
L
Linus Torvalds 已提交
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
	struct pgpath *pgpath;
	struct priority_group *pg;

	list_for_each_entry(pg, &m->priority_groups, list) {
		list_for_each_entry(pgpath, &pg->pgpaths, list) {
			if (pgpath->path.dev == dev)
				r = action(pgpath);
		}
	}

	return r;
}

/*
 * Temporarily try to avoid having to use the specified PG
 */
static void bypass_pg(struct multipath *m, struct priority_group *pg,
		      int bypassed)
{
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);

	pg->bypassed = bypassed;
	m->current_pgpath = NULL;
	m->current_pg = NULL;

	spin_unlock_irqrestore(&m->lock, flags);

1073
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
}

/*
 * Switch to using the specified PG from the next I/O that gets mapped
 */
static int switch_pg_num(struct multipath *m, const char *pgstr)
{
	struct priority_group *pg;
	unsigned pgnum;
	unsigned long flags;
1084
	char dummy;
L
Linus Torvalds 已提交
1085

1086
	if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
L
Linus Torvalds 已提交
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
	    (pgnum > m->nr_priority_groups)) {
		DMWARN("invalid PG number supplied to switch_pg_num");
		return -EINVAL;
	}

	spin_lock_irqsave(&m->lock, flags);
	list_for_each_entry(pg, &m->priority_groups, list) {
		pg->bypassed = 0;
		if (--pgnum)
			continue;

		m->current_pgpath = NULL;
		m->current_pg = NULL;
		m->next_pg = pg;
	}
	spin_unlock_irqrestore(&m->lock, flags);

1104
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
	return 0;
}

/*
 * Set/clear bypassed status of a PG.
 * PGs are numbered upwards from 1 in the order they were declared.
 */
static int bypass_pg_num(struct multipath *m, const char *pgstr, int bypassed)
{
	struct priority_group *pg;
	unsigned pgnum;
1116
	char dummy;
L
Linus Torvalds 已提交
1117

1118
	if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
L
Linus Torvalds 已提交
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
	    (pgnum > m->nr_priority_groups)) {
		DMWARN("invalid PG number supplied to bypass_pg");
		return -EINVAL;
	}

	list_for_each_entry(pg, &m->priority_groups, list) {
		if (!--pgnum)
			break;
	}

	bypass_pg(m, pg, bypassed);
	return 0;
}

D
Dave Wysochanski 已提交
1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
/*
 * Should we retry pg_init immediately?
 */
static int pg_init_limit_reached(struct multipath *m, struct pgpath *pgpath)
{
	unsigned long flags;
	int limit_reached = 0;

	spin_lock_irqsave(&m->lock, flags);

1143
	if (m->pg_init_count <= m->pg_init_retries && !m->pg_init_disabled)
D
Dave Wysochanski 已提交
1144 1145 1146 1147 1148 1149 1150 1151 1152
		m->pg_init_required = 1;
	else
		limit_reached = 1;

	spin_unlock_irqrestore(&m->lock, flags);

	return limit_reached;
}

1153
static void pg_init_done(void *data, int errors)
1154
{
1155
	struct pgpath *pgpath = data;
1156 1157 1158
	struct priority_group *pg = pgpath->pg;
	struct multipath *m = pg->m;
	unsigned long flags;
1159
	unsigned delay_retry = 0;
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169

	/* device or driver problems */
	switch (errors) {
	case SCSI_DH_OK:
		break;
	case SCSI_DH_NOSYS:
		if (!m->hw_handler_name) {
			errors = 0;
			break;
		}
1170 1171
		DMERR("Could not failover the device: Handler scsi_dh_%s "
		      "Error %d.", m->hw_handler_name, errors);
1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
		/*
		 * Fail path for now, so we do not ping pong
		 */
		fail_path(pgpath);
		break;
	case SCSI_DH_DEV_TEMP_BUSY:
		/*
		 * Probably doing something like FW upgrade on the
		 * controller so try the other pg.
		 */
		bypass_pg(m, pg, 1);
		break;
	case SCSI_DH_RETRY:
1185 1186
		/* Wait before retrying. */
		delay_retry = 1;
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
	case SCSI_DH_IMM_RETRY:
	case SCSI_DH_RES_TEMP_UNAVAIL:
		if (pg_init_limit_reached(m, pgpath))
			fail_path(pgpath);
		errors = 0;
		break;
	default:
		/*
		 * We probably do not want to fail the path for a device
		 * error, but this is what the old dm did. In future
		 * patches we can do more advanced handling.
		 */
		fail_path(pgpath);
	}

	spin_lock_irqsave(&m->lock, flags);
	if (errors) {
1204 1205 1206 1207 1208
		if (pgpath == m->current_pgpath) {
			DMERR("Could not failover device. Error %d.", errors);
			m->current_pgpath = NULL;
			m->current_pg = NULL;
		}
1209
	} else if (!m->pg_init_required)
1210 1211
		pg->bypassed = 0;

1212 1213 1214 1215
	if (--m->pg_init_in_progress)
		/* Activations of other paths are still on going */
		goto out;

1216 1217 1218 1219 1220 1221
	if (m->pg_init_required) {
		m->pg_init_delay_retry = delay_retry;
		if (__pg_init_all_paths(m))
			goto out;
	}
	m->queue_io = 0;
1222

1223 1224 1225 1226 1227
	/*
	 * Wake up any thread waiting to suspend.
	 */
	wake_up(&m->pg_init_wait);

1228
out:
1229 1230 1231
	spin_unlock_irqrestore(&m->lock, flags);
}

1232 1233
static void activate_path(struct work_struct *work)
{
1234
	struct pgpath *pgpath =
1235
		container_of(work, struct pgpath, activate_path.work);
1236

1237 1238 1239 1240 1241
	if (pgpath->is_active)
		scsi_dh_activate(bdev_get_queue(pgpath->path.dev->bdev),
				 pg_init_done, pgpath);
	else
		pg_init_done(pgpath, SCSI_DH_DEV_OFFLINED);
1242 1243
}

1244 1245 1246 1247 1248 1249 1250
static int noretry_error(int error)
{
	switch (error) {
	case -EOPNOTSUPP:
	case -EREMOTEIO:
	case -EILSEQ:
	case -ENODATA:
1251
	case -ENOSPC:
1252 1253 1254 1255 1256 1257 1258
		return 1;
	}

	/* Anything else could be a path failure, so should be retried */
	return 0;
}

L
Linus Torvalds 已提交
1259 1260 1261
/*
 * end_io handling
 */
1262
static int do_end_io(struct multipath *m, struct request *clone,
A
Alasdair G Kergon 已提交
1263
		     int error, struct dm_mpath_io *mpio)
L
Linus Torvalds 已提交
1264
{
1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276
	/*
	 * We don't queue any clone request inside the multipath target
	 * during end I/O handling, since those clone requests don't have
	 * bio clones.  If we queue them inside the multipath target,
	 * we need to make bio clones, that requires memory allocation.
	 * (See drivers/md/dm.c:end_clone_bio() about why the clone requests
	 *  don't have bio clones.)
	 * Instead of queueing the clone request here, we queue the original
	 * request into dm core, which will remake a clone request and
	 * clone bios for it and resubmit it later.
	 */
	int r = DM_ENDIO_REQUEUE;
1277
	unsigned long flags;
L
Linus Torvalds 已提交
1278

1279
	if (!error && !clone->errors)
L
Linus Torvalds 已提交
1280 1281
		return 0;	/* I/O complete */

1282
	if (noretry_error(error))
M
Mike Snitzer 已提交
1283 1284
		return error;

1285 1286
	if (mpio->pgpath)
		fail_path(mpio->pgpath);
L
Linus Torvalds 已提交
1287

1288
	spin_lock_irqsave(&m->lock, flags);
1289 1290 1291 1292 1293 1294 1295 1296 1297
	if (!m->nr_valid_paths) {
		if (!m->queue_if_no_path) {
			if (!__must_push_back(m))
				r = -EIO;
		} else {
			if (error == -EBADE)
				r = error;
		}
	}
1298
	spin_unlock_irqrestore(&m->lock, flags);
L
Linus Torvalds 已提交
1299

1300
	return r;
L
Linus Torvalds 已提交
1301 1302
}

1303
static int multipath_end_io(struct dm_target *ti, struct request *clone,
L
Linus Torvalds 已提交
1304 1305
			    int error, union map_info *map_context)
{
A
Alasdair G Kergon 已提交
1306 1307
	struct multipath *m = ti->private;
	struct dm_mpath_io *mpio = map_context->ptr;
1308
	struct pgpath *pgpath;
L
Linus Torvalds 已提交
1309 1310 1311
	struct path_selector *ps;
	int r;

1312 1313
	BUG_ON(!mpio);

1314
	r  = do_end_io(m, clone, error, mpio);
1315
	pgpath = mpio->pgpath;
L
Linus Torvalds 已提交
1316 1317 1318
	if (pgpath) {
		ps = &pgpath->pg->ps;
		if (ps->type->end_io)
1319
			ps->type->end_io(ps, &pgpath->path, mpio->nr_bytes);
L
Linus Torvalds 已提交
1320
	}
1321
	clear_mapinfo(m, map_context);
L
Linus Torvalds 已提交
1322 1323 1324 1325 1326 1327

	return r;
}

/*
 * Suspend can't complete until all the I/O is processed so if
1328 1329 1330
 * the last path fails we must error any remaining I/O.
 * Note that if the freeze_bdev fails while suspending, the
 * queue_if_no_path state is lost - userspace should reset it.
L
Linus Torvalds 已提交
1331 1332 1333 1334 1335
 */
static void multipath_presuspend(struct dm_target *ti)
{
	struct multipath *m = (struct multipath *) ti->private;

1336
	queue_if_no_path(m, 0, 1);
L
Linus Torvalds 已提交
1337 1338
}

1339 1340
static void multipath_postsuspend(struct dm_target *ti)
{
1341 1342 1343
	struct multipath *m = ti->private;

	mutex_lock(&m->work_mutex);
1344
	flush_multipath_work(m);
1345
	mutex_unlock(&m->work_mutex);
1346 1347
}

1348 1349 1350
/*
 * Restore the queue_if_no_path setting.
 */
L
Linus Torvalds 已提交
1351 1352 1353 1354 1355 1356
static void multipath_resume(struct dm_target *ti)
{
	struct multipath *m = (struct multipath *) ti->private;
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);
1357
	m->queue_if_no_path = m->saved_queue_if_no_path;
L
Linus Torvalds 已提交
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
	spin_unlock_irqrestore(&m->lock, flags);
}

/*
 * Info output has the following format:
 * num_multipath_feature_args [multipath_feature_args]*
 * num_handler_status_args [handler_status_args]*
 * num_groups init_group_number
 *            [A|D|E num_ps_status_args [ps_status_args]*
 *             num_paths num_selector_args
 *             [path_dev A|F fail_count [selector_args]* ]+ ]+
 *
 * Table output has the following format (identical to the constructor string):
 * num_feature_args [features_args]*
 * num_handler_args hw_handler [hw_handler_args]*
 * num_groups init_group_number
 *     [priority selector-name num_ps_args [ps_args]*
 *      num_paths num_selector_args [path_dev [selector_args]* ]+ ]+
 */
1377 1378
static void multipath_status(struct dm_target *ti, status_type_t type,
			     unsigned status_flags, char *result, unsigned maxlen)
L
Linus Torvalds 已提交
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
{
	int sz = 0;
	unsigned long flags;
	struct multipath *m = (struct multipath *) ti->private;
	struct priority_group *pg;
	struct pgpath *p;
	unsigned pg_num;
	char state;

	spin_lock_irqsave(&m->lock, flags);

	/* Features */
	if (type == STATUSTYPE_INFO)
1392
		DMEMIT("2 %u %u ", m->queue_io, m->pg_init_count);
D
Dave Wysochanski 已提交
1393 1394
	else {
		DMEMIT("%u ", m->queue_if_no_path +
1395
			      (m->pg_init_retries > 0) * 2 +
1396 1397
			      (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT) * 2 +
			      m->retain_attached_hw_handler);
D
Dave Wysochanski 已提交
1398 1399 1400 1401
		if (m->queue_if_no_path)
			DMEMIT("queue_if_no_path ");
		if (m->pg_init_retries)
			DMEMIT("pg_init_retries %u ", m->pg_init_retries);
1402 1403
		if (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT)
			DMEMIT("pg_init_delay_msecs %u ", m->pg_init_delay_msecs);
1404 1405
		if (m->retain_attached_hw_handler)
			DMEMIT("retain_attached_hw_handler ");
D
Dave Wysochanski 已提交
1406
	}
L
Linus Torvalds 已提交
1407

1408
	if (!m->hw_handler_name || type == STATUSTYPE_INFO)
L
Linus Torvalds 已提交
1409 1410
		DMEMIT("0 ");
	else
1411
		DMEMIT("1 %s ", m->hw_handler_name);
L
Linus Torvalds 已提交
1412 1413 1414 1415 1416 1417 1418 1419

	DMEMIT("%u ", m->nr_priority_groups);

	if (m->next_pg)
		pg_num = m->next_pg->pg_num;
	else if (m->current_pg)
		pg_num = m->current_pg->pg_num;
	else
1420
		pg_num = (m->nr_priority_groups ? 1 : 0);
L
Linus Torvalds 已提交
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447

	DMEMIT("%u ", pg_num);

	switch (type) {
	case STATUSTYPE_INFO:
		list_for_each_entry(pg, &m->priority_groups, list) {
			if (pg->bypassed)
				state = 'D';	/* Disabled */
			else if (pg == m->current_pg)
				state = 'A';	/* Currently Active */
			else
				state = 'E';	/* Enabled */

			DMEMIT("%c ", state);

			if (pg->ps.type->status)
				sz += pg->ps.type->status(&pg->ps, NULL, type,
							  result + sz,
							  maxlen - sz);
			else
				DMEMIT("0 ");

			DMEMIT("%u %u ", pg->nr_pgpaths,
			       pg->ps.type->info_args);

			list_for_each_entry(p, &pg->pgpaths, list) {
				DMEMIT("%s %s %u ", p->path.dev->name,
1448
				       p->is_active ? "A" : "F",
L
Linus Torvalds 已提交
1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487
				       p->fail_count);
				if (pg->ps.type->status)
					sz += pg->ps.type->status(&pg->ps,
					      &p->path, type, result + sz,
					      maxlen - sz);
			}
		}
		break;

	case STATUSTYPE_TABLE:
		list_for_each_entry(pg, &m->priority_groups, list) {
			DMEMIT("%s ", pg->ps.type->name);

			if (pg->ps.type->status)
				sz += pg->ps.type->status(&pg->ps, NULL, type,
							  result + sz,
							  maxlen - sz);
			else
				DMEMIT("0 ");

			DMEMIT("%u %u ", pg->nr_pgpaths,
			       pg->ps.type->table_args);

			list_for_each_entry(p, &pg->pgpaths, list) {
				DMEMIT("%s ", p->path.dev->name);
				if (pg->ps.type->status)
					sz += pg->ps.type->status(&pg->ps,
					      &p->path, type, result + sz,
					      maxlen - sz);
			}
		}
		break;
	}

	spin_unlock_irqrestore(&m->lock, flags);
}

static int multipath_message(struct dm_target *ti, unsigned argc, char **argv)
{
1488
	int r = -EINVAL;
L
Linus Torvalds 已提交
1489 1490 1491 1492
	struct dm_dev *dev;
	struct multipath *m = (struct multipath *) ti->private;
	action_fn action;

1493 1494
	mutex_lock(&m->work_mutex);

1495 1496 1497 1498 1499
	if (dm_suspended(ti)) {
		r = -EBUSY;
		goto out;
	}

L
Linus Torvalds 已提交
1500
	if (argc == 1) {
1501
		if (!strcasecmp(argv[0], "queue_if_no_path")) {
1502 1503
			r = queue_if_no_path(m, 1, 0);
			goto out;
1504
		} else if (!strcasecmp(argv[0], "fail_if_no_path")) {
1505 1506 1507
			r = queue_if_no_path(m, 0, 0);
			goto out;
		}
L
Linus Torvalds 已提交
1508 1509
	}

1510
	if (argc != 2) {
1511
		DMWARN("Invalid multipath message arguments. Expected 2 arguments, got %d.", argc);
1512 1513
		goto out;
	}
L
Linus Torvalds 已提交
1514

1515
	if (!strcasecmp(argv[0], "disable_group")) {
1516 1517
		r = bypass_pg_num(m, argv[1], 1);
		goto out;
1518
	} else if (!strcasecmp(argv[0], "enable_group")) {
1519 1520
		r = bypass_pg_num(m, argv[1], 0);
		goto out;
1521
	} else if (!strcasecmp(argv[0], "switch_group")) {
1522 1523
		r = switch_pg_num(m, argv[1]);
		goto out;
1524
	} else if (!strcasecmp(argv[0], "reinstate_path"))
L
Linus Torvalds 已提交
1525
		action = reinstate_path;
1526
	else if (!strcasecmp(argv[0], "fail_path"))
L
Linus Torvalds 已提交
1527
		action = fail_path;
1528
	else {
1529
		DMWARN("Unrecognised multipath message received: %s", argv[0]);
1530 1531
		goto out;
	}
L
Linus Torvalds 已提交
1532

1533
	r = dm_get_device(ti, argv[1], dm_table_get_mode(ti->table), &dev);
L
Linus Torvalds 已提交
1534
	if (r) {
1535
		DMWARN("message: error getting device %s",
L
Linus Torvalds 已提交
1536
		       argv[1]);
1537
		goto out;
L
Linus Torvalds 已提交
1538 1539 1540 1541 1542 1543
	}

	r = action_dev(m, dev, action);

	dm_put_device(ti, dev);

1544 1545
out:
	mutex_unlock(&m->work_mutex);
L
Linus Torvalds 已提交
1546 1547 1548
	return r;
}

1549
static int multipath_ioctl(struct dm_target *ti, unsigned int cmd,
M
Milan Broz 已提交
1550 1551
			   unsigned long arg)
{
1552
	struct multipath *m = ti->private;
1553
	struct pgpath *pgpath;
1554 1555
	struct block_device *bdev;
	fmode_t mode;
M
Milan Broz 已提交
1556
	unsigned long flags;
1557 1558 1559 1560 1561
	int r;

	bdev = NULL;
	mode = 0;
	r = 0;
M
Milan Broz 已提交
1562 1563 1564 1565

	spin_lock_irqsave(&m->lock, flags);

	if (!m->current_pgpath)
1566
		__choose_pgpath(m, 0);
M
Milan Broz 已提交
1567

1568 1569 1570 1571 1572
	pgpath = m->current_pgpath;

	if (pgpath) {
		bdev = pgpath->path.dev->bdev;
		mode = pgpath->path.dev->mode;
1573
	}
M
Milan Broz 已提交
1574

1575
	if ((pgpath && m->queue_io) || (!pgpath && m->queue_if_no_path))
1576
		r = -ENOTCONN;
M
Milan Broz 已提交
1577 1578 1579 1580 1581
	else if (!bdev)
		r = -EIO;

	spin_unlock_irqrestore(&m->lock, flags);

1582 1583 1584
	/*
	 * Only pass ioctls through if the device sizes match exactly.
	 */
1585 1586 1587 1588 1589
	if (!bdev || ti->len != i_size_read(bdev->bd_inode) >> SECTOR_SHIFT) {
		int err = scsi_verify_blk_ioctl(NULL, cmd);
		if (err)
			r = err;
	}
1590

1591 1592 1593 1594 1595 1596 1597 1598
	if (r == -ENOTCONN && !fatal_signal_pending(current)) {
		spin_lock_irqsave(&m->lock, flags);
		if (!m->current_pg) {
			/* Path status changed, redo selection */
			__choose_pgpath(m, 0);
		}
		if (m->pg_init_required)
			__pg_init_all_paths(m);
1599
		spin_unlock_irqrestore(&m->lock, flags);
1600
		dm_table_run_md_queue_async(m->ti->table);
1601
	}
1602

1603
	return r ? : __blkdev_driver_ioctl(bdev, mode, cmd, arg);
M
Milan Broz 已提交
1604 1605
}

1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
static int multipath_iterate_devices(struct dm_target *ti,
				     iterate_devices_callout_fn fn, void *data)
{
	struct multipath *m = ti->private;
	struct priority_group *pg;
	struct pgpath *p;
	int ret = 0;

	list_for_each_entry(pg, &m->priority_groups, list) {
		list_for_each_entry(p, &pg->pgpaths, list) {
1616
			ret = fn(ti, p->path.dev, ti->begin, ti->len, data);
1617 1618 1619 1620 1621 1622 1623 1624 1625
			if (ret)
				goto out;
		}
	}

out:
	return ret;
}

1626 1627 1628 1629
static int __pgpath_busy(struct pgpath *pgpath)
{
	struct request_queue *q = bdev_get_queue(pgpath->path.dev->bdev);

1630
	return blk_lld_busy(q);
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650
}

/*
 * We return "busy", only when we can map I/Os but underlying devices
 * are busy (so even if we map I/Os now, the I/Os will wait on
 * the underlying queue).
 * In other words, if we want to kill I/Os or queue them inside us
 * due to map unavailability, we don't return "busy".  Otherwise,
 * dm core won't give us the I/Os and we can't do what we want.
 */
static int multipath_busy(struct dm_target *ti)
{
	int busy = 0, has_active = 0;
	struct multipath *m = ti->private;
	struct priority_group *pg;
	struct pgpath *pgpath;
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);

1651 1652 1653
	/* pg_init in progress or no paths available */
	if (m->pg_init_in_progress ||
	    (!m->nr_valid_paths && m->queue_if_no_path)) {
1654 1655 1656
		busy = 1;
		goto out;
	}
1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700
	/* Guess which priority_group will be used at next mapping time */
	if (unlikely(!m->current_pgpath && m->next_pg))
		pg = m->next_pg;
	else if (likely(m->current_pg))
		pg = m->current_pg;
	else
		/*
		 * We don't know which pg will be used at next mapping time.
		 * We don't call __choose_pgpath() here to avoid to trigger
		 * pg_init just by busy checking.
		 * So we don't know whether underlying devices we will be using
		 * at next mapping time are busy or not. Just try mapping.
		 */
		goto out;

	/*
	 * If there is one non-busy active path at least, the path selector
	 * will be able to select it. So we consider such a pg as not busy.
	 */
	busy = 1;
	list_for_each_entry(pgpath, &pg->pgpaths, list)
		if (pgpath->is_active) {
			has_active = 1;

			if (!__pgpath_busy(pgpath)) {
				busy = 0;
				break;
			}
		}

	if (!has_active)
		/*
		 * No active path in this pg, so this pg won't be used and
		 * the current_pg will be changed at next mapping time.
		 * We need to try mapping to determine it.
		 */
		busy = 0;

out:
	spin_unlock_irqrestore(&m->lock, flags);

	return busy;
}

L
Linus Torvalds 已提交
1701 1702 1703 1704 1705
/*-----------------------------------------------------------------
 * Module setup
 *---------------------------------------------------------------*/
static struct target_type multipath_target = {
	.name = "multipath",
1706
	.version = {1, 9, 0},
L
Linus Torvalds 已提交
1707 1708 1709
	.module = THIS_MODULE,
	.ctr = multipath_ctr,
	.dtr = multipath_dtr,
1710
	.map_rq = multipath_map,
1711 1712
	.clone_and_map_rq = multipath_clone_and_map,
	.release_clone_rq = multipath_release_clone,
1713
	.rq_end_io = multipath_end_io,
L
Linus Torvalds 已提交
1714
	.presuspend = multipath_presuspend,
1715
	.postsuspend = multipath_postsuspend,
L
Linus Torvalds 已提交
1716 1717 1718
	.resume = multipath_resume,
	.status = multipath_status,
	.message = multipath_message,
M
Milan Broz 已提交
1719
	.ioctl  = multipath_ioctl,
1720
	.iterate_devices = multipath_iterate_devices,
1721
	.busy = multipath_busy,
L
Linus Torvalds 已提交
1722 1723 1724 1725 1726 1727 1728
};

static int __init dm_multipath_init(void)
{
	int r;

	/* allocate a slab for the dm_ios */
A
Alasdair G Kergon 已提交
1729
	_mpio_cache = KMEM_CACHE(dm_mpath_io, 0);
L
Linus Torvalds 已提交
1730 1731 1732 1733 1734
	if (!_mpio_cache)
		return -ENOMEM;

	r = dm_register_target(&multipath_target);
	if (r < 0) {
1735
		DMERR("register failed %d", r);
1736 1737
		r = -EINVAL;
		goto bad_register_target;
L
Linus Torvalds 已提交
1738 1739
	}

1740
	kmultipathd = alloc_workqueue("kmpathd", WQ_MEM_RECLAIM, 0);
1741
	if (!kmultipathd) {
1742
		DMERR("failed to create workqueue kmpathd");
1743 1744
		r = -ENOMEM;
		goto bad_alloc_kmultipathd;
1745 1746
	}

1747 1748 1749 1750 1751 1752
	/*
	 * A separate workqueue is used to handle the device handlers
	 * to avoid overloading existing workqueue. Overloading the
	 * old workqueue would also create a bottleneck in the
	 * path of the storage hardware device activation.
	 */
1753 1754
	kmpath_handlerd = alloc_ordered_workqueue("kmpath_handlerd",
						  WQ_MEM_RECLAIM);
1755 1756
	if (!kmpath_handlerd) {
		DMERR("failed to create workqueue kmpath_handlerd");
1757 1758
		r = -ENOMEM;
		goto bad_alloc_kmpath_handlerd;
1759 1760
	}

1761
	DMINFO("version %u.%u.%u loaded",
L
Linus Torvalds 已提交
1762 1763 1764
	       multipath_target.version[0], multipath_target.version[1],
	       multipath_target.version[2]);

1765 1766 1767 1768 1769 1770 1771 1772 1773
	return 0;

bad_alloc_kmpath_handlerd:
	destroy_workqueue(kmultipathd);
bad_alloc_kmultipathd:
	dm_unregister_target(&multipath_target);
bad_register_target:
	kmem_cache_destroy(_mpio_cache);

L
Linus Torvalds 已提交
1774 1775 1776 1777 1778
	return r;
}

static void __exit dm_multipath_exit(void)
{
1779
	destroy_workqueue(kmpath_handlerd);
1780 1781
	destroy_workqueue(kmultipathd);

1782
	dm_unregister_target(&multipath_target);
L
Linus Torvalds 已提交
1783 1784 1785 1786 1787 1788 1789 1790 1791
	kmem_cache_destroy(_mpio_cache);
}

module_init(dm_multipath_init);
module_exit(dm_multipath_exit);

MODULE_DESCRIPTION(DM_NAME " multipath target");
MODULE_AUTHOR("Sistina Software <dm-devel@redhat.com>");
MODULE_LICENSE("GPL");