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