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  * scsi_req_abort_cmd -- Request command recovery for the specified command
 597  * cmd: pointer to the SCSI command of interest
 598  *
 599  * This function requests that SCSI Core start recovery for the
 600  * command by deleting the timer and adding the command to the eh
 601  * queue.  It can be called by either LLDDs or SCSI Core.  LLDDs who
 602  * implement their own error recovery MAY ignore the timeout event if
 603  * they generated scsi_req_abort_cmd.
 604  */
 605 void scsi_req_abort_cmd(struct scsi_cmnd *cmd)
 606 {
 607         if (!scsi_delete_timer(cmd))
 608                 return;
 609         scsi_times_out(cmd);
 610 }
 611 EXPORT_SYMBOL(scsi_req_abort_cmd);
 612
 613 /**
 614  * scsi_done - Enqueue the finished SCSI command into the done queue.
 615  * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
 616  * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
 617  *
 618  * This function is the mid-level's (SCSI Core) interrupt routine, which
 619  * regains ownership of the SCSI command (de facto) from a LLDD, and enqueues
 620  * the command to the done queue for further processing.
 621  *
 622  * This is the producer of the done queue who enqueues at the tail.
 623  *
 624  * This function is interrupt context safe.
 625  */
 626 static void scsi_done(struct scsi_cmnd *cmd)
 627 {
 628         /*
 629          * We don't have to worry about this one timing out any more.
 630          * If we are unable to remove the timer, then the command
 631          * has already timed out.  In which case, we have no choice but to
 632          * let the timeout function run, as we have no idea where in fact
 633          * that function could really be.  It might be on another processor,
 634          * etc, etc.
 635          */
 636         if (!scsi_delete_timer(cmd))
 637                 return;
 638         __scsi_done(cmd);
 639 }
 640
 641 /* Private entry to scsi_done() to complete a command when the timer
 642  * isn't running --- used by scsi_times_out */
 643 void __scsi_done(struct scsi_cmnd *cmd)
 644 {
 645         struct request *rq = cmd->request;
 646
 647         /*
 648          * Set the serial numbers back to zero
 649          */
 650         cmd->serial_number = 0;
 651
 652         atomic_inc(&cmd->device->iodone_cnt);
 653         if (cmd->result)
 654                 atomic_inc(&cmd->device->ioerr_cnt);
 655
 656         BUG_ON(!rq);
 657
 658         /*
 659          * The uptodate/nbytes values don't matter, as we allow partial
 660          * completes and thus will check this in the softirq callback
 661          */
 662         rq->completion_data = cmd;
 663         blk_complete_request(rq);
 664 }
 665
 666 /*
 667  * Function:    scsi_retry_command
 668  *
 669  * Purpose:     Send a command back to the low level to be retried.
 670  *
 671  * Notes:       This command is always executed in the context of the
 672  *              bottom half handler, or the error handler thread. Low
 673  *              level drivers should not become re-entrant as a result of
 674  *              this.
 675  */
 676 int scsi_retry_command(struct scsi_cmnd *cmd)
 677 {
 678         /*
 679          * Zero the sense information from the last time we tried
 680          * this command.
 681          */
 682         memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
 683
 684         return scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
 685 }
 686
 687 /*
 688  * Function:    scsi_finish_command
 689  *
 690  * Purpose:     Pass command off to upper layer for finishing of I/O
 691  *              request, waking processes that are waiting on results,
 692  *              etc.
 693  */
 694 void scsi_finish_command(struct scsi_cmnd *cmd)
 695 {
 696         struct scsi_device *sdev = cmd->device;
 697         struct Scsi_Host *shost = sdev->host;
 698
 699         scsi_device_unbusy(sdev);
 700
 701         /*
 702          * Clear the flags which say that the device/host is no longer
 703          * capable of accepting new commands.  These are set in scsi_queue.c
 704          * for both the queue full condition on a device, and for a
 705          * host full condition on the host.
 706          *
 707          * XXX(hch): What about locking?
 708          */
 709         shost->host_blocked = 0;
 710         sdev->device_blocked = 0;
 711
 712         /*
 713          * If we have valid sense information, then some kind of recovery
 714          * must have taken place.  Make a note of this.
 715          */
 716         if (SCSI_SENSE_VALID(cmd))
 717                 cmd->result |= (DRIVER_SENSE << 24);
 718
 719         SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
 720                                 "Notifying upper driver of completion "
 721                                 "(result %x)\n", cmd->result));
 722
 723         cmd->done(cmd);
 724 }
 725 EXPORT_SYMBOL(scsi_finish_command);
 726
 727 /*
 728  * Function:    scsi_adjust_queue_depth()
 729  *
 730  * Purpose:     Allow low level drivers to tell us to change the queue depth
 731  *              on a specific SCSI device
 732  *
 733  * Arguments:   sdev    - SCSI Device in question
 734  *              tagged  - Do we use tagged queueing (non-0) or do we treat
 735  *                        this device as an untagged device (0)
 736  *              tags    - Number of tags allowed if tagged queueing enabled,
 737  *                        or number of commands the low level driver can
 738  *                        queue up in non-tagged mode (as per cmd_per_lun).
 739  *
 740  * Returns:     Nothing
 741  *
 742  * Lock Status: None held on entry
 743  *
 744  * Notes:       Low level drivers may call this at any time and we will do
 745  *              the right thing depending on whether or not the device is
 746  *              currently active and whether or not it even has the
 747  *              command blocks built yet.
 748  */
 749 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
 750 {
 751         unsigned long flags;
 752
 753         /*
 754          * refuse to set tagged depth to an unworkable size
 755          */
 756         if (tags <= 0)
 757                 return;
 758
 759         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 760
 761         /* Check to see if the queue is managed by the block layer
 762          * if it is, and we fail to adjust the depth, exit */
 763         if (blk_queue_tagged(sdev->request_queue) &&
 764             blk_queue_resize_tags(sdev->request_queue, tags) != 0)
 765                 goto out;
 766
 767         sdev->queue_depth = tags;
 768         switch (tagged) {
 769                 case MSG_ORDERED_TAG:
 770                         sdev->ordered_tags = 1;
 771                         sdev->simple_tags = 1;
 772                         break;
 773                 case MSG_SIMPLE_TAG:
 774                         sdev->ordered_tags = 0;
 775                         sdev->simple_tags = 1;
 776                         break;
 777                 default:
 778                         sdev_printk(KERN_WARNING, sdev,
 779                                     "scsi_adjust_queue_depth, bad queue type, "
 780                                     "disabled\n");
 781                 case 0:
 782                         sdev->ordered_tags = sdev->simple_tags = 0;
 783                         sdev->queue_depth = tags;
 784                         break;
 785         }
 786  out:
 787         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 788 }
 789 EXPORT_SYMBOL(scsi_adjust_queue_depth);
 790
 791 /*
 792  * Function:    scsi_track_queue_full()
 793  *
 794  * Purpose:     This function will track successive QUEUE_FULL events on a
 795  *              specific SCSI device to determine if and when there is a
 796  *              need to adjust the queue depth on the device.
 797  *
 798  * Arguments:   sdev    - SCSI Device in question
 799  *              depth   - Current number of outstanding SCSI commands on
 800  *                        this device, not counting the one returned as
 801  *                        QUEUE_FULL.
 802  *
 803  * Returns:     0 - No change needed
 804  *              >0 - Adjust queue depth to this new depth
 805  *              -1 - Drop back to untagged operation using host->cmd_per_lun
 806  *                      as the untagged command depth
 807  *
 808  * Lock Status: None held on entry
 809  *
 810  * Notes:       Low level drivers may call this at any time and we will do
 811  *              "The Right Thing."  We are interrupt context safe.
 812  */
 813 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 814 {
 815         if ((jiffies >> 4) == sdev->last_queue_full_time)
 816                 return 0;
 817
 818         sdev->last_queue_full_time = (jiffies >> 4);
 819         if (sdev->last_queue_full_depth != depth) {
 820                 sdev->last_queue_full_count = 1;
 821                 sdev->last_queue_full_depth = depth;
 822         } else {
 823                 sdev->last_queue_full_count++;
 824         }
 825
 826         if (sdev->last_queue_full_count <= 10)
 827                 return 0;
 828         if (sdev->last_queue_full_depth < 8) {
 829                 /* Drop back to untagged */
 830                 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 831                 return -1;
 832         }
 833
 834         if (sdev->ordered_tags)
 835                 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
 836         else
 837                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
 838         return depth;
 839 }
 840 EXPORT_SYMBOL(scsi_track_queue_full);
 841
 842 /**
 843  * scsi_device_get  -  get an addition reference to a scsi_device
 844  * @sdev:       device to get a reference to
 845  *
 846  * Gets a reference to the scsi_device and increments the use count
 847  * of the underlying LLDD module.  You must hold host_lock of the
 848  * parent Scsi_Host or already have a reference when calling this.
 849  */
 850 int scsi_device_get(struct scsi_device *sdev)
 851 {
 852         if (sdev->sdev_state == SDEV_DEL)
 853                 return -ENXIO;
 854         if (!get_device(&sdev->sdev_gendev))
 855                 return -ENXIO;
 856         /* We can fail this if we're doing SCSI operations
 857          * from module exit (like cache flush) */
 858         try_module_get(sdev->host->hostt->module);
 859
 860         return 0;
 861 }
 862 EXPORT_SYMBOL(scsi_device_get);
 863
 864 /**
 865  * scsi_device_put  -  release a reference to a scsi_device
 866  * @sdev:       device to release a reference on.
 867  *
 868  * Release a reference to the scsi_device and decrements the use count
 869  * of the underlying LLDD module.  The device is freed once the last
 870  * user vanishes.
 871  */
 872 void scsi_device_put(struct scsi_device *sdev)
 873 {
 874         struct module *module = sdev->host->hostt->module;
 875
 876 #ifdef CONFIG_MODULE_UNLOAD
 877         /* The module refcount will be zero if scsi_device_get()
 878          * was called from a module removal routine */
 879         if (module && module_refcount(module) != 0)
 880                 module_put(module);
 881 #endif
 882         put_device(&sdev->sdev_gendev);
 883 }
 884 EXPORT_SYMBOL(scsi_device_put);
 885
 886 /* helper for shost_for_each_device, thus not documented */
 887 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
 888                                            struct scsi_device *prev)
 889 {
 890         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
 891         struct scsi_device *next = NULL;
 892         unsigned long flags;
 893
 894         spin_lock_irqsave(shost->host_lock, flags);
 895         while (list->next != &shost->__devices) {
 896                 next = list_entry(list->next, struct scsi_device, siblings);
 897                 /* skip devices that we can't get a reference to */
 898                 if (!scsi_device_get(next))
 899                         break;
 900                 next = NULL;
 901                 list = list->next;
 902         }
 903         spin_unlock_irqrestore(shost->host_lock, flags);
 904
 905         if (prev)
 906                 scsi_device_put(prev);
 907         return next;
 908 }
 909 EXPORT_SYMBOL(__scsi_iterate_devices);
 910
 911 /**
 912  * starget_for_each_device  -  helper to walk all devices of a target
 913  * @starget:    target whose devices we want to iterate over.
 914  *
 915  * This traverses over each devices of @shost.  The devices have
 916  * a reference that must be released by scsi_host_put when breaking
 917  * out of the loop.
 918  */
 919 void starget_for_each_device(struct scsi_target *starget, void * data,
 920                      void (*fn)(struct scsi_device *, void *))
 921 {
 922         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 923         struct scsi_device *sdev;
 924
 925         shost_for_each_device(sdev, shost) {
 926                 if ((sdev->channel == starget->channel) &&
 927                     (sdev->id == starget->id))
 928                         fn(sdev, data);
 929         }
 930 }
 931 EXPORT_SYMBOL(starget_for_each_device);
 932
 933 /**
 934  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
 935  * @starget:    SCSI target pointer
 936  * @lun:        SCSI Logical Unit Number
 937  *
 938  * Looks up the scsi_device with the specified @lun for a give
 939  * @starget. The returned scsi_device does not have an additional
 940  * reference.  You must hold the host's host_lock over this call and
 941  * any access to the returned scsi_device.
 942  *
 943  * Note:  The only reason why drivers would want to use this is because
 944  * they're need to access the device list in irq context.  Otherwise you
 945  * really want to use scsi_device_lookup_by_target instead.
 946  **/
 947 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
 948                                                    uint lun)
 949 {
 950         struct scsi_device *sdev;
 951
 952         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
 953                 if (sdev->lun ==lun)
 954                         return sdev;
 955         }
 956
 957         return NULL;
 958 }
 959 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
 960
 961 /**
 962  * scsi_device_lookup_by_target - find a device given the target
 963  * @starget:    SCSI target pointer
 964  * @lun:        SCSI Logical Unit Number
 965  *
 966  * Looks up the scsi_device with the specified @channel, @id, @lun for a
 967  * give host.  The returned scsi_device has an additional reference that
 968  * needs to be release with scsi_host_put once you're done with it.
 969  **/
 970 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
 971                                                  uint lun)
 972 {
 973         struct scsi_device *sdev;
 974         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 975         unsigned long flags;
 976
 977         spin_lock_irqsave(shost->host_lock, flags);
 978         sdev = __scsi_device_lookup_by_target(starget, lun);
 979         if (sdev && scsi_device_get(sdev))
 980                 sdev = NULL;
 981         spin_unlock_irqrestore(shost->host_lock, flags);
 982
 983         return sdev;
 984 }
 985 EXPORT_SYMBOL(scsi_device_lookup_by_target);
 986
 987 /**
 988  * scsi_device_lookup - find a device given the host (UNLOCKED)
 989  * @shost:      SCSI host pointer
 990  * @channel:    SCSI channel (zero if only one channel)
 991  * @pun:        SCSI target number (physical unit number)
 992  * @lun:        SCSI Logical Unit Number
 993  *
 994  * Looks up the scsi_device with the specified @channel, @id, @lun for a
 995  * give host. The returned scsi_device does not have an additional reference.
 996  * You must hold the host's host_lock over this call and any access to the
 997  * returned scsi_device.
 998  *
 999  * Note:  The only reason why drivers would want to use this is because
1000  * they're need to access the device list in irq context.  Otherwise you
1001  * really want to use scsi_device_lookup instead.
1002  **/
1003 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1004                 uint channel, uint id, uint lun)
1005 {
1006         struct scsi_device *sdev;
1007
1008         list_for_each_entry(sdev, &shost->__devices, siblings) {
1009                 if (sdev->channel == channel && sdev->id == id &&
1010                                 sdev->lun ==lun)
1011                         return sdev;
1012         }
1013
1014         return NULL;
1015 }
1016 EXPORT_SYMBOL(__scsi_device_lookup);
1017
1018 /**
1019  * scsi_device_lookup - find a device given the host
1020  * @shost:      SCSI host pointer
1021  * @channel:    SCSI channel (zero if only one channel)
1022  * @id:         SCSI target number (physical unit number)
1023  * @lun:        SCSI Logical Unit Number
1024  *
1025  * Looks up the scsi_device with the specified @channel, @id, @lun for a
1026  * give host.  The returned scsi_device has an additional reference that
1027  * needs to be release with scsi_host_put once you're done with it.
1028  **/
1029 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1030                 uint channel, uint id, uint lun)
1031 {
1032         struct scsi_device *sdev;
1033         unsigned long flags;
1034
1035         spin_lock_irqsave(shost->host_lock, flags);
1036         sdev = __scsi_device_lookup(shost, channel, id, lun);
1037         if (sdev && scsi_device_get(sdev))
1038                 sdev = NULL;
1039         spin_unlock_irqrestore(shost->host_lock, flags);
1040
1041         return sdev;
1042 }
1043 EXPORT_SYMBOL(scsi_device_lookup);
1044
1045 /**
1046  * scsi_device_cancel - cancel outstanding IO to this device
1047  * @sdev:       Pointer to struct scsi_device
1048  * @recovery:   Boolean instructing function to recover device or not.
1049  *
1050  **/
1051 int scsi_device_cancel(struct scsi_device *sdev, int recovery)
1052 {
1053         struct scsi_cmnd *scmd;
1054         LIST_HEAD(active_list);
1055         struct list_head *lh, *lh_sf;
1056         unsigned long flags;
1057
1058         scsi_device_set_state(sdev, SDEV_CANCEL);
1059
1060         spin_lock_irqsave(&sdev->list_lock, flags);
1061         list_for_each_entry(scmd, &sdev->cmd_list, list) {
1062                 if (scmd->request) {
1063                         /*
1064                          * If we are unable to remove the timer, it means
1065                          * that the command has already timed out or
1066                          * finished.
1067                          */
1068                         if (!scsi_delete_timer(scmd))
1069                                 continue;
1070                         list_add_tail(&scmd->eh_entry, &active_list);
1071                 }
1072         }
1073         spin_unlock_irqrestore(&sdev->list_lock, flags);
1074
1075         if (!list_empty(&active_list)) {
1076                 list_for_each_safe(lh, lh_sf, &active_list) {
1077                         scmd = list_entry(lh, struct scsi_cmnd, eh_entry);
1078                         list_del_init(lh);
1079                         if (recovery &&
1080                             !scsi_eh_scmd_add(scmd, SCSI_EH_CANCEL_CMD)) {
1081                                 scmd->result = (DID_ABORT << 16);
1082                                 scsi_finish_command(scmd);
1083                         }
1084                 }
1085         }
1086
1087         return 0;
1088 }
1089 EXPORT_SYMBOL(scsi_device_cancel);
1090
1091 MODULE_DESCRIPTION("SCSI core");
1092 MODULE_LICENSE("GPL");
1093
1094 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1095 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1096
1097 static int __init init_scsi(void)
1098 {
1099         int error;
1100
1101         error = scsi_init_queue();
1102         if (error)
1103                 return error;
1104         error = scsi_init_procfs();
1105         if (error)
1106                 goto cleanup_queue;
1107         error = scsi_init_devinfo();
1108         if (error)
1109                 goto cleanup_procfs;
1110         error = scsi_init_hosts();
1111         if (error)
1112                 goto cleanup_devlist;
1113         error = scsi_init_sysctl();
1114         if (error)
1115                 goto cleanup_hosts;
1116         error = scsi_sysfs_register();
1117         if (error)
1118                 goto cleanup_sysctl;
1119
1120         scsi_netlink_init();
1121
1122         printk(KERN_NOTICE "SCSI subsystem initialized\n");
1123         return 0;
1124
1125 cleanup_sysctl:
1126         scsi_exit_sysctl();
1127 cleanup_hosts:
1128         scsi_exit_hosts();
1129 cleanup_devlist:
1130         scsi_exit_devinfo();
1131 cleanup_procfs:
1132         scsi_exit_procfs();
1133 cleanup_queue:
1134         scsi_exit_queue();
1135         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1136                -error);
1137         return error;
1138 }
1139
1140 static void __exit exit_scsi(void)
1141 {
1142         scsi_netlink_exit();
1143         scsi_sysfs_unregister();
1144         scsi_exit_sysctl();
1145         scsi_exit_hosts();
1146         scsi_exit_devinfo();
1147         scsi_exit_procfs();
1148         scsi_exit_queue();
1149 }
1150
1151 subsys_initcall(init_scsi);
1152 module_exit(exit_scsi);