1 /* 2 * Copyright (C) 2003 Sistina Software Limited. 3 * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved. 4 * 5 * This file is released under the GPL. 6 */ 7 8 #include <linux/device-mapper.h> 9 10 #include "dm-path-selector.h" 11 #include "dm-uevent.h" 12 13 #include <linux/ctype.h> 14 #include <linux/init.h> 15 #include <linux/mempool.h> 16 #include <linux/module.h> 17 #include <linux/pagemap.h> 18 #include <linux/slab.h> 19 #include <linux/time.h> 20 #include <linux/workqueue.h> 21 #include <scsi/scsi_dh.h> 22 #include <asm/atomic.h> 23 24 #define DM_MSG_PREFIX "multipath" 25 #define MESG_STR(x) x, sizeof(x) 26 #define DM_PG_INIT_DELAY_MSECS 2000 27 #define DM_PG_INIT_DELAY_DEFAULT ((unsigned) -1) 28 29 /* Path properties */ 30 struct pgpath { 31 struct list_head list; 32 33 struct priority_group *pg; /* Owning PG */ 34 unsigned is_active; /* Path status */ 35 unsigned fail_count; /* Cumulative failure count */ 36 37 struct dm_path path; 38 struct delayed_work activate_path; 39 }; 40 41 #define path_to_pgpath(__pgp) container_of((__pgp), struct pgpath, path) 42 43 /* 44 * Paths are grouped into Priority Groups and numbered from 1 upwards. 45 * Each has a path selector which controls which path gets used. 46 */ 47 struct priority_group { 48 struct list_head list; 49 50 struct multipath *m; /* Owning multipath instance */ 51 struct path_selector ps; 52 53 unsigned pg_num; /* Reference number */ 54 unsigned bypassed; /* Temporarily bypass this PG? */ 55 56 unsigned nr_pgpaths; /* Number of paths in PG */ 57 struct list_head pgpaths; 58 }; 59 60 /* Multipath context */ 61 struct multipath { 62 struct list_head list; 63 struct dm_target *ti; 64 65 spinlock_t lock; 66 67 const char *hw_handler_name; 68 char *hw_handler_params; 69 70 unsigned nr_priority_groups; 71 struct list_head priority_groups; 72 73 wait_queue_head_t pg_init_wait; /* Wait for pg_init completion */ 74 75 unsigned pg_init_required; /* pg_init needs calling? */ 76 unsigned pg_init_in_progress; /* Only one pg_init allowed at once */ 77 unsigned pg_init_delay_retry; /* Delay pg_init retry? */ 78 79 unsigned nr_valid_paths; /* Total number of usable paths */ 80 struct pgpath *current_pgpath; 81 struct priority_group *current_pg; 82 struct priority_group *next_pg; /* Switch to this PG if set */ 83 unsigned repeat_count; /* I/Os left before calling PS again */ 84 85 unsigned queue_io; /* Must we queue all I/O? */ 86 unsigned queue_if_no_path; /* Queue I/O if last path fails? */ 87 unsigned saved_queue_if_no_path;/* Saved state during suspension */ 88 unsigned pg_init_retries; /* Number of times to retry pg_init */ 89 unsigned pg_init_count; /* Number of times pg_init called */ 90 unsigned pg_init_delay_msecs; /* Number of msecs before pg_init retry */ 91 92 struct work_struct process_queued_ios; 93 struct list_head queued_ios; 94 unsigned queue_size; 95 96 struct work_struct trigger_event; 97 98 /* 99 * We must use a mempool of dm_mpath_io structs so that we 100 * can resubmit bios on error. 101 */ 102 mempool_t *mpio_pool; 103 104 struct mutex work_mutex; 105 }; 106 107 /* 108 * Context information attached to each bio we process. 109 */ 110 struct dm_mpath_io { 111 struct pgpath *pgpath; 112 size_t nr_bytes; 113 }; 114 115 typedef int (*action_fn) (struct pgpath *pgpath); 116 117 #define MIN_IOS 256 /* Mempool size */ 118 119 static struct kmem_cache *_mpio_cache; 120 121 static struct workqueue_struct *kmultipathd, *kmpath_handlerd; 122 static void process_queued_ios(struct work_struct *work); 123 static void trigger_event(struct work_struct *work); 124 static void activate_path(struct work_struct *work); 125 126 127 /*----------------------------------------------- 128 * Allocation routines 129 *-----------------------------------------------*/ 130 131 static struct pgpath *alloc_pgpath(void) 132 { 133 struct pgpath *pgpath = kzalloc(sizeof(*pgpath), GFP_KERNEL); 134 135 if (pgpath) { 136 pgpath->is_active = 1; 137 INIT_DELAYED_WORK(&pgpath->activate_path, activate_path); 138 } 139 140 return pgpath; 141 } 142 143 static void free_pgpath(struct pgpath *pgpath) 144 { 145 kfree(pgpath); 146 } 147 148 static struct priority_group *alloc_priority_group(void) 149 { 150 struct priority_group *pg; 151 152 pg = kzalloc(sizeof(*pg), GFP_KERNEL); 153 154 if (pg) 155 INIT_LIST_HEAD(&pg->pgpaths); 156 157 return pg; 158 } 159 160 static void free_pgpaths(struct list_head *pgpaths, struct dm_target *ti) 161 { 162 struct pgpath *pgpath, *tmp; 163 struct multipath *m = ti->private; 164 165 list_for_each_entry_safe(pgpath, tmp, pgpaths, list) { 166 list_del(&pgpath->list); 167 if (m->hw_handler_name) 168 scsi_dh_detach(bdev_get_queue(pgpath->path.dev->bdev)); 169 dm_put_device(ti, pgpath->path.dev); 170 free_pgpath(pgpath); 171 } 172 } 173 174 static void free_priority_group(struct priority_group *pg, 175 struct dm_target *ti) 176 { 177 struct path_selector *ps = &pg->ps; 178 179 if (ps->type) { 180 ps->type->destroy(ps); 181 dm_put_path_selector(ps->type); 182 } 183 184 free_pgpaths(&pg->pgpaths, ti); 185 kfree(pg); 186 } 187 188 static struct multipath *alloc_multipath(struct dm_target *ti) 189 { 190 struct multipath *m; 191 192 m = kzalloc(sizeof(*m), GFP_KERNEL); 193 if (m) { 194 INIT_LIST_HEAD(&m->priority_groups); 195 INIT_LIST_HEAD(&m->queued_ios); 196 spin_lock_init(&m->lock); 197 m->queue_io = 1; 198 m->pg_init_delay_msecs = DM_PG_INIT_DELAY_DEFAULT; 199 INIT_WORK(&m->process_queued_ios, process_queued_ios); 200 INIT_WORK(&m->trigger_event, trigger_event); 201 init_waitqueue_head(&m->pg_init_wait); 202 mutex_init(&m->work_mutex); 203 m->mpio_pool = mempool_create_slab_pool(MIN_IOS, _mpio_cache); 204 if (!m->mpio_pool) { 205 kfree(m); 206 return NULL; 207 } 208 m->ti = ti; 209 ti->private = m; 210 } 211 212 return m; 213 } 214 215 static void free_multipath(struct multipath *m) 216 { 217 struct priority_group *pg, *tmp; 218 219 list_for_each_entry_safe(pg, tmp, &m->priority_groups, list) { 220 list_del(&pg->list); 221 free_priority_group(pg, m->ti); 222 } 223 224 kfree(m->hw_handler_name); 225 kfree(m->hw_handler_params); 226 mempool_destroy(m->mpio_pool); 227 kfree(m); 228 } 229 230 231 /*----------------------------------------------- 232 * Path selection 233 *-----------------------------------------------*/ 234 235 static void __pg_init_all_paths(struct multipath *m) 236 { 237 struct pgpath *pgpath; 238 unsigned long pg_init_delay = 0; 239 240 m->pg_init_count++; 241 m->pg_init_required = 0; 242 if (m->pg_init_delay_retry) 243 pg_init_delay = msecs_to_jiffies(m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT ? 244 m->pg_init_delay_msecs : DM_PG_INIT_DELAY_MSECS); 245 list_for_each_entry(pgpath, &m->current_pg->pgpaths, list) { 246 /* Skip failed paths */ 247 if (!pgpath->is_active) 248 continue; 249 if (queue_delayed_work(kmpath_handlerd, &pgpath->activate_path, 250 pg_init_delay)) 251 m->pg_init_in_progress++; 252 } 253 } 254 255 static void __switch_pg(struct multipath *m, struct pgpath *pgpath) 256 { 257 m->current_pg = pgpath->pg; 258 259 /* Must we initialise the PG first, and queue I/O till it's ready? */ 260 if (m->hw_handler_name) { 261 m->pg_init_required = 1; 262 m->queue_io = 1; 263 } else { 264 m->pg_init_required = 0; 265 m->queue_io = 0; 266 } 267 268 m->pg_init_count = 0; 269 } 270 271 static int __choose_path_in_pg(struct multipath *m, struct priority_group *pg, 272 size_t nr_bytes) 273 { 274 struct dm_path *path; 275 276 path = pg->ps.type->select_path(&pg->ps, &m->repeat_count, nr_bytes); 277 if (!path) 278 return -ENXIO; 279 280 m->current_pgpath = path_to_pgpath(path); 281 282 if (m->current_pg != pg) 283 __switch_pg(m, m->current_pgpath); 284 285 return 0; 286 } 287 288 static void __choose_pgpath(struct multipath *m, size_t nr_bytes) 289 { 290 struct priority_group *pg; 291 unsigned bypassed = 1; 292 293 if (!m->nr_valid_paths) 294 goto failed; 295 296 /* Were we instructed to switch PG? */ 297 if (m->next_pg) { 298 pg = m->next_pg; 299 m->next_pg = NULL; 300 if (!__choose_path_in_pg(m, pg, nr_bytes)) 301 return; 302 } 303 304 /* Don't change PG until it has no remaining paths */ 305 if (m->current_pg && !__choose_path_in_pg(m, m->current_pg, nr_bytes)) 306 return; 307 308 /* 309 * Loop through priority groups until we find a valid path. 310 * First time we skip PGs marked 'bypassed'. 311 * Second time we only try the ones we skipped. 312 */ 313 do { 314 list_for_each_entry(pg, &m->priority_groups, list) { 315 if (pg->bypassed == bypassed) 316 continue; 317 if (!__choose_path_in_pg(m, pg, nr_bytes)) 318 return; 319 } 320 } while (bypassed--); 321 322 failed: 323 m->current_pgpath = NULL; 324 m->current_pg = NULL; 325 } 326 327 /* 328 * Check whether bios must be queued in the device-mapper core rather 329 * than here in the target. 330 * 331 * m->lock must be held on entry. 332 * 333 * If m->queue_if_no_path and m->saved_queue_if_no_path hold the 334 * same value then we are not between multipath_presuspend() 335 * and multipath_resume() calls and we have no need to check 336 * for the DMF_NOFLUSH_SUSPENDING flag. 337 */ 338 static int __must_push_back(struct multipath *m) 339 { 340 return (m->queue_if_no_path != m->saved_queue_if_no_path && 341 dm_noflush_suspending(m->ti)); 342 } 343 344 static int map_io(struct multipath *m, struct request *clone, 345 struct dm_mpath_io *mpio, unsigned was_queued) 346 { 347 int r = DM_MAPIO_REMAPPED; 348 size_t nr_bytes = blk_rq_bytes(clone); 349 unsigned long flags; 350 struct pgpath *pgpath; 351 struct block_device *bdev; 352 353 spin_lock_irqsave(&m->lock, flags); 354 355 /* Do we need to select a new pgpath? */ 356 if (!m->current_pgpath || 357 (!m->queue_io && (m->repeat_count && --m->repeat_count == 0))) 358 __choose_pgpath(m, nr_bytes); 359 360 pgpath = m->current_pgpath; 361 362 if (was_queued) 363 m->queue_size--; 364 365 if ((pgpath && m->queue_io) || 366 (!pgpath && m->queue_if_no_path)) { 367 /* Queue for the daemon to resubmit */ 368 list_add_tail(&clone->queuelist, &m->queued_ios); 369 m->queue_size++; 370 if ((m->pg_init_required && !m->pg_init_in_progress) || 371 !m->queue_io) 372 queue_work(kmultipathd, &m->process_queued_ios); 373 pgpath = NULL; 374 r = DM_MAPIO_SUBMITTED; 375 } else if (pgpath) { 376 bdev = pgpath->path.dev->bdev; 377 clone->q = bdev_get_queue(bdev); 378 clone->rq_disk = bdev->bd_disk; 379 } else if (__must_push_back(m)) 380 r = DM_MAPIO_REQUEUE; 381 else 382 r = -EIO; /* Failed */ 383 384 mpio->pgpath = pgpath; 385 mpio->nr_bytes = nr_bytes; 386 387 if (r == DM_MAPIO_REMAPPED && pgpath->pg->ps.type->start_io) 388 pgpath->pg->ps.type->start_io(&pgpath->pg->ps, &pgpath->path, 389 nr_bytes); 390 391 spin_unlock_irqrestore(&m->lock, flags); 392 393 return r; 394 } 395 396 /* 397 * If we run out of usable paths, should we queue I/O or error it? 398 */ 399 static int queue_if_no_path(struct multipath *m, unsigned queue_if_no_path, 400 unsigned save_old_value) 401 { 402 unsigned long flags; 403 404 spin_lock_irqsave(&m->lock, flags); 405 406 if (save_old_value) 407 m->saved_queue_if_no_path = m->queue_if_no_path; 408 else 409 m->saved_queue_if_no_path = queue_if_no_path; 410 m->queue_if_no_path = queue_if_no_path; 411 if (!m->queue_if_no_path && m->queue_size) 412 queue_work(kmultipathd, &m->process_queued_ios); 413 414 spin_unlock_irqrestore(&m->lock, flags); 415 416 return 0; 417 } 418 419 /*----------------------------------------------------------------- 420 * The multipath daemon is responsible for resubmitting queued ios. 421 *---------------------------------------------------------------*/ 422 423 static void dispatch_queued_ios(struct multipath *m) 424 { 425 int r; 426 unsigned long flags; 427 struct dm_mpath_io *mpio; 428 union map_info *info; 429 struct request *clone, *n; 430 LIST_HEAD(cl); 431 432 spin_lock_irqsave(&m->lock, flags); 433 list_splice_init(&m->queued_ios, &cl); 434 spin_unlock_irqrestore(&m->lock, flags); 435 436 list_for_each_entry_safe(clone, n, &cl, queuelist) { 437 list_del_init(&clone->queuelist); 438 439 info = dm_get_rq_mapinfo(clone); 440 mpio = info->ptr; 441 442 r = map_io(m, clone, mpio, 1); 443 if (r < 0) { 444 mempool_free(mpio, m->mpio_pool); 445 dm_kill_unmapped_request(clone, r); 446 } else if (r == DM_MAPIO_REMAPPED) 447 dm_dispatch_request(clone); 448 else if (r == DM_MAPIO_REQUEUE) { 449 mempool_free(mpio, m->mpio_pool); 450 dm_requeue_unmapped_request(clone); 451 } 452 } 453 } 454 455 static void process_queued_ios(struct work_struct *work) 456 { 457 struct multipath *m = 458 container_of(work, struct multipath, process_queued_ios); 459 struct pgpath *pgpath = NULL; 460 unsigned must_queue = 1; 461 unsigned long flags; 462 463 spin_lock_irqsave(&m->lock, flags); 464 465 if (!m->queue_size) 466 goto out; 467 468 if (!m->current_pgpath) 469 __choose_pgpath(m, 0); 470 471 pgpath = m->current_pgpath; 472 473 if ((pgpath && !m->queue_io) || 474 (!pgpath && !m->queue_if_no_path)) 475 must_queue = 0; 476 477 if (m->pg_init_required && !m->pg_init_in_progress && pgpath) 478 __pg_init_all_paths(m); 479 480 out: 481 spin_unlock_irqrestore(&m->lock, flags); 482 if (!must_queue) 483 dispatch_queued_ios(m); 484 } 485 486 /* 487 * An event is triggered whenever a path is taken out of use. 488 * Includes path failure and PG bypass. 489 */ 490 static void trigger_event(struct work_struct *work) 491 { 492 struct multipath *m = 493 container_of(work, struct multipath, trigger_event); 494 495 dm_table_event(m->ti->table); 496 } 497 498 /*----------------------------------------------------------------- 499 * Constructor/argument parsing: 500 * <#multipath feature args> [<arg>]* 501 * <#hw_handler args> [hw_handler [<arg>]*] 502 * <#priority groups> 503 * <initial priority group> 504 * [<selector> <#selector args> [<arg>]* 505 * <#paths> <#per-path selector args> 506 * [<path> [<arg>]* ]+ ]+ 507 *---------------------------------------------------------------*/ 508 struct param { 509 unsigned min; 510 unsigned max; 511 char *error; 512 }; 513 514 static int read_param(struct param *param, char *str, unsigned *v, char **error) 515 { 516 if (!str || 517 (sscanf(str, "%u", v) != 1) || 518 (*v < param->min) || 519 (*v > param->max)) { 520 *error = param->error; 521 return -EINVAL; 522 } 523 524 return 0; 525 } 526 527 struct arg_set { 528 unsigned argc; 529 char **argv; 530 }; 531 532 static char *shift(struct arg_set *as) 533 { 534 char *r; 535 536 if (as->argc) { 537 as->argc--; 538 r = *as->argv; 539 as->argv++; 540 return r; 541 } 542 543 return NULL; 544 } 545 546 static void consume(struct arg_set *as, unsigned n) 547 { 548 BUG_ON (as->argc < n); 549 as->argc -= n; 550 as->argv += n; 551 } 552 553 static int parse_path_selector(struct arg_set *as, struct priority_group *pg, 554 struct dm_target *ti) 555 { 556 int r; 557 struct path_selector_type *pst; 558 unsigned ps_argc; 559 560 static struct param _params[] = { 561 {0, 1024, "invalid number of path selector args"}, 562 }; 563 564 pst = dm_get_path_selector(shift(as)); 565 if (!pst) { 566 ti->error = "unknown path selector type"; 567 return -EINVAL; 568 } 569 570 r = read_param(_params, shift(as), &ps_argc, &ti->error); 571 if (r) { 572 dm_put_path_selector(pst); 573 return -EINVAL; 574 } 575 576 if (ps_argc > as->argc) { 577 dm_put_path_selector(pst); 578 ti->error = "not enough arguments for path selector"; 579 return -EINVAL; 580 } 581 582 r = pst->create(&pg->ps, ps_argc, as->argv); 583 if (r) { 584 dm_put_path_selector(pst); 585 ti->error = "path selector constructor failed"; 586 return r; 587 } 588 589 pg->ps.type = pst; 590 consume(as, ps_argc); 591 592 return 0; 593 } 594 595 static struct pgpath *parse_path(struct arg_set *as, struct path_selector *ps, 596 struct dm_target *ti) 597 { 598 int r; 599 struct pgpath *p; 600 struct multipath *m = ti->private; 601 602 /* we need at least a path arg */ 603 if (as->argc < 1) { 604 ti->error = "no device given"; 605 return ERR_PTR(-EINVAL); 606 } 607 608 p = alloc_pgpath(); 609 if (!p) 610 return ERR_PTR(-ENOMEM); 611 612 r = dm_get_device(ti, shift(as), dm_table_get_mode(ti->table), 613 &p->path.dev); 614 if (r) { 615 ti->error = "error getting device"; 616 goto bad; 617 } 618 619 if (m->hw_handler_name) { 620 struct request_queue *q = bdev_get_queue(p->path.dev->bdev); 621 622 r = scsi_dh_attach(q, m->hw_handler_name); 623 if (r == -EBUSY) { 624 /* 625 * Already attached to different hw_handler, 626 * try to reattach with correct one. 627 */ 628 scsi_dh_detach(q); 629 r = scsi_dh_attach(q, m->hw_handler_name); 630 } 631 632 if (r < 0) { 633 ti->error = "error attaching hardware handler"; 634 dm_put_device(ti, p->path.dev); 635 goto bad; 636 } 637 638 if (m->hw_handler_params) { 639 r = scsi_dh_set_params(q, m->hw_handler_params); 640 if (r < 0) { 641 ti->error = "unable to set hardware " 642 "handler parameters"; 643 scsi_dh_detach(q); 644 dm_put_device(ti, p->path.dev); 645 goto bad; 646 } 647 } 648 } 649 650 r = ps->type->add_path(ps, &p->path, as->argc, as->argv, &ti->error); 651 if (r) { 652 dm_put_device(ti, p->path.dev); 653 goto bad; 654 } 655 656 return p; 657 658 bad: 659 free_pgpath(p); 660 return ERR_PTR(r); 661 } 662 663 static struct priority_group *parse_priority_group(struct arg_set *as, 664 struct multipath *m) 665 { 666 static struct param _params[] = { 667 {1, 1024, "invalid number of paths"}, 668 {0, 1024, "invalid number of selector args"} 669 }; 670 671 int r; 672 unsigned i, nr_selector_args, nr_params; 673 struct priority_group *pg; 674 struct dm_target *ti = m->ti; 675 676 if (as->argc < 2) { 677 as->argc = 0; 678 ti->error = "not enough priority group arguments"; 679 return ERR_PTR(-EINVAL); 680 } 681 682 pg = alloc_priority_group(); 683 if (!pg) { 684 ti->error = "couldn't allocate priority group"; 685 return ERR_PTR(-ENOMEM); 686 } 687 pg->m = m; 688 689 r = parse_path_selector(as, pg, ti); 690 if (r) 691 goto bad; 692 693 /* 694 * read the paths 695 */ 696 r = read_param(_params, shift(as), &pg->nr_pgpaths, &ti->error); 697 if (r) 698 goto bad; 699 700 r = read_param(_params + 1, shift(as), &nr_selector_args, &ti->error); 701 if (r) 702 goto bad; 703 704 nr_params = 1 + nr_selector_args; 705 for (i = 0; i < pg->nr_pgpaths; i++) { 706 struct pgpath *pgpath; 707 struct arg_set path_args; 708 709 if (as->argc < nr_params) { 710 ti->error = "not enough path parameters"; 711 r = -EINVAL; 712 goto bad; 713 } 714 715 path_args.argc = nr_params; 716 path_args.argv = as->argv; 717 718 pgpath = parse_path(&path_args, &pg->ps, ti); 719 if (IS_ERR(pgpath)) { 720 r = PTR_ERR(pgpath); 721 goto bad; 722 } 723 724 pgpath->pg = pg; 725 list_add_tail(&pgpath->list, &pg->pgpaths); 726 consume(as, nr_params); 727 } 728 729 return pg; 730 731 bad: 732 free_priority_group(pg, ti); 733 return ERR_PTR(r); 734 } 735 736 static int parse_hw_handler(struct arg_set *as, struct multipath *m) 737 { 738 unsigned hw_argc; 739 int ret; 740 struct dm_target *ti = m->ti; 741 742 static struct param _params[] = { 743 {0, 1024, "invalid number of hardware handler args"}, 744 }; 745 746 if (read_param(_params, shift(as), &hw_argc, &ti->error)) 747 return -EINVAL; 748 749 if (!hw_argc) 750 return 0; 751 752 if (hw_argc > as->argc) { 753 ti->error = "not enough arguments for hardware handler"; 754 return -EINVAL; 755 } 756 757 m->hw_handler_name = kstrdup(shift(as), GFP_KERNEL); 758 request_module("scsi_dh_%s", m->hw_handler_name); 759 if (scsi_dh_handler_exist(m->hw_handler_name) == 0) { 760 ti->error = "unknown hardware handler type"; 761 ret = -EINVAL; 762 goto fail; 763 } 764 765 if (hw_argc > 1) { 766 char *p; 767 int i, j, len = 4; 768 769 for (i = 0; i <= hw_argc - 2; i++) 770 len += strlen(as->argv[i]) + 1; 771 p = m->hw_handler_params = kzalloc(len, GFP_KERNEL); 772 if (!p) { 773 ti->error = "memory allocation failed"; 774 ret = -ENOMEM; 775 goto fail; 776 } 777 j = sprintf(p, "%d", hw_argc - 1); 778 for (i = 0, p+=j+1; i <= hw_argc - 2; i++, p+=j+1) 779 j = sprintf(p, "%s", as->argv[i]); 780 } 781 consume(as, hw_argc - 1); 782 783 return 0; 784 fail: 785 kfree(m->hw_handler_name); 786 m->hw_handler_name = NULL; 787 return ret; 788 } 789 790 static int parse_features(struct arg_set *as, struct multipath *m) 791 { 792 int r; 793 unsigned argc; 794 struct dm_target *ti = m->ti; 795 const char *param_name; 796 797 static struct param _params[] = { 798 {0, 5, "invalid number of feature args"}, 799 {1, 50, "pg_init_retries must be between 1 and 50"}, 800 {0, 60000, "pg_init_delay_msecs must be between 0 and 60000"}, 801 }; 802 803 r = read_param(_params, shift(as), &argc, &ti->error); 804 if (r) 805 return -EINVAL; 806 807 if (!argc) 808 return 0; 809 810 do { 811 param_name = shift(as); 812 argc--; 813 814 if (!strnicmp(param_name, MESG_STR("queue_if_no_path"))) { 815 r = queue_if_no_path(m, 1, 0); 816 continue; 817 } 818 819 if (!strnicmp(param_name, MESG_STR("pg_init_retries")) && 820 (argc >= 1)) { 821 r = read_param(_params + 1, shift(as), 822 &m->pg_init_retries, &ti->error); 823 argc--; 824 continue; 825 } 826 827 if (!strnicmp(param_name, MESG_STR("pg_init_delay_msecs")) && 828 (argc >= 1)) { 829 r = read_param(_params + 2, shift(as), 830 &m->pg_init_delay_msecs, &ti->error); 831 argc--; 832 continue; 833 } 834 835 ti->error = "Unrecognised multipath feature request"; 836 r = -EINVAL; 837 } while (argc && !r); 838 839 return r; 840 } 841 842 static int multipath_ctr(struct dm_target *ti, unsigned int argc, 843 char **argv) 844 { 845 /* target parameters */ 846 static struct param _params[] = { 847 {0, 1024, "invalid number of priority groups"}, 848 {0, 1024, "invalid initial priority group number"}, 849 }; 850 851 int r; 852 struct multipath *m; 853 struct arg_set as; 854 unsigned pg_count = 0; 855 unsigned next_pg_num; 856 857 as.argc = argc; 858 as.argv = argv; 859 860 m = alloc_multipath(ti); 861 if (!m) { 862 ti->error = "can't allocate multipath"; 863 return -EINVAL; 864 } 865 866 r = parse_features(&as, m); 867 if (r) 868 goto bad; 869 870 r = parse_hw_handler(&as, m); 871 if (r) 872 goto bad; 873 874 r = read_param(_params, shift(&as), &m->nr_priority_groups, &ti->error); 875 if (r) 876 goto bad; 877 878 r = read_param(_params + 1, shift(&as), &next_pg_num, &ti->error); 879 if (r) 880 goto bad; 881 882 if ((!m->nr_priority_groups && next_pg_num) || 883 (m->nr_priority_groups && !next_pg_num)) { 884 ti->error = "invalid initial priority group"; 885 r = -EINVAL; 886 goto bad; 887 } 888 889 /* parse the priority groups */ 890 while (as.argc) { 891 struct priority_group *pg; 892 893 pg = parse_priority_group(&as, m); 894 if (IS_ERR(pg)) { 895 r = PTR_ERR(pg); 896 goto bad; 897 } 898 899 m->nr_valid_paths += pg->nr_pgpaths; 900 list_add_tail(&pg->list, &m->priority_groups); 901 pg_count++; 902 pg->pg_num = pg_count; 903 if (!--next_pg_num) 904 m->next_pg = pg; 905 } 906 907 if (pg_count != m->nr_priority_groups) { 908 ti->error = "priority group count mismatch"; 909 r = -EINVAL; 910 goto bad; 911 } 912 913 ti->num_flush_requests = 1; 914 ti->num_discard_requests = 1; 915 916 return 0; 917 918 bad: 919 free_multipath(m); 920 return r; 921 } 922 923 static void multipath_wait_for_pg_init_completion(struct multipath *m) 924 { 925 DECLARE_WAITQUEUE(wait, current); 926 unsigned long flags; 927 928 add_wait_queue(&m->pg_init_wait, &wait); 929 930 while (1) { 931 set_current_state(TASK_UNINTERRUPTIBLE); 932 933 spin_lock_irqsave(&m->lock, flags); 934 if (!m->pg_init_in_progress) { 935 spin_unlock_irqrestore(&m->lock, flags); 936 break; 937 } 938 spin_unlock_irqrestore(&m->lock, flags); 939 940 io_schedule(); 941 } 942 set_current_state(TASK_RUNNING); 943 944 remove_wait_queue(&m->pg_init_wait, &wait); 945 } 946 947 static void flush_multipath_work(struct multipath *m) 948 { 949 flush_workqueue(kmpath_handlerd); 950 multipath_wait_for_pg_init_completion(m); 951 flush_workqueue(kmultipathd); 952 flush_work_sync(&m->trigger_event); 953 } 954 955 static void multipath_dtr(struct dm_target *ti) 956 { 957 struct multipath *m = ti->private; 958 959 flush_multipath_work(m); 960 free_multipath(m); 961 } 962 963 /* 964 * Map cloned requests 965 */ 966 static int multipath_map(struct dm_target *ti, struct request *clone, 967 union map_info *map_context) 968 { 969 int r; 970 struct dm_mpath_io *mpio; 971 struct multipath *m = (struct multipath *) ti->private; 972 973 mpio = mempool_alloc(m->mpio_pool, GFP_ATOMIC); 974 if (!mpio) 975 /* ENOMEM, requeue */ 976 return DM_MAPIO_REQUEUE; 977 memset(mpio, 0, sizeof(*mpio)); 978 979 map_context->ptr = mpio; 980 clone->cmd_flags |= REQ_FAILFAST_TRANSPORT; 981 r = map_io(m, clone, mpio, 0); 982 if (r < 0 || r == DM_MAPIO_REQUEUE) 983 mempool_free(mpio, m->mpio_pool); 984 985 return r; 986 } 987 988 /* 989 * Take a path out of use. 990 */ 991 static int fail_path(struct pgpath *pgpath) 992 { 993 unsigned long flags; 994 struct multipath *m = pgpath->pg->m; 995 996 spin_lock_irqsave(&m->lock, flags); 997 998 if (!pgpath->is_active) 999 goto out; 1000 1001 DMWARN("Failing path %s.", pgpath->path.dev->name); 1002 1003 pgpath->pg->ps.type->fail_path(&pgpath->pg->ps, &pgpath->path); 1004 pgpath->is_active = 0; 1005 pgpath->fail_count++; 1006 1007 m->nr_valid_paths--; 1008 1009 if (pgpath == m->current_pgpath) 1010 m->current_pgpath = NULL; 1011 1012 dm_path_uevent(DM_UEVENT_PATH_FAILED, m->ti, 1013 pgpath->path.dev->name, m->nr_valid_paths); 1014 1015 schedule_work(&m->trigger_event); 1016 1017 out: 1018 spin_unlock_irqrestore(&m->lock, flags); 1019 1020 return 0; 1021 } 1022 1023 /* 1024 * Reinstate a previously-failed path 1025 */ 1026 static int reinstate_path(struct pgpath *pgpath) 1027 { 1028 int r = 0; 1029 unsigned long flags; 1030 struct multipath *m = pgpath->pg->m; 1031 1032 spin_lock_irqsave(&m->lock, flags); 1033 1034 if (pgpath->is_active) 1035 goto out; 1036 1037 if (!pgpath->pg->ps.type->reinstate_path) { 1038 DMWARN("Reinstate path not supported by path selector %s", 1039 pgpath->pg->ps.type->name); 1040 r = -EINVAL; 1041 goto out; 1042 } 1043 1044 r = pgpath->pg->ps.type->reinstate_path(&pgpath->pg->ps, &pgpath->path); 1045 if (r) 1046 goto out; 1047 1048 pgpath->is_active = 1; 1049 1050 if (!m->nr_valid_paths++ && m->queue_size) { 1051 m->current_pgpath = NULL; 1052 queue_work(kmultipathd, &m->process_queued_ios); 1053 } else if (m->hw_handler_name && (m->current_pg == pgpath->pg)) { 1054 if (queue_work(kmpath_handlerd, &pgpath->activate_path.work)) 1055 m->pg_init_in_progress++; 1056 } 1057 1058 dm_path_uevent(DM_UEVENT_PATH_REINSTATED, m->ti, 1059 pgpath->path.dev->name, m->nr_valid_paths); 1060 1061 schedule_work(&m->trigger_event); 1062 1063 out: 1064 spin_unlock_irqrestore(&m->lock, flags); 1065 1066 return r; 1067 } 1068 1069 /* 1070 * Fail or reinstate all paths that match the provided struct dm_dev. 1071 */ 1072 static int action_dev(struct multipath *m, struct dm_dev *dev, 1073 action_fn action) 1074 { 1075 int r = -EINVAL; 1076 struct pgpath *pgpath; 1077 struct priority_group *pg; 1078 1079 list_for_each_entry(pg, &m->priority_groups, list) { 1080 list_for_each_entry(pgpath, &pg->pgpaths, list) { 1081 if (pgpath->path.dev == dev) 1082 r = action(pgpath); 1083 } 1084 } 1085 1086 return r; 1087 } 1088 1089 /* 1090 * Temporarily try to avoid having to use the specified PG 1091 */ 1092 static void bypass_pg(struct multipath *m, struct priority_group *pg, 1093 int bypassed) 1094 { 1095 unsigned long flags; 1096 1097 spin_lock_irqsave(&m->lock, flags); 1098 1099 pg->bypassed = bypassed; 1100 m->current_pgpath = NULL; 1101 m->current_pg = NULL; 1102 1103 spin_unlock_irqrestore(&m->lock, flags); 1104 1105 schedule_work(&m->trigger_event); 1106 } 1107 1108 /* 1109 * Switch to using the specified PG from the next I/O that gets mapped 1110 */ 1111 static int switch_pg_num(struct multipath *m, const char *pgstr) 1112 { 1113 struct priority_group *pg; 1114 unsigned pgnum; 1115 unsigned long flags; 1116 1117 if (!pgstr || (sscanf(pgstr, "%u", &pgnum) != 1) || !pgnum || 1118 (pgnum > m->nr_priority_groups)) { 1119 DMWARN("invalid PG number supplied to switch_pg_num"); 1120 return -EINVAL; 1121 } 1122 1123 spin_lock_irqsave(&m->lock, flags); 1124 list_for_each_entry(pg, &m->priority_groups, list) { 1125 pg->bypassed = 0; 1126 if (--pgnum) 1127 continue; 1128 1129 m->current_pgpath = NULL; 1130 m->current_pg = NULL; 1131 m->next_pg = pg; 1132 } 1133 spin_unlock_irqrestore(&m->lock, flags); 1134 1135 schedule_work(&m->trigger_event); 1136 return 0; 1137 } 1138 1139 /* 1140 * Set/clear bypassed status of a PG. 1141 * PGs are numbered upwards from 1 in the order they were declared. 1142 */ 1143 static int bypass_pg_num(struct multipath *m, const char *pgstr, int bypassed) 1144 { 1145 struct priority_group *pg; 1146 unsigned pgnum; 1147 1148 if (!pgstr || (sscanf(pgstr, "%u", &pgnum) != 1) || !pgnum || 1149 (pgnum > m->nr_priority_groups)) { 1150 DMWARN("invalid PG number supplied to bypass_pg"); 1151 return -EINVAL; 1152 } 1153 1154 list_for_each_entry(pg, &m->priority_groups, list) { 1155 if (!--pgnum) 1156 break; 1157 } 1158 1159 bypass_pg(m, pg, bypassed); 1160 return 0; 1161 } 1162 1163 /* 1164 * Should we retry pg_init immediately? 1165 */ 1166 static int pg_init_limit_reached(struct multipath *m, struct pgpath *pgpath) 1167 { 1168 unsigned long flags; 1169 int limit_reached = 0; 1170 1171 spin_lock_irqsave(&m->lock, flags); 1172 1173 if (m->pg_init_count <= m->pg_init_retries) 1174 m->pg_init_required = 1; 1175 else 1176 limit_reached = 1; 1177 1178 spin_unlock_irqrestore(&m->lock, flags); 1179 1180 return limit_reached; 1181 } 1182 1183 static void pg_init_done(void *data, int errors) 1184 { 1185 struct pgpath *pgpath = data; 1186 struct priority_group *pg = pgpath->pg; 1187 struct multipath *m = pg->m; 1188 unsigned long flags; 1189 unsigned delay_retry = 0; 1190 1191 /* device or driver problems */ 1192 switch (errors) { 1193 case SCSI_DH_OK: 1194 break; 1195 case SCSI_DH_NOSYS: 1196 if (!m->hw_handler_name) { 1197 errors = 0; 1198 break; 1199 } 1200 DMERR("Could not failover the device: Handler scsi_dh_%s " 1201 "Error %d.", m->hw_handler_name, errors); 1202 /* 1203 * Fail path for now, so we do not ping pong 1204 */ 1205 fail_path(pgpath); 1206 break; 1207 case SCSI_DH_DEV_TEMP_BUSY: 1208 /* 1209 * Probably doing something like FW upgrade on the 1210 * controller so try the other pg. 1211 */ 1212 bypass_pg(m, pg, 1); 1213 break; 1214 case SCSI_DH_RETRY: 1215 /* Wait before retrying. */ 1216 delay_retry = 1; 1217 case SCSI_DH_IMM_RETRY: 1218 case SCSI_DH_RES_TEMP_UNAVAIL: 1219 if (pg_init_limit_reached(m, pgpath)) 1220 fail_path(pgpath); 1221 errors = 0; 1222 break; 1223 default: 1224 /* 1225 * We probably do not want to fail the path for a device 1226 * error, but this is what the old dm did. In future 1227 * patches we can do more advanced handling. 1228 */ 1229 fail_path(pgpath); 1230 } 1231 1232 spin_lock_irqsave(&m->lock, flags); 1233 if (errors) { 1234 if (pgpath == m->current_pgpath) { 1235 DMERR("Could not failover device. Error %d.", errors); 1236 m->current_pgpath = NULL; 1237 m->current_pg = NULL; 1238 } 1239 } else if (!m->pg_init_required) 1240 pg->bypassed = 0; 1241 1242 if (--m->pg_init_in_progress) 1243 /* Activations of other paths are still on going */ 1244 goto out; 1245 1246 if (!m->pg_init_required) 1247 m->queue_io = 0; 1248 1249 m->pg_init_delay_retry = delay_retry; 1250 queue_work(kmultipathd, &m->process_queued_ios); 1251 1252 /* 1253 * Wake up any thread waiting to suspend. 1254 */ 1255 wake_up(&m->pg_init_wait); 1256 1257 out: 1258 spin_unlock_irqrestore(&m->lock, flags); 1259 } 1260 1261 static void activate_path(struct work_struct *work) 1262 { 1263 struct pgpath *pgpath = 1264 container_of(work, struct pgpath, activate_path.work); 1265 1266 scsi_dh_activate(bdev_get_queue(pgpath->path.dev->bdev), 1267 pg_init_done, pgpath); 1268 } 1269 1270 /* 1271 * end_io handling 1272 */ 1273 static int do_end_io(struct multipath *m, struct request *clone, 1274 int error, struct dm_mpath_io *mpio) 1275 { 1276 /* 1277 * We don't queue any clone request inside the multipath target 1278 * during end I/O handling, since those clone requests don't have 1279 * bio clones. If we queue them inside the multipath target, 1280 * we need to make bio clones, that requires memory allocation. 1281 * (See drivers/md/dm.c:end_clone_bio() about why the clone requests 1282 * don't have bio clones.) 1283 * Instead of queueing the clone request here, we queue the original 1284 * request into dm core, which will remake a clone request and 1285 * clone bios for it and resubmit it later. 1286 */ 1287 int r = DM_ENDIO_REQUEUE; 1288 unsigned long flags; 1289 1290 if (!error && !clone->errors) 1291 return 0; /* I/O complete */ 1292 1293 if (error == -EOPNOTSUPP || error == -EREMOTEIO || error == -EILSEQ) 1294 return error; 1295 1296 if (mpio->pgpath) 1297 fail_path(mpio->pgpath); 1298 1299 spin_lock_irqsave(&m->lock, flags); 1300 if (!m->nr_valid_paths) { 1301 if (!m->queue_if_no_path) { 1302 if (!__must_push_back(m)) 1303 r = -EIO; 1304 } else { 1305 if (error == -EBADE) 1306 r = error; 1307 } 1308 } 1309 spin_unlock_irqrestore(&m->lock, flags); 1310 1311 return r; 1312 } 1313 1314 static int multipath_end_io(struct dm_target *ti, struct request *clone, 1315 int error, union map_info *map_context) 1316 { 1317 struct multipath *m = ti->private; 1318 struct dm_mpath_io *mpio = map_context->ptr; 1319 struct pgpath *pgpath = mpio->pgpath; 1320 struct path_selector *ps; 1321 int r; 1322 1323 r = do_end_io(m, clone, error, mpio); 1324 if (pgpath) { 1325 ps = &pgpath->pg->ps; 1326 if (ps->type->end_io) 1327 ps->type->end_io(ps, &pgpath->path, mpio->nr_bytes); 1328 } 1329 mempool_free(mpio, m->mpio_pool); 1330 1331 return r; 1332 } 1333 1334 /* 1335 * Suspend can't complete until all the I/O is processed so if 1336 * the last path fails we must error any remaining I/O. 1337 * Note that if the freeze_bdev fails while suspending, the 1338 * queue_if_no_path state is lost - userspace should reset it. 1339 */ 1340 static void multipath_presuspend(struct dm_target *ti) 1341 { 1342 struct multipath *m = (struct multipath *) ti->private; 1343 1344 queue_if_no_path(m, 0, 1); 1345 } 1346 1347 static void multipath_postsuspend(struct dm_target *ti) 1348 { 1349 struct multipath *m = ti->private; 1350 1351 mutex_lock(&m->work_mutex); 1352 flush_multipath_work(m); 1353 mutex_unlock(&m->work_mutex); 1354 } 1355 1356 /* 1357 * Restore the queue_if_no_path setting. 1358 */ 1359 static void multipath_resume(struct dm_target *ti) 1360 { 1361 struct multipath *m = (struct multipath *) ti->private; 1362 unsigned long flags; 1363 1364 spin_lock_irqsave(&m->lock, flags); 1365 m->queue_if_no_path = m->saved_queue_if_no_path; 1366 spin_unlock_irqrestore(&m->lock, flags); 1367 } 1368 1369 /* 1370 * Info output has the following format: 1371 * num_multipath_feature_args [multipath_feature_args]* 1372 * num_handler_status_args [handler_status_args]* 1373 * num_groups init_group_number 1374 * [A|D|E num_ps_status_args [ps_status_args]* 1375 * num_paths num_selector_args 1376 * [path_dev A|F fail_count [selector_args]* ]+ ]+ 1377 * 1378 * Table output has the following format (identical to the constructor string): 1379 * num_feature_args [features_args]* 1380 * num_handler_args hw_handler [hw_handler_args]* 1381 * num_groups init_group_number 1382 * [priority selector-name num_ps_args [ps_args]* 1383 * num_paths num_selector_args [path_dev [selector_args]* ]+ ]+ 1384 */ 1385 static int multipath_status(struct dm_target *ti, status_type_t type, 1386 char *result, unsigned int maxlen) 1387 { 1388 int sz = 0; 1389 unsigned long flags; 1390 struct multipath *m = (struct multipath *) ti->private; 1391 struct priority_group *pg; 1392 struct pgpath *p; 1393 unsigned pg_num; 1394 char state; 1395 1396 spin_lock_irqsave(&m->lock, flags); 1397 1398 /* Features */ 1399 if (type == STATUSTYPE_INFO) 1400 DMEMIT("2 %u %u ", m->queue_size, m->pg_init_count); 1401 else { 1402 DMEMIT("%u ", m->queue_if_no_path + 1403 (m->pg_init_retries > 0) * 2 + 1404 (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT) * 2); 1405 if (m->queue_if_no_path) 1406 DMEMIT("queue_if_no_path "); 1407 if (m->pg_init_retries) 1408 DMEMIT("pg_init_retries %u ", m->pg_init_retries); 1409 if (m->pg_init_delay_msecs != DM_PG_INIT_DELAY_DEFAULT) 1410 DMEMIT("pg_init_delay_msecs %u ", m->pg_init_delay_msecs); 1411 } 1412 1413 if (!m->hw_handler_name || type == STATUSTYPE_INFO) 1414 DMEMIT("0 "); 1415 else 1416 DMEMIT("1 %s ", m->hw_handler_name); 1417 1418 DMEMIT("%u ", m->nr_priority_groups); 1419 1420 if (m->next_pg) 1421 pg_num = m->next_pg->pg_num; 1422 else if (m->current_pg) 1423 pg_num = m->current_pg->pg_num; 1424 else 1425 pg_num = (m->nr_priority_groups ? 1 : 0); 1426 1427 DMEMIT("%u ", pg_num); 1428 1429 switch (type) { 1430 case STATUSTYPE_INFO: 1431 list_for_each_entry(pg, &m->priority_groups, list) { 1432 if (pg->bypassed) 1433 state = 'D'; /* Disabled */ 1434 else if (pg == m->current_pg) 1435 state = 'A'; /* Currently Active */ 1436 else 1437 state = 'E'; /* Enabled */ 1438 1439 DMEMIT("%c ", state); 1440 1441 if (pg->ps.type->status) 1442 sz += pg->ps.type->status(&pg->ps, NULL, type, 1443 result + sz, 1444 maxlen - sz); 1445 else 1446 DMEMIT("0 "); 1447 1448 DMEMIT("%u %u ", pg->nr_pgpaths, 1449 pg->ps.type->info_args); 1450 1451 list_for_each_entry(p, &pg->pgpaths, list) { 1452 DMEMIT("%s %s %u ", p->path.dev->name, 1453 p->is_active ? "A" : "F", 1454 p->fail_count); 1455 if (pg->ps.type->status) 1456 sz += pg->ps.type->status(&pg->ps, 1457 &p->path, type, result + sz, 1458 maxlen - sz); 1459 } 1460 } 1461 break; 1462 1463 case STATUSTYPE_TABLE: 1464 list_for_each_entry(pg, &m->priority_groups, list) { 1465 DMEMIT("%s ", pg->ps.type->name); 1466 1467 if (pg->ps.type->status) 1468 sz += pg->ps.type->status(&pg->ps, NULL, type, 1469 result + sz, 1470 maxlen - sz); 1471 else 1472 DMEMIT("0 "); 1473 1474 DMEMIT("%u %u ", pg->nr_pgpaths, 1475 pg->ps.type->table_args); 1476 1477 list_for_each_entry(p, &pg->pgpaths, list) { 1478 DMEMIT("%s ", p->path.dev->name); 1479 if (pg->ps.type->status) 1480 sz += pg->ps.type->status(&pg->ps, 1481 &p->path, type, result + sz, 1482 maxlen - sz); 1483 } 1484 } 1485 break; 1486 } 1487 1488 spin_unlock_irqrestore(&m->lock, flags); 1489 1490 return 0; 1491 } 1492 1493 static int multipath_message(struct dm_target *ti, unsigned argc, char **argv) 1494 { 1495 int r = -EINVAL; 1496 struct dm_dev *dev; 1497 struct multipath *m = (struct multipath *) ti->private; 1498 action_fn action; 1499 1500 mutex_lock(&m->work_mutex); 1501 1502 if (dm_suspended(ti)) { 1503 r = -EBUSY; 1504 goto out; 1505 } 1506 1507 if (argc == 1) { 1508 if (!strnicmp(argv[0], MESG_STR("queue_if_no_path"))) { 1509 r = queue_if_no_path(m, 1, 0); 1510 goto out; 1511 } else if (!strnicmp(argv[0], MESG_STR("fail_if_no_path"))) { 1512 r = queue_if_no_path(m, 0, 0); 1513 goto out; 1514 } 1515 } 1516 1517 if (argc != 2) { 1518 DMWARN("Unrecognised multipath message received."); 1519 goto out; 1520 } 1521 1522 if (!strnicmp(argv[0], MESG_STR("disable_group"))) { 1523 r = bypass_pg_num(m, argv[1], 1); 1524 goto out; 1525 } else if (!strnicmp(argv[0], MESG_STR("enable_group"))) { 1526 r = bypass_pg_num(m, argv[1], 0); 1527 goto out; 1528 } else if (!strnicmp(argv[0], MESG_STR("switch_group"))) { 1529 r = switch_pg_num(m, argv[1]); 1530 goto out; 1531 } else if (!strnicmp(argv[0], MESG_STR("reinstate_path"))) 1532 action = reinstate_path; 1533 else if (!strnicmp(argv[0], MESG_STR("fail_path"))) 1534 action = fail_path; 1535 else { 1536 DMWARN("Unrecognised multipath message received."); 1537 goto out; 1538 } 1539 1540 r = dm_get_device(ti, argv[1], dm_table_get_mode(ti->table), &dev); 1541 if (r) { 1542 DMWARN("message: error getting device %s", 1543 argv[1]); 1544 goto out; 1545 } 1546 1547 r = action_dev(m, dev, action); 1548 1549 dm_put_device(ti, dev); 1550 1551 out: 1552 mutex_unlock(&m->work_mutex); 1553 return r; 1554 } 1555 1556 static int multipath_ioctl(struct dm_target *ti, unsigned int cmd, 1557 unsigned long arg) 1558 { 1559 struct multipath *m = (struct multipath *) ti->private; 1560 struct block_device *bdev = NULL; 1561 fmode_t mode = 0; 1562 unsigned long flags; 1563 int r = 0; 1564 1565 spin_lock_irqsave(&m->lock, flags); 1566 1567 if (!m->current_pgpath) 1568 __choose_pgpath(m, 0); 1569 1570 if (m->current_pgpath) { 1571 bdev = m->current_pgpath->path.dev->bdev; 1572 mode = m->current_pgpath->path.dev->mode; 1573 } 1574 1575 if (m->queue_io) 1576 r = -EAGAIN; 1577 else if (!bdev) 1578 r = -EIO; 1579 1580 spin_unlock_irqrestore(&m->lock, flags); 1581 1582 return r ? : __blkdev_driver_ioctl(bdev, mode, cmd, arg); 1583 } 1584 1585 static int multipath_iterate_devices(struct dm_target *ti, 1586 iterate_devices_callout_fn fn, void *data) 1587 { 1588 struct multipath *m = ti->private; 1589 struct priority_group *pg; 1590 struct pgpath *p; 1591 int ret = 0; 1592 1593 list_for_each_entry(pg, &m->priority_groups, list) { 1594 list_for_each_entry(p, &pg->pgpaths, list) { 1595 ret = fn(ti, p->path.dev, ti->begin, ti->len, data); 1596 if (ret) 1597 goto out; 1598 } 1599 } 1600 1601 out: 1602 return ret; 1603 } 1604 1605 static int __pgpath_busy(struct pgpath *pgpath) 1606 { 1607 struct request_queue *q = bdev_get_queue(pgpath->path.dev->bdev); 1608 1609 return dm_underlying_device_busy(q); 1610 } 1611 1612 /* 1613 * We return "busy", only when we can map I/Os but underlying devices 1614 * are busy (so even if we map I/Os now, the I/Os will wait on 1615 * the underlying queue). 1616 * In other words, if we want to kill I/Os or queue them inside us 1617 * due to map unavailability, we don't return "busy". Otherwise, 1618 * dm core won't give us the I/Os and we can't do what we want. 1619 */ 1620 static int multipath_busy(struct dm_target *ti) 1621 { 1622 int busy = 0, has_active = 0; 1623 struct multipath *m = ti->private; 1624 struct priority_group *pg; 1625 struct pgpath *pgpath; 1626 unsigned long flags; 1627 1628 spin_lock_irqsave(&m->lock, flags); 1629 1630 /* Guess which priority_group will be used at next mapping time */ 1631 if (unlikely(!m->current_pgpath && m->next_pg)) 1632 pg = m->next_pg; 1633 else if (likely(m->current_pg)) 1634 pg = m->current_pg; 1635 else 1636 /* 1637 * We don't know which pg will be used at next mapping time. 1638 * We don't call __choose_pgpath() here to avoid to trigger 1639 * pg_init just by busy checking. 1640 * So we don't know whether underlying devices we will be using 1641 * at next mapping time are busy or not. Just try mapping. 1642 */ 1643 goto out; 1644 1645 /* 1646 * If there is one non-busy active path at least, the path selector 1647 * will be able to select it. So we consider such a pg as not busy. 1648 */ 1649 busy = 1; 1650 list_for_each_entry(pgpath, &pg->pgpaths, list) 1651 if (pgpath->is_active) { 1652 has_active = 1; 1653 1654 if (!__pgpath_busy(pgpath)) { 1655 busy = 0; 1656 break; 1657 } 1658 } 1659 1660 if (!has_active) 1661 /* 1662 * No active path in this pg, so this pg won't be used and 1663 * the current_pg will be changed at next mapping time. 1664 * We need to try mapping to determine it. 1665 */ 1666 busy = 0; 1667 1668 out: 1669 spin_unlock_irqrestore(&m->lock, flags); 1670 1671 return busy; 1672 } 1673 1674 /*----------------------------------------------------------------- 1675 * Module setup 1676 *---------------------------------------------------------------*/ 1677 static struct target_type multipath_target = { 1678 .name = "multipath", 1679 .version = {1, 3, 0}, 1680 .module = THIS_MODULE, 1681 .ctr = multipath_ctr, 1682 .dtr = multipath_dtr, 1683 .map_rq = multipath_map, 1684 .rq_end_io = multipath_end_io, 1685 .presuspend = multipath_presuspend, 1686 .postsuspend = multipath_postsuspend, 1687 .resume = multipath_resume, 1688 .status = multipath_status, 1689 .message = multipath_message, 1690 .ioctl = multipath_ioctl, 1691 .iterate_devices = multipath_iterate_devices, 1692 .busy = multipath_busy, 1693 }; 1694 1695 static int __init dm_multipath_init(void) 1696 { 1697 int r; 1698 1699 /* allocate a slab for the dm_ios */ 1700 _mpio_cache = KMEM_CACHE(dm_mpath_io, 0); 1701 if (!_mpio_cache) 1702 return -ENOMEM; 1703 1704 r = dm_register_target(&multipath_target); 1705 if (r < 0) { 1706 DMERR("register failed %d", r); 1707 kmem_cache_destroy(_mpio_cache); 1708 return -EINVAL; 1709 } 1710 1711 kmultipathd = alloc_workqueue("kmpathd", WQ_MEM_RECLAIM, 0); 1712 if (!kmultipathd) { 1713 DMERR("failed to create workqueue kmpathd"); 1714 dm_unregister_target(&multipath_target); 1715 kmem_cache_destroy(_mpio_cache); 1716 return -ENOMEM; 1717 } 1718 1719 /* 1720 * A separate workqueue is used to handle the device handlers 1721 * to avoid overloading existing workqueue. Overloading the 1722 * old workqueue would also create a bottleneck in the 1723 * path of the storage hardware device activation. 1724 */ 1725 kmpath_handlerd = alloc_ordered_workqueue("kmpath_handlerd", 1726 WQ_MEM_RECLAIM); 1727 if (!kmpath_handlerd) { 1728 DMERR("failed to create workqueue kmpath_handlerd"); 1729 destroy_workqueue(kmultipathd); 1730 dm_unregister_target(&multipath_target); 1731 kmem_cache_destroy(_mpio_cache); 1732 return -ENOMEM; 1733 } 1734 1735 DMINFO("version %u.%u.%u loaded", 1736 multipath_target.version[0], multipath_target.version[1], 1737 multipath_target.version[2]); 1738 1739 return r; 1740 } 1741 1742 static void __exit dm_multipath_exit(void) 1743 { 1744 destroy_workqueue(kmpath_handlerd); 1745 destroy_workqueue(kmultipathd); 1746 1747 dm_unregister_target(&multipath_target); 1748 kmem_cache_destroy(_mpio_cache); 1749 } 1750 1751 module_init(dm_multipath_init); 1752 module_exit(dm_multipath_exit); 1753 1754 MODULE_DESCRIPTION(DM_NAME " multipath target"); 1755 MODULE_AUTHOR("Sistina Software <dm-devel@redhat.com>"); 1756 MODULE_LICENSE("GPL"); 1757