dm-mpath.c 50.4 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-rq.h"
11
#include "dm-bio-record.h"
L
Linus Torvalds 已提交
12
#include "dm-path-selector.h"
M
Mike Anderson 已提交
13
#include "dm-uevent.h"
L
Linus Torvalds 已提交
14

15
#include <linux/blkdev.h>
L
Linus Torvalds 已提交
16 17 18 19 20 21 22 23
#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>
24
#include <linux/delay.h>
25
#include <scsi/scsi_dh.h>
A
Arun Sharma 已提交
26
#include <linux/atomic.h>
27
#include <linux/blk-mq.h>
L
Linus Torvalds 已提交
28

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

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

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

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

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

#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;
61 62

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

/* Multipath context */
struct multipath {
67
	unsigned long flags;		/* Multipath state flags */
68

69
	spinlock_t lock;
70
	enum dm_queue_mode queue_mode;
71

L
Linus Torvalds 已提交
72 73 74 75
	struct pgpath *current_pgpath;
	struct priority_group *current_pg;
	struct priority_group *next_pg;	/* Switch to this PG if set */

76 77 78
	atomic_t nr_valid_paths;	/* Total number of usable paths */
	unsigned nr_priority_groups;
	struct list_head priority_groups;
79

80 81 82
	const char *hw_handler_name;
	char *hw_handler_params;
	wait_queue_head_t pg_init_wait;	/* Wait for pg_init completion */
D
Dave Wysochanski 已提交
83
	unsigned pg_init_retries;	/* Number of times to retry pg_init */
84
	unsigned pg_init_delay_msecs;	/* Number of msecs before pg_init retry */
85 86 87
	atomic_t pg_init_in_progress;	/* Only one pg_init allowed at once */
	atomic_t pg_init_count;		/* Number of times pg_init called */

88
	struct mutex work_mutex;
89
	struct work_struct trigger_event;
90
	struct dm_target *ti;
91 92 93

	struct work_struct process_queued_bios;
	struct bio_list queued_bios;
L
Linus Torvalds 已提交
94 95 96
};

/*
97
 * Context information attached to each io we process.
L
Linus Torvalds 已提交
98
 */
A
Alasdair G Kergon 已提交
99
struct dm_mpath_io {
L
Linus Torvalds 已提交
100
	struct pgpath *pgpath;
101
	size_t nr_bytes;
L
Linus Torvalds 已提交
102 103 104 105
};

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

106
static struct workqueue_struct *kmultipathd, *kmpath_handlerd;
D
David Howells 已提交
107
static void trigger_event(struct work_struct *work);
108 109
static void activate_or_offline_path(struct pgpath *pgpath);
static void activate_path_work(struct work_struct *work);
110
static void process_queued_bios(struct work_struct *work);
L
Linus Torvalds 已提交
111

112 113 114 115 116 117 118 119 120 121 122
/*-----------------------------------------------
 * Multipath state flags.
 *-----------------------------------------------*/

#define MPATHF_QUEUE_IO 0			/* Must we queue all I/O? */
#define MPATHF_QUEUE_IF_NO_PATH 1		/* Queue I/O if last path fails? */
#define MPATHF_SAVED_QUEUE_IF_NO_PATH 2		/* Saved state during suspension */
#define MPATHF_RETAIN_ATTACHED_HW_HANDLER 3	/* If there's already a hw_handler present, don't change it. */
#define MPATHF_PG_INIT_DISABLED 4		/* pg_init is not currently allowed */
#define MPATHF_PG_INIT_REQUIRED 5		/* pg_init needs calling? */
#define MPATHF_PG_INIT_DELAY_RETRY 6		/* Delay pg_init retry? */
L
Linus Torvalds 已提交
123 124 125 126 127 128 129

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

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

132 133 134 135
	if (!pgpath)
		return NULL;

	pgpath->is_active = true;
L
Linus Torvalds 已提交
136 137 138 139

	return pgpath;
}

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

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

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

M
Micha³ Miros³aw 已提交
151 152
	if (pg)
		INIT_LIST_HEAD(&pg->pgpaths);
L
Linus Torvalds 已提交
153 154 155 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

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

182
static struct multipath *alloc_multipath(struct dm_target *ti)
L
Linus Torvalds 已提交
183 184 185
{
	struct multipath *m;

M
Micha³ Miros³aw 已提交
186
	m = kzalloc(sizeof(*m), GFP_KERNEL);
L
Linus Torvalds 已提交
187 188 189
	if (m) {
		INIT_LIST_HEAD(&m->priority_groups);
		spin_lock_init(&m->lock);
190
		atomic_set(&m->nr_valid_paths, 0);
D
David Howells 已提交
191
		INIT_WORK(&m->trigger_event, trigger_event);
192
		mutex_init(&m->work_mutex);
193

194
		m->queue_mode = DM_TYPE_NONE;
195

M
Micha³ Miros³aw 已提交
196 197
		m->ti = ti;
		ti->private = m;
L
Linus Torvalds 已提交
198 199 200 201 202
	}

	return m;
}

203 204 205 206 207 208 209 210 211 212
static int alloc_multipath_stage2(struct dm_target *ti, struct multipath *m)
{
	if (m->queue_mode == DM_TYPE_NONE) {
		/*
		 * Default to request-based.
		 */
		if (dm_use_blk_mq(dm_table_get_md(ti->table)))
			m->queue_mode = DM_TYPE_MQ_REQUEST_BASED;
		else
			m->queue_mode = DM_TYPE_REQUEST_BASED;
213

214
	} else if (m->queue_mode == DM_TYPE_BIO_BASED) {
215
		INIT_WORK(&m->process_queued_bios, process_queued_bios);
216 217 218 219 220
		/*
		 * bio-based doesn't support any direct scsi_dh management;
		 * it just discovers if a scsi_dh is attached.
		 */
		set_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags);
221 222 223 224
	}

	dm_table_set_type(ti->table, m->queue_mode);

225 226 227 228 229 230 231 232 233 234
	/*
	 * Init fields that are only used when a scsi_dh is attached
	 * - must do this unconditionally (really doesn't hurt non-SCSI uses)
	 */
	set_bit(MPATHF_QUEUE_IO, &m->flags);
	atomic_set(&m->pg_init_in_progress, 0);
	atomic_set(&m->pg_init_count, 0);
	m->pg_init_delay_msecs = DM_PG_INIT_DELAY_DEFAULT;
	init_waitqueue_head(&m->pg_init_wait);

235 236 237
	return 0;
}

L
Linus Torvalds 已提交
238 239 240 241 242 243 244 245 246
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);
	}

247
	kfree(m->hw_handler_name);
248
	kfree(m->hw_handler_params);
249
	mutex_destroy(&m->work_mutex);
L
Linus Torvalds 已提交
250 251 252
	kfree(m);
}

253 254 255 256 257
static struct dm_mpath_io *get_mpio(union map_info *info)
{
	return info->ptr;
}

258 259 260 261 262
static size_t multipath_per_bio_data_size(void)
{
	return sizeof(struct dm_mpath_io) + sizeof(struct dm_bio_details);
}

263 264
static struct dm_mpath_io *get_mpio_from_bio(struct bio *bio)
{
265
	return dm_per_bio_data(bio, multipath_per_bio_data_size());
266 267
}

268
static struct dm_bio_details *get_bio_details_from_mpio(struct dm_mpath_io *mpio)
269
{
270 271 272 273 274
	/* dm_bio_details is immediately after the dm_mpath_io in bio's per-bio-data */
	void *bio_details = mpio + 1;
	return bio_details;
}

275
static void multipath_init_per_bio_data(struct bio *bio, struct dm_mpath_io **mpio_p)
276 277
{
	struct dm_mpath_io *mpio = get_mpio_from_bio(bio);
278
	struct dm_bio_details *bio_details = get_bio_details_from_mpio(mpio);
279

280 281 282
	mpio->nr_bytes = bio->bi_iter.bi_size;
	mpio->pgpath = NULL;
	*mpio_p = mpio;
283

284
	dm_bio_record(bio_details, bio);
285 286
}

L
Linus Torvalds 已提交
287 288 289 290
/*-----------------------------------------------
 * Path selection
 *-----------------------------------------------*/

291
static int __pg_init_all_paths(struct multipath *m)
K
Kiyoshi Ueda 已提交
292 293
{
	struct pgpath *pgpath;
294
	unsigned long pg_init_delay = 0;
K
Kiyoshi Ueda 已提交
295

296 297
	lockdep_assert_held(&m->lock);

298
	if (atomic_read(&m->pg_init_in_progress) || test_bit(MPATHF_PG_INIT_DISABLED, &m->flags))
299
		return 0;
300

301
	atomic_inc(&m->pg_init_count);
302
	clear_bit(MPATHF_PG_INIT_REQUIRED, &m->flags);
303 304 305 306 307

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

308
	if (test_bit(MPATHF_PG_INIT_DELAY_RETRY, &m->flags))
309 310
		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 已提交
311 312 313 314
	list_for_each_entry(pgpath, &m->current_pg->pgpaths, list) {
		/* Skip failed paths */
		if (!pgpath->is_active)
			continue;
315 316
		if (queue_delayed_work(kmpath_handlerd, &pgpath->activate_path,
				       pg_init_delay))
317
			atomic_inc(&m->pg_init_in_progress);
K
Kiyoshi Ueda 已提交
318
	}
319
	return atomic_read(&m->pg_init_in_progress);
K
Kiyoshi Ueda 已提交
320 321
}

322
static int pg_init_all_paths(struct multipath *m)
L
Linus Torvalds 已提交
323
{
324
	int ret;
325 326 327
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);
328
	ret = __pg_init_all_paths(m);
329
	spin_unlock_irqrestore(&m->lock, flags);
330 331

	return ret;
332 333 334 335 336
}

static void __switch_pg(struct multipath *m, struct priority_group *pg)
{
	m->current_pg = pg;
L
Linus Torvalds 已提交
337 338

	/* Must we initialise the PG first, and queue I/O till it's ready? */
339
	if (m->hw_handler_name) {
340 341
		set_bit(MPATHF_PG_INIT_REQUIRED, &m->flags);
		set_bit(MPATHF_QUEUE_IO, &m->flags);
L
Linus Torvalds 已提交
342
	} else {
343 344
		clear_bit(MPATHF_PG_INIT_REQUIRED, &m->flags);
		clear_bit(MPATHF_QUEUE_IO, &m->flags);
L
Linus Torvalds 已提交
345
	}
D
Dave Wysochanski 已提交
346

347
	atomic_set(&m->pg_init_count, 0);
L
Linus Torvalds 已提交
348 349
}

350 351 352
static struct pgpath *choose_path_in_pg(struct multipath *m,
					struct priority_group *pg,
					size_t nr_bytes)
L
Linus Torvalds 已提交
353
{
354
	unsigned long flags;
355
	struct dm_path *path;
356
	struct pgpath *pgpath;
L
Linus Torvalds 已提交
357

358
	path = pg->ps.type->select_path(&pg->ps, nr_bytes);
L
Linus Torvalds 已提交
359
	if (!path)
360
		return ERR_PTR(-ENXIO);
L
Linus Torvalds 已提交
361

362
	pgpath = path_to_pgpath(path);
L
Linus Torvalds 已提交
363

364
	if (unlikely(READ_ONCE(m->current_pg) != pg)) {
365 366 367 368 369 370
		/* Only update current_pgpath if pg changed */
		spin_lock_irqsave(&m->lock, flags);
		m->current_pgpath = pgpath;
		__switch_pg(m, pg);
		spin_unlock_irqrestore(&m->lock, flags);
	}
L
Linus Torvalds 已提交
371

372
	return pgpath;
L
Linus Torvalds 已提交
373 374
}

375
static struct pgpath *choose_pgpath(struct multipath *m, size_t nr_bytes)
L
Linus Torvalds 已提交
376
{
377
	unsigned long flags;
L
Linus Torvalds 已提交
378
	struct priority_group *pg;
379
	struct pgpath *pgpath;
380
	unsigned bypassed = 1;
L
Linus Torvalds 已提交
381

382
	if (!atomic_read(&m->nr_valid_paths)) {
383
		clear_bit(MPATHF_QUEUE_IO, &m->flags);
L
Linus Torvalds 已提交
384
		goto failed;
385
	}
L
Linus Torvalds 已提交
386 387

	/* Were we instructed to switch PG? */
388
	if (READ_ONCE(m->next_pg)) {
389
		spin_lock_irqsave(&m->lock, flags);
L
Linus Torvalds 已提交
390
		pg = m->next_pg;
391 392 393 394
		if (!pg) {
			spin_unlock_irqrestore(&m->lock, flags);
			goto check_current_pg;
		}
L
Linus Torvalds 已提交
395
		m->next_pg = NULL;
396 397 398 399
		spin_unlock_irqrestore(&m->lock, flags);
		pgpath = choose_path_in_pg(m, pg, nr_bytes);
		if (!IS_ERR_OR_NULL(pgpath))
			return pgpath;
L
Linus Torvalds 已提交
400 401 402
	}

	/* Don't change PG until it has no remaining paths */
403
check_current_pg:
404
	pg = READ_ONCE(m->current_pg);
405 406 407 408 409
	if (pg) {
		pgpath = choose_path_in_pg(m, pg, nr_bytes);
		if (!IS_ERR_OR_NULL(pgpath))
			return pgpath;
	}
L
Linus Torvalds 已提交
410 411 412 413

	/*
	 * Loop through priority groups until we find a valid path.
	 * First time we skip PGs marked 'bypassed'.
414 415
	 * Second time we only try the ones we skipped, but set
	 * pg_init_delay_retry so we do not hammer controllers.
L
Linus Torvalds 已提交
416 417 418
	 */
	do {
		list_for_each_entry(pg, &m->priority_groups, list) {
419
			if (pg->bypassed == !!bypassed)
L
Linus Torvalds 已提交
420
				continue;
421 422
			pgpath = choose_path_in_pg(m, pg, nr_bytes);
			if (!IS_ERR_OR_NULL(pgpath)) {
423
				if (!bypassed)
424
					set_bit(MPATHF_PG_INIT_DELAY_RETRY, &m->flags);
425
				return pgpath;
426
			}
L
Linus Torvalds 已提交
427 428 429 430
		}
	} while (bypassed--);

failed:
431
	spin_lock_irqsave(&m->lock, flags);
L
Linus Torvalds 已提交
432 433
	m->current_pgpath = NULL;
	m->current_pg = NULL;
434 435 436
	spin_unlock_irqrestore(&m->lock, flags);

	return NULL;
L
Linus Torvalds 已提交
437 438
}

439
/*
440 441 442
 * dm_report_EIO() is a macro instead of a function to make pr_debug()
 * report the function name and line number of the function from which
 * it has been invoked.
443
 */
444
#define dm_report_EIO(m)						\
445
do {									\
446 447 448 449 450 451 452
	struct mapped_device *md = dm_table_get_md((m)->ti->table);	\
									\
	pr_debug("%s: returning EIO; QIFNP = %d; SQIFNP = %d; DNFS = %d\n", \
		 dm_device_name(md),					\
		 test_bit(MPATHF_QUEUE_IF_NO_PATH, &(m)->flags),	\
		 test_bit(MPATHF_SAVED_QUEUE_IF_NO_PATH, &(m)->flags),	\
		 dm_noflush_suspending((m)->ti));			\
453
} while (0)
454

455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
/*
 * Check whether bios must be queued in the device-mapper core rather
 * than here in the target.
 *
 * If MPATHF_QUEUE_IF_NO_PATH and MPATHF_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 bool __must_push_back(struct multipath *m, unsigned long flags)
{
	return ((test_bit(MPATHF_QUEUE_IF_NO_PATH, &flags) !=
		 test_bit(MPATHF_SAVED_QUEUE_IF_NO_PATH, &flags)) &&
		dm_noflush_suspending(m->ti));
}

/*
 * Following functions use READ_ONCE to get atomic access to
 * all m->flags to avoid taking spinlock
 */
static bool must_push_back_rq(struct multipath *m)
{
	unsigned long flags = READ_ONCE(m->flags);
	return test_bit(MPATHF_QUEUE_IF_NO_PATH, &flags) || __must_push_back(m, flags);
}

static bool must_push_back_bio(struct multipath *m)
{
	unsigned long flags = READ_ONCE(m->flags);
	return __must_push_back(m, flags);
}

H
Hannes Reinecke 已提交
487
/*
488
 * Map cloned requests (request-based multipath)
H
Hannes Reinecke 已提交
489
 */
490 491 492
static int multipath_clone_and_map(struct dm_target *ti, struct request *rq,
				   union map_info *map_context,
				   struct request **__clone)
L
Linus Torvalds 已提交
493
{
494
	struct multipath *m = ti->private;
495
	size_t nr_bytes = blk_rq_bytes(rq);
L
Linus Torvalds 已提交
496
	struct pgpath *pgpath;
497
	struct block_device *bdev;
498
	struct dm_mpath_io *mpio = get_mpio(map_context);
499
	struct request_queue *q;
500
	struct request *clone;
L
Linus Torvalds 已提交
501 502

	/* Do we need to select a new pgpath? */
503
	pgpath = READ_ONCE(m->current_pgpath);
504 505
	if (!pgpath || !test_bit(MPATHF_QUEUE_IO, &m->flags))
		pgpath = choose_pgpath(m, nr_bytes);
L
Linus Torvalds 已提交
506

507
	if (!pgpath) {
508
		if (must_push_back_rq(m))
509
			return DM_MAPIO_DELAY_REQUEUE;
510
		dm_report_EIO(m);	/* Failed */
511
		return DM_MAPIO_KILL;
512 513
	} else if (test_bit(MPATHF_QUEUE_IO, &m->flags) ||
		   test_bit(MPATHF_PG_INIT_REQUIRED, &m->flags)) {
514 515
		pg_init_all_paths(m);
		return DM_MAPIO_DELAY_REQUEUE;
516
	}
517

518 519 520
	mpio->pgpath = pgpath;
	mpio->nr_bytes = nr_bytes;

521
	bdev = pgpath->path.dev->bdev;
522 523
	q = bdev_get_queue(bdev);
	clone = blk_get_request(q, rq->cmd_flags | REQ_NOMERGE, GFP_ATOMIC);
524 525
	if (IS_ERR(clone)) {
		/* EBUSY, ENODEV or EWOULDBLOCK: requeue */
526
		if (blk_queue_dying(q)) {
527 528
			atomic_inc(&m->pg_init_in_progress);
			activate_or_offline_path(pgpath);
529
			return DM_MAPIO_DELAY_REQUEUE;
530
		}
531 532 533 534 535 536 537 538 539 540 541 542

		/*
		 * blk-mq's SCHED_RESTART can cover this requeue, so we
		 * needn't deal with it by DELAY_REQUEUE. More importantly,
		 * we have to return DM_MAPIO_REQUEUE so that blk-mq can
		 * get the queue busy feedback (via BLK_STS_RESOURCE),
		 * otherwise I/O merging can suffer.
		 */
		if (q->mq_ops)
			return DM_MAPIO_REQUEUE;
		else
			return DM_MAPIO_DELAY_REQUEUE;
543
	}
544 545 546 547
	clone->bio = clone->biotail = NULL;
	clone->rq_disk = bdev->bd_disk;
	clone->cmd_flags |= REQ_FAILFAST_TRANSPORT;
	*__clone = clone;
548

549 550 551 552
	if (pgpath->pg->ps.type->start_io)
		pgpath->pg->ps.type->start_io(&pgpath->pg->ps,
					      &pgpath->path,
					      nr_bytes);
553
	return DM_MAPIO_REMAPPED;
L
Linus Torvalds 已提交
554 555
}

556 557
static void multipath_release_clone(struct request *clone)
{
558
	blk_put_request(clone);
559 560
}

561 562 563
/*
 * Map cloned bios (bio-based multipath)
 */
564 565

static struct pgpath *__map_bio(struct multipath *m, struct bio *bio)
566 567 568 569 570 571
{
	struct pgpath *pgpath;
	unsigned long flags;
	bool queue_io;

	/* Do we need to select a new pgpath? */
572
	pgpath = READ_ONCE(m->current_pgpath);
573 574
	queue_io = test_bit(MPATHF_QUEUE_IO, &m->flags);
	if (!pgpath || !queue_io)
575
		pgpath = choose_pgpath(m, bio->bi_iter.bi_size);
576 577 578 579 580 581 582

	if ((pgpath && queue_io) ||
	    (!pgpath && test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags))) {
		/* Queue for the daemon to resubmit */
		spin_lock_irqsave(&m->lock, flags);
		bio_list_add(&m->queued_bios, bio);
		spin_unlock_irqrestore(&m->lock, flags);
583

584 585 586 587 588
		/* PG_INIT_REQUIRED cannot be set without QUEUE_IO */
		if (queue_io || test_bit(MPATHF_PG_INIT_REQUIRED, &m->flags))
			pg_init_all_paths(m);
		else if (!queue_io)
			queue_work(kmultipathd, &m->process_queued_bios);
589 590

		return ERR_PTR(-EAGAIN);
591 592
	}

593 594 595
	return pgpath;
}

596
static struct pgpath *__map_bio_fast(struct multipath *m, struct bio *bio)
597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
{
	struct pgpath *pgpath;
	unsigned long flags;

	/* Do we need to select a new pgpath? */
	/*
	 * FIXME: currently only switching path if no path (due to failure, etc)
	 * - which negates the point of using a path selector
	 */
	pgpath = READ_ONCE(m->current_pgpath);
	if (!pgpath)
		pgpath = choose_pgpath(m, bio->bi_iter.bi_size);

	if (!pgpath) {
		if (test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags)) {
			/* Queue for the daemon to resubmit */
			spin_lock_irqsave(&m->lock, flags);
			bio_list_add(&m->queued_bios, bio);
			spin_unlock_irqrestore(&m->lock, flags);
616
			queue_work(kmultipathd, &m->process_queued_bios);
617 618

			return ERR_PTR(-EAGAIN);
619
		}
620 621 622 623 624 625 626 627 628 629 630
		return NULL;
	}

	return pgpath;
}

static int __multipath_map_bio(struct multipath *m, struct bio *bio,
			       struct dm_mpath_io *mpio)
{
	struct pgpath *pgpath;

631 632
	if (!m->hw_handler_name)
		pgpath = __map_bio_fast(m, bio);
633 634
	else
		pgpath = __map_bio(m, bio);
635

636
	if (IS_ERR(pgpath))
637 638 639
		return DM_MAPIO_SUBMITTED;

	if (!pgpath) {
640
		if (must_push_back_bio(m))
641
			return DM_MAPIO_REQUEUE;
642
		dm_report_EIO(m);
643
		return DM_MAPIO_KILL;
644 645 646 647
	}

	mpio->pgpath = pgpath;

648
	bio->bi_status = 0;
649
	bio_set_dev(bio, pgpath->path.dev->bdev);
J
Jens Axboe 已提交
650
	bio->bi_opf |= REQ_FAILFAST_TRANSPORT;
651 652 653 654

	if (pgpath->pg->ps.type->start_io)
		pgpath->pg->ps.type->start_io(&pgpath->pg->ps,
					      &pgpath->path,
655
					      mpio->nr_bytes);
656 657 658 659 660 661
	return DM_MAPIO_REMAPPED;
}

static int multipath_map_bio(struct dm_target *ti, struct bio *bio)
{
	struct multipath *m = ti->private;
662 663
	struct dm_mpath_io *mpio = NULL;

664
	multipath_init_per_bio_data(bio, &mpio);
665 666 667
	return __multipath_map_bio(m, bio, mpio);
}

668
static void process_queued_io_list(struct multipath *m)
669
{
670 671
	if (m->queue_mode == DM_TYPE_MQ_REQUEST_BASED)
		dm_mq_kick_requeue_list(dm_table_get_md(m->ti->table));
672
	else if (m->queue_mode == DM_TYPE_BIO_BASED)
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
		queue_work(kmultipathd, &m->process_queued_bios);
}

static void process_queued_bios(struct work_struct *work)
{
	int r;
	unsigned long flags;
	struct bio *bio;
	struct bio_list bios;
	struct blk_plug plug;
	struct multipath *m =
		container_of(work, struct multipath, process_queued_bios);

	bio_list_init(&bios);

	spin_lock_irqsave(&m->lock, flags);

	if (bio_list_empty(&m->queued_bios)) {
		spin_unlock_irqrestore(&m->lock, flags);
		return;
	}

	bio_list_merge(&bios, &m->queued_bios);
	bio_list_init(&m->queued_bios);

	spin_unlock_irqrestore(&m->lock, flags);

	blk_start_plug(&plug);
	while ((bio = bio_list_pop(&bios))) {
702 703 704
		struct dm_mpath_io *mpio = get_mpio_from_bio(bio);
		dm_bio_restore(get_bio_details_from_mpio(mpio), bio);
		r = __multipath_map_bio(m, bio, mpio);
705 706
		switch (r) {
		case DM_MAPIO_KILL:
707 708
			bio->bi_status = BLK_STS_IOERR;
			bio_endio(bio);
709
			break;
710
		case DM_MAPIO_REQUEUE:
711
			bio->bi_status = BLK_STS_DM_REQUEUE;
712
			bio_endio(bio);
713 714
			break;
		case DM_MAPIO_REMAPPED:
715
			generic_make_request(bio);
716
			break;
717 718 719 720
		case 0:
			break;
		default:
			WARN_ONCE(true, "__multipath_map_bio() returned %d\n", r);
721
		}
722 723 724 725
	}
	blk_finish_plug(&plug);
}

L
Linus Torvalds 已提交
726 727 728
/*
 * If we run out of usable paths, should we queue I/O or error it?
 */
729 730
static int queue_if_no_path(struct multipath *m, bool queue_if_no_path,
			    bool save_old_value)
L
Linus Torvalds 已提交
731 732 733 734
{
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);
L
Lukas Wunner 已提交
735 736 737
	assign_bit(MPATHF_SAVED_QUEUE_IF_NO_PATH, &m->flags,
		   (save_old_value && test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags)) ||
		   (!save_old_value && queue_if_no_path));
738
	assign_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags, queue_if_no_path);
L
Linus Torvalds 已提交
739 740
	spin_unlock_irqrestore(&m->lock, flags);

741
	if (!queue_if_no_path) {
742
		dm_table_run_md_queue_async(m->ti->table);
743
		process_queued_io_list(m);
744
	}
745

L
Linus Torvalds 已提交
746 747 748 749 750 751 752
	return 0;
}

/*
 * An event is triggered whenever a path is taken out of use.
 * Includes path failure and PG bypass.
 */
D
David Howells 已提交
753
static void trigger_event(struct work_struct *work)
L
Linus Torvalds 已提交
754
{
D
David Howells 已提交
755 756
	struct multipath *m =
		container_of(work, struct multipath, trigger_event);
L
Linus Torvalds 已提交
757 758 759 760 761 762 763 764 765 766 767 768 769 770

	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>]* ]+ ]+
 *---------------------------------------------------------------*/
771
static int parse_path_selector(struct dm_arg_set *as, struct priority_group *pg,
L
Linus Torvalds 已提交
772 773 774 775 776 777
			       struct dm_target *ti)
{
	int r;
	struct path_selector_type *pst;
	unsigned ps_argc;

E
Eric Biggers 已提交
778
	static const struct dm_arg _args[] = {
779
		{0, 1024, "invalid number of path selector args"},
L
Linus Torvalds 已提交
780 781
	};

782
	pst = dm_get_path_selector(dm_shift_arg(as));
L
Linus Torvalds 已提交
783
	if (!pst) {
784
		ti->error = "unknown path selector type";
L
Linus Torvalds 已提交
785 786 787
		return -EINVAL;
	}

788
	r = dm_read_arg_group(_args, as, &ps_argc, &ti->error);
789 790
	if (r) {
		dm_put_path_selector(pst);
L
Linus Torvalds 已提交
791
		return -EINVAL;
792
	}
L
Linus Torvalds 已提交
793 794 795 796

	r = pst->create(&pg->ps, ps_argc, as->argv);
	if (r) {
		dm_put_path_selector(pst);
797
		ti->error = "path selector constructor failed";
L
Linus Torvalds 已提交
798 799 800 801
		return r;
	}

	pg->ps.type = pst;
802
	dm_consume_args(as, ps_argc);
L
Linus Torvalds 已提交
803 804 805 806

	return 0;
}

807 808
static int setup_scsi_dh(struct block_device *bdev, struct multipath *m,
			 const char *attached_handler_name, char **error)
L
Linus Torvalds 已提交
809
{
810 811
	struct request_queue *q = bdev_get_queue(bdev);
	int r;
812

813
	if (test_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags)) {
814
retain:
815
		if (attached_handler_name) {
816 817 818 819 820 821 822 823 824
			/*
			 * Clear any hw_handler_params associated with a
			 * handler that isn't already attached.
			 */
			if (m->hw_handler_name && strcmp(attached_handler_name, m->hw_handler_name)) {
				kfree(m->hw_handler_params);
				m->hw_handler_params = NULL;
			}

825 826 827 828 829 830 831 832 833 834
			/*
			 * Reset hw_handler_name to match the attached 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;
		}
	}
835

836
	if (m->hw_handler_name) {
837 838
		r = scsi_dh_attach(q, m->hw_handler_name);
		if (r == -EBUSY) {
839
			char b[BDEVNAME_SIZE];
840

841
			printk(KERN_INFO "dm-mpath: retaining handler on device %s\n",
842
			       bdevname(bdev, b));
843 844
			goto retain;
		}
845
		if (r < 0) {
846 847
			*error = "error attaching hardware handler";
			return r;
848
		}
849 850 851 852

		if (m->hw_handler_params) {
			r = scsi_dh_set_params(q, m->hw_handler_params);
			if (r < 0) {
853 854
				*error = "unable to set hardware handler parameters";
				return r;
855 856
			}
		}
857 858
	}

859 860 861 862 863 864 865 866 867
	return 0;
}

static struct pgpath *parse_path(struct dm_arg_set *as, struct path_selector *ps,
				 struct dm_target *ti)
{
	int r;
	struct pgpath *p;
	struct multipath *m = ti->private;
868 869
	struct request_queue *q;
	const char *attached_handler_name;
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887

	/* we need at least a path arg */
	if (as->argc < 1) {
		ti->error = "no device given";
		return ERR_PTR(-EINVAL);
	}

	p = alloc_pgpath();
	if (!p)
		return ERR_PTR(-ENOMEM);

	r = dm_get_device(ti, dm_shift_arg(as), dm_table_get_mode(ti->table),
			  &p->path.dev);
	if (r) {
		ti->error = "error getting device";
		goto bad;
	}

888 889 890
	q = bdev_get_queue(p->path.dev->bdev);
	attached_handler_name = scsi_dh_attached_handler_name(q, GFP_KERNEL);
	if (attached_handler_name) {
891
		INIT_DELAYED_WORK(&p->activate_path, activate_path_work);
892
		r = setup_scsi_dh(p->path.dev->bdev, m, attached_handler_name, &ti->error);
893 894 895 896 897 898
		if (r) {
			dm_put_device(ti, p->path.dev);
			goto bad;
		}
	}

L
Linus Torvalds 已提交
899 900 901 902 903 904 905 906 907
	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);
908
	return ERR_PTR(r);
L
Linus Torvalds 已提交
909 910
}

911
static struct priority_group *parse_priority_group(struct dm_arg_set *as,
M
Micha³ Miros³aw 已提交
912
						   struct multipath *m)
L
Linus Torvalds 已提交
913
{
E
Eric Biggers 已提交
914
	static const struct dm_arg _args[] = {
915 916
		{1, 1024, "invalid number of paths"},
		{0, 1024, "invalid number of selector args"}
L
Linus Torvalds 已提交
917 918 919
	};

	int r;
920
	unsigned i, nr_selector_args, nr_args;
L
Linus Torvalds 已提交
921
	struct priority_group *pg;
M
Micha³ Miros³aw 已提交
922
	struct dm_target *ti = m->ti;
L
Linus Torvalds 已提交
923 924 925

	if (as->argc < 2) {
		as->argc = 0;
926 927
		ti->error = "not enough priority group arguments";
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
928 929 930 931
	}

	pg = alloc_priority_group();
	if (!pg) {
932
		ti->error = "couldn't allocate priority group";
933
		return ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
934 935 936 937 938 939 940 941 942 943
	}
	pg->m = m;

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

	/*
	 * read the paths
	 */
944
	r = dm_read_arg(_args, as, &pg->nr_pgpaths, &ti->error);
L
Linus Torvalds 已提交
945 946 947
	if (r)
		goto bad;

948
	r = dm_read_arg(_args + 1, as, &nr_selector_args, &ti->error);
L
Linus Torvalds 已提交
949 950 951
	if (r)
		goto bad;

952
	nr_args = 1 + nr_selector_args;
L
Linus Torvalds 已提交
953 954
	for (i = 0; i < pg->nr_pgpaths; i++) {
		struct pgpath *pgpath;
955
		struct dm_arg_set path_args;
L
Linus Torvalds 已提交
956

957
		if (as->argc < nr_args) {
958
			ti->error = "not enough path parameters";
959
			r = -EINVAL;
L
Linus Torvalds 已提交
960
			goto bad;
961
		}
L
Linus Torvalds 已提交
962

963
		path_args.argc = nr_args;
L
Linus Torvalds 已提交
964 965 966
		path_args.argv = as->argv;

		pgpath = parse_path(&path_args, &pg->ps, ti);
967 968
		if (IS_ERR(pgpath)) {
			r = PTR_ERR(pgpath);
L
Linus Torvalds 已提交
969
			goto bad;
970
		}
L
Linus Torvalds 已提交
971 972 973

		pgpath->pg = pg;
		list_add_tail(&pgpath->list, &pg->pgpaths);
974
		dm_consume_args(as, nr_args);
L
Linus Torvalds 已提交
975 976 977 978 979 980
	}

	return pg;

 bad:
	free_priority_group(pg, ti);
981
	return ERR_PTR(r);
L
Linus Torvalds 已提交
982 983
}

984
static int parse_hw_handler(struct dm_arg_set *as, struct multipath *m)
L
Linus Torvalds 已提交
985 986
{
	unsigned hw_argc;
987
	int ret;
M
Micha³ Miros³aw 已提交
988
	struct dm_target *ti = m->ti;
L
Linus Torvalds 已提交
989

E
Eric Biggers 已提交
990
	static const struct dm_arg _args[] = {
991
		{0, 1024, "invalid number of hardware handler args"},
L
Linus Torvalds 已提交
992 993
	};

994
	if (dm_read_arg_group(_args, as, &hw_argc, &ti->error))
L
Linus Torvalds 已提交
995 996 997 998 999
		return -EINVAL;

	if (!hw_argc)
		return 0;

1000
	if (m->queue_mode == DM_TYPE_BIO_BASED) {
1001 1002 1003 1004 1005
		dm_consume_args(as, hw_argc);
		DMERR("bio-based multipath doesn't allow hardware handler args");
		return 0;
	}

1006
	m->hw_handler_name = kstrdup(dm_shift_arg(as), GFP_KERNEL);
1007 1008
	if (!m->hw_handler_name)
		return -EINVAL;
1009

1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
	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]);
	}
1026
	dm_consume_args(as, hw_argc - 1);
L
Linus Torvalds 已提交
1027 1028

	return 0;
1029 1030 1031 1032
fail:
	kfree(m->hw_handler_name);
	m->hw_handler_name = NULL;
	return ret;
L
Linus Torvalds 已提交
1033 1034
}

1035
static int parse_features(struct dm_arg_set *as, struct multipath *m)
L
Linus Torvalds 已提交
1036 1037 1038
{
	int r;
	unsigned argc;
M
Micha³ Miros³aw 已提交
1039
	struct dm_target *ti = m->ti;
1040
	const char *arg_name;
L
Linus Torvalds 已提交
1041

E
Eric Biggers 已提交
1042
	static const struct dm_arg _args[] = {
1043
		{0, 8, "invalid number of feature args"},
D
Dave Wysochanski 已提交
1044
		{1, 50, "pg_init_retries must be between 1 and 50"},
1045
		{0, 60000, "pg_init_delay_msecs must be between 0 and 60000"},
L
Linus Torvalds 已提交
1046 1047
	};

1048
	r = dm_read_arg_group(_args, as, &argc, &ti->error);
L
Linus Torvalds 已提交
1049 1050 1051 1052 1053 1054
	if (r)
		return -EINVAL;

	if (!argc)
		return 0;

D
Dave Wysochanski 已提交
1055
	do {
1056
		arg_name = dm_shift_arg(as);
D
Dave Wysochanski 已提交
1057 1058
		argc--;

1059
		if (!strcasecmp(arg_name, "queue_if_no_path")) {
1060
			r = queue_if_no_path(m, true, false);
D
Dave Wysochanski 已提交
1061 1062 1063
			continue;
		}

1064
		if (!strcasecmp(arg_name, "retain_attached_hw_handler")) {
1065
			set_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags);
1066 1067 1068
			continue;
		}

1069
		if (!strcasecmp(arg_name, "pg_init_retries") &&
D
Dave Wysochanski 已提交
1070
		    (argc >= 1)) {
1071
			r = dm_read_arg(_args + 1, as, &m->pg_init_retries, &ti->error);
D
Dave Wysochanski 已提交
1072 1073 1074 1075
			argc--;
			continue;
		}

1076
		if (!strcasecmp(arg_name, "pg_init_delay_msecs") &&
1077
		    (argc >= 1)) {
1078
			r = dm_read_arg(_args + 2, as, &m->pg_init_delay_msecs, &ti->error);
1079 1080 1081 1082
			argc--;
			continue;
		}

1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
		if (!strcasecmp(arg_name, "queue_mode") &&
		    (argc >= 1)) {
			const char *queue_mode_name = dm_shift_arg(as);

			if (!strcasecmp(queue_mode_name, "bio"))
				m->queue_mode = DM_TYPE_BIO_BASED;
			else if (!strcasecmp(queue_mode_name, "rq"))
				m->queue_mode = DM_TYPE_REQUEST_BASED;
			else if (!strcasecmp(queue_mode_name, "mq"))
				m->queue_mode = DM_TYPE_MQ_REQUEST_BASED;
			else {
				ti->error = "Unknown 'queue_mode' requested";
				r = -EINVAL;
			}
			argc--;
			continue;
		}

L
Linus Torvalds 已提交
1101
		ti->error = "Unrecognised multipath feature request";
D
Dave Wysochanski 已提交
1102 1103 1104 1105
		r = -EINVAL;
	} while (argc && !r);

	return r;
L
Linus Torvalds 已提交
1106 1107
}

1108
static int multipath_ctr(struct dm_target *ti, unsigned argc, char **argv)
L
Linus Torvalds 已提交
1109
{
1110
	/* target arguments */
E
Eric Biggers 已提交
1111
	static const struct dm_arg _args[] = {
1112 1113
		{0, 1024, "invalid number of priority groups"},
		{0, 1024, "invalid initial priority group number"},
L
Linus Torvalds 已提交
1114 1115 1116 1117
	};

	int r;
	struct multipath *m;
1118
	struct dm_arg_set as;
L
Linus Torvalds 已提交
1119 1120 1121 1122 1123 1124
	unsigned pg_count = 0;
	unsigned next_pg_num;

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

1125
	m = alloc_multipath(ti);
L
Linus Torvalds 已提交
1126
	if (!m) {
1127
		ti->error = "can't allocate multipath";
L
Linus Torvalds 已提交
1128 1129 1130
		return -EINVAL;
	}

M
Micha³ Miros³aw 已提交
1131
	r = parse_features(&as, m);
L
Linus Torvalds 已提交
1132 1133 1134
	if (r)
		goto bad;

1135 1136 1137 1138
	r = alloc_multipath_stage2(ti, m);
	if (r)
		goto bad;

M
Micha³ Miros³aw 已提交
1139
	r = parse_hw_handler(&as, m);
L
Linus Torvalds 已提交
1140 1141 1142
	if (r)
		goto bad;

1143
	r = dm_read_arg(_args, &as, &m->nr_priority_groups, &ti->error);
L
Linus Torvalds 已提交
1144 1145 1146
	if (r)
		goto bad;

1147
	r = dm_read_arg(_args + 1, &as, &next_pg_num, &ti->error);
L
Linus Torvalds 已提交
1148 1149 1150
	if (r)
		goto bad;

1151 1152 1153 1154 1155 1156 1157
	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 已提交
1158 1159 1160
	/* parse the priority groups */
	while (as.argc) {
		struct priority_group *pg;
1161
		unsigned nr_valid_paths = atomic_read(&m->nr_valid_paths);
L
Linus Torvalds 已提交
1162

M
Micha³ Miros³aw 已提交
1163
		pg = parse_priority_group(&as, m);
1164 1165
		if (IS_ERR(pg)) {
			r = PTR_ERR(pg);
L
Linus Torvalds 已提交
1166 1167 1168
			goto bad;
		}

1169 1170 1171
		nr_valid_paths += pg->nr_pgpaths;
		atomic_set(&m->nr_valid_paths, nr_valid_paths);

L
Linus Torvalds 已提交
1172 1173 1174 1175 1176 1177 1178 1179
		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) {
1180
		ti->error = "priority group count mismatch";
L
Linus Torvalds 已提交
1181 1182 1183 1184
		r = -EINVAL;
		goto bad;
	}

1185 1186
	ti->num_flush_bios = 1;
	ti->num_discard_bios = 1;
1187
	ti->num_write_same_bios = 1;
1188
	ti->num_write_zeroes_bios = 1;
1189
	if (m->queue_mode == DM_TYPE_BIO_BASED)
1190
		ti->per_io_data_size = multipath_per_bio_data_size();
1191
	else
1192
		ti->per_io_data_size = sizeof(struct dm_mpath_io);
M
Mikulas Patocka 已提交
1193

L
Linus Torvalds 已提交
1194 1195 1196 1197 1198 1199 1200
	return 0;

 bad:
	free_multipath(m);
	return r;
}

1201 1202
static void multipath_wait_for_pg_init_completion(struct multipath *m)
{
1203
	DEFINE_WAIT(wait);
1204 1205

	while (1) {
1206
		prepare_to_wait(&m->pg_init_wait, &wait, TASK_UNINTERRUPTIBLE);
1207

1208
		if (!atomic_read(&m->pg_init_in_progress))
1209 1210 1211 1212
			break;

		io_schedule();
	}
1213
	finish_wait(&m->pg_init_wait, &wait);
1214 1215 1216
}

static void flush_multipath_work(struct multipath *m)
L
Linus Torvalds 已提交
1217
{
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227
	if (m->hw_handler_name) {
		set_bit(MPATHF_PG_INIT_DISABLED, &m->flags);
		smp_mb__after_atomic();

		flush_workqueue(kmpath_handlerd);
		multipath_wait_for_pg_init_completion(m);

		clear_bit(MPATHF_PG_INIT_DISABLED, &m->flags);
		smp_mb__after_atomic();
	}
1228

1229
	flush_workqueue(kmultipathd);
1230
	flush_work(&m->trigger_event);
1231 1232 1233 1234 1235 1236
}

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

1237
	flush_multipath_work(m);
L
Linus Torvalds 已提交
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
	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);

1251
	if (!pgpath->is_active)
L
Linus Torvalds 已提交
1252 1253
		goto out;

1254
	DMWARN("Failing path %s.", pgpath->path.dev->name);
L
Linus Torvalds 已提交
1255 1256

	pgpath->pg->ps.type->fail_path(&pgpath->pg->ps, &pgpath->path);
1257
	pgpath->is_active = false;
L
Linus Torvalds 已提交
1258 1259
	pgpath->fail_count++;

1260
	atomic_dec(&m->nr_valid_paths);
L
Linus Torvalds 已提交
1261 1262 1263 1264

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

M
Mike Anderson 已提交
1265
	dm_path_uevent(DM_UEVENT_PATH_FAILED, m->ti,
1266
		       pgpath->path.dev->name, atomic_read(&m->nr_valid_paths));
M
Mike Anderson 已提交
1267

1268
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280

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

	return 0;
}

/*
 * Reinstate a previously-failed path
 */
static int reinstate_path(struct pgpath *pgpath)
{
1281
	int r = 0, run_queue = 0;
L
Linus Torvalds 已提交
1282 1283
	unsigned long flags;
	struct multipath *m = pgpath->pg->m;
1284
	unsigned nr_valid_paths;
L
Linus Torvalds 已提交
1285 1286 1287

	spin_lock_irqsave(&m->lock, flags);

1288
	if (pgpath->is_active)
L
Linus Torvalds 已提交
1289 1290
		goto out;

1291
	DMWARN("Reinstating path %s.", pgpath->path.dev->name);
L
Linus Torvalds 已提交
1292 1293 1294 1295 1296

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

1297
	pgpath->is_active = true;
L
Linus Torvalds 已提交
1298

1299 1300
	nr_valid_paths = atomic_inc_return(&m->nr_valid_paths);
	if (nr_valid_paths == 1) {
1301
		m->current_pgpath = NULL;
1302
		run_queue = 1;
1303
	} else if (m->hw_handler_name && (m->current_pg == pgpath->pg)) {
1304
		if (queue_work(kmpath_handlerd, &pgpath->activate_path.work))
1305
			atomic_inc(&m->pg_init_in_progress);
1306
	}
L
Linus Torvalds 已提交
1307

M
Mike Anderson 已提交
1308
	dm_path_uevent(DM_UEVENT_PATH_REINSTATED, m->ti,
1309
		       pgpath->path.dev->name, nr_valid_paths);
M
Mike Anderson 已提交
1310

1311
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1312 1313 1314

out:
	spin_unlock_irqrestore(&m->lock, flags);
1315
	if (run_queue) {
1316
		dm_table_run_md_queue_async(m->ti->table);
1317
		process_queued_io_list(m);
1318
	}
L
Linus Torvalds 已提交
1319 1320 1321 1322 1323 1324 1325 1326 1327 1328

	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)
{
1329
	int r = -EINVAL;
L
Linus Torvalds 已提交
1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346
	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,
1347
		      bool bypassed)
L
Linus Torvalds 已提交
1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
{
	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);

1359
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
}

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

1372
	if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
1373
	    !m->nr_priority_groups || (pgnum > m->nr_priority_groups)) {
L
Linus Torvalds 已提交
1374 1375 1376 1377 1378 1379
		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) {
1380
		pg->bypassed = false;
L
Linus Torvalds 已提交
1381 1382 1383 1384 1385 1386 1387 1388 1389
		if (--pgnum)
			continue;

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

1390
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1391 1392 1393 1394 1395 1396 1397
	return 0;
}

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

1404
	if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
1405
	    !m->nr_priority_groups || (pgnum > m->nr_priority_groups)) {
L
Linus Torvalds 已提交
1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
		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 已提交
1419 1420 1421
/*
 * Should we retry pg_init immediately?
 */
1422
static bool pg_init_limit_reached(struct multipath *m, struct pgpath *pgpath)
D
Dave Wysochanski 已提交
1423 1424
{
	unsigned long flags;
1425
	bool limit_reached = false;
D
Dave Wysochanski 已提交
1426 1427 1428

	spin_lock_irqsave(&m->lock, flags);

1429 1430
	if (atomic_read(&m->pg_init_count) <= m->pg_init_retries &&
	    !test_bit(MPATHF_PG_INIT_DISABLED, &m->flags))
1431
		set_bit(MPATHF_PG_INIT_REQUIRED, &m->flags);
D
Dave Wysochanski 已提交
1432
	else
1433
		limit_reached = true;
D
Dave Wysochanski 已提交
1434 1435 1436 1437 1438 1439

	spin_unlock_irqrestore(&m->lock, flags);

	return limit_reached;
}

1440
static void pg_init_done(void *data, int errors)
1441
{
1442
	struct pgpath *pgpath = data;
1443 1444 1445
	struct priority_group *pg = pgpath->pg;
	struct multipath *m = pg->m;
	unsigned long flags;
1446
	bool delay_retry = false;
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456

	/* device or driver problems */
	switch (errors) {
	case SCSI_DH_OK:
		break;
	case SCSI_DH_NOSYS:
		if (!m->hw_handler_name) {
			errors = 0;
			break;
		}
1457 1458
		DMERR("Could not failover the device: Handler scsi_dh_%s "
		      "Error %d.", m->hw_handler_name, errors);
1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
		/*
		 * 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.
		 */
1469
		bypass_pg(m, pg, true);
1470 1471
		break;
	case SCSI_DH_RETRY:
1472 1473
		/* Wait before retrying. */
		delay_retry = 1;
1474
		/* fall through */
1475 1476 1477 1478 1479 1480
	case SCSI_DH_IMM_RETRY:
	case SCSI_DH_RES_TEMP_UNAVAIL:
		if (pg_init_limit_reached(m, pgpath))
			fail_path(pgpath);
		errors = 0;
		break;
1481
	case SCSI_DH_DEV_OFFLINED:
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492
	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) {
1493 1494 1495 1496 1497
		if (pgpath == m->current_pgpath) {
			DMERR("Could not failover device. Error %d.", errors);
			m->current_pgpath = NULL;
			m->current_pg = NULL;
		}
1498
	} else if (!test_bit(MPATHF_PG_INIT_REQUIRED, &m->flags))
1499
		pg->bypassed = false;
1500

1501
	if (atomic_dec_return(&m->pg_init_in_progress) > 0)
1502 1503 1504
		/* Activations of other paths are still on going */
		goto out;

1505 1506 1507 1508 1509 1510
	if (test_bit(MPATHF_PG_INIT_REQUIRED, &m->flags)) {
		if (delay_retry)
			set_bit(MPATHF_PG_INIT_DELAY_RETRY, &m->flags);
		else
			clear_bit(MPATHF_PG_INIT_DELAY_RETRY, &m->flags);

1511 1512 1513
		if (__pg_init_all_paths(m))
			goto out;
	}
1514
	clear_bit(MPATHF_QUEUE_IO, &m->flags);
1515

1516
	process_queued_io_list(m);
1517

1518 1519 1520 1521 1522
	/*
	 * Wake up any thread waiting to suspend.
	 */
	wake_up(&m->pg_init_wait);

1523
out:
1524 1525 1526
	spin_unlock_irqrestore(&m->lock, flags);
}

1527
static void activate_or_offline_path(struct pgpath *pgpath)
1528
{
1529
	struct request_queue *q = bdev_get_queue(pgpath->path.dev->bdev);
1530

1531 1532
	if (pgpath->is_active && !blk_queue_dying(q))
		scsi_dh_activate(q, pg_init_done, pgpath);
1533 1534
	else
		pg_init_done(pgpath, SCSI_DH_DEV_OFFLINED);
1535 1536
}

1537 1538 1539 1540 1541 1542 1543 1544
static void activate_path_work(struct work_struct *work)
{
	struct pgpath *pgpath =
		container_of(work, struct pgpath, activate_path.work);

	activate_or_offline_path(pgpath);
}

1545
static int multipath_end_io(struct dm_target *ti, struct request *clone,
1546
			    blk_status_t error, union map_info *map_context)
L
Linus Torvalds 已提交
1547
{
1548 1549
	struct dm_mpath_io *mpio = get_mpio(map_context);
	struct pgpath *pgpath = mpio->pgpath;
1550
	int r = DM_ENDIO_DONE;
1551

1552 1553 1554 1555 1556
	/*
	 * 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.
1557
	 * (See drivers/md/dm-rq.c:end_clone_bio() about why the clone requests
1558 1559 1560 1561 1562
	 *  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.
	 */
K
Keith Busch 已提交
1563
	if (error && blk_path_error(error)) {
1564
		struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1565

1566 1567 1568 1569
		if (error == BLK_STS_RESOURCE)
			r = DM_ENDIO_DELAY_REQUEUE;
		else
			r = DM_ENDIO_REQUEUE;
L
Linus Torvalds 已提交
1570

1571 1572
		if (pgpath)
			fail_path(pgpath);
L
Linus Torvalds 已提交
1573

1574
		if (atomic_read(&m->nr_valid_paths) == 0 &&
1575
		    !must_push_back_rq(m)) {
1576
			if (error == BLK_STS_IOERR)
1577
				dm_report_EIO(m);
1578 1579 1580
			/* complete with the original error */
			r = DM_ENDIO_DONE;
		}
1581
	}
1582

L
Linus Torvalds 已提交
1583
	if (pgpath) {
1584 1585
		struct path_selector *ps = &pgpath->pg->ps;

L
Linus Torvalds 已提交
1586
		if (ps->type->end_io)
1587
			ps->type->end_io(ps, &pgpath->path, mpio->nr_bytes);
L
Linus Torvalds 已提交
1588 1589
	}

1590
	return r;
L
Linus Torvalds 已提交
1591 1592
}

1593
static int multipath_end_io_bio(struct dm_target *ti, struct bio *clone,
1594
				blk_status_t *error)
1595
{
1596 1597 1598
	struct multipath *m = ti->private;
	struct dm_mpath_io *mpio = get_mpio_from_bio(clone);
	struct pgpath *pgpath = mpio->pgpath;
1599
	unsigned long flags;
1600
	int r = DM_ENDIO_DONE;
1601

K
Keith Busch 已提交
1602
	if (!*error || !blk_path_error(*error))
1603
		goto done;
1604

1605 1606
	if (pgpath)
		fail_path(pgpath);
1607

1608
	if (atomic_read(&m->nr_valid_paths) == 0 &&
1609
	    !test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags)) {
1610 1611 1612 1613 1614 1615
		if (must_push_back_bio(m)) {
			r = DM_ENDIO_REQUEUE;
		} else {
			dm_report_EIO(m);
			*error = BLK_STS_IOERR;
		}
1616
		goto done;
1617
	}
1618 1619 1620 1621 1622 1623 1624

	spin_lock_irqsave(&m->lock, flags);
	bio_list_add(&m->queued_bios, clone);
	spin_unlock_irqrestore(&m->lock, flags);
	if (!test_bit(MPATHF_QUEUE_IO, &m->flags))
		queue_work(kmultipathd, &m->process_queued_bios);

1625
	r = DM_ENDIO_INCOMPLETE;
1626
done:
1627
	if (pgpath) {
1628 1629
		struct path_selector *ps = &pgpath->pg->ps;

1630 1631 1632 1633
		if (ps->type->end_io)
			ps->type->end_io(ps, &pgpath->path, mpio->nr_bytes);
	}

1634
	return r;
1635 1636
}

L
Linus Torvalds 已提交
1637 1638
/*
 * Suspend can't complete until all the I/O is processed so if
1639 1640 1641
 * 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 已提交
1642 1643 1644
 */
static void multipath_presuspend(struct dm_target *ti)
{
1645
	struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1646

1647
	queue_if_no_path(m, false, true);
L
Linus Torvalds 已提交
1648 1649
}

1650 1651
static void multipath_postsuspend(struct dm_target *ti)
{
1652 1653 1654
	struct multipath *m = ti->private;

	mutex_lock(&m->work_mutex);
1655
	flush_multipath_work(m);
1656
	mutex_unlock(&m->work_mutex);
1657 1658
}

1659 1660 1661
/*
 * Restore the queue_if_no_path setting.
 */
L
Linus Torvalds 已提交
1662 1663
static void multipath_resume(struct dm_target *ti)
{
1664
	struct multipath *m = ti->private;
1665
	unsigned long flags;
L
Linus Torvalds 已提交
1666

1667
	spin_lock_irqsave(&m->lock, flags);
L
Lukas Wunner 已提交
1668 1669
	assign_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags,
		   test_bit(MPATHF_SAVED_QUEUE_IF_NO_PATH, &m->flags));
1670
	spin_unlock_irqrestore(&m->lock, flags);
L
Linus Torvalds 已提交
1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688
}

/*
 * 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]* ]+ ]+
 */
1689 1690
static void multipath_status(struct dm_target *ti, status_type_t type,
			     unsigned status_flags, char *result, unsigned maxlen)
L
Linus Torvalds 已提交
1691 1692 1693
{
	int sz = 0;
	unsigned long flags;
1694
	struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1695 1696 1697 1698 1699 1700 1701 1702 1703
	struct priority_group *pg;
	struct pgpath *p;
	unsigned pg_num;
	char state;

	spin_lock_irqsave(&m->lock, flags);

	/* Features */
	if (type == STATUSTYPE_INFO)
1704 1705
		DMEMIT("2 %u %u ", test_bit(MPATHF_QUEUE_IO, &m->flags),
		       atomic_read(&m->pg_init_count));
D
Dave Wysochanski 已提交
1706
	else {
1707
		DMEMIT("%u ", test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags) +
1708
			      (m->pg_init_retries > 0) * 2 +
1709
			      (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT) * 2 +
1710 1711 1712
			      test_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags) +
			      (m->queue_mode != DM_TYPE_REQUEST_BASED) * 2);

1713
		if (test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags))
D
Dave Wysochanski 已提交
1714 1715 1716
			DMEMIT("queue_if_no_path ");
		if (m->pg_init_retries)
			DMEMIT("pg_init_retries %u ", m->pg_init_retries);
1717 1718
		if (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT)
			DMEMIT("pg_init_delay_msecs %u ", m->pg_init_delay_msecs);
1719
		if (test_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags))
1720
			DMEMIT("retain_attached_hw_handler ");
1721 1722 1723 1724 1725 1726 1727 1728
		if (m->queue_mode != DM_TYPE_REQUEST_BASED) {
			switch(m->queue_mode) {
			case DM_TYPE_BIO_BASED:
				DMEMIT("queue_mode bio ");
				break;
			case DM_TYPE_MQ_REQUEST_BASED:
				DMEMIT("queue_mode mq ");
				break;
1729 1730 1731
			default:
				WARN_ON_ONCE(true);
				break;
1732 1733
			}
		}
D
Dave Wysochanski 已提交
1734
	}
L
Linus Torvalds 已提交
1735

1736
	if (!m->hw_handler_name || type == STATUSTYPE_INFO)
L
Linus Torvalds 已提交
1737 1738
		DMEMIT("0 ");
	else
1739
		DMEMIT("1 %s ", m->hw_handler_name);
L
Linus Torvalds 已提交
1740 1741 1742 1743 1744 1745 1746 1747

	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
1748
		pg_num = (m->nr_priority_groups ? 1 : 0);
L
Linus Torvalds 已提交
1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775

	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,
1776
				       p->is_active ? "A" : "F",
L
Linus Torvalds 已提交
1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
				       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)
{
1816
	int r = -EINVAL;
L
Linus Torvalds 已提交
1817
	struct dm_dev *dev;
1818
	struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1819 1820
	action_fn action;

1821 1822
	mutex_lock(&m->work_mutex);

1823 1824 1825 1826 1827
	if (dm_suspended(ti)) {
		r = -EBUSY;
		goto out;
	}

L
Linus Torvalds 已提交
1828
	if (argc == 1) {
1829
		if (!strcasecmp(argv[0], "queue_if_no_path")) {
1830
			r = queue_if_no_path(m, true, false);
1831
			goto out;
1832
		} else if (!strcasecmp(argv[0], "fail_if_no_path")) {
1833
			r = queue_if_no_path(m, false, false);
1834 1835
			goto out;
		}
L
Linus Torvalds 已提交
1836 1837
	}

1838
	if (argc != 2) {
1839
		DMWARN("Invalid multipath message arguments. Expected 2 arguments, got %d.", argc);
1840 1841
		goto out;
	}
L
Linus Torvalds 已提交
1842

1843
	if (!strcasecmp(argv[0], "disable_group")) {
1844
		r = bypass_pg_num(m, argv[1], true);
1845
		goto out;
1846
	} else if (!strcasecmp(argv[0], "enable_group")) {
1847
		r = bypass_pg_num(m, argv[1], false);
1848
		goto out;
1849
	} else if (!strcasecmp(argv[0], "switch_group")) {
1850 1851
		r = switch_pg_num(m, argv[1]);
		goto out;
1852
	} else if (!strcasecmp(argv[0], "reinstate_path"))
L
Linus Torvalds 已提交
1853
		action = reinstate_path;
1854
	else if (!strcasecmp(argv[0], "fail_path"))
L
Linus Torvalds 已提交
1855
		action = fail_path;
1856
	else {
1857
		DMWARN("Unrecognised multipath message received: %s", argv[0]);
1858 1859
		goto out;
	}
L
Linus Torvalds 已提交
1860

1861
	r = dm_get_device(ti, argv[1], dm_table_get_mode(ti->table), &dev);
L
Linus Torvalds 已提交
1862
	if (r) {
1863
		DMWARN("message: error getting device %s",
L
Linus Torvalds 已提交
1864
		       argv[1]);
1865
		goto out;
L
Linus Torvalds 已提交
1866 1867 1868 1869 1870 1871
	}

	r = action_dev(m, dev, action);

	dm_put_device(ti, dev);

1872 1873
out:
	mutex_unlock(&m->work_mutex);
L
Linus Torvalds 已提交
1874 1875 1876
	return r;
}

C
Christoph Hellwig 已提交
1877 1878
static int multipath_prepare_ioctl(struct dm_target *ti,
		struct block_device **bdev, fmode_t *mode)
M
Milan Broz 已提交
1879
{
1880
	struct multipath *m = ti->private;
1881
	struct pgpath *current_pgpath;
1882 1883
	int r;

1884
	current_pgpath = READ_ONCE(m->current_pgpath);
1885 1886
	if (!current_pgpath)
		current_pgpath = choose_pgpath(m, 0);
M
Milan Broz 已提交
1887

1888
	if (current_pgpath) {
1889
		if (!test_bit(MPATHF_QUEUE_IO, &m->flags)) {
1890 1891
			*bdev = current_pgpath->path.dev->bdev;
			*mode = current_pgpath->path.dev->mode;
1892 1893 1894 1895 1896 1897 1898
			r = 0;
		} else {
			/* pg_init has not started or completed */
			r = -ENOTCONN;
		}
	} else {
		/* No path is available */
1899
		if (test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags))
1900 1901 1902
			r = -ENOTCONN;
		else
			r = -EIO;
1903
	}
M
Milan Broz 已提交
1904

1905
	if (r == -ENOTCONN) {
1906
		if (!READ_ONCE(m->current_pg)) {
1907
			/* Path status changed, redo selection */
1908
			(void) choose_pgpath(m, 0);
1909
		}
1910
		if (test_bit(MPATHF_PG_INIT_REQUIRED, &m->flags))
1911
			pg_init_all_paths(m);
1912
		dm_table_run_md_queue_async(m->ti->table);
1913
		process_queued_io_list(m);
1914
	}
1915

C
Christoph Hellwig 已提交
1916 1917 1918 1919 1920 1921
	/*
	 * 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 已提交
1922 1923
}

1924 1925 1926 1927 1928 1929 1930 1931 1932 1933
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) {
1934
			ret = fn(ti, p->path.dev, ti->begin, ti->len, data);
1935 1936 1937 1938 1939 1940 1941 1942 1943
			if (ret)
				goto out;
		}
	}

out:
	return ret;
}

1944
static int pgpath_busy(struct pgpath *pgpath)
1945 1946 1947
{
	struct request_queue *q = bdev_get_queue(pgpath->path.dev->bdev);

1948
	return blk_lld_busy(q);
1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960
}

/*
 * 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)
{
1961
	bool busy = false, has_active = false;
1962
	struct multipath *m = ti->private;
1963
	struct priority_group *pg, *next_pg;
1964 1965
	struct pgpath *pgpath;

1966 1967
	/* pg_init in progress */
	if (atomic_read(&m->pg_init_in_progress))
1968 1969
		return true;

1970 1971 1972 1973
	/* no paths available, for blk-mq: rely on IO mapping to delay requeue */
	if (!atomic_read(&m->nr_valid_paths) && test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags))
		return (m->queue_mode != DM_TYPE_MQ_REQUEST_BASED);

1974
	/* Guess which priority_group will be used at next mapping time */
1975 1976 1977
	pg = READ_ONCE(m->current_pg);
	next_pg = READ_ONCE(m->next_pg);
	if (unlikely(!READ_ONCE(m->current_pgpath) && next_pg))
1978 1979 1980
		pg = next_pg;

	if (!pg) {
1981 1982
		/*
		 * We don't know which pg will be used at next mapping time.
1983
		 * We don't call choose_pgpath() here to avoid to trigger
1984 1985 1986 1987
		 * 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.
		 */
1988 1989
		return busy;
	}
1990 1991 1992 1993 1994

	/*
	 * 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.
	 */
1995
	busy = true;
1996
	list_for_each_entry(pgpath, &pg->pgpaths, list) {
1997
		if (pgpath->is_active) {
1998
			has_active = true;
1999
			if (!pgpath_busy(pgpath)) {
2000
				busy = false;
2001 2002 2003
				break;
			}
		}
2004
	}
2005

2006
	if (!has_active) {
2007 2008 2009 2010 2011
		/*
		 * 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.
		 */
2012
		busy = false;
2013
	}
2014 2015 2016 2017

	return busy;
}

L
Linus Torvalds 已提交
2018 2019 2020 2021 2022
/*-----------------------------------------------------------------
 * Module setup
 *---------------------------------------------------------------*/
static struct target_type multipath_target = {
	.name = "multipath",
2023
	.version = {1, 12, 0},
M
Mike Snitzer 已提交
2024
	.features = DM_TARGET_SINGLETON | DM_TARGET_IMMUTABLE,
L
Linus Torvalds 已提交
2025 2026 2027
	.module = THIS_MODULE,
	.ctr = multipath_ctr,
	.dtr = multipath_dtr,
2028 2029
	.clone_and_map_rq = multipath_clone_and_map,
	.release_clone_rq = multipath_release_clone,
2030
	.rq_end_io = multipath_end_io,
2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042
	.map = multipath_map_bio,
	.end_io = multipath_end_io_bio,
	.presuspend = multipath_presuspend,
	.postsuspend = multipath_postsuspend,
	.resume = multipath_resume,
	.status = multipath_status,
	.message = multipath_message,
	.prepare_ioctl = multipath_prepare_ioctl,
	.iterate_devices = multipath_iterate_devices,
	.busy = multipath_busy,
};

L
Linus Torvalds 已提交
2043 2044 2045 2046
static int __init dm_multipath_init(void)
{
	int r;

2047
	kmultipathd = alloc_workqueue("kmpathd", WQ_MEM_RECLAIM, 0);
2048
	if (!kmultipathd) {
2049
		DMERR("failed to create workqueue kmpathd");
2050 2051
		r = -ENOMEM;
		goto bad_alloc_kmultipathd;
2052 2053
	}

2054 2055 2056 2057 2058 2059
	/*
	 * 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.
	 */
2060 2061
	kmpath_handlerd = alloc_ordered_workqueue("kmpath_handlerd",
						  WQ_MEM_RECLAIM);
2062 2063
	if (!kmpath_handlerd) {
		DMERR("failed to create workqueue kmpath_handlerd");
2064 2065
		r = -ENOMEM;
		goto bad_alloc_kmpath_handlerd;
2066 2067
	}

2068 2069 2070 2071 2072 2073 2074
	r = dm_register_target(&multipath_target);
	if (r < 0) {
		DMERR("request-based register failed %d", r);
		r = -EINVAL;
		goto bad_register_target;
	}

2075 2076
	return 0;

2077 2078
bad_register_target:
	destroy_workqueue(kmpath_handlerd);
2079 2080 2081
bad_alloc_kmpath_handlerd:
	destroy_workqueue(kmultipathd);
bad_alloc_kmultipathd:
L
Linus Torvalds 已提交
2082 2083 2084 2085 2086
	return r;
}

static void __exit dm_multipath_exit(void)
{
2087
	destroy_workqueue(kmpath_handlerd);
2088 2089
	destroy_workqueue(kmultipathd);

2090
	dm_unregister_target(&multipath_target);
L
Linus Torvalds 已提交
2091 2092 2093 2094 2095 2096 2097 2098
}

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