dm-mpath.c 49.3 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 67 68 69
};

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

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

73 74
	spinlock_t lock;

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

	wait_queue_head_t pg_init_wait;	/* Wait for pg_init completion */

L
Linus Torvalds 已提交
80 81 82 83
	struct pgpath *current_pgpath;
	struct priority_group *current_pg;
	struct priority_group *next_pg;	/* Switch to this PG if set */

84
	unsigned long flags;		/* Multipath state flags */
85

D
Dave Wysochanski 已提交
86
	unsigned pg_init_retries;	/* Number of times to retry pg_init */
87
	unsigned pg_init_delay_msecs;	/* Number of msecs before pg_init retry */
L
Linus Torvalds 已提交
88

89 90 91 92
	atomic_t nr_valid_paths;	/* Total number of usable paths */
	atomic_t pg_init_in_progress;	/* Only one pg_init allowed at once */
	atomic_t pg_init_count;		/* Number of times pg_init called */

93
	enum dm_queue_mode queue_mode;
94

95
	struct mutex work_mutex;
96
	struct work_struct trigger_event;
97 98 99

	struct work_struct process_queued_bios;
	struct bio_list queued_bios;
L
Linus Torvalds 已提交
100 101 102
};

/*
103
 * Context information attached to each io we process.
L
Linus Torvalds 已提交
104
 */
A
Alasdair G Kergon 已提交
105
struct dm_mpath_io {
L
Linus Torvalds 已提交
106
	struct pgpath *pgpath;
107
	size_t nr_bytes;
L
Linus Torvalds 已提交
108 109 110 111
};

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

112
static struct workqueue_struct *kmultipathd, *kmpath_handlerd;
D
David Howells 已提交
113
static void trigger_event(struct work_struct *work);
114 115
static void activate_or_offline_path(struct pgpath *pgpath);
static void activate_path_work(struct work_struct *work);
116
static void process_queued_bios(struct work_struct *work);
L
Linus Torvalds 已提交
117

118 119 120 121 122 123 124 125 126 127 128
/*-----------------------------------------------
 * 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 已提交
129 130 131 132 133 134 135

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

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

138
	if (pgpath) {
139
		pgpath->is_active = true;
140
		INIT_DELAYED_WORK(&pgpath->activate_path, activate_path_work);
141
	}
L
Linus Torvalds 已提交
142 143 144 145

	return pgpath;
}

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

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

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

M
Micha³ Miros³aw 已提交
157 158
	if (pg)
		INIT_LIST_HEAD(&pg->pgpaths);
L
Linus Torvalds 已提交
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 185 186 187

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

188
static struct multipath *alloc_multipath(struct dm_target *ti)
L
Linus Torvalds 已提交
189 190 191
{
	struct multipath *m;

M
Micha³ Miros³aw 已提交
192
	m = kzalloc(sizeof(*m), GFP_KERNEL);
L
Linus Torvalds 已提交
193 194 195
	if (m) {
		INIT_LIST_HEAD(&m->priority_groups);
		spin_lock_init(&m->lock);
196
		set_bit(MPATHF_QUEUE_IO, &m->flags);
197 198 199
		atomic_set(&m->nr_valid_paths, 0);
		atomic_set(&m->pg_init_in_progress, 0);
		atomic_set(&m->pg_init_count, 0);
200
		m->pg_init_delay_msecs = DM_PG_INIT_DELAY_DEFAULT;
D
David Howells 已提交
201
		INIT_WORK(&m->trigger_event, trigger_event);
202
		init_waitqueue_head(&m->pg_init_wait);
203
		mutex_init(&m->work_mutex);
204

205
		m->queue_mode = DM_TYPE_NONE;
206

M
Micha³ Miros³aw 已提交
207 208
		m->ti = ti;
		ti->private = m;
L
Linus Torvalds 已提交
209 210 211 212 213
	}

	return m;
}

214 215 216 217 218 219 220 221 222 223
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;
224 225 226

	} else if (m->queue_mode == DM_TYPE_BIO_BASED ||
		   m->queue_mode == DM_TYPE_NVME_BIO_BASED) {
227
		INIT_WORK(&m->process_queued_bios, process_queued_bios);
228 229 230 231 232 233 234 235

		if (m->queue_mode == DM_TYPE_BIO_BASED) {
			/*
			 * 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);
		}
236 237 238 239 240 241 242
	}

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

	return 0;
}

L
Linus Torvalds 已提交
243 244 245 246 247 248 249 250 251
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);
	}

252
	kfree(m->hw_handler_name);
253
	kfree(m->hw_handler_params);
L
Linus Torvalds 已提交
254 255 256
	kfree(m);
}

257 258 259 260 261
static struct dm_mpath_io *get_mpio(union map_info *info)
{
	return info->ptr;
}

262 263 264 265 266
static size_t multipath_per_bio_data_size(void)
{
	return sizeof(struct dm_mpath_io) + sizeof(struct dm_bio_details);
}

267 268
static struct dm_mpath_io *get_mpio_from_bio(struct bio *bio)
{
269
	return dm_per_bio_data(bio, multipath_per_bio_data_size());
270 271
}

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

279
static void multipath_init_per_bio_data(struct bio *bio, struct dm_mpath_io **mpio_p)
280 281
{
	struct dm_mpath_io *mpio = get_mpio_from_bio(bio);
282
	struct dm_bio_details *bio_details = get_bio_details_from_mpio(mpio);
283

284 285 286
	mpio->nr_bytes = bio->bi_iter.bi_size;
	mpio->pgpath = NULL;
	*mpio_p = mpio;
287

288
	dm_bio_record(bio_details, bio);
289 290
}

L
Linus Torvalds 已提交
291 292 293 294
/*-----------------------------------------------
 * Path selection
 *-----------------------------------------------*/

295
static int __pg_init_all_paths(struct multipath *m)
K
Kiyoshi Ueda 已提交
296 297
{
	struct pgpath *pgpath;
298
	unsigned long pg_init_delay = 0;
K
Kiyoshi Ueda 已提交
299

300 301
	lockdep_assert_held(&m->lock);

302
	if (atomic_read(&m->pg_init_in_progress) || test_bit(MPATHF_PG_INIT_DISABLED, &m->flags))
303
		return 0;
304

305
	atomic_inc(&m->pg_init_count);
306
	clear_bit(MPATHF_PG_INIT_REQUIRED, &m->flags);
307 308 309 310 311

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

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

326
static int pg_init_all_paths(struct multipath *m)
L
Linus Torvalds 已提交
327
{
328
	int ret;
329 330 331
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);
332
	ret = __pg_init_all_paths(m);
333
	spin_unlock_irqrestore(&m->lock, flags);
334 335

	return ret;
336 337 338 339 340
}

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

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

351
	atomic_set(&m->pg_init_count, 0);
L
Linus Torvalds 已提交
352 353
}

354 355 356
static struct pgpath *choose_path_in_pg(struct multipath *m,
					struct priority_group *pg,
					size_t nr_bytes)
L
Linus Torvalds 已提交
357
{
358
	unsigned long flags;
359
	struct dm_path *path;
360
	struct pgpath *pgpath;
L
Linus Torvalds 已提交
361

362
	path = pg->ps.type->select_path(&pg->ps, nr_bytes);
L
Linus Torvalds 已提交
363
	if (!path)
364
		return ERR_PTR(-ENXIO);
L
Linus Torvalds 已提交
365

366
	pgpath = path_to_pgpath(path);
L
Linus Torvalds 已提交
367

368
	if (unlikely(READ_ONCE(m->current_pg) != pg)) {
369 370 371 372 373 374
		/* 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 已提交
375

376
	return pgpath;
L
Linus Torvalds 已提交
377 378
}

379
static struct pgpath *choose_pgpath(struct multipath *m, size_t nr_bytes)
L
Linus Torvalds 已提交
380
{
381
	unsigned long flags;
L
Linus Torvalds 已提交
382
	struct priority_group *pg;
383
	struct pgpath *pgpath;
384
	unsigned bypassed = 1;
L
Linus Torvalds 已提交
385

386
	if (!atomic_read(&m->nr_valid_paths)) {
387
		clear_bit(MPATHF_QUEUE_IO, &m->flags);
L
Linus Torvalds 已提交
388
		goto failed;
389
	}
L
Linus Torvalds 已提交
390 391

	/* Were we instructed to switch PG? */
392
	if (READ_ONCE(m->next_pg)) {
393
		spin_lock_irqsave(&m->lock, flags);
L
Linus Torvalds 已提交
394
		pg = m->next_pg;
395 396 397 398
		if (!pg) {
			spin_unlock_irqrestore(&m->lock, flags);
			goto check_current_pg;
		}
L
Linus Torvalds 已提交
399
		m->next_pg = NULL;
400 401 402 403
		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 已提交
404 405 406
	}

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

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

failed:
435
	spin_lock_irqsave(&m->lock, flags);
L
Linus Torvalds 已提交
436 437
	m->current_pgpath = NULL;
	m->current_pg = NULL;
438 439 440
	spin_unlock_irqrestore(&m->lock, flags);

	return NULL;
L
Linus Torvalds 已提交
441 442
}

443
/*
444 445 446
 * 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.
447
 */
448
#define dm_report_EIO(m)						\
449
do {									\
450 451 452 453 454 455 456
	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));			\
457
} while (0)
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 487 488 489 490
/*
 * 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 已提交
491
/*
492
 * Map cloned requests (request-based multipath)
H
Hannes Reinecke 已提交
493
 */
494 495 496
static int multipath_clone_and_map(struct dm_target *ti, struct request *rq,
				   union map_info *map_context,
				   struct request **__clone)
L
Linus Torvalds 已提交
497
{
498
	struct multipath *m = ti->private;
499
	size_t nr_bytes = blk_rq_bytes(rq);
L
Linus Torvalds 已提交
500
	struct pgpath *pgpath;
501
	struct block_device *bdev;
502
	struct dm_mpath_io *mpio = get_mpio(map_context);
503
	struct request_queue *q;
504
	struct request *clone;
L
Linus Torvalds 已提交
505 506

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

511
	if (!pgpath) {
512
		if (must_push_back_rq(m))
513
			return DM_MAPIO_DELAY_REQUEUE;
514
		dm_report_EIO(m);	/* Failed */
515
		return DM_MAPIO_KILL;
516 517
	} else if (test_bit(MPATHF_QUEUE_IO, &m->flags) ||
		   test_bit(MPATHF_PG_INIT_REQUIRED, &m->flags)) {
518 519
		if (pg_init_all_paths(m))
			return DM_MAPIO_DELAY_REQUEUE;
520
		return DM_MAPIO_REQUEUE;
521
	}
522

523 524 525
	mpio->pgpath = pgpath;
	mpio->nr_bytes = nr_bytes;

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

543 544 545 546
	if (pgpath->pg->ps.type->start_io)
		pgpath->pg->ps.type->start_io(&pgpath->pg->ps,
					      &pgpath->path,
					      nr_bytes);
547
	return DM_MAPIO_REMAPPED;
L
Linus Torvalds 已提交
548 549
}

550 551
static void multipath_release_clone(struct request *clone)
{
552
	blk_put_request(clone);
553 554
}

555 556 557 558 559 560 561 562 563 564
/*
 * Map cloned bios (bio-based multipath)
 */
static int __multipath_map_bio(struct multipath *m, struct bio *bio, struct dm_mpath_io *mpio)
{
	struct pgpath *pgpath;
	unsigned long flags;
	bool queue_io;

	/* Do we need to select a new pgpath? */
565
	pgpath = READ_ONCE(m->current_pgpath);
566 567
	queue_io = test_bit(MPATHF_QUEUE_IO, &m->flags);
	if (!pgpath || !queue_io)
568
		pgpath = choose_pgpath(m, mpio->nr_bytes);
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584

	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);
		/* 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);
		return DM_MAPIO_SUBMITTED;
	}

	if (!pgpath) {
585
		if (must_push_back_bio(m))
586
			return DM_MAPIO_REQUEUE;
587
		dm_report_EIO(m);
588
		return DM_MAPIO_KILL;
589 590 591 592
	}

	mpio->pgpath = pgpath;

593
	bio->bi_status = 0;
594
	bio_set_dev(bio, pgpath->path.dev->bdev);
J
Jens Axboe 已提交
595
	bio->bi_opf |= REQ_FAILFAST_TRANSPORT;
596 597 598 599

	if (pgpath->pg->ps.type->start_io)
		pgpath->pg->ps.type->start_io(&pgpath->pg->ps,
					      &pgpath->path,
600
					      mpio->nr_bytes);
601 602 603 604 605 606
	return DM_MAPIO_REMAPPED;
}

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

609
	multipath_init_per_bio_data(bio, &mpio);
610 611 612
	return __multipath_map_bio(m, bio, mpio);
}

613
static void process_queued_io_list(struct multipath *m)
614
{
615 616
	if (m->queue_mode == DM_TYPE_MQ_REQUEST_BASED)
		dm_mq_kick_requeue_list(dm_table_get_md(m->ti->table));
617 618
	else if (m->queue_mode == DM_TYPE_BIO_BASED ||
		 m->queue_mode == DM_TYPE_NVME_BIO_BASED)
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
		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))) {
648 649 650
		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);
651 652
		switch (r) {
		case DM_MAPIO_KILL:
653 654
			bio->bi_status = BLK_STS_IOERR;
			bio_endio(bio);
655
			break;
656
		case DM_MAPIO_REQUEUE:
657
			bio->bi_status = BLK_STS_DM_REQUEUE;
658
			bio_endio(bio);
659 660
			break;
		case DM_MAPIO_REMAPPED:
661
			generic_make_request(bio);
662
			break;
663 664 665 666
		case 0:
			break;
		default:
			WARN_ONCE(true, "__multipath_map_bio() returned %d\n", r);
667
		}
668 669 670 671
	}
	blk_finish_plug(&plug);
}

L
Linus Torvalds 已提交
672 673 674
/*
 * If we run out of usable paths, should we queue I/O or error it?
 */
675 676
static int queue_if_no_path(struct multipath *m, bool queue_if_no_path,
			    bool save_old_value)
L
Linus Torvalds 已提交
677 678 679 680
{
	unsigned long flags;

	spin_lock_irqsave(&m->lock, flags);
L
Lukas Wunner 已提交
681 682 683
	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));
684
	assign_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags, queue_if_no_path);
L
Linus Torvalds 已提交
685 686
	spin_unlock_irqrestore(&m->lock, flags);

687
	if (!queue_if_no_path) {
688
		dm_table_run_md_queue_async(m->ti->table);
689
		process_queued_io_list(m);
690
	}
691

L
Linus Torvalds 已提交
692 693 694 695 696 697 698
	return 0;
}

/*
 * An event is triggered whenever a path is taken out of use.
 * Includes path failure and PG bypass.
 */
D
David Howells 已提交
699
static void trigger_event(struct work_struct *work)
L
Linus Torvalds 已提交
700
{
D
David Howells 已提交
701 702
	struct multipath *m =
		container_of(work, struct multipath, trigger_event);
L
Linus Torvalds 已提交
703 704 705 706 707 708 709 710 711 712 713 714 715 716

	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>]* ]+ ]+
 *---------------------------------------------------------------*/
717
static int parse_path_selector(struct dm_arg_set *as, struct priority_group *pg,
L
Linus Torvalds 已提交
718 719 720 721 722 723
			       struct dm_target *ti)
{
	int r;
	struct path_selector_type *pst;
	unsigned ps_argc;

E
Eric Biggers 已提交
724
	static const struct dm_arg _args[] = {
725
		{0, 1024, "invalid number of path selector args"},
L
Linus Torvalds 已提交
726 727
	};

728
	pst = dm_get_path_selector(dm_shift_arg(as));
L
Linus Torvalds 已提交
729
	if (!pst) {
730
		ti->error = "unknown path selector type";
L
Linus Torvalds 已提交
731 732 733
		return -EINVAL;
	}

734
	r = dm_read_arg_group(_args, as, &ps_argc, &ti->error);
735 736
	if (r) {
		dm_put_path_selector(pst);
L
Linus Torvalds 已提交
737
		return -EINVAL;
738
	}
L
Linus Torvalds 已提交
739 740 741 742

	r = pst->create(&pg->ps, ps_argc, as->argv);
	if (r) {
		dm_put_path_selector(pst);
743
		ti->error = "path selector constructor failed";
L
Linus Torvalds 已提交
744 745 746 747
		return r;
	}

	pg->ps.type = pst;
748
	dm_consume_args(as, ps_argc);
L
Linus Torvalds 已提交
749 750 751 752

	return 0;
}

753
static struct pgpath *parse_path(struct dm_arg_set *as, struct path_selector *ps,
L
Linus Torvalds 已提交
754 755 756 757
			       struct dm_target *ti)
{
	int r;
	struct pgpath *p;
758
	struct multipath *m = ti->private;
759 760
	struct request_queue *q = NULL;
	const char *attached_handler_name;
L
Linus Torvalds 已提交
761 762 763

	/* we need at least a path arg */
	if (as->argc < 1) {
764
		ti->error = "no device given";
765
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
766 767 768 769
	}

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

772
	r = dm_get_device(ti, dm_shift_arg(as), dm_table_get_mode(ti->table),
773
			  &p->path.dev);
L
Linus Torvalds 已提交
774
	if (r) {
775
		ti->error = "error getting device";
L
Linus Torvalds 已提交
776 777 778
		goto bad;
	}

779
	if (test_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags) || m->hw_handler_name)
780 781
		q = bdev_get_queue(p->path.dev->bdev);

782
	if (test_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags)) {
783
retain:
784 785
		attached_handler_name = scsi_dh_attached_handler_name(q, GFP_KERNEL);
		if (attached_handler_name) {
786 787 788 789 790 791 792 793 794
			/*
			 * 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;
			}

795 796 797 798 799 800 801 802 803 804
			/*
			 * 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;
		}
	}
805

806
	if (m->hw_handler_name) {
807 808
		r = scsi_dh_attach(q, m->hw_handler_name);
		if (r == -EBUSY) {
809
			char b[BDEVNAME_SIZE];
810

811 812 813 814
			printk(KERN_INFO "dm-mpath: retaining handler on device %s\n",
				bdevname(p->path.dev->bdev, b));
			goto retain;
		}
815
		if (r < 0) {
816
			ti->error = "error attaching hardware handler";
817 818 819
			dm_put_device(ti, p->path.dev);
			goto bad;
		}
820 821 822 823 824 825 826 827 828 829

		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;
			}
		}
830 831
	}

L
Linus Torvalds 已提交
832 833 834 835 836 837 838 839 840 841
	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);
842
	return ERR_PTR(r);
L
Linus Torvalds 已提交
843 844
}

845
static struct priority_group *parse_priority_group(struct dm_arg_set *as,
M
Micha³ Miros³aw 已提交
846
						   struct multipath *m)
L
Linus Torvalds 已提交
847
{
E
Eric Biggers 已提交
848
	static const struct dm_arg _args[] = {
849 850
		{1, 1024, "invalid number of paths"},
		{0, 1024, "invalid number of selector args"}
L
Linus Torvalds 已提交
851 852 853
	};

	int r;
854
	unsigned i, nr_selector_args, nr_args;
L
Linus Torvalds 已提交
855
	struct priority_group *pg;
M
Micha³ Miros³aw 已提交
856
	struct dm_target *ti = m->ti;
L
Linus Torvalds 已提交
857 858 859

	if (as->argc < 2) {
		as->argc = 0;
860 861
		ti->error = "not enough priority group arguments";
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
862 863 864 865
	}

	pg = alloc_priority_group();
	if (!pg) {
866
		ti->error = "couldn't allocate priority group";
867
		return ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
868 869 870 871 872 873 874 875 876 877
	}
	pg->m = m;

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

	/*
	 * read the paths
	 */
878
	r = dm_read_arg(_args, as, &pg->nr_pgpaths, &ti->error);
L
Linus Torvalds 已提交
879 880 881
	if (r)
		goto bad;

882
	r = dm_read_arg(_args + 1, as, &nr_selector_args, &ti->error);
L
Linus Torvalds 已提交
883 884 885
	if (r)
		goto bad;

886
	nr_args = 1 + nr_selector_args;
L
Linus Torvalds 已提交
887 888
	for (i = 0; i < pg->nr_pgpaths; i++) {
		struct pgpath *pgpath;
889
		struct dm_arg_set path_args;
L
Linus Torvalds 已提交
890

891
		if (as->argc < nr_args) {
892
			ti->error = "not enough path parameters";
893
			r = -EINVAL;
L
Linus Torvalds 已提交
894
			goto bad;
895
		}
L
Linus Torvalds 已提交
896

897
		path_args.argc = nr_args;
L
Linus Torvalds 已提交
898 899 900
		path_args.argv = as->argv;

		pgpath = parse_path(&path_args, &pg->ps, ti);
901 902
		if (IS_ERR(pgpath)) {
			r = PTR_ERR(pgpath);
L
Linus Torvalds 已提交
903
			goto bad;
904
		}
L
Linus Torvalds 已提交
905 906 907

		pgpath->pg = pg;
		list_add_tail(&pgpath->list, &pg->pgpaths);
908
		dm_consume_args(as, nr_args);
L
Linus Torvalds 已提交
909 910 911 912 913 914
	}

	return pg;

 bad:
	free_priority_group(pg, ti);
915
	return ERR_PTR(r);
L
Linus Torvalds 已提交
916 917
}

918
static int parse_hw_handler(struct dm_arg_set *as, struct multipath *m)
L
Linus Torvalds 已提交
919 920
{
	unsigned hw_argc;
921
	int ret;
M
Micha³ Miros³aw 已提交
922
	struct dm_target *ti = m->ti;
L
Linus Torvalds 已提交
923

E
Eric Biggers 已提交
924
	static const struct dm_arg _args[] = {
925
		{0, 1024, "invalid number of hardware handler args"},
L
Linus Torvalds 已提交
926 927
	};

928
	if (dm_read_arg_group(_args, as, &hw_argc, &ti->error))
L
Linus Torvalds 已提交
929 930 931 932 933
		return -EINVAL;

	if (!hw_argc)
		return 0;

934 935
	if (m->queue_mode == DM_TYPE_BIO_BASED ||
	    m->queue_mode == DM_TYPE_NVME_BIO_BASED) {
936 937 938 939 940
		dm_consume_args(as, hw_argc);
		DMERR("bio-based multipath doesn't allow hardware handler args");
		return 0;
	}

941
	m->hw_handler_name = kstrdup(dm_shift_arg(as), GFP_KERNEL);
942 943
	if (!m->hw_handler_name)
		return -EINVAL;
944

945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
	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]);
	}
961
	dm_consume_args(as, hw_argc - 1);
L
Linus Torvalds 已提交
962 963

	return 0;
964 965 966 967
fail:
	kfree(m->hw_handler_name);
	m->hw_handler_name = NULL;
	return ret;
L
Linus Torvalds 已提交
968 969
}

970
static int parse_features(struct dm_arg_set *as, struct multipath *m)
L
Linus Torvalds 已提交
971 972 973
{
	int r;
	unsigned argc;
M
Micha³ Miros³aw 已提交
974
	struct dm_target *ti = m->ti;
975
	const char *arg_name;
L
Linus Torvalds 已提交
976

E
Eric Biggers 已提交
977
	static const struct dm_arg _args[] = {
978
		{0, 8, "invalid number of feature args"},
D
Dave Wysochanski 已提交
979
		{1, 50, "pg_init_retries must be between 1 and 50"},
980
		{0, 60000, "pg_init_delay_msecs must be between 0 and 60000"},
L
Linus Torvalds 已提交
981 982
	};

983
	r = dm_read_arg_group(_args, as, &argc, &ti->error);
L
Linus Torvalds 已提交
984 985 986 987 988 989
	if (r)
		return -EINVAL;

	if (!argc)
		return 0;

D
Dave Wysochanski 已提交
990
	do {
991
		arg_name = dm_shift_arg(as);
D
Dave Wysochanski 已提交
992 993
		argc--;

994
		if (!strcasecmp(arg_name, "queue_if_no_path")) {
995
			r = queue_if_no_path(m, true, false);
D
Dave Wysochanski 已提交
996 997 998
			continue;
		}

999
		if (!strcasecmp(arg_name, "retain_attached_hw_handler")) {
1000
			set_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags);
1001 1002 1003
			continue;
		}

1004
		if (!strcasecmp(arg_name, "pg_init_retries") &&
D
Dave Wysochanski 已提交
1005
		    (argc >= 1)) {
1006
			r = dm_read_arg(_args + 1, as, &m->pg_init_retries, &ti->error);
D
Dave Wysochanski 已提交
1007 1008 1009 1010
			argc--;
			continue;
		}

1011
		if (!strcasecmp(arg_name, "pg_init_delay_msecs") &&
1012
		    (argc >= 1)) {
1013
			r = dm_read_arg(_args + 2, as, &m->pg_init_delay_msecs, &ti->error);
1014 1015 1016 1017
			argc--;
			continue;
		}

1018 1019 1020 1021 1022 1023
		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;
1024 1025
			else if (!strcasecmp(queue_mode_name, "nvme"))
				m->queue_mode = DM_TYPE_NVME_BIO_BASED;
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
			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 已提交
1038
		ti->error = "Unrecognised multipath feature request";
D
Dave Wysochanski 已提交
1039 1040 1041 1042
		r = -EINVAL;
	} while (argc && !r);

	return r;
L
Linus Torvalds 已提交
1043 1044
}

1045
static int multipath_ctr(struct dm_target *ti, unsigned argc, char **argv)
L
Linus Torvalds 已提交
1046
{
1047
	/* target arguments */
E
Eric Biggers 已提交
1048
	static const struct dm_arg _args[] = {
1049 1050
		{0, 1024, "invalid number of priority groups"},
		{0, 1024, "invalid initial priority group number"},
L
Linus Torvalds 已提交
1051 1052 1053 1054
	};

	int r;
	struct multipath *m;
1055
	struct dm_arg_set as;
L
Linus Torvalds 已提交
1056 1057 1058 1059 1060 1061
	unsigned pg_count = 0;
	unsigned next_pg_num;

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

1062
	m = alloc_multipath(ti);
L
Linus Torvalds 已提交
1063
	if (!m) {
1064
		ti->error = "can't allocate multipath";
L
Linus Torvalds 已提交
1065 1066 1067
		return -EINVAL;
	}

M
Micha³ Miros³aw 已提交
1068
	r = parse_features(&as, m);
L
Linus Torvalds 已提交
1069 1070 1071
	if (r)
		goto bad;

1072 1073 1074 1075
	r = alloc_multipath_stage2(ti, m);
	if (r)
		goto bad;

M
Micha³ Miros³aw 已提交
1076
	r = parse_hw_handler(&as, m);
L
Linus Torvalds 已提交
1077 1078 1079
	if (r)
		goto bad;

1080
	r = dm_read_arg(_args, &as, &m->nr_priority_groups, &ti->error);
L
Linus Torvalds 已提交
1081 1082 1083
	if (r)
		goto bad;

1084
	r = dm_read_arg(_args + 1, &as, &next_pg_num, &ti->error);
L
Linus Torvalds 已提交
1085 1086 1087
	if (r)
		goto bad;

1088 1089 1090 1091 1092 1093 1094
	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 已提交
1095 1096 1097
	/* parse the priority groups */
	while (as.argc) {
		struct priority_group *pg;
1098
		unsigned nr_valid_paths = atomic_read(&m->nr_valid_paths);
L
Linus Torvalds 已提交
1099

M
Micha³ Miros³aw 已提交
1100
		pg = parse_priority_group(&as, m);
1101 1102
		if (IS_ERR(pg)) {
			r = PTR_ERR(pg);
L
Linus Torvalds 已提交
1103 1104 1105
			goto bad;
		}

1106 1107 1108
		nr_valid_paths += pg->nr_pgpaths;
		atomic_set(&m->nr_valid_paths, nr_valid_paths);

L
Linus Torvalds 已提交
1109 1110 1111 1112 1113 1114 1115 1116
		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) {
1117
		ti->error = "priority group count mismatch";
L
Linus Torvalds 已提交
1118 1119 1120 1121
		r = -EINVAL;
		goto bad;
	}

1122 1123
	ti->num_flush_bios = 1;
	ti->num_discard_bios = 1;
1124
	ti->num_write_same_bios = 1;
1125
	ti->num_write_zeroes_bios = 1;
1126
	if (m->queue_mode == DM_TYPE_BIO_BASED || m->queue_mode == DM_TYPE_NVME_BIO_BASED)
1127
		ti->per_io_data_size = multipath_per_bio_data_size();
1128
	else
1129
		ti->per_io_data_size = sizeof(struct dm_mpath_io);
M
Mikulas Patocka 已提交
1130

L
Linus Torvalds 已提交
1131 1132 1133 1134 1135 1136 1137
	return 0;

 bad:
	free_multipath(m);
	return r;
}

1138 1139
static void multipath_wait_for_pg_init_completion(struct multipath *m)
{
1140
	DEFINE_WAIT(wait);
1141 1142

	while (1) {
1143
		prepare_to_wait(&m->pg_init_wait, &wait, TASK_UNINTERRUPTIBLE);
1144

1145
		if (!atomic_read(&m->pg_init_in_progress))
1146 1147 1148 1149
			break;

		io_schedule();
	}
1150
	finish_wait(&m->pg_init_wait, &wait);
1151 1152 1153
}

static void flush_multipath_work(struct multipath *m)
L
Linus Torvalds 已提交
1154
{
1155 1156
	set_bit(MPATHF_PG_INIT_DISABLED, &m->flags);
	smp_mb__after_atomic();
1157

1158
	flush_workqueue(kmpath_handlerd);
1159
	multipath_wait_for_pg_init_completion(m);
1160
	flush_workqueue(kmultipathd);
1161
	flush_work(&m->trigger_event);
1162

1163 1164
	clear_bit(MPATHF_PG_INIT_DISABLED, &m->flags);
	smp_mb__after_atomic();
1165 1166 1167 1168 1169 1170
}

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

1171
	flush_multipath_work(m);
L
Linus Torvalds 已提交
1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
	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);

1185
	if (!pgpath->is_active)
L
Linus Torvalds 已提交
1186 1187
		goto out;

1188
	DMWARN("Failing path %s.", pgpath->path.dev->name);
L
Linus Torvalds 已提交
1189 1190

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

1194
	atomic_dec(&m->nr_valid_paths);
L
Linus Torvalds 已提交
1195 1196 1197 1198

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

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

1202
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214

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

	return 0;
}

/*
 * Reinstate a previously-failed path
 */
static int reinstate_path(struct pgpath *pgpath)
{
1215
	int r = 0, run_queue = 0;
L
Linus Torvalds 已提交
1216 1217
	unsigned long flags;
	struct multipath *m = pgpath->pg->m;
1218
	unsigned nr_valid_paths;
L
Linus Torvalds 已提交
1219 1220 1221

	spin_lock_irqsave(&m->lock, flags);

1222
	if (pgpath->is_active)
L
Linus Torvalds 已提交
1223 1224
		goto out;

1225
	DMWARN("Reinstating path %s.", pgpath->path.dev->name);
L
Linus Torvalds 已提交
1226 1227 1228 1229 1230

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

1231
	pgpath->is_active = true;
L
Linus Torvalds 已提交
1232

1233 1234
	nr_valid_paths = atomic_inc_return(&m->nr_valid_paths);
	if (nr_valid_paths == 1) {
1235
		m->current_pgpath = NULL;
1236
		run_queue = 1;
1237
	} else if (m->hw_handler_name && (m->current_pg == pgpath->pg)) {
1238
		if (queue_work(kmpath_handlerd, &pgpath->activate_path.work))
1239
			atomic_inc(&m->pg_init_in_progress);
1240
	}
L
Linus Torvalds 已提交
1241

M
Mike Anderson 已提交
1242
	dm_path_uevent(DM_UEVENT_PATH_REINSTATED, m->ti,
1243
		       pgpath->path.dev->name, nr_valid_paths);
M
Mike Anderson 已提交
1244

1245
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1246 1247 1248

out:
	spin_unlock_irqrestore(&m->lock, flags);
1249
	if (run_queue) {
1250
		dm_table_run_md_queue_async(m->ti->table);
1251
		process_queued_io_list(m);
1252
	}
L
Linus Torvalds 已提交
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262

	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)
{
1263
	int r = -EINVAL;
L
Linus Torvalds 已提交
1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
	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,
1281
		      bool bypassed)
L
Linus Torvalds 已提交
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292
{
	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);

1293
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
}

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

1306
	if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
1307
	    !m->nr_priority_groups || (pgnum > m->nr_priority_groups)) {
L
Linus Torvalds 已提交
1308 1309 1310 1311 1312 1313
		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) {
1314
		pg->bypassed = false;
L
Linus Torvalds 已提交
1315 1316 1317 1318 1319 1320 1321 1322 1323
		if (--pgnum)
			continue;

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

1324
	schedule_work(&m->trigger_event);
L
Linus Torvalds 已提交
1325 1326 1327 1328 1329 1330 1331
	return 0;
}

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

1338
	if (!pgstr || (sscanf(pgstr, "%u%c", &pgnum, &dummy) != 1) || !pgnum ||
1339
	    !m->nr_priority_groups || (pgnum > m->nr_priority_groups)) {
L
Linus Torvalds 已提交
1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
		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 已提交
1353 1354 1355
/*
 * Should we retry pg_init immediately?
 */
1356
static bool pg_init_limit_reached(struct multipath *m, struct pgpath *pgpath)
D
Dave Wysochanski 已提交
1357 1358
{
	unsigned long flags;
1359
	bool limit_reached = false;
D
Dave Wysochanski 已提交
1360 1361 1362

	spin_lock_irqsave(&m->lock, flags);

1363 1364
	if (atomic_read(&m->pg_init_count) <= m->pg_init_retries &&
	    !test_bit(MPATHF_PG_INIT_DISABLED, &m->flags))
1365
		set_bit(MPATHF_PG_INIT_REQUIRED, &m->flags);
D
Dave Wysochanski 已提交
1366
	else
1367
		limit_reached = true;
D
Dave Wysochanski 已提交
1368 1369 1370 1371 1372 1373

	spin_unlock_irqrestore(&m->lock, flags);

	return limit_reached;
}

1374
static void pg_init_done(void *data, int errors)
1375
{
1376
	struct pgpath *pgpath = data;
1377 1378 1379
	struct priority_group *pg = pgpath->pg;
	struct multipath *m = pg->m;
	unsigned long flags;
1380
	bool delay_retry = false;
1381 1382 1383 1384 1385 1386 1387 1388 1389 1390

	/* device or driver problems */
	switch (errors) {
	case SCSI_DH_OK:
		break;
	case SCSI_DH_NOSYS:
		if (!m->hw_handler_name) {
			errors = 0;
			break;
		}
1391 1392
		DMERR("Could not failover the device: Handler scsi_dh_%s "
		      "Error %d.", m->hw_handler_name, errors);
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
		/*
		 * 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.
		 */
1403
		bypass_pg(m, pg, true);
1404 1405
		break;
	case SCSI_DH_RETRY:
1406 1407
		/* Wait before retrying. */
		delay_retry = 1;
1408
		/* fall through */
1409 1410 1411 1412 1413 1414
	case SCSI_DH_IMM_RETRY:
	case SCSI_DH_RES_TEMP_UNAVAIL:
		if (pg_init_limit_reached(m, pgpath))
			fail_path(pgpath);
		errors = 0;
		break;
1415
	case SCSI_DH_DEV_OFFLINED:
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426
	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) {
1427 1428 1429 1430 1431
		if (pgpath == m->current_pgpath) {
			DMERR("Could not failover device. Error %d.", errors);
			m->current_pgpath = NULL;
			m->current_pg = NULL;
		}
1432
	} else if (!test_bit(MPATHF_PG_INIT_REQUIRED, &m->flags))
1433
		pg->bypassed = false;
1434

1435
	if (atomic_dec_return(&m->pg_init_in_progress) > 0)
1436 1437 1438
		/* Activations of other paths are still on going */
		goto out;

1439 1440 1441 1442 1443 1444
	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);

1445 1446 1447
		if (__pg_init_all_paths(m))
			goto out;
	}
1448
	clear_bit(MPATHF_QUEUE_IO, &m->flags);
1449

1450
	process_queued_io_list(m);
1451

1452 1453 1454 1455 1456
	/*
	 * Wake up any thread waiting to suspend.
	 */
	wake_up(&m->pg_init_wait);

1457
out:
1458 1459 1460
	spin_unlock_irqrestore(&m->lock, flags);
}

1461
static void activate_or_offline_path(struct pgpath *pgpath)
1462
{
1463
	struct request_queue *q = bdev_get_queue(pgpath->path.dev->bdev);
1464

1465 1466
	if (pgpath->is_active && !blk_queue_dying(q))
		scsi_dh_activate(q, pg_init_done, pgpath);
1467 1468
	else
		pg_init_done(pgpath, SCSI_DH_DEV_OFFLINED);
1469 1470
}

1471 1472 1473 1474 1475 1476 1477 1478
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);
}

1479
static int noretry_error(blk_status_t error)
1480 1481
{
	switch (error) {
1482 1483 1484 1485 1486
	case BLK_STS_NOTSUPP:
	case BLK_STS_NOSPC:
	case BLK_STS_TARGET:
	case BLK_STS_NEXUS:
	case BLK_STS_MEDIUM:
1487 1488 1489 1490 1491 1492 1493
		return 1;
	}

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

1494
static int multipath_end_io(struct dm_target *ti, struct request *clone,
1495
			    blk_status_t error, union map_info *map_context)
L
Linus Torvalds 已提交
1496
{
1497 1498
	struct dm_mpath_io *mpio = get_mpio(map_context);
	struct pgpath *pgpath = mpio->pgpath;
1499
	int r = DM_ENDIO_DONE;
1500

1501 1502 1503 1504 1505
	/*
	 * 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.
1506
	 * (See drivers/md/dm-rq.c:end_clone_bio() about why the clone requests
1507 1508 1509 1510 1511
	 *  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.
	 */
1512 1513
	if (error && !noretry_error(error)) {
		struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1514

1515
		r = DM_ENDIO_REQUEUE;
L
Linus Torvalds 已提交
1516

1517 1518
		if (pgpath)
			fail_path(pgpath);
L
Linus Torvalds 已提交
1519

1520
		if (atomic_read(&m->nr_valid_paths) == 0 &&
1521
		    !must_push_back_rq(m)) {
1522
			if (error == BLK_STS_IOERR)
1523
				dm_report_EIO(m);
1524 1525 1526
			/* complete with the original error */
			r = DM_ENDIO_DONE;
		}
1527
	}
1528

L
Linus Torvalds 已提交
1529
	if (pgpath) {
1530 1531
		struct path_selector *ps = &pgpath->pg->ps;

L
Linus Torvalds 已提交
1532
		if (ps->type->end_io)
1533
			ps->type->end_io(ps, &pgpath->path, mpio->nr_bytes);
L
Linus Torvalds 已提交
1534 1535
	}

1536
	return r;
L
Linus Torvalds 已提交
1537 1538
}

1539 1540
static int multipath_end_io_bio(struct dm_target *ti, struct bio *clone,
		blk_status_t *error)
1541
{
1542 1543 1544
	struct multipath *m = ti->private;
	struct dm_mpath_io *mpio = get_mpio_from_bio(clone);
	struct pgpath *pgpath = mpio->pgpath;
1545
	unsigned long flags;
1546
	int r = DM_ENDIO_DONE;
1547

1548
	if (!*error || noretry_error(*error))
1549
		goto done;
1550

1551 1552
	if (pgpath)
		fail_path(pgpath);
1553

1554
	if (atomic_read(&m->nr_valid_paths) == 0 &&
1555
	    !test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags)) {
1556 1557 1558 1559 1560 1561
		if (must_push_back_bio(m)) {
			r = DM_ENDIO_REQUEUE;
		} else {
			dm_report_EIO(m);
			*error = BLK_STS_IOERR;
		}
1562
		goto done;
1563
	}
1564 1565 1566 1567 1568 1569 1570

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

1571
	r = DM_ENDIO_INCOMPLETE;
1572
done:
1573
	if (pgpath) {
1574 1575
		struct path_selector *ps = &pgpath->pg->ps;

1576 1577 1578 1579
		if (ps->type->end_io)
			ps->type->end_io(ps, &pgpath->path, mpio->nr_bytes);
	}

1580
	return r;
1581 1582
}

L
Linus Torvalds 已提交
1583 1584
/*
 * Suspend can't complete until all the I/O is processed so if
1585 1586 1587
 * 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 已提交
1588 1589 1590
 */
static void multipath_presuspend(struct dm_target *ti)
{
1591
	struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1592

1593
	queue_if_no_path(m, false, true);
L
Linus Torvalds 已提交
1594 1595
}

1596 1597
static void multipath_postsuspend(struct dm_target *ti)
{
1598 1599 1600
	struct multipath *m = ti->private;

	mutex_lock(&m->work_mutex);
1601
	flush_multipath_work(m);
1602
	mutex_unlock(&m->work_mutex);
1603 1604
}

1605 1606 1607
/*
 * Restore the queue_if_no_path setting.
 */
L
Linus Torvalds 已提交
1608 1609
static void multipath_resume(struct dm_target *ti)
{
1610
	struct multipath *m = ti->private;
1611
	unsigned long flags;
L
Linus Torvalds 已提交
1612

1613
	spin_lock_irqsave(&m->lock, flags);
L
Lukas Wunner 已提交
1614 1615
	assign_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags,
		   test_bit(MPATHF_SAVED_QUEUE_IF_NO_PATH, &m->flags));
1616
	spin_unlock_irqrestore(&m->lock, flags);
L
Linus Torvalds 已提交
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634
}

/*
 * 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]* ]+ ]+
 */
1635 1636
static void multipath_status(struct dm_target *ti, status_type_t type,
			     unsigned status_flags, char *result, unsigned maxlen)
L
Linus Torvalds 已提交
1637 1638 1639
{
	int sz = 0;
	unsigned long flags;
1640
	struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1641 1642 1643 1644 1645 1646 1647 1648 1649
	struct priority_group *pg;
	struct pgpath *p;
	unsigned pg_num;
	char state;

	spin_lock_irqsave(&m->lock, flags);

	/* Features */
	if (type == STATUSTYPE_INFO)
1650 1651
		DMEMIT("2 %u %u ", test_bit(MPATHF_QUEUE_IO, &m->flags),
		       atomic_read(&m->pg_init_count));
D
Dave Wysochanski 已提交
1652
	else {
1653
		DMEMIT("%u ", test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags) +
1654
			      (m->pg_init_retries > 0) * 2 +
1655
			      (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT) * 2 +
1656 1657 1658
			      test_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags) +
			      (m->queue_mode != DM_TYPE_REQUEST_BASED) * 2);

1659
		if (test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags))
D
Dave Wysochanski 已提交
1660 1661 1662
			DMEMIT("queue_if_no_path ");
		if (m->pg_init_retries)
			DMEMIT("pg_init_retries %u ", m->pg_init_retries);
1663 1664
		if (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT)
			DMEMIT("pg_init_delay_msecs %u ", m->pg_init_delay_msecs);
1665
		if (test_bit(MPATHF_RETAIN_ATTACHED_HW_HANDLER, &m->flags))
1666
			DMEMIT("retain_attached_hw_handler ");
1667 1668 1669 1670 1671
		if (m->queue_mode != DM_TYPE_REQUEST_BASED) {
			switch(m->queue_mode) {
			case DM_TYPE_BIO_BASED:
				DMEMIT("queue_mode bio ");
				break;
1672 1673 1674
			case DM_TYPE_NVME_BIO_BASED:
				DMEMIT("queue_mode nvme ");
				break;
1675 1676 1677
			case DM_TYPE_MQ_REQUEST_BASED:
				DMEMIT("queue_mode mq ");
				break;
1678 1679 1680
			default:
				WARN_ON_ONCE(true);
				break;
1681 1682
			}
		}
D
Dave Wysochanski 已提交
1683
	}
L
Linus Torvalds 已提交
1684

1685
	if (!m->hw_handler_name || type == STATUSTYPE_INFO)
L
Linus Torvalds 已提交
1686 1687
		DMEMIT("0 ");
	else
1688
		DMEMIT("1 %s ", m->hw_handler_name);
L
Linus Torvalds 已提交
1689 1690 1691 1692 1693 1694 1695 1696

	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
1697
		pg_num = (m->nr_priority_groups ? 1 : 0);
L
Linus Torvalds 已提交
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724

	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,
1725
				       p->is_active ? "A" : "F",
L
Linus Torvalds 已提交
1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764
				       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)
{
1765
	int r = -EINVAL;
L
Linus Torvalds 已提交
1766
	struct dm_dev *dev;
1767
	struct multipath *m = ti->private;
L
Linus Torvalds 已提交
1768 1769
	action_fn action;

1770 1771
	mutex_lock(&m->work_mutex);

1772 1773 1774 1775 1776
	if (dm_suspended(ti)) {
		r = -EBUSY;
		goto out;
	}

L
Linus Torvalds 已提交
1777
	if (argc == 1) {
1778
		if (!strcasecmp(argv[0], "queue_if_no_path")) {
1779
			r = queue_if_no_path(m, true, false);
1780
			goto out;
1781
		} else if (!strcasecmp(argv[0], "fail_if_no_path")) {
1782
			r = queue_if_no_path(m, false, false);
1783 1784
			goto out;
		}
L
Linus Torvalds 已提交
1785 1786
	}

1787
	if (argc != 2) {
1788
		DMWARN("Invalid multipath message arguments. Expected 2 arguments, got %d.", argc);
1789 1790
		goto out;
	}
L
Linus Torvalds 已提交
1791

1792
	if (!strcasecmp(argv[0], "disable_group")) {
1793
		r = bypass_pg_num(m, argv[1], true);
1794
		goto out;
1795
	} else if (!strcasecmp(argv[0], "enable_group")) {
1796
		r = bypass_pg_num(m, argv[1], false);
1797
		goto out;
1798
	} else if (!strcasecmp(argv[0], "switch_group")) {
1799 1800
		r = switch_pg_num(m, argv[1]);
		goto out;
1801
	} else if (!strcasecmp(argv[0], "reinstate_path"))
L
Linus Torvalds 已提交
1802
		action = reinstate_path;
1803
	else if (!strcasecmp(argv[0], "fail_path"))
L
Linus Torvalds 已提交
1804
		action = fail_path;
1805
	else {
1806
		DMWARN("Unrecognised multipath message received: %s", argv[0]);
1807 1808
		goto out;
	}
L
Linus Torvalds 已提交
1809

1810
	r = dm_get_device(ti, argv[1], dm_table_get_mode(ti->table), &dev);
L
Linus Torvalds 已提交
1811
	if (r) {
1812
		DMWARN("message: error getting device %s",
L
Linus Torvalds 已提交
1813
		       argv[1]);
1814
		goto out;
L
Linus Torvalds 已提交
1815 1816 1817 1818 1819 1820
	}

	r = action_dev(m, dev, action);

	dm_put_device(ti, dev);

1821 1822
out:
	mutex_unlock(&m->work_mutex);
L
Linus Torvalds 已提交
1823 1824 1825
	return r;
}

C
Christoph Hellwig 已提交
1826 1827
static int multipath_prepare_ioctl(struct dm_target *ti,
		struct block_device **bdev, fmode_t *mode)
M
Milan Broz 已提交
1828
{
1829
	struct multipath *m = ti->private;
1830
	struct pgpath *current_pgpath;
1831 1832
	int r;

1833
	current_pgpath = READ_ONCE(m->current_pgpath);
1834 1835
	if (!current_pgpath)
		current_pgpath = choose_pgpath(m, 0);
M
Milan Broz 已提交
1836

1837
	if (current_pgpath) {
1838
		if (!test_bit(MPATHF_QUEUE_IO, &m->flags)) {
1839 1840
			*bdev = current_pgpath->path.dev->bdev;
			*mode = current_pgpath->path.dev->mode;
1841 1842 1843 1844 1845 1846 1847
			r = 0;
		} else {
			/* pg_init has not started or completed */
			r = -ENOTCONN;
		}
	} else {
		/* No path is available */
1848
		if (test_bit(MPATHF_QUEUE_IF_NO_PATH, &m->flags))
1849 1850 1851
			r = -ENOTCONN;
		else
			r = -EIO;
1852
	}
M
Milan Broz 已提交
1853

1854
	if (r == -ENOTCONN) {
1855
		if (!READ_ONCE(m->current_pg)) {
1856
			/* Path status changed, redo selection */
1857
			(void) choose_pgpath(m, 0);
1858
		}
1859
		if (test_bit(MPATHF_PG_INIT_REQUIRED, &m->flags))
1860
			pg_init_all_paths(m);
1861
		dm_table_run_md_queue_async(m->ti->table);
1862
		process_queued_io_list(m);
1863
	}
1864

C
Christoph Hellwig 已提交
1865 1866 1867 1868 1869 1870
	/*
	 * 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 已提交
1871 1872
}

1873 1874 1875 1876 1877 1878 1879 1880 1881 1882
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) {
1883
			ret = fn(ti, p->path.dev, ti->begin, ti->len, data);
1884 1885 1886 1887 1888 1889 1890 1891 1892
			if (ret)
				goto out;
		}
	}

out:
	return ret;
}

1893
static int pgpath_busy(struct pgpath *pgpath)
1894 1895 1896
{
	struct request_queue *q = bdev_get_queue(pgpath->path.dev->bdev);

1897
	return blk_lld_busy(q);
1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909
}

/*
 * 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)
{
1910
	bool busy = false, has_active = false;
1911
	struct multipath *m = ti->private;
1912
	struct priority_group *pg, *next_pg;
1913 1914
	struct pgpath *pgpath;

1915 1916
	/* pg_init in progress */
	if (atomic_read(&m->pg_init_in_progress))
1917 1918
		return true;

1919 1920 1921 1922
	/* 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);

1923
	/* Guess which priority_group will be used at next mapping time */
1924 1925 1926
	pg = READ_ONCE(m->current_pg);
	next_pg = READ_ONCE(m->next_pg);
	if (unlikely(!READ_ONCE(m->current_pgpath) && next_pg))
1927 1928 1929
		pg = next_pg;

	if (!pg) {
1930 1931
		/*
		 * We don't know which pg will be used at next mapping time.
1932
		 * We don't call choose_pgpath() here to avoid to trigger
1933 1934 1935 1936
		 * 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.
		 */
1937 1938
		return busy;
	}
1939 1940 1941 1942 1943

	/*
	 * 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.
	 */
1944
	busy = true;
1945
	list_for_each_entry(pgpath, &pg->pgpaths, list) {
1946
		if (pgpath->is_active) {
1947
			has_active = true;
1948
			if (!pgpath_busy(pgpath)) {
1949
				busy = false;
1950 1951 1952
				break;
			}
		}
1953
	}
1954

1955
	if (!has_active) {
1956 1957 1958 1959 1960
		/*
		 * 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.
		 */
1961
		busy = false;
1962
	}
1963 1964 1965 1966

	return busy;
}

L
Linus Torvalds 已提交
1967 1968 1969 1970 1971
/*-----------------------------------------------------------------
 * Module setup
 *---------------------------------------------------------------*/
static struct target_type multipath_target = {
	.name = "multipath",
1972
	.version = {1, 12, 0},
M
Mike Snitzer 已提交
1973
	.features = DM_TARGET_SINGLETON | DM_TARGET_IMMUTABLE,
L
Linus Torvalds 已提交
1974 1975 1976
	.module = THIS_MODULE,
	.ctr = multipath_ctr,
	.dtr = multipath_dtr,
1977 1978
	.clone_and_map_rq = multipath_clone_and_map,
	.release_clone_rq = multipath_release_clone,
1979
	.rq_end_io = multipath_end_io,
1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991
	.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 已提交
1992 1993 1994 1995
static int __init dm_multipath_init(void)
{
	int r;

1996
	kmultipathd = alloc_workqueue("kmpathd", WQ_MEM_RECLAIM, 0);
1997
	if (!kmultipathd) {
1998
		DMERR("failed to create workqueue kmpathd");
1999 2000
		r = -ENOMEM;
		goto bad_alloc_kmultipathd;
2001 2002
	}

2003 2004 2005 2006 2007 2008
	/*
	 * 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.
	 */
2009 2010
	kmpath_handlerd = alloc_ordered_workqueue("kmpath_handlerd",
						  WQ_MEM_RECLAIM);
2011 2012
	if (!kmpath_handlerd) {
		DMERR("failed to create workqueue kmpath_handlerd");
2013 2014
		r = -ENOMEM;
		goto bad_alloc_kmpath_handlerd;
2015 2016
	}

2017 2018 2019 2020 2021 2022 2023
	r = dm_register_target(&multipath_target);
	if (r < 0) {
		DMERR("request-based register failed %d", r);
		r = -EINVAL;
		goto bad_register_target;
	}

2024 2025
	return 0;

2026 2027
bad_register_target:
	destroy_workqueue(kmpath_handlerd);
2028 2029 2030
bad_alloc_kmpath_handlerd:
	destroy_workqueue(kmultipathd);
bad_alloc_kmultipathd:
L
Linus Torvalds 已提交
2031 2032 2033 2034 2035
	return r;
}

static void __exit dm_multipath_exit(void)
{
2036
	destroy_workqueue(kmpath_handlerd);
2037 2038
	destroy_workqueue(kmultipathd);

2039
	dm_unregister_target(&multipath_target);
L
Linus Torvalds 已提交
2040 2041 2042 2043 2044 2045 2046 2047
}

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