drivers/scsi/scsi.c

   1 /*
   2  *  scsi.c Copyright (C) 1992 Drew Eckhardt
   3  *         Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
   4  *         Copyright (C) 2002, 2003 Christoph Hellwig
   5  *
   6  *  generic mid-level SCSI driver
   7  *      Initial versions: Drew Eckhardt
   8  *      Subsequent revisions: Eric Youngdale
   9  *
  10  *  <drew@colorado.edu>
  11  *
  12  *  Bug correction thanks go to :
  13  *      Rik Faith <faith@cs.unc.edu>
  14  *      Tommy Thorn <tthorn>
  15  *      Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de>
  16  *
  17  *  Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to
  18  *  add scatter-gather, multiple outstanding request, and other
  19  *  enhancements.
  20  *
  21  *  Native multichannel, wide scsi, /proc/scsi and hot plugging
  22  *  support added by Michael Neuffer <mike@i-connect.net>
  23  *
  24  *  Added request_module("scsi_hostadapter") for kerneld:
  25  *  (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf)
  26  *  Bjorn Ekwall  <bj0rn@blox.se>
  27  *  (changed to kmod)
  28  *
  29  *  Major improvements to the timeout, abort, and reset processing,
  30  *  as well as performance modifications for large queue depths by
  31  *  Leonard N. Zubkoff <lnz@dandelion.com>
  32  *
  33  *  Converted cli() code to spinlocks, Ingo Molnar
  34  *
  35  *  Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
  36  *
  37  *  out_of_space hacks, D. Gilbert (dpg) 990608
  38  */
  39
  40 #include <linux/module.h>
  41 #include <linux/moduleparam.h>
  42 #include <linux/kernel.h>
  43 #include <linux/timer.h>
  44 #include <linux/string.h>
  45 #include <linux/slab.h>
  46 #include <linux/blkdev.h>
  47 #include <linux/delay.h>
  48 #include <linux/init.h>
  49 #include <linux/completion.h>
  50 #include <linux/unistd.h>
  51 #include <linux/spinlock.h>
  52 #include <linux/kmod.h>
  53 #include <linux/interrupt.h>
  54 #include <linux/notifier.h>
  55 #include <linux/cpu.h>
  56 #include <linux/mutex.h>
  57 #include <linux/async.h>
  58 #include <asm/unaligned.h>
  59
  60 #include <scsi/scsi.h>
  61 #include <scsi/scsi_cmnd.h>
  62 #include <scsi/scsi_dbg.h>
  63 #include <scsi/scsi_device.h>
  64 #include <scsi/scsi_driver.h>
  65 #include <scsi/scsi_eh.h>
  66 #include <scsi/scsi_host.h>
  67 #include <scsi/scsi_tcq.h>
  68
  69 #include "scsi_priv.h"
  70 #include "scsi_logging.h"
  71
  72 #define CREATE_TRACE_POINTS
  73 #include <trace/events/scsi.h>
  74
  75 /*
  76  * Definitions and constants.
  77  */
  78
  79 /*
  80  * Note - the initial logging level can be set here to log events at boot time.
  81  * After the system is up, you may enable logging via the /proc interface.
  82  */
  83 unsigned int scsi_logging_level;
  84 #if defined(CONFIG_SCSI_LOGGING)
  85 EXPORT_SYMBOL(scsi_logging_level);
  86 #endif
  87
  88 /* sd, scsi core and power management need to coordinate flushing async actions */
  89 ASYNC_DOMAIN(scsi_sd_probe_domain);
  90 EXPORT_SYMBOL(scsi_sd_probe_domain);
  91
  92 /*
  93  * Separate domain (from scsi_sd_probe_domain) to maximize the benefit of
  94  * asynchronous system resume operations.  It is marked 'exclusive' to avoid
  95  * being included in the async_synchronize_full() that is invoked by
  96  * dpm_resume()
  97  */
  98 ASYNC_DOMAIN_EXCLUSIVE(scsi_sd_pm_domain);
  99 EXPORT_SYMBOL(scsi_sd_pm_domain);
 100
 101 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
 102  * You may not alter any existing entry (although adding new ones is
 103  * encouraged once assigned by ANSI/INCITS T10
 104  */
 105 static const char *const scsi_device_types[] = {
 106         "Direct-Access    ",
 107         "Sequential-Access",
 108         "Printer          ",
 109         "Processor        ",
 110         "WORM             ",
 111         "CD-ROM           ",
 112         "Scanner          ",
 113         "Optical Device   ",
 114         "Medium Changer   ",
 115         "Communications   ",
 116         "ASC IT8          ",
 117         "ASC IT8          ",
 118         "RAID             ",
 119         "Enclosure        ",
 120         "Direct-Access-RBC",
 121         "Optical card     ",
 122         "Bridge controller",
 123         "Object storage   ",
 124         "Automation/Drive ",
 125         "Security Manager ",
 126         "Direct-Access-ZBC",
 127 };
 128
 129 /**
 130  * scsi_device_type - Return 17 char string indicating device type.
 131  * @type: type number to look up
 132  */
 133
 134 const char * scsi_device_type(unsigned type)
 135 {
 136         if (type == 0x1e)
 137                 return "Well-known LUN   ";
 138         if (type == 0x1f)
 139                 return "No Device        ";
 140         if (type >= ARRAY_SIZE(scsi_device_types))
 141                 return "Unknown          ";
 142         return scsi_device_types[type];
 143 }
 144
 145 EXPORT_SYMBOL(scsi_device_type);
 146
 147 struct scsi_host_cmd_pool {
 148         struct kmem_cache       *cmd_slab;
 149         struct kmem_cache       *sense_slab;
 150         unsigned int            users;
 151         char                    *cmd_name;
 152         char                    *sense_name;
 153         unsigned int            slab_flags;
 154         gfp_t                   gfp_mask;
 155 };
 156
 157 static struct scsi_host_cmd_pool scsi_cmd_pool = {
 158         .cmd_name       = "scsi_cmd_cache",
 159         .sense_name     = "scsi_sense_cache",
 160         .slab_flags     = SLAB_HWCACHE_ALIGN,
 161 };
 162
 163 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
 164         .cmd_name       = "scsi_cmd_cache(DMA)",
 165         .sense_name     = "scsi_sense_cache(DMA)",
 166         .slab_flags     = SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
 167         .gfp_mask       = __GFP_DMA,
 168 };
 169
 170 static DEFINE_MUTEX(host_cmd_pool_mutex);
 171
 172 /**
 173  * scsi_host_free_command - internal function to release a command
 174  * @shost:      host to free the command for
 175  * @cmd:        command to release
 176  *
 177  * the command must previously have been allocated by
 178  * scsi_host_alloc_command.
 179  */
 180 static void
 181 scsi_host_free_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
 182 {
 183         struct scsi_host_cmd_pool *pool = shost->cmd_pool;
 184
 185         if (cmd->prot_sdb)
 186                 kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb);
 187         kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
 188         kmem_cache_free(pool->cmd_slab, cmd);
 189 }
 190
 191 /**
 192  * scsi_host_alloc_command - internal function to allocate command
 193  * @shost:      SCSI host whose pool to allocate from
 194  * @gfp_mask:   mask for the allocation
 195  *
 196  * Returns a fully allocated command with sense buffer and protection
 197  * data buffer (where applicable) or NULL on failure
 198  */
 199 static struct scsi_cmnd *
 200 scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 201 {
 202         struct scsi_host_cmd_pool *pool = shost->cmd_pool;
 203         struct scsi_cmnd *cmd;
 204
 205         cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask);
 206         if (!cmd)
 207                 goto fail;
 208
 209         cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab,
 210                                              gfp_mask | pool->gfp_mask);
 211         if (!cmd->sense_buffer)
 212                 goto fail_free_cmd;
 213
 214         if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
 215                 cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask);
 216                 if (!cmd->prot_sdb)
 217                         goto fail_free_sense;
 218         }
 219
 220         return cmd;
 221
 222 fail_free_sense:
 223         kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
 224 fail_free_cmd:
 225         kmem_cache_free(pool->cmd_slab, cmd);
 226 fail:
 227         return NULL;
 228 }
 229
 230 /**
 231  * __scsi_get_command - Allocate a struct scsi_cmnd
 232  * @shost: host to transmit command
 233  * @gfp_mask: allocation mask
 234  *
 235  * Description: allocate a struct scsi_cmd from host's slab, recycling from the
 236  *              host's free_list if necessary.
 237  */
 238 static struct scsi_cmnd *
 239 __scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 240 {
 241         struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask);
 242
 243         if (unlikely(!cmd)) {
 244                 unsigned long flags;
 245
 246                 spin_lock_irqsave(&shost->free_list_lock, flags);
 247                 if (likely(!list_empty(&shost->free_list))) {
 248                         cmd = list_entry(shost->free_list.next,
 249                                          struct scsi_cmnd, list);
 250                         list_del_init(&cmd->list);
 251                 }
 252                 spin_unlock_irqrestore(&shost->free_list_lock, flags);
 253
 254                 if (cmd) {
 255                         void *buf, *prot;
 256
 257                         buf = cmd->sense_buffer;
 258                         prot = cmd->prot_sdb;
 259
 260                         memset(cmd, 0, sizeof(*cmd));
 261
 262                         cmd->sense_buffer = buf;
 263                         cmd->prot_sdb = prot;
 264                 }
 265         }
 266
 267         return cmd;
 268 }
 269
 270 /**
 271  * scsi_get_command - Allocate and setup a scsi command block
 272  * @dev: parent scsi device
 273  * @gfp_mask: allocator flags
 274  *
 275  * Returns:     The allocated scsi command structure.
 276  */
 277 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
 278 {
 279         struct scsi_cmnd *cmd = __scsi_get_command(dev->host, gfp_mask);
 280         unsigned long flags;
 281
 282         if (unlikely(cmd == NULL))
 283                 return NULL;
 284
 285         cmd->device = dev;
 286         INIT_LIST_HEAD(&cmd->list);
 287         INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler);
 288         spin_lock_irqsave(&dev->list_lock, flags);
 289         list_add_tail(&cmd->list, &dev->cmd_list);
 290         spin_unlock_irqrestore(&dev->list_lock, flags);
 291         cmd->jiffies_at_alloc = jiffies;
 292         return cmd;
 293 }
 294
 295 /**
 296  * __scsi_put_command - Free a struct scsi_cmnd
 297  * @shost: dev->host
 298  * @cmd: Command to free
 299  */
 300 static void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
 301 {
 302         unsigned long flags;
 303
 304         if (unlikely(list_empty(&shost->free_list))) {
 305                 spin_lock_irqsave(&shost->free_list_lock, flags);
 306                 if (list_empty(&shost->free_list)) {
 307                         list_add(&cmd->list, &shost->free_list);
 308                         cmd = NULL;
 309                 }
 310                 spin_unlock_irqrestore(&shost->free_list_lock, flags);
 311         }
 312
 313         if (likely(cmd != NULL))
 314                 scsi_host_free_command(shost, cmd);
 315 }
 316
 317 /**
 318  * scsi_put_command - Free a scsi command block
 319  * @cmd: command block to free
 320  *
 321  * Returns:     Nothing.
 322  *
 323  * Notes:       The command must not belong to any lists.
 324  */
 325 void scsi_put_command(struct scsi_cmnd *cmd)
 326 {
 327         unsigned long flags;
 328
 329         /* serious error if the command hasn't come from a device list */
 330         spin_lock_irqsave(&cmd->device->list_lock, flags);
 331         BUG_ON(list_empty(&cmd->list));
 332         list_del_init(&cmd->list);
 333         spin_unlock_irqrestore(&cmd->device->list_lock, flags);
 334
 335         BUG_ON(delayed_work_pending(&cmd->abort_work));
 336
 337         __scsi_put_command(cmd->device->host, cmd);
 338 }
 339
 340 static struct scsi_host_cmd_pool *
 341 scsi_find_host_cmd_pool(struct Scsi_Host *shost)
 342 {
 343         if (shost->hostt->cmd_size)
 344                 return shost->hostt->cmd_pool;
 345         if (shost->unchecked_isa_dma)
 346                 return &scsi_cmd_dma_pool;
 347         return &scsi_cmd_pool;
 348 }
 349
 350 static void
 351 scsi_free_host_cmd_pool(struct scsi_host_cmd_pool *pool)
 352 {
 353         kfree(pool->sense_name);
 354         kfree(pool->cmd_name);
 355         kfree(pool);
 356 }
 357
 358 static struct scsi_host_cmd_pool *
 359 scsi_alloc_host_cmd_pool(struct Scsi_Host *shost)
 360 {
 361         struct scsi_host_template *hostt = shost->hostt;
 362         struct scsi_host_cmd_pool *pool;
 363
 364         pool = kzalloc(sizeof(*pool), GFP_KERNEL);
 365         if (!pool)
 366                 return NULL;
 367
 368         pool->cmd_name = kasprintf(GFP_KERNEL, "%s_cmd", hostt->proc_name);
 369         pool->sense_name = kasprintf(GFP_KERNEL, "%s_sense", hostt->proc_name);
 370         if (!pool->cmd_name || !pool->sense_name) {
 371                 scsi_free_host_cmd_pool(pool);
 372                 return NULL;
 373         }
 374
 375         pool->slab_flags = SLAB_HWCACHE_ALIGN;
 376         if (shost->unchecked_isa_dma) {
 377                 pool->slab_flags |= SLAB_CACHE_DMA;
 378                 pool->gfp_mask = __GFP_DMA;
 379         }
 380
 381         if (hostt->cmd_size)
 382                 hostt->cmd_pool = pool;
 383
 384         return pool;
 385 }
 386
 387 static struct scsi_host_cmd_pool *
 388 scsi_get_host_cmd_pool(struct Scsi_Host *shost)
 389 {
 390         struct scsi_host_template *hostt = shost->hostt;
 391         struct scsi_host_cmd_pool *retval = NULL, *pool;
 392         size_t cmd_size = sizeof(struct scsi_cmnd) + hostt->cmd_size;
 393
 394         /*
 395          * Select a command slab for this host and create it if not
 396          * yet existent.
 397          */
 398         mutex_lock(&host_cmd_pool_mutex);
 399         pool = scsi_find_host_cmd_pool(shost);
 400         if (!pool) {
 401                 pool = scsi_alloc_host_cmd_pool(shost);
 402                 if (!pool)
 403                         goto out;
 404         }
 405
 406         if (!pool->users) {
 407                 pool->cmd_slab = kmem_cache_create(pool->cmd_name, cmd_size, 0,
 408                                                    pool->slab_flags, NULL);
 409                 if (!pool->cmd_slab)
 410                         goto out_free_pool;
 411
 412                 pool->sense_slab = kmem_cache_create(pool->sense_name,
 413                                                      SCSI_SENSE_BUFFERSIZE, 0,
 414                                                      pool->slab_flags, NULL);
 415                 if (!pool->sense_slab)
 416                         goto out_free_slab;
 417         }
 418
 419         pool->users++;
 420         retval = pool;
 421 out:
 422         mutex_unlock(&host_cmd_pool_mutex);
 423         return retval;
 424
 425 out_free_slab:
 426         kmem_cache_destroy(pool->cmd_slab);
 427 out_free_pool:
 428         if (hostt->cmd_size) {
 429                 scsi_free_host_cmd_pool(pool);
 430                 hostt->cmd_pool = NULL;
 431         }
 432         goto out;
 433 }
 434
 435 static void scsi_put_host_cmd_pool(struct Scsi_Host *shost)
 436 {
 437         struct scsi_host_template *hostt = shost->hostt;
 438         struct scsi_host_cmd_pool *pool;
 439
 440         mutex_lock(&host_cmd_pool_mutex);
 441         pool = scsi_find_host_cmd_pool(shost);
 442
 443         /*
 444          * This may happen if a driver has a mismatched get and put
 445          * of the command pool; the driver should be implicated in
 446          * the stack trace
 447          */
 448         BUG_ON(pool->users == 0);
 449
 450         if (!--pool->users) {
 451                 kmem_cache_destroy(pool->cmd_slab);
 452                 kmem_cache_destroy(pool->sense_slab);
 453                 if (hostt->cmd_size) {
 454                         scsi_free_host_cmd_pool(pool);
 455                         hostt->cmd_pool = NULL;
 456                 }
 457         }
 458         mutex_unlock(&host_cmd_pool_mutex);
 459 }
 460
 461 /**
 462  * scsi_setup_command_freelist - Setup the command freelist for a scsi host.
 463  * @shost: host to allocate the freelist for.
 464  *
 465  * Description: The command freelist protects against system-wide out of memory
 466  * deadlock by preallocating one SCSI command structure for each host, so the
 467  * system can always write to a swap file on a device associated with that host.
 468  *
 469  * Returns:     Nothing.
 470  */
 471 int scsi_setup_command_freelist(struct Scsi_Host *shost)
 472 {
 473         const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL;
 474         struct scsi_cmnd *cmd;
 475
 476         spin_lock_init(&shost->free_list_lock);
 477         INIT_LIST_HEAD(&shost->free_list);
 478
 479         shost->cmd_pool = scsi_get_host_cmd_pool(shost);
 480         if (!shost->cmd_pool)
 481                 return -ENOMEM;
 482
 483         /*
 484          * Get one backup command for this host.
 485          */
 486         cmd = scsi_host_alloc_command(shost, gfp_mask);
 487         if (!cmd) {
 488                 scsi_put_host_cmd_pool(shost);
 489                 shost->cmd_pool = NULL;
 490                 return -ENOMEM;
 491         }
 492         list_add(&cmd->list, &shost->free_list);
 493         return 0;
 494 }
 495
 496 /**
 497  * scsi_destroy_command_freelist - Release the command freelist for a scsi host.
 498  * @shost: host whose freelist is going to be destroyed
 499  */
 500 void scsi_destroy_command_freelist(struct Scsi_Host *shost)
 501 {
 502         /*
 503          * If cmd_pool is NULL the free list was not initialized, so
 504          * do not attempt to release resources.
 505          */
 506         if (!shost->cmd_pool)
 507                 return;
 508
 509         while (!list_empty(&shost->free_list)) {
 510                 struct scsi_cmnd *cmd;
 511
 512                 cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
 513                 list_del_init(&cmd->list);
 514                 scsi_host_free_command(shost, cmd);
 515         }
 516         shost->cmd_pool = NULL;
 517         scsi_put_host_cmd_pool(shost);
 518 }
 519
 520 #ifdef CONFIG_SCSI_LOGGING
 521 void scsi_log_send(struct scsi_cmnd *cmd)
 522 {
 523         unsigned int level;
 524
 525         /*
 526          * If ML QUEUE log level is greater than or equal to:
 527          *
 528          * 1: nothing (match completion)
 529          *
 530          * 2: log opcode + command of all commands + cmd address
 531          *
 532          * 3: same as 2
 533          *
 534          * 4: same as 3 plus dump extra junk
 535          */
 536         if (unlikely(scsi_logging_level)) {
 537                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
 538                                        SCSI_LOG_MLQUEUE_BITS);
 539                 if (level > 1) {
 540                         scmd_printk(KERN_INFO, cmd,
 541                                     "Send: scmd 0x%p\n", cmd);
 542                         scsi_print_command(cmd);
 543                         if (level > 3) {
 544                                 printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
 545                                        " queuecommand 0x%p\n",
 546                                         scsi_sglist(cmd), scsi_bufflen(cmd),
 547                                         cmd->device->host->hostt->queuecommand);
 548
 549                         }
 550                 }
 551         }
 552 }
 553
 554 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
 555 {
 556         unsigned int level;
 557
 558         /*
 559          * If ML COMPLETE log level is greater than or equal to:
 560          *
 561          * 1: log disposition, result, opcode + command, and conditionally
 562          * sense data for failures or non SUCCESS dispositions.
 563          *
 564          * 2: same as 1 but for all command completions.
 565          *
 566          * 3: same as 2
 567          *
 568          * 4: same as 3 plus dump extra junk
 569          */
 570         if (unlikely(scsi_logging_level)) {
 571                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
 572                                        SCSI_LOG_MLCOMPLETE_BITS);
 573                 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
 574                     (level > 1)) {
 575                         scsi_print_result(cmd, "Done: ", disposition);
 576                         scsi_print_command(cmd);
 577                         if (status_byte(cmd->result) & CHECK_CONDITION)
 578                                 scsi_print_sense(cmd);
 579                         if (level > 3)
 580                                 scmd_printk(KERN_INFO, cmd,
 581                                             "scsi host busy %d failed %d\n",
 582                                             atomic_read(&cmd->device->host->host_busy),
 583                                             cmd->device->host->host_failed);
 584                 }
 585         }
 586 }
 587 #endif
 588
 589 /**
 590  * scsi_cmd_get_serial - Assign a serial number to a command
 591  * @host: the scsi host
 592  * @cmd: command to assign serial number to
 593  *
 594  * Description: a serial number identifies a request for error recovery
 595  * and debugging purposes.  Protected by the Host_Lock of host.
 596  */
 597 void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 598 {
 599         cmd->serial_number = host->cmd_serial_number++;
 600         if (cmd->serial_number == 0)
 601                 cmd->serial_number = host->cmd_serial_number++;
 602 }
 603 EXPORT_SYMBOL(scsi_cmd_get_serial);
 604
 605 /**
 606  * scsi_dispatch_command - Dispatch a command to the low-level driver.
 607  * @cmd: command block we are dispatching.
 608  *
 609  * Return: nonzero return request was rejected and device's queue needs to be
 610  * plugged.
 611  */
 612 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
 613 {
 614         struct Scsi_Host *host = cmd->device->host;
 615         int rtn = 0;
 616
 617         atomic_inc(&cmd->device->iorequest_cnt);
 618
 619         /* check if the device is still usable */
 620         if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
 621                 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
 622                  * returns an immediate error upwards, and signals
 623                  * that the device is no longer present */
 624                 cmd->result = DID_NO_CONNECT << 16;
 625                 goto done;
 626         }
 627
 628         /* Check to see if the scsi lld made this device blocked. */
 629         if (unlikely(scsi_device_blocked(cmd->device))) {
 630                 /*
 631                  * in blocked state, the command is just put back on
 632                  * the device queue.  The suspend state has already
 633                  * blocked the queue so future requests should not
 634                  * occur until the device transitions out of the
 635                  * suspend state.
 636                  */
 637                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 638                         "queuecommand : device blocked\n"));
 639                 return SCSI_MLQUEUE_DEVICE_BUSY;
 640         }
 641
 642         /* Store the LUN value in cmnd, if needed. */
 643         if (cmd->device->lun_in_cdb)
 644                 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
 645                                (cmd->device->lun << 5 & 0xe0);
 646
 647         scsi_log_send(cmd);
 648
 649         /*
 650          * Before we queue this command, check if the command
 651          * length exceeds what the host adapter can handle.
 652          */
 653         if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
 654                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 655                                "queuecommand : command too long. "
 656                                "cdb_size=%d host->max_cmd_len=%d\n",
 657                                cmd->cmd_len, cmd->device->host->max_cmd_len));
 658                 cmd->result = (DID_ABORT << 16);
 659                 goto done;
 660         }
 661
 662         if (unlikely(host->shost_state == SHOST_DEL)) {
 663                 cmd->result = (DID_NO_CONNECT << 16);
 664                 goto done;
 665
 666         }
 667
 668         trace_scsi_dispatch_cmd_start(cmd);
 669         rtn = host->hostt->queuecommand(host, cmd);
 670         if (rtn) {
 671                 trace_scsi_dispatch_cmd_error(cmd, rtn);
 672                 if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
 673                     rtn != SCSI_MLQUEUE_TARGET_BUSY)
 674                         rtn = SCSI_MLQUEUE_HOST_BUSY;
 675
 676                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 677                         "queuecommand : request rejected\n"));
 678         }
 679
 680         return rtn;
 681  done:
 682         cmd->scsi_done(cmd);
 683         return 0;
 684 }
 685
 686 /**
 687  * scsi_finish_command - cleanup and pass command back to upper layer
 688  * @cmd: the command
 689  *
 690  * Description: Pass command off to upper layer for finishing of I/O
 691  *              request, waking processes that are waiting on results,
 692  *              etc.
 693  */
 694 void scsi_finish_command(struct scsi_cmnd *cmd)
 695 {
 696         struct scsi_device *sdev = cmd->device;
 697         struct scsi_target *starget = scsi_target(sdev);
 698         struct Scsi_Host *shost = sdev->host;
 699         struct scsi_driver *drv;
 700         unsigned int good_bytes;
 701
 702         scsi_device_unbusy(sdev);
 703
 704         /*
 705          * Clear the flags that say that the device/target/host is no longer
 706          * capable of accepting new commands.
 707          */
 708         if (atomic_read(&shost->host_blocked))
 709                 atomic_set(&shost->host_blocked, 0);
 710         if (atomic_read(&starget->target_blocked))
 711                 atomic_set(&starget->target_blocked, 0);
 712         if (atomic_read(&sdev->device_blocked))
 713                 atomic_set(&sdev->device_blocked, 0);
 714
 715         /*
 716          * If we have valid sense information, then some kind of recovery
 717          * must have taken place.  Make a note of this.
 718          */
 719         if (SCSI_SENSE_VALID(cmd))
 720                 cmd->result |= (DRIVER_SENSE << 24);
 721
 722         SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
 723                                 "Notifying upper driver of completion "
 724                                 "(result %x)\n", cmd->result));
 725
 726         good_bytes = scsi_bufflen(cmd);
 727         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
 728                 int old_good_bytes = good_bytes;
 729                 drv = scsi_cmd_to_driver(cmd);
 730                 if (drv->done)
 731                         good_bytes = drv->done(cmd);
 732                 /*
 733                  * USB may not give sense identifying bad sector and
 734                  * simply return a residue instead, so subtract off the
 735                  * residue if drv->done() error processing indicates no
 736                  * change to the completion length.
 737                  */
 738                 if (good_bytes == old_good_bytes)
 739                         good_bytes -= scsi_get_resid(cmd);
 740         }
 741         scsi_io_completion(cmd, good_bytes);
 742 }
 743
 744 /**
 745  * scsi_change_queue_depth - change a device's queue depth
 746  * @sdev: SCSI Device in question
 747  * @depth: number of commands allowed to be queued to the driver
 748  *
 749  * Sets the device queue depth and returns the new value.
 750  */
 751 int scsi_change_queue_depth(struct scsi_device *sdev, int depth)
 752 {
 753         unsigned long flags;
 754
 755         if (depth <= 0)
 756                 goto out;
 757
 758         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 759
 760         /*
 761          * Check to see if the queue is managed by the block layer.
 762          * If it is, and we fail to adjust the depth, exit.
 763          *
 764          * Do not resize the tag map if it is a host wide share bqt,
 765          * because the size should be the hosts's can_queue. If there
 766          * is more IO than the LLD's can_queue (so there are not enuogh
 767          * tags) request_fn's host queue ready check will handle it.
 768          */
 769         if (!shost_use_blk_mq(sdev->host) && !sdev->host->bqt) {
 770                 if (blk_queue_tagged(sdev->request_queue) &&
 771                     blk_queue_resize_tags(sdev->request_queue, depth) != 0)
 772                         goto out_unlock;
 773         }
 774
 775         sdev->queue_depth = depth;
 776 out_unlock:
 777         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 778 out:
 779         return sdev->queue_depth;
 780 }
 781 EXPORT_SYMBOL(scsi_change_queue_depth);
 782
 783 /**
 784  * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
 785  * @sdev: SCSI Device in question
 786  * @depth: Current number of outstanding SCSI commands on this device,
 787  *         not counting the one returned as QUEUE_FULL.
 788  *
 789  * Description: This function will track successive QUEUE_FULL events on a
 790  *              specific SCSI device to determine if and when there is a
 791  *              need to adjust the queue depth on the device.
 792  *
 793  * Returns:     0 - No change needed, >0 - Adjust queue depth to this new depth,
 794  *              -1 - Drop back to untagged operation using host->cmd_per_lun
 795  *                      as the untagged command depth
 796  *
 797  * Lock Status: None held on entry
 798  *
 799  * Notes:       Low level drivers may call this at any time and we will do
 800  *              "The Right Thing."  We are interrupt context safe.
 801  */
 802 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 803 {
 804
 805         /*
 806          * Don't let QUEUE_FULLs on the same
 807          * jiffies count, they could all be from
 808          * same event.
 809          */
 810         if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
 811                 return 0;
 812
 813         sdev->last_queue_full_time = jiffies;
 814         if (sdev->last_queue_full_depth != depth) {
 815                 sdev->last_queue_full_count = 1;
 816                 sdev->last_queue_full_depth = depth;
 817         } else {
 818                 sdev->last_queue_full_count++;
 819         }
 820
 821         if (sdev->last_queue_full_count <= 10)
 822                 return 0;
 823         if (sdev->last_queue_full_depth < 8) {
 824                 /* Drop back to untagged */
 825                 scsi_set_tag_type(sdev, 0);
 826                 scsi_change_queue_depth(sdev, sdev->host->cmd_per_lun);
 827                 return -1;
 828         }
 829
 830         return scsi_change_queue_depth(sdev, depth);
 831 }
 832 EXPORT_SYMBOL(scsi_track_queue_full);
 833
 834 /**
 835  * scsi_change_queue_type() - Change a device's queue type
 836  * @sdev:     The SCSI device whose queue depth is to change
 837  * @tag_type: Identifier for queue type
 838  */
 839 int scsi_change_queue_type(struct scsi_device *sdev, int tag_type)
 840 {
 841         if (!sdev->tagged_supported)
 842                 return 0;
 843
 844         scsi_set_tag_type(sdev, tag_type);
 845         return tag_type;
 846
 847 }
 848 EXPORT_SYMBOL(scsi_change_queue_type);
 849
 850 /**
 851  * scsi_vpd_inquiry - Request a device provide us with a VPD page
 852  * @sdev: The device to ask
 853  * @buffer: Where to put the result
 854  * @page: Which Vital Product Data to return
 855  * @len: The length of the buffer
 856  *
 857  * This is an internal helper function.  You probably want to use
 858  * scsi_get_vpd_page instead.
 859  *
 860  * Returns size of the vpd page on success or a negative error number.
 861  */
 862 static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
 863                                                         u8 page, unsigned len)
 864 {
 865         int result;
 866         unsigned char cmd[16];
 867
 868         if (len < 4)
 869                 return -EINVAL;
 870
 871         cmd[0] = INQUIRY;
 872         cmd[1] = 1;             /* EVPD */
 873         cmd[2] = page;
 874         cmd[3] = len >> 8;
 875         cmd[4] = len & 0xff;
 876         cmd[5] = 0;             /* Control byte */
 877
 878         /*
 879          * I'm not convinced we need to try quite this hard to get VPD, but
 880          * all the existing users tried this hard.
 881          */
 882         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
 883                                   len, NULL, 30 * HZ, 3, NULL);
 884         if (result)
 885                 return -EIO;
 886
 887         /* Sanity check that we got the page back that we asked for */
 888         if (buffer[1] != page)
 889                 return -EIO;
 890
 891         return get_unaligned_be16(&buffer[2]) + 4;
 892 }
 893
 894 /**
 895  * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
 896  * @sdev: The device to ask
 897  * @page: Which Vital Product Data to return
 898  * @buf: where to store the VPD
 899  * @buf_len: number of bytes in the VPD buffer area
 900  *
 901  * SCSI devices may optionally supply Vital Product Data.  Each 'page'
 902  * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
 903  * If the device supports this VPD page, this routine returns a pointer
 904  * to a buffer containing the data from that page.  The caller is
 905  * responsible for calling kfree() on this pointer when it is no longer
 906  * needed.  If we cannot retrieve the VPD page this routine returns %NULL.
 907  */
 908 int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
 909                       int buf_len)
 910 {
 911         int i, result;
 912
 913         if (sdev->skip_vpd_pages)
 914                 goto fail;
 915
 916         /* Ask for all the pages supported by this device */
 917         result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
 918         if (result < 4)
 919                 goto fail;
 920
 921         /* If the user actually wanted this page, we can skip the rest */
 922         if (page == 0)
 923                 return 0;
 924
 925         for (i = 4; i < min(result, buf_len); i++)
 926                 if (buf[i] == page)
 927                         goto found;
 928
 929         if (i < result && i >= buf_len)
 930                 /* ran off the end of the buffer, give us benefit of doubt */
 931                 goto found;
 932         /* The device claims it doesn't support the requested page */
 933         goto fail;
 934
 935  found:
 936         result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
 937         if (result < 0)
 938                 goto fail;
 939
 940         return 0;
 941
 942  fail:
 943         return -EINVAL;
 944 }
 945 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
 946
 947 /**
 948  * scsi_attach_vpd - Attach Vital Product Data to a SCSI device structure
 949  * @sdev: The device to ask
 950  *
 951  * Attach the 'Device Identification' VPD page (0x83) and the
 952  * 'Unit Serial Number' VPD page (0x80) to a SCSI device
 953  * structure. This information can be used to identify the device
 954  * uniquely.
 955  */
 956 void scsi_attach_vpd(struct scsi_device *sdev)
 957 {
 958         int result, i;
 959         int vpd_len = SCSI_VPD_PG_LEN;
 960         int pg80_supported = 0;
 961         int pg83_supported = 0;
 962         unsigned char *vpd_buf;
 963
 964         if (sdev->skip_vpd_pages)
 965                 return;
 966 retry_pg0:
 967         vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
 968         if (!vpd_buf)
 969                 return;
 970
 971         /* Ask for all the pages supported by this device */
 972         result = scsi_vpd_inquiry(sdev, vpd_buf, 0, vpd_len);
 973         if (result < 0) {
 974                 kfree(vpd_buf);
 975                 return;
 976         }
 977         if (result > vpd_len) {
 978                 vpd_len = result;
 979                 kfree(vpd_buf);
 980                 goto retry_pg0;
 981         }
 982
 983         for (i = 4; i < result; i++) {
 984                 if (vpd_buf[i] == 0x80)
 985                         pg80_supported = 1;
 986                 if (vpd_buf[i] == 0x83)
 987                         pg83_supported = 1;
 988         }
 989         kfree(vpd_buf);
 990         vpd_len = SCSI_VPD_PG_LEN;
 991
 992         if (pg80_supported) {
 993 retry_pg80:
 994                 vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
 995                 if (!vpd_buf)
 996                         return;
 997
 998                 result = scsi_vpd_inquiry(sdev, vpd_buf, 0x80, vpd_len);
 999                 if (result < 0) {
1000                         kfree(vpd_buf);
1001                         return;
1002                 }
1003                 if (result > vpd_len) {
1004                         vpd_len = result;
1005                         kfree(vpd_buf);
1006                         goto retry_pg80;
1007                 }
1008                 sdev->vpd_pg80_len = result;
1009                 sdev->vpd_pg80 = vpd_buf;
1010                 vpd_len = SCSI_VPD_PG_LEN;
1011         }
1012
1013         if (pg83_supported) {
1014 retry_pg83:
1015                 vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
1016                 if (!vpd_buf)
1017                         return;
1018
1019                 result = scsi_vpd_inquiry(sdev, vpd_buf, 0x83, vpd_len);
1020                 if (result < 0) {
1021                         kfree(vpd_buf);
1022                         return;
1023                 }
1024                 if (result > vpd_len) {
1025                         vpd_len = result;
1026                         kfree(vpd_buf);
1027                         goto retry_pg83;
1028                 }
1029                 sdev->vpd_pg83_len = result;
1030                 sdev->vpd_pg83 = vpd_buf;
1031         }
1032 }
1033
1034 /**
1035  * scsi_report_opcode - Find out if a given command opcode is supported
1036  * @sdev:       scsi device to query
1037  * @buffer:     scratch buffer (must be at least 20 bytes long)
1038  * @len:        length of buffer
1039  * @opcode:     opcode for command to look up
1040  *
1041  * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
1042  * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is
1043  * unsupported and 1 if the device claims to support the command.
1044  */
1045 int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
1046                        unsigned int len, unsigned char opcode)
1047 {
1048         unsigned char cmd[16];
1049         struct scsi_sense_hdr sshdr;
1050         int result;
1051
1052         if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
1053                 return -EINVAL;
1054
1055         memset(cmd, 0, 16);
1056         cmd[0] = MAINTENANCE_IN;
1057         cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
1058         cmd[2] = 1;             /* One command format */
1059         cmd[3] = opcode;
1060         put_unaligned_be32(len, &cmd[6]);
1061         memset(buffer, 0, len);
1062
1063         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
1064                                   &sshdr, 30 * HZ, 3, NULL);
1065
1066         if (result && scsi_sense_valid(&sshdr) &&
1067             sshdr.sense_key == ILLEGAL_REQUEST &&
1068             (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
1069                 return -EINVAL;
1070
1071         if ((buffer[1] & 3) == 3) /* Command supported */
1072                 return 1;
1073
1074         return 0;
1075 }
1076 EXPORT_SYMBOL(scsi_report_opcode);
1077
1078 /**
1079  * scsi_device_get  -  get an additional reference to a scsi_device
1080  * @sdev:       device to get a reference to
1081  *
1082  * Description: Gets a reference to the scsi_device and increments the use count
1083  * of the underlying LLDD module.  You must hold host_lock of the
1084  * parent Scsi_Host or already have a reference when calling this.
1085  */
1086 int scsi_device_get(struct scsi_device *sdev)
1087 {
1088         if (sdev->sdev_state == SDEV_DEL)
1089                 return -ENXIO;
1090         if (!get_device(&sdev->sdev_gendev))
1091                 return -ENXIO;
1092         /* We can fail this if we're doing SCSI operations
1093          * from module exit (like cache flush) */
1094         try_module_get(sdev->host->hostt->module);
1095
1096         return 0;
1097 }
1098 EXPORT_SYMBOL(scsi_device_get);
1099
1100 /**
1101  * scsi_device_put  -  release a reference to a scsi_device
1102  * @sdev:       device to release a reference on.
1103  *
1104  * Description: Release a reference to the scsi_device and decrements the use
1105  * count of the underlying LLDD module.  The device is freed once the last
1106  * user vanishes.
1107  */
1108 void scsi_device_put(struct scsi_device *sdev)
1109 {
1110 #ifdef CONFIG_MODULE_UNLOAD
1111         struct module *module = sdev->host->hostt->module;
1112
1113         /* The module refcount will be zero if scsi_device_get()
1114          * was called from a module removal routine */
1115         if (module && module_refcount(module) != 0)
1116                 module_put(module);
1117 #endif
1118         put_device(&sdev->sdev_gendev);
1119 }
1120 EXPORT_SYMBOL(scsi_device_put);
1121
1122 /* helper for shost_for_each_device, see that for documentation */
1123 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1124                                            struct scsi_device *prev)
1125 {
1126         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1127         struct scsi_device *next = NULL;
1128         unsigned long flags;
1129
1130         spin_lock_irqsave(shost->host_lock, flags);
1131         while (list->next != &shost->__devices) {
1132                 next = list_entry(list->next, struct scsi_device, siblings);
1133                 /* skip devices that we can't get a reference to */
1134                 if (!scsi_device_get(next))
1135                         break;
1136                 next = NULL;
1137                 list = list->next;
1138         }
1139         spin_unlock_irqrestore(shost->host_lock, flags);
1140
1141         if (prev)
1142                 scsi_device_put(prev);
1143         return next;
1144 }
1145 EXPORT_SYMBOL(__scsi_iterate_devices);
1146
1147 /**
1148  * starget_for_each_device  -  helper to walk all devices of a target
1149  * @starget:    target whose devices we want to iterate over.
1150  * @data:       Opaque passed to each function call.
1151  * @fn:         Function to call on each device
1152  *
1153  * This traverses over each device of @starget.  The devices have
1154  * a reference that must be released by scsi_host_put when breaking
1155  * out of the loop.
1156  */
1157 void starget_for_each_device(struct scsi_target *starget, void *data,
1158                      void (*fn)(struct scsi_device *, void *))
1159 {
1160         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1161         struct scsi_device *sdev;
1162
1163         shost_for_each_device(sdev, shost) {
1164                 if ((sdev->channel == starget->channel) &&
1165                     (sdev->id == starget->id))
1166                         fn(sdev, data);
1167         }
1168 }
1169 EXPORT_SYMBOL(starget_for_each_device);
1170
1171 /**
1172  * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1173  * @starget:    target whose devices we want to iterate over.
1174  * @data:       parameter for callback @fn()
1175  * @fn:         callback function that is invoked for each device
1176  *
1177  * This traverses over each device of @starget.  It does _not_
1178  * take a reference on the scsi_device, so the whole loop must be
1179  * protected by shost->host_lock.
1180  *
1181  * Note:  The only reason why drivers would want to use this is because
1182  * they need to access the device list in irq context.  Otherwise you
1183  * really want to use starget_for_each_device instead.
1184  **/
1185 void __starget_for_each_device(struct scsi_target *starget, void *data,
1186                                void (*fn)(struct scsi_device *, void *))
1187 {
1188         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1189         struct scsi_device *sdev;
1190
1191         __shost_for_each_device(sdev, shost) {
1192                 if ((sdev->channel == starget->channel) &&
1193                     (sdev->id == starget->id))
1194                         fn(sdev, data);
1195         }
1196 }
1197 EXPORT_SYMBOL(__starget_for_each_device);
1198
1199 /**
1200  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1201  * @starget:    SCSI target pointer
1202  * @lun:        SCSI Logical Unit Number
1203  *
1204  * Description: Looks up the scsi_device with the specified @lun for a given
1205  * @starget.  The returned scsi_device does not have an additional
1206  * reference.  You must hold the host's host_lock over this call and
1207  * any access to the returned scsi_device. A scsi_device in state
1208  * SDEV_DEL is skipped.
1209  *
1210  * Note:  The only reason why drivers should use this is because
1211  * they need to access the device list in irq context.  Otherwise you
1212  * really want to use scsi_device_lookup_by_target instead.
1213  **/
1214 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1215                                                    u64 lun)
1216 {
1217         struct scsi_device *sdev;
1218
1219         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1220                 if (sdev->sdev_state == SDEV_DEL)
1221                         continue;
1222                 if (sdev->lun ==lun)
1223                         return sdev;
1224         }
1225
1226         return NULL;
1227 }
1228 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1229
1230 /**
1231  * scsi_device_lookup_by_target - find a device given the target
1232  * @starget:    SCSI target pointer
1233  * @lun:        SCSI Logical Unit Number
1234  *
1235  * Description: Looks up the scsi_device with the specified @lun for a given
1236  * @starget.  The returned scsi_device has an additional reference that
1237  * needs to be released with scsi_device_put once you're done with it.
1238  **/
1239 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1240                                                  u64 lun)
1241 {
1242         struct scsi_device *sdev;
1243         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1244         unsigned long flags;
1245
1246         spin_lock_irqsave(shost->host_lock, flags);
1247         sdev = __scsi_device_lookup_by_target(starget, lun);
1248         if (sdev && scsi_device_get(sdev))
1249                 sdev = NULL;
1250         spin_unlock_irqrestore(shost->host_lock, flags);
1251
1252         return sdev;
1253 }
1254 EXPORT_SYMBOL(scsi_device_lookup_by_target);
1255
1256 /**
1257  * __scsi_device_lookup - find a device given the host (UNLOCKED)
1258  * @shost:      SCSI host pointer
1259  * @channel:    SCSI channel (zero if only one channel)
1260  * @id:         SCSI target number (physical unit number)
1261  * @lun:        SCSI Logical Unit Number
1262  *
1263  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1264  * for a given host. The returned scsi_device does not have an additional
1265  * reference.  You must hold the host's host_lock over this call and any access
1266  * to the returned scsi_device.
1267  *
1268  * Note:  The only reason why drivers would want to use this is because
1269  * they need to access the device list in irq context.  Otherwise you
1270  * really want to use scsi_device_lookup instead.
1271  **/
1272 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1273                 uint channel, uint id, u64 lun)
1274 {
1275         struct scsi_device *sdev;
1276
1277         list_for_each_entry(sdev, &shost->__devices, siblings) {
1278                 if (sdev->channel == channel && sdev->id == id &&
1279                                 sdev->lun ==lun)
1280                         return sdev;
1281         }
1282
1283         return NULL;
1284 }
1285 EXPORT_SYMBOL(__scsi_device_lookup);
1286
1287 /**
1288  * scsi_device_lookup - find a device given the host
1289  * @shost:      SCSI host pointer
1290  * @channel:    SCSI channel (zero if only one channel)
1291  * @id:         SCSI target number (physical unit number)
1292  * @lun:        SCSI Logical Unit Number
1293  *
1294  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1295  * for a given host.  The returned scsi_device has an additional reference that
1296  * needs to be released with scsi_device_put once you're done with it.
1297  **/
1298 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1299                 uint channel, uint id, u64 lun)
1300 {
1301         struct scsi_device *sdev;
1302         unsigned long flags;
1303
1304         spin_lock_irqsave(shost->host_lock, flags);
1305         sdev = __scsi_device_lookup(shost, channel, id, lun);
1306         if (sdev && scsi_device_get(sdev))
1307                 sdev = NULL;
1308         spin_unlock_irqrestore(shost->host_lock, flags);
1309
1310         return sdev;
1311 }
1312 EXPORT_SYMBOL(scsi_device_lookup);
1313
1314 MODULE_DESCRIPTION("SCSI core");
1315 MODULE_LICENSE("GPL");
1316
1317 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1318 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1319
1320 #ifdef CONFIG_SCSI_MQ_DEFAULT
1321 bool scsi_use_blk_mq = true;
1322 #else
1323 bool scsi_use_blk_mq = false;
1324 #endif
1325 module_param_named(use_blk_mq, scsi_use_blk_mq, bool, S_IWUSR | S_IRUGO);
1326
1327 static int __init init_scsi(void)
1328 {
1329         int error;
1330
1331         error = scsi_init_queue();
1332         if (error)
1333                 return error;
1334         error = scsi_init_procfs();
1335         if (error)
1336                 goto cleanup_queue;
1337         error = scsi_init_devinfo();
1338         if (error)
1339                 goto cleanup_procfs;
1340         error = scsi_init_hosts();
1341         if (error)
1342                 goto cleanup_devlist;
1343         error = scsi_init_sysctl();
1344         if (error)
1345                 goto cleanup_hosts;
1346         error = scsi_sysfs_register();
1347         if (error)
1348                 goto cleanup_sysctl;
1349
1350         scsi_netlink_init();
1351
1352         printk(KERN_NOTICE "SCSI subsystem initialized\n");
1353         return 0;
1354
1355 cleanup_sysctl:
1356         scsi_exit_sysctl();
1357 cleanup_hosts:
1358         scsi_exit_hosts();
1359 cleanup_devlist:
1360         scsi_exit_devinfo();
1361 cleanup_procfs:
1362         scsi_exit_procfs();
1363 cleanup_queue:
1364         scsi_exit_queue();
1365         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1366                -error);
1367         return error;
1368 }
1369
1370 static void __exit exit_scsi(void)
1371 {
1372         scsi_netlink_exit();
1373         scsi_sysfs_unregister();
1374         scsi_exit_sysctl();
1375         scsi_exit_hosts();
1376         scsi_exit_devinfo();
1377         scsi_exit_procfs();
1378         scsi_exit_queue();
1379         async_unregister_domain(&scsi_sd_probe_domain);
1380 }
1381
1382 subsys_initcall(init_scsi);
1383 module_exit(exit_scsi);