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 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);
 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
 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                         scmd_printk(KERN_INFO, cmd, "Send: ");
 365                         if (level > 2)
 366                                 printk("0x%p ", cmd);
 367                         printk("\n");
 368                         scsi_print_command(cmd);
 369                         if (level > 3) {
 370                                 printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
 371                                        " queuecommand 0x%p\n",
 372                                         scsi_sglist(cmd), scsi_bufflen(cmd),
 373                                         cmd->device->host->hostt->queuecommand);
 374
 375                         }
 376                 }
 377         }
 378 }
 379
 380 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
 381 {
 382         unsigned int level;
 383
 384         /*
 385          * If ML COMPLETE log level is greater than or equal to:
 386          *
 387          * 1: log disposition, result, opcode + command, and conditionally
 388          * sense data for failures or non SUCCESS dispositions.
 389          *
 390          * 2: same as 1 but for all command completions.
 391          *
 392          * 3: same as 2 plus dump cmd address
 393          *
 394          * 4: same as 3 plus dump extra junk
 395          */
 396         if (unlikely(scsi_logging_level)) {
 397                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
 398                                        SCSI_LOG_MLCOMPLETE_BITS);
 399                 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
 400                     (level > 1)) {
 401                         scmd_printk(KERN_INFO, cmd, "Done: ");
 402                         if (level > 2)
 403                                 printk("0x%p ", cmd);
 404                         /*
 405                          * Dump truncated values, so we usually fit within
 406                          * 80 chars.
 407                          */
 408                         switch (disposition) {
 409                         case SUCCESS:
 410                                 printk("SUCCESS\n");
 411                                 break;
 412                         case NEEDS_RETRY:
 413                                 printk("RETRY\n");
 414                                 break;
 415                         case ADD_TO_MLQUEUE:
 416                                 printk("MLQUEUE\n");
 417                                 break;
 418                         case FAILED:
 419                                 printk("FAILED\n");
 420                                 break;
 421                         case TIMEOUT_ERROR:
 422                                 /*
 423                                  * If called via scsi_times_out.
 424                                  */
 425                                 printk("TIMEOUT\n");
 426                                 break;
 427                         default:
 428                                 printk("UNKNOWN\n");
 429                         }
 430                         scsi_print_result(cmd);
 431                         scsi_print_command(cmd);
 432                         if (status_byte(cmd->result) & CHECK_CONDITION)
 433                                 scsi_print_sense("", cmd);
 434                         if (level > 3)
 435                                 scmd_printk(KERN_INFO, cmd,
 436                                             "scsi host busy %d failed %d\n",
 437                                             cmd->device->host->host_busy,
 438                                             cmd->device->host->host_failed);
 439                 }
 440         }
 441 }
 442 #endif
 443
 444 /*
 445  * Assign a serial number to the request for error recovery
 446  * and debugging purposes.  Protected by the Host_Lock of host.
 447  */
 448 static inline void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 449 {
 450         cmd->serial_number = host->cmd_serial_number++;
 451         if (cmd->serial_number == 0)
 452                 cmd->serial_number = host->cmd_serial_number++;
 453 }
 454
 455 /*
 456  * Function:    scsi_dispatch_command
 457  *
 458  * Purpose:     Dispatch a command to the low-level driver.
 459  *
 460  * Arguments:   cmd - command block we are dispatching.
 461  *
 462  * Notes:
 463  */
 464 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
 465 {
 466         struct Scsi_Host *host = cmd->device->host;
 467         unsigned long flags = 0;
 468         unsigned long timeout;
 469         int rtn = 0;
 470
 471         /* check if the device is still usable */
 472         if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
 473                 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
 474                  * returns an immediate error upwards, and signals
 475                  * that the device is no longer present */
 476                 cmd->result = DID_NO_CONNECT << 16;
 477                 atomic_inc(&cmd->device->iorequest_cnt);
 478                 __scsi_done(cmd);
 479                 /* return 0 (because the command has been processed) */
 480                 goto out;
 481         }
 482
 483         /* Check to see if the scsi lld put this device into state SDEV_BLOCK. */
 484         if (unlikely(cmd->device->sdev_state == SDEV_BLOCK)) {
 485                 /*
 486                  * in SDEV_BLOCK, the command is just put back on the device
 487                  * queue.  The suspend state has already blocked the queue so
 488                  * future requests should not occur until the device
 489                  * transitions out of the suspend state.
 490                  */
 491                 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
 492
 493                 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
 494
 495                 /*
 496                  * NOTE: rtn is still zero here because we don't need the
 497                  * queue to be plugged on return (it's already stopped)
 498                  */
 499                 goto out;
 500         }
 501
 502         /*
 503          * If SCSI-2 or lower, store the LUN value in cmnd.
 504          */
 505         if (cmd->device->scsi_level <= SCSI_2 &&
 506             cmd->device->scsi_level != SCSI_UNKNOWN) {
 507                 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
 508                                (cmd->device->lun << 5 & 0xe0);
 509         }
 510
 511         /*
 512          * We will wait MIN_RESET_DELAY clock ticks after the last reset so
 513          * we can avoid the drive not being ready.
 514          */
 515         timeout = host->last_reset + MIN_RESET_DELAY;
 516
 517         if (host->resetting && time_before(jiffies, timeout)) {
 518                 int ticks_remaining = timeout - jiffies;
 519                 /*
 520                  * NOTE: This may be executed from within an interrupt
 521                  * handler!  This is bad, but for now, it'll do.  The irq
 522                  * level of the interrupt handler has been masked out by the
 523                  * platform dependent interrupt handling code already, so the
 524                  * sti() here will not cause another call to the SCSI host's
 525                  * interrupt handler (assuming there is one irq-level per
 526                  * host).
 527                  */
 528                 while (--ticks_remaining >= 0)
 529                         mdelay(1 + 999 / HZ);
 530                 host->resetting = 0;
 531         }
 532
 533         /*
 534          * AK: unlikely race here: for some reason the timer could
 535          * expire before the serial number is set up below.
 536          */
 537         scsi_add_timer(cmd, cmd->timeout_per_command, scsi_times_out);
 538
 539         scsi_log_send(cmd);
 540
 541         /*
 542          * We will use a queued command if possible, otherwise we will
 543          * emulate the queuing and calling of completion function ourselves.
 544          */
 545         atomic_inc(&cmd->device->iorequest_cnt);
 546
 547         /*
 548          * Before we queue this command, check if the command
 549          * length exceeds what the host adapter can handle.
 550          */
 551         if (CDB_SIZE(cmd) > cmd->device->host->max_cmd_len) {
 552                 SCSI_LOG_MLQUEUE(3,
 553                                 printk("queuecommand : command too long.\n"));
 554                 cmd->result = (DID_ABORT << 16);
 555
 556                 scsi_done(cmd);
 557                 goto out;
 558         }
 559
 560         spin_lock_irqsave(host->host_lock, flags);
 561         scsi_cmd_get_serial(host, cmd);
 562
 563         if (unlikely(host->shost_state == SHOST_DEL)) {
 564                 cmd->result = (DID_NO_CONNECT << 16);
 565                 scsi_done(cmd);
 566         } else {
 567                 rtn = host->hostt->queuecommand(cmd, scsi_done);
 568         }
 569         spin_unlock_irqrestore(host->host_lock, flags);
 570         if (rtn) {
 571                 if (scsi_delete_timer(cmd)) {
 572                         atomic_inc(&cmd->device->iodone_cnt);
 573                         scsi_queue_insert(cmd,
 574                                           (rtn == SCSI_MLQUEUE_DEVICE_BUSY) ?
 575                                           rtn : SCSI_MLQUEUE_HOST_BUSY);
 576                 }
 577                 SCSI_LOG_MLQUEUE(3,
 578                     printk("queuecommand : request rejected\n"));
 579         }
 580
 581  out:
 582         SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
 583         return rtn;
 584 }
 585
 586 /**
 587  * scsi_req_abort_cmd -- Request command recovery for the specified command
 588  * cmd: pointer to the SCSI command of interest
 589  *
 590  * This function requests that SCSI Core start recovery for the
 591  * command by deleting the timer and adding the command to the eh
 592  * queue.  It can be called by either LLDDs or SCSI Core.  LLDDs who
 593  * implement their own error recovery MAY ignore the timeout event if
 594  * they generated scsi_req_abort_cmd.
 595  */
 596 void scsi_req_abort_cmd(struct scsi_cmnd *cmd)
 597 {
 598         if (!scsi_delete_timer(cmd))
 599                 return;
 600         scsi_times_out(cmd);
 601 }
 602 EXPORT_SYMBOL(scsi_req_abort_cmd);
 603
 604 /**
 605  * scsi_done - Enqueue the finished SCSI command into the done queue.
 606  * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
 607  * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
 608  *
 609  * This function is the mid-level's (SCSI Core) interrupt routine, which
 610  * regains ownership of the SCSI command (de facto) from a LLDD, and enqueues
 611  * the command to the done queue for further processing.
 612  *
 613  * This is the producer of the done queue who enqueues at the tail.
 614  *
 615  * This function is interrupt context safe.
 616  */
 617 static void scsi_done(struct scsi_cmnd *cmd)
 618 {
 619         /*
 620          * We don't have to worry about this one timing out any more.
 621          * If we are unable to remove the timer, then the command
 622          * has already timed out.  In which case, we have no choice but to
 623          * let the timeout function run, as we have no idea where in fact
 624          * that function could really be.  It might be on another processor,
 625          * etc, etc.
 626          */
 627         if (!scsi_delete_timer(cmd))
 628                 return;
 629         __scsi_done(cmd);
 630 }
 631
 632 /* Private entry to scsi_done() to complete a command when the timer
 633  * isn't running --- used by scsi_times_out */
 634 void __scsi_done(struct scsi_cmnd *cmd)
 635 {
 636         struct request *rq = cmd->request;
 637
 638         /*
 639          * Set the serial numbers back to zero
 640          */
 641         cmd->serial_number = 0;
 642
 643         atomic_inc(&cmd->device->iodone_cnt);
 644         if (cmd->result)
 645                 atomic_inc(&cmd->device->ioerr_cnt);
 646
 647         BUG_ON(!rq);
 648
 649         /*
 650          * The uptodate/nbytes values don't matter, as we allow partial
 651          * completes and thus will check this in the softirq callback
 652          */
 653         rq->completion_data = cmd;
 654         blk_complete_request(rq);
 655 }
 656
 657 /* Move this to a header if it becomes more generally useful */
 658 static struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)
 659 {
 660         return *(struct scsi_driver **)cmd->request->rq_disk->private_data;
 661 }
 662
 663 /*
 664  * Function:    scsi_finish_command
 665  *
 666  * Purpose:     Pass command off to upper layer for finishing of I/O
 667  *              request, waking processes that are waiting on results,
 668  *              etc.
 669  */
 670 void scsi_finish_command(struct scsi_cmnd *cmd)
 671 {
 672         struct scsi_device *sdev = cmd->device;
 673         struct Scsi_Host *shost = sdev->host;
 674         struct scsi_driver *drv;
 675         unsigned int good_bytes;
 676
 677         scsi_device_unbusy(sdev);
 678
 679         /*
 680          * Clear the flags which say that the device/host is no longer
 681          * capable of accepting new commands.  These are set in scsi_queue.c
 682          * for both the queue full condition on a device, and for a
 683          * host full condition on the host.
 684          *
 685          * XXX(hch): What about locking?
 686          */
 687         shost->host_blocked = 0;
 688         sdev->device_blocked = 0;
 689
 690         /*
 691          * If we have valid sense information, then some kind of recovery
 692          * must have taken place.  Make a note of this.
 693          */
 694         if (SCSI_SENSE_VALID(cmd))
 695                 cmd->result |= (DRIVER_SENSE << 24);
 696
 697         SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
 698                                 "Notifying upper driver of completion "
 699                                 "(result %x)\n", cmd->result));
 700
 701         good_bytes = cmd->request_bufflen;
 702         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
 703                 drv = scsi_cmd_to_driver(cmd);
 704                 if (drv->done)
 705                         good_bytes = drv->done(cmd);
 706         }
 707         scsi_io_completion(cmd, good_bytes);
 708 }
 709 EXPORT_SYMBOL(scsi_finish_command);
 710
 711 /*
 712  * Function:    scsi_adjust_queue_depth()
 713  *
 714  * Purpose:     Allow low level drivers to tell us to change the queue depth
 715  *              on a specific SCSI device
 716  *
 717  * Arguments:   sdev    - SCSI Device in question
 718  *              tagged  - Do we use tagged queueing (non-0) or do we treat
 719  *                        this device as an untagged device (0)
 720  *              tags    - Number of tags allowed if tagged queueing enabled,
 721  *                        or number of commands the low level driver can
 722  *                        queue up in non-tagged mode (as per cmd_per_lun).
 723  *
 724  * Returns:     Nothing
 725  *
 726  * Lock Status: None held on entry
 727  *
 728  * Notes:       Low level drivers may call this at any time and we will do
 729  *              the right thing depending on whether or not the device is
 730  *              currently active and whether or not it even has the
 731  *              command blocks built yet.
 732  */
 733 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
 734 {
 735         unsigned long flags;
 736
 737         /*
 738          * refuse to set tagged depth to an unworkable size
 739          */
 740         if (tags <= 0)
 741                 return;
 742
 743         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 744
 745         /* Check to see if the queue is managed by the block layer
 746          * if it is, and we fail to adjust the depth, exit */
 747         if (blk_queue_tagged(sdev->request_queue) &&
 748             blk_queue_resize_tags(sdev->request_queue, tags) != 0)
 749                 goto out;
 750
 751         sdev->queue_depth = tags;
 752         switch (tagged) {
 753                 case MSG_ORDERED_TAG:
 754                         sdev->ordered_tags = 1;
 755                         sdev->simple_tags = 1;
 756                         break;
 757                 case MSG_SIMPLE_TAG:
 758                         sdev->ordered_tags = 0;
 759                         sdev->simple_tags = 1;
 760                         break;
 761                 default:
 762                         sdev_printk(KERN_WARNING, sdev,
 763                                     "scsi_adjust_queue_depth, bad queue type, "
 764                                     "disabled\n");
 765                 case 0:
 766                         sdev->ordered_tags = sdev->simple_tags = 0;
 767                         sdev->queue_depth = tags;
 768                         break;
 769         }
 770  out:
 771         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 772 }
 773 EXPORT_SYMBOL(scsi_adjust_queue_depth);
 774
 775 /*
 776  * Function:    scsi_track_queue_full()
 777  *
 778  * Purpose:     This function will track successive QUEUE_FULL events on a
 779  *              specific SCSI device to determine if and when there is a
 780  *              need to adjust the queue depth on the device.
 781  *
 782  * Arguments:   sdev    - SCSI Device in question
 783  *              depth   - Current number of outstanding SCSI commands on
 784  *                        this device, not counting the one returned as
 785  *                        QUEUE_FULL.
 786  *
 787  * Returns:     0 - No change needed
 788  *              >0 - Adjust queue depth to this new depth
 789  *              -1 - Drop back to untagged operation using host->cmd_per_lun
 790  *                      as the untagged command depth
 791  *
 792  * Lock Status: None held on entry
 793  *
 794  * Notes:       Low level drivers may call this at any time and we will do
 795  *              "The Right Thing."  We are interrupt context safe.
 796  */
 797 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 798 {
 799         if ((jiffies >> 4) == sdev->last_queue_full_time)
 800                 return 0;
 801
 802         sdev->last_queue_full_time = (jiffies >> 4);
 803         if (sdev->last_queue_full_depth != depth) {
 804                 sdev->last_queue_full_count = 1;
 805                 sdev->last_queue_full_depth = depth;
 806         } else {
 807                 sdev->last_queue_full_count++;
 808         }
 809
 810         if (sdev->last_queue_full_count <= 10)
 811                 return 0;
 812         if (sdev->last_queue_full_depth < 8) {
 813                 /* Drop back to untagged */
 814                 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 815                 return -1;
 816         }
 817
 818         if (sdev->ordered_tags)
 819                 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
 820         else
 821                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
 822         return depth;
 823 }
 824 EXPORT_SYMBOL(scsi_track_queue_full);
 825
 826 /**
 827  * scsi_device_get  -  get an addition reference to a scsi_device
 828  * @sdev:       device to get a reference to
 829  *
 830  * Gets a reference to the scsi_device and increments the use count
 831  * of the underlying LLDD module.  You must hold host_lock of the
 832  * parent Scsi_Host or already have a reference when calling this.
 833  */
 834 int scsi_device_get(struct scsi_device *sdev)
 835 {
 836         if (sdev->sdev_state == SDEV_DEL)
 837                 return -ENXIO;
 838         if (!get_device(&sdev->sdev_gendev))
 839                 return -ENXIO;
 840         /* We can fail this if we're doing SCSI operations
 841          * from module exit (like cache flush) */
 842         try_module_get(sdev->host->hostt->module);
 843
 844         return 0;
 845 }
 846 EXPORT_SYMBOL(scsi_device_get);
 847
 848 /**
 849  * scsi_device_put  -  release a reference to a scsi_device
 850  * @sdev:       device to release a reference on.
 851  *
 852  * Release a reference to the scsi_device and decrements the use count
 853  * of the underlying LLDD module.  The device is freed once the last
 854  * user vanishes.
 855  */
 856 void scsi_device_put(struct scsi_device *sdev)
 857 {
 858 #ifdef CONFIG_MODULE_UNLOAD
 859         struct module *module = sdev->host->hostt->module;
 860
 861         /* The module refcount will be zero if scsi_device_get()
 862          * was called from a module removal routine */
 863         if (module && module_refcount(module) != 0)
 864                 module_put(module);
 865 #endif
 866         put_device(&sdev->sdev_gendev);
 867 }
 868 EXPORT_SYMBOL(scsi_device_put);
 869
 870 /* helper for shost_for_each_device, thus not documented */
 871 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
 872                                            struct scsi_device *prev)
 873 {
 874         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
 875         struct scsi_device *next = NULL;
 876         unsigned long flags;
 877
 878         spin_lock_irqsave(shost->host_lock, flags);
 879         while (list->next != &shost->__devices) {
 880                 next = list_entry(list->next, struct scsi_device, siblings);
 881                 /* skip devices that we can't get a reference to */
 882                 if (!scsi_device_get(next))
 883                         break;
 884                 next = NULL;
 885                 list = list->next;
 886         }
 887         spin_unlock_irqrestore(shost->host_lock, flags);
 888
 889         if (prev)
 890                 scsi_device_put(prev);
 891         return next;
 892 }
 893 EXPORT_SYMBOL(__scsi_iterate_devices);
 894
 895 /**
 896  * starget_for_each_device  -  helper to walk all devices of a target
 897  * @starget:    target whose devices we want to iterate over.
 898  *
 899  * This traverses over each device of @starget.  The devices have
 900  * a reference that must be released by scsi_host_put when breaking
 901  * out of the loop.
 902  */
 903 void starget_for_each_device(struct scsi_target *starget, void *data,
 904                      void (*fn)(struct scsi_device *, void *))
 905 {
 906         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 907         struct scsi_device *sdev;
 908
 909         shost_for_each_device(sdev, shost) {
 910                 if ((sdev->channel == starget->channel) &&
 911                     (sdev->id == starget->id))
 912                         fn(sdev, data);
 913         }
 914 }
 915 EXPORT_SYMBOL(starget_for_each_device);
 916
 917 /**
 918  * __starget_for_each_device  -  helper to walk all devices of a target
 919  *                               (UNLOCKED)
 920  * @starget:    target whose devices we want to iterate over.
 921  *
 922  * This traverses over each device of @starget.  It does _not_
 923  * take a reference on the scsi_device, so the whole loop must be
 924  * protected by shost->host_lock.
 925  *
 926  * Note:  The only reason why drivers would want to use this is because
 927  * they need to access the device list in irq context.  Otherwise you
 928  * really want to use starget_for_each_device instead.
 929  **/
 930 void __starget_for_each_device(struct scsi_target *starget, void *data,
 931                                void (*fn)(struct scsi_device *, void *))
 932 {
 933         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 934         struct scsi_device *sdev;
 935
 936         __shost_for_each_device(sdev, shost) {
 937                 if ((sdev->channel == starget->channel) &&
 938                     (sdev->id == starget->id))
 939                         fn(sdev, data);
 940         }
 941 }
 942 EXPORT_SYMBOL(__starget_for_each_device);
 943
 944 /**
 945  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
 946  * @starget:    SCSI target pointer
 947  * @lun:        SCSI Logical Unit Number
 948  *
 949  * Looks up the scsi_device with the specified @lun for a give
 950  * @starget. The returned scsi_device does not have an additional
 951  * reference.  You must hold the host's host_lock over this call and
 952  * any access to the returned scsi_device.
 953  *
 954  * Note:  The only reason why drivers would want to use this is because
 955  * they're need to access the device list in irq context.  Otherwise you
 956  * really want to use scsi_device_lookup_by_target instead.
 957  **/
 958 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
 959                                                    uint lun)
 960 {
 961         struct scsi_device *sdev;
 962
 963         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
 964                 if (sdev->lun ==lun)
 965                         return sdev;
 966         }
 967
 968         return NULL;
 969 }
 970 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
 971
 972 /**
 973  * scsi_device_lookup_by_target - find a device given the target
 974  * @starget:    SCSI target pointer
 975  * @lun:        SCSI Logical Unit Number
 976  *
 977  * Looks up the scsi_device with the specified @channel, @id, @lun for a
 978  * give host.  The returned scsi_device has an additional reference that
 979  * needs to be release with scsi_host_put once you're done with it.
 980  **/
 981 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
 982                                                  uint lun)
 983 {
 984         struct scsi_device *sdev;
 985         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 986         unsigned long flags;
 987
 988         spin_lock_irqsave(shost->host_lock, flags);
 989         sdev = __scsi_device_lookup_by_target(starget, lun);
 990         if (sdev && scsi_device_get(sdev))
 991                 sdev = NULL;
 992         spin_unlock_irqrestore(shost->host_lock, flags);
 993
 994         return sdev;
 995 }
 996 EXPORT_SYMBOL(scsi_device_lookup_by_target);
 997
 998 /**
 999  * scsi_device_lookup - find a device given the host (UNLOCKED)
1000  * @shost:      SCSI host pointer
1001  * @channel:    SCSI channel (zero if only one channel)
1002  * @pun:        SCSI target number (physical unit number)
1003  * @lun:        SCSI Logical Unit Number
1004  *
1005  * Looks up the scsi_device with the specified @channel, @id, @lun for a
1006  * give host. The returned scsi_device does not have an additional reference.
1007  * You must hold the host's host_lock over this call and any access to the
1008  * returned scsi_device.
1009  *
1010  * Note:  The only reason why drivers would want to use this is because
1011  * they're need to access the device list in irq context.  Otherwise you
1012  * really want to use scsi_device_lookup instead.
1013  **/
1014 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1015                 uint channel, uint id, uint lun)
1016 {
1017         struct scsi_device *sdev;
1018
1019         list_for_each_entry(sdev, &shost->__devices, siblings) {
1020                 if (sdev->channel == channel && sdev->id == id &&
1021                                 sdev->lun ==lun)
1022                         return sdev;
1023         }
1024
1025         return NULL;
1026 }
1027 EXPORT_SYMBOL(__scsi_device_lookup);
1028
1029 /**
1030  * scsi_device_lookup - find a device given the host
1031  * @shost:      SCSI host pointer
1032  * @channel:    SCSI channel (zero if only one channel)
1033  * @id:         SCSI target number (physical unit number)
1034  * @lun:        SCSI Logical Unit Number
1035  *
1036  * Looks up the scsi_device with the specified @channel, @id, @lun for a
1037  * give host.  The returned scsi_device has an additional reference that
1038  * needs to be release with scsi_host_put once you're done with it.
1039  **/
1040 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1041                 uint channel, uint id, uint lun)
1042 {
1043         struct scsi_device *sdev;
1044         unsigned long flags;
1045
1046         spin_lock_irqsave(shost->host_lock, flags);
1047         sdev = __scsi_device_lookup(shost, channel, id, lun);
1048         if (sdev && scsi_device_get(sdev))
1049                 sdev = NULL;
1050         spin_unlock_irqrestore(shost->host_lock, flags);
1051
1052         return sdev;
1053 }
1054 EXPORT_SYMBOL(scsi_device_lookup);
1055
1056 MODULE_DESCRIPTION("SCSI core");
1057 MODULE_LICENSE("GPL");
1058
1059 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1060 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1061
1062 static int __init init_scsi(void)
1063 {
1064         int error;
1065
1066         error = scsi_init_queue();
1067         if (error)
1068                 return error;
1069         error = scsi_init_procfs();
1070         if (error)
1071                 goto cleanup_queue;
1072         error = scsi_init_devinfo();
1073         if (error)
1074                 goto cleanup_procfs;
1075         error = scsi_init_hosts();
1076         if (error)
1077                 goto cleanup_devlist;
1078         error = scsi_init_sysctl();
1079         if (error)
1080                 goto cleanup_hosts;
1081         error = scsi_sysfs_register();
1082         if (error)
1083                 goto cleanup_sysctl;
1084
1085         scsi_netlink_init();
1086
1087         printk(KERN_NOTICE "SCSI subsystem initialized\n");
1088         return 0;
1089
1090 cleanup_sysctl:
1091         scsi_exit_sysctl();
1092 cleanup_hosts:
1093         scsi_exit_hosts();
1094 cleanup_devlist:
1095         scsi_exit_devinfo();
1096 cleanup_procfs:
1097         scsi_exit_procfs();
1098 cleanup_queue:
1099         scsi_exit_queue();
1100         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1101                -error);
1102         return error;
1103 }
1104
1105 static void __exit exit_scsi(void)
1106 {
1107         scsi_netlink_exit();
1108         scsi_sysfs_unregister();
1109         scsi_exit_sysctl();
1110         scsi_exit_hosts();
1111         scsi_exit_devinfo();
1112         scsi_exit_procfs();
1113         scsi_exit_queue();
1114 }
1115
1116 subsys_initcall(init_scsi);
1117 module_exit(exit_scsi);