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