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