drivers/scsi/scsi.c

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