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