drivers/scsi/scsi.c

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