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