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);
 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
 348         /*
 349          * If ML QUEUE log level is greater than or equal to:
 350          *
 351          * 1: nothing (match completion)
 352          *
 353          * 2: log opcode + command of all commands
 354          *
 355          * 3: same as 2 plus dump cmd address
 356          *
 357          * 4: same as 3 plus dump extra junk
 358          */
 359         if (unlikely(scsi_logging_level)) {
 360                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
 361                                        SCSI_LOG_MLQUEUE_BITS);
 362                 if (level > 1) {
 363                         scmd_printk(KERN_INFO, cmd, "Send: ");
 364                         if (level > 2)
 365                                 printk("0x%p ", cmd);
 366                         printk("\n");
 367                         scsi_print_command(cmd);
 368                         if (level > 3) {
 369                                 printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
 370                                        " done = 0x%p, queuecommand 0x%p\n",
 371                                         scsi_sglist(cmd), scsi_bufflen(cmd),
 372                                         cmd->done,
 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 /*
 658  * Function:    scsi_finish_command
 659  *
 660  * Purpose:     Pass command off to upper layer for finishing of I/O
 661  *              request, waking processes that are waiting on results,
 662  *              etc.
 663  */
 664 void scsi_finish_command(struct scsi_cmnd *cmd)
 665 {
 666         struct scsi_device *sdev = cmd->device;
 667         struct Scsi_Host *shost = sdev->host;
 668
 669         scsi_device_unbusy(sdev);
 670
 671         /*
 672          * Clear the flags which say that the device/host is no longer
 673          * capable of accepting new commands.  These are set in scsi_queue.c
 674          * for both the queue full condition on a device, and for a
 675          * host full condition on the host.
 676          *
 677          * XXX(hch): What about locking?
 678          */
 679         shost->host_blocked = 0;
 680         sdev->device_blocked = 0;
 681
 682         /*
 683          * If we have valid sense information, then some kind of recovery
 684          * must have taken place.  Make a note of this.
 685          */
 686         if (SCSI_SENSE_VALID(cmd))
 687                 cmd->result |= (DRIVER_SENSE << 24);
 688
 689         SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
 690                                 "Notifying upper driver of completion "
 691                                 "(result %x)\n", cmd->result));
 692
 693         cmd->done(cmd);
 694 }
 695 EXPORT_SYMBOL(scsi_finish_command);
 696
 697 /*
 698  * Function:    scsi_adjust_queue_depth()
 699  *
 700  * Purpose:     Allow low level drivers to tell us to change the queue depth
 701  *              on a specific SCSI device
 702  *
 703  * Arguments:   sdev    - SCSI Device in question
 704  *              tagged  - Do we use tagged queueing (non-0) or do we treat
 705  *                        this device as an untagged device (0)
 706  *              tags    - Number of tags allowed if tagged queueing enabled,
 707  *                        or number of commands the low level driver can
 708  *                        queue up in non-tagged mode (as per cmd_per_lun).
 709  *
 710  * Returns:     Nothing
 711  *
 712  * Lock Status: None held on entry
 713  *
 714  * Notes:       Low level drivers may call this at any time and we will do
 715  *              the right thing depending on whether or not the device is
 716  *              currently active and whether or not it even has the
 717  *              command blocks built yet.
 718  */
 719 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
 720 {
 721         unsigned long flags;
 722
 723         /*
 724          * refuse to set tagged depth to an unworkable size
 725          */
 726         if (tags <= 0)
 727                 return;
 728
 729         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 730
 731         /* Check to see if the queue is managed by the block layer
 732          * if it is, and we fail to adjust the depth, exit */
 733         if (blk_queue_tagged(sdev->request_queue) &&
 734             blk_queue_resize_tags(sdev->request_queue, tags) != 0)
 735                 goto out;
 736
 737         sdev->queue_depth = tags;
 738         switch (tagged) {
 739                 case MSG_ORDERED_TAG:
 740                         sdev->ordered_tags = 1;
 741                         sdev->simple_tags = 1;
 742                         break;
 743                 case MSG_SIMPLE_TAG:
 744                         sdev->ordered_tags = 0;
 745                         sdev->simple_tags = 1;
 746                         break;
 747                 default:
 748                         sdev_printk(KERN_WARNING, sdev,
 749                                     "scsi_adjust_queue_depth, bad queue type, "
 750                                     "disabled\n");
 751                 case 0:
 752                         sdev->ordered_tags = sdev->simple_tags = 0;
 753                         sdev->queue_depth = tags;
 754                         break;
 755         }
 756  out:
 757         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 758 }
 759 EXPORT_SYMBOL(scsi_adjust_queue_depth);
 760
 761 /*
 762  * Function:    scsi_track_queue_full()
 763  *
 764  * Purpose:     This function will track successive QUEUE_FULL events on a
 765  *              specific SCSI device to determine if and when there is a
 766  *              need to adjust the queue depth on the device.
 767  *
 768  * Arguments:   sdev    - SCSI Device in question
 769  *              depth   - Current number of outstanding SCSI commands on
 770  *                        this device, not counting the one returned as
 771  *                        QUEUE_FULL.
 772  *
 773  * Returns:     0 - No change needed
 774  *              >0 - Adjust queue depth to this new depth
 775  *              -1 - Drop back to untagged operation using host->cmd_per_lun
 776  *                      as the untagged command depth
 777  *
 778  * Lock Status: None held on entry
 779  *
 780  * Notes:       Low level drivers may call this at any time and we will do
 781  *              "The Right Thing."  We are interrupt context safe.
 782  */
 783 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 784 {
 785         if ((jiffies >> 4) == sdev->last_queue_full_time)
 786                 return 0;
 787
 788         sdev->last_queue_full_time = (jiffies >> 4);
 789         if (sdev->last_queue_full_depth != depth) {
 790                 sdev->last_queue_full_count = 1;
 791                 sdev->last_queue_full_depth = depth;
 792         } else {
 793                 sdev->last_queue_full_count++;
 794         }
 795
 796         if (sdev->last_queue_full_count <= 10)
 797                 return 0;
 798         if (sdev->last_queue_full_depth < 8) {
 799                 /* Drop back to untagged */
 800                 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 801                 return -1;
 802         }
 803
 804         if (sdev->ordered_tags)
 805                 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
 806         else
 807                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
 808         return depth;
 809 }
 810 EXPORT_SYMBOL(scsi_track_queue_full);
 811
 812 /**
 813  * scsi_device_get  -  get an addition reference to a scsi_device
 814  * @sdev:       device to get a reference to
 815  *
 816  * Gets a reference to the scsi_device and increments the use count
 817  * of the underlying LLDD module.  You must hold host_lock of the
 818  * parent Scsi_Host or already have a reference when calling this.
 819  */
 820 int scsi_device_get(struct scsi_device *sdev)
 821 {
 822         if (sdev->sdev_state == SDEV_DEL)
 823                 return -ENXIO;
 824         if (!get_device(&sdev->sdev_gendev))
 825                 return -ENXIO;
 826         /* We can fail this if we're doing SCSI operations
 827          * from module exit (like cache flush) */
 828         try_module_get(sdev->host->hostt->module);
 829
 830         return 0;
 831 }
 832 EXPORT_SYMBOL(scsi_device_get);
 833
 834 /**
 835  * scsi_device_put  -  release a reference to a scsi_device
 836  * @sdev:       device to release a reference on.
 837  *
 838  * Release a reference to the scsi_device and decrements the use count
 839  * of the underlying LLDD module.  The device is freed once the last
 840  * user vanishes.
 841  */
 842 void scsi_device_put(struct scsi_device *sdev)
 843 {
 844 #ifdef CONFIG_MODULE_UNLOAD
 845         struct module *module = sdev->host->hostt->module;
 846
 847         /* The module refcount will be zero if scsi_device_get()
 848          * was called from a module removal routine */
 849         if (module && module_refcount(module) != 0)
 850                 module_put(module);
 851 #endif
 852         put_device(&sdev->sdev_gendev);
 853 }
 854 EXPORT_SYMBOL(scsi_device_put);
 855
 856 /* helper for shost_for_each_device, thus not documented */
 857 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
 858                                            struct scsi_device *prev)
 859 {
 860         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
 861         struct scsi_device *next = NULL;
 862         unsigned long flags;
 863
 864         spin_lock_irqsave(shost->host_lock, flags);
 865         while (list->next != &shost->__devices) {
 866                 next = list_entry(list->next, struct scsi_device, siblings);
 867                 /* skip devices that we can't get a reference to */
 868                 if (!scsi_device_get(next))
 869                         break;
 870                 next = NULL;
 871                 list = list->next;
 872         }
 873         spin_unlock_irqrestore(shost->host_lock, flags);
 874
 875         if (prev)
 876                 scsi_device_put(prev);
 877         return next;
 878 }
 879 EXPORT_SYMBOL(__scsi_iterate_devices);
 880
 881 /**
 882  * starget_for_each_device  -  helper to walk all devices of a target
 883  * @starget:    target whose devices we want to iterate over.
 884  *
 885  * This traverses over each device of @starget.  The devices have
 886  * a reference that must be released by scsi_host_put when breaking
 887  * out of the loop.
 888  */
 889 void starget_for_each_device(struct scsi_target *starget, void *data,
 890                      void (*fn)(struct scsi_device *, void *))
 891 {
 892         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 893         struct scsi_device *sdev;
 894
 895         shost_for_each_device(sdev, shost) {
 896                 if ((sdev->channel == starget->channel) &&
 897                     (sdev->id == starget->id))
 898                         fn(sdev, data);
 899         }
 900 }
 901 EXPORT_SYMBOL(starget_for_each_device);
 902
 903 /**
 904  * __starget_for_each_device  -  helper to walk all devices of a target
 905  *                               (UNLOCKED)
 906  * @starget:    target whose devices we want to iterate over.
 907  *
 908  * This traverses over each device of @starget.  It does _not_
 909  * take a reference on the scsi_device, so the whole loop must be
 910  * protected by shost->host_lock.
 911  *
 912  * Note:  The only reason why drivers would want to use this is because
 913  * they need to access the device list in irq context.  Otherwise you
 914  * really want to use starget_for_each_device instead.
 915  **/
 916 void __starget_for_each_device(struct scsi_target *starget, void *data,
 917                                void (*fn)(struct scsi_device *, void *))
 918 {
 919         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 920         struct scsi_device *sdev;
 921
 922         __shost_for_each_device(sdev, shost) {
 923                 if ((sdev->channel == starget->channel) &&
 924                     (sdev->id == starget->id))
 925                         fn(sdev, data);
 926         }
 927 }
 928 EXPORT_SYMBOL(__starget_for_each_device);
 929
 930 /**
 931  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
 932  * @starget:    SCSI target pointer
 933  * @lun:        SCSI Logical Unit Number
 934  *
 935  * Looks up the scsi_device with the specified @lun for a give
 936  * @starget. The returned scsi_device does not have an additional
 937  * reference.  You must hold the host's host_lock over this call and
 938  * any access to the returned scsi_device.
 939  *
 940  * Note:  The only reason why drivers would want to use this is because
 941  * they're need to access the device list in irq context.  Otherwise you
 942  * really want to use scsi_device_lookup_by_target instead.
 943  **/
 944 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
 945                                                    uint lun)
 946 {
 947         struct scsi_device *sdev;
 948
 949         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
 950                 if (sdev->lun ==lun)
 951                         return sdev;
 952         }
 953
 954         return NULL;
 955 }
 956 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
 957
 958 /**
 959  * scsi_device_lookup_by_target - find a device given the target
 960  * @starget:    SCSI target pointer
 961  * @lun:        SCSI Logical Unit Number
 962  *
 963  * Looks up the scsi_device with the specified @channel, @id, @lun for a
 964  * give host.  The returned scsi_device has an additional reference that
 965  * needs to be release with scsi_host_put once you're done with it.
 966  **/
 967 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
 968                                                  uint lun)
 969 {
 970         struct scsi_device *sdev;
 971         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 972         unsigned long flags;
 973
 974         spin_lock_irqsave(shost->host_lock, flags);
 975         sdev = __scsi_device_lookup_by_target(starget, lun);
 976         if (sdev && scsi_device_get(sdev))
 977                 sdev = NULL;
 978         spin_unlock_irqrestore(shost->host_lock, flags);
 979
 980         return sdev;
 981 }
 982 EXPORT_SYMBOL(scsi_device_lookup_by_target);
 983
 984 /**
 985  * scsi_device_lookup - find a device given the host (UNLOCKED)
 986  * @shost:      SCSI host pointer
 987  * @channel:    SCSI channel (zero if only one channel)
 988  * @pun:        SCSI target number (physical unit number)
 989  * @lun:        SCSI Logical Unit Number
 990  *
 991  * Looks up the scsi_device with the specified @channel, @id, @lun for a
 992  * give host. The returned scsi_device does not have an additional reference.
 993  * You must hold the host's host_lock over this call and any access to the
 994  * returned scsi_device.
 995  *
 996  * Note:  The only reason why drivers would want to use this is because
 997  * they're need to access the device list in irq context.  Otherwise you
 998  * really want to use scsi_device_lookup instead.
 999  **/
1000 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1001                 uint channel, uint id, uint lun)
1002 {
1003         struct scsi_device *sdev;
1004
1005         list_for_each_entry(sdev, &shost->__devices, siblings) {
1006                 if (sdev->channel == channel && sdev->id == id &&
1007                                 sdev->lun ==lun)
1008                         return sdev;
1009         }
1010
1011         return NULL;
1012 }
1013 EXPORT_SYMBOL(__scsi_device_lookup);
1014
1015 /**
1016  * scsi_device_lookup - find a device given the host
1017  * @shost:      SCSI host pointer
1018  * @channel:    SCSI channel (zero if only one channel)
1019  * @id:         SCSI target number (physical unit number)
1020  * @lun:        SCSI Logical Unit Number
1021  *
1022  * Looks up the scsi_device with the specified @channel, @id, @lun for a
1023  * give host.  The returned scsi_device has an additional reference that
1024  * needs to be release with scsi_host_put once you're done with it.
1025  **/
1026 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1027                 uint channel, uint id, uint lun)
1028 {
1029         struct scsi_device *sdev;
1030         unsigned long flags;
1031
1032         spin_lock_irqsave(shost->host_lock, flags);
1033         sdev = __scsi_device_lookup(shost, channel, id, lun);
1034         if (sdev && scsi_device_get(sdev))
1035                 sdev = NULL;
1036         spin_unlock_irqrestore(shost->host_lock, flags);
1037
1038         return sdev;
1039 }
1040 EXPORT_SYMBOL(scsi_device_lookup);
1041
1042 MODULE_DESCRIPTION("SCSI core");
1043 MODULE_LICENSE("GPL");
1044
1045 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1046 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1047
1048 static int __init init_scsi(void)
1049 {
1050         int error;
1051
1052         error = scsi_init_queue();
1053         if (error)
1054                 return error;
1055         error = scsi_init_procfs();
1056         if (error)
1057                 goto cleanup_queue;
1058         error = scsi_init_devinfo();
1059         if (error)
1060                 goto cleanup_procfs;
1061         error = scsi_init_hosts();
1062         if (error)
1063                 goto cleanup_devlist;
1064         error = scsi_init_sysctl();
1065         if (error)
1066                 goto cleanup_hosts;
1067         error = scsi_sysfs_register();
1068         if (error)
1069                 goto cleanup_sysctl;
1070
1071         scsi_netlink_init();
1072
1073         printk(KERN_NOTICE "SCSI subsystem initialized\n");
1074         return 0;
1075
1076 cleanup_sysctl:
1077         scsi_exit_sysctl();
1078 cleanup_hosts:
1079         scsi_exit_hosts();
1080 cleanup_devlist:
1081         scsi_exit_devinfo();
1082 cleanup_procfs:
1083         scsi_exit_procfs();
1084 cleanup_queue:
1085         scsi_exit_queue();
1086         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1087                -error);
1088         return error;
1089 }
1090
1091 static void __exit exit_scsi(void)
1092 {
1093         scsi_netlink_exit();
1094         scsi_sysfs_unregister();
1095         scsi_exit_sysctl();
1096         scsi_exit_hosts();
1097         scsi_exit_devinfo();
1098         scsi_exit_procfs();
1099         scsi_exit_queue();
1100 }
1101
1102 subsys_initcall(init_scsi);
1103 module_exit(exit_scsi);