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