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 #include <asm/unaligned.h>
  59
  60 #include <scsi/scsi.h>
  61 #include <scsi/scsi_cmnd.h>
  62 #include <scsi/scsi_dbg.h>
  63 #include <scsi/scsi_device.h>
  64 #include <scsi/scsi_driver.h>
  65 #include <scsi/scsi_eh.h>
  66 #include <scsi/scsi_host.h>
  67 #include <scsi/scsi_tcq.h>
  68
  69 #include "scsi_priv.h"
  70 #include "scsi_logging.h"
  71
  72 #define CREATE_TRACE_POINTS
  73 #include <trace/events/scsi.h>
  74
  75 static void scsi_done(struct scsi_cmnd *cmd);
  76
  77 /*
  78  * Definitions and constants.
  79  */
  80
  81 /*
  82  * Note - the initial logging level can be set here to log events at boot time.
  83  * After the system is up, you may enable logging via the /proc interface.
  84  */
  85 unsigned int scsi_logging_level;
  86 #if defined(CONFIG_SCSI_LOGGING)
  87 EXPORT_SYMBOL(scsi_logging_level);
  88 #endif
  89
  90 /* sd, scsi core and power management need to coordinate flushing async actions */
  91 ASYNC_DOMAIN(scsi_sd_probe_domain);
  92 EXPORT_SYMBOL(scsi_sd_probe_domain);
  93
  94 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
  95  * You may not alter any existing entry (although adding new ones is
  96  * encouraged once assigned by ANSI/INCITS T10
  97  */
  98 static const char *const scsi_device_types[] = {
  99         "Direct-Access    ",
 100         "Sequential-Access",
 101         "Printer          ",
 102         "Processor        ",
 103         "WORM             ",
 104         "CD-ROM           ",
 105         "Scanner          ",
 106         "Optical Device   ",
 107         "Medium Changer   ",
 108         "Communications   ",
 109         "ASC IT8          ",
 110         "ASC IT8          ",
 111         "RAID             ",
 112         "Enclosure        ",
 113         "Direct-Access-RBC",
 114         "Optical card     ",
 115         "Bridge controller",
 116         "Object storage   ",
 117         "Automation/Drive ",
 118 };
 119
 120 /**
 121  * scsi_device_type - Return 17 char string indicating device type.
 122  * @type: type number to look up
 123  */
 124
 125 const char * scsi_device_type(unsigned type)
 126 {
 127         if (type == 0x1e)
 128                 return "Well-known LUN   ";
 129         if (type == 0x1f)
 130                 return "No Device        ";
 131         if (type >= ARRAY_SIZE(scsi_device_types))
 132                 return "Unknown          ";
 133         return scsi_device_types[type];
 134 }
 135
 136 EXPORT_SYMBOL(scsi_device_type);
 137
 138 struct scsi_host_cmd_pool {
 139         struct kmem_cache       *cmd_slab;
 140         struct kmem_cache       *sense_slab;
 141         unsigned int            users;
 142         char                    *cmd_name;
 143         char                    *sense_name;
 144         unsigned int            slab_flags;
 145         gfp_t                   gfp_mask;
 146 };
 147
 148 static struct scsi_host_cmd_pool scsi_cmd_pool = {
 149         .cmd_name       = "scsi_cmd_cache",
 150         .sense_name     = "scsi_sense_cache",
 151         .slab_flags     = SLAB_HWCACHE_ALIGN,
 152 };
 153
 154 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
 155         .cmd_name       = "scsi_cmd_cache(DMA)",
 156         .sense_name     = "scsi_sense_cache(DMA)",
 157         .slab_flags     = SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
 158         .gfp_mask       = __GFP_DMA,
 159 };
 160
 161 static DEFINE_MUTEX(host_cmd_pool_mutex);
 162
 163 /**
 164  * scsi_pool_alloc_command - internal function to get a fully allocated command
 165  * @pool:       slab pool to allocate the command from
 166  * @gfp_mask:   mask for the allocation
 167  *
 168  * Returns a fully allocated command (with the allied sense buffer) or
 169  * NULL on failure
 170  */
 171 static struct scsi_cmnd *
 172 scsi_pool_alloc_command(struct scsi_host_cmd_pool *pool, gfp_t gfp_mask)
 173 {
 174         struct scsi_cmnd *cmd;
 175
 176         cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask);
 177         if (!cmd)
 178                 return NULL;
 179
 180         cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab,
 181                                              gfp_mask | pool->gfp_mask);
 182         if (!cmd->sense_buffer) {
 183                 kmem_cache_free(pool->cmd_slab, cmd);
 184                 return NULL;
 185         }
 186
 187         return cmd;
 188 }
 189
 190 /**
 191  * scsi_pool_free_command - internal function to release a command
 192  * @pool:       slab pool to allocate the command from
 193  * @cmd:        command to release
 194  *
 195  * the command must previously have been allocated by
 196  * scsi_pool_alloc_command.
 197  */
 198 static void
 199 scsi_pool_free_command(struct scsi_host_cmd_pool *pool,
 200                          struct scsi_cmnd *cmd)
 201 {
 202         if (cmd->prot_sdb)
 203                 kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb);
 204
 205         kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
 206         kmem_cache_free(pool->cmd_slab, cmd);
 207 }
 208
 209 /**
 210  * scsi_host_alloc_command - internal function to allocate command
 211  * @shost:      SCSI host whose pool to allocate from
 212  * @gfp_mask:   mask for the allocation
 213  *
 214  * Returns a fully allocated command with sense buffer and protection
 215  * data buffer (where applicable) or NULL on failure
 216  */
 217 static struct scsi_cmnd *
 218 scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 219 {
 220         struct scsi_cmnd *cmd;
 221
 222         cmd = scsi_pool_alloc_command(shost->cmd_pool, gfp_mask);
 223         if (!cmd)
 224                 return NULL;
 225
 226         if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
 227                 cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask);
 228
 229                 if (!cmd->prot_sdb) {
 230                         scsi_pool_free_command(shost->cmd_pool, cmd);
 231                         return NULL;
 232                 }
 233         }
 234
 235         return cmd;
 236 }
 237
 238 /**
 239  * __scsi_get_command - Allocate a struct scsi_cmnd
 240  * @shost: host to transmit command
 241  * @gfp_mask: allocation mask
 242  *
 243  * Description: allocate a struct scsi_cmd from host's slab, recycling from the
 244  *              host's free_list if necessary.
 245  */
 246 struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 247 {
 248         struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask);
 249
 250         if (unlikely(!cmd)) {
 251                 unsigned long flags;
 252
 253                 spin_lock_irqsave(&shost->free_list_lock, flags);
 254                 if (likely(!list_empty(&shost->free_list))) {
 255                         cmd = list_entry(shost->free_list.next,
 256                                          struct scsi_cmnd, list);
 257                         list_del_init(&cmd->list);
 258                 }
 259                 spin_unlock_irqrestore(&shost->free_list_lock, flags);
 260
 261                 if (cmd) {
 262                         void *buf, *prot;
 263
 264                         buf = cmd->sense_buffer;
 265                         prot = cmd->prot_sdb;
 266
 267                         memset(cmd, 0, sizeof(*cmd));
 268
 269                         cmd->sense_buffer = buf;
 270                         cmd->prot_sdb = prot;
 271                 }
 272         }
 273
 274         return cmd;
 275 }
 276 EXPORT_SYMBOL_GPL(__scsi_get_command);
 277
 278 /**
 279  * scsi_get_command - Allocate and setup a scsi command block
 280  * @dev: parent scsi device
 281  * @gfp_mask: allocator flags
 282  *
 283  * Returns:     The allocated scsi command structure.
 284  */
 285 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
 286 {
 287         struct scsi_cmnd *cmd;
 288
 289         /* Bail if we can't get a reference to the device */
 290         if (!get_device(&dev->sdev_gendev))
 291                 return NULL;
 292
 293         cmd = __scsi_get_command(dev->host, gfp_mask);
 294
 295         if (likely(cmd != NULL)) {
 296                 unsigned long flags;
 297
 298                 cmd->device = dev;
 299                 INIT_LIST_HEAD(&cmd->list);
 300                 INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler);
 301                 spin_lock_irqsave(&dev->list_lock, flags);
 302                 list_add_tail(&cmd->list, &dev->cmd_list);
 303                 spin_unlock_irqrestore(&dev->list_lock, flags);
 304                 cmd->jiffies_at_alloc = jiffies;
 305         } else
 306                 put_device(&dev->sdev_gendev);
 307
 308         return cmd;
 309 }
 310 EXPORT_SYMBOL(scsi_get_command);
 311
 312 /**
 313  * __scsi_put_command - Free a struct scsi_cmnd
 314  * @shost: dev->host
 315  * @cmd: Command to free
 316  * @dev: parent scsi device
 317  */
 318 void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd,
 319                         struct device *dev)
 320 {
 321         unsigned long flags;
 322
 323         if (unlikely(list_empty(&shost->free_list))) {
 324                 spin_lock_irqsave(&shost->free_list_lock, flags);
 325                 if (list_empty(&shost->free_list)) {
 326                         list_add(&cmd->list, &shost->free_list);
 327                         cmd = NULL;
 328                 }
 329                 spin_unlock_irqrestore(&shost->free_list_lock, flags);
 330         }
 331
 332         if (likely(cmd != NULL))
 333                 scsi_pool_free_command(shost->cmd_pool, cmd);
 334
 335         put_device(dev);
 336 }
 337 EXPORT_SYMBOL(__scsi_put_command);
 338
 339 /**
 340  * scsi_put_command - Free a scsi command block
 341  * @cmd: command block to free
 342  *
 343  * Returns:     Nothing.
 344  *
 345  * Notes:       The command must not belong to any lists.
 346  */
 347 void scsi_put_command(struct scsi_cmnd *cmd)
 348 {
 349         struct scsi_device *sdev = cmd->device;
 350         unsigned long flags;
 351
 352         /* serious error if the command hasn't come from a device list */
 353         spin_lock_irqsave(&cmd->device->list_lock, flags);
 354         BUG_ON(list_empty(&cmd->list));
 355         list_del_init(&cmd->list);
 356         spin_unlock_irqrestore(&cmd->device->list_lock, flags);
 357
 358         cancel_delayed_work(&cmd->abort_work);
 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         int rtn = 0;
 661
 662         atomic_inc(&cmd->device->iorequest_cnt);
 663
 664         /* check if the device is still usable */
 665         if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
 666                 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
 667                  * returns an immediate error upwards, and signals
 668                  * that the device is no longer present */
 669                 cmd->result = DID_NO_CONNECT << 16;
 670                 scsi_done(cmd);
 671                 /* return 0 (because the command has been processed) */
 672                 goto out;
 673         }
 674
 675         /* Check to see if the scsi lld made this device blocked. */
 676         if (unlikely(scsi_device_blocked(cmd->device))) {
 677                 /*
 678                  * in blocked state, the command is just put back on
 679                  * the device queue.  The suspend state has already
 680                  * blocked the queue so future requests should not
 681                  * occur until the device transitions out of the
 682                  * suspend state.
 683                  */
 684
 685                 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
 686
 687                 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
 688
 689                 /*
 690                  * NOTE: rtn is still zero here because we don't need the
 691                  * queue to be plugged on return (it's already stopped)
 692                  */
 693                 goto out;
 694         }
 695
 696         /*
 697          * If SCSI-2 or lower, store the LUN value in cmnd.
 698          */
 699         if (cmd->device->scsi_level <= SCSI_2 &&
 700             cmd->device->scsi_level != SCSI_UNKNOWN) {
 701                 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
 702                                (cmd->device->lun << 5 & 0xe0);
 703         }
 704
 705         scsi_log_send(cmd);
 706
 707         /*
 708          * Before we queue this command, check if the command
 709          * length exceeds what the host adapter can handle.
 710          */
 711         if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
 712                 SCSI_LOG_MLQUEUE(3,
 713                         printk("queuecommand : command too long. "
 714                                "cdb_size=%d host->max_cmd_len=%d\n",
 715                                cmd->cmd_len, cmd->device->host->max_cmd_len));
 716                 cmd->result = (DID_ABORT << 16);
 717
 718                 scsi_done(cmd);
 719                 goto out;
 720         }
 721
 722         if (unlikely(host->shost_state == SHOST_DEL)) {
 723                 cmd->result = (DID_NO_CONNECT << 16);
 724                 scsi_done(cmd);
 725         } else {
 726                 trace_scsi_dispatch_cmd_start(cmd);
 727                 cmd->scsi_done = scsi_done;
 728                 rtn = host->hostt->queuecommand(host, cmd);
 729         }
 730
 731         if (rtn) {
 732                 trace_scsi_dispatch_cmd_error(cmd, rtn);
 733                 if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
 734                     rtn != SCSI_MLQUEUE_TARGET_BUSY)
 735                         rtn = SCSI_MLQUEUE_HOST_BUSY;
 736
 737                 scsi_queue_insert(cmd, rtn);
 738
 739                 SCSI_LOG_MLQUEUE(3,
 740                     printk("queuecommand : request rejected\n"));
 741         }
 742
 743  out:
 744         SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
 745         return rtn;
 746 }
 747
 748 /**
 749  * scsi_done - Invoke completion on finished SCSI command.
 750  * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
 751  * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
 752  *
 753  * Description: This function is the mid-level's (SCSI Core) interrupt routine,
 754  * which regains ownership of the SCSI command (de facto) from a LLDD, and
 755  * calls blk_complete_request() for further processing.
 756  *
 757  * This function is interrupt context safe.
 758  */
 759 static void scsi_done(struct scsi_cmnd *cmd)
 760 {
 761         trace_scsi_dispatch_cmd_done(cmd);
 762         blk_complete_request(cmd->request);
 763 }
 764
 765 /**
 766  * scsi_finish_command - cleanup and pass command back to upper layer
 767  * @cmd: the command
 768  *
 769  * Description: Pass command off to upper layer for finishing of I/O
 770  *              request, waking processes that are waiting on results,
 771  *              etc.
 772  */
 773 void scsi_finish_command(struct scsi_cmnd *cmd)
 774 {
 775         struct scsi_device *sdev = cmd->device;
 776         struct scsi_target *starget = scsi_target(sdev);
 777         struct Scsi_Host *shost = sdev->host;
 778         struct scsi_driver *drv;
 779         unsigned int good_bytes;
 780
 781         scsi_device_unbusy(sdev);
 782
 783         /*
 784          * Clear the flags which say that the device/host is no longer
 785          * capable of accepting new commands.  These are set in scsi_queue.c
 786          * for both the queue full condition on a device, and for a
 787          * host full condition on the host.
 788          *
 789          * XXX(hch): What about locking?
 790          */
 791         shost->host_blocked = 0;
 792         starget->target_blocked = 0;
 793         sdev->device_blocked = 0;
 794
 795         /*
 796          * If we have valid sense information, then some kind of recovery
 797          * must have taken place.  Make a note of this.
 798          */
 799         if (SCSI_SENSE_VALID(cmd))
 800                 cmd->result |= (DRIVER_SENSE << 24);
 801
 802         SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
 803                                 "Notifying upper driver of completion "
 804                                 "(result %x)\n", cmd->result));
 805
 806         good_bytes = scsi_bufflen(cmd);
 807         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
 808                 int old_good_bytes = good_bytes;
 809                 drv = scsi_cmd_to_driver(cmd);
 810                 if (drv->done)
 811                         good_bytes = drv->done(cmd);
 812                 /*
 813                  * USB may not give sense identifying bad sector and
 814                  * simply return a residue instead, so subtract off the
 815                  * residue if drv->done() error processing indicates no
 816                  * change to the completion length.
 817                  */
 818                 if (good_bytes == old_good_bytes)
 819                         good_bytes -= scsi_get_resid(cmd);
 820         }
 821         scsi_io_completion(cmd, good_bytes);
 822 }
 823 EXPORT_SYMBOL(scsi_finish_command);
 824
 825 /**
 826  * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
 827  * @sdev: SCSI Device in question
 828  * @tagged: Do we use tagged queueing (non-0) or do we treat
 829  *          this device as an untagged device (0)
 830  * @tags: Number of tags allowed if tagged queueing enabled,
 831  *        or number of commands the low level driver can
 832  *        queue up in non-tagged mode (as per cmd_per_lun).
 833  *
 834  * Returns:     Nothing
 835  *
 836  * Lock Status: None held on entry
 837  *
 838  * Notes:       Low level drivers may call this at any time and we will do
 839  *              the right thing depending on whether or not the device is
 840  *              currently active and whether or not it even has the
 841  *              command blocks built yet.
 842  */
 843 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
 844 {
 845         unsigned long flags;
 846
 847         /*
 848          * refuse to set tagged depth to an unworkable size
 849          */
 850         if (tags <= 0)
 851                 return;
 852
 853         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 854
 855         /*
 856          * Check to see if the queue is managed by the block layer.
 857          * If it is, and we fail to adjust the depth, exit.
 858          *
 859          * Do not resize the tag map if it is a host wide share bqt,
 860          * because the size should be the hosts's can_queue. If there
 861          * is more IO than the LLD's can_queue (so there are not enuogh
 862          * tags) request_fn's host queue ready check will handle it.
 863          */
 864         if (!sdev->host->bqt) {
 865                 if (blk_queue_tagged(sdev->request_queue) &&
 866                     blk_queue_resize_tags(sdev->request_queue, tags) != 0)
 867                         goto out;
 868         }
 869
 870         sdev->queue_depth = tags;
 871         switch (tagged) {
 872                 case MSG_ORDERED_TAG:
 873                         sdev->ordered_tags = 1;
 874                         sdev->simple_tags = 1;
 875                         break;
 876                 case MSG_SIMPLE_TAG:
 877                         sdev->ordered_tags = 0;
 878                         sdev->simple_tags = 1;
 879                         break;
 880                 default:
 881                         sdev_printk(KERN_WARNING, sdev,
 882                                     "scsi_adjust_queue_depth, bad queue type, "
 883                                     "disabled\n");
 884                 case 0:
 885                         sdev->ordered_tags = sdev->simple_tags = 0;
 886                         sdev->queue_depth = tags;
 887                         break;
 888         }
 889  out:
 890         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 891 }
 892 EXPORT_SYMBOL(scsi_adjust_queue_depth);
 893
 894 /**
 895  * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
 896  * @sdev: SCSI Device in question
 897  * @depth: Current number of outstanding SCSI commands on this device,
 898  *         not counting the one returned as QUEUE_FULL.
 899  *
 900  * Description: This function will track successive QUEUE_FULL events on a
 901  *              specific SCSI device to determine if and when there is a
 902  *              need to adjust the queue depth on the device.
 903  *
 904  * Returns:     0 - No change needed, >0 - Adjust queue depth to this new depth,
 905  *              -1 - Drop back to untagged operation using host->cmd_per_lun
 906  *                      as the untagged command depth
 907  *
 908  * Lock Status: None held on entry
 909  *
 910  * Notes:       Low level drivers may call this at any time and we will do
 911  *              "The Right Thing."  We are interrupt context safe.
 912  */
 913 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 914 {
 915
 916         /*
 917          * Don't let QUEUE_FULLs on the same
 918          * jiffies count, they could all be from
 919          * same event.
 920          */
 921         if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
 922                 return 0;
 923
 924         sdev->last_queue_full_time = jiffies;
 925         if (sdev->last_queue_full_depth != depth) {
 926                 sdev->last_queue_full_count = 1;
 927                 sdev->last_queue_full_depth = depth;
 928         } else {
 929                 sdev->last_queue_full_count++;
 930         }
 931
 932         if (sdev->last_queue_full_count <= 10)
 933                 return 0;
 934         if (sdev->last_queue_full_depth < 8) {
 935                 /* Drop back to untagged */
 936                 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 937                 return -1;
 938         }
 939
 940         if (sdev->ordered_tags)
 941                 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
 942         else
 943                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
 944         return depth;
 945 }
 946 EXPORT_SYMBOL(scsi_track_queue_full);
 947
 948 /**
 949  * scsi_vpd_inquiry - Request a device provide us with a VPD page
 950  * @sdev: The device to ask
 951  * @buffer: Where to put the result
 952  * @page: Which Vital Product Data to return
 953  * @len: The length of the buffer
 954  *
 955  * This is an internal helper function.  You probably want to use
 956  * scsi_get_vpd_page instead.
 957  *
 958  * Returns 0 on success or a negative error number.
 959  */
 960 static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
 961                                                         u8 page, unsigned len)
 962 {
 963         int result;
 964         unsigned char cmd[16];
 965
 966         cmd[0] = INQUIRY;
 967         cmd[1] = 1;             /* EVPD */
 968         cmd[2] = page;
 969         cmd[3] = len >> 8;
 970         cmd[4] = len & 0xff;
 971         cmd[5] = 0;             /* Control byte */
 972
 973         /*
 974          * I'm not convinced we need to try quite this hard to get VPD, but
 975          * all the existing users tried this hard.
 976          */
 977         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
 978                                   len, NULL, 30 * HZ, 3, NULL);
 979         if (result)
 980                 return result;
 981
 982         /* Sanity check that we got the page back that we asked for */
 983         if (buffer[1] != page)
 984                 return -EIO;
 985
 986         return 0;
 987 }
 988
 989 /**
 990  * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
 991  * @sdev: The device to ask
 992  * @page: Which Vital Product Data to return
 993  * @buf: where to store the VPD
 994  * @buf_len: number of bytes in the VPD buffer area
 995  *
 996  * SCSI devices may optionally supply Vital Product Data.  Each 'page'
 997  * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
 998  * If the device supports this VPD page, this routine returns a pointer
 999  * to a buffer containing the data from that page.  The caller is
1000  * responsible for calling kfree() on this pointer when it is no longer
1001  * needed.  If we cannot retrieve the VPD page this routine returns %NULL.
1002  */
1003 int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
1004                       int buf_len)
1005 {
1006         int i, result;
1007
1008         if (sdev->skip_vpd_pages)
1009                 goto fail;
1010
1011         /* Ask for all the pages supported by this device */
1012         result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
1013         if (result)
1014                 goto fail;
1015
1016         /* If the user actually wanted this page, we can skip the rest */
1017         if (page == 0)
1018                 return 0;
1019
1020         for (i = 0; i < min((int)buf[3], buf_len - 4); i++)
1021                 if (buf[i + 4] == page)
1022                         goto found;
1023
1024         if (i < buf[3] && i >= buf_len - 4)
1025                 /* ran off the end of the buffer, give us benefit of doubt */
1026                 goto found;
1027         /* The device claims it doesn't support the requested page */
1028         goto fail;
1029
1030  found:
1031         result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
1032         if (result)
1033                 goto fail;
1034
1035         return 0;
1036
1037  fail:
1038         return -EINVAL;
1039 }
1040 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
1041
1042 /**
1043  * scsi_report_opcode - Find out if a given command opcode is supported
1044  * @sdev:       scsi device to query
1045  * @buffer:     scratch buffer (must be at least 20 bytes long)
1046  * @len:        length of buffer
1047  * @opcode:     opcode for command to look up
1048  *
1049  * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
1050  * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is
1051  * unsupported and 1 if the device claims to support the command.
1052  */
1053 int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
1054                        unsigned int len, unsigned char opcode)
1055 {
1056         unsigned char cmd[16];
1057         struct scsi_sense_hdr sshdr;
1058         int result;
1059
1060         if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
1061                 return -EINVAL;
1062
1063         memset(cmd, 0, 16);
1064         cmd[0] = MAINTENANCE_IN;
1065         cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
1066         cmd[2] = 1;             /* One command format */
1067         cmd[3] = opcode;
1068         put_unaligned_be32(len, &cmd[6]);
1069         memset(buffer, 0, len);
1070
1071         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
1072                                   &sshdr, 30 * HZ, 3, NULL);
1073
1074         if (result && scsi_sense_valid(&sshdr) &&
1075             sshdr.sense_key == ILLEGAL_REQUEST &&
1076             (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
1077                 return -EINVAL;
1078
1079         if ((buffer[1] & 3) == 3) /* Command supported */
1080                 return 1;
1081
1082         return 0;
1083 }
1084 EXPORT_SYMBOL(scsi_report_opcode);
1085
1086 /**
1087  * scsi_device_get  -  get an additional reference to a scsi_device
1088  * @sdev:       device to get a reference to
1089  *
1090  * Description: Gets a reference to the scsi_device and increments the use count
1091  * of the underlying LLDD module.  You must hold host_lock of the
1092  * parent Scsi_Host or already have a reference when calling this.
1093  */
1094 int scsi_device_get(struct scsi_device *sdev)
1095 {
1096         if (sdev->sdev_state == SDEV_DEL)
1097                 return -ENXIO;
1098         if (!get_device(&sdev->sdev_gendev))
1099                 return -ENXIO;
1100         /* We can fail this if we're doing SCSI operations
1101          * from module exit (like cache flush) */
1102         try_module_get(sdev->host->hostt->module);
1103
1104         return 0;
1105 }
1106 EXPORT_SYMBOL(scsi_device_get);
1107
1108 /**
1109  * scsi_device_put  -  release a reference to a scsi_device
1110  * @sdev:       device to release a reference on.
1111  *
1112  * Description: Release a reference to the scsi_device and decrements the use
1113  * count of the underlying LLDD module.  The device is freed once the last
1114  * user vanishes.
1115  */
1116 void scsi_device_put(struct scsi_device *sdev)
1117 {
1118 #ifdef CONFIG_MODULE_UNLOAD
1119         struct module *module = sdev->host->hostt->module;
1120
1121         /* The module refcount will be zero if scsi_device_get()
1122          * was called from a module removal routine */
1123         if (module && module_refcount(module) != 0)
1124                 module_put(module);
1125 #endif
1126         put_device(&sdev->sdev_gendev);
1127 }
1128 EXPORT_SYMBOL(scsi_device_put);
1129
1130 /* helper for shost_for_each_device, see that for documentation */
1131 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1132                                            struct scsi_device *prev)
1133 {
1134         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1135         struct scsi_device *next = NULL;
1136         unsigned long flags;
1137
1138         spin_lock_irqsave(shost->host_lock, flags);
1139         while (list->next != &shost->__devices) {
1140                 next = list_entry(list->next, struct scsi_device, siblings);
1141                 /* skip devices that we can't get a reference to */
1142                 if (!scsi_device_get(next))
1143                         break;
1144                 next = NULL;
1145                 list = list->next;
1146         }
1147         spin_unlock_irqrestore(shost->host_lock, flags);
1148
1149         if (prev)
1150                 scsi_device_put(prev);
1151         return next;
1152 }
1153 EXPORT_SYMBOL(__scsi_iterate_devices);
1154
1155 /**
1156  * starget_for_each_device  -  helper to walk all devices of a target
1157  * @starget:    target whose devices we want to iterate over.
1158  * @data:       Opaque passed to each function call.
1159  * @fn:         Function to call on each device
1160  *
1161  * This traverses over each device of @starget.  The devices have
1162  * a reference that must be released by scsi_host_put when breaking
1163  * out of the loop.
1164  */
1165 void starget_for_each_device(struct scsi_target *starget, void *data,
1166                      void (*fn)(struct scsi_device *, void *))
1167 {
1168         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1169         struct scsi_device *sdev;
1170
1171         shost_for_each_device(sdev, shost) {
1172                 if ((sdev->channel == starget->channel) &&
1173                     (sdev->id == starget->id))
1174                         fn(sdev, data);
1175         }
1176 }
1177 EXPORT_SYMBOL(starget_for_each_device);
1178
1179 /**
1180  * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1181  * @starget:    target whose devices we want to iterate over.
1182  * @data:       parameter for callback @fn()
1183  * @fn:         callback function that is invoked for each device
1184  *
1185  * This traverses over each device of @starget.  It does _not_
1186  * take a reference on the scsi_device, so the whole loop must be
1187  * protected by shost->host_lock.
1188  *
1189  * Note:  The only reason why drivers would want to use this is because
1190  * they need to access the device list in irq context.  Otherwise you
1191  * really want to use starget_for_each_device instead.
1192  **/
1193 void __starget_for_each_device(struct scsi_target *starget, void *data,
1194                                void (*fn)(struct scsi_device *, void *))
1195 {
1196         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1197         struct scsi_device *sdev;
1198
1199         __shost_for_each_device(sdev, shost) {
1200                 if ((sdev->channel == starget->channel) &&
1201                     (sdev->id == starget->id))
1202                         fn(sdev, data);
1203         }
1204 }
1205 EXPORT_SYMBOL(__starget_for_each_device);
1206
1207 /**
1208  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1209  * @starget:    SCSI target pointer
1210  * @lun:        SCSI Logical Unit Number
1211  *
1212  * Description: Looks up the scsi_device with the specified @lun for a given
1213  * @starget.  The returned scsi_device does not have an additional
1214  * reference.  You must hold the host's host_lock over this call and
1215  * any access to the returned scsi_device. A scsi_device in state
1216  * SDEV_DEL is skipped.
1217  *
1218  * Note:  The only reason why drivers should use this is because
1219  * they need to access the device list in irq context.  Otherwise you
1220  * really want to use scsi_device_lookup_by_target instead.
1221  **/
1222 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1223                                                    uint lun)
1224 {
1225         struct scsi_device *sdev;
1226
1227         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1228                 if (sdev->sdev_state == SDEV_DEL)
1229                         continue;
1230                 if (sdev->lun ==lun)
1231                         return sdev;
1232         }
1233
1234         return NULL;
1235 }
1236 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1237
1238 /**
1239  * scsi_device_lookup_by_target - find a device given the target
1240  * @starget:    SCSI target pointer
1241  * @lun:        SCSI Logical Unit Number
1242  *
1243  * Description: Looks up the scsi_device with the specified @lun for a given
1244  * @starget.  The returned scsi_device has an additional reference that
1245  * needs to be released with scsi_device_put once you're done with it.
1246  **/
1247 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1248                                                  uint lun)
1249 {
1250         struct scsi_device *sdev;
1251         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1252         unsigned long flags;
1253
1254         spin_lock_irqsave(shost->host_lock, flags);
1255         sdev = __scsi_device_lookup_by_target(starget, lun);
1256         if (sdev && scsi_device_get(sdev))
1257                 sdev = NULL;
1258         spin_unlock_irqrestore(shost->host_lock, flags);
1259
1260         return sdev;
1261 }
1262 EXPORT_SYMBOL(scsi_device_lookup_by_target);
1263
1264 /**
1265  * __scsi_device_lookup - find a device given the host (UNLOCKED)
1266  * @shost:      SCSI host pointer
1267  * @channel:    SCSI channel (zero if only one channel)
1268  * @id:         SCSI target number (physical unit number)
1269  * @lun:        SCSI Logical Unit Number
1270  *
1271  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1272  * for a given host. The returned scsi_device does not have an additional
1273  * reference.  You must hold the host's host_lock over this call and any access
1274  * to the returned scsi_device.
1275  *
1276  * Note:  The only reason why drivers would want to use this is because
1277  * they need to access the device list in irq context.  Otherwise you
1278  * really want to use scsi_device_lookup instead.
1279  **/
1280 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1281                 uint channel, uint id, uint lun)
1282 {
1283         struct scsi_device *sdev;
1284
1285         list_for_each_entry(sdev, &shost->__devices, siblings) {
1286                 if (sdev->channel == channel && sdev->id == id &&
1287                                 sdev->lun ==lun)
1288                         return sdev;
1289         }
1290
1291         return NULL;
1292 }
1293 EXPORT_SYMBOL(__scsi_device_lookup);
1294
1295 /**
1296  * scsi_device_lookup - find a device given the host
1297  * @shost:      SCSI host pointer
1298  * @channel:    SCSI channel (zero if only one channel)
1299  * @id:         SCSI target number (physical unit number)
1300  * @lun:        SCSI Logical Unit Number
1301  *
1302  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1303  * for a given host.  The returned scsi_device has an additional reference that
1304  * needs to be released with scsi_device_put once you're done with it.
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         unsigned long flags;
1311
1312         spin_lock_irqsave(shost->host_lock, flags);
1313         sdev = __scsi_device_lookup(shost, channel, id, lun);
1314         if (sdev && scsi_device_get(sdev))
1315                 sdev = NULL;
1316         spin_unlock_irqrestore(shost->host_lock, flags);
1317
1318         return sdev;
1319 }
1320 EXPORT_SYMBOL(scsi_device_lookup);
1321
1322 MODULE_DESCRIPTION("SCSI core");
1323 MODULE_LICENSE("GPL");
1324
1325 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1326 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1327
1328 static int __init init_scsi(void)
1329 {
1330         int error;
1331
1332         error = scsi_init_queue();
1333         if (error)
1334                 return error;
1335         error = scsi_init_procfs();
1336         if (error)
1337                 goto cleanup_queue;
1338         error = scsi_init_devinfo();
1339         if (error)
1340                 goto cleanup_procfs;
1341         error = scsi_init_hosts();
1342         if (error)
1343                 goto cleanup_devlist;
1344         error = scsi_init_sysctl();
1345         if (error)
1346                 goto cleanup_hosts;
1347         error = scsi_sysfs_register();
1348         if (error)
1349                 goto cleanup_sysctl;
1350
1351         scsi_netlink_init();
1352
1353         printk(KERN_NOTICE "SCSI subsystem initialized\n");
1354         return 0;
1355
1356 cleanup_sysctl:
1357         scsi_exit_sysctl();
1358 cleanup_hosts:
1359         scsi_exit_hosts();
1360 cleanup_devlist:
1361         scsi_exit_devinfo();
1362 cleanup_procfs:
1363         scsi_exit_procfs();
1364 cleanup_queue:
1365         scsi_exit_queue();
1366         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1367                -error);
1368         return error;
1369 }
1370
1371 static void __exit exit_scsi(void)
1372 {
1373         scsi_netlink_exit();
1374         scsi_sysfs_unregister();
1375         scsi_exit_sysctl();
1376         scsi_exit_hosts();
1377         scsi_exit_devinfo();
1378         scsi_exit_procfs();
1379         scsi_exit_queue();
1380         async_unregister_domain(&scsi_sd_probe_domain);
1381 }
1382
1383 subsys_initcall(init_scsi);
1384 module_exit(exit_scsi);