LCOV - code coverage report
Current view: top level - lkbce/drivers/scsi - scsi.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 153 446 34.3 %
Date: 2017-01-25 Functions: 13 34 38.2 %

          Line data    Source code
       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           1 : 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         128 :         if (type == 0x1e)
     124          64 :                 return "Well-known LUN   ";
     125         128 :         if (type == 0x1f)
     126          64 :                 return "No Device        ";
     127         128 :         if (type >= ARRAY_SIZE(scsi_device_types))
     128          64 :                 return "Unknown          ";
     129          64 :         return scsi_device_types[type];
     130             : }
     131           1 : 
     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           1 : 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           1 : 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           1 : 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           0 : 
     172           0 :         cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask);
     173           0 :         if (!cmd)
     174           0 :                 return NULL;
     175             : 
     176           0 :         cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab,
     177             :                                              gfp_mask | pool->gfp_mask);
     178           0 :         if (!cmd->sense_buffer) {
     179           0 :                 kmem_cache_free(pool->cmd_slab, cmd);
     180           0 :                 return NULL;
     181             :         }
     182             : 
     183           0 :         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           6 :         if (cmd->prot_sdb)
     199           4 :                 kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb);
     200             : 
     201           4 :         kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
     202           2 :         kmem_cache_free(pool->cmd_slab, cmd);
     203           2 : }
     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           0 :         struct scsi_cmnd *cmd;
     217           0 : 
     218           0 :         cmd = scsi_pool_alloc_command(shost->cmd_pool, gfp_mask);
     219           0 :         if (!cmd)
     220           0 :                 return NULL;
     221             : 
     222           0 :         if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
     223           0 :                 cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask);
     224             : 
     225           0 :                 if (!cmd->prot_sdb) {
     226           0 :                         scsi_pool_free_command(shost->cmd_pool, cmd);
     227           0 :                         return NULL;
     228             :                 }
     229             :         }
     230             : 
     231           0 :         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           0 :         struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask);
     245           0 : 
     246           0 :         if (unlikely(!cmd)) {
     247           0 :                 unsigned long flags;
     248           0 : 
     249           0 :                 spin_lock_irqsave(&shost->free_list_lock, flags);
     250           0 :                 if (likely(!list_empty(&shost->free_list))) {
     251           0 :                         cmd = list_entry(shost->free_list.next,
     252           0 :                                          struct scsi_cmnd, list);
     253           0 :                         list_del_init(&cmd->list);
     254             :                 }
     255           0 :                 spin_unlock_irqrestore(&shost->free_list_lock, flags);
     256             : 
     257           0 :                 if (cmd) {
     258             :                         void *buf, *prot;
     259             : 
     260           0 :                         buf = cmd->sense_buffer;
     261           0 :                         prot = cmd->prot_sdb;
     262             : 
     263           0 :                         memset(cmd, 0, sizeof(*cmd));
     264             : 
     265           0 :                         cmd->sense_buffer = buf;
     266           0 :                         cmd->prot_sdb = prot;
     267             :                 }
     268             :         }
     269             : 
     270           0 :         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           0 :         struct scsi_cmnd *cmd;
     284           0 : 
     285           0 :         /* Bail if we can't get a reference to the device */
     286           0 :         if (!get_device(&dev->sdev_gendev))
     287           0 :                 return NULL;
     288             : 
     289           0 :         cmd = __scsi_get_command(dev->host, gfp_mask);
     290             : 
     291           0 :         if (likely(cmd != NULL)) {
     292             :                 unsigned long flags;
     293             : 
     294           0 :                 cmd->device = dev;
     295           0 :                 INIT_LIST_HEAD(&cmd->list);
     296           0 :                 spin_lock_irqsave(&dev->list_lock, flags);
     297           0 :                 list_add_tail(&cmd->list, &dev->cmd_list);
     298           0 :                 spin_unlock_irqrestore(&dev->list_lock, flags);
     299           0 :                 cmd->jiffies_at_alloc = jiffies;
     300             :         } else
     301           0 :                 put_device(&dev->sdev_gendev);
     302             : 
     303           0 :         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           0 : {
     316           0 :         unsigned long flags;
     317           0 : 
     318           0 :         /* changing locks here, don't need to restore the irq state */
     319           0 :         spin_lock_irqsave(&shost->free_list_lock, flags);
     320           0 :         if (unlikely(list_empty(&shost->free_list))) {
     321           0 :                 list_add(&cmd->list, &shost->free_list);
     322           0 :                 cmd = NULL;
     323             :         }
     324           0 :         spin_unlock_irqrestore(&shost->free_list_lock, flags);
     325             : 
     326           0 :         if (likely(cmd != NULL))
     327           0 :                 scsi_pool_free_command(shost->cmd_pool, cmd);
     328             : 
     329           0 :         put_device(dev);
     330           0 : }
     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           0 :         struct scsi_device *sdev = cmd->device;
     344           0 :         unsigned long flags;
     345           0 : 
     346           0 :         /* serious error if the command hasn't come from a device list */
     347           0 :         spin_lock_irqsave(&cmd->device->list_lock, flags);
     348           0 :         BUG_ON(list_empty(&cmd->list));
     349           0 :         list_del_init(&cmd->list);
     350           0 :         spin_unlock_irqrestore(&cmd->device->list_lock, flags);
     351             : 
     352           0 :         __scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev);
     353           0 : }
     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           0 :         struct scsi_host_cmd_pool *retval = NULL, *pool;
     359           0 :         /*
     360             :          * Select a command slab for this host and create it if not
     361             :          * yet existent.
     362             :          */
     363           0 :         mutex_lock(&host_cmd_pool_mutex);
     364           0 :         pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool :
     365             :                 &scsi_cmd_pool;
     366           0 :         if (!pool->users) {
     367           0 :                 pool->cmd_slab = kmem_cache_create(pool->cmd_name,
     368             :                                                    sizeof(struct scsi_cmnd), 0,
     369             :                                                    pool->slab_flags, NULL);
     370           0 :                 if (!pool->cmd_slab)
     371           0 :                         goto fail;
     372             : 
     373           0 :                 pool->sense_slab = kmem_cache_create(pool->sense_name,
     374             :                                                      SCSI_SENSE_BUFFERSIZE, 0,
     375             :                                                      pool->slab_flags, NULL);
     376           0 :                 if (!pool->sense_slab) {
     377           0 :                         kmem_cache_destroy(pool->cmd_slab);
     378           0 :                         goto fail;
     379             :                 }
     380             :         }
     381             : 
     382           0 :         pool->users++;
     383           0 :         retval = pool;
     384           0 :  fail:
     385           0 :         mutex_unlock(&host_cmd_pool_mutex);
     386           0 :         return retval;
     387             : }
     388             : 
     389             : static void scsi_put_host_cmd_pool(gfp_t gfp_mask)
     390             : {
     391           2 :         struct scsi_host_cmd_pool *pool;
     392           2 : 
     393           2 :         mutex_lock(&host_cmd_pool_mutex);
     394          12 :         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          12 :         BUG_ON(pool->users == 0);
     402             : 
     403           6 :         if (!--pool->users) {
     404           2 :                 kmem_cache_destroy(pool->cmd_slab);
     405           2 :                 kmem_cache_destroy(pool->sense_slab);
     406             :         }
     407           2 :         mutex_unlock(&host_cmd_pool_mutex);
     408           2 : }
     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           0 :         struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
     426           0 : 
     427           0 :         if (!pool)
     428           0 :                 return NULL;
     429             : 
     430           0 :         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           0 :         struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
     446           0 : 
     447           0 :         /*
     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           0 :         BUG_ON(!pool);
     454             : 
     455           0 :         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           0 :         scsi_put_host_cmd_pool(gfp_mask);
     462           0 :         scsi_put_host_cmd_pool(gfp_mask);
     463           0 : }
     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           0 :         struct scsi_cmnd *cmd;
     479           0 :         const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL;
     480           0 : 
     481           0 :         spin_lock_init(&shost->free_list_lock);
     482           0 :         INIT_LIST_HEAD(&shost->free_list);
     483             : 
     484           0 :         shost->cmd_pool = scsi_get_host_cmd_pool(gfp_mask);
     485             : 
     486           0 :         if (!shost->cmd_pool)
     487           0 :                 return -ENOMEM;
     488             : 
     489             :         /*
     490             :          * Get one backup command for this host.
     491             :          */
     492           0 :         cmd = scsi_host_alloc_command(shost, gfp_mask);
     493           0 :         if (!cmd) {
     494           0 :                 scsi_put_host_cmd_pool(gfp_mask);
     495           0 :                 shost->cmd_pool = NULL;
     496           0 :                 return -ENOMEM;
     497             :         }
     498           0 :         list_add(&cmd->list, &shost->free_list);
     499           0 :         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           2 :         /*
     509           2 :          * If cmd_pool is NULL the free list was not initialized, so
     510           2 :          * do not attempt to release resources.
     511             :          */
     512           6 :         if (!shost->cmd_pool)
     513           2 :                 return;
     514             : 
     515          10 :         while (!list_empty(&shost->free_list)) {
     516           2 :                 struct scsi_cmnd *cmd;
     517           2 : 
     518           4 :                 cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
     519           4 :                 list_del_init(&cmd->list);
     520           4 :                 scsi_pool_free_command(shost->cmd_pool, cmd);
     521             :         }
     522           4 :         shost->cmd_pool = NULL;
     523          14 :         scsi_put_host_cmd_pool(shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL);
     524           2 : }
     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           0 :         cmd->serial_number = host->cmd_serial_number++;
     637           0 :         if (cmd->serial_number == 0) 
     638           0 :                 cmd->serial_number = host->cmd_serial_number++;
     639           0 : }
     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           0 :         struct Scsi_Host *host = cmd->device->host;
     651           0 :         unsigned long flags = 0;
     652           0 :         unsigned long timeout;
     653           0 :         int rtn = 0;
     654           0 : 
     655           0 :         atomic_inc(&cmd->device->iorequest_cnt);
     656           0 : 
     657           0 :         /* check if the device is still usable */
     658           0 :         if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
     659           0 :                 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
     660           0 :                  * returns an immediate error upwards, and signals
     661           0 :                  * that the device is no longer present */
     662           0 :                 cmd->result = DID_NO_CONNECT << 16;
     663           0 :                 scsi_done(cmd);
     664             :                 /* return 0 (because the command has been processed) */
     665           0 :                 goto out;
     666             :         }
     667             : 
     668             :         /* Check to see if the scsi lld made this device blocked. */
     669           0 :         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           0 :                 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           0 :                 goto out;
     687             :         }
     688             : 
     689             :         /* 
     690             :          * If SCSI-2 or lower, store the LUN value in cmnd.
     691             :          */
     692           0 :         if (cmd->device->scsi_level <= SCSI_2 &&
     693             :             cmd->device->scsi_level != SCSI_UNKNOWN) {
     694           0 :                 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           0 :         timeout = host->last_reset + MIN_RESET_DELAY;
     703             : 
     704           0 :         if (host->resetting && time_before(jiffies, timeout)) {
     705           0 :                 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           0 :                 while (--ticks_remaining >= 0)
     716           0 :                         mdelay(1 + 999 / HZ);
     717           0 :                 host->resetting = 0;
     718             :         }
     719             : 
     720           0 :         scsi_log_send(cmd);
     721             : 
     722             :         /*
     723             :          * Before we queue this command, check if the command
     724           0 :          * length exceeds what the host adapter can handle.
     725             :          */
     726           0 :         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           0 :                 cmd->result = (DID_ABORT << 16);
     732             : 
     733           0 :                 scsi_done(cmd);
     734           0 :                 goto out;
     735             :         }
     736             : 
     737           0 :         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           0 :         scsi_cmd_get_serial(host, cmd); 
     745             : 
     746           0 :         if (unlikely(host->shost_state == SHOST_DEL)) {
     747           0 :                 cmd->result = (DID_NO_CONNECT << 16);
     748           0 :                 scsi_done(cmd);
     749             :         } else {
     750           0 :                 rtn = host->hostt->queuecommand(cmd, scsi_done);
     751             :         }
     752           0 :         spin_unlock_irqrestore(host->host_lock, flags);
     753           0 :         if (rtn) {
     754           0 :                 if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
     755             :                     rtn != SCSI_MLQUEUE_TARGET_BUSY)
     756           0 :                         rtn = SCSI_MLQUEUE_HOST_BUSY;
     757             : 
     758           0 :                 scsi_queue_insert(cmd, rtn);
     759             : 
     760             :                 SCSI_LOG_MLQUEUE(3,
     761             :                     printk("queuecommand : request rejected\n"));
     762             :         }
     763           0 : 
     764             :  out:
     765             :         SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
     766           0 :         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           0 :         blk_complete_request(cmd->request);
     785           0 : }
     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           0 :         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           0 :         struct scsi_device *sdev = cmd->device;
     804           0 :         struct scsi_target *starget = scsi_target(sdev);
     805           0 :         struct Scsi_Host *shost = sdev->host;
     806           0 :         struct scsi_driver *drv;
     807           0 :         unsigned int good_bytes;
     808           0 : 
     809           0 :         scsi_device_unbusy(sdev);
     810           0 : 
     811           0 :         /*
     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           0 :         shost->host_blocked = 0;
     820           0 :         starget->target_blocked = 0;
     821           0 :         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           0 :         if (SCSI_SENSE_VALID(cmd))
     828           0 :                 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           0 :         good_bytes = scsi_bufflen(cmd);
     835           0 :         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
     836           0 :                 int old_good_bytes = good_bytes;
     837           0 :                 drv = scsi_cmd_to_driver(cmd);
     838           0 :                 if (drv->done)
     839           0 :                         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           0 :                 if (good_bytes == old_good_bytes)
     847           0 :                         good_bytes -= scsi_get_resid(cmd);
     848             :         }
     849           0 :         scsi_io_completion(cmd, good_bytes);
     850           0 : }
     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          40 :         unsigned long flags;
     874          40 : 
     875          40 :         /*
     876          40 :          * refuse to set tagged depth to an unworkable size
     877          40 :          */
     878         120 :         if (tags <= 0)
     879          80 :                 return;
     880             : 
     881         120 :         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         120 :         if (!sdev->host->bqt) {
     893         280 :                 if (blk_queue_tagged(sdev->request_queue) &&
     894             :                     blk_queue_resize_tags(sdev->request_queue, tags) != 0)
     895          40 :                         goto out;
     896             :         }
     897             : 
     898          80 :         sdev->queue_depth = tags;
     899             :         switch (tagged) {
     900         240 :                 case MSG_ORDERED_TAG:
     901          80 :                         sdev->ordered_tags = 1;
     902          80 :                         sdev->simple_tags = 1;
     903          80 :                         break;
     904         320 :                 case MSG_SIMPLE_TAG:
     905          80 :                         sdev->ordered_tags = 0;
     906          80 :                         sdev->simple_tags = 1;
     907          80 :                         break;
     908         160 :                 default:
     909         320 :                         sdev_printk(KERN_WARNING, sdev,
     910             :                                     "scsi_adjust_queue_depth, bad queue type, "
     911             :                                     "disabled\n");
     912         280 :                 case 0:
     913         360 :                         sdev->ordered_tags = sdev->simple_tags = 0;
     914         120 :                         sdev->queue_depth = tags;
     915         120 :                         break;
     916             :         }
     917             :  out:
     918         240 :         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
     919         160 : }
     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           0 :         if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
     950           0 :                 return 0;
     951             : 
     952           0 :         sdev->last_queue_full_time = jiffies;
     953           0 :         if (sdev->last_queue_full_depth != depth) {
     954           0 :                 sdev->last_queue_full_count = 1;
     955           0 :                 sdev->last_queue_full_depth = depth;
     956             :         } else {
     957           0 :                 sdev->last_queue_full_count++;
     958             :         }
     959             : 
     960           0 :         if (sdev->last_queue_full_count <= 10)
     961           0 :                 return 0;
     962           0 :         if (sdev->last_queue_full_depth < 8) {
     963             :                 /* Drop back to untagged */
     964           0 :                 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
     965           0 :                 return -1;
     966             :         }
     967             :         
     968           0 :         if (sdev->ordered_tags)
     969           0 :                 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
     970             :         else
     971           0 :                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
     972           0 :         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           0 :         int result;
     992           0 :         unsigned char cmd[16];
     993             : 
     994           0 :         cmd[0] = INQUIRY;
     995           0 :         cmd[1] = 1;             /* EVPD */
     996           0 :         cmd[2] = page;
     997           0 :         cmd[3] = len >> 8;
     998           0 :         cmd[4] = len & 0xff;
     999           0 :         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           0 :         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
    1006             :                                   len, NULL, 30 * HZ, 3, NULL);
    1007           0 :         if (result)
    1008           0 :                 return result;
    1009             : 
    1010             :         /* Sanity check that we got the page back that we asked for */
    1011           0 :         if (buffer[1] != page)
    1012           0 :                 return -EIO;
    1013             : 
    1014           0 :         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           0 :         int i, result;
    1032           0 :         unsigned int len;
    1033           0 :         const unsigned int init_vpd_len = 255;
    1034           0 :         unsigned char *buf = kmalloc(init_vpd_len, GFP_KERNEL);
    1035           0 : 
    1036           0 :         if (!buf)
    1037           0 :                 return NULL;
    1038             : 
    1039             :         /* Ask for all the pages supported by this device */
    1040           0 :         result = scsi_vpd_inquiry(sdev, buf, 0, init_vpd_len);
    1041           0 :         if (result)
    1042           0 :                 goto fail;
    1043             : 
    1044             :         /* If the user actually wanted this page, we can skip the rest */
    1045           0 :         if (page == 0)
    1046           0 :                 return buf;
    1047             : 
    1048           0 :         for (i = 0; i < buf[3]; i++)
    1049           0 :                 if (buf[i + 4] == page)
    1050           0 :                         goto found;
    1051             :         /* The device claims it doesn't support the requested page */
    1052           0 :         goto fail;
    1053           0 : 
    1054             :  found:
    1055           0 :         result = scsi_vpd_inquiry(sdev, buf, page, 255);
    1056           0 :         if (result)
    1057           0 :                 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           0 :         len = ((buf[2] << 8) | buf[3]) + 4;
    1064           0 :         if (len <= init_vpd_len)
    1065           0 :                 return buf;
    1066             : 
    1067           0 :         kfree(buf);
    1068           0 :         buf = kmalloc(len, GFP_KERNEL);
    1069           0 :         result = scsi_vpd_inquiry(sdev, buf, page, len);
    1070           0 :         if (result)
    1071           0 :                 goto fail;
    1072             : 
    1073           0 :         return buf;
    1074           0 : 
    1075             :  fail:
    1076           0 :         kfree(buf);
    1077           0 :         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         848 :         if (sdev->sdev_state == SDEV_DEL)
    1092         212 :                 return -ENXIO;
    1093         636 :         if (!get_device(&sdev->sdev_gendev))
    1094         212 :                 return -ENXIO;
    1095             :         /* We can fail this if we're doing SCSI operations
    1096             :          * from module exit (like cache flush) */
    1097         424 :         try_module_get(sdev->host->hostt->module);
    1098             : 
    1099         212 :         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         148 :         put_device(&sdev->sdev_gendev);
    1122         148 : }
    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           0 : {
    1129           0 :         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
    1130           0 :         struct scsi_device *next = NULL;
    1131           0 :         unsigned long flags;
    1132           0 : 
    1133           0 :         spin_lock_irqsave(shost->host_lock, flags);
    1134           0 :         while (list->next != &shost->__devices) {
    1135           0 :                 next = list_entry(list->next, struct scsi_device, siblings);
    1136           0 :                 /* skip devices that we can't get a reference to */
    1137           0 :                 if (!scsi_device_get(next))
    1138           0 :                         break;
    1139           0 :                 next = NULL;
    1140           0 :                 list = list->next;
    1141           0 :         }
    1142           0 :         spin_unlock_irqrestore(shost->host_lock, flags);
    1143             : 
    1144           0 :         if (prev)
    1145           0 :                 scsi_device_put(prev);
    1146           0 :         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           0 :         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
    1164           0 :         struct scsi_device *sdev;
    1165           0 : 
    1166           0 :         shost_for_each_device(sdev, shost) {
    1167           0 :                 if ((sdev->channel == starget->channel) &&
    1168           0 :                     (sdev->id == starget->id))
    1169           0 :                         fn(sdev, data);
    1170             :         }
    1171             : }
    1172             : EXPORT_SYMBOL(starget_for_each_device);
    1173           0 : 
    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           0 :         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
    1192           0 :         struct scsi_device *sdev;
    1193           0 : 
    1194           0 :         __shost_for_each_device(sdev, shost) {
    1195           0 :                 if ((sdev->channel == starget->channel) &&
    1196           0 :                     (sdev->id == starget->id))
    1197           0 :                         fn(sdev, data);
    1198             :         }
    1199             : }
    1200             : EXPORT_SYMBOL(__starget_for_each_device);
    1201           0 : 
    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          40 : {
    1220          40 :         struct scsi_device *sdev;
    1221          40 : 
    1222         320 :         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
    1223         200 :                 if (sdev->sdev_state == SDEV_DEL)
    1224          80 :                         continue;
    1225          80 :                 if (sdev->lun ==lun)
    1226          40 :                         return sdev;
    1227             :         }
    1228             : 
    1229          40 :         return NULL;
    1230          40 : }
    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          40 : {
    1245          40 :         struct scsi_device *sdev;
    1246         160 :         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
    1247          40 :         unsigned long flags;
    1248          40 : 
    1249         160 :         spin_lock_irqsave(shost->host_lock, flags);
    1250          80 :         sdev = __scsi_device_lookup_by_target(starget, lun);
    1251         280 :         if (sdev && scsi_device_get(sdev))
    1252          40 :                 sdev = NULL;
    1253         160 :         spin_unlock_irqrestore(shost->host_lock, flags);
    1254             : 
    1255          40 :         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           1 :         struct scsi_device *sdev;
    1279           1 : 
    1280           9 :         list_for_each_entry(sdev, &shost->__devices, siblings) {
    1281           8 :                 if (sdev->channel == channel && sdev->id == id &&
    1282           1 :                                 sdev->lun ==lun)
    1283           1 :                         return sdev;
    1284             :         }
    1285             : 
    1286           1 :         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           1 :         struct scsi_device *sdev;
    1305           1 :         unsigned long flags;
    1306           1 : 
    1307           4 :         spin_lock_irqsave(shost->host_lock, flags);
    1308           2 :         sdev = __scsi_device_lookup(shost, channel, id, lun);
    1309           7 :         if (sdev && scsi_device_get(sdev))
    1310           1 :                 sdev = NULL;
    1311           4 :         spin_unlock_irqrestore(shost->host_lock, flags);
    1312             : 
    1313           1 :         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           1 :         int error;
    1326             : 
    1327           4 :         error = scsi_init_queue();
    1328           2 :         if (error)
    1329           1 :                 return error;
    1330           3 :         error = scsi_init_procfs();
    1331           2 :         if (error)
    1332           1 :                 goto cleanup_queue;
    1333           6 :         error = scsi_init_devinfo();
    1334           2 :         if (error)
    1335           1 :                 goto cleanup_procfs;
    1336           2 :         error = scsi_init_hosts();
    1337           2 :         if (error)
    1338           1 :                 goto cleanup_devlist;
    1339           2 :         error = scsi_init_sysctl();
    1340           2 :         if (error)
    1341           1 :                 goto cleanup_hosts;
    1342           2 :         error = scsi_sysfs_register();
    1343           2 :         if (error)
    1344           1 :                 goto cleanup_sysctl;
    1345             : 
    1346           2 :         scsi_netlink_init();
    1347             : 
    1348           1 :         printk(KERN_NOTICE "SCSI subsystem initialized\n");
    1349           1 :         return 0;
    1350           1 : 
    1351             : cleanup_sysctl:
    1352           2 :         scsi_exit_sysctl();
    1353             : cleanup_hosts:
    1354           5 :         scsi_exit_hosts();
    1355             : cleanup_devlist:
    1356           5 :         scsi_exit_devinfo();
    1357             : cleanup_procfs:
    1358           5 :         scsi_exit_procfs();
    1359             : cleanup_queue:
    1360           5 :         scsi_exit_queue();
    1361           1 :         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
    1362             :                -error);
    1363           1 :         return error;
    1364             : }
    1365             : 
    1366             : static void __exit exit_scsi(void)
    1367             : {
    1368           4 :         scsi_netlink_exit();
    1369           4 :         scsi_sysfs_unregister();
    1370           4 :         scsi_exit_sysctl();
    1371           4 :         scsi_exit_hosts();
    1372           4 :         scsi_exit_devinfo();
    1373           4 :         scsi_exit_procfs();
    1374           4 :         scsi_exit_queue();
    1375           2 : }
    1376             : 
    1377             : subsys_initcall(init_scsi);
    1378             : module_exit(exit_scsi);

Generated by: LCOV version 1.10