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