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