drivers/scsi/scsi.c

   1 /*
   2  *  scsi.c Copyright (C) 1992 Drew Eckhardt
   3  *         Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
   4  *         Copyright (C) 2002, 2003 Christoph Hellwig
   5  *
   6  *  generic mid-level SCSI driver
   7  *      Initial versions: Drew Eckhardt
   8  *      Subsequent revisions: Eric Youngdale
   9  *
  10  *  <drew@colorado.edu>
  11  *
  12  *  Bug correction thanks go to :
  13  *      Rik Faith <faith@cs.unc.edu>
  14  *      Tommy Thorn <tthorn>
  15  *      Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de>
  16  *
  17  *  Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to
  18  *  add scatter-gather, multiple outstanding request, and other
  19  *  enhancements.
  20  *
  21  *  Native multichannel, wide scsi, /proc/scsi and hot plugging
  22  *  support added by Michael Neuffer <mike@i-connect.net>
  23  *
  24  *  Added request_module("scsi_hostadapter") for kerneld:
  25  *  (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf)
  26  *  Bjorn Ekwall  <bj0rn@blox.se>
  27  *  (changed to kmod)
  28  *
  29  *  Major improvements to the timeout, abort, and reset processing,
  30  *  as well as performance modifications for large queue depths by
  31  *  Leonard N. Zubkoff <lnz@dandelion.com>
  32  *
  33  *  Converted cli() code to spinlocks, Ingo Molnar
  34  *
  35  *  Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
  36  *
  37  *  out_of_space hacks, D. Gilbert (dpg) 990608
  38  */
  39
  40 #include <linux/module.h>
  41 #include <linux/moduleparam.h>
  42 #include <linux/kernel.h>
  43 #include <linux/timer.h>
  44 #include <linux/string.h>
  45 #include <linux/slab.h>
  46 #include <linux/blkdev.h>
  47 #include <linux/delay.h>
  48 #include <linux/init.h>
  49 #include <linux/completion.h>
  50 #include <linux/unistd.h>
  51 #include <linux/spinlock.h>
  52 #include <linux/kmod.h>
  53 #include <linux/interrupt.h>
  54 #include <linux/notifier.h>
  55 #include <linux/cpu.h>
  56 #include <linux/mutex.h>
  57 #include <linux/async.h>
  58 #include <asm/unaligned.h>
  59
  60 #include <scsi/scsi.h>
  61 #include <scsi/scsi_cmnd.h>
  62 #include <scsi/scsi_dbg.h>
  63 #include <scsi/scsi_device.h>
  64 #include <scsi/scsi_driver.h>
  65 #include <scsi/scsi_eh.h>
  66 #include <scsi/scsi_host.h>
  67 #include <scsi/scsi_tcq.h>
  68
  69 #include "scsi_priv.h"
  70 #include "scsi_logging.h"
  71
  72 #define CREATE_TRACE_POINTS
  73 #include <trace/events/scsi.h>
  74
  75 static void scsi_done(struct scsi_cmnd *cmd);
  76
  77 /*
  78  * Definitions and constants.
  79  */
  80
  81 /*
  82  * Note - the initial logging level can be set here to log events at boot time.
  83  * After the system is up, you may enable logging via the /proc interface.
  84  */
  85 unsigned int scsi_logging_level;
  86 #if defined(CONFIG_SCSI_LOGGING)
  87 EXPORT_SYMBOL(scsi_logging_level);
  88 #endif
  89
  90 /* sd, scsi core and power management need to coordinate flushing async actions */
  91 ASYNC_DOMAIN(scsi_sd_probe_domain);
  92 EXPORT_SYMBOL(scsi_sd_probe_domain);
  93
  94 /*
  95  * Separate domain (from scsi_sd_probe_domain) to maximize the benefit of
  96  * asynchronous system resume operations.  It is marked 'exclusive' to avoid
  97  * being included in the async_synchronize_full() that is invoked by
  98  * dpm_resume()
  99  */
 100 ASYNC_DOMAIN_EXCLUSIVE(scsi_sd_pm_domain);
 101 EXPORT_SYMBOL(scsi_sd_pm_domain);
 102
 103 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
 104  * You may not alter any existing entry (although adding new ones is
 105  * encouraged once assigned by ANSI/INCITS T10
 106  */
 107 static const char *const scsi_device_types[] = {
 108         "Direct-Access    ",
 109         "Sequential-Access",
 110         "Printer          ",
 111         "Processor        ",
 112         "WORM             ",
 113         "CD-ROM           ",
 114         "Scanner          ",
 115         "Optical Device   ",
 116         "Medium Changer   ",
 117         "Communications   ",
 118         "ASC IT8          ",
 119         "ASC IT8          ",
 120         "RAID             ",
 121         "Enclosure        ",
 122         "Direct-Access-RBC",
 123         "Optical card     ",
 124         "Bridge controller",
 125         "Object storage   ",
 126         "Automation/Drive ",
 127 };
 128
 129 /**
 130  * scsi_device_type - Return 17 char string indicating device type.
 131  * @type: type number to look up
 132  */
 133
 134 const char * scsi_device_type(unsigned type)
 135 {
 136         if (type == 0x1e)
 137                 return "Well-known LUN   ";
 138         if (type == 0x1f)
 139                 return "No Device        ";
 140         if (type >= ARRAY_SIZE(scsi_device_types))
 141                 return "Unknown          ";
 142         return scsi_device_types[type];
 143 }
 144
 145 EXPORT_SYMBOL(scsi_device_type);
 146
 147 struct scsi_host_cmd_pool {
 148         struct kmem_cache       *cmd_slab;
 149         struct kmem_cache       *sense_slab;
 150         unsigned int            users;
 151         char                    *cmd_name;
 152         char                    *sense_name;
 153         unsigned int            slab_flags;
 154         gfp_t                   gfp_mask;
 155 };
 156
 157 static struct scsi_host_cmd_pool scsi_cmd_pool = {
 158         .cmd_name       = "scsi_cmd_cache",
 159         .sense_name     = "scsi_sense_cache",
 160         .slab_flags     = SLAB_HWCACHE_ALIGN,
 161 };
 162
 163 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
 164         .cmd_name       = "scsi_cmd_cache(DMA)",
 165         .sense_name     = "scsi_sense_cache(DMA)",
 166         .slab_flags     = SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
 167         .gfp_mask       = __GFP_DMA,
 168 };
 169
 170 static DEFINE_MUTEX(host_cmd_pool_mutex);
 171
 172 /**
 173  * scsi_pool_alloc_command - internal function to get a fully allocated command
 174  * @pool:       slab pool to allocate the command from
 175  * @gfp_mask:   mask for the allocation
 176  *
 177  * Returns a fully allocated command (with the allied sense buffer) or
 178  * NULL on failure
 179  */
 180 static struct scsi_cmnd *
 181 scsi_pool_alloc_command(struct scsi_host_cmd_pool *pool, gfp_t gfp_mask)
 182 {
 183         struct scsi_cmnd *cmd;
 184
 185         cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask);
 186         if (!cmd)
 187                 return NULL;
 188
 189         cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab,
 190                                              gfp_mask | pool->gfp_mask);
 191         if (!cmd->sense_buffer) {
 192                 kmem_cache_free(pool->cmd_slab, cmd);
 193                 return NULL;
 194         }
 195
 196         return cmd;
 197 }
 198
 199 /**
 200  * scsi_pool_free_command - internal function to release a command
 201  * @pool:       slab pool to allocate the command from
 202  * @cmd:        command to release
 203  *
 204  * the command must previously have been allocated by
 205  * scsi_pool_alloc_command.
 206  */
 207 static void
 208 scsi_pool_free_command(struct scsi_host_cmd_pool *pool,
 209                          struct scsi_cmnd *cmd)
 210 {
 211         if (cmd->prot_sdb)
 212                 kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb);
 213
 214         kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
 215         kmem_cache_free(pool->cmd_slab, cmd);
 216 }
 217
 218 /**
 219  * scsi_host_alloc_command - internal function to allocate command
 220  * @shost:      SCSI host whose pool to allocate from
 221  * @gfp_mask:   mask for the allocation
 222  *
 223  * Returns a fully allocated command with sense buffer and protection
 224  * data buffer (where applicable) or NULL on failure
 225  */
 226 static struct scsi_cmnd *
 227 scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 228 {
 229         struct scsi_cmnd *cmd;
 230
 231         cmd = scsi_pool_alloc_command(shost->cmd_pool, gfp_mask);
 232         if (!cmd)
 233                 return NULL;
 234
 235         if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
 236                 cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask);
 237
 238                 if (!cmd->prot_sdb) {
 239                         scsi_pool_free_command(shost->cmd_pool, cmd);
 240                         return NULL;
 241                 }
 242         }
 243
 244         return cmd;
 245 }
 246
 247 /**
 248  * __scsi_get_command - Allocate a struct scsi_cmnd
 249  * @shost: host to transmit command
 250  * @gfp_mask: allocation mask
 251  *
 252  * Description: allocate a struct scsi_cmd from host's slab, recycling from the
 253  *              host's free_list if necessary.
 254  */
 255 struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 256 {
 257         struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask);
 258
 259         if (unlikely(!cmd)) {
 260                 unsigned long flags;
 261
 262                 spin_lock_irqsave(&shost->free_list_lock, flags);
 263                 if (likely(!list_empty(&shost->free_list))) {
 264                         cmd = list_entry(shost->free_list.next,
 265                                          struct scsi_cmnd, list);
 266                         list_del_init(&cmd->list);
 267                 }
 268                 spin_unlock_irqrestore(&shost->free_list_lock, flags);
 269
 270                 if (cmd) {
 271                         void *buf, *prot;
 272
 273                         buf = cmd->sense_buffer;
 274                         prot = cmd->prot_sdb;
 275
 276                         memset(cmd, 0, sizeof(*cmd));
 277
 278                         cmd->sense_buffer = buf;
 279                         cmd->prot_sdb = prot;
 280                 }
 281         }
 282
 283         return cmd;
 284 }
 285 EXPORT_SYMBOL_GPL(__scsi_get_command);
 286
 287 /**
 288  * scsi_get_command - Allocate and setup a scsi command block
 289  * @dev: parent scsi device
 290  * @gfp_mask: allocator flags
 291  *
 292  * Returns:     The allocated scsi command structure.
 293  */
 294 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
 295 {
 296         struct scsi_cmnd *cmd;
 297
 298         /* Bail if we can't get a reference to the device */
 299         if (!get_device(&dev->sdev_gendev))
 300                 return NULL;
 301
 302         cmd = __scsi_get_command(dev->host, gfp_mask);
 303
 304         if (likely(cmd != NULL)) {
 305                 unsigned long flags;
 306
 307                 cmd->device = dev;
 308                 INIT_LIST_HEAD(&cmd->list);
 309                 INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler);
 310                 spin_lock_irqsave(&dev->list_lock, flags);
 311                 list_add_tail(&cmd->list, &dev->cmd_list);
 312                 spin_unlock_irqrestore(&dev->list_lock, flags);
 313                 cmd->jiffies_at_alloc = jiffies;
 314         } else
 315                 put_device(&dev->sdev_gendev);
 316
 317         return cmd;
 318 }
 319 EXPORT_SYMBOL(scsi_get_command);
 320
 321 /**
 322  * __scsi_put_command - Free a struct scsi_cmnd
 323  * @shost: dev->host
 324  * @cmd: Command to free
 325  * @dev: parent scsi device
 326  */
 327 void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd,
 328                         struct device *dev)
 329 {
 330         unsigned long flags;
 331
 332         /* changing locks here, don't need to restore the irq state */
 333         spin_lock_irqsave(&shost->free_list_lock, flags);
 334         if (unlikely(list_empty(&shost->free_list))) {
 335                 list_add(&cmd->list, &shost->free_list);
 336                 cmd = NULL;
 337         }
 338         spin_unlock_irqrestore(&shost->free_list_lock, flags);
 339
 340         if (likely(cmd != NULL))
 341                 scsi_pool_free_command(shost->cmd_pool, cmd);
 342
 343         put_device(dev);
 344 }
 345 EXPORT_SYMBOL(__scsi_put_command);
 346
 347 /**
 348  * scsi_put_command - Free a scsi command block
 349  * @cmd: command block to free
 350  *
 351  * Returns:     Nothing.
 352  *
 353  * Notes:       The command must not belong to any lists.
 354  */
 355 void scsi_put_command(struct scsi_cmnd *cmd)
 356 {
 357         struct scsi_device *sdev = cmd->device;
 358         unsigned long flags;
 359
 360         /* serious error if the command hasn't come from a device list */
 361         spin_lock_irqsave(&cmd->device->list_lock, flags);
 362         BUG_ON(list_empty(&cmd->list));
 363         list_del_init(&cmd->list);
 364         spin_unlock_irqrestore(&cmd->device->list_lock, flags);
 365
 366         cancel_delayed_work(&cmd->abort_work);
 367
 368         __scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev);
 369 }
 370 EXPORT_SYMBOL(scsi_put_command);
 371
 372 static struct scsi_host_cmd_pool *scsi_get_host_cmd_pool(gfp_t gfp_mask)
 373 {
 374         struct scsi_host_cmd_pool *retval = NULL, *pool;
 375         /*
 376          * Select a command slab for this host and create it if not
 377          * yet existent.
 378          */
 379         mutex_lock(&host_cmd_pool_mutex);
 380         pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool :
 381                 &scsi_cmd_pool;
 382         if (!pool->users) {
 383                 pool->cmd_slab = kmem_cache_create(pool->cmd_name,
 384                                                    sizeof(struct scsi_cmnd), 0,
 385                                                    pool->slab_flags, NULL);
 386                 if (!pool->cmd_slab)
 387                         goto fail;
 388
 389                 pool->sense_slab = kmem_cache_create(pool->sense_name,
 390                                                      SCSI_SENSE_BUFFERSIZE, 0,
 391                                                      pool->slab_flags, NULL);
 392                 if (!pool->sense_slab) {
 393                         kmem_cache_destroy(pool->cmd_slab);
 394                         goto fail;
 395                 }
 396         }
 397
 398         pool->users++;
 399         retval = pool;
 400  fail:
 401         mutex_unlock(&host_cmd_pool_mutex);
 402         return retval;
 403 }
 404
 405 static void scsi_put_host_cmd_pool(gfp_t gfp_mask)
 406 {
 407         struct scsi_host_cmd_pool *pool;
 408
 409         mutex_lock(&host_cmd_pool_mutex);
 410         pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool :
 411                 &scsi_cmd_pool;
 412         /*
 413          * This may happen if a driver has a mismatched get and put
 414          * of the command pool; the driver should be implicated in
 415          * the stack trace
 416          */
 417         BUG_ON(pool->users == 0);
 418
 419         if (!--pool->users) {
 420                 kmem_cache_destroy(pool->cmd_slab);
 421                 kmem_cache_destroy(pool->sense_slab);
 422         }
 423         mutex_unlock(&host_cmd_pool_mutex);
 424 }
 425
 426 /**
 427  * scsi_allocate_command - get a fully allocated SCSI command
 428  * @gfp_mask:   allocation mask
 429  *
 430  * This function is for use outside of the normal host based pools.
 431  * It allocates the relevant command and takes an additional reference
 432  * on the pool it used.  This function *must* be paired with
 433  * scsi_free_command which also has the identical mask, otherwise the
 434  * free pool counts will eventually go wrong and you'll trigger a bug.
 435  *
 436  * This function should *only* be used by drivers that need a static
 437  * command allocation at start of day for internal functions.
 438  */
 439 struct scsi_cmnd *scsi_allocate_command(gfp_t gfp_mask)
 440 {
 441         struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
 442
 443         if (!pool)
 444                 return NULL;
 445
 446         return scsi_pool_alloc_command(pool, gfp_mask);
 447 }
 448 EXPORT_SYMBOL(scsi_allocate_command);
 449
 450 /**
 451  * scsi_free_command - free a command allocated by scsi_allocate_command
 452  * @gfp_mask:   mask used in the original allocation
 453  * @cmd:        command to free
 454  *
 455  * Note: using the original allocation mask is vital because that's
 456  * what determines which command pool we use to free the command.  Any
 457  * mismatch will cause the system to BUG eventually.
 458  */
 459 void scsi_free_command(gfp_t gfp_mask, struct scsi_cmnd *cmd)
 460 {
 461         struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
 462
 463         /*
 464          * this could trigger if the mask to scsi_allocate_command
 465          * doesn't match this mask.  Otherwise we're guaranteed that this
 466          * succeeds because scsi_allocate_command must have taken a reference
 467          * on the pool
 468          */
 469         BUG_ON(!pool);
 470
 471         scsi_pool_free_command(pool, cmd);
 472         /*
 473          * scsi_put_host_cmd_pool is called twice; once to release the
 474          * reference we took above, and once to release the reference
 475          * originally taken by scsi_allocate_command
 476          */
 477         scsi_put_host_cmd_pool(gfp_mask);
 478         scsi_put_host_cmd_pool(gfp_mask);
 479 }
 480 EXPORT_SYMBOL(scsi_free_command);
 481
 482 /**
 483  * scsi_setup_command_freelist - Setup the command freelist for a scsi host.
 484  * @shost: host to allocate the freelist for.
 485  *
 486  * Description: The command freelist protects against system-wide out of memory
 487  * deadlock by preallocating one SCSI command structure for each host, so the
 488  * system can always write to a swap file on a device associated with that host.
 489  *
 490  * Returns:     Nothing.
 491  */
 492 int scsi_setup_command_freelist(struct Scsi_Host *shost)
 493 {
 494         struct scsi_cmnd *cmd;
 495         const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL;
 496
 497         spin_lock_init(&shost->free_list_lock);
 498         INIT_LIST_HEAD(&shost->free_list);
 499
 500         shost->cmd_pool = scsi_get_host_cmd_pool(gfp_mask);
 501
 502         if (!shost->cmd_pool)
 503                 return -ENOMEM;
 504
 505         /*
 506          * Get one backup command for this host.
 507          */
 508         cmd = scsi_host_alloc_command(shost, gfp_mask);
 509         if (!cmd) {
 510                 scsi_put_host_cmd_pool(gfp_mask);
 511                 shost->cmd_pool = NULL;
 512                 return -ENOMEM;
 513         }
 514         list_add(&cmd->list, &shost->free_list);
 515         return 0;
 516 }
 517
 518 /**
 519  * scsi_destroy_command_freelist - Release the command freelist for a scsi host.
 520  * @shost: host whose freelist is going to be destroyed
 521  */
 522 void scsi_destroy_command_freelist(struct Scsi_Host *shost)
 523 {
 524         /*
 525          * If cmd_pool is NULL the free list was not initialized, so
 526          * do not attempt to release resources.
 527          */
 528         if (!shost->cmd_pool)
 529                 return;
 530
 531         while (!list_empty(&shost->free_list)) {
 532                 struct scsi_cmnd *cmd;
 533
 534                 cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
 535                 list_del_init(&cmd->list);
 536                 scsi_pool_free_command(shost->cmd_pool, cmd);
 537         }
 538         shost->cmd_pool = NULL;
 539         scsi_put_host_cmd_pool(shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL);
 540 }
 541
 542 #ifdef CONFIG_SCSI_LOGGING
 543 void scsi_log_send(struct scsi_cmnd *cmd)
 544 {
 545         unsigned int level;
 546
 547         /*
 548          * If ML QUEUE log level is greater than or equal to:
 549          *
 550          * 1: nothing (match completion)
 551          *
 552          * 2: log opcode + command of all commands
 553          *
 554          * 3: same as 2 plus dump cmd address
 555          *
 556          * 4: same as 3 plus dump extra junk
 557          */
 558         if (unlikely(scsi_logging_level)) {
 559                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
 560                                        SCSI_LOG_MLQUEUE_BITS);
 561                 if (level > 1) {
 562                         scmd_printk(KERN_INFO, cmd, "Send: ");
 563                         if (level > 2)
 564                                 printk("0x%p ", cmd);
 565                         printk("\n");
 566                         scsi_print_command(cmd);
 567                         if (level > 3) {
 568                                 printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
 569                                        " queuecommand 0x%p\n",
 570                                         scsi_sglist(cmd), scsi_bufflen(cmd),
 571                                         cmd->device->host->hostt->queuecommand);
 572
 573                         }
 574                 }
 575         }
 576 }
 577
 578 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
 579 {
 580         unsigned int level;
 581
 582         /*
 583          * If ML COMPLETE log level is greater than or equal to:
 584          *
 585          * 1: log disposition, result, opcode + command, and conditionally
 586          * sense data for failures or non SUCCESS dispositions.
 587          *
 588          * 2: same as 1 but for all command completions.
 589          *
 590          * 3: same as 2 plus dump cmd address
 591          *
 592          * 4: same as 3 plus dump extra junk
 593          */
 594         if (unlikely(scsi_logging_level)) {
 595                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
 596                                        SCSI_LOG_MLCOMPLETE_BITS);
 597                 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
 598                     (level > 1)) {
 599                         scmd_printk(KERN_INFO, cmd, "Done: ");
 600                         if (level > 2)
 601                                 printk("0x%p ", cmd);
 602                         /*
 603                          * Dump truncated values, so we usually fit within
 604                          * 80 chars.
 605                          */
 606                         switch (disposition) {
 607                         case SUCCESS:
 608                                 printk("SUCCESS\n");
 609                                 break;
 610                         case NEEDS_RETRY:
 611                                 printk("RETRY\n");
 612                                 break;
 613                         case ADD_TO_MLQUEUE:
 614                                 printk("MLQUEUE\n");
 615                                 break;
 616                         case FAILED:
 617                                 printk("FAILED\n");
 618                                 break;
 619                         case TIMEOUT_ERROR:
 620                                 /*
 621                                  * If called via scsi_times_out.
 622                                  */
 623                                 printk("TIMEOUT\n");
 624                                 break;
 625                         default:
 626                                 printk("UNKNOWN\n");
 627                         }
 628                         scsi_print_result(cmd);
 629                         scsi_print_command(cmd);
 630                         if (status_byte(cmd->result) & CHECK_CONDITION)
 631                                 scsi_print_sense("", cmd);
 632                         if (level > 3)
 633                                 scmd_printk(KERN_INFO, cmd,
 634                                             "scsi host busy %d failed %d\n",
 635                                             cmd->device->host->host_busy,
 636                                             cmd->device->host->host_failed);
 637                 }
 638         }
 639 }
 640 #endif
 641
 642 /**
 643  * scsi_cmd_get_serial - Assign a serial number to a command
 644  * @host: the scsi host
 645  * @cmd: command to assign serial number to
 646  *
 647  * Description: a serial number identifies a request for error recovery
 648  * and debugging purposes.  Protected by the Host_Lock of host.
 649  */
 650 void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 651 {
 652         cmd->serial_number = host->cmd_serial_number++;
 653         if (cmd->serial_number == 0)
 654                 cmd->serial_number = host->cmd_serial_number++;
 655 }
 656 EXPORT_SYMBOL(scsi_cmd_get_serial);
 657
 658 /**
 659  * scsi_dispatch_command - Dispatch a command to the low-level driver.
 660  * @cmd: command block we are dispatching.
 661  *
 662  * Return: nonzero return request was rejected and device's queue needs to be
 663  * plugged.
 664  */
 665 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
 666 {
 667         struct Scsi_Host *host = cmd->device->host;
 668         int rtn = 0;
 669
 670         atomic_inc(&cmd->device->iorequest_cnt);
 671
 672         /* check if the device is still usable */
 673         if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
 674                 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
 675                  * returns an immediate error upwards, and signals
 676                  * that the device is no longer present */
 677                 cmd->result = DID_NO_CONNECT << 16;
 678                 scsi_done(cmd);
 679                 /* return 0 (because the command has been processed) */
 680                 goto out;
 681         }
 682
 683         /* Check to see if the scsi lld made this device blocked. */
 684         if (unlikely(scsi_device_blocked(cmd->device))) {
 685                 /*
 686                  * in blocked state, the command is just put back on
 687                  * the device queue.  The suspend state has already
 688                  * blocked the queue so future requests should not
 689                  * occur until the device transitions out of the
 690                  * suspend state.
 691                  */
 692
 693                 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
 694
 695                 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
 696
 697                 /*
 698                  * NOTE: rtn is still zero here because we don't need the
 699                  * queue to be plugged on return (it's already stopped)
 700                  */
 701                 goto out;
 702         }
 703
 704         /*
 705          * If SCSI-2 or lower, store the LUN value in cmnd.
 706          */
 707         if (cmd->device->scsi_level <= SCSI_2 &&
 708             cmd->device->scsi_level != SCSI_UNKNOWN) {
 709                 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
 710                                (cmd->device->lun << 5 & 0xe0);
 711         }
 712
 713         scsi_log_send(cmd);
 714
 715         /*
 716          * Before we queue this command, check if the command
 717          * length exceeds what the host adapter can handle.
 718          */
 719         if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
 720                 SCSI_LOG_MLQUEUE(3,
 721                         printk("queuecommand : command too long. "
 722                                "cdb_size=%d host->max_cmd_len=%d\n",
 723                                cmd->cmd_len, cmd->device->host->max_cmd_len));
 724                 cmd->result = (DID_ABORT << 16);
 725
 726                 scsi_done(cmd);
 727                 goto out;
 728         }
 729
 730         if (unlikely(host->shost_state == SHOST_DEL)) {
 731                 cmd->result = (DID_NO_CONNECT << 16);
 732                 scsi_done(cmd);
 733         } else {
 734                 trace_scsi_dispatch_cmd_start(cmd);
 735                 cmd->scsi_done = scsi_done;
 736                 rtn = host->hostt->queuecommand(host, cmd);
 737         }
 738
 739         if (rtn) {
 740                 trace_scsi_dispatch_cmd_error(cmd, rtn);
 741                 if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
 742                     rtn != SCSI_MLQUEUE_TARGET_BUSY)
 743                         rtn = SCSI_MLQUEUE_HOST_BUSY;
 744
 745                 scsi_queue_insert(cmd, rtn);
 746
 747                 SCSI_LOG_MLQUEUE(3,
 748                     printk("queuecommand : request rejected\n"));
 749         }
 750
 751  out:
 752         SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
 753         return rtn;
 754 }
 755
 756 /**
 757  * scsi_done - Invoke completion on finished SCSI command.
 758  * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
 759  * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
 760  *
 761  * Description: This function is the mid-level's (SCSI Core) interrupt routine,
 762  * which regains ownership of the SCSI command (de facto) from a LLDD, and
 763  * calls blk_complete_request() for further processing.
 764  *
 765  * This function is interrupt context safe.
 766  */
 767 static void scsi_done(struct scsi_cmnd *cmd)
 768 {
 769         trace_scsi_dispatch_cmd_done(cmd);
 770         blk_complete_request(cmd->request);
 771 }
 772
 773 /**
 774  * scsi_finish_command - cleanup and pass command back to upper layer
 775  * @cmd: the command
 776  *
 777  * Description: Pass command off to upper layer for finishing of I/O
 778  *              request, waking processes that are waiting on results,
 779  *              etc.
 780  */
 781 void scsi_finish_command(struct scsi_cmnd *cmd)
 782 {
 783         struct scsi_device *sdev = cmd->device;
 784         struct scsi_target *starget = scsi_target(sdev);
 785         struct Scsi_Host *shost = sdev->host;
 786         struct scsi_driver *drv;
 787         unsigned int good_bytes;
 788
 789         scsi_device_unbusy(sdev);
 790
 791         /*
 792          * Clear the flags which say that the device/host is no longer
 793          * capable of accepting new commands.  These are set in scsi_queue.c
 794          * for both the queue full condition on a device, and for a
 795          * host full condition on the host.
 796          *
 797          * XXX(hch): What about locking?
 798          */
 799         shost->host_blocked = 0;
 800         starget->target_blocked = 0;
 801         sdev->device_blocked = 0;
 802
 803         /*
 804          * If we have valid sense information, then some kind of recovery
 805          * must have taken place.  Make a note of this.
 806          */
 807         if (SCSI_SENSE_VALID(cmd))
 808                 cmd->result |= (DRIVER_SENSE << 24);
 809
 810         SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
 811                                 "Notifying upper driver of completion "
 812                                 "(result %x)\n", cmd->result));
 813
 814         good_bytes = scsi_bufflen(cmd);
 815         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
 816                 int old_good_bytes = good_bytes;
 817                 drv = scsi_cmd_to_driver(cmd);
 818                 if (drv->done)
 819                         good_bytes = drv->done(cmd);
 820                 /*
 821                  * USB may not give sense identifying bad sector and
 822                  * simply return a residue instead, so subtract off the
 823                  * residue if drv->done() error processing indicates no
 824                  * change to the completion length.
 825                  */
 826                 if (good_bytes == old_good_bytes)
 827                         good_bytes -= scsi_get_resid(cmd);
 828         }
 829         scsi_io_completion(cmd, good_bytes);
 830 }
 831 EXPORT_SYMBOL(scsi_finish_command);
 832
 833 /**
 834  * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
 835  * @sdev: SCSI Device in question
 836  * @tagged: Do we use tagged queueing (non-0) or do we treat
 837  *          this device as an untagged device (0)
 838  * @tags: Number of tags allowed if tagged queueing enabled,
 839  *        or number of commands the low level driver can
 840  *        queue up in non-tagged mode (as per cmd_per_lun).
 841  *
 842  * Returns:     Nothing
 843  *
 844  * Lock Status: None held on entry
 845  *
 846  * Notes:       Low level drivers may call this at any time and we will do
 847  *              the right thing depending on whether or not the device is
 848  *              currently active and whether or not it even has the
 849  *              command blocks built yet.
 850  */
 851 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
 852 {
 853         unsigned long flags;
 854
 855         /*
 856          * refuse to set tagged depth to an unworkable size
 857          */
 858         if (tags <= 0)
 859                 return;
 860
 861         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 862
 863         /*
 864          * Check to see if the queue is managed by the block layer.
 865          * If it is, and we fail to adjust the depth, exit.
 866          *
 867          * Do not resize the tag map if it is a host wide share bqt,
 868          * because the size should be the hosts's can_queue. If there
 869          * is more IO than the LLD's can_queue (so there are not enuogh
 870          * tags) request_fn's host queue ready check will handle it.
 871          */
 872         if (!sdev->host->bqt) {
 873                 if (blk_queue_tagged(sdev->request_queue) &&
 874                     blk_queue_resize_tags(sdev->request_queue, tags) != 0)
 875                         goto out;
 876         }
 877
 878         sdev->queue_depth = tags;
 879         switch (tagged) {
 880                 case MSG_ORDERED_TAG:
 881                         sdev->ordered_tags = 1;
 882                         sdev->simple_tags = 1;
 883                         break;
 884                 case MSG_SIMPLE_TAG:
 885                         sdev->ordered_tags = 0;
 886                         sdev->simple_tags = 1;
 887                         break;
 888                 default:
 889                         sdev_printk(KERN_WARNING, sdev,
 890                                     "scsi_adjust_queue_depth, bad queue type, "
 891                                     "disabled\n");
 892                 case 0:
 893                         sdev->ordered_tags = sdev->simple_tags = 0;
 894                         sdev->queue_depth = tags;
 895                         break;
 896         }
 897  out:
 898         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 899 }
 900 EXPORT_SYMBOL(scsi_adjust_queue_depth);
 901
 902 /**
 903  * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
 904  * @sdev: SCSI Device in question
 905  * @depth: Current number of outstanding SCSI commands on this device,
 906  *         not counting the one returned as QUEUE_FULL.
 907  *
 908  * Description: This function will track successive QUEUE_FULL events on a
 909  *              specific SCSI device to determine if and when there is a
 910  *              need to adjust the queue depth on the device.
 911  *
 912  * Returns:     0 - No change needed, >0 - Adjust queue depth to this new depth,
 913  *              -1 - Drop back to untagged operation using host->cmd_per_lun
 914  *                      as the untagged command depth
 915  *
 916  * Lock Status: None held on entry
 917  *
 918  * Notes:       Low level drivers may call this at any time and we will do
 919  *              "The Right Thing."  We are interrupt context safe.
 920  */
 921 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 922 {
 923
 924         /*
 925          * Don't let QUEUE_FULLs on the same
 926          * jiffies count, they could all be from
 927          * same event.
 928          */
 929         if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
 930                 return 0;
 931
 932         sdev->last_queue_full_time = jiffies;
 933         if (sdev->last_queue_full_depth != depth) {
 934                 sdev->last_queue_full_count = 1;
 935                 sdev->last_queue_full_depth = depth;
 936         } else {
 937                 sdev->last_queue_full_count++;
 938         }
 939
 940         if (sdev->last_queue_full_count <= 10)
 941                 return 0;
 942         if (sdev->last_queue_full_depth < 8) {
 943                 /* Drop back to untagged */
 944                 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 945                 return -1;
 946         }
 947
 948         if (sdev->ordered_tags)
 949                 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
 950         else
 951                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
 952         return depth;
 953 }
 954 EXPORT_SYMBOL(scsi_track_queue_full);
 955
 956 /**
 957  * scsi_vpd_inquiry - Request a device provide us with a VPD page
 958  * @sdev: The device to ask
 959  * @buffer: Where to put the result
 960  * @page: Which Vital Product Data to return
 961  * @len: The length of the buffer
 962  *
 963  * This is an internal helper function.  You probably want to use
 964  * scsi_get_vpd_page instead.
 965  *
 966  * Returns 0 on success or a negative error number.
 967  */
 968 static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
 969                                                         u8 page, unsigned len)
 970 {
 971         int result;
 972         unsigned char cmd[16];
 973
 974         cmd[0] = INQUIRY;
 975         cmd[1] = 1;             /* EVPD */
 976         cmd[2] = page;
 977         cmd[3] = len >> 8;
 978         cmd[4] = len & 0xff;
 979         cmd[5] = 0;             /* Control byte */
 980
 981         /*
 982          * I'm not convinced we need to try quite this hard to get VPD, but
 983          * all the existing users tried this hard.
 984          */
 985         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
 986                                   len, NULL, 30 * HZ, 3, NULL);
 987         if (result)
 988                 return result;
 989
 990         /* Sanity check that we got the page back that we asked for */
 991         if (buffer[1] != page)
 992                 return -EIO;
 993
 994         return 0;
 995 }
 996
 997 /**
 998  * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
 999  * @sdev: The device to ask
1000  * @page: Which Vital Product Data to return
1001  * @buf: where to store the VPD
1002  * @buf_len: number of bytes in the VPD buffer area
1003  *
1004  * SCSI devices may optionally supply Vital Product Data.  Each 'page'
1005  * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
1006  * If the device supports this VPD page, this routine returns a pointer
1007  * to a buffer containing the data from that page.  The caller is
1008  * responsible for calling kfree() on this pointer when it is no longer
1009  * needed.  If we cannot retrieve the VPD page this routine returns %NULL.
1010  */
1011 int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
1012                       int buf_len)
1013 {
1014         int i, result;
1015
1016         if (sdev->skip_vpd_pages)
1017                 goto fail;
1018
1019         /* Ask for all the pages supported by this device */
1020         result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
1021         if (result)
1022                 goto fail;
1023
1024         /* If the user actually wanted this page, we can skip the rest */
1025         if (page == 0)
1026                 return 0;
1027
1028         for (i = 0; i < min((int)buf[3], buf_len - 4); i++)
1029                 if (buf[i + 4] == page)
1030                         goto found;
1031
1032         if (i < buf[3] && i >= buf_len - 4)
1033                 /* ran off the end of the buffer, give us benefit of doubt */
1034                 goto found;
1035         /* The device claims it doesn't support the requested page */
1036         goto fail;
1037
1038  found:
1039         result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
1040         if (result)
1041                 goto fail;
1042
1043         return 0;
1044
1045  fail:
1046         return -EINVAL;
1047 }
1048 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
1049
1050 /**
1051  * scsi_report_opcode - Find out if a given command opcode is supported
1052  * @sdev:       scsi device to query
1053  * @buffer:     scratch buffer (must be at least 20 bytes long)
1054  * @len:        length of buffer
1055  * @opcode:     opcode for command to look up
1056  *
1057  * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
1058  * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is
1059  * unsupported and 1 if the device claims to support the command.
1060  */
1061 int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
1062                        unsigned int len, unsigned char opcode)
1063 {
1064         unsigned char cmd[16];
1065         struct scsi_sense_hdr sshdr;
1066         int result;
1067
1068         if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
1069                 return -EINVAL;
1070
1071         memset(cmd, 0, 16);
1072         cmd[0] = MAINTENANCE_IN;
1073         cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
1074         cmd[2] = 1;             /* One command format */
1075         cmd[3] = opcode;
1076         put_unaligned_be32(len, &cmd[6]);
1077         memset(buffer, 0, len);
1078
1079         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
1080                                   &sshdr, 30 * HZ, 3, NULL);
1081
1082         if (result && scsi_sense_valid(&sshdr) &&
1083             sshdr.sense_key == ILLEGAL_REQUEST &&
1084             (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
1085                 return -EINVAL;
1086
1087         if ((buffer[1] & 3) == 3) /* Command supported */
1088                 return 1;
1089
1090         return 0;
1091 }
1092 EXPORT_SYMBOL(scsi_report_opcode);
1093
1094 /**
1095  * scsi_device_get  -  get an additional reference to a scsi_device
1096  * @sdev:       device to get a reference to
1097  *
1098  * Description: Gets a reference to the scsi_device and increments the use count
1099  * of the underlying LLDD module.  You must hold host_lock of the
1100  * parent Scsi_Host or already have a reference when calling this.
1101  */
1102 int scsi_device_get(struct scsi_device *sdev)
1103 {
1104         if (sdev->sdev_state == SDEV_DEL)
1105                 return -ENXIO;
1106         if (!get_device(&sdev->sdev_gendev))
1107                 return -ENXIO;
1108         /* We can fail this if we're doing SCSI operations
1109          * from module exit (like cache flush) */
1110         try_module_get(sdev->host->hostt->module);
1111
1112         return 0;
1113 }
1114 EXPORT_SYMBOL(scsi_device_get);
1115
1116 /**
1117  * scsi_device_put  -  release a reference to a scsi_device
1118  * @sdev:       device to release a reference on.
1119  *
1120  * Description: Release a reference to the scsi_device and decrements the use
1121  * count of the underlying LLDD module.  The device is freed once the last
1122  * user vanishes.
1123  */
1124 void scsi_device_put(struct scsi_device *sdev)
1125 {
1126 #ifdef CONFIG_MODULE_UNLOAD
1127         struct module *module = sdev->host->hostt->module;
1128
1129         /* The module refcount will be zero if scsi_device_get()
1130          * was called from a module removal routine */
1131         if (module && module_refcount(module) != 0)
1132                 module_put(module);
1133 #endif
1134         put_device(&sdev->sdev_gendev);
1135 }
1136 EXPORT_SYMBOL(scsi_device_put);
1137
1138 /* helper for shost_for_each_device, see that for documentation */
1139 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1140                                            struct scsi_device *prev)
1141 {
1142         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1143         struct scsi_device *next = NULL;
1144         unsigned long flags;
1145
1146         spin_lock_irqsave(shost->host_lock, flags);
1147         while (list->next != &shost->__devices) {
1148                 next = list_entry(list->next, struct scsi_device, siblings);
1149                 /* skip devices that we can't get a reference to */
1150                 if (!scsi_device_get(next))
1151                         break;
1152                 next = NULL;
1153                 list = list->next;
1154         }
1155         spin_unlock_irqrestore(shost->host_lock, flags);
1156
1157         if (prev)
1158                 scsi_device_put(prev);
1159         return next;
1160 }
1161 EXPORT_SYMBOL(__scsi_iterate_devices);
1162
1163 /**
1164  * starget_for_each_device  -  helper to walk all devices of a target
1165  * @starget:    target whose devices we want to iterate over.
1166  * @data:       Opaque passed to each function call.
1167  * @fn:         Function to call on each device
1168  *
1169  * This traverses over each device of @starget.  The devices have
1170  * a reference that must be released by scsi_host_put when breaking
1171  * out of the loop.
1172  */
1173 void starget_for_each_device(struct scsi_target *starget, void *data,
1174                      void (*fn)(struct scsi_device *, void *))
1175 {
1176         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1177         struct scsi_device *sdev;
1178
1179         shost_for_each_device(sdev, shost) {
1180                 if ((sdev->channel == starget->channel) &&
1181                     (sdev->id == starget->id))
1182                         fn(sdev, data);
1183         }
1184 }
1185 EXPORT_SYMBOL(starget_for_each_device);
1186
1187 /**
1188  * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1189  * @starget:    target whose devices we want to iterate over.
1190  * @data:       parameter for callback @fn()
1191  * @fn:         callback function that is invoked for each device
1192  *
1193  * This traverses over each device of @starget.  It does _not_
1194  * take a reference on the scsi_device, so the whole loop must be
1195  * protected by shost->host_lock.
1196  *
1197  * Note:  The only reason why drivers would want to use this is because
1198  * they need to access the device list in irq context.  Otherwise you
1199  * really want to use starget_for_each_device instead.
1200  **/
1201 void __starget_for_each_device(struct scsi_target *starget, void *data,
1202                                void (*fn)(struct scsi_device *, void *))
1203 {
1204         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1205         struct scsi_device *sdev;
1206
1207         __shost_for_each_device(sdev, shost) {
1208                 if ((sdev->channel == starget->channel) &&
1209                     (sdev->id == starget->id))
1210                         fn(sdev, data);
1211         }
1212 }
1213 EXPORT_SYMBOL(__starget_for_each_device);
1214
1215 /**
1216  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1217  * @starget:    SCSI target pointer
1218  * @lun:        SCSI Logical Unit Number
1219  *
1220  * Description: Looks up the scsi_device with the specified @lun for a given
1221  * @starget.  The returned scsi_device does not have an additional
1222  * reference.  You must hold the host's host_lock over this call and
1223  * any access to the returned scsi_device. A scsi_device in state
1224  * SDEV_DEL is skipped.
1225  *
1226  * Note:  The only reason why drivers should use this is because
1227  * they need to access the device list in irq context.  Otherwise you
1228  * really want to use scsi_device_lookup_by_target instead.
1229  **/
1230 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1231                                                    uint lun)
1232 {
1233         struct scsi_device *sdev;
1234
1235         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1236                 if (sdev->sdev_state == SDEV_DEL)
1237                         continue;
1238                 if (sdev->lun ==lun)
1239                         return sdev;
1240         }
1241
1242         return NULL;
1243 }
1244 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1245
1246 /**
1247  * scsi_device_lookup_by_target - find a device given the target
1248  * @starget:    SCSI target pointer
1249  * @lun:        SCSI Logical Unit Number
1250  *
1251  * Description: Looks up the scsi_device with the specified @lun for a given
1252  * @starget.  The returned scsi_device has an additional reference that
1253  * needs to be released with scsi_device_put once you're done with it.
1254  **/
1255 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1256                                                  uint lun)
1257 {
1258         struct scsi_device *sdev;
1259         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1260         unsigned long flags;
1261
1262         spin_lock_irqsave(shost->host_lock, flags);
1263         sdev = __scsi_device_lookup_by_target(starget, lun);
1264         if (sdev && scsi_device_get(sdev))
1265                 sdev = NULL;
1266         spin_unlock_irqrestore(shost->host_lock, flags);
1267
1268         return sdev;
1269 }
1270 EXPORT_SYMBOL(scsi_device_lookup_by_target);
1271
1272 /**
1273  * __scsi_device_lookup - find a device given the host (UNLOCKED)
1274  * @shost:      SCSI host pointer
1275  * @channel:    SCSI channel (zero if only one channel)
1276  * @id:         SCSI target number (physical unit number)
1277  * @lun:        SCSI Logical Unit Number
1278  *
1279  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1280  * for a given host. The returned scsi_device does not have an additional
1281  * reference.  You must hold the host's host_lock over this call and any access
1282  * to the returned scsi_device.
1283  *
1284  * Note:  The only reason why drivers would want to use this is because
1285  * they need to access the device list in irq context.  Otherwise you
1286  * really want to use scsi_device_lookup instead.
1287  **/
1288 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1289                 uint channel, uint id, uint lun)
1290 {
1291         struct scsi_device *sdev;
1292
1293         list_for_each_entry(sdev, &shost->__devices, siblings) {
1294                 if (sdev->channel == channel && sdev->id == id &&
1295                                 sdev->lun ==lun)
1296                         return sdev;
1297         }
1298
1299         return NULL;
1300 }
1301 EXPORT_SYMBOL(__scsi_device_lookup);
1302
1303 /**
1304  * scsi_device_lookup - find a device given the host
1305  * @shost:      SCSI host pointer
1306  * @channel:    SCSI channel (zero if only one channel)
1307  * @id:         SCSI target number (physical unit number)
1308  * @lun:        SCSI Logical Unit Number
1309  *
1310  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1311  * for a given host.  The returned scsi_device has an additional reference that
1312  * needs to be released with scsi_device_put once you're done with it.
1313  **/
1314 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1315                 uint channel, uint id, uint lun)
1316 {
1317         struct scsi_device *sdev;
1318         unsigned long flags;
1319
1320         spin_lock_irqsave(shost->host_lock, flags);
1321         sdev = __scsi_device_lookup(shost, channel, id, lun);
1322         if (sdev && scsi_device_get(sdev))
1323                 sdev = NULL;
1324         spin_unlock_irqrestore(shost->host_lock, flags);
1325
1326         return sdev;
1327 }
1328 EXPORT_SYMBOL(scsi_device_lookup);
1329
1330 MODULE_DESCRIPTION("SCSI core");
1331 MODULE_LICENSE("GPL");
1332
1333 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1334 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1335
1336 static int __init init_scsi(void)
1337 {
1338         int error;
1339
1340         error = scsi_init_queue();
1341         if (error)
1342                 return error;
1343         error = scsi_init_procfs();
1344         if (error)
1345                 goto cleanup_queue;
1346         error = scsi_init_devinfo();
1347         if (error)
1348                 goto cleanup_procfs;
1349         error = scsi_init_hosts();
1350         if (error)
1351                 goto cleanup_devlist;
1352         error = scsi_init_sysctl();
1353         if (error)
1354                 goto cleanup_hosts;
1355         error = scsi_sysfs_register();
1356         if (error)
1357                 goto cleanup_sysctl;
1358
1359         scsi_netlink_init();
1360
1361         printk(KERN_NOTICE "SCSI subsystem initialized\n");
1362         return 0;
1363
1364 cleanup_sysctl:
1365         scsi_exit_sysctl();
1366 cleanup_hosts:
1367         scsi_exit_hosts();
1368 cleanup_devlist:
1369         scsi_exit_devinfo();
1370 cleanup_procfs:
1371         scsi_exit_procfs();
1372 cleanup_queue:
1373         scsi_exit_queue();
1374         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1375                -error);
1376         return error;
1377 }
1378
1379 static void __exit exit_scsi(void)
1380 {
1381         scsi_netlink_exit();
1382         scsi_sysfs_unregister();
1383         scsi_exit_sysctl();
1384         scsi_exit_hosts();
1385         scsi_exit_devinfo();
1386         scsi_exit_procfs();
1387         scsi_exit_queue();
1388         async_unregister_domain(&scsi_sd_probe_domain);
1389 }
1390
1391 subsys_initcall(init_scsi);
1392 module_exit(exit_scsi);