dm-mpath.c 41.1 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>
26
#include <linux/blk-mq.h>
L
Linus Torvalds 已提交
27

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

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

	struct priority_group *pg;	/* Owning PG */
	unsigned fail_count;		/* Cumulative failure count */

39
	struct dm_path path;
40
	struct delayed_work activate_path;
41 42

	bool is_active:1;		/* Path status */
L
Linus Torvalds 已提交
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
};

#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 nr_pgpaths;		/* Number of paths in PG */
	struct list_head pgpaths;
60 61

	bool bypassed:1;		/* Temporarily bypass this PG? */
L
Linus Torvalds 已提交
62 63 64 65 66 67 68
};

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

69
	const char *hw_handler_name;
70
	char *hw_handler_params;
71

72 73
	spinlock_t lock;

L
Linus Torvalds 已提交
74 75
	unsigned nr_priority_groups;
	struct list_head priority_groups;
76 77 78

	wait_queue_head_t pg_init_wait;	/* Wait for pg_init completion */

79
	unsigned pg_init_in_progress;	/* Only one pg_init allowed at once */
L
Linus Torvalds 已提交
80 81 82 83 84 85

	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 */

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

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

	struct work_struct trigger_event;

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

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

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

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

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

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


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

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

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

	return pgpath;
}

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

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

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

M
Micha³ Miros³aw 已提交
154 155
	if (pg)
		INIT_LIST_HEAD(&pg->pgpaths);
L
Linus Torvalds 已提交
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184

	return pg;
}

static void free_pgpaths(struct list_head *pgpaths, struct dm_target *ti)
{
	struct pgpath *pgpath, *tmp;

	list_for_each_entry_safe(pgpath, tmp, pgpaths, list) {
		list_del(&pgpath->list);
		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);
}

185
static struct multipath *alloc_multipath(struct dm_target *ti, bool use_blk_mq)
L
Linus Torvalds 已提交
186 187 188
{
	struct multipath *m;

M
Micha³ Miros³aw 已提交
189
	m = kzalloc(sizeof(*m), GFP_KERNEL);
L
Linus Torvalds 已提交
190 191 192
	if (m) {
		INIT_LIST_HEAD(&m->priority_groups);
		spin_lock_init(&m->lock);
193
		m->queue_io = true;
194
		m->pg_init_delay_msecs = DM_PG_INIT_DELAY_DEFAULT;
D
David Howells 已提交
195
		INIT_WORK(&m->trigger_event, trigger_event);
196
		init_waitqueue_head(&m->pg_init_wait);
197
		mutex_init(&m->work_mutex);
198 199 200 201 202 203 204 205 206 207

		m->mpio_pool = NULL;
		if (!use_blk_mq) {
			unsigned min_ios = dm_get_reserved_rq_based_ios();

			m->mpio_pool = mempool_create_slab_pool(min_ios, _mpio_cache);
			if (!m->mpio_pool) {
				kfree(m);
				return NULL;
			}
L
Linus Torvalds 已提交
208
		}
209

M
Micha³ Miros³aw 已提交
210 211
		m->ti = ti;
		ti->private = m;
L
Linus Torvalds 已提交
212 213 214 215 216 217 218 219 220 221 222 223 224 225
	}

	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);
	}

226
	kfree(m->hw_handler_name);
227
	kfree(m->hw_handler_params);
L
Linus Torvalds 已提交
228 229 230 231
	mempool_destroy(m->mpio_pool);
	kfree(m);
}

232 233 234 235 236 237
static struct dm_mpath_io *get_mpio(union map_info *info)
{
	return info->ptr;
}

static struct dm_mpath_io *set_mpio(struct multipath *m, union map_info *info)
238 239 240
{
	struct dm_mpath_io *mpio;

241 242
	if (!m->mpio_pool) {
		/* Use blk-mq pdu memory requested via per_io_data_size */
243
		mpio = get_mpio(info);
244 245 246 247
		memset(mpio, 0, sizeof(*mpio));
		return mpio;
	}

248 249
	mpio = mempool_alloc(m->mpio_pool, GFP_ATOMIC);
	if (!mpio)
250
		return NULL;
251 252 253 254

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

255
	return mpio;
256 257
}

258
static void clear_request_fn_mpio(struct multipath *m, union map_info *info)
259
{
260
	/* Only needed for non blk-mq (.request_fn) multipath */
261 262
	if (m->mpio_pool) {
		struct dm_mpath_io *mpio = info->ptr;
263

264 265 266
		info->ptr = NULL;
		mempool_free(mpio, m->mpio_pool);
	}
267
}
L
Linus Torvalds 已提交
268 269 270 271 272

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

273
static int __pg_init_all_paths(struct multipath *m)
K
Kiyoshi Ueda 已提交
274 275
{
	struct pgpath *pgpath;
276
	unsigned long pg_init_delay = 0;
K
Kiyoshi Ueda 已提交
277

278
	if (m->pg_init_in_progress || m->pg_init_disabled)
279
		return 0;
280

K
Kiyoshi Ueda 已提交
281
	m->pg_init_count++;
282
	m->pg_init_required = false;
283 284 285 286 287

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

288 289 290
	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 已提交
291 292 293 294
	list_for_each_entry(pgpath, &m->current_pg->pgpaths, list) {
		/* Skip failed paths */
		if (!pgpath->is_active)
			continue;
295 296
		if (queue_delayed_work(kmpath_handlerd, &pgpath->activate_path,
				       pg_init_delay))
K
Kiyoshi Ueda 已提交
297 298
			m->pg_init_in_progress++;
	}
299
	return m->pg_init_in_progress;
K
Kiyoshi Ueda 已提交
300 301
}

L
Linus Torvalds 已提交
302 303 304 305 306
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? */
307
	if (m->hw_handler_name) {
308 309
		m->pg_init_required = true;
		m->queue_io = true;
L
Linus Torvalds 已提交
310
	} else {
311 312
		m->pg_init_required = false;
		m->queue_io = false;
L
Linus Torvalds 已提交
313
	}
D
Dave Wysochanski 已提交
314 315

	m->pg_init_count = 0;
L
Linus Torvalds 已提交
316 317
}

318 319
static int __choose_path_in_pg(struct multipath *m, struct priority_group *pg,
			       size_t nr_bytes)
L
Linus Torvalds 已提交
320
{
321
	struct dm_path *path;
L
Linus Torvalds 已提交
322

323
	path = pg->ps.type->select_path(&pg->ps, nr_bytes);
L
Linus Torvalds 已提交
324 325 326 327 328 329 330 331 332 333 334
	if (!path)
		return -ENXIO;

	m->current_pgpath = path_to_pgpath(path);

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

	return 0;
}

335
static void __choose_pgpath(struct multipath *m, size_t nr_bytes)
L
Linus Torvalds 已提交
336 337
{
	struct priority_group *pg;
338
	bool bypassed = true;
L
Linus Torvalds 已提交
339

340
	if (!m->nr_valid_paths) {
341
		m->queue_io = false;
L
Linus Torvalds 已提交
342
		goto failed;
343
	}
L
Linus Torvalds 已提交
344 345 346 347 348

	/* Were we instructed to switch PG? */
	if (m->next_pg) {
		pg = m->next_pg;
		m->next_pg = NULL;
349
		if (!__choose_path_in_pg(m, pg, nr_bytes))
L
Linus Torvalds 已提交
350 351 352 353
			return;
	}

	/* Don't change PG until it has no remaining paths */
354
	if (m->current_pg && !__choose_path_in_pg(m, m->current_pg, nr_bytes))
L
Linus Torvalds 已提交
355 356 357 358 359
		return;

	/*
	 * Loop through priority groups until we find a valid path.
	 * First time we skip PGs marked 'bypassed'.
360 361
	 * Second time we only try the ones we skipped, but set
	 * pg_init_delay_retry so we do not hammer controllers.
L
Linus Torvalds 已提交
362 363 364 365 366
	 */
	do {
		list_for_each_entry(pg, &m->priority_groups, list) {
			if (pg->bypassed == bypassed)
				continue;
367 368
			if (!__choose_path_in_pg(m, pg, nr_bytes)) {
				if (!bypassed)
369
					m->pg_init_delay_retry = true;
L
Linus Torvalds 已提交
370
				return;
371
			}
L
Linus Torvalds 已提交
372 373 374 375 376 377 378 379
		}
	} while (bypassed--);

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

380 381 382 383 384 385 386 387 388 389 390 391 392
/*
 * 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)
{
393 394 395
	return (m->queue_if_no_path ||
		(m->queue_if_no_path != m->saved_queue_if_no_path &&
		 dm_noflush_suspending(m->ti)));
396 397
}

H
Hannes Reinecke 已提交
398 399 400
/*
 * Map cloned requests
 */
401 402 403
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 已提交
404
{
405
	struct multipath *m = ti->private;
406
	int r = DM_MAPIO_REQUEUE;
407
	size_t nr_bytes = clone ? blk_rq_bytes(clone) : blk_rq_bytes(rq);
L
Linus Torvalds 已提交
408
	struct pgpath *pgpath;
409
	struct block_device *bdev;
410
	struct dm_mpath_io *mpio;
L
Linus Torvalds 已提交
411

412
	spin_lock_irq(&m->lock);
L
Linus Torvalds 已提交
413 414

	/* Do we need to select a new pgpath? */
415
	if (!m->current_pgpath || !m->queue_io)
416
		__choose_pgpath(m, nr_bytes);
L
Linus Torvalds 已提交
417 418 419

	pgpath = m->current_pgpath;

420 421 422 423
	if (!pgpath) {
		if (!__must_push_back(m))
			r = -EIO;	/* Failed */
		goto out_unlock;
424
	} else if (m->queue_io || m->pg_init_required) {
425
		__pg_init_all_paths(m);
426 427
		goto out_unlock;
	}
428

429 430
	mpio = set_mpio(m, map_context);
	if (!mpio)
431 432 433
		/* ENOMEM, requeue */
		goto out_unlock;

434 435 436
	mpio->pgpath = pgpath;
	mpio->nr_bytes = nr_bytes;

437
	bdev = pgpath->path.dev->bdev;
438 439 440

	spin_unlock_irq(&m->lock);

441
	if (clone) {
442 443 444 445
		/*
		 * Old request-based interface: allocated clone is passed in.
		 * Used by: .request_fn stacked on .request_fn path(s).
		 */
446 447 448 449
		clone->q = bdev_get_queue(bdev);
		clone->rq_disk = bdev->bd_disk;
		clone->cmd_flags |= REQ_FAILFAST_TRANSPORT;
	} else {
450 451 452 453 454
		/*
		 * blk-mq request-based interface; used by both:
		 * .request_fn stacked on blk-mq path(s) and
		 * blk-mq stacked on blk-mq path(s).
		 */
455 456
		*__clone = blk_mq_alloc_request(bdev_get_queue(bdev),
						rq_data_dir(rq), BLK_MQ_REQ_NOWAIT);
457
		if (IS_ERR(*__clone)) {
458
			/* ENOMEM, requeue */
459
			clear_request_fn_mpio(m, map_context);
460
			return r;
461
		}
462 463 464 465 466
		(*__clone)->bio = (*__clone)->biotail = NULL;
		(*__clone)->rq_disk = bdev->bd_disk;
		(*__clone)->cmd_flags |= REQ_FAILFAST_TRANSPORT;
	}

467 468 469 470
	if (pgpath->pg->ps.type->start_io)
		pgpath->pg->ps.type->start_io(&pgpath->pg->ps,
					      &pgpath->path,
					      nr_bytes);
471
	return DM_MAPIO_REMAPPED;
L
Linus Torvalds 已提交
472

473
out_unlock:
474
	spin_unlock_irq(&m->lock);
L
Linus Torvalds 已提交
475 476 477 478

	return r;
}

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
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)
{
494
	blk_mq_free_request(clone);
495 496
}

L
Linus Torvalds 已提交
497 498 499
/*
 * If we run out of usable paths, should we queue I/O or error it?
 */
500 501
static int queue_if_no_path(struct multipath *m, bool queue_if_no_path,
			    bool save_old_value)
L
Linus Torvalds 已提交
502 503 504 505 506
{
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);

507 508 509 510
	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 已提交
511 512 513
	m->queue_if_no_path = queue_if_no_path;
	spin_unlock_irqrestore(&m->lock, flags);

514 515 516
	if (!queue_if_no_path)
		dm_table_run_md_queue_async(m->ti->table);

L
Linus Torvalds 已提交
517 518 519 520 521 522 523
	return 0;
}

/*
 * An event is triggered whenever a path is taken out of use.
 * Includes path failure and PG bypass.
 */
D
David Howells 已提交
524
static void trigger_event(struct work_struct *work)
L
Linus Torvalds 已提交
525
{
D
David Howells 已提交
526 527
	struct multipath *m =
		container_of(work, struct multipath, trigger_event);
L
Linus Torvalds 已提交
528 529 530 531 532 533 534 535 536 537 538 539 540 541

	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>]* ]+ ]+
 *---------------------------------------------------------------*/
542
static int parse_path_selector(struct dm_arg_set *as, struct priority_group *pg,
L
Linus Torvalds 已提交
543 544 545 546 547 548
			       struct dm_target *ti)
{
	int r;
	struct path_selector_type *pst;
	unsigned ps_argc;

549
	static struct dm_arg _args[] = {
550
		{0, 1024, "invalid number of path selector args"},
L
Linus Torvalds 已提交
551 552
	};

553
	pst = dm_get_path_selector(dm_shift_arg(as));
L
Linus Torvalds 已提交
554
	if (!pst) {
555
		ti->error = "unknown path selector type";
L
Linus Torvalds 已提交
556 557 558
		return -EINVAL;
	}

559
	r = dm_read_arg_group(_args, as, &ps_argc, &ti->error);
560 561
	if (r) {
		dm_put_path_selector(pst);
L
Linus Torvalds 已提交
562
		return -EINVAL;
563
	}
L
Linus Torvalds 已提交
564 565 566 567

	r = pst->create(&pg->ps, ps_argc, as->argv);
	if (r) {
		dm_put_path_selector(pst);
568
		ti->error = "path selector constructor failed";
L
Linus Torvalds 已提交
569 570 571 572
		return r;
	}

	pg->ps.type = pst;
573
	dm_consume_args(as, ps_argc);
L
Linus Torvalds 已提交
574 575 576 577

	return 0;
}

578
static struct pgpath *parse_path(struct dm_arg_set *as, struct path_selector *ps,
L
Linus Torvalds 已提交
579 580 581 582
			       struct dm_target *ti)
{
	int r;
	struct pgpath *p;
583
	struct multipath *m = ti->private;
584 585
	struct request_queue *q = NULL;
	const char *attached_handler_name;
L
Linus Torvalds 已提交
586 587 588

	/* we need at least a path arg */
	if (as->argc < 1) {
589
		ti->error = "no device given";
590
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
591 592 593 594
	}

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

597
	r = dm_get_device(ti, dm_shift_arg(as), dm_table_get_mode(ti->table),
598
			  &p->path.dev);
L
Linus Torvalds 已提交
599
	if (r) {
600
		ti->error = "error getting device";
L
Linus Torvalds 已提交
601 602 603
		goto bad;
	}

604 605 606 607
	if (m->retain_attached_hw_handler || m->hw_handler_name)
		q = bdev_get_queue(p->path.dev->bdev);

	if (m->retain_attached_hw_handler) {
608
retain:
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
		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;
		}
	}
626

627
	if (m->hw_handler_name) {
628 629
		r = scsi_dh_attach(q, m->hw_handler_name);
		if (r == -EBUSY) {
630
			char b[BDEVNAME_SIZE];
631

632 633 634 635
			printk(KERN_INFO "dm-mpath: retaining handler on device %s\n",
				bdevname(p->path.dev->bdev, b));
			goto retain;
		}
636
		if (r < 0) {
637
			ti->error = "error attaching hardware handler";
638 639 640
			dm_put_device(ti, p->path.dev);
			goto bad;
		}
641 642 643 644 645 646 647 648 649 650

		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";
				dm_put_device(ti, p->path.dev);
				goto bad;
			}
		}
651 652
	}

L
Linus Torvalds 已提交
653 654 655 656 657 658 659 660 661 662
	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);
663
	return ERR_PTR(r);
L
Linus Torvalds 已提交
664 665
}

666
static struct priority_group *parse_priority_group(struct dm_arg_set *as,
M
Micha³ Miros³aw 已提交
667
						   struct multipath *m)
L
Linus Torvalds 已提交
668
{
669
	static struct dm_arg _args[] = {
670 671
		{1, 1024, "invalid number of paths"},
		{0, 1024, "invalid number of selector args"}
L
Linus Torvalds 已提交
672 673 674
	};

	int r;
675
	unsigned i, nr_selector_args, nr_args;
L
Linus Torvalds 已提交
676
	struct priority_group *pg;
M
Micha³ Miros³aw 已提交
677
	struct dm_target *ti = m->ti;
L
Linus Torvalds 已提交
678 679 680

	if (as->argc < 2) {
		as->argc = 0;
681 682
		ti->error = "not enough priority group arguments";
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
683 684 685 686
	}

	pg = alloc_priority_group();
	if (!pg) {
687
		ti->error = "couldn't allocate priority group";
688
		return ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
689 690 691 692 693 694 695 696 697 698
	}
	pg->m = m;

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

	/*
	 * read the paths
	 */
699
	r = dm_read_arg(_args, as, &pg->nr_pgpaths, &ti->error);
L
Linus Torvalds 已提交
700 701 702
	if (r)
		goto bad;

703
	r = dm_read_arg(_args + 1, as, &nr_selector_args, &ti->error);
L
Linus Torvalds 已提交
704 705 706
	if (r)
		goto bad;

707
	nr_args = 1 + nr_selector_args;
L
Linus Torvalds 已提交
708 709
	for (i = 0; i < pg->nr_pgpaths; i++) {
		struct pgpath *pgpath;
710
		struct dm_arg_set path_args;
L
Linus Torvalds 已提交
711

712
		if (as->argc < nr_args) {
713
			ti->error = "not enough path parameters";
714
			r = -EINVAL;
L
Linus Torvalds 已提交
715
			goto bad;
716
		}
L
Linus Torvalds 已提交
717

718
		path_args.argc = nr_args;
L
Linus Torvalds 已提交
719 720 721
		path_args.argv = as->argv;

		pgpath = parse_path(&path_args, &pg->ps, ti);
722 723
		if (IS_ERR(pgpath)) {
			r = PTR_ERR(pgpath);
L
Linus Torvalds 已提交
724
			goto bad;
725
		}
L
Linus Torvalds 已提交
726 727 728

		pgpath->pg = pg;
		list_add_tail(&pgpath->list, &pg->pgpaths);
729
		dm_consume_args(as, nr_args);
L
Linus Torvalds 已提交
730 731 732 733 734 735
	}

	return pg;

 bad:
	free_priority_group(pg, ti);
736
	return ERR_PTR(r);
L
Linus Torvalds 已提交
737 738
}

739
static int parse_hw_handler(struct dm_arg_set *as, struct multipath *m)
L
Linus Torvalds 已提交
740 741
{
	unsigned hw_argc;
742
	int ret;
M
Micha³ Miros³aw 已提交
743
	struct dm_target *ti = m->ti;
L
Linus Torvalds 已提交
744

745
	static struct dm_arg _args[] = {
746
		{0, 1024, "invalid number of hardware handler args"},
L
Linus Torvalds 已提交
747 748
	};

749
	if (dm_read_arg_group(_args, as, &hw_argc, &ti->error))
L
Linus Torvalds 已提交
750 751 752 753 754
		return -EINVAL;

	if (!hw_argc)
		return 0;

755
	m->hw_handler_name = kstrdup(dm_shift_arg(as), GFP_KERNEL);
756

757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
	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]);
	}
773
	dm_consume_args(as, hw_argc - 1);
L
Linus Torvalds 已提交
774 775

	return 0;
776 777 778 779
fail:
	kfree(m->hw_handler_name);
	m->hw_handler_name = NULL;
	return ret;
L
Linus Torvalds 已提交
780 781
}

782
static int parse_features(struct dm_arg_set *as, struct multipath *m)
L
Linus Torvalds 已提交
783 784 785
{
	int r;
	unsigned argc;
M
Micha³ Miros³aw 已提交
786
	struct dm_target *ti = m->ti;
787
	const char *arg_name;
L
Linus Torvalds 已提交
788

789
	static struct dm_arg _args[] = {
790
		{0, 6, "invalid number of feature args"},
D
Dave Wysochanski 已提交
791
		{1, 50, "pg_init_retries must be between 1 and 50"},
792
		{0, 60000, "pg_init_delay_msecs must be between 0 and 60000"},
L
Linus Torvalds 已提交
793 794
	};

795
	r = dm_read_arg_group(_args, as, &argc, &ti->error);
L
Linus Torvalds 已提交
796 797 798 799 800 801
	if (r)
		return -EINVAL;

	if (!argc)
		return 0;

D
Dave Wysochanski 已提交
802
	do {
803
		arg_name = dm_shift_arg(as);
D
Dave Wysochanski 已提交
804 805
		argc--;

806
		if (!strcasecmp(arg_name, "queue_if_no_path")) {
807
			r = queue_if_no_path(m, true, false);
D
Dave Wysochanski 已提交
808 809 810
			continue;
		}

811
		if (!strcasecmp(arg_name, "retain_attached_hw_handler")) {
812
			m->retain_attached_hw_handler = true;
813 814 815
			continue;
		}

816
		if (!strcasecmp(arg_name, "pg_init_retries") &&
D
Dave Wysochanski 已提交
817
		    (argc >= 1)) {
818
			r = dm_read_arg(_args + 1, as, &m->pg_init_retries, &ti->error);
D
Dave Wysochanski 已提交
819 820 821 822
			argc--;
			continue;
		}

823
		if (!strcasecmp(arg_name, "pg_init_delay_msecs") &&
824
		    (argc >= 1)) {
825
			r = dm_read_arg(_args + 2, as, &m->pg_init_delay_msecs, &ti->error);
826 827 828 829
			argc--;
			continue;
		}

L
Linus Torvalds 已提交
830
		ti->error = "Unrecognised multipath feature request";
D
Dave Wysochanski 已提交
831 832 833 834
		r = -EINVAL;
	} while (argc && !r);

	return r;
L
Linus Torvalds 已提交
835 836 837 838 839
}

static int multipath_ctr(struct dm_target *ti, unsigned int argc,
			 char **argv)
{
840 841
	/* target arguments */
	static struct dm_arg _args[] = {
842 843
		{0, 1024, "invalid number of priority groups"},
		{0, 1024, "invalid initial priority group number"},
L
Linus Torvalds 已提交
844 845 846 847
	};

	int r;
	struct multipath *m;
848
	struct dm_arg_set as;
L
Linus Torvalds 已提交
849 850
	unsigned pg_count = 0;
	unsigned next_pg_num;
851
	bool use_blk_mq = dm_use_blk_mq(dm_table_get_md(ti->table));
L
Linus Torvalds 已提交
852 853 854 855

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

856
	m = alloc_multipath(ti, use_blk_mq);
L
Linus Torvalds 已提交
857
	if (!m) {
858
		ti->error = "can't allocate multipath";
L
Linus Torvalds 已提交
859 860 861
		return -EINVAL;
	}

M
Micha³ Miros³aw 已提交
862
	r = parse_features(&as, m);
L
Linus Torvalds 已提交
863 864 865
	if (r)
		goto bad;

M
Micha³ Miros³aw 已提交
866
	r = parse_hw_handler(&as, m);
L
Linus Torvalds 已提交
867 868 869
	if (r)
		goto bad;

870
	r = dm_read_arg(_args, &as, &m->nr_priority_groups, &ti->error);
L
Linus Torvalds 已提交
871 872 873
	if (r)
		goto bad;

874
	r = dm_read_arg(_args + 1, &as, &next_pg_num, &ti->error);
L
Linus Torvalds 已提交
875 876 877
	if (r)
		goto bad;

878 879 880 881 882 883 884
	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 已提交
885 886 887 888
	/* parse the priority groups */
	while (as.argc) {
		struct priority_group *pg;

M
Micha³ Miros³aw 已提交
889
		pg = parse_priority_group(&as, m);
890 891
		if (IS_ERR(pg)) {
			r = PTR_ERR(pg);
L
Linus Torvalds 已提交
892 893 894 895 896 897 898 899 900 901 902 903
			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) {
904
		ti->error = "priority group count mismatch";
L
Linus Torvalds 已提交
905 906 907 908
		r = -EINVAL;
		goto bad;
	}

909 910
	ti->num_flush_bios = 1;
	ti->num_discard_bios = 1;
911
	ti->num_write_same_bios = 1;
912 913
	if (use_blk_mq)
		ti->per_io_data_size = sizeof(struct dm_mpath_io);
M
Mikulas Patocka 已提交
914

L
Linus Torvalds 已提交
915 916 917 918 919 920 921
	return 0;

 bad:
	free_multipath(m);
	return r;
}

922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
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 已提交
947
{
948 949 950
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);
951
	m->pg_init_disabled = true;
952 953
	spin_unlock_irqrestore(&m->lock, flags);

954
	flush_workqueue(kmpath_handlerd);
955
	multipath_wait_for_pg_init_completion(m);
956
	flush_workqueue(kmultipathd);
957
	flush_work(&m->trigger_event);
958 959

	spin_lock_irqsave(&m->lock, flags);
960
	m->pg_init_disabled = false;
961
	spin_unlock_irqrestore(&m->lock, flags);
962 963 964 965 966 967
}

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

968
	flush_multipath_work(m);
L
Linus Torvalds 已提交
969 970 971 972 973 974 975 976 977 978 979 980 981
	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);

982
	if (!pgpath->is_active)
L
Linus Torvalds 已提交
983 984
		goto out;

985
	DMWARN("Failing path %s.", pgpath->path.dev->name);
L
Linus Torvalds 已提交
986 987

	pgpath->pg->ps.type->fail_path(&pgpath->pg->ps, &pgpath->path);
988
	pgpath->is_active = false;
L
Linus Torvalds 已提交
989 990 991 992 993 994 995
	pgpath->fail_count++;

	m->nr_valid_paths--;

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

M
Mike Anderson 已提交
996 997 998
	dm_path_uevent(DM_UEVENT_PATH_FAILED, m->ti,
		      pgpath->path.dev->name, m->nr_valid_paths);

999
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011

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

	return 0;
}

/*
 * Reinstate a previously-failed path
 */
static int reinstate_path(struct pgpath *pgpath)
{
1012
	int r = 0, run_queue = 0;
L
Linus Torvalds 已提交
1013 1014 1015 1016 1017
	unsigned long flags;
	struct multipath *m = pgpath->pg->m;

	spin_lock_irqsave(&m->lock, flags);

1018
	if (pgpath->is_active)
L
Linus Torvalds 已提交
1019 1020
		goto out;

1021
	if (!pgpath->pg->ps.type->reinstate_path) {
L
Linus Torvalds 已提交
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
		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;

1032
	pgpath->is_active = true;
L
Linus Torvalds 已提交
1033

1034
	if (!m->nr_valid_paths++) {
1035
		m->current_pgpath = NULL;
1036
		run_queue = 1;
1037
	} else if (m->hw_handler_name && (m->current_pg == pgpath->pg)) {
1038
		if (queue_work(kmpath_handlerd, &pgpath->activate_path.work))
1039 1040
			m->pg_init_in_progress++;
	}
L
Linus Torvalds 已提交
1041

M
Mike Anderson 已提交
1042 1043 1044
	dm_path_uevent(DM_UEVENT_PATH_REINSTATED, m->ti,
		      pgpath->path.dev->name, m->nr_valid_paths);

1045
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1046 1047 1048

out:
	spin_unlock_irqrestore(&m->lock, flags);
1049 1050
	if (run_queue)
		dm_table_run_md_queue_async(m->ti->table);
L
Linus Torvalds 已提交
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060

	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)
{
1061
	int r = -EINVAL;
L
Linus Torvalds 已提交
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078
	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,
1079
		      bool bypassed)
L
Linus Torvalds 已提交
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
{
	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);

1091
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
}

/*
 * 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;
1102
	char dummy;
L
Linus Torvalds 已提交
1103

1104
	if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
L
Linus Torvalds 已提交
1105 1106 1107 1108 1109 1110 1111
	    (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) {
1112
		pg->bypassed = false;
L
Linus Torvalds 已提交
1113 1114 1115 1116 1117 1118 1119 1120 1121
		if (--pgnum)
			continue;

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

1122
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1123 1124 1125 1126 1127 1128 1129
	return 0;
}

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

1136
	if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
L
Linus Torvalds 已提交
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
	    (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 已提交
1151 1152 1153
/*
 * Should we retry pg_init immediately?
 */
1154
static bool pg_init_limit_reached(struct multipath *m, struct pgpath *pgpath)
D
Dave Wysochanski 已提交
1155 1156
{
	unsigned long flags;
1157
	bool limit_reached = false;
D
Dave Wysochanski 已提交
1158 1159 1160

	spin_lock_irqsave(&m->lock, flags);

1161
	if (m->pg_init_count <= m->pg_init_retries && !m->pg_init_disabled)
1162
		m->pg_init_required = true;
D
Dave Wysochanski 已提交
1163
	else
1164
		limit_reached = true;
D
Dave Wysochanski 已提交
1165 1166 1167 1168 1169 1170

	spin_unlock_irqrestore(&m->lock, flags);

	return limit_reached;
}

1171
static void pg_init_done(void *data, int errors)
1172
{
1173
	struct pgpath *pgpath = data;
1174 1175 1176
	struct priority_group *pg = pgpath->pg;
	struct multipath *m = pg->m;
	unsigned long flags;
1177
	bool delay_retry = false;
1178 1179 1180 1181 1182 1183 1184 1185 1186 1187

	/* device or driver problems */
	switch (errors) {
	case SCSI_DH_OK:
		break;
	case SCSI_DH_NOSYS:
		if (!m->hw_handler_name) {
			errors = 0;
			break;
		}
1188 1189
		DMERR("Could not failover the device: Handler scsi_dh_%s "
		      "Error %d.", m->hw_handler_name, errors);
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
		/*
		 * 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.
		 */
1200
		bypass_pg(m, pg, true);
1201 1202
		break;
	case SCSI_DH_RETRY:
1203 1204
		/* Wait before retrying. */
		delay_retry = 1;
1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
	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) {
1222 1223 1224 1225 1226
		if (pgpath == m->current_pgpath) {
			DMERR("Could not failover device. Error %d.", errors);
			m->current_pgpath = NULL;
			m->current_pg = NULL;
		}
1227
	} else if (!m->pg_init_required)
1228
		pg->bypassed = false;
1229

1230 1231 1232 1233
	if (--m->pg_init_in_progress)
		/* Activations of other paths are still on going */
		goto out;

1234 1235 1236 1237 1238
	if (m->pg_init_required) {
		m->pg_init_delay_retry = delay_retry;
		if (__pg_init_all_paths(m))
			goto out;
	}
1239
	m->queue_io = false;
1240

1241 1242 1243 1244 1245
	/*
	 * Wake up any thread waiting to suspend.
	 */
	wake_up(&m->pg_init_wait);

1246
out:
1247 1248 1249
	spin_unlock_irqrestore(&m->lock, flags);
}

1250 1251
static void activate_path(struct work_struct *work)
{
1252
	struct pgpath *pgpath =
1253
		container_of(work, struct pgpath, activate_path.work);
1254

1255 1256 1257 1258 1259
	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);
1260 1261
}

1262 1263 1264 1265 1266 1267 1268
static int noretry_error(int error)
{
	switch (error) {
	case -EOPNOTSUPP:
	case -EREMOTEIO:
	case -EILSEQ:
	case -ENODATA:
1269
	case -ENOSPC:
1270 1271 1272 1273 1274 1275 1276
		return 1;
	}

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

L
Linus Torvalds 已提交
1277 1278 1279
/*
 * end_io handling
 */
1280
static int do_end_io(struct multipath *m, struct request *clone,
A
Alasdair G Kergon 已提交
1281
		     int error, struct dm_mpath_io *mpio)
L
Linus Torvalds 已提交
1282
{
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
	/*
	 * 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;
1295
	unsigned long flags;
L
Linus Torvalds 已提交
1296

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

1300
	if (noretry_error(error))
M
Mike Snitzer 已提交
1301 1302
		return error;

1303 1304
	if (mpio->pgpath)
		fail_path(mpio->pgpath);
L
Linus Torvalds 已提交
1305

1306
	spin_lock_irqsave(&m->lock, flags);
1307 1308 1309 1310 1311 1312 1313 1314 1315
	if (!m->nr_valid_paths) {
		if (!m->queue_if_no_path) {
			if (!__must_push_back(m))
				r = -EIO;
		} else {
			if (error == -EBADE)
				r = error;
		}
	}
1316
	spin_unlock_irqrestore(&m->lock, flags);
L
Linus Torvalds 已提交
1317

1318
	return r;
L
Linus Torvalds 已提交
1319 1320
}

1321
static int multipath_end_io(struct dm_target *ti, struct request *clone,
L
Linus Torvalds 已提交
1322 1323
			    int error, union map_info *map_context)
{
A
Alasdair G Kergon 已提交
1324
	struct multipath *m = ti->private;
1325
	struct dm_mpath_io *mpio = get_mpio(map_context);
1326
	struct pgpath *pgpath;
L
Linus Torvalds 已提交
1327 1328 1329
	struct path_selector *ps;
	int r;

1330 1331
	BUG_ON(!mpio);

1332
	r = do_end_io(m, clone, error, mpio);
1333
	pgpath = mpio->pgpath;
L
Linus Torvalds 已提交
1334 1335 1336
	if (pgpath) {
		ps = &pgpath->pg->ps;
		if (ps->type->end_io)
1337
			ps->type->end_io(ps, &pgpath->path, mpio->nr_bytes);
L
Linus Torvalds 已提交
1338
	}
1339
	clear_request_fn_mpio(m, map_context);
L
Linus Torvalds 已提交
1340 1341 1342 1343 1344 1345

	return r;
}

/*
 * Suspend can't complete until all the I/O is processed so if
1346 1347 1348
 * 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 已提交
1349 1350 1351
 */
static void multipath_presuspend(struct dm_target *ti)
{
1352
	struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1353

1354
	queue_if_no_path(m, false, true);
L
Linus Torvalds 已提交
1355 1356
}

1357 1358
static void multipath_postsuspend(struct dm_target *ti)
{
1359 1360 1361
	struct multipath *m = ti->private;

	mutex_lock(&m->work_mutex);
1362
	flush_multipath_work(m);
1363
	mutex_unlock(&m->work_mutex);
1364 1365
}

1366 1367 1368
/*
 * Restore the queue_if_no_path setting.
 */
L
Linus Torvalds 已提交
1369 1370
static void multipath_resume(struct dm_target *ti)
{
1371
	struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1372 1373 1374
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);
1375
	m->queue_if_no_path = m->saved_queue_if_no_path;
L
Linus Torvalds 已提交
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
	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]* ]+ ]+
 */
1395 1396
static void multipath_status(struct dm_target *ti, status_type_t type,
			     unsigned status_flags, char *result, unsigned maxlen)
L
Linus Torvalds 已提交
1397 1398 1399
{
	int sz = 0;
	unsigned long flags;
1400
	struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1401 1402 1403 1404 1405 1406 1407 1408 1409
	struct priority_group *pg;
	struct pgpath *p;
	unsigned pg_num;
	char state;

	spin_lock_irqsave(&m->lock, flags);

	/* Features */
	if (type == STATUSTYPE_INFO)
1410
		DMEMIT("2 %u %u ", m->queue_io, m->pg_init_count);
D
Dave Wysochanski 已提交
1411 1412
	else {
		DMEMIT("%u ", m->queue_if_no_path +
1413
			      (m->pg_init_retries > 0) * 2 +
1414 1415
			      (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT) * 2 +
			      m->retain_attached_hw_handler);
D
Dave Wysochanski 已提交
1416 1417 1418 1419
		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);
1420 1421
		if (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT)
			DMEMIT("pg_init_delay_msecs %u ", m->pg_init_delay_msecs);
1422 1423
		if (m->retain_attached_hw_handler)
			DMEMIT("retain_attached_hw_handler ");
D
Dave Wysochanski 已提交
1424
	}
L
Linus Torvalds 已提交
1425

1426
	if (!m->hw_handler_name || type == STATUSTYPE_INFO)
L
Linus Torvalds 已提交
1427 1428
		DMEMIT("0 ");
	else
1429
		DMEMIT("1 %s ", m->hw_handler_name);
L
Linus Torvalds 已提交
1430 1431 1432 1433 1434 1435 1436 1437

	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
1438
		pg_num = (m->nr_priority_groups ? 1 : 0);
L
Linus Torvalds 已提交
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465

	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,
1466
				       p->is_active ? "A" : "F",
L
Linus Torvalds 已提交
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505
				       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)
{
1506
	int r = -EINVAL;
L
Linus Torvalds 已提交
1507
	struct dm_dev *dev;
1508
	struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1509 1510
	action_fn action;

1511 1512
	mutex_lock(&m->work_mutex);

1513 1514 1515 1516 1517
	if (dm_suspended(ti)) {
		r = -EBUSY;
		goto out;
	}

L
Linus Torvalds 已提交
1518
	if (argc == 1) {
1519
		if (!strcasecmp(argv[0], "queue_if_no_path")) {
1520
			r = queue_if_no_path(m, true, false);
1521
			goto out;
1522
		} else if (!strcasecmp(argv[0], "fail_if_no_path")) {
1523
			r = queue_if_no_path(m, false, false);
1524 1525
			goto out;
		}
L
Linus Torvalds 已提交
1526 1527
	}

1528
	if (argc != 2) {
1529
		DMWARN("Invalid multipath message arguments. Expected 2 arguments, got %d.", argc);
1530 1531
		goto out;
	}
L
Linus Torvalds 已提交
1532

1533
	if (!strcasecmp(argv[0], "disable_group")) {
1534
		r = bypass_pg_num(m, argv[1], true);
1535
		goto out;
1536
	} else if (!strcasecmp(argv[0], "enable_group")) {
1537
		r = bypass_pg_num(m, argv[1], false);
1538
		goto out;
1539
	} else if (!strcasecmp(argv[0], "switch_group")) {
1540 1541
		r = switch_pg_num(m, argv[1]);
		goto out;
1542
	} else if (!strcasecmp(argv[0], "reinstate_path"))
L
Linus Torvalds 已提交
1543
		action = reinstate_path;
1544
	else if (!strcasecmp(argv[0], "fail_path"))
L
Linus Torvalds 已提交
1545
		action = fail_path;
1546
	else {
1547
		DMWARN("Unrecognised multipath message received: %s", argv[0]);
1548 1549
		goto out;
	}
L
Linus Torvalds 已提交
1550

1551
	r = dm_get_device(ti, argv[1], dm_table_get_mode(ti->table), &dev);
L
Linus Torvalds 已提交
1552
	if (r) {
1553
		DMWARN("message: error getting device %s",
L
Linus Torvalds 已提交
1554
		       argv[1]);
1555
		goto out;
L
Linus Torvalds 已提交
1556 1557 1558 1559 1560 1561
	}

	r = action_dev(m, dev, action);

	dm_put_device(ti, dev);

1562 1563
out:
	mutex_unlock(&m->work_mutex);
L
Linus Torvalds 已提交
1564 1565 1566
	return r;
}

C
Christoph Hellwig 已提交
1567 1568
static int multipath_prepare_ioctl(struct dm_target *ti,
		struct block_device **bdev, fmode_t *mode)
M
Milan Broz 已提交
1569
{
1570
	struct multipath *m = ti->private;
M
Milan Broz 已提交
1571
	unsigned long flags;
1572 1573
	int r;

M
Milan Broz 已提交
1574 1575 1576
	spin_lock_irqsave(&m->lock, flags);

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

1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
	if (m->current_pgpath) {
		if (!m->queue_io) {
			*bdev = m->current_pgpath->path.dev->bdev;
			*mode = m->current_pgpath->path.dev->mode;
			r = 0;
		} else {
			/* pg_init has not started or completed */
			r = -ENOTCONN;
		}
	} else {
		/* No path is available */
		if (m->queue_if_no_path)
			r = -ENOTCONN;
		else
			r = -EIO;
1594
	}
M
Milan Broz 已提交
1595 1596 1597

	spin_unlock_irqrestore(&m->lock, flags);

1598
	if (r == -ENOTCONN) {
1599 1600 1601 1602 1603 1604 1605
		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);
1606
		spin_unlock_irqrestore(&m->lock, flags);
1607
		dm_table_run_md_queue_async(m->ti->table);
1608
	}
1609

C
Christoph Hellwig 已提交
1610 1611 1612 1613 1614 1615
	/*
	 * Only pass ioctls through if the device sizes match exactly.
	 */
	if (!r && ti->len != i_size_read((*bdev)->bd_inode) >> SECTOR_SHIFT)
		return 1;
	return r;
M
Milan Broz 已提交
1616 1617
}

1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
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) {
1628
			ret = fn(ti, p->path.dev, ti->begin, ti->len, data);
1629 1630 1631 1632 1633 1634 1635 1636 1637
			if (ret)
				goto out;
		}
	}

out:
	return ret;
}

1638 1639 1640 1641
static int __pgpath_busy(struct pgpath *pgpath)
{
	struct request_queue *q = bdev_get_queue(pgpath->path.dev->bdev);

1642
	return blk_lld_busy(q);
1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
}

/*
 * 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)
{
1655
	bool busy = false, has_active = false;
1656 1657 1658 1659 1660 1661 1662
	struct multipath *m = ti->private;
	struct priority_group *pg;
	struct pgpath *pgpath;
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);

1663 1664 1665
	/* pg_init in progress or no paths available */
	if (m->pg_init_in_progress ||
	    (!m->nr_valid_paths && m->queue_if_no_path)) {
1666
		busy = true;
1667 1668
		goto out;
	}
1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
	/* 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.
	 */
1688
	busy = true;
1689 1690
	list_for_each_entry(pgpath, &pg->pgpaths, list)
		if (pgpath->is_active) {
1691
			has_active = true;
1692 1693

			if (!__pgpath_busy(pgpath)) {
1694
				busy = false;
1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
				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.
		 */
1705
		busy = false;
1706 1707 1708 1709 1710 1711 1712

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

	return busy;
}

L
Linus Torvalds 已提交
1713 1714 1715 1716 1717
/*-----------------------------------------------------------------
 * Module setup
 *---------------------------------------------------------------*/
static struct target_type multipath_target = {
	.name = "multipath",
M
Mike Snitzer 已提交
1718 1719
	.version = {1, 11, 0},
	.features = DM_TARGET_SINGLETON | DM_TARGET_IMMUTABLE,
L
Linus Torvalds 已提交
1720 1721 1722
	.module = THIS_MODULE,
	.ctr = multipath_ctr,
	.dtr = multipath_dtr,
1723
	.map_rq = multipath_map,
1724 1725
	.clone_and_map_rq = multipath_clone_and_map,
	.release_clone_rq = multipath_release_clone,
1726
	.rq_end_io = multipath_end_io,
L
Linus Torvalds 已提交
1727
	.presuspend = multipath_presuspend,
1728
	.postsuspend = multipath_postsuspend,
L
Linus Torvalds 已提交
1729 1730 1731
	.resume = multipath_resume,
	.status = multipath_status,
	.message = multipath_message,
C
Christoph Hellwig 已提交
1732
	.prepare_ioctl = multipath_prepare_ioctl,
1733
	.iterate_devices = multipath_iterate_devices,
1734
	.busy = multipath_busy,
L
Linus Torvalds 已提交
1735 1736 1737 1738 1739 1740 1741
};

static int __init dm_multipath_init(void)
{
	int r;

	/* allocate a slab for the dm_ios */
A
Alasdair G Kergon 已提交
1742
	_mpio_cache = KMEM_CACHE(dm_mpath_io, 0);
L
Linus Torvalds 已提交
1743 1744 1745 1746 1747
	if (!_mpio_cache)
		return -ENOMEM;

	r = dm_register_target(&multipath_target);
	if (r < 0) {
1748
		DMERR("register failed %d", r);
1749 1750
		r = -EINVAL;
		goto bad_register_target;
L
Linus Torvalds 已提交
1751 1752
	}

1753
	kmultipathd = alloc_workqueue("kmpathd", WQ_MEM_RECLAIM, 0);
1754
	if (!kmultipathd) {
1755
		DMERR("failed to create workqueue kmpathd");
1756 1757
		r = -ENOMEM;
		goto bad_alloc_kmultipathd;
1758 1759
	}

1760 1761 1762 1763 1764 1765
	/*
	 * 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.
	 */
1766 1767
	kmpath_handlerd = alloc_ordered_workqueue("kmpath_handlerd",
						  WQ_MEM_RECLAIM);
1768 1769
	if (!kmpath_handlerd) {
		DMERR("failed to create workqueue kmpath_handlerd");
1770 1771
		r = -ENOMEM;
		goto bad_alloc_kmpath_handlerd;
1772 1773
	}

1774
	DMINFO("version %u.%u.%u loaded",
L
Linus Torvalds 已提交
1775 1776 1777
	       multipath_target.version[0], multipath_target.version[1],
	       multipath_target.version[2]);

1778 1779 1780 1781 1782 1783 1784 1785 1786
	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 已提交
1787 1788 1789 1790 1791
	return r;
}

static void __exit dm_multipath_exit(void)
{
1792
	destroy_workqueue(kmpath_handlerd);
1793 1794
	destroy_workqueue(kmultipathd);

1795
	dm_unregister_target(&multipath_target);
L
Linus Torvalds 已提交
1796 1797 1798 1799 1800 1801 1802 1803 1804
	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");