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