linux/drivers/scsi/hosts.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 *  hosts.c Copyright (C) 1992 Drew Eckhardt
   4 *          Copyright (C) 1993, 1994, 1995 Eric Youngdale
   5 *          Copyright (C) 2002-2003 Christoph Hellwig
   6 *
   7 *  mid to lowlevel SCSI driver interface
   8 *      Initial versions: Drew Eckhardt
   9 *      Subsequent revisions: Eric Youngdale
  10 *
  11 *  <drew@colorado.edu>
  12 *
  13 *  Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
  14 *  Added QLOGIC QLA1280 SCSI controller kernel host support. 
  15 *     August 4, 1999 Fred Lewis, Intel DuPont
  16 *
  17 *  Updated to reflect the new initialization scheme for the higher 
  18 *  level of scsi drivers (sd/sr/st)
  19 *  September 17, 2000 Torben Mathiasen <tmm@image.dk>
  20 *
  21 *  Restructured scsi_host lists and associated functions.
  22 *  September 04, 2002 Mike Anderson (andmike@us.ibm.com)
  23 */
  24
  25#include <linux/module.h>
  26#include <linux/blkdev.h>
  27#include <linux/kernel.h>
  28#include <linux/slab.h>
  29#include <linux/kthread.h>
  30#include <linux/string.h>
  31#include <linux/mm.h>
  32#include <linux/init.h>
  33#include <linux/completion.h>
  34#include <linux/transport_class.h>
  35#include <linux/platform_device.h>
  36#include <linux/pm_runtime.h>
  37#include <linux/idr.h>
  38#include <scsi/scsi_device.h>
  39#include <scsi/scsi_host.h>
  40#include <scsi/scsi_transport.h>
  41#include <scsi/scsi_cmnd.h>
  42
  43#include "scsi_priv.h"
  44#include "scsi_logging.h"
  45
  46
  47static int shost_eh_deadline = -1;
  48
  49module_param_named(eh_deadline, shost_eh_deadline, int, S_IRUGO|S_IWUSR);
  50MODULE_PARM_DESC(eh_deadline,
  51                 "SCSI EH timeout in seconds (should be between 0 and 2^31-1)");
  52
  53static DEFINE_IDA(host_index_ida);
  54
  55
  56static void scsi_host_cls_release(struct device *dev)
  57{
  58        put_device(&class_to_shost(dev)->shost_gendev);
  59}
  60
  61static struct class shost_class = {
  62        .name           = "scsi_host",
  63        .dev_release    = scsi_host_cls_release,
  64};
  65
  66/**
  67 *      scsi_host_set_state - Take the given host through the host state model.
  68 *      @shost: scsi host to change the state of.
  69 *      @state: state to change to.
  70 *
  71 *      Returns zero if unsuccessful or an error if the requested
  72 *      transition is illegal.
  73 **/
  74int scsi_host_set_state(struct Scsi_Host *shost, enum scsi_host_state state)
  75{
  76        enum scsi_host_state oldstate = shost->shost_state;
  77
  78        if (state == oldstate)
  79                return 0;
  80
  81        switch (state) {
  82        case SHOST_CREATED:
  83                /* There are no legal states that come back to
  84                 * created.  This is the manually initialised start
  85                 * state */
  86                goto illegal;
  87
  88        case SHOST_RUNNING:
  89                switch (oldstate) {
  90                case SHOST_CREATED:
  91                case SHOST_RECOVERY:
  92                        break;
  93                default:
  94                        goto illegal;
  95                }
  96                break;
  97
  98        case SHOST_RECOVERY:
  99                switch (oldstate) {
 100                case SHOST_RUNNING:
 101                        break;
 102                default:
 103                        goto illegal;
 104                }
 105                break;
 106
 107        case SHOST_CANCEL:
 108                switch (oldstate) {
 109                case SHOST_CREATED:
 110                case SHOST_RUNNING:
 111                case SHOST_CANCEL_RECOVERY:
 112                        break;
 113                default:
 114                        goto illegal;
 115                }
 116                break;
 117
 118        case SHOST_DEL:
 119                switch (oldstate) {
 120                case SHOST_CANCEL:
 121                case SHOST_DEL_RECOVERY:
 122                        break;
 123                default:
 124                        goto illegal;
 125                }
 126                break;
 127
 128        case SHOST_CANCEL_RECOVERY:
 129                switch (oldstate) {
 130                case SHOST_CANCEL:
 131                case SHOST_RECOVERY:
 132                        break;
 133                default:
 134                        goto illegal;
 135                }
 136                break;
 137
 138        case SHOST_DEL_RECOVERY:
 139                switch (oldstate) {
 140                case SHOST_CANCEL_RECOVERY:
 141                        break;
 142                default:
 143                        goto illegal;
 144                }
 145                break;
 146        }
 147        shost->shost_state = state;
 148        return 0;
 149
 150 illegal:
 151        SCSI_LOG_ERROR_RECOVERY(1,
 152                                shost_printk(KERN_ERR, shost,
 153                                             "Illegal host state transition"
 154                                             "%s->%s\n",
 155                                             scsi_host_state_name(oldstate),
 156                                             scsi_host_state_name(state)));
 157        return -EINVAL;
 158}
 159
 160/**
 161 * scsi_remove_host - remove a scsi host
 162 * @shost:      a pointer to a scsi host to remove
 163 **/
 164void scsi_remove_host(struct Scsi_Host *shost)
 165{
 166        unsigned long flags;
 167
 168        mutex_lock(&shost->scan_mutex);
 169        spin_lock_irqsave(shost->host_lock, flags);
 170        if (scsi_host_set_state(shost, SHOST_CANCEL))
 171                if (scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY)) {
 172                        spin_unlock_irqrestore(shost->host_lock, flags);
 173                        mutex_unlock(&shost->scan_mutex);
 174                        return;
 175                }
 176        spin_unlock_irqrestore(shost->host_lock, flags);
 177
 178        scsi_autopm_get_host(shost);
 179        flush_workqueue(shost->tmf_work_q);
 180        scsi_forget_host(shost);
 181        mutex_unlock(&shost->scan_mutex);
 182        scsi_proc_host_rm(shost);
 183
 184        spin_lock_irqsave(shost->host_lock, flags);
 185        if (scsi_host_set_state(shost, SHOST_DEL))
 186                BUG_ON(scsi_host_set_state(shost, SHOST_DEL_RECOVERY));
 187        spin_unlock_irqrestore(shost->host_lock, flags);
 188
 189        transport_unregister_device(&shost->shost_gendev);
 190        device_unregister(&shost->shost_dev);
 191        device_del(&shost->shost_gendev);
 192}
 193EXPORT_SYMBOL(scsi_remove_host);
 194
 195/**
 196 * scsi_add_host_with_dma - add a scsi host with dma device
 197 * @shost:      scsi host pointer to add
 198 * @dev:        a struct device of type scsi class
 199 * @dma_dev:    dma device for the host
 200 *
 201 * Note: You rarely need to worry about this unless you're in a
 202 * virtualised host environments, so use the simpler scsi_add_host()
 203 * function instead.
 204 *
 205 * Return value: 
 206 *      0 on success / != 0 for error
 207 **/
 208int scsi_add_host_with_dma(struct Scsi_Host *shost, struct device *dev,
 209                           struct device *dma_dev)
 210{
 211        struct scsi_host_template *sht = shost->hostt;
 212        int error = -EINVAL;
 213
 214        shost_printk(KERN_INFO, shost, "%s\n",
 215                        sht->info ? sht->info(shost) : sht->name);
 216
 217        if (!shost->can_queue) {
 218                shost_printk(KERN_ERR, shost,
 219                             "can_queue = 0 no longer supported\n");
 220                goto fail;
 221        }
 222
 223        shost->cmd_per_lun = min_t(short, shost->cmd_per_lun,
 224                                   shost->can_queue);
 225
 226        error = scsi_init_sense_cache(shost);
 227        if (error)
 228                goto fail;
 229
 230        error = scsi_mq_setup_tags(shost);
 231        if (error)
 232                goto fail;
 233
 234        if (!shost->shost_gendev.parent)
 235                shost->shost_gendev.parent = dev ? dev : &platform_bus;
 236        if (!dma_dev)
 237                dma_dev = shost->shost_gendev.parent;
 238
 239        shost->dma_dev = dma_dev;
 240
 241        /*
 242         * Increase usage count temporarily here so that calling
 243         * scsi_autopm_put_host() will trigger runtime idle if there is
 244         * nothing else preventing suspending the device.
 245         */
 246        pm_runtime_get_noresume(&shost->shost_gendev);
 247        pm_runtime_set_active(&shost->shost_gendev);
 248        pm_runtime_enable(&shost->shost_gendev);
 249        device_enable_async_suspend(&shost->shost_gendev);
 250
 251        error = device_add(&shost->shost_gendev);
 252        if (error)
 253                goto out_disable_runtime_pm;
 254
 255        scsi_host_set_state(shost, SHOST_RUNNING);
 256        get_device(shost->shost_gendev.parent);
 257
 258        device_enable_async_suspend(&shost->shost_dev);
 259
 260        get_device(&shost->shost_gendev);
 261        error = device_add(&shost->shost_dev);
 262        if (error)
 263                goto out_del_gendev;
 264
 265        if (shost->transportt->host_size) {
 266                shost->shost_data = kzalloc(shost->transportt->host_size,
 267                                         GFP_KERNEL);
 268                if (shost->shost_data == NULL) {
 269                        error = -ENOMEM;
 270                        goto out_del_dev;
 271                }
 272        }
 273
 274        if (shost->transportt->create_work_queue) {
 275                snprintf(shost->work_q_name, sizeof(shost->work_q_name),
 276                         "scsi_wq_%d", shost->host_no);
 277                shost->work_q = alloc_workqueue("%s",
 278                        WQ_SYSFS | __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_UNBOUND,
 279                        1, shost->work_q_name);
 280
 281                if (!shost->work_q) {
 282                        error = -EINVAL;
 283                        goto out_del_dev;
 284                }
 285        }
 286
 287        error = scsi_sysfs_add_host(shost);
 288        if (error)
 289                goto out_del_dev;
 290
 291        scsi_proc_host_add(shost);
 292        scsi_autopm_put_host(shost);
 293        return error;
 294
 295        /*
 296         * Any host allocation in this function will be freed in
 297         * scsi_host_dev_release().
 298         */
 299 out_del_dev:
 300        device_del(&shost->shost_dev);
 301 out_del_gendev:
 302        /*
 303         * Host state is SHOST_RUNNING so we have to explicitly release
 304         * ->shost_dev.
 305         */
 306        put_device(&shost->shost_dev);
 307        device_del(&shost->shost_gendev);
 308 out_disable_runtime_pm:
 309        device_disable_async_suspend(&shost->shost_gendev);
 310        pm_runtime_disable(&shost->shost_gendev);
 311        pm_runtime_set_suspended(&shost->shost_gendev);
 312        pm_runtime_put_noidle(&shost->shost_gendev);
 313 fail:
 314        return error;
 315}
 316EXPORT_SYMBOL(scsi_add_host_with_dma);
 317
 318static void scsi_host_dev_release(struct device *dev)
 319{
 320        struct Scsi_Host *shost = dev_to_shost(dev);
 321        struct device *parent = dev->parent;
 322
 323        scsi_proc_hostdir_rm(shost->hostt);
 324
 325        /* Wait for functions invoked through call_rcu(&shost->rcu, ...) */
 326        rcu_barrier();
 327
 328        if (shost->tmf_work_q)
 329                destroy_workqueue(shost->tmf_work_q);
 330        if (shost->ehandler)
 331                kthread_stop(shost->ehandler);
 332        if (shost->work_q)
 333                destroy_workqueue(shost->work_q);
 334
 335        if (shost->shost_state == SHOST_CREATED) {
 336                /*
 337                 * Free the shost_dev device name here if scsi_host_alloc()
 338                 * and scsi_host_put() have been called but neither
 339                 * scsi_host_add() nor scsi_host_remove() has been called.
 340                 * This avoids that the memory allocated for the shost_dev
 341                 * name is leaked.
 342                 */
 343                kfree(dev_name(&shost->shost_dev));
 344        }
 345
 346        if (shost->tag_set.tags)
 347                scsi_mq_destroy_tags(shost);
 348
 349        kfree(shost->shost_data);
 350
 351        ida_simple_remove(&host_index_ida, shost->host_no);
 352
 353        if (shost->shost_state != SHOST_CREATED)
 354                put_device(parent);
 355        kfree(shost);
 356}
 357
 358static struct device_type scsi_host_type = {
 359        .name =         "scsi_host",
 360        .release =      scsi_host_dev_release,
 361};
 362
 363/**
 364 * scsi_host_alloc - register a scsi host adapter instance.
 365 * @sht:        pointer to scsi host template
 366 * @privsize:   extra bytes to allocate for driver
 367 *
 368 * Note:
 369 *      Allocate a new Scsi_Host and perform basic initialization.
 370 *      The host is not published to the scsi midlayer until scsi_add_host
 371 *      is called.
 372 *
 373 * Return value:
 374 *      Pointer to a new Scsi_Host
 375 **/
 376struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
 377{
 378        struct Scsi_Host *shost;
 379        int index;
 380
 381        shost = kzalloc(sizeof(struct Scsi_Host) + privsize, GFP_KERNEL);
 382        if (!shost)
 383                return NULL;
 384
 385        shost->host_lock = &shost->default_lock;
 386        spin_lock_init(shost->host_lock);
 387        shost->shost_state = SHOST_CREATED;
 388        INIT_LIST_HEAD(&shost->__devices);
 389        INIT_LIST_HEAD(&shost->__targets);
 390        INIT_LIST_HEAD(&shost->eh_cmd_q);
 391        INIT_LIST_HEAD(&shost->starved_list);
 392        init_waitqueue_head(&shost->host_wait);
 393        mutex_init(&shost->scan_mutex);
 394
 395        index = ida_simple_get(&host_index_ida, 0, 0, GFP_KERNEL);
 396        if (index < 0) {
 397                kfree(shost);
 398                return NULL;
 399        }
 400        shost->host_no = index;
 401
 402        shost->dma_channel = 0xff;
 403
 404        /* These three are default values which can be overridden */
 405        shost->max_channel = 0;
 406        shost->max_id = 8;
 407        shost->max_lun = 8;
 408
 409        /* Give each shost a default transportt */
 410        shost->transportt = &blank_transport_template;
 411
 412        /*
 413         * All drivers right now should be able to handle 12 byte
 414         * commands.  Every so often there are requests for 16 byte
 415         * commands, but individual low-level drivers need to certify that
 416         * they actually do something sensible with such commands.
 417         */
 418        shost->max_cmd_len = 12;
 419        shost->hostt = sht;
 420        shost->this_id = sht->this_id;
 421        shost->can_queue = sht->can_queue;
 422        shost->sg_tablesize = sht->sg_tablesize;
 423        shost->sg_prot_tablesize = sht->sg_prot_tablesize;
 424        shost->cmd_per_lun = sht->cmd_per_lun;
 425        shost->no_write_same = sht->no_write_same;
 426        shost->host_tagset = sht->host_tagset;
 427
 428        if (shost_eh_deadline == -1 || !sht->eh_host_reset_handler)
 429                shost->eh_deadline = -1;
 430        else if ((ulong) shost_eh_deadline * HZ > INT_MAX) {
 431                shost_printk(KERN_WARNING, shost,
 432                             "eh_deadline %u too large, setting to %u\n",
 433                             shost_eh_deadline, INT_MAX / HZ);
 434                shost->eh_deadline = INT_MAX;
 435        } else
 436                shost->eh_deadline = shost_eh_deadline * HZ;
 437
 438        if (sht->supported_mode == MODE_UNKNOWN)
 439                /* means we didn't set it ... default to INITIATOR */
 440                shost->active_mode = MODE_INITIATOR;
 441        else
 442                shost->active_mode = sht->supported_mode;
 443
 444        if (sht->max_host_blocked)
 445                shost->max_host_blocked = sht->max_host_blocked;
 446        else
 447                shost->max_host_blocked = SCSI_DEFAULT_HOST_BLOCKED;
 448
 449        /*
 450         * If the driver imposes no hard sector transfer limit, start at
 451         * machine infinity initially.
 452         */
 453        if (sht->max_sectors)
 454                shost->max_sectors = sht->max_sectors;
 455        else
 456                shost->max_sectors = SCSI_DEFAULT_MAX_SECTORS;
 457
 458        if (sht->max_segment_size)
 459                shost->max_segment_size = sht->max_segment_size;
 460        else
 461                shost->max_segment_size = BLK_MAX_SEGMENT_SIZE;
 462
 463        /*
 464         * assume a 4GB boundary, if not set
 465         */
 466        if (sht->dma_boundary)
 467                shost->dma_boundary = sht->dma_boundary;
 468        else
 469                shost->dma_boundary = 0xffffffff;
 470
 471        if (sht->virt_boundary_mask)
 472                shost->virt_boundary_mask = sht->virt_boundary_mask;
 473
 474        device_initialize(&shost->shost_gendev);
 475        dev_set_name(&shost->shost_gendev, "host%d", shost->host_no);
 476        shost->shost_gendev.bus = &scsi_bus_type;
 477        shost->shost_gendev.type = &scsi_host_type;
 478
 479        device_initialize(&shost->shost_dev);
 480        shost->shost_dev.parent = &shost->shost_gendev;
 481        shost->shost_dev.class = &shost_class;
 482        dev_set_name(&shost->shost_dev, "host%d", shost->host_no);
 483        shost->shost_dev.groups = scsi_sysfs_shost_attr_groups;
 484
 485        shost->ehandler = kthread_run(scsi_error_handler, shost,
 486                        "scsi_eh_%d", shost->host_no);
 487        if (IS_ERR(shost->ehandler)) {
 488                shost_printk(KERN_WARNING, shost,
 489                        "error handler thread failed to spawn, error = %ld\n",
 490                        PTR_ERR(shost->ehandler));
 491                shost->ehandler = NULL;
 492                goto fail;
 493        }
 494
 495        shost->tmf_work_q = alloc_workqueue("scsi_tmf_%d",
 496                                        WQ_UNBOUND | WQ_MEM_RECLAIM | WQ_SYSFS,
 497                                           1, shost->host_no);
 498        if (!shost->tmf_work_q) {
 499                shost_printk(KERN_WARNING, shost,
 500                             "failed to create tmf workq\n");
 501                goto fail;
 502        }
 503        scsi_proc_hostdir_add(shost->hostt);
 504        return shost;
 505 fail:
 506        /*
 507         * Host state is still SHOST_CREATED and that is enough to release
 508         * ->shost_gendev. scsi_host_dev_release() will free
 509         * dev_name(&shost->shost_dev).
 510         */
 511        put_device(&shost->shost_gendev);
 512
 513        return NULL;
 514}
 515EXPORT_SYMBOL(scsi_host_alloc);
 516
 517static int __scsi_host_match(struct device *dev, const void *data)
 518{
 519        struct Scsi_Host *p;
 520        const unsigned short *hostnum = data;
 521
 522        p = class_to_shost(dev);
 523        return p->host_no == *hostnum;
 524}
 525
 526/**
 527 * scsi_host_lookup - get a reference to a Scsi_Host by host no
 528 * @hostnum:    host number to locate
 529 *
 530 * Return value:
 531 *      A pointer to located Scsi_Host or NULL.
 532 *
 533 *      The caller must do a scsi_host_put() to drop the reference
 534 *      that scsi_host_get() took. The put_device() below dropped
 535 *      the reference from class_find_device().
 536 **/
 537struct Scsi_Host *scsi_host_lookup(unsigned short hostnum)
 538{
 539        struct device *cdev;
 540        struct Scsi_Host *shost = NULL;
 541
 542        cdev = class_find_device(&shost_class, NULL, &hostnum,
 543                                 __scsi_host_match);
 544        if (cdev) {
 545                shost = scsi_host_get(class_to_shost(cdev));
 546                put_device(cdev);
 547        }
 548        return shost;
 549}
 550EXPORT_SYMBOL(scsi_host_lookup);
 551
 552/**
 553 * scsi_host_get - inc a Scsi_Host ref count
 554 * @shost:      Pointer to Scsi_Host to inc.
 555 **/
 556struct Scsi_Host *scsi_host_get(struct Scsi_Host *shost)
 557{
 558        if ((shost->shost_state == SHOST_DEL) ||
 559                !get_device(&shost->shost_gendev))
 560                return NULL;
 561        return shost;
 562}
 563EXPORT_SYMBOL(scsi_host_get);
 564
 565static bool scsi_host_check_in_flight(struct request *rq, void *data,
 566                                      bool reserved)
 567{
 568        int *count = data;
 569        struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
 570
 571        if (test_bit(SCMD_STATE_INFLIGHT, &cmd->state))
 572                (*count)++;
 573
 574        return true;
 575}
 576
 577/**
 578 * scsi_host_busy - Return the host busy counter
 579 * @shost:      Pointer to Scsi_Host to inc.
 580 **/
 581int scsi_host_busy(struct Scsi_Host *shost)
 582{
 583        int cnt = 0;
 584
 585        blk_mq_tagset_busy_iter(&shost->tag_set,
 586                                scsi_host_check_in_flight, &cnt);
 587        return cnt;
 588}
 589EXPORT_SYMBOL(scsi_host_busy);
 590
 591/**
 592 * scsi_host_put - dec a Scsi_Host ref count
 593 * @shost:      Pointer to Scsi_Host to dec.
 594 **/
 595void scsi_host_put(struct Scsi_Host *shost)
 596{
 597        put_device(&shost->shost_gendev);
 598}
 599EXPORT_SYMBOL(scsi_host_put);
 600
 601int scsi_init_hosts(void)
 602{
 603        return class_register(&shost_class);
 604}
 605
 606void scsi_exit_hosts(void)
 607{
 608        class_unregister(&shost_class);
 609        ida_destroy(&host_index_ida);
 610}
 611
 612int scsi_is_host_device(const struct device *dev)
 613{
 614        return dev->type == &scsi_host_type;
 615}
 616EXPORT_SYMBOL(scsi_is_host_device);
 617
 618/**
 619 * scsi_queue_work - Queue work to the Scsi_Host workqueue.
 620 * @shost:      Pointer to Scsi_Host.
 621 * @work:       Work to queue for execution.
 622 *
 623 * Return value:
 624 *      1 - work queued for execution
 625 *      0 - work is already queued
 626 *      -EINVAL - work queue doesn't exist
 627 **/
 628int scsi_queue_work(struct Scsi_Host *shost, struct work_struct *work)
 629{
 630        if (unlikely(!shost->work_q)) {
 631                shost_printk(KERN_ERR, shost,
 632                        "ERROR: Scsi host '%s' attempted to queue scsi-work, "
 633                        "when no workqueue created.\n", shost->hostt->name);
 634                dump_stack();
 635
 636                return -EINVAL;
 637        }
 638
 639        return queue_work(shost->work_q, work);
 640}
 641EXPORT_SYMBOL_GPL(scsi_queue_work);
 642
 643/**
 644 * scsi_flush_work - Flush a Scsi_Host's workqueue.
 645 * @shost:      Pointer to Scsi_Host.
 646 **/
 647void scsi_flush_work(struct Scsi_Host *shost)
 648{
 649        if (!shost->work_q) {
 650                shost_printk(KERN_ERR, shost,
 651                        "ERROR: Scsi host '%s' attempted to flush scsi-work, "
 652                        "when no workqueue created.\n", shost->hostt->name);
 653                dump_stack();
 654                return;
 655        }
 656
 657        flush_workqueue(shost->work_q);
 658}
 659EXPORT_SYMBOL_GPL(scsi_flush_work);
 660
 661static bool complete_all_cmds_iter(struct request *rq, void *data, bool rsvd)
 662{
 663        struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq);
 664        int status = *(int *)data;
 665
 666        scsi_dma_unmap(scmd);
 667        scmd->result = status << 16;
 668        scmd->scsi_done(scmd);
 669        return true;
 670}
 671
 672/**
 673 * scsi_host_complete_all_commands - Terminate all running commands
 674 * @shost:      Scsi Host on which commands should be terminated
 675 * @status:     Status to be set for the terminated commands
 676 *
 677 * There is no protection against modification of the number
 678 * of outstanding commands. It is the responsibility of the
 679 * caller to ensure that concurrent I/O submission and/or
 680 * completion is stopped when calling this function.
 681 */
 682void scsi_host_complete_all_commands(struct Scsi_Host *shost, int status)
 683{
 684        blk_mq_tagset_busy_iter(&shost->tag_set, complete_all_cmds_iter,
 685                                &status);
 686}
 687EXPORT_SYMBOL_GPL(scsi_host_complete_all_commands);
 688
 689struct scsi_host_busy_iter_data {
 690        bool (*fn)(struct scsi_cmnd *, void *, bool);
 691        void *priv;
 692};
 693
 694static bool __scsi_host_busy_iter_fn(struct request *req, void *priv,
 695                                   bool reserved)
 696{
 697        struct scsi_host_busy_iter_data *iter_data = priv;
 698        struct scsi_cmnd *sc = blk_mq_rq_to_pdu(req);
 699
 700        return iter_data->fn(sc, iter_data->priv, reserved);
 701}
 702
 703/**
 704 * scsi_host_busy_iter - Iterate over all busy commands
 705 * @shost:      Pointer to Scsi_Host.
 706 * @fn:         Function to call on each busy command
 707 * @priv:       Data pointer passed to @fn
 708 *
 709 * If locking against concurrent command completions is required
 710 * ithas to be provided by the caller
 711 **/
 712void scsi_host_busy_iter(struct Scsi_Host *shost,
 713                         bool (*fn)(struct scsi_cmnd *, void *, bool),
 714                         void *priv)
 715{
 716        struct scsi_host_busy_iter_data iter_data = {
 717                .fn = fn,
 718                .priv = priv,
 719        };
 720
 721        blk_mq_tagset_busy_iter(&shost->tag_set, __scsi_host_busy_iter_fn,
 722                                &iter_data);
 723}
 724EXPORT_SYMBOL_GPL(scsi_host_busy_iter);
 725