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