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
  58 #include <scsi/scsi.h>
  59 #include <scsi/scsi_cmnd.h>
  60 #include <scsi/scsi_dbg.h>
  61 #include <scsi/scsi_device.h>
  62 #include <scsi/scsi_driver.h>
  63 #include <scsi/scsi_eh.h>
  64 #include <scsi/scsi_host.h>
  65 #include <scsi/scsi_tcq.h>
  66
  67 #include "scsi_priv.h"
  68 #include "scsi_logging.h"
  69
  70 static void scsi_done(struct scsi_cmnd *cmd);
  71
  72 /*
  73  * Definitions and constants.
  74  */
  75
  76 #define MIN_RESET_DELAY (2*HZ)
  77
  78 /* Do not call reset on error if we just did a reset within 15 sec. */
  79 #define MIN_RESET_PERIOD (15*HZ)
  80
  81 /*
  82  * Note - the initial logging level can be set here to log events at boot time.
  83  * After the system is up, you may enable logging via the /proc interface.
  84  */
  85 unsigned int scsi_logging_level;
  86 #if defined(CONFIG_SCSI_LOGGING)
  87 EXPORT_SYMBOL(scsi_logging_level);
  88 #endif
  89
  90 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
  91  * You may not alter any existing entry (although adding new ones is
  92  * encouraged once assigned by ANSI/INCITS T10
  93  */
  94 static const char *const scsi_device_types[] = {
  95         "Direct-Access    ",
  96         "Sequential-Access",
  97         "Printer          ",
  98         "Processor        ",
  99         "WORM             ",
 100         "CD-ROM           ",
 101         "Scanner          ",
 102         "Optical Device   ",
 103         "Medium Changer   ",
 104         "Communications   ",
 105         "ASC IT8          ",
 106         "ASC IT8          ",
 107         "RAID             ",
 108         "Enclosure        ",
 109         "Direct-Access-RBC",
 110         "Optical card     ",
 111         "Bridge controller",
 112         "Object storage   ",
 113         "Automation/Drive ",
 114 };
 115
 116 /**
 117  * scsi_device_type - Return 17 char string indicating device type.
 118  * @type: type number to look up
 119  */
 120
 121 const char * scsi_device_type(unsigned type)
 122 {
 123         if (type == 0x1e)
 124                 return "Well-known LUN   ";
 125         if (type == 0x1f)
 126                 return "No Device        ";
 127         if (type >= ARRAY_SIZE(scsi_device_types))
 128                 return "Unknown          ";
 129         return scsi_device_types[type];
 130 }
 131
 132 EXPORT_SYMBOL(scsi_device_type);
 133
 134 struct scsi_host_cmd_pool {
 135         struct kmem_cache       *cmd_slab;
 136         struct kmem_cache       *sense_slab;
 137         unsigned int            users;
 138         char                    *cmd_name;
 139         char                    *sense_name;
 140         unsigned int            slab_flags;
 141         gfp_t                   gfp_mask;
 142 };
 143
 144 static struct scsi_host_cmd_pool scsi_cmd_pool = {
 145         .cmd_name       = "scsi_cmd_cache",
 146         .sense_name     = "scsi_sense_cache",
 147         .slab_flags     = SLAB_HWCACHE_ALIGN,
 148 };
 149
 150 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
 151         .cmd_name       = "scsi_cmd_cache(DMA)",
 152         .sense_name     = "scsi_sense_cache(DMA)",
 153         .slab_flags     = SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
 154         .gfp_mask       = __GFP_DMA,
 155 };
 156
 157 static DEFINE_MUTEX(host_cmd_pool_mutex);
 158
 159 /**
 160  * scsi_pool_alloc_command - internal function to get a fully allocated command
 161  * @pool:       slab pool to allocate the command from
 162  * @gfp_mask:   mask for the allocation
 163  *
 164  * Returns a fully allocated command (with the allied sense buffer) or
 165  * NULL on failure
 166  */
 167 static struct scsi_cmnd *
 168 scsi_pool_alloc_command(struct scsi_host_cmd_pool *pool, gfp_t gfp_mask)
 169 {
 170         struct scsi_cmnd *cmd;
 171
 172         cmd = kmem_cache_alloc(pool->cmd_slab, gfp_mask | pool->gfp_mask);
 173         if (!cmd)
 174                 return NULL;
 175
 176         memset(cmd, 0, sizeof(*cmd));
 177
 178         cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab,
 179                                              gfp_mask | pool->gfp_mask);
 180         if (!cmd->sense_buffer) {
 181                 kmem_cache_free(pool->cmd_slab, cmd);
 182                 return NULL;
 183         }
 184
 185         return cmd;
 186 }
 187
 188 /**
 189  * scsi_pool_free_command - internal function to release a command
 190  * @pool:       slab pool to allocate the command from
 191  * @cmd:        command to release
 192  *
 193  * the command must previously have been allocated by
 194  * scsi_pool_alloc_command.
 195  */
 196 static void
 197 scsi_pool_free_command(struct scsi_host_cmd_pool *pool,
 198                          struct scsi_cmnd *cmd)
 199 {
 200         if (cmd->prot_sdb)
 201                 kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb);
 202
 203         kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
 204         kmem_cache_free(pool->cmd_slab, cmd);
 205 }
 206
 207 /**
 208  * scsi_host_alloc_command - internal function to allocate command
 209  * @shost:      SCSI host whose pool to allocate from
 210  * @gfp_mask:   mask for the allocation
 211  *
 212  * Returns a fully allocated command with sense buffer and protection
 213  * data buffer (where applicable) or NULL on failure
 214  */
 215 static struct scsi_cmnd *
 216 scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 217 {
 218         struct scsi_cmnd *cmd;
 219
 220         cmd = scsi_pool_alloc_command(shost->cmd_pool, gfp_mask);
 221         if (!cmd)
 222                 return NULL;
 223
 224         if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
 225                 cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask);
 226
 227                 if (!cmd->prot_sdb) {
 228                         scsi_pool_free_command(shost->cmd_pool, cmd);
 229                         return NULL;
 230                 }
 231         }
 232
 233         return cmd;
 234 }
 235
 236 /**
 237  * __scsi_get_command - Allocate a struct scsi_cmnd
 238  * @shost: host to transmit command
 239  * @gfp_mask: allocation mask
 240  *
 241  * Description: allocate a struct scsi_cmd from host's slab, recycling from the
 242  *              host's free_list if necessary.
 243  */
 244 struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 245 {
 246         struct scsi_cmnd *cmd;
 247         unsigned char *buf;
 248
 249         cmd = scsi_host_alloc_command(shost, gfp_mask);
 250
 251         if (unlikely(!cmd)) {
 252                 unsigned long flags;
 253
 254                 spin_lock_irqsave(&shost->free_list_lock, flags);
 255                 if (likely(!list_empty(&shost->free_list))) {
 256                         cmd = list_entry(shost->free_list.next,
 257                                          struct scsi_cmnd, list);
 258                         list_del_init(&cmd->list);
 259                 }
 260                 spin_unlock_irqrestore(&shost->free_list_lock, flags);
 261
 262                 if (cmd) {
 263                         buf = cmd->sense_buffer;
 264                         memset(cmd, 0, sizeof(*cmd));
 265                         cmd->sense_buffer = buf;
 266                 }
 267         }
 268
 269         return cmd;
 270 }
 271 EXPORT_SYMBOL_GPL(__scsi_get_command);
 272
 273 /**
 274  * scsi_get_command - Allocate and setup a scsi command block
 275  * @dev: parent scsi device
 276  * @gfp_mask: allocator flags
 277  *
 278  * Returns:     The allocated scsi command structure.
 279  */
 280 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
 281 {
 282         struct scsi_cmnd *cmd;
 283
 284         /* Bail if we can't get a reference to the device */
 285         if (!get_device(&dev->sdev_gendev))
 286                 return NULL;
 287
 288         cmd = __scsi_get_command(dev->host, gfp_mask);
 289
 290         if (likely(cmd != NULL)) {
 291                 unsigned long flags;
 292
 293                 cmd->device = dev;
 294                 INIT_LIST_HEAD(&cmd->list);
 295                 spin_lock_irqsave(&dev->list_lock, flags);
 296                 list_add_tail(&cmd->list, &dev->cmd_list);
 297                 spin_unlock_irqrestore(&dev->list_lock, flags);
 298                 cmd->jiffies_at_alloc = jiffies;
 299         } else
 300                 put_device(&dev->sdev_gendev);
 301
 302         return cmd;
 303 }
 304 EXPORT_SYMBOL(scsi_get_command);
 305
 306 /**
 307  * __scsi_put_command - Free a struct scsi_cmnd
 308  * @shost: dev->host
 309  * @cmd: Command to free
 310  * @dev: parent scsi device
 311  */
 312 void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd,
 313                         struct device *dev)
 314 {
 315         unsigned long flags;
 316
 317         /* changing locks here, don't need to restore the irq state */
 318         spin_lock_irqsave(&shost->free_list_lock, flags);
 319         if (unlikely(list_empty(&shost->free_list))) {
 320                 list_add(&cmd->list, &shost->free_list);
 321                 cmd = NULL;
 322         }
 323         spin_unlock_irqrestore(&shost->free_list_lock, flags);
 324
 325         if (likely(cmd != NULL))
 326                 scsi_pool_free_command(shost->cmd_pool, cmd);
 327
 328         put_device(dev);
 329 }
 330 EXPORT_SYMBOL(__scsi_put_command);
 331
 332 /**
 333  * scsi_put_command - Free a scsi command block
 334  * @cmd: command block to free
 335  *
 336  * Returns:     Nothing.
 337  *
 338  * Notes:       The command must not belong to any lists.
 339  */
 340 void scsi_put_command(struct scsi_cmnd *cmd)
 341 {
 342         struct scsi_device *sdev = cmd->device;
 343         unsigned long flags;
 344
 345         /* serious error if the command hasn't come from a device list */
 346         spin_lock_irqsave(&cmd->device->list_lock, flags);
 347         BUG_ON(list_empty(&cmd->list));
 348         list_del_init(&cmd->list);
 349         spin_unlock_irqrestore(&cmd->device->list_lock, flags);
 350
 351         __scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev);
 352 }
 353 EXPORT_SYMBOL(scsi_put_command);
 354
 355 static struct scsi_host_cmd_pool *scsi_get_host_cmd_pool(gfp_t gfp_mask)
 356 {
 357         struct scsi_host_cmd_pool *retval = NULL, *pool;
 358         /*
 359          * Select a command slab for this host and create it if not
 360          * yet existent.
 361          */
 362         mutex_lock(&host_cmd_pool_mutex);
 363         pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool :
 364                 &scsi_cmd_pool;
 365         if (!pool->users) {
 366                 pool->cmd_slab = kmem_cache_create(pool->cmd_name,
 367                                                    sizeof(struct scsi_cmnd), 0,
 368                                                    pool->slab_flags, NULL);
 369                 if (!pool->cmd_slab)
 370                         goto fail;
 371
 372                 pool->sense_slab = kmem_cache_create(pool->sense_name,
 373                                                      SCSI_SENSE_BUFFERSIZE, 0,
 374                                                      pool->slab_flags, NULL);
 375                 if (!pool->sense_slab) {
 376                         kmem_cache_destroy(pool->cmd_slab);
 377                         goto fail;
 378                 }
 379         }
 380
 381         pool->users++;
 382         retval = pool;
 383  fail:
 384         mutex_unlock(&host_cmd_pool_mutex);
 385         return retval;
 386 }
 387
 388 static void scsi_put_host_cmd_pool(gfp_t gfp_mask)
 389 {
 390         struct scsi_host_cmd_pool *pool;
 391
 392         mutex_lock(&host_cmd_pool_mutex);
 393         pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool :
 394                 &scsi_cmd_pool;
 395         /*
 396          * This may happen if a driver has a mismatched get and put
 397          * of the command pool; the driver should be implicated in
 398          * the stack trace
 399          */
 400         BUG_ON(pool->users == 0);
 401
 402         if (!--pool->users) {
 403                 kmem_cache_destroy(pool->cmd_slab);
 404                 kmem_cache_destroy(pool->sense_slab);
 405         }
 406         mutex_unlock(&host_cmd_pool_mutex);
 407 }
 408
 409 /**
 410  * scsi_allocate_command - get a fully allocated SCSI command
 411  * @gfp_mask:   allocation mask
 412  *
 413  * This function is for use outside of the normal host based pools.
 414  * It allocates the relevant command and takes an additional reference
 415  * on the pool it used.  This function *must* be paired with
 416  * scsi_free_command which also has the identical mask, otherwise the
 417  * free pool counts will eventually go wrong and you'll trigger a bug.
 418  *
 419  * This function should *only* be used by drivers that need a static
 420  * command allocation at start of day for internal functions.
 421  */
 422 struct scsi_cmnd *scsi_allocate_command(gfp_t gfp_mask)
 423 {
 424         struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
 425
 426         if (!pool)
 427                 return NULL;
 428
 429         return scsi_pool_alloc_command(pool, gfp_mask);
 430 }
 431 EXPORT_SYMBOL(scsi_allocate_command);
 432
 433 /**
 434  * scsi_free_command - free a command allocated by scsi_allocate_command
 435  * @gfp_mask:   mask used in the original allocation
 436  * @cmd:        command to free
 437  *
 438  * Note: using the original allocation mask is vital because that's
 439  * what determines which command pool we use to free the command.  Any
 440  * mismatch will cause the system to BUG eventually.
 441  */
 442 void scsi_free_command(gfp_t gfp_mask, struct scsi_cmnd *cmd)
 443 {
 444         struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
 445
 446         /*
 447          * this could trigger if the mask to scsi_allocate_command
 448          * doesn't match this mask.  Otherwise we're guaranteed that this
 449          * succeeds because scsi_allocate_command must have taken a reference
 450          * on the pool
 451          */
 452         BUG_ON(!pool);
 453
 454         scsi_pool_free_command(pool, cmd);
 455         /*
 456          * scsi_put_host_cmd_pool is called twice; once to release the
 457          * reference we took above, and once to release the reference
 458          * originally taken by scsi_allocate_command
 459          */
 460         scsi_put_host_cmd_pool(gfp_mask);
 461         scsi_put_host_cmd_pool(gfp_mask);
 462 }
 463 EXPORT_SYMBOL(scsi_free_command);
 464
 465 /**
 466  * scsi_setup_command_freelist - Setup the command freelist for a scsi host.
 467  * @shost: host to allocate the freelist for.
 468  *
 469  * Description: The command freelist protects against system-wide out of memory
 470  * deadlock by preallocating one SCSI command structure for each host, so the
 471  * system can always write to a swap file on a device associated with that host.
 472  *
 473  * Returns:     Nothing.
 474  */
 475 int scsi_setup_command_freelist(struct Scsi_Host *shost)
 476 {
 477         struct scsi_cmnd *cmd;
 478         const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL;
 479
 480         spin_lock_init(&shost->free_list_lock);
 481         INIT_LIST_HEAD(&shost->free_list);
 482
 483         shost->cmd_pool = scsi_get_host_cmd_pool(gfp_mask);
 484
 485         if (!shost->cmd_pool)
 486                 return -ENOMEM;
 487
 488         /*
 489          * Get one backup command for this host.
 490          */
 491         cmd = scsi_host_alloc_command(shost, gfp_mask);
 492         if (!cmd) {
 493                 scsi_put_host_cmd_pool(gfp_mask);
 494                 shost->cmd_pool = NULL;
 495                 return -ENOMEM;
 496         }
 497         list_add(&cmd->list, &shost->free_list);
 498         return 0;
 499 }
 500
 501 /**
 502  * scsi_destroy_command_freelist - Release the command freelist for a scsi host.
 503  * @shost: host whose freelist is going to be destroyed
 504  */
 505 void scsi_destroy_command_freelist(struct Scsi_Host *shost)
 506 {
 507         /*
 508          * If cmd_pool is NULL the free list was not initialized, so
 509          * do not attempt to release resources.
 510          */
 511         if (!shost->cmd_pool)
 512                 return;
 513
 514         while (!list_empty(&shost->free_list)) {
 515                 struct scsi_cmnd *cmd;
 516
 517                 cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
 518                 list_del_init(&cmd->list);
 519                 scsi_pool_free_command(shost->cmd_pool, cmd);
 520         }
 521         shost->cmd_pool = NULL;
 522         scsi_put_host_cmd_pool(shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL);
 523 }
 524
 525 #ifdef CONFIG_SCSI_LOGGING
 526 void scsi_log_send(struct scsi_cmnd *cmd)
 527 {
 528         unsigned int level;
 529
 530         /*
 531          * If ML QUEUE log level is greater than or equal to:
 532          *
 533          * 1: nothing (match completion)
 534          *
 535          * 2: log opcode + command of all commands
 536          *
 537          * 3: same as 2 plus dump cmd address
 538          *
 539          * 4: same as 3 plus dump extra junk
 540          */
 541         if (unlikely(scsi_logging_level)) {
 542                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
 543                                        SCSI_LOG_MLQUEUE_BITS);
 544                 if (level > 1) {
 545                         scmd_printk(KERN_INFO, cmd, "Send: ");
 546                         if (level > 2)
 547                                 printk("0x%p ", cmd);
 548                         printk("\n");
 549                         scsi_print_command(cmd);
 550                         if (level > 3) {
 551                                 printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
 552                                        " queuecommand 0x%p\n",
 553                                         scsi_sglist(cmd), scsi_bufflen(cmd),
 554                                         cmd->device->host->hostt->queuecommand);
 555
 556                         }
 557                 }
 558         }
 559 }
 560
 561 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
 562 {
 563         unsigned int level;
 564
 565         /*
 566          * If ML COMPLETE log level is greater than or equal to:
 567          *
 568          * 1: log disposition, result, opcode + command, and conditionally
 569          * sense data for failures or non SUCCESS dispositions.
 570          *
 571          * 2: same as 1 but for all command completions.
 572          *
 573          * 3: same as 2 plus dump cmd address
 574          *
 575          * 4: same as 3 plus dump extra junk
 576          */
 577         if (unlikely(scsi_logging_level)) {
 578                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
 579                                        SCSI_LOG_MLCOMPLETE_BITS);
 580                 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
 581                     (level > 1)) {
 582                         scmd_printk(KERN_INFO, cmd, "Done: ");
 583                         if (level > 2)
 584                                 printk("0x%p ", cmd);
 585                         /*
 586                          * Dump truncated values, so we usually fit within
 587                          * 80 chars.
 588                          */
 589                         switch (disposition) {
 590                         case SUCCESS:
 591                                 printk("SUCCESS\n");
 592                                 break;
 593                         case NEEDS_RETRY:
 594                                 printk("RETRY\n");
 595                                 break;
 596                         case ADD_TO_MLQUEUE:
 597                                 printk("MLQUEUE\n");
 598                                 break;
 599                         case FAILED:
 600                                 printk("FAILED\n");
 601                                 break;
 602                         case TIMEOUT_ERROR:
 603                                 /*
 604                                  * If called via scsi_times_out.
 605                                  */
 606                                 printk("TIMEOUT\n");
 607                                 break;
 608                         default:
 609                                 printk("UNKNOWN\n");
 610                         }
 611                         scsi_print_result(cmd);
 612                         scsi_print_command(cmd);
 613                         if (status_byte(cmd->result) & CHECK_CONDITION)
 614                                 scsi_print_sense("", cmd);
 615                         if (level > 3)
 616                                 scmd_printk(KERN_INFO, cmd,
 617                                             "scsi host busy %d failed %d\n",
 618                                             cmd->device->host->host_busy,
 619                                             cmd->device->host->host_failed);
 620                 }
 621         }
 622 }
 623 #endif
 624
 625 /**
 626  * scsi_cmd_get_serial - Assign a serial number to a command
 627  * @host: the scsi host
 628  * @cmd: command to assign serial number to
 629  *
 630  * Description: a serial number identifies a request for error recovery
 631  * and debugging purposes.  Protected by the Host_Lock of host.
 632  */
 633 static inline void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 634 {
 635         cmd->serial_number = host->cmd_serial_number++;
 636         if (cmd->serial_number == 0)
 637                 cmd->serial_number = host->cmd_serial_number++;
 638 }
 639
 640 /**
 641  * scsi_dispatch_command - Dispatch a command to the low-level driver.
 642  * @cmd: command block we are dispatching.
 643  *
 644  * Return: nonzero return request was rejected and device's queue needs to be
 645  * plugged.
 646  */
 647 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
 648 {
 649         struct Scsi_Host *host = cmd->device->host;
 650         unsigned long flags = 0;
 651         unsigned long timeout;
 652         int rtn = 0;
 653
 654         /*
 655          * We will use a queued command if possible, otherwise we will
 656          * emulate the queuing and calling of completion function ourselves.
 657          */
 658         atomic_inc(&cmd->device->iorequest_cnt);
 659
 660         /* check if the device is still usable */
 661         if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
 662                 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
 663                  * returns an immediate error upwards, and signals
 664                  * that the device is no longer present */
 665                 cmd->result = DID_NO_CONNECT << 16;
 666                 scsi_done(cmd);
 667                 /* return 0 (because the command has been processed) */
 668                 goto out;
 669         }
 670
 671         /* Check to see if the scsi lld put this device into state SDEV_BLOCK. */
 672         if (unlikely(cmd->device->sdev_state == SDEV_BLOCK)) {
 673                 /*
 674                  * in SDEV_BLOCK, the command is just put back on the device
 675                  * queue.  The suspend state has already blocked the queue so
 676                  * future requests should not occur until the device
 677                  * transitions out of the suspend state.
 678                  */
 679
 680                 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
 681
 682                 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
 683
 684                 /*
 685                  * NOTE: rtn is still zero here because we don't need the
 686                  * queue to be plugged on return (it's already stopped)
 687                  */
 688                 goto out;
 689         }
 690
 691         /*
 692          * If SCSI-2 or lower, store the LUN value in cmnd.
 693          */
 694         if (cmd->device->scsi_level <= SCSI_2 &&
 695             cmd->device->scsi_level != SCSI_UNKNOWN) {
 696                 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
 697                                (cmd->device->lun << 5 & 0xe0);
 698         }
 699
 700         /*
 701          * We will wait MIN_RESET_DELAY clock ticks after the last reset so
 702          * we can avoid the drive not being ready.
 703          */
 704         timeout = host->last_reset + MIN_RESET_DELAY;
 705
 706         if (host->resetting && time_before(jiffies, timeout)) {
 707                 int ticks_remaining = timeout - jiffies;
 708                 /*
 709                  * NOTE: This may be executed from within an interrupt
 710                  * handler!  This is bad, but for now, it'll do.  The irq
 711                  * level of the interrupt handler has been masked out by the
 712                  * platform dependent interrupt handling code already, so the
 713                  * sti() here will not cause another call to the SCSI host's
 714                  * interrupt handler (assuming there is one irq-level per
 715                  * host).
 716                  */
 717                 while (--ticks_remaining >= 0)
 718                         mdelay(1 + 999 / HZ);
 719                 host->resetting = 0;
 720         }
 721
 722         scsi_log_send(cmd);
 723
 724         /*
 725          * Before we queue this command, check if the command
 726          * length exceeds what the host adapter can handle.
 727          */
 728         if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
 729                 SCSI_LOG_MLQUEUE(3,
 730                         printk("queuecommand : command too long. "
 731                                "cdb_size=%d host->max_cmd_len=%d\n",
 732                                cmd->cmd_len, cmd->device->host->max_cmd_len));
 733                 cmd->result = (DID_ABORT << 16);
 734
 735                 scsi_done(cmd);
 736                 goto out;
 737         }
 738
 739         spin_lock_irqsave(host->host_lock, flags);
 740         /*
 741          * AK: unlikely race here: for some reason the timer could
 742          * expire before the serial number is set up below.
 743          *
 744          * TODO: kill serial or move to blk layer
 745          */
 746         scsi_cmd_get_serial(host, cmd);
 747
 748         if (unlikely(host->shost_state == SHOST_DEL)) {
 749                 cmd->result = (DID_NO_CONNECT << 16);
 750                 scsi_done(cmd);
 751         } else {
 752                 rtn = host->hostt->queuecommand(cmd, scsi_done);
 753         }
 754         spin_unlock_irqrestore(host->host_lock, flags);
 755         if (rtn) {
 756                 scsi_queue_insert(cmd, (rtn == SCSI_MLQUEUE_DEVICE_BUSY) ?
 757                                                 rtn : SCSI_MLQUEUE_HOST_BUSY);
 758                 SCSI_LOG_MLQUEUE(3,
 759                     printk("queuecommand : request rejected\n"));
 760         }
 761
 762  out:
 763         SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
 764         return rtn;
 765 }
 766
 767 /**
 768  * scsi_done - Enqueue the finished SCSI command into the done queue.
 769  * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
 770  * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
 771  *
 772  * Description: This function is the mid-level's (SCSI Core) interrupt routine,
 773  * which regains ownership of the SCSI command (de facto) from a LLDD, and
 774  * enqueues the command to the done queue for further processing.
 775  *
 776  * This is the producer of the done queue who enqueues at the tail.
 777  *
 778  * This function is interrupt context safe.
 779  */
 780 static void scsi_done(struct scsi_cmnd *cmd)
 781 {
 782         blk_complete_request(cmd->request);
 783 }
 784
 785 /* Move this to a header if it becomes more generally useful */
 786 static struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)
 787 {
 788         return *(struct scsi_driver **)cmd->request->rq_disk->private_data;
 789 }
 790
 791 /**
 792  * scsi_finish_command - cleanup and pass command back to upper layer
 793  * @cmd: the command
 794  *
 795  * Description: Pass command off to upper layer for finishing of I/O
 796  *              request, waking processes that are waiting on results,
 797  *              etc.
 798  */
 799 void scsi_finish_command(struct scsi_cmnd *cmd)
 800 {
 801         struct scsi_device *sdev = cmd->device;
 802         struct Scsi_Host *shost = sdev->host;
 803         struct scsi_driver *drv;
 804         unsigned int good_bytes;
 805
 806         scsi_device_unbusy(sdev);
 807
 808         /*
 809          * Clear the flags which say that the device/host is no longer
 810          * capable of accepting new commands.  These are set in scsi_queue.c
 811          * for both the queue full condition on a device, and for a
 812          * host full condition on the host.
 813          *
 814          * XXX(hch): What about locking?
 815          */
 816         shost->host_blocked = 0;
 817         sdev->device_blocked = 0;
 818
 819         /*
 820          * If we have valid sense information, then some kind of recovery
 821          * must have taken place.  Make a note of this.
 822          */
 823         if (SCSI_SENSE_VALID(cmd))
 824                 cmd->result |= (DRIVER_SENSE << 24);
 825
 826         SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
 827                                 "Notifying upper driver of completion "
 828                                 "(result %x)\n", cmd->result));
 829
 830         good_bytes = scsi_bufflen(cmd);
 831         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
 832                 int old_good_bytes = good_bytes;
 833                 drv = scsi_cmd_to_driver(cmd);
 834                 if (drv->done)
 835                         good_bytes = drv->done(cmd);
 836                 /*
 837                  * USB may not give sense identifying bad sector and
 838                  * simply return a residue instead, so subtract off the
 839                  * residue if drv->done() error processing indicates no
 840                  * change to the completion length.
 841                  */
 842                 if (good_bytes == old_good_bytes)
 843                         good_bytes -= scsi_get_resid(cmd);
 844         }
 845         scsi_io_completion(cmd, good_bytes);
 846 }
 847 EXPORT_SYMBOL(scsi_finish_command);
 848
 849 /**
 850  * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
 851  * @sdev: SCSI Device in question
 852  * @tagged: Do we use tagged queueing (non-0) or do we treat
 853  *          this device as an untagged device (0)
 854  * @tags: Number of tags allowed if tagged queueing enabled,
 855  *        or number of commands the low level driver can
 856  *        queue up in non-tagged mode (as per cmd_per_lun).
 857  *
 858  * Returns:     Nothing
 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 depending on whether or not the device is
 864  *              currently active and whether or not it even has the
 865  *              command blocks built yet.
 866  */
 867 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
 868 {
 869         unsigned long flags;
 870
 871         /*
 872          * refuse to set tagged depth to an unworkable size
 873          */
 874         if (tags <= 0)
 875                 return;
 876
 877         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 878
 879         /*
 880          * Check to see if the queue is managed by the block layer.
 881          * If it is, and we fail to adjust the depth, exit.
 882          *
 883          * Do not resize the tag map if it is a host wide share bqt,
 884          * because the size should be the hosts's can_queue. If there
 885          * is more IO than the LLD's can_queue (so there are not enuogh
 886          * tags) request_fn's host queue ready check will handle it.
 887          */
 888         if (!sdev->host->bqt) {
 889                 if (blk_queue_tagged(sdev->request_queue) &&
 890                     blk_queue_resize_tags(sdev->request_queue, tags) != 0)
 891                         goto out;
 892         }
 893
 894         sdev->queue_depth = tags;
 895         switch (tagged) {
 896                 case MSG_ORDERED_TAG:
 897                         sdev->ordered_tags = 1;
 898                         sdev->simple_tags = 1;
 899                         break;
 900                 case MSG_SIMPLE_TAG:
 901                         sdev->ordered_tags = 0;
 902                         sdev->simple_tags = 1;
 903                         break;
 904                 default:
 905                         sdev_printk(KERN_WARNING, sdev,
 906                                     "scsi_adjust_queue_depth, bad queue type, "
 907                                     "disabled\n");
 908                 case 0:
 909                         sdev->ordered_tags = sdev->simple_tags = 0;
 910                         sdev->queue_depth = tags;
 911                         break;
 912         }
 913  out:
 914         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 915 }
 916 EXPORT_SYMBOL(scsi_adjust_queue_depth);
 917
 918 /**
 919  * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
 920  * @sdev: SCSI Device in question
 921  * @depth: Current number of outstanding SCSI commands on this device,
 922  *         not counting the one returned as QUEUE_FULL.
 923  *
 924  * Description: This function will track successive QUEUE_FULL events on a
 925  *              specific SCSI device to determine if and when there is a
 926  *              need to adjust the queue depth on the device.
 927  *
 928  * Returns:     0 - No change needed, >0 - Adjust queue depth to this new depth,
 929  *              -1 - Drop back to untagged operation using host->cmd_per_lun
 930  *                      as the untagged command depth
 931  *
 932  * Lock Status: None held on entry
 933  *
 934  * Notes:       Low level drivers may call this at any time and we will do
 935  *              "The Right Thing."  We are interrupt context safe.
 936  */
 937 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 938 {
 939         if ((jiffies >> 4) == sdev->last_queue_full_time)
 940                 return 0;
 941
 942         sdev->last_queue_full_time = (jiffies >> 4);
 943         if (sdev->last_queue_full_depth != depth) {
 944                 sdev->last_queue_full_count = 1;
 945                 sdev->last_queue_full_depth = depth;
 946         } else {
 947                 sdev->last_queue_full_count++;
 948         }
 949
 950         if (sdev->last_queue_full_count <= 10)
 951                 return 0;
 952         if (sdev->last_queue_full_depth < 8) {
 953                 /* Drop back to untagged */
 954                 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 955                 return -1;
 956         }
 957
 958         if (sdev->ordered_tags)
 959                 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
 960         else
 961                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
 962         return depth;
 963 }
 964 EXPORT_SYMBOL(scsi_track_queue_full);
 965
 966 /**
 967  * scsi_device_get  -  get an additional reference to a scsi_device
 968  * @sdev:       device to get a reference to
 969  *
 970  * Description: Gets a reference to the scsi_device and increments the use count
 971  * of the underlying LLDD module.  You must hold host_lock of the
 972  * parent Scsi_Host or already have a reference when calling this.
 973  */
 974 int scsi_device_get(struct scsi_device *sdev)
 975 {
 976         if (sdev->sdev_state == SDEV_DEL)
 977                 return -ENXIO;
 978         if (!get_device(&sdev->sdev_gendev))
 979                 return -ENXIO;
 980         /* We can fail this if we're doing SCSI operations
 981          * from module exit (like cache flush) */
 982         try_module_get(sdev->host->hostt->module);
 983
 984         return 0;
 985 }
 986 EXPORT_SYMBOL(scsi_device_get);
 987
 988 /**
 989  * scsi_device_put  -  release a reference to a scsi_device
 990  * @sdev:       device to release a reference on.
 991  *
 992  * Description: Release a reference to the scsi_device and decrements the use
 993  * count of the underlying LLDD module.  The device is freed once the last
 994  * user vanishes.
 995  */
 996 void scsi_device_put(struct scsi_device *sdev)
 997 {
 998 #ifdef CONFIG_MODULE_UNLOAD
 999         struct module *module = sdev->host->hostt->module;
1000
1001         /* The module refcount will be zero if scsi_device_get()
1002          * was called from a module removal routine */
1003         if (module && module_refcount(module) != 0)
1004                 module_put(module);
1005 #endif
1006         put_device(&sdev->sdev_gendev);
1007 }
1008 EXPORT_SYMBOL(scsi_device_put);
1009
1010 /* helper for shost_for_each_device, see that for documentation */
1011 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1012                                            struct scsi_device *prev)
1013 {
1014         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1015         struct scsi_device *next = NULL;
1016         unsigned long flags;
1017
1018         spin_lock_irqsave(shost->host_lock, flags);
1019         while (list->next != &shost->__devices) {
1020                 next = list_entry(list->next, struct scsi_device, siblings);
1021                 /* skip devices that we can't get a reference to */
1022                 if (!scsi_device_get(next))
1023                         break;
1024                 next = NULL;
1025                 list = list->next;
1026         }
1027         spin_unlock_irqrestore(shost->host_lock, flags);
1028
1029         if (prev)
1030                 scsi_device_put(prev);
1031         return next;
1032 }
1033 EXPORT_SYMBOL(__scsi_iterate_devices);
1034
1035 /**
1036  * starget_for_each_device  -  helper to walk all devices of a target
1037  * @starget:    target whose devices we want to iterate over.
1038  * @data:       Opaque passed to each function call.
1039  * @fn:         Function to call on each device
1040  *
1041  * This traverses over each device of @starget.  The devices have
1042  * a reference that must be released by scsi_host_put when breaking
1043  * out of the loop.
1044  */
1045 void starget_for_each_device(struct scsi_target *starget, void *data,
1046                      void (*fn)(struct scsi_device *, void *))
1047 {
1048         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1049         struct scsi_device *sdev;
1050
1051         shost_for_each_device(sdev, shost) {
1052                 if ((sdev->channel == starget->channel) &&
1053                     (sdev->id == starget->id))
1054                         fn(sdev, data);
1055         }
1056 }
1057 EXPORT_SYMBOL(starget_for_each_device);
1058
1059 /**
1060  * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1061  * @starget:    target whose devices we want to iterate over.
1062  * @data:       parameter for callback @fn()
1063  * @fn:         callback function that is invoked for each device
1064  *
1065  * This traverses over each device of @starget.  It does _not_
1066  * take a reference on the scsi_device, so the whole loop must be
1067  * protected by shost->host_lock.
1068  *
1069  * Note:  The only reason why drivers would want to use this is because
1070  * they need to access the device list in irq context.  Otherwise you
1071  * really want to use starget_for_each_device instead.
1072  **/
1073 void __starget_for_each_device(struct scsi_target *starget, void *data,
1074                                void (*fn)(struct scsi_device *, void *))
1075 {
1076         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1077         struct scsi_device *sdev;
1078
1079         __shost_for_each_device(sdev, shost) {
1080                 if ((sdev->channel == starget->channel) &&
1081                     (sdev->id == starget->id))
1082                         fn(sdev, data);
1083         }
1084 }
1085 EXPORT_SYMBOL(__starget_for_each_device);
1086
1087 /**
1088  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1089  * @starget:    SCSI target pointer
1090  * @lun:        SCSI Logical Unit Number
1091  *
1092  * Description: Looks up the scsi_device with the specified @lun for a given
1093  * @starget.  The returned scsi_device does not have an additional
1094  * reference.  You must hold the host's host_lock over this call and
1095  * any access to the returned scsi_device.
1096  *
1097  * Note:  The only reason why drivers should use this is because
1098  * they need to access the device list in irq context.  Otherwise you
1099  * really want to use scsi_device_lookup_by_target instead.
1100  **/
1101 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1102                                                    uint lun)
1103 {
1104         struct scsi_device *sdev;
1105
1106         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1107                 if (sdev->lun ==lun)
1108                         return sdev;
1109         }
1110
1111         return NULL;
1112 }
1113 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1114
1115 /**
1116  * scsi_device_lookup_by_target - find a device given the target
1117  * @starget:    SCSI target pointer
1118  * @lun:        SCSI Logical Unit Number
1119  *
1120  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1121  * for a given host.  The returned scsi_device has an additional reference that
1122  * needs to be released with scsi_device_put once you're done with it.
1123  **/
1124 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1125                                                  uint lun)
1126 {
1127         struct scsi_device *sdev;
1128         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1129         unsigned long flags;
1130
1131         spin_lock_irqsave(shost->host_lock, flags);
1132         sdev = __scsi_device_lookup_by_target(starget, lun);
1133         if (sdev && scsi_device_get(sdev))
1134                 sdev = NULL;
1135         spin_unlock_irqrestore(shost->host_lock, flags);
1136
1137         return sdev;
1138 }
1139 EXPORT_SYMBOL(scsi_device_lookup_by_target);
1140
1141 /**
1142  * __scsi_device_lookup - find a device given the host (UNLOCKED)
1143  * @shost:      SCSI host pointer
1144  * @channel:    SCSI channel (zero if only one channel)
1145  * @id:         SCSI target number (physical unit number)
1146  * @lun:        SCSI Logical Unit Number
1147  *
1148  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1149  * for a given host. The returned scsi_device does not have an additional
1150  * reference.  You must hold the host's host_lock over this call and any access
1151  * to the returned scsi_device.
1152  *
1153  * Note:  The only reason why drivers would want to use this is because
1154  * they need to access the device list in irq context.  Otherwise you
1155  * really want to use scsi_device_lookup instead.
1156  **/
1157 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1158                 uint channel, uint id, uint lun)
1159 {
1160         struct scsi_device *sdev;
1161
1162         list_for_each_entry(sdev, &shost->__devices, siblings) {
1163                 if (sdev->channel == channel && sdev->id == id &&
1164                                 sdev->lun ==lun)
1165                         return sdev;
1166         }
1167
1168         return NULL;
1169 }
1170 EXPORT_SYMBOL(__scsi_device_lookup);
1171
1172 /**
1173  * scsi_device_lookup - find a device given the host
1174  * @shost:      SCSI host pointer
1175  * @channel:    SCSI channel (zero if only one channel)
1176  * @id:         SCSI target number (physical unit number)
1177  * @lun:        SCSI Logical Unit Number
1178  *
1179  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1180  * for a given host.  The returned scsi_device has an additional reference that
1181  * needs to be released with scsi_device_put once you're done with it.
1182  **/
1183 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1184                 uint channel, uint id, uint lun)
1185 {
1186         struct scsi_device *sdev;
1187         unsigned long flags;
1188
1189         spin_lock_irqsave(shost->host_lock, flags);
1190         sdev = __scsi_device_lookup(shost, channel, id, lun);
1191         if (sdev && scsi_device_get(sdev))
1192                 sdev = NULL;
1193         spin_unlock_irqrestore(shost->host_lock, flags);
1194
1195         return sdev;
1196 }
1197 EXPORT_SYMBOL(scsi_device_lookup);
1198
1199 MODULE_DESCRIPTION("SCSI core");
1200 MODULE_LICENSE("GPL");
1201
1202 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1203 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1204
1205 static int __init init_scsi(void)
1206 {
1207         int error;
1208
1209         error = scsi_init_queue();
1210         if (error)
1211                 return error;
1212         error = scsi_init_procfs();
1213         if (error)
1214                 goto cleanup_queue;
1215         error = scsi_init_devinfo();
1216         if (error)
1217                 goto cleanup_procfs;
1218         error = scsi_init_hosts();
1219         if (error)
1220                 goto cleanup_devlist;
1221         error = scsi_init_sysctl();
1222         if (error)
1223                 goto cleanup_hosts;
1224         error = scsi_sysfs_register();
1225         if (error)
1226                 goto cleanup_sysctl;
1227
1228         scsi_netlink_init();
1229
1230         printk(KERN_NOTICE "SCSI subsystem initialized\n");
1231         return 0;
1232
1233 cleanup_sysctl:
1234         scsi_exit_sysctl();
1235 cleanup_hosts:
1236         scsi_exit_hosts();
1237 cleanup_devlist:
1238         scsi_exit_devinfo();
1239 cleanup_procfs:
1240         scsi_exit_procfs();
1241 cleanup_queue:
1242         scsi_exit_queue();
1243         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1244                -error);
1245         return error;
1246 }
1247
1248 static void __exit exit_scsi(void)
1249 {
1250         scsi_netlink_exit();
1251         scsi_sysfs_unregister();
1252         scsi_exit_sysctl();
1253         scsi_exit_hosts();
1254         scsi_exit_devinfo();
1255         scsi_exit_procfs();
1256         scsi_exit_queue();
1257 }
1258
1259 subsys_initcall(init_scsi);
1260 module_exit(exit_scsi);