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  *  <[email protected]>
  11  *
  12  *  Bug correction thanks go to :
  13  *      Rik Faith <[email protected]>
  14  *      Tommy Thorn <tthorn>
  15  *      Thomas Wuensche <[email protected]>
  16  *
  17  *  Modified by Eric Youngdale [email protected] or [email protected] 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 <[email protected]>
  23  *
  24  *  Added request_module("scsi_hostadapter") for kerneld:
  25  *  (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf)
  26  *  Bjorn Ekwall  <[email protected]>
  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 <[email protected]>
  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
 531          *
 532          * 3: same as 2 plus dump cmd address
 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, "Send: ");
 541                         if (level > 2)
 542                                 printk("0x%p ", cmd);
 543                         printk("\n");
 544                         scsi_print_command(cmd);
 545                         if (level > 3) {
 546                                 printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
 547                                        " queuecommand 0x%p\n",
 548                                         scsi_sglist(cmd), scsi_bufflen(cmd),
 549                                         cmd->device->host->hostt->queuecommand);
 550
 551                         }
 552                 }
 553         }
 554 }
 555
 556 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
 557 {
 558         unsigned int level;
 559
 560         /*
 561          * If ML COMPLETE log level is greater than or equal to:
 562          *
 563          * 1: log disposition, result, opcode + command, and conditionally
 564          * sense data for failures or non SUCCESS dispositions.
 565          *
 566          * 2: same as 1 but for all command completions.
 567          *
 568          * 3: same as 2 plus dump cmd address
 569          *
 570          * 4: same as 3 plus dump extra junk
 571          */
 572         if (unlikely(scsi_logging_level)) {
 573                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
 574                                        SCSI_LOG_MLCOMPLETE_BITS);
 575                 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
 576                     (level > 1)) {
 577                         scmd_printk(KERN_INFO, cmd, "Done: ");
 578                         if (level > 2)
 579                                 printk("0x%p ", cmd);
 580                         /*
 581                          * Dump truncated values, so we usually fit within
 582                          * 80 chars.
 583                          */
 584                         switch (disposition) {
 585                         case SUCCESS:
 586                                 printk("SUCCESS\n");
 587                                 break;
 588                         case NEEDS_RETRY:
 589                                 printk("RETRY\n");
 590                                 break;
 591                         case ADD_TO_MLQUEUE:
 592                                 printk("MLQUEUE\n");
 593                                 break;
 594                         case FAILED:
 595                                 printk("FAILED\n");
 596                                 break;
 597                         case TIMEOUT_ERROR:
 598                                 /*
 599                                  * If called via scsi_times_out.
 600                                  */
 601                                 printk("TIMEOUT\n");
 602                                 break;
 603                         default:
 604                                 printk("UNKNOWN\n");
 605                         }
 606                         scsi_print_result(cmd);
 607                         scsi_print_command(cmd);
 608                         if (status_byte(cmd->result) & CHECK_CONDITION)
 609                                 scsi_print_sense("", cmd);
 610                         if (level > 3)
 611                                 scmd_printk(KERN_INFO, cmd,
 612                                             "scsi host busy %d failed %d\n",
 613                                             atomic_read(&cmd->device->host->host_busy),
 614                                             cmd->device->host->host_failed);
 615                 }
 616         }
 617 }
 618 #endif
 619
 620 /**
 621  * scsi_cmd_get_serial - Assign a serial number to a command
 622  * @host: the scsi host
 623  * @cmd: command to assign serial number to
 624  *
 625  * Description: a serial number identifies a request for error recovery
 626  * and debugging purposes.  Protected by the Host_Lock of host.
 627  */
 628 void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 629 {
 630         cmd->serial_number = host->cmd_serial_number++;
 631         if (cmd->serial_number == 0)
 632                 cmd->serial_number = host->cmd_serial_number++;
 633 }
 634 EXPORT_SYMBOL(scsi_cmd_get_serial);
 635
 636 /**
 637  * scsi_dispatch_command - Dispatch a command to the low-level driver.
 638  * @cmd: command block we are dispatching.
 639  *
 640  * Return: nonzero return request was rejected and device's queue needs to be
 641  * plugged.
 642  */
 643 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
 644 {
 645         struct Scsi_Host *host = cmd->device->host;
 646         int rtn = 0;
 647
 648         atomic_inc(&cmd->device->iorequest_cnt);
 649
 650         /* check if the device is still usable */
 651         if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
 652                 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
 653                  * returns an immediate error upwards, and signals
 654                  * that the device is no longer present */
 655                 cmd->result = DID_NO_CONNECT << 16;
 656                 goto done;
 657         }
 658
 659         /* Check to see if the scsi lld made this device blocked. */
 660         if (unlikely(scsi_device_blocked(cmd->device))) {
 661                 /*
 662                  * in blocked state, the command is just put back on
 663                  * the device queue.  The suspend state has already
 664                  * blocked the queue so future requests should not
 665                  * occur until the device transitions out of the
 666                  * suspend state.
 667                  */
 668                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 669                         "queuecommand : device blocked\n"));
 670                 return SCSI_MLQUEUE_DEVICE_BUSY;
 671         }
 672
 673         /* Store the LUN value in cmnd, if needed. */
 674         if (cmd->device->lun_in_cdb)
 675                 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
 676                                (cmd->device->lun << 5 & 0xe0);
 677
 678         scsi_log_send(cmd);
 679
 680         /*
 681          * Before we queue this command, check if the command
 682          * length exceeds what the host adapter can handle.
 683          */
 684         if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
 685                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 686                                "queuecommand : command too long. "
 687                                "cdb_size=%d host->max_cmd_len=%d\n",
 688                                cmd->cmd_len, cmd->device->host->max_cmd_len));
 689                 cmd->result = (DID_ABORT << 16);
 690                 goto done;
 691         }
 692
 693         if (unlikely(host->shost_state == SHOST_DEL)) {
 694                 cmd->result = (DID_NO_CONNECT << 16);
 695                 goto done;
 696
 697         }
 698
 699         trace_scsi_dispatch_cmd_start(cmd);
 700         rtn = host->hostt->queuecommand(host, cmd);
 701         if (rtn) {
 702                 trace_scsi_dispatch_cmd_error(cmd, rtn);
 703                 if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
 704                     rtn != SCSI_MLQUEUE_TARGET_BUSY)
 705                         rtn = SCSI_MLQUEUE_HOST_BUSY;
 706
 707                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 708                         "queuecommand : request rejected\n"));
 709         }
 710
 711         return rtn;
 712  done:
 713         cmd->scsi_done(cmd);
 714         return 0;
 715 }
 716
 717 /**
 718  * scsi_finish_command - cleanup and pass command back to upper layer
 719  * @cmd: the command
 720  *
 721  * Description: Pass command off to upper layer for finishing of I/O
 722  *              request, waking processes that are waiting on results,
 723  *              etc.
 724  */
 725 void scsi_finish_command(struct scsi_cmnd *cmd)
 726 {
 727         struct scsi_device *sdev = cmd->device;
 728         struct scsi_target *starget = scsi_target(sdev);
 729         struct Scsi_Host *shost = sdev->host;
 730         struct scsi_driver *drv;
 731         unsigned int good_bytes;
 732
 733         scsi_device_unbusy(sdev);
 734
 735         /*
 736          * Clear the flags that say that the device/target/host is no longer
 737          * capable of accepting new commands.
 738          */
 739         if (atomic_read(&shost->host_blocked))
 740                 atomic_set(&shost->host_blocked, 0);
 741         if (atomic_read(&starget->target_blocked))
 742                 atomic_set(&starget->target_blocked, 0);
 743         if (atomic_read(&sdev->device_blocked))
 744                 atomic_set(&sdev->device_blocked, 0);
 745
 746         /*
 747          * If we have valid sense information, then some kind of recovery
 748          * must have taken place.  Make a note of this.
 749          */
 750         if (SCSI_SENSE_VALID(cmd))
 751                 cmd->result |= (DRIVER_SENSE << 24);
 752
 753         SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
 754                                 "Notifying upper driver of completion "
 755                                 "(result %x)\n", cmd->result));
 756
 757         good_bytes = scsi_bufflen(cmd);
 758         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
 759                 int old_good_bytes = good_bytes;
 760                 drv = scsi_cmd_to_driver(cmd);
 761                 if (drv->done)
 762                         good_bytes = drv->done(cmd);
 763                 /*
 764                  * USB may not give sense identifying bad sector and
 765                  * simply return a residue instead, so subtract off the
 766                  * residue if drv->done() error processing indicates no
 767                  * change to the completion length.
 768                  */
 769                 if (good_bytes == old_good_bytes)
 770                         good_bytes -= scsi_get_resid(cmd);
 771         }
 772         scsi_io_completion(cmd, good_bytes);
 773 }
 774
 775 /**
 776  * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
 777  * @sdev: SCSI Device in question
 778  * @tagged: Do we use tagged queueing (non-0) or do we treat
 779  *          this device as an untagged device (0)
 780  * @tags: Number of tags allowed if tagged queueing enabled,
 781  *        or number of commands the low level driver can
 782  *        queue up in non-tagged mode (as per cmd_per_lun).
 783  *
 784  * Returns:     Nothing
 785  *
 786  * Lock Status: None held on entry
 787  *
 788  * Notes:       Low level drivers may call this at any time and we will do
 789  *              the right thing depending on whether or not the device is
 790  *              currently active and whether or not it even has the
 791  *              command blocks built yet.
 792  */
 793 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
 794 {
 795         unsigned long flags;
 796
 797         /*
 798          * refuse to set tagged depth to an unworkable size
 799          */
 800         if (tags <= 0)
 801                 return;
 802
 803         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 804
 805         /*
 806          * Check to see if the queue is managed by the block layer.
 807          * If it is, and we fail to adjust the depth, exit.
 808          *
 809          * Do not resize the tag map if it is a host wide share bqt,
 810          * because the size should be the hosts's can_queue. If there
 811          * is more IO than the LLD's can_queue (so there are not enuogh
 812          * tags) request_fn's host queue ready check will handle it.
 813          */
 814         if (!shost_use_blk_mq(sdev->host) && !sdev->host->bqt) {
 815                 if (blk_queue_tagged(sdev->request_queue) &&
 816                     blk_queue_resize_tags(sdev->request_queue, tags) != 0)
 817                         goto out;
 818         }
 819
 820         sdev->queue_depth = tags;
 821         switch (tagged) {
 822                 case 0:
 823                         sdev->ordered_tags = 0;
 824                         sdev->simple_tags = 0;
 825                         break;
 826                 case MSG_ORDERED_TAG:
 827                         sdev->ordered_tags = 1;
 828                         sdev->simple_tags = 1;
 829                         break;
 830                 case MSG_SIMPLE_TAG:
 831                         sdev->ordered_tags = 0;
 832                         sdev->simple_tags = 1;
 833                         break;
 834                 default:
 835                         sdev->ordered_tags = 0;
 836                         sdev->simple_tags = 0;
 837                         sdev_printk(KERN_WARNING, sdev,
 838                                     "scsi_adjust_queue_depth, bad queue type, "
 839                                     "disabled\n");
 840         }
 841  out:
 842         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 843 }
 844 EXPORT_SYMBOL(scsi_adjust_queue_depth);
 845
 846 /**
 847  * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
 848  * @sdev: SCSI Device in question
 849  * @depth: Current number of outstanding SCSI commands on this device,
 850  *         not counting the one returned as QUEUE_FULL.
 851  *
 852  * Description: This function will track successive QUEUE_FULL events on a
 853  *              specific SCSI device to determine if and when there is a
 854  *              need to adjust the queue depth on the device.
 855  *
 856  * Returns:     0 - No change needed, >0 - Adjust queue depth to this new depth,
 857  *              -1 - Drop back to untagged operation using host->cmd_per_lun
 858  *                      as the untagged command depth
 859  *
 860  * Lock Status: None held on entry
 861  *
 862  * Notes:       Low level drivers may call this at any time and we will do
 863  *              "The Right Thing."  We are interrupt context safe.
 864  */
 865 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 866 {
 867
 868         /*
 869          * Don't let QUEUE_FULLs on the same
 870          * jiffies count, they could all be from
 871          * same event.
 872          */
 873         if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
 874                 return 0;
 875
 876         sdev->last_queue_full_time = jiffies;
 877         if (sdev->last_queue_full_depth != depth) {
 878                 sdev->last_queue_full_count = 1;
 879                 sdev->last_queue_full_depth = depth;
 880         } else {
 881                 sdev->last_queue_full_count++;
 882         }
 883
 884         if (sdev->last_queue_full_count <= 10)
 885                 return 0;
 886         if (sdev->last_queue_full_depth < 8) {
 887                 /* Drop back to untagged */
 888                 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 889                 return -1;
 890         }
 891
 892         if (sdev->ordered_tags)
 893                 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
 894         else
 895                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
 896         return depth;
 897 }
 898 EXPORT_SYMBOL(scsi_track_queue_full);
 899
 900 /**
 901  * scsi_vpd_inquiry - Request a device provide us with a VPD page
 902  * @sdev: The device to ask
 903  * @buffer: Where to put the result
 904  * @page: Which Vital Product Data to return
 905  * @len: The length of the buffer
 906  *
 907  * This is an internal helper function.  You probably want to use
 908  * scsi_get_vpd_page instead.
 909  *
 910  * Returns size of the vpd page on success or a negative error number.
 911  */
 912 static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
 913                                                         u8 page, unsigned len)
 914 {
 915         int result;
 916         unsigned char cmd[16];
 917
 918         if (len < 4)
 919                 return -EINVAL;
 920
 921         cmd[0] = INQUIRY;
 922         cmd[1] = 1;             /* EVPD */
 923         cmd[2] = page;
 924         cmd[3] = len >> 8;
 925         cmd[4] = len & 0xff;
 926         cmd[5] = 0;             /* Control byte */
 927
 928         /*
 929          * I'm not convinced we need to try quite this hard to get VPD, but
 930          * all the existing users tried this hard.
 931          */
 932         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
 933                                   len, NULL, 30 * HZ, 3, NULL);
 934         if (result)
 935                 return -EIO;
 936
 937         /* Sanity check that we got the page back that we asked for */
 938         if (buffer[1] != page)
 939                 return -EIO;
 940
 941         return get_unaligned_be16(&buffer[2]) + 4;
 942 }
 943
 944 /**
 945  * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
 946  * @sdev: The device to ask
 947  * @page: Which Vital Product Data to return
 948  * @buf: where to store the VPD
 949  * @buf_len: number of bytes in the VPD buffer area
 950  *
 951  * SCSI devices may optionally supply Vital Product Data.  Each 'page'
 952  * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
 953  * If the device supports this VPD page, this routine returns a pointer
 954  * to a buffer containing the data from that page.  The caller is
 955  * responsible for calling kfree() on this pointer when it is no longer
 956  * needed.  If we cannot retrieve the VPD page this routine returns %NULL.
 957  */
 958 int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
 959                       int buf_len)
 960 {
 961         int i, result;
 962
 963         if (sdev->skip_vpd_pages)
 964                 goto fail;
 965
 966         /* Ask for all the pages supported by this device */
 967         result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
 968         if (result < 4)
 969                 goto fail;
 970
 971         /* If the user actually wanted this page, we can skip the rest */
 972         if (page == 0)
 973                 return 0;
 974
 975         for (i = 4; i < min(result, buf_len); i++)
 976                 if (buf[i] == page)
 977                         goto found;
 978
 979         if (i < result && i >= buf_len)
 980                 /* ran off the end of the buffer, give us benefit of doubt */
 981                 goto found;
 982         /* The device claims it doesn't support the requested page */
 983         goto fail;
 984
 985  found:
 986         result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
 987         if (result < 0)
 988                 goto fail;
 989
 990         return 0;
 991
 992  fail:
 993         return -EINVAL;
 994 }
 995 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
 996
 997 /**
 998  * scsi_attach_vpd - Attach Vital Product Data to a SCSI device structure
 999  * @sdev: The device to ask
1000  *
1001  * Attach the 'Device Identification' VPD page (0x83) and the
1002  * 'Unit Serial Number' VPD page (0x80) to a SCSI device
1003  * structure. This information can be used to identify the device
1004  * uniquely.
1005  */
1006 void scsi_attach_vpd(struct scsi_device *sdev)
1007 {
1008         int result, i;
1009         int vpd_len = SCSI_VPD_PG_LEN;
1010         int pg80_supported = 0;
1011         int pg83_supported = 0;
1012         unsigned char *vpd_buf;
1013
1014         if (sdev->skip_vpd_pages)
1015                 return;
1016 retry_pg0:
1017         vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
1018         if (!vpd_buf)
1019                 return;
1020
1021         /* Ask for all the pages supported by this device */
1022         result = scsi_vpd_inquiry(sdev, vpd_buf, 0, vpd_len);
1023         if (result < 0) {
1024                 kfree(vpd_buf);
1025                 return;
1026         }
1027         if (result > vpd_len) {
1028                 vpd_len = result;
1029                 kfree(vpd_buf);
1030                 goto retry_pg0;
1031         }
1032
1033         for (i = 4; i < result; i++) {
1034                 if (vpd_buf[i] == 0x80)
1035                         pg80_supported = 1;
1036                 if (vpd_buf[i] == 0x83)
1037                         pg83_supported = 1;
1038         }
1039         kfree(vpd_buf);
1040         vpd_len = SCSI_VPD_PG_LEN;
1041
1042         if (pg80_supported) {
1043 retry_pg80:
1044                 vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
1045                 if (!vpd_buf)
1046                         return;
1047
1048                 result = scsi_vpd_inquiry(sdev, vpd_buf, 0x80, vpd_len);
1049                 if (result < 0) {
1050                         kfree(vpd_buf);
1051                         return;
1052                 }
1053                 if (result > vpd_len) {
1054                         vpd_len = result;
1055                         kfree(vpd_buf);
1056                         goto retry_pg80;
1057                 }
1058                 sdev->vpd_pg80_len = result;
1059                 sdev->vpd_pg80 = vpd_buf;
1060                 vpd_len = SCSI_VPD_PG_LEN;
1061         }
1062
1063         if (pg83_supported) {
1064 retry_pg83:
1065                 vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
1066                 if (!vpd_buf)
1067                         return;
1068
1069                 result = scsi_vpd_inquiry(sdev, vpd_buf, 0x83, vpd_len);
1070                 if (result < 0) {
1071                         kfree(vpd_buf);
1072                         return;
1073                 }
1074                 if (result > vpd_len) {
1075                         vpd_len = result;
1076                         kfree(vpd_buf);
1077                         goto retry_pg83;
1078                 }
1079                 sdev->vpd_pg83_len = result;
1080                 sdev->vpd_pg83 = vpd_buf;
1081         }
1082 }
1083
1084 /**
1085  * scsi_report_opcode - Find out if a given command opcode is supported
1086  * @sdev:       scsi device to query
1087  * @buffer:     scratch buffer (must be at least 20 bytes long)
1088  * @len:        length of buffer
1089  * @opcode:     opcode for command to look up
1090  *
1091  * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
1092  * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is
1093  * unsupported and 1 if the device claims to support the command.
1094  */
1095 int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
1096                        unsigned int len, unsigned char opcode)
1097 {
1098         unsigned char cmd[16];
1099         struct scsi_sense_hdr sshdr;
1100         int result;
1101
1102         if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
1103                 return -EINVAL;
1104
1105         memset(cmd, 0, 16);
1106         cmd[0] = MAINTENANCE_IN;
1107         cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
1108         cmd[2] = 1;             /* One command format */
1109         cmd[3] = opcode;
1110         put_unaligned_be32(len, &cmd[6]);
1111         memset(buffer, 0, len);
1112
1113         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
1114                                   &sshdr, 30 * HZ, 3, NULL);
1115
1116         if (result && scsi_sense_valid(&sshdr) &&
1117             sshdr.sense_key == ILLEGAL_REQUEST &&
1118             (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
1119                 return -EINVAL;
1120
1121         if ((buffer[1] & 3) == 3) /* Command supported */
1122                 return 1;
1123
1124         return 0;
1125 }
1126 EXPORT_SYMBOL(scsi_report_opcode);
1127
1128 /**
1129  * scsi_device_get  -  get an additional reference to a scsi_device
1130  * @sdev:       device to get a reference to
1131  *
1132  * Description: Gets a reference to the scsi_device and increments the use count
1133  * of the underlying LLDD module.  You must hold host_lock of the
1134  * parent Scsi_Host or already have a reference when calling this.
1135  */
1136 int scsi_device_get(struct scsi_device *sdev)
1137 {
1138         if (sdev->sdev_state == SDEV_DEL)
1139                 return -ENXIO;
1140         if (!get_device(&sdev->sdev_gendev))
1141                 return -ENXIO;
1142         /* We can fail this if we're doing SCSI operations
1143          * from module exit (like cache flush) */
1144         try_module_get(sdev->host->hostt->module);
1145
1146         return 0;
1147 }
1148 EXPORT_SYMBOL(scsi_device_get);
1149
1150 /**
1151  * scsi_device_put  -  release a reference to a scsi_device
1152  * @sdev:       device to release a reference on.
1153  *
1154  * Description: Release a reference to the scsi_device and decrements the use
1155  * count of the underlying LLDD module.  The device is freed once the last
1156  * user vanishes.
1157  */
1158 void scsi_device_put(struct scsi_device *sdev)
1159 {
1160 #ifdef CONFIG_MODULE_UNLOAD
1161         struct module *module = sdev->host->hostt->module;
1162
1163         /* The module refcount will be zero if scsi_device_get()
1164          * was called from a module removal routine */
1165         if (module && module_refcount(module) != 0)
1166                 module_put(module);
1167 #endif
1168         put_device(&sdev->sdev_gendev);
1169 }
1170 EXPORT_SYMBOL(scsi_device_put);
1171
1172 /* helper for shost_for_each_device, see that for documentation */
1173 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1174                                            struct scsi_device *prev)
1175 {
1176         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1177         struct scsi_device *next = NULL;
1178         unsigned long flags;
1179
1180         spin_lock_irqsave(shost->host_lock, flags);
1181         while (list->next != &shost->__devices) {
1182                 next = list_entry(list->next, struct scsi_device, siblings);
1183                 /* skip devices that we can't get a reference to */
1184                 if (!scsi_device_get(next))
1185                         break;
1186                 next = NULL;
1187                 list = list->next;
1188         }
1189         spin_unlock_irqrestore(shost->host_lock, flags);
1190
1191         if (prev)
1192                 scsi_device_put(prev);
1193         return next;
1194 }
1195 EXPORT_SYMBOL(__scsi_iterate_devices);
1196
1197 /**
1198  * starget_for_each_device  -  helper to walk all devices of a target
1199  * @starget:    target whose devices we want to iterate over.
1200  * @data:       Opaque passed to each function call.
1201  * @fn:         Function to call on each device
1202  *
1203  * This traverses over each device of @starget.  The devices have
1204  * a reference that must be released by scsi_host_put when breaking
1205  * out of the loop.
1206  */
1207 void starget_for_each_device(struct scsi_target *starget, void *data,
1208                      void (*fn)(struct scsi_device *, void *))
1209 {
1210         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1211         struct scsi_device *sdev;
1212
1213         shost_for_each_device(sdev, shost) {
1214                 if ((sdev->channel == starget->channel) &&
1215                     (sdev->id == starget->id))
1216                         fn(sdev, data);
1217         }
1218 }
1219 EXPORT_SYMBOL(starget_for_each_device);
1220
1221 /**
1222  * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1223  * @starget:    target whose devices we want to iterate over.
1224  * @data:       parameter for callback @fn()
1225  * @fn:         callback function that is invoked for each device
1226  *
1227  * This traverses over each device of @starget.  It does _not_
1228  * take a reference on the scsi_device, so the whole loop must be
1229  * protected by shost->host_lock.
1230  *
1231  * Note:  The only reason why drivers would want to use this is because
1232  * they need to access the device list in irq context.  Otherwise you
1233  * really want to use starget_for_each_device instead.
1234  **/
1235 void __starget_for_each_device(struct scsi_target *starget, void *data,
1236                                void (*fn)(struct scsi_device *, void *))
1237 {
1238         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1239         struct scsi_device *sdev;
1240
1241         __shost_for_each_device(sdev, shost) {
1242                 if ((sdev->channel == starget->channel) &&
1243                     (sdev->id == starget->id))
1244                         fn(sdev, data);
1245         }
1246 }
1247 EXPORT_SYMBOL(__starget_for_each_device);
1248
1249 /**
1250  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1251  * @starget:    SCSI target pointer
1252  * @lun:        SCSI Logical Unit Number
1253  *
1254  * Description: Looks up the scsi_device with the specified @lun for a given
1255  * @starget.  The returned scsi_device does not have an additional
1256  * reference.  You must hold the host's host_lock over this call and
1257  * any access to the returned scsi_device. A scsi_device in state
1258  * SDEV_DEL is skipped.
1259  *
1260  * Note:  The only reason why drivers should use this is because
1261  * they need to access the device list in irq context.  Otherwise you
1262  * really want to use scsi_device_lookup_by_target instead.
1263  **/
1264 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1265                                                    u64 lun)
1266 {
1267         struct scsi_device *sdev;
1268
1269         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1270                 if (sdev->sdev_state == SDEV_DEL)
1271                         continue;
1272                 if (sdev->lun ==lun)
1273                         return sdev;
1274         }
1275
1276         return NULL;
1277 }
1278 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1279
1280 /**
1281  * scsi_device_lookup_by_target - find a device given the target
1282  * @starget:    SCSI target pointer
1283  * @lun:        SCSI Logical Unit Number
1284  *
1285  * Description: Looks up the scsi_device with the specified @lun for a given
1286  * @starget.  The returned scsi_device has an additional reference that
1287  * needs to be released with scsi_device_put once you're done with it.
1288  **/
1289 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1290                                                  u64 lun)
1291 {
1292         struct scsi_device *sdev;
1293         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1294         unsigned long flags;
1295
1296         spin_lock_irqsave(shost->host_lock, flags);
1297         sdev = __scsi_device_lookup_by_target(starget, lun);
1298         if (sdev && scsi_device_get(sdev))
1299                 sdev = NULL;
1300         spin_unlock_irqrestore(shost->host_lock, flags);
1301
1302         return sdev;
1303 }
1304 EXPORT_SYMBOL(scsi_device_lookup_by_target);
1305
1306 /**
1307  * __scsi_device_lookup - find a device given the host (UNLOCKED)
1308  * @shost:      SCSI host pointer
1309  * @channel:    SCSI channel (zero if only one channel)
1310  * @id:         SCSI target number (physical unit number)
1311  * @lun:        SCSI Logical Unit Number
1312  *
1313  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1314  * for a given host. The returned scsi_device does not have an additional
1315  * reference.  You must hold the host's host_lock over this call and any access
1316  * to the returned scsi_device.
1317  *
1318  * Note:  The only reason why drivers would want to use this is because
1319  * they need to access the device list in irq context.  Otherwise you
1320  * really want to use scsi_device_lookup instead.
1321  **/
1322 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1323                 uint channel, uint id, u64 lun)
1324 {
1325         struct scsi_device *sdev;
1326
1327         list_for_each_entry(sdev, &shost->__devices, siblings) {
1328                 if (sdev->channel == channel && sdev->id == id &&
1329                                 sdev->lun ==lun)
1330                         return sdev;
1331         }
1332
1333         return NULL;
1334 }
1335 EXPORT_SYMBOL(__scsi_device_lookup);
1336
1337 /**
1338  * scsi_device_lookup - find a device given the host
1339  * @shost:      SCSI host pointer
1340  * @channel:    SCSI channel (zero if only one channel)
1341  * @id:         SCSI target number (physical unit number)
1342  * @lun:        SCSI Logical Unit Number
1343  *
1344  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1345  * for a given host.  The returned scsi_device has an additional reference that
1346  * needs to be released with scsi_device_put once you're done with it.
1347  **/
1348 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1349                 uint channel, uint id, u64 lun)
1350 {
1351         struct scsi_device *sdev;
1352         unsigned long flags;
1353
1354         spin_lock_irqsave(shost->host_lock, flags);
1355         sdev = __scsi_device_lookup(shost, channel, id, lun);
1356         if (sdev && scsi_device_get(sdev))
1357                 sdev = NULL;
1358         spin_unlock_irqrestore(shost->host_lock, flags);
1359
1360         return sdev;
1361 }
1362 EXPORT_SYMBOL(scsi_device_lookup);
1363
1364 MODULE_DESCRIPTION("SCSI core");
1365 MODULE_LICENSE("GPL");
1366
1367 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1368 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1369
1370 #ifdef CONFIG_SCSI_MQ_DEFAULT
1371 bool scsi_use_blk_mq = true;
1372 #else
1373 bool scsi_use_blk_mq = false;
1374 #endif
1375 module_param_named(use_blk_mq, scsi_use_blk_mq, bool, S_IWUSR | S_IRUGO);
1376
1377 static int __init init_scsi(void)
1378 {
1379         int error;
1380
1381         error = scsi_init_queue();
1382         if (error)
1383                 return error;
1384         error = scsi_init_procfs();
1385         if (error)
1386                 goto cleanup_queue;
1387         error = scsi_init_devinfo();
1388         if (error)
1389                 goto cleanup_procfs;
1390         error = scsi_init_hosts();
1391         if (error)
1392                 goto cleanup_devlist;
1393         error = scsi_init_sysctl();
1394         if (error)
1395                 goto cleanup_hosts;
1396         error = scsi_sysfs_register();
1397         if (error)
1398                 goto cleanup_sysctl;
1399
1400         scsi_netlink_init();
1401
1402         printk(KERN_NOTICE "SCSI subsystem initialized\n");
1403         return 0;
1404
1405 cleanup_sysctl:
1406         scsi_exit_sysctl();
1407 cleanup_hosts:
1408         scsi_exit_hosts();
1409 cleanup_devlist:
1410         scsi_exit_devinfo();
1411 cleanup_procfs:
1412         scsi_exit_procfs();
1413 cleanup_queue:
1414         scsi_exit_queue();
1415         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1416                -error);
1417         return error;
1418 }
1419
1420 static void __exit exit_scsi(void)
1421 {
1422         scsi_netlink_exit();
1423         scsi_sysfs_unregister();
1424         scsi_exit_sysctl();
1425         scsi_exit_hosts();
1426         scsi_exit_devinfo();
1427         scsi_exit_procfs();
1428         scsi_exit_queue();
1429         async_unregister_domain(&scsi_sd_probe_domain);
1430 }
1431
1432 subsys_initcall(init_scsi);
1433 module_exit(exit_scsi);