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