drivers/scsi/scsi.c

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