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