LCOV - code coverage report
Current view: top level - drivers/scsi - scsi_lib.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 439 1157 37.9 %
Date: 2022-04-01 14:35:51 Functions: 41 88 46.6 %
Branches: 175 680 25.7 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * Copyright (C) 1999 Eric Youngdale
       4                 :            :  * Copyright (C) 2014 Christoph Hellwig
       5                 :            :  *
       6                 :            :  *  SCSI queueing library.
       7                 :            :  *      Initial versions: Eric Youngdale (eric@andante.org).
       8                 :            :  *                        Based upon conversations with large numbers
       9                 :            :  *                        of people at Linux Expo.
      10                 :            :  */
      11                 :            : 
      12                 :            : #include <linux/bio.h>
      13                 :            : #include <linux/bitops.h>
      14                 :            : #include <linux/blkdev.h>
      15                 :            : #include <linux/completion.h>
      16                 :            : #include <linux/kernel.h>
      17                 :            : #include <linux/export.h>
      18                 :            : #include <linux/init.h>
      19                 :            : #include <linux/pci.h>
      20                 :            : #include <linux/delay.h>
      21                 :            : #include <linux/hardirq.h>
      22                 :            : #include <linux/scatterlist.h>
      23                 :            : #include <linux/blk-mq.h>
      24                 :            : #include <linux/ratelimit.h>
      25                 :            : #include <asm/unaligned.h>
      26                 :            : 
      27                 :            : #include <scsi/scsi.h>
      28                 :            : #include <scsi/scsi_cmnd.h>
      29                 :            : #include <scsi/scsi_dbg.h>
      30                 :            : #include <scsi/scsi_device.h>
      31                 :            : #include <scsi/scsi_driver.h>
      32                 :            : #include <scsi/scsi_eh.h>
      33                 :            : #include <scsi/scsi_host.h>
      34                 :            : #include <scsi/scsi_transport.h> /* __scsi_init_queue() */
      35                 :            : #include <scsi/scsi_dh.h>
      36                 :            : 
      37                 :            : #include <trace/events/scsi.h>
      38                 :            : 
      39                 :            : #include "scsi_debugfs.h"
      40                 :            : #include "scsi_priv.h"
      41                 :            : #include "scsi_logging.h"
      42                 :            : 
      43                 :            : /*
      44                 :            :  * Size of integrity metadata is usually small, 1 inline sg should
      45                 :            :  * cover normal cases.
      46                 :            :  */
      47                 :            : #ifdef CONFIG_ARCH_NO_SG_CHAIN
      48                 :            : #define  SCSI_INLINE_PROT_SG_CNT  0
      49                 :            : #define  SCSI_INLINE_SG_CNT  0
      50                 :            : #else
      51                 :            : #define  SCSI_INLINE_PROT_SG_CNT  1
      52                 :            : #define  SCSI_INLINE_SG_CNT  2
      53                 :            : #endif
      54                 :            : 
      55                 :            : static struct kmem_cache *scsi_sdb_cache;
      56                 :            : static struct kmem_cache *scsi_sense_cache;
      57                 :            : static struct kmem_cache *scsi_sense_isadma_cache;
      58                 :            : static DEFINE_MUTEX(scsi_sense_cache_mutex);
      59                 :            : 
      60                 :            : static void scsi_mq_uninit_cmd(struct scsi_cmnd *cmd);
      61                 :            : 
      62                 :            : static inline struct kmem_cache *
      63                 :        273 : scsi_select_sense_cache(bool unchecked_isa_dma)
      64                 :            : {
      65                 :        273 :         return unchecked_isa_dma ? scsi_sense_isadma_cache : scsi_sense_cache;
      66                 :            : }
      67                 :            : 
      68                 :          0 : static void scsi_free_sense_buffer(bool unchecked_isa_dma,
      69                 :            :                                    unsigned char *sense_buffer)
      70                 :            : {
      71                 :          0 :         kmem_cache_free(scsi_select_sense_cache(unchecked_isa_dma),
      72                 :            :                         sense_buffer);
      73                 :            : }
      74                 :            : 
      75                 :        231 : static unsigned char *scsi_alloc_sense_buffer(bool unchecked_isa_dma,
      76                 :            :         gfp_t gfp_mask, int numa_node)
      77                 :            : {
      78                 :        231 :         return kmem_cache_alloc_node(scsi_select_sense_cache(unchecked_isa_dma),
      79                 :            :                                      gfp_mask, numa_node);
      80                 :            : }
      81                 :            : 
      82                 :         42 : int scsi_init_sense_cache(struct Scsi_Host *shost)
      83                 :            : {
      84                 :         42 :         struct kmem_cache *cache;
      85                 :         42 :         int ret = 0;
      86                 :            : 
      87                 :         42 :         mutex_lock(&scsi_sense_cache_mutex);
      88         [ -  + ]:         42 :         cache = scsi_select_sense_cache(shost->unchecked_isa_dma);
      89         [ +  + ]:         42 :         if (cache)
      90                 :         21 :                 goto exit;
      91                 :            : 
      92         [ -  + ]:         21 :         if (shost->unchecked_isa_dma) {
      93                 :          0 :                 scsi_sense_isadma_cache =
      94                 :          0 :                         kmem_cache_create("scsi_sense_cache(DMA)",
      95                 :            :                                 SCSI_SENSE_BUFFERSIZE, 0,
      96                 :            :                                 SLAB_HWCACHE_ALIGN | SLAB_CACHE_DMA, NULL);
      97         [ #  # ]:          0 :                 if (!scsi_sense_isadma_cache)
      98                 :          0 :                         ret = -ENOMEM;
      99                 :            :         } else {
     100                 :         42 :                 scsi_sense_cache =
     101                 :         21 :                         kmem_cache_create_usercopy("scsi_sense_cache",
     102                 :            :                                 SCSI_SENSE_BUFFERSIZE, 0, SLAB_HWCACHE_ALIGN,
     103                 :            :                                 0, SCSI_SENSE_BUFFERSIZE, NULL);
     104         [ +  - ]:         21 :                 if (!scsi_sense_cache)
     105                 :          0 :                         ret = -ENOMEM;
     106                 :            :         }
     107                 :         21 :  exit:
     108                 :         42 :         mutex_unlock(&scsi_sense_cache_mutex);
     109                 :         42 :         return ret;
     110                 :            : }
     111                 :            : 
     112                 :            : /*
     113                 :            :  * When to reinvoke queueing after a resource shortage. It's 3 msecs to
     114                 :            :  * not change behaviour from the previous unplug mechanism, experimentation
     115                 :            :  * may prove this needs changing.
     116                 :            :  */
     117                 :            : #define SCSI_QUEUE_DELAY        3
     118                 :            : 
     119                 :            : static void
     120                 :          0 : scsi_set_blocked(struct scsi_cmnd *cmd, int reason)
     121                 :            : {
     122                 :          0 :         struct Scsi_Host *host = cmd->device->host;
     123                 :          0 :         struct scsi_device *device = cmd->device;
     124   [ #  #  #  # ]:          0 :         struct scsi_target *starget = scsi_target(device);
     125                 :            : 
     126                 :            :         /*
     127                 :            :          * Set the appropriate busy bit for the device/host.
     128                 :            :          *
     129                 :            :          * If the host/device isn't busy, assume that something actually
     130                 :            :          * completed, and that we should be able to queue a command now.
     131                 :            :          *
     132                 :            :          * Note that the prior mid-layer assumption that any host could
     133                 :            :          * always queue at least one command is now broken.  The mid-layer
     134                 :            :          * will implement a user specifiable stall (see
     135                 :            :          * scsi_host.max_host_blocked and scsi_device.max_device_blocked)
     136                 :            :          * if a command is requeued with no other commands outstanding
     137                 :            :          * either for the device or for the host.
     138                 :            :          */
     139   [ #  #  #  # ]:          0 :         switch (reason) {
     140                 :          0 :         case SCSI_MLQUEUE_HOST_BUSY:
     141                 :          0 :                 atomic_set(&host->host_blocked, host->max_host_blocked);
     142                 :            :                 break;
     143                 :          0 :         case SCSI_MLQUEUE_DEVICE_BUSY:
     144                 :            :         case SCSI_MLQUEUE_EH_RETRY:
     145                 :          0 :                 atomic_set(&device->device_blocked,
     146                 :          0 :                            device->max_device_blocked);
     147                 :            :                 break;
     148                 :          0 :         case SCSI_MLQUEUE_TARGET_BUSY:
     149                 :          0 :                 atomic_set(&starget->target_blocked,
     150                 :          0 :                            starget->max_target_blocked);
     151                 :            :                 break;
     152                 :            :         }
     153                 :          0 : }
     154                 :            : 
     155                 :          0 : static void scsi_mq_requeue_cmd(struct scsi_cmnd *cmd)
     156                 :            : {
     157         [ #  # ]:          0 :         if (cmd->request->rq_flags & RQF_DONTPREP) {
     158                 :          0 :                 cmd->request->rq_flags &= ~RQF_DONTPREP;
     159                 :          0 :                 scsi_mq_uninit_cmd(cmd);
     160                 :            :         } else {
     161                 :          0 :                 WARN_ON_ONCE(true);
     162                 :            :         }
     163                 :          0 :         blk_mq_requeue_request(cmd->request, true);
     164                 :          0 : }
     165                 :            : 
     166                 :            : /**
     167                 :            :  * __scsi_queue_insert - private queue insertion
     168                 :            :  * @cmd: The SCSI command being requeued
     169                 :            :  * @reason:  The reason for the requeue
     170                 :            :  * @unbusy: Whether the queue should be unbusied
     171                 :            :  *
     172                 :            :  * This is a private queue insertion.  The public interface
     173                 :            :  * scsi_queue_insert() always assumes the queue should be unbusied
     174                 :            :  * because it's always called before the completion.  This function is
     175                 :            :  * for a requeue after completion, which should only occur in this
     176                 :            :  * file.
     177                 :            :  */
     178                 :          0 : static void __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, bool unbusy)
     179                 :            : {
     180                 :          0 :         struct scsi_device *device = cmd->device;
     181                 :            : 
     182                 :          0 :         SCSI_LOG_MLQUEUE(1, scmd_printk(KERN_INFO, cmd,
     183                 :          0 :                 "Inserting command %p into mlqueue\n", cmd));
     184                 :            : 
     185                 :          0 :         scsi_set_blocked(cmd, reason);
     186                 :            : 
     187                 :            :         /*
     188                 :            :          * Decrement the counters, since these commands are no longer
     189                 :            :          * active on the host/device.
     190                 :            :          */
     191         [ #  # ]:          0 :         if (unbusy)
     192                 :          0 :                 scsi_device_unbusy(device, cmd);
     193                 :            : 
     194                 :            :         /*
     195                 :            :          * Requeue this command.  It will go before all other commands
     196                 :            :          * that are already in the queue. Schedule requeue work under
     197                 :            :          * lock such that the kblockd_schedule_work() call happens
     198                 :            :          * before blk_cleanup_queue() finishes.
     199                 :            :          */
     200                 :          0 :         cmd->result = 0;
     201                 :            : 
     202                 :          0 :         blk_mq_requeue_request(cmd->request, true);
     203                 :          0 : }
     204                 :            : 
     205                 :            : /*
     206                 :            :  * Function:    scsi_queue_insert()
     207                 :            :  *
     208                 :            :  * Purpose:     Insert a command in the midlevel queue.
     209                 :            :  *
     210                 :            :  * Arguments:   cmd    - command that we are adding to queue.
     211                 :            :  *              reason - why we are inserting command to queue.
     212                 :            :  *
     213                 :            :  * Lock status: Assumed that lock is not held upon entry.
     214                 :            :  *
     215                 :            :  * Returns:     Nothing.
     216                 :            :  *
     217                 :            :  * Notes:       We do this for one of two cases.  Either the host is busy
     218                 :            :  *              and it cannot accept any more commands for the time being,
     219                 :            :  *              or the device returned QUEUE_FULL and can accept no more
     220                 :            :  *              commands.
     221                 :            :  * Notes:       This could be called either from an interrupt context or a
     222                 :            :  *              normal process context.
     223                 :            :  */
     224                 :          0 : void scsi_queue_insert(struct scsi_cmnd *cmd, int reason)
     225                 :            : {
     226                 :          0 :         __scsi_queue_insert(cmd, reason, true);
     227                 :          0 : }
     228                 :            : 
     229                 :            : 
     230                 :            : /**
     231                 :            :  * __scsi_execute - insert request and wait for the result
     232                 :            :  * @sdev:       scsi device
     233                 :            :  * @cmd:        scsi command
     234                 :            :  * @data_direction: data direction
     235                 :            :  * @buffer:     data buffer
     236                 :            :  * @bufflen:    len of buffer
     237                 :            :  * @sense:      optional sense buffer
     238                 :            :  * @sshdr:      optional decoded sense header
     239                 :            :  * @timeout:    request timeout in seconds
     240                 :            :  * @retries:    number of times to retry request
     241                 :            :  * @flags:      flags for ->cmd_flags
     242                 :            :  * @rq_flags:   flags for ->rq_flags
     243                 :            :  * @resid:      optional residual length
     244                 :            :  *
     245                 :            :  * Returns the scsi_cmnd result field if a command was executed, or a negative
     246                 :            :  * Linux error code if we didn't get that far.
     247                 :            :  */
     248                 :       2646 : int __scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
     249                 :            :                  int data_direction, void *buffer, unsigned bufflen,
     250                 :            :                  unsigned char *sense, struct scsi_sense_hdr *sshdr,
     251                 :            :                  int timeout, int retries, u64 flags, req_flags_t rq_flags,
     252                 :            :                  int *resid)
     253                 :            : {
     254                 :       2646 :         struct request *req;
     255                 :       2646 :         struct scsi_request *rq;
     256                 :       2646 :         int ret = DRIVER_ERROR << 24;
     257                 :            : 
     258         [ +  - ]:       5292 :         req = blk_get_request(sdev->request_queue,
     259                 :            :                         data_direction == DMA_TO_DEVICE ?
     260                 :            :                         REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, BLK_MQ_REQ_PREEMPT);
     261         [ +  - ]:       2646 :         if (IS_ERR(req))
     262                 :            :                 return ret;
     263         [ +  + ]:       2646 :         rq = scsi_req(req);
     264                 :            : 
     265   [ +  +  -  + ]:       2646 :         if (bufflen &&  blk_rq_map_kern(sdev->request_queue, req,
     266                 :            :                                         buffer, bufflen, GFP_NOIO))
     267                 :          0 :                 goto out;
     268                 :            : 
     269                 :       2646 :         rq->cmd_len = COMMAND_SIZE(cmd[0]);
     270                 :       2646 :         memcpy(rq->cmd, cmd, rq->cmd_len);
     271                 :       2646 :         rq->retries = retries;
     272                 :       2646 :         req->timeout = timeout;
     273                 :       2646 :         req->cmd_flags |= flags;
     274                 :       2646 :         req->rq_flags |= rq_flags | RQF_QUIET;
     275                 :            : 
     276                 :            :         /*
     277                 :            :          * head injection *required* here otherwise quiesce won't work
     278                 :            :          */
     279                 :       2646 :         blk_execute_rq(req->q, NULL, req, 1);
     280                 :            : 
     281                 :            :         /*
     282                 :            :          * Some devices (USB mass-storage in particular) may transfer
     283                 :            :          * garbage data together with a residue indicating that the data
     284                 :            :          * is invalid.  Prevent the garbage from being misinterpreted
     285                 :            :          * and prevent security leaks by zeroing out the excess data.
     286                 :            :          */
     287   [ -  +  -  - ]:       2646 :         if (unlikely(rq->resid_len > 0 && rq->resid_len <= bufflen))
     288                 :          0 :                 memset(buffer + (bufflen - rq->resid_len), 0, rq->resid_len);
     289                 :            : 
     290         [ +  + ]:       2646 :         if (resid)
     291                 :        105 :                 *resid = rq->resid_len;
     292   [ -  +  -  - ]:       2646 :         if (sense && rq->sense_len)
     293                 :          0 :                 memcpy(sense, rq->sense, SCSI_SENSE_BUFFERSIZE);
     294         [ +  + ]:       2646 :         if (sshdr)
     295                 :       1575 :                 scsi_normalize_sense(rq->sense, rq->sense_len, sshdr);
     296                 :       2646 :         ret = rq->result;
     297                 :       2646 :  out:
     298                 :       2646 :         blk_put_request(req);
     299                 :            : 
     300                 :       2646 :         return ret;
     301                 :            : }
     302                 :            : EXPORT_SYMBOL(__scsi_execute);
     303                 :            : 
     304                 :            : /*
     305                 :            :  * Function:    scsi_init_cmd_errh()
     306                 :            :  *
     307                 :            :  * Purpose:     Initialize cmd fields related to error handling.
     308                 :            :  *
     309                 :            :  * Arguments:   cmd     - command that is ready to be queued.
     310                 :            :  *
     311                 :            :  * Notes:       This function has the job of initializing a number of
     312                 :            :  *              fields related to error handling.   Typically this will
     313                 :            :  *              be called once for each command, as required.
     314                 :            :  */
     315                 :      23739 : static void scsi_init_cmd_errh(struct scsi_cmnd *cmd)
     316                 :            : {
     317         [ -  + ]:      23739 :         scsi_set_resid(cmd, 0);
     318                 :      23739 :         memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
     319         [ -  + ]:      23739 :         if (cmd->cmd_len == 0)
     320         [ #  # ]:          0 :                 cmd->cmd_len = scsi_command_size(cmd->cmnd);
     321                 :      23739 : }
     322                 :            : 
     323                 :            : /*
     324                 :            :  * Wake up the error handler if necessary. Avoid as follows that the error
     325                 :            :  * handler is not woken up if host in-flight requests number ==
     326                 :            :  * shost->host_failed: use call_rcu() in scsi_eh_scmd_add() in combination
     327                 :            :  * with an RCU read lock in this function to ensure that this function in
     328                 :            :  * its entirety either finishes before scsi_eh_scmd_add() increases the
     329                 :            :  * host_failed counter or that it notices the shost state change made by
     330                 :            :  * scsi_eh_scmd_add().
     331                 :            :  */
     332                 :      23739 : static void scsi_dec_host_busy(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
     333                 :            : {
     334                 :      23739 :         unsigned long flags;
     335                 :            : 
     336                 :      23739 :         rcu_read_lock();
     337                 :      23739 :         __clear_bit(SCMD_STATE_INFLIGHT, &cmd->state);
     338   [ +  +  +  + ]:      47268 :         if (unlikely(scsi_host_in_recovery(shost))) {
     339                 :        210 :                 spin_lock_irqsave(shost->host_lock, flags);
     340   [ -  +  -  - ]:        210 :                 if (shost->host_failed || shost->host_eh_scheduled)
     341                 :        210 :                         scsi_eh_wakeup(shost);
     342                 :        210 :                 spin_unlock_irqrestore(shost->host_lock, flags);
     343                 :            :         }
     344                 :      23739 :         rcu_read_unlock();
     345                 :      23739 : }
     346                 :            : 
     347                 :      23739 : void scsi_device_unbusy(struct scsi_device *sdev, struct scsi_cmnd *cmd)
     348                 :            : {
     349                 :      23739 :         struct Scsi_Host *shost = sdev->host;
     350                 :      23739 :         struct scsi_target *starget = scsi_target(sdev);
     351                 :            : 
     352                 :      23739 :         scsi_dec_host_busy(shost, cmd);
     353                 :            : 
     354         [ -  + ]:      23739 :         if (starget->can_queue > 0)
     355                 :          0 :                 atomic_dec(&starget->target_busy);
     356                 :            : 
     357                 :      23739 :         atomic_dec(&sdev->device_busy);
     358                 :      23739 : }
     359                 :            : 
     360                 :          0 : static void scsi_kick_queue(struct request_queue *q)
     361                 :            : {
     362                 :          0 :         blk_mq_run_hw_queues(q, false);
     363                 :            : }
     364                 :            : 
     365                 :            : /*
     366                 :            :  * Called for single_lun devices on IO completion. Clear starget_sdev_user,
     367                 :            :  * and call blk_run_queue for all the scsi_devices on the target -
     368                 :            :  * including current_sdev first.
     369                 :            :  *
     370                 :            :  * Called with *no* scsi locks held.
     371                 :            :  */
     372                 :          0 : static void scsi_single_lun_run(struct scsi_device *current_sdev)
     373                 :            : {
     374                 :          0 :         struct Scsi_Host *shost = current_sdev->host;
     375                 :          0 :         struct scsi_device *sdev, *tmp;
     376                 :          0 :         struct scsi_target *starget = scsi_target(current_sdev);
     377                 :          0 :         unsigned long flags;
     378                 :            : 
     379                 :          0 :         spin_lock_irqsave(shost->host_lock, flags);
     380                 :          0 :         starget->starget_sdev_user = NULL;
     381                 :          0 :         spin_unlock_irqrestore(shost->host_lock, flags);
     382                 :            : 
     383                 :            :         /*
     384                 :            :          * Call blk_run_queue for all LUNs on the target, starting with
     385                 :            :          * current_sdev. We race with others (to set starget_sdev_user),
     386                 :            :          * but in most cases, we will be first. Ideally, each LU on the
     387                 :            :          * target would get some limited time or requests on the target.
     388                 :            :          */
     389                 :          0 :         scsi_kick_queue(current_sdev->request_queue);
     390                 :            : 
     391                 :          0 :         spin_lock_irqsave(shost->host_lock, flags);
     392         [ #  # ]:          0 :         if (starget->starget_sdev_user)
     393                 :          0 :                 goto out;
     394         [ #  # ]:          0 :         list_for_each_entry_safe(sdev, tmp, &starget->devices,
     395                 :            :                         same_target_siblings) {
     396         [ #  # ]:          0 :                 if (sdev == current_sdev)
     397                 :          0 :                         continue;
     398         [ #  # ]:          0 :                 if (scsi_device_get(sdev))
     399                 :          0 :                         continue;
     400                 :            : 
     401                 :          0 :                 spin_unlock_irqrestore(shost->host_lock, flags);
     402                 :          0 :                 scsi_kick_queue(sdev->request_queue);
     403                 :          0 :                 spin_lock_irqsave(shost->host_lock, flags);
     404                 :            :         
     405                 :          0 :                 scsi_device_put(sdev);
     406                 :            :         }
     407                 :          0 :  out:
     408                 :          0 :         spin_unlock_irqrestore(shost->host_lock, flags);
     409                 :          0 : }
     410                 :            : 
     411                 :          0 : static inline bool scsi_device_is_busy(struct scsi_device *sdev)
     412                 :            : {
     413         [ #  # ]:          0 :         if (atomic_read(&sdev->device_busy) >= sdev->queue_depth)
     414                 :            :                 return true;
     415         [ #  # ]:          0 :         if (atomic_read(&sdev->device_blocked) > 0)
     416                 :          0 :                 return true;
     417                 :            :         return false;
     418                 :            : }
     419                 :            : 
     420                 :          0 : static inline bool scsi_target_is_busy(struct scsi_target *starget)
     421                 :            : {
     422         [ #  # ]:          0 :         if (starget->can_queue > 0) {
     423         [ #  # ]:          0 :                 if (atomic_read(&starget->target_busy) >= starget->can_queue)
     424                 :            :                         return true;
     425         [ #  # ]:          0 :                 if (atomic_read(&starget->target_blocked) > 0)
     426                 :          0 :                         return true;
     427                 :            :         }
     428                 :            :         return false;
     429                 :            : }
     430                 :            : 
     431                 :          0 : static inline bool scsi_host_is_busy(struct Scsi_Host *shost)
     432                 :            : {
     433         [ #  # ]:          0 :         if (atomic_read(&shost->host_blocked) > 0)
     434                 :            :                 return true;
     435         [ #  # ]:          0 :         if (shost->host_self_blocked)
     436                 :            :                 return true;
     437                 :            :         return false;
     438                 :            : }
     439                 :            : 
     440                 :          0 : static void scsi_starved_list_run(struct Scsi_Host *shost)
     441                 :            : {
     442                 :          0 :         LIST_HEAD(starved_list);
     443                 :          0 :         struct scsi_device *sdev;
     444                 :          0 :         unsigned long flags;
     445                 :            : 
     446                 :          0 :         spin_lock_irqsave(shost->host_lock, flags);
     447         [ #  # ]:          0 :         list_splice_init(&shost->starved_list, &starved_list);
     448                 :            : 
     449                 :          0 :         while (!list_empty(&starved_list)) {
     450                 :          0 :                 struct request_queue *slq;
     451                 :            : 
     452                 :            :                 /*
     453                 :            :                  * As long as shost is accepting commands and we have
     454                 :            :                  * starved queues, call blk_run_queue. scsi_request_fn
     455                 :            :                  * drops the queue_lock and can add us back to the
     456                 :            :                  * starved_list.
     457                 :            :                  *
     458                 :            :                  * host_lock protects the starved_list and starved_entry.
     459                 :            :                  * scsi_request_fn must get the host_lock before checking
     460                 :            :                  * or modifying starved_list or starved_entry.
     461                 :            :                  */
     462                 :          0 :                 if (scsi_host_is_busy(shost))
     463                 :            :                         break;
     464                 :            : 
     465                 :          0 :                 sdev = list_entry(starved_list.next,
     466                 :            :                                   struct scsi_device, starved_entry);
     467                 :          0 :                 list_del_init(&sdev->starved_entry);
     468         [ #  # ]:          0 :                 if (scsi_target_is_busy(scsi_target(sdev))) {
     469                 :          0 :                         list_move_tail(&sdev->starved_entry,
     470                 :            :                                        &shost->starved_list);
     471                 :          0 :                         continue;
     472                 :            :                 }
     473                 :            : 
     474                 :            :                 /*
     475                 :            :                  * Once we drop the host lock, a racing scsi_remove_device()
     476                 :            :                  * call may remove the sdev from the starved list and destroy
     477                 :            :                  * it and the queue.  Mitigate by taking a reference to the
     478                 :            :                  * queue and never touching the sdev again after we drop the
     479                 :            :                  * host lock.  Note: if __scsi_remove_device() invokes
     480                 :            :                  * blk_cleanup_queue() before the queue is run from this
     481                 :            :                  * function then blk_run_queue() will return immediately since
     482                 :            :                  * blk_cleanup_queue() marks the queue with QUEUE_FLAG_DYING.
     483                 :            :                  */
     484                 :          0 :                 slq = sdev->request_queue;
     485         [ #  # ]:          0 :                 if (!blk_get_queue(slq))
     486                 :          0 :                         continue;
     487                 :          0 :                 spin_unlock_irqrestore(shost->host_lock, flags);
     488                 :            : 
     489                 :          0 :                 scsi_kick_queue(slq);
     490                 :          0 :                 blk_put_queue(slq);
     491                 :            : 
     492         [ #  # ]:          0 :                 spin_lock_irqsave(shost->host_lock, flags);
     493                 :            :         }
     494                 :            :         /* put any unprocessed entries back */
     495         [ #  # ]:          0 :         list_splice(&starved_list, &shost->starved_list);
     496                 :          0 :         spin_unlock_irqrestore(shost->host_lock, flags);
     497                 :          0 : }
     498                 :            : 
     499                 :            : /*
     500                 :            :  * Function:   scsi_run_queue()
     501                 :            :  *
     502                 :            :  * Purpose:    Select a proper request queue to serve next
     503                 :            :  *
     504                 :            :  * Arguments:  q       - last request's queue
     505                 :            :  *
     506                 :            :  * Returns:     Nothing
     507                 :            :  *
     508                 :            :  * Notes:      The previous command was completely finished, start
     509                 :            :  *             a new one if possible.
     510                 :            :  */
     511                 :        210 : static void scsi_run_queue(struct request_queue *q)
     512                 :            : {
     513                 :        210 :         struct scsi_device *sdev = q->queuedata;
     514                 :            : 
     515         [ -  + ]:        210 :         if (scsi_target(sdev)->single_lun)
     516                 :          0 :                 scsi_single_lun_run(sdev);
     517         [ -  + ]:        210 :         if (!list_empty(&sdev->host->starved_list))
     518                 :          0 :                 scsi_starved_list_run(sdev->host);
     519                 :            : 
     520                 :        210 :         blk_mq_run_hw_queues(q, false);
     521                 :        210 : }
     522                 :            : 
     523                 :          0 : void scsi_requeue_run_queue(struct work_struct *work)
     524                 :            : {
     525                 :          0 :         struct scsi_device *sdev;
     526                 :          0 :         struct request_queue *q;
     527                 :            : 
     528                 :          0 :         sdev = container_of(work, struct scsi_device, requeue_work);
     529                 :          0 :         q = sdev->request_queue;
     530                 :          0 :         scsi_run_queue(q);
     531                 :          0 : }
     532                 :            : 
     533                 :        252 : void scsi_run_host_queues(struct Scsi_Host *shost)
     534                 :            : {
     535                 :        252 :         struct scsi_device *sdev;
     536                 :            : 
     537         [ +  + ]:        462 :         shost_for_each_device(sdev, shost)
     538                 :        210 :                 scsi_run_queue(sdev->request_queue);
     539                 :        252 : }
     540                 :            : 
     541                 :      23739 : static void scsi_uninit_cmd(struct scsi_cmnd *cmd)
     542                 :            : {
     543   [ +  +  +  + ]:      44643 :         if (!blk_rq_is_passthrough(cmd->request)) {
     544         [ +  - ]:      20904 :                 struct scsi_driver *drv = scsi_cmd_to_driver(cmd);
     545                 :            : 
     546         [ +  - ]:      20904 :                 if (drv->uninit_command)
     547                 :      20904 :                         drv->uninit_command(cmd);
     548                 :            :         }
     549                 :      23739 : }
     550                 :            : 
     551                 :      23739 : static void scsi_mq_free_sgtables(struct scsi_cmnd *cmd)
     552                 :            : {
     553         [ +  + ]:      23739 :         if (cmd->sdb.table.nents)
     554                 :      23040 :                 sg_free_table_chained(&cmd->sdb.table,
     555                 :            :                                 SCSI_INLINE_SG_CNT);
     556   [ -  +  -  - ]:      23739 :         if (scsi_prot_sg_count(cmd))
     557                 :          0 :                 sg_free_table_chained(&cmd->prot_sdb->table,
     558                 :            :                                 SCSI_INLINE_PROT_SG_CNT);
     559                 :      23739 : }
     560                 :            : 
     561                 :      23739 : static void scsi_mq_uninit_cmd(struct scsi_cmnd *cmd)
     562                 :            : {
     563                 :      23739 :         scsi_mq_free_sgtables(cmd);
     564                 :      23739 :         scsi_uninit_cmd(cmd);
     565                 :      23739 :         scsi_del_cmd_from_list(cmd);
     566                 :      23739 : }
     567                 :            : 
     568                 :            : /* Returns false when no more bytes to process, true if there are more */
     569                 :      23739 : static bool scsi_end_request(struct request *req, blk_status_t error,
     570                 :            :                 unsigned int bytes)
     571                 :            : {
     572                 :      23739 :         struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
     573                 :      23739 :         struct scsi_device *sdev = cmd->device;
     574                 :      23739 :         struct request_queue *q = sdev->request_queue;
     575                 :            : 
     576         [ +  - ]:      23739 :         if (blk_update_request(req, error, bytes))
     577                 :            :                 return true;
     578                 :            : 
     579         [ +  + ]:      23739 :         if (blk_queue_add_random(q))
     580                 :      22668 :                 add_disk_randomness(req->rq_disk);
     581                 :            : 
     582         [ +  + ]:      23739 :         if (!blk_rq_is_scsi(req)) {
     583         [ -  + ]:      20904 :                 WARN_ON_ONCE(!(cmd->flags & SCMD_INITIALIZED));
     584                 :      20904 :                 cmd->flags &= ~SCMD_INITIALIZED;
     585                 :            :         }
     586                 :            : 
     587                 :            :         /*
     588                 :            :          * Calling rcu_barrier() is not necessary here because the
     589                 :            :          * SCSI error handler guarantees that the function called by
     590                 :            :          * call_rcu() has been called before scsi_end_request() is
     591                 :            :          * called.
     592                 :            :          */
     593                 :      23739 :         destroy_rcu_head(&cmd->rcu);
     594                 :            : 
     595                 :            :         /*
     596                 :            :          * In the MQ case the command gets freed by __blk_mq_end_request,
     597                 :            :          * so we have to do all cleanup that depends on it earlier.
     598                 :            :          *
     599                 :            :          * We also can't kick the queues from irq context, so we
     600                 :            :          * will have to defer it to a workqueue.
     601                 :            :          */
     602                 :      23739 :         scsi_mq_uninit_cmd(cmd);
     603                 :            : 
     604                 :            :         /*
     605                 :            :          * queue is still alive, so grab the ref for preventing it
     606                 :            :          * from being cleaned up during running queue.
     607                 :            :          */
     608                 :      23739 :         percpu_ref_get(&q->q_usage_counter);
     609                 :            : 
     610                 :      23739 :         __blk_mq_end_request(req, error);
     611                 :            : 
     612   [ +  -  -  + ]:      23739 :         if (scsi_target(sdev)->single_lun ||
     613         [ -  + ]:      23739 :             !list_empty(&sdev->host->starved_list))
     614                 :          0 :                 kblockd_schedule_work(&sdev->requeue_work);
     615                 :            :         else
     616                 :      23739 :                 blk_mq_run_hw_queues(q, true);
     617                 :            : 
     618                 :      23739 :         percpu_ref_put(&q->q_usage_counter);
     619                 :      23739 :         return false;
     620                 :            : }
     621                 :            : 
     622                 :            : /**
     623                 :            :  * scsi_result_to_blk_status - translate a SCSI result code into blk_status_t
     624                 :            :  * @cmd:        SCSI command
     625                 :            :  * @result:     scsi error code
     626                 :            :  *
     627                 :            :  * Translate a SCSI result code into a blk_status_t value. May reset the host
     628                 :            :  * byte of @cmd->result.
     629                 :            :  */
     630                 :        273 : static blk_status_t scsi_result_to_blk_status(struct scsi_cmnd *cmd, int result)
     631                 :            : {
     632   [ +  -  -  -  :        273 :         switch (host_byte(result)) {
                -  -  - ]
     633                 :            :         case DID_OK:
     634                 :            :                 /*
     635                 :            :                  * Also check the other bytes than the status byte in result
     636                 :            :                  * to handle the case when a SCSI LLD sets result to
     637                 :            :                  * DRIVER_SENSE << 24 without setting SAM_STAT_CHECK_CONDITION.
     638                 :            :                  */
     639   [ +  -  -  - ]:        273 :                 if (scsi_status_is_good(result) && (result & ~0xff) == 0)
     640                 :          0 :                         return BLK_STS_OK;
     641                 :            :                 return BLK_STS_IOERR;
     642                 :            :         case DID_TRANSPORT_FAILFAST:
     643                 :            :                 return BLK_STS_TRANSPORT;
     644                 :            :         case DID_TARGET_FAILURE:
     645                 :          0 :                 set_host_byte(cmd, DID_OK);
     646                 :          0 :                 return BLK_STS_TARGET;
     647                 :            :         case DID_NEXUS_FAILURE:
     648                 :          0 :                 set_host_byte(cmd, DID_OK);
     649                 :          0 :                 return BLK_STS_NEXUS;
     650                 :            :         case DID_ALLOC_FAILURE:
     651                 :          0 :                 set_host_byte(cmd, DID_OK);
     652                 :          0 :                 return BLK_STS_NOSPC;
     653                 :            :         case DID_MEDIUM_ERROR:
     654                 :          0 :                 set_host_byte(cmd, DID_OK);
     655                 :          0 :                 return BLK_STS_MEDIUM;
     656                 :          0 :         default:
     657                 :          0 :                 return BLK_STS_IOERR;
     658                 :            :         }
     659                 :            : }
     660                 :            : 
     661                 :            : /* Helper for scsi_io_completion() when "reprep" action required. */
     662                 :          0 : static void scsi_io_completion_reprep(struct scsi_cmnd *cmd,
     663                 :            :                                       struct request_queue *q)
     664                 :            : {
     665                 :            :         /* A new command will be prepared and issued. */
     666                 :          0 :         scsi_mq_requeue_cmd(cmd);
     667                 :          0 : }
     668                 :            : 
     669                 :            : /* Helper for scsi_io_completion() when special action required. */
     670                 :          0 : static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result)
     671                 :            : {
     672                 :          0 :         struct request_queue *q = cmd->device->request_queue;
     673                 :          0 :         struct request *req = cmd->request;
     674                 :          0 :         int level = 0;
     675                 :          0 :         enum {ACTION_FAIL, ACTION_REPREP, ACTION_RETRY,
     676                 :            :               ACTION_DELAYED_RETRY} action;
     677                 :          0 :         unsigned long wait_for = (cmd->allowed + 1) * req->timeout;
     678                 :          0 :         struct scsi_sense_hdr sshdr;
     679                 :          0 :         bool sense_valid;
     680                 :          0 :         bool sense_current = true;      /* false implies "deferred sense" */
     681                 :          0 :         blk_status_t blk_stat;
     682                 :            : 
     683                 :          0 :         sense_valid = scsi_command_normalize_sense(cmd, &sshdr);
     684         [ #  # ]:          0 :         if (sense_valid)
     685         [ #  # ]:          0 :                 sense_current = !scsi_sense_is_deferred(&sshdr);
     686                 :            : 
     687                 :          0 :         blk_stat = scsi_result_to_blk_status(cmd, result);
     688                 :            : 
     689         [ #  # ]:          0 :         if (host_byte(result) == DID_RESET) {
     690                 :            :                 /* Third party bus reset or reset for error recovery
     691                 :            :                  * reasons.  Just retry the command and see what
     692                 :            :                  * happens.
     693                 :            :                  */
     694                 :            :                 action = ACTION_RETRY;
     695         [ #  # ]:          0 :         } else if (sense_valid && sense_current) {
     696   [ #  #  #  #  :          0 :                 switch (sshdr.sense_key) {
                      # ]
     697                 :          0 :                 case UNIT_ATTENTION:
     698         [ #  # ]:          0 :                         if (cmd->device->removable) {
     699                 :            :                                 /* Detected disc change.  Set a bit
     700                 :            :                                  * and quietly refuse further access.
     701                 :            :                                  */
     702                 :          0 :                                 cmd->device->changed = 1;
     703                 :          0 :                                 action = ACTION_FAIL;
     704                 :            :                         } else {
     705                 :            :                                 /* Must have been a power glitch, or a
     706                 :            :                                  * bus reset.  Could not have been a
     707                 :            :                                  * media change, so we just retry the
     708                 :            :                                  * command and see what happens.
     709                 :            :                                  */
     710                 :            :                                 action = ACTION_RETRY;
     711                 :            :                         }
     712                 :            :                         break;
     713                 :          0 :                 case ILLEGAL_REQUEST:
     714                 :            :                         /* If we had an ILLEGAL REQUEST returned, then
     715                 :            :                          * we may have performed an unsupported
     716                 :            :                          * command.  The only thing this should be
     717                 :            :                          * would be a ten byte read where only a six
     718                 :            :                          * byte read was supported.  Also, on a system
     719                 :            :                          * where READ CAPACITY failed, we may have
     720                 :            :                          * read past the end of the disk.
     721                 :            :                          */
     722         [ #  # ]:          0 :                         if ((cmd->device->use_10_for_rw &&
     723   [ #  #  #  # ]:          0 :                             sshdr.asc == 0x20 && sshdr.ascq == 0x00) &&
     724         [ #  # ]:          0 :                             (cmd->cmnd[0] == READ_10 ||
     725                 :            :                              cmd->cmnd[0] == WRITE_10)) {
     726                 :            :                                 /* This will issue a new 6-byte command. */
     727                 :          0 :                                 cmd->device->use_10_for_rw = 0;
     728                 :          0 :                                 action = ACTION_REPREP;
     729         [ #  # ]:          0 :                         } else if (sshdr.asc == 0x10) /* DIX */ {
     730                 :            :                                 action = ACTION_FAIL;
     731                 :            :                                 blk_stat = BLK_STS_PROTECTION;
     732                 :            :                         /* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
     733         [ #  # ]:          0 :                         } else if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
     734                 :            :                                 action = ACTION_FAIL;
     735                 :            :                                 blk_stat = BLK_STS_TARGET;
     736                 :            :                         } else
     737                 :            :                                 action = ACTION_FAIL;
     738                 :            :                         break;
     739                 :          0 :                 case ABORTED_COMMAND:
     740                 :          0 :                         action = ACTION_FAIL;
     741         [ #  # ]:          0 :                         if (sshdr.asc == 0x10) /* DIF */
     742                 :            :                                 blk_stat = BLK_STS_PROTECTION;
     743                 :            :                         break;
     744                 :          0 :                 case NOT_READY:
     745                 :            :                         /* If the device is in the process of becoming
     746                 :            :                          * ready, or has a temporary blockage, retry.
     747                 :            :                          */
     748         [ #  # ]:          0 :                         if (sshdr.asc == 0x04) {
     749         [ #  # ]:          0 :                                 switch (sshdr.ascq) {
     750                 :            :                                 case 0x01: /* becoming ready */
     751                 :            :                                 case 0x04: /* format in progress */
     752                 :            :                                 case 0x05: /* rebuild in progress */
     753                 :            :                                 case 0x06: /* recalculation in progress */
     754                 :            :                                 case 0x07: /* operation in progress */
     755                 :            :                                 case 0x08: /* Long write in progress */
     756                 :            :                                 case 0x09: /* self test in progress */
     757                 :            :                                 case 0x14: /* space allocation in progress */
     758                 :            :                                 case 0x1a: /* start stop unit in progress */
     759                 :            :                                 case 0x1b: /* sanitize in progress */
     760                 :            :                                 case 0x1d: /* configuration in progress */
     761                 :            :                                 case 0x24: /* depopulation in progress */
     762                 :            :                                         action = ACTION_DELAYED_RETRY;
     763                 :            :                                         break;
     764                 :            :                                 default:
     765                 :            :                                         action = ACTION_FAIL;
     766                 :            :                                         break;
     767                 :            :                                 }
     768                 :            :                         } else
     769                 :            :                                 action = ACTION_FAIL;
     770                 :            :                         break;
     771                 :            :                 case VOLUME_OVERFLOW:
     772                 :            :                         /* See SSC3rXX or current. */
     773                 :            :                         action = ACTION_FAIL;
     774                 :            :                         break;
     775                 :            :                 default:
     776                 :            :                         action = ACTION_FAIL;
     777                 :            :                         break;
     778                 :            :                 }
     779                 :            :         } else
     780                 :            :                 action = ACTION_FAIL;
     781                 :            : 
     782                 :          0 :         if (action != ACTION_FAIL &&
     783         [ #  # ]:          0 :             time_before(cmd->jiffies_at_alloc + wait_for, jiffies))
     784                 :            :                 action = ACTION_FAIL;
     785                 :            : 
     786   [ #  #  #  # ]:          0 :         switch (action) {
     787                 :          0 :         case ACTION_FAIL:
     788                 :            :                 /* Give up and fail the remainder of the request */
     789         [ #  # ]:          0 :                 if (!(req->rq_flags & RQF_QUIET)) {
     790                 :          0 :                         static DEFINE_RATELIMIT_STATE(_rs,
     791                 :            :                                         DEFAULT_RATELIMIT_INTERVAL,
     792                 :            :                                         DEFAULT_RATELIMIT_BURST);
     793                 :            : 
     794                 :          0 :                         if (unlikely(scsi_logging_level))
     795                 :            :                                 level =
     796                 :            :                                      SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
     797                 :            :                                                     SCSI_LOG_MLCOMPLETE_BITS);
     798                 :            : 
     799                 :            :                         /*
     800                 :            :                          * if logging is enabled the failure will be printed
     801                 :            :                          * in scsi_log_completion(), so avoid duplicate messages
     802                 :            :                          */
     803         [ #  # ]:          0 :                         if (!level && __ratelimit(&_rs)) {
     804                 :          0 :                                 scsi_print_result(cmd, NULL, FAILED);
     805         [ #  # ]:          0 :                                 if (driver_byte(result) == DRIVER_SENSE)
     806                 :          0 :                                         scsi_print_sense(cmd);
     807                 :          0 :                                 scsi_print_command(cmd);
     808                 :            :                         }
     809                 :            :                 }
     810         [ #  # ]:          0 :                 if (!scsi_end_request(req, blk_stat, blk_rq_err_bytes(req)))
     811                 :          0 :                         return;
     812                 :            :                 /*FALLTHRU*/
     813                 :            :         case ACTION_REPREP:
     814                 :          0 :                 scsi_io_completion_reprep(cmd, q);
     815                 :            :                 break;
     816                 :          0 :         case ACTION_RETRY:
     817                 :            :                 /* Retry the same command immediately */
     818                 :          0 :                 __scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY, false);
     819                 :          0 :                 break;
     820                 :          0 :         case ACTION_DELAYED_RETRY:
     821                 :            :                 /* Retry the same command after a delay */
     822                 :          0 :                 __scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY, false);
     823                 :          0 :                 break;
     824                 :            :         }
     825                 :          0 : }
     826                 :            : 
     827                 :            : /*
     828                 :            :  * Helper for scsi_io_completion() when cmd->result is non-zero. Returns a
     829                 :            :  * new result that may suppress further error checking. Also modifies
     830                 :            :  * *blk_statp in some cases.
     831                 :            :  */
     832                 :        273 : static int scsi_io_completion_nz_result(struct scsi_cmnd *cmd, int result,
     833                 :            :                                         blk_status_t *blk_statp)
     834                 :            : {
     835                 :        273 :         bool sense_valid;
     836                 :        273 :         bool sense_current = true;      /* false implies "deferred sense" */
     837                 :        273 :         struct request *req = cmd->request;
     838                 :        273 :         struct scsi_sense_hdr sshdr;
     839                 :            : 
     840                 :        273 :         sense_valid = scsi_command_normalize_sense(cmd, &sshdr);
     841         [ +  - ]:        273 :         if (sense_valid)
     842         [ +  - ]:        546 :                 sense_current = !scsi_sense_is_deferred(&sshdr);
     843                 :            : 
     844   [ -  +  +  - ]:        273 :         if (blk_rq_is_passthrough(req)) {
     845         [ +  - ]:        273 :                 if (sense_valid) {
     846                 :            :                         /*
     847                 :            :                          * SG_IO wants current and deferred errors
     848                 :            :                          */
     849                 :        273 :                         scsi_req(req)->sense_len =
     850                 :        273 :                                 min(8 + cmd->sense_buffer[7],
     851                 :            :                                     SCSI_SENSE_BUFFERSIZE);
     852                 :            :                 }
     853         [ +  - ]:        273 :                 if (sense_current)
     854                 :        273 :                         *blk_statp = scsi_result_to_blk_status(cmd, result);
     855   [ #  #  #  # ]:          0 :         } else if (blk_rq_bytes(req) == 0 && sense_current) {
     856                 :            :                 /*
     857                 :            :                  * Flush commands do not transfers any data, and thus cannot use
     858                 :            :                  * good_bytes != blk_rq_bytes(req) as the signal for an error.
     859                 :            :                  * This sets *blk_statp explicitly for the problem case.
     860                 :            :                  */
     861                 :          0 :                 *blk_statp = scsi_result_to_blk_status(cmd, result);
     862                 :            :         }
     863                 :            :         /*
     864                 :            :          * Recovered errors need reporting, but they're always treated as
     865                 :            :          * success, so fiddle the result code here.  For passthrough requests
     866                 :            :          * we already took a copy of the original into sreq->result which
     867                 :            :          * is what gets returned to the user
     868                 :            :          */
     869   [ +  -  +  + ]:        273 :         if (sense_valid && (sshdr.sense_key == RECOVERED_ERROR)) {
     870                 :         63 :                 bool do_print = true;
     871                 :            :                 /*
     872                 :            :                  * if ATA PASS-THROUGH INFORMATION AVAILABLE [0x0, 0x1d]
     873                 :            :                  * skip print since caller wants ATA registers. Only occurs
     874                 :            :                  * on SCSI ATA PASS_THROUGH commands when CK_COND=1
     875                 :            :                  */
     876   [ +  -  -  + ]:         63 :                 if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d))
     877                 :            :                         do_print = false;
     878         [ #  # ]:          0 :                 else if (req->rq_flags & RQF_QUIET)
     879                 :            :                         do_print = false;
     880                 :          0 :                 if (do_print)
     881                 :          0 :                         scsi_print_sense(cmd);
     882                 :         63 :                 result = 0;
     883                 :            :                 /* for passthrough, *blk_statp may be set */
     884                 :         63 :                 *blk_statp = BLK_STS_OK;
     885                 :            :         }
     886                 :            :         /*
     887                 :            :          * Another corner case: the SCSI status byte is non-zero but 'good'.
     888                 :            :          * Example: PRE-FETCH command returns SAM_STAT_CONDITION_MET when
     889                 :            :          * it is able to fit nominated LBs in its cache (and SAM_STAT_GOOD
     890                 :            :          * if it can't fit). Treat SAM_STAT_CONDITION_MET and the related
     891                 :            :          * intermediate statuses (both obsolete in SAM-4) as good.
     892                 :            :          */
     893         [ +  + ]:        273 :         if (status_byte(result) && scsi_status_is_good(result)) {
     894                 :          0 :                 result = 0;
     895                 :          0 :                 *blk_statp = BLK_STS_OK;
     896                 :            :         }
     897                 :        273 :         return result;
     898                 :            : }
     899                 :            : 
     900                 :            : /*
     901                 :            :  * Function:    scsi_io_completion()
     902                 :            :  *
     903                 :            :  * Purpose:     Completion processing for block device I/O requests.
     904                 :            :  *
     905                 :            :  * Arguments:   cmd   - command that is finished.
     906                 :            :  *
     907                 :            :  * Lock status: Assumed that no lock is held upon entry.
     908                 :            :  *
     909                 :            :  * Returns:     Nothing
     910                 :            :  *
     911                 :            :  * Notes:       We will finish off the specified number of sectors.  If we
     912                 :            :  *              are done, the command block will be released and the queue
     913                 :            :  *              function will be goosed.  If we are not done then we have to
     914                 :            :  *              figure out what to do next:
     915                 :            :  *
     916                 :            :  *              a) We can call scsi_requeue_command().  The request
     917                 :            :  *                 will be unprepared and put back on the queue.  Then
     918                 :            :  *                 a new command will be created for it.  This should
     919                 :            :  *                 be used if we made forward progress, or if we want
     920                 :            :  *                 to switch from READ(10) to READ(6) for example.
     921                 :            :  *
     922                 :            :  *              b) We can call __scsi_queue_insert().  The request will
     923                 :            :  *                 be put back on the queue and retried using the same
     924                 :            :  *                 command as before, possibly after a delay.
     925                 :            :  *
     926                 :            :  *              c) We can call scsi_end_request() with blk_stat other than
     927                 :            :  *                 BLK_STS_OK, to fail the remainder of the request.
     928                 :            :  */
     929                 :      23739 : void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
     930                 :            : {
     931                 :      23739 :         int result = cmd->result;
     932                 :      23739 :         struct request_queue *q = cmd->device->request_queue;
     933                 :      23739 :         struct request *req = cmd->request;
     934                 :      23739 :         blk_status_t blk_stat = BLK_STS_OK;
     935                 :            : 
     936         [ +  + ]:      23739 :         if (unlikely(result))   /* a nz result may or may not be an error */
     937                 :        273 :                 result = scsi_io_completion_nz_result(cmd, result, &blk_stat);
     938                 :            : 
     939   [ +  +  +  + ]:      44643 :         if (unlikely(blk_rq_is_passthrough(req))) {
     940                 :            :                 /*
     941                 :            :                  * scsi_result_to_blk_status may have reset the host_byte
     942                 :            :                  */
     943                 :       2835 :                 scsi_req(req)->result = cmd->result;
     944                 :            :         }
     945                 :            : 
     946                 :            :         /*
     947                 :            :          * Next deal with any sectors which we were able to correctly
     948                 :            :          * handle.
     949                 :            :          */
     950                 :      23739 :         SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, cmd,
     951                 :            :                 "%u sectors total, %d bytes done.\n",
     952                 :      23739 :                 blk_rq_sectors(req), good_bytes));
     953                 :            : 
     954                 :            :         /*
     955                 :            :          * Next deal with any sectors which we were able to correctly
     956                 :            :          * handle. Failed, zero length commands always need to drop down
     957                 :            :          * to retry code. Fast path should return in this block.
     958                 :            :          */
     959   [ +  +  +  + ]:      23739 :         if (likely(blk_rq_bytes(req) > 0 || blk_stat == BLK_STS_OK)) {
     960         [ -  + ]:      23529 :                 if (likely(!scsi_end_request(req, blk_stat, good_bytes)))
     961                 :      23739 :                         return; /* no bytes remaining */
     962                 :            :         }
     963                 :            : 
     964                 :            :         /* Kill remainder if no retries. */
     965   [ +  -  +  - ]:        210 :         if (unlikely(blk_stat && scsi_noretry_cmd(cmd))) {
     966         [ -  + ]:        210 :                 if (scsi_end_request(req, blk_stat, blk_rq_bytes(req)))
     967         [ #  # ]:          0 :                         WARN_ONCE(true,
     968                 :            :                             "Bytes remaining after failed, no-retry command");
     969                 :        210 :                 return;
     970                 :            :         }
     971                 :            : 
     972                 :            :         /*
     973                 :            :          * If there had been no error, but we have leftover bytes in the
     974                 :            :          * requeues just queue the command up again.
     975                 :            :          */
     976         [ #  # ]:          0 :         if (likely(result == 0))
     977                 :          0 :                 scsi_io_completion_reprep(cmd, q);
     978                 :            :         else
     979                 :          0 :                 scsi_io_completion_action(cmd, result);
     980                 :            : }
     981                 :            : 
     982                 :      23040 : static blk_status_t scsi_init_sgtable(struct request *req,
     983                 :            :                 struct scsi_data_buffer *sdb)
     984                 :            : {
     985                 :      23040 :         int count;
     986                 :            : 
     987                 :            :         /*
     988                 :            :          * If sg table allocation fails, requeue request later.
     989                 :            :          */
     990   [ +  -  +  - ]:      46080 :         if (unlikely(sg_alloc_table_chained(&sdb->table,
     991                 :            :                         blk_rq_nr_phys_segments(req), sdb->table.sgl,
     992                 :            :                         SCSI_INLINE_SG_CNT)))
     993                 :            :                 return BLK_STS_RESOURCE;
     994                 :            : 
     995                 :            :         /* 
     996                 :            :          * Next, walk the list, and fill in the addresses and sizes of
     997                 :            :          * each segment.
     998                 :            :          */
     999                 :      23040 :         count = blk_rq_map_sg(req->q, req, sdb->table.sgl);
    1000         [ -  + ]:      23040 :         BUG_ON(count > sdb->table.nents);
    1001                 :      23040 :         sdb->table.nents = count;
    1002         [ -  + ]:      23040 :         sdb->length = blk_rq_payload_bytes(req);
    1003                 :      23040 :         return BLK_STS_OK;
    1004                 :            : }
    1005                 :            : 
    1006                 :            : /*
    1007                 :            :  * Function:    scsi_init_io()
    1008                 :            :  *
    1009                 :            :  * Purpose:     SCSI I/O initialize function.
    1010                 :            :  *
    1011                 :            :  * Arguments:   cmd   - Command descriptor we wish to initialize
    1012                 :            :  *
    1013                 :            :  * Returns:     BLK_STS_OK on success
    1014                 :            :  *              BLK_STS_RESOURCE if the failure is retryable
    1015                 :            :  *              BLK_STS_IOERR if the failure is fatal
    1016                 :            :  */
    1017                 :      23040 : blk_status_t scsi_init_io(struct scsi_cmnd *cmd)
    1018                 :            : {
    1019                 :      23040 :         struct request *rq = cmd->request;
    1020                 :      23040 :         blk_status_t ret;
    1021                 :            : 
    1022   [ +  -  -  +  :      46080 :         if (WARN_ON_ONCE(!blk_rq_nr_phys_segments(rq)))
                   +  - ]
    1023                 :            :                 return BLK_STS_IOERR;
    1024                 :            : 
    1025                 :      23040 :         ret = scsi_init_sgtable(rq, &cmd->sdb);
    1026                 :      23040 :         if (ret)
    1027                 :            :                 return ret;
    1028                 :            : 
    1029                 :            :         if (blk_integrity_rq(rq)) {
    1030                 :            :                 struct scsi_data_buffer *prot_sdb = cmd->prot_sdb;
    1031                 :            :                 int ivecs, count;
    1032                 :            : 
    1033                 :            :                 if (WARN_ON_ONCE(!prot_sdb)) {
    1034                 :            :                         /*
    1035                 :            :                          * This can happen if someone (e.g. multipath)
    1036                 :            :                          * queues a command to a device on an adapter
    1037                 :            :                          * that does not support DIX.
    1038                 :            :                          */
    1039                 :            :                         ret = BLK_STS_IOERR;
    1040                 :            :                         goto out_free_sgtables;
    1041                 :            :                 }
    1042                 :            : 
    1043                 :            :                 ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio);
    1044                 :            : 
    1045                 :            :                 if (sg_alloc_table_chained(&prot_sdb->table, ivecs,
    1046                 :            :                                 prot_sdb->table.sgl,
    1047                 :            :                                 SCSI_INLINE_PROT_SG_CNT)) {
    1048                 :            :                         ret = BLK_STS_RESOURCE;
    1049                 :            :                         goto out_free_sgtables;
    1050                 :            :                 }
    1051                 :            : 
    1052                 :            :                 count = blk_rq_map_integrity_sg(rq->q, rq->bio,
    1053                 :            :                                                 prot_sdb->table.sgl);
    1054                 :            :                 BUG_ON(count > ivecs);
    1055                 :            :                 BUG_ON(count > queue_max_integrity_segments(rq->q));
    1056                 :            : 
    1057                 :            :                 cmd->prot_sdb = prot_sdb;
    1058                 :            :                 cmd->prot_sdb->table.nents = count;
    1059                 :            :         }
    1060                 :            : 
    1061                 :            :         return BLK_STS_OK;
    1062                 :            : out_free_sgtables:
    1063                 :            :         scsi_mq_free_sgtables(cmd);
    1064                 :            :         return ret;
    1065                 :            : }
    1066                 :            : EXPORT_SYMBOL(scsi_init_io);
    1067                 :            : 
    1068                 :            : /**
    1069                 :            :  * scsi_initialize_rq - initialize struct scsi_cmnd partially
    1070                 :            :  * @rq: Request associated with the SCSI command to be initialized.
    1071                 :            :  *
    1072                 :            :  * This function initializes the members of struct scsi_cmnd that must be
    1073                 :            :  * initialized before request processing starts and that won't be
    1074                 :            :  * reinitialized if a SCSI command is requeued.
    1075                 :            :  *
    1076                 :            :  * Called from inside blk_get_request() for pass-through requests and from
    1077                 :            :  * inside scsi_init_command() for filesystem requests.
    1078                 :            :  */
    1079                 :      23739 : static void scsi_initialize_rq(struct request *rq)
    1080                 :            : {
    1081                 :       2835 :         struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
    1082                 :            : 
    1083                 :      23739 :         scsi_req_init(&cmd->req);
    1084                 :      20904 :         init_rcu_head(&cmd->rcu);
    1085                 :      23739 :         cmd->jiffies_at_alloc = jiffies;
    1086                 :      23739 :         cmd->retries = 0;
    1087                 :      20904 : }
    1088                 :            : 
    1089                 :            : /*
    1090                 :            :  * Only called when the request isn't completed by SCSI, and not freed by
    1091                 :            :  * SCSI
    1092                 :            :  */
    1093                 :          0 : static void scsi_cleanup_rq(struct request *rq)
    1094                 :            : {
    1095         [ #  # ]:          0 :         if (rq->rq_flags & RQF_DONTPREP) {
    1096                 :          0 :                 scsi_mq_uninit_cmd(blk_mq_rq_to_pdu(rq));
    1097                 :          0 :                 rq->rq_flags &= ~RQF_DONTPREP;
    1098                 :            :         }
    1099                 :          0 : }
    1100                 :            : 
    1101                 :            : /* Add a command to the list used by the aacraid and dpt_i2o drivers */
    1102                 :      23739 : void scsi_add_cmd_to_list(struct scsi_cmnd *cmd)
    1103                 :            : {
    1104                 :      23739 :         struct scsi_device *sdev = cmd->device;
    1105                 :      23739 :         struct Scsi_Host *shost = sdev->host;
    1106                 :      23739 :         unsigned long flags;
    1107                 :            : 
    1108         [ -  + ]:      23739 :         if (shost->use_cmd_list) {
    1109                 :          0 :                 spin_lock_irqsave(&sdev->list_lock, flags);
    1110                 :          0 :                 list_add_tail(&cmd->list, &sdev->cmd_list);
    1111                 :          0 :                 spin_unlock_irqrestore(&sdev->list_lock, flags);
    1112                 :            :         }
    1113                 :      23739 : }
    1114                 :            : 
    1115                 :            : /* Remove a command from the list used by the aacraid and dpt_i2o drivers */
    1116                 :      23739 : void scsi_del_cmd_from_list(struct scsi_cmnd *cmd)
    1117                 :            : {
    1118                 :      23739 :         struct scsi_device *sdev = cmd->device;
    1119                 :      23739 :         struct Scsi_Host *shost = sdev->host;
    1120                 :      23739 :         unsigned long flags;
    1121                 :            : 
    1122         [ -  + ]:      23739 :         if (shost->use_cmd_list) {
    1123                 :          0 :                 spin_lock_irqsave(&sdev->list_lock, flags);
    1124         [ #  # ]:          0 :                 BUG_ON(list_empty(&cmd->list));
    1125                 :          0 :                 list_del_init(&cmd->list);
    1126                 :          0 :                 spin_unlock_irqrestore(&sdev->list_lock, flags);
    1127                 :            :         }
    1128                 :      23739 : }
    1129                 :            : 
    1130                 :            : /* Called after a request has been started. */
    1131                 :      23739 : void scsi_init_command(struct scsi_device *dev, struct scsi_cmnd *cmd)
    1132                 :            : {
    1133                 :      23739 :         void *buf = cmd->sense_buffer;
    1134                 :      23739 :         void *prot = cmd->prot_sdb;
    1135         [ +  + ]:      23739 :         struct request *rq = blk_mq_rq_from_pdu(cmd);
    1136                 :      23739 :         unsigned int flags = cmd->flags & SCMD_PRESERVED_FLAGS;
    1137                 :      23739 :         unsigned long jiffies_at_alloc;
    1138                 :      23739 :         int retries;
    1139                 :      23739 :         bool in_flight;
    1140                 :            : 
    1141   [ +  +  +  - ]:      23739 :         if (!blk_rq_is_scsi(rq) && !(flags & SCMD_INITIALIZED)) {
    1142                 :      20904 :                 flags |= SCMD_INITIALIZED;
    1143                 :      20904 :                 scsi_initialize_rq(rq);
    1144                 :            :         }
    1145                 :            : 
    1146                 :      23739 :         jiffies_at_alloc = cmd->jiffies_at_alloc;
    1147                 :      23739 :         retries = cmd->retries;
    1148                 :      23739 :         in_flight = test_bit(SCMD_STATE_INFLIGHT, &cmd->state);
    1149                 :            :         /* zero out the cmd, except for the embedded scsi_request */
    1150                 :      23739 :         memset((char *)cmd + sizeof(cmd->req), 0,
    1151                 :      23739 :                 sizeof(*cmd) - sizeof(cmd->req) + dev->host->hostt->cmd_size);
    1152                 :            : 
    1153                 :      23739 :         cmd->device = dev;
    1154                 :      23739 :         cmd->sense_buffer = buf;
    1155                 :      23739 :         cmd->prot_sdb = prot;
    1156                 :      23739 :         cmd->flags = flags;
    1157                 :      23739 :         INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler);
    1158                 :      23739 :         cmd->jiffies_at_alloc = jiffies_at_alloc;
    1159                 :      23739 :         cmd->retries = retries;
    1160         [ +  - ]:      23739 :         if (in_flight)
    1161                 :      23739 :                 __set_bit(SCMD_STATE_INFLIGHT, &cmd->state);
    1162                 :            : 
    1163                 :      23739 :         scsi_add_cmd_to_list(cmd);
    1164                 :      23739 : }
    1165                 :            : 
    1166                 :            : static blk_status_t scsi_setup_scsi_cmnd(struct scsi_device *sdev,
    1167                 :            :                 struct request *req)
    1168                 :            : {
    1169                 :            :         struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
    1170                 :            : 
    1171                 :            :         /*
    1172                 :            :          * Passthrough requests may transfer data, in which case they must
    1173                 :            :          * a bio attached to them.  Or they might contain a SCSI command
    1174                 :            :          * that does not transfer data, in which case they may optionally
    1175                 :            :          * submit a request without an attached bio.
    1176                 :            :          */
    1177                 :            :         if (req->bio) {
    1178                 :            :                 blk_status_t ret = scsi_init_io(cmd);
    1179                 :            :                 if (unlikely(ret != BLK_STS_OK))
    1180                 :            :                         return ret;
    1181                 :            :         } else {
    1182                 :            :                 BUG_ON(blk_rq_bytes(req));
    1183                 :            : 
    1184                 :            :                 memset(&cmd->sdb, 0, sizeof(cmd->sdb));
    1185                 :            :         }
    1186                 :            : 
    1187                 :            :         cmd->cmd_len = scsi_req(req)->cmd_len;
    1188                 :            :         cmd->cmnd = scsi_req(req)->cmd;
    1189                 :            :         cmd->transfersize = blk_rq_bytes(req);
    1190                 :            :         cmd->allowed = scsi_req(req)->retries;
    1191                 :            :         return BLK_STS_OK;
    1192                 :            : }
    1193                 :            : 
    1194                 :            : /*
    1195                 :            :  * Setup a normal block command.  These are simple request from filesystems
    1196                 :            :  * that still need to be translated to SCSI CDBs from the ULD.
    1197                 :            :  */
    1198                 :      20904 : static blk_status_t scsi_setup_fs_cmnd(struct scsi_device *sdev,
    1199                 :            :                 struct request *req)
    1200                 :            : {
    1201         [ -  + ]:      20904 :         struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
    1202                 :            : 
    1203   [ -  +  -  - ]:      20904 :         if (unlikely(sdev->handler && sdev->handler->prep_fn)) {
    1204                 :          0 :                 blk_status_t ret = sdev->handler->prep_fn(sdev, req);
    1205         [ #  # ]:          0 :                 if (ret != BLK_STS_OK)
    1206                 :            :                         return ret;
    1207                 :            :         }
    1208                 :            : 
    1209                 :      20904 :         cmd->cmnd = scsi_req(req)->cmd = scsi_req(req)->__cmd;
    1210                 :      20904 :         memset(cmd->cmnd, 0, BLK_MAX_CDB);
    1211                 :      20904 :         return scsi_cmd_to_driver(cmd)->init_command(cmd);
    1212                 :            : }
    1213                 :            : 
    1214                 :      23739 : static blk_status_t scsi_setup_cmnd(struct scsi_device *sdev,
    1215                 :            :                 struct request *req)
    1216                 :            : {
    1217         [ +  + ]:      23739 :         struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
    1218                 :            : 
    1219         [ +  + ]:      23739 :         if (!blk_rq_bytes(req))
    1220                 :        699 :                 cmd->sc_data_direction = DMA_NONE;
    1221         [ +  + ]:      23040 :         else if (rq_data_dir(req) == WRITE)
    1222                 :        531 :                 cmd->sc_data_direction = DMA_TO_DEVICE;
    1223                 :            :         else
    1224                 :      22509 :                 cmd->sc_data_direction = DMA_FROM_DEVICE;
    1225                 :            : 
    1226         [ +  + ]:      23739 :         if (blk_rq_is_scsi(req))
    1227                 :       2835 :                 return scsi_setup_scsi_cmnd(sdev, req);
    1228                 :            :         else
    1229                 :      20904 :                 return scsi_setup_fs_cmnd(sdev, req);
    1230                 :            : }
    1231                 :            : 
    1232                 :            : static blk_status_t
    1233                 :        105 : scsi_prep_state_check(struct scsi_device *sdev, struct request *req)
    1234                 :            : {
    1235   [ -  -  -  +  :        105 :         switch (sdev->sdev_state) {
                      - ]
    1236                 :          0 :         case SDEV_OFFLINE:
    1237                 :            :         case SDEV_TRANSPORT_OFFLINE:
    1238                 :            :                 /*
    1239                 :            :                  * If the device is offline we refuse to process any
    1240                 :            :                  * commands.  The device must be brought online
    1241                 :            :                  * before trying any recovery commands.
    1242                 :            :                  */
    1243                 :          0 :                 sdev_printk(KERN_ERR, sdev,
    1244                 :            :                             "rejecting I/O to offline device\n");
    1245                 :          0 :                 return BLK_STS_IOERR;
    1246                 :          0 :         case SDEV_DEL:
    1247                 :            :                 /*
    1248                 :            :                  * If the device is fully deleted, we refuse to
    1249                 :            :                  * process any commands as well.
    1250                 :            :                  */
    1251                 :          0 :                 sdev_printk(KERN_ERR, sdev,
    1252                 :            :                             "rejecting I/O to dead device\n");
    1253                 :          0 :                 return BLK_STS_IOERR;
    1254                 :            :         case SDEV_BLOCK:
    1255                 :            :         case SDEV_CREATED_BLOCK:
    1256                 :            :                 return BLK_STS_RESOURCE;
    1257                 :          0 :         case SDEV_QUIESCE:
    1258                 :            :                 /*
    1259                 :            :                  * If the devices is blocked we defer normal commands.
    1260                 :            :                  */
    1261   [ #  #  #  # ]:          0 :                 if (req && !(req->rq_flags & RQF_PREEMPT))
    1262                 :          0 :                         return BLK_STS_RESOURCE;
    1263                 :            :                 return BLK_STS_OK;
    1264                 :        105 :         default:
    1265                 :            :                 /*
    1266                 :            :                  * For any other not fully online state we only allow
    1267                 :            :                  * special commands.  In particular any user initiated
    1268                 :            :                  * command is not allowed.
    1269                 :            :                  */
    1270   [ +  -  -  + ]:        105 :                 if (req && !(req->rq_flags & RQF_PREEMPT))
    1271                 :          0 :                         return BLK_STS_IOERR;
    1272                 :            :                 return BLK_STS_OK;
    1273                 :            :         }
    1274                 :            : }
    1275                 :            : 
    1276                 :            : /*
    1277                 :            :  * scsi_dev_queue_ready: if we can send requests to sdev, return 1 else
    1278                 :            :  * return 0.
    1279                 :            :  *
    1280                 :            :  * Called with the queue_lock held.
    1281                 :            :  */
    1282                 :            : static inline int scsi_dev_queue_ready(struct request_queue *q,
    1283                 :            :                                   struct scsi_device *sdev)
    1284                 :            : {
    1285                 :            :         unsigned int busy;
    1286                 :            : 
    1287                 :            :         busy = atomic_inc_return(&sdev->device_busy) - 1;
    1288                 :            :         if (atomic_read(&sdev->device_blocked)) {
    1289                 :            :                 if (busy)
    1290                 :            :                         goto out_dec;
    1291                 :            : 
    1292                 :            :                 /*
    1293                 :            :                  * unblock after device_blocked iterates to zero
    1294                 :            :                  */
    1295                 :            :                 if (atomic_dec_return(&sdev->device_blocked) > 0)
    1296                 :            :                         goto out_dec;
    1297                 :            :                 SCSI_LOG_MLQUEUE(3, sdev_printk(KERN_INFO, sdev,
    1298                 :            :                                    "unblocking device at zero depth\n"));
    1299                 :            :         }
    1300                 :            : 
    1301                 :            :         if (busy >= sdev->queue_depth)
    1302                 :            :                 goto out_dec;
    1303                 :            : 
    1304                 :            :         return 1;
    1305                 :            : out_dec:
    1306                 :            :         atomic_dec(&sdev->device_busy);
    1307                 :            :         return 0;
    1308                 :            : }
    1309                 :            : 
    1310                 :            : /*
    1311                 :            :  * scsi_target_queue_ready: checks if there we can send commands to target
    1312                 :            :  * @sdev: scsi device on starget to check.
    1313                 :            :  */
    1314                 :      23739 : static inline int scsi_target_queue_ready(struct Scsi_Host *shost,
    1315                 :            :                                            struct scsi_device *sdev)
    1316                 :            : {
    1317         [ -  + ]:      23739 :         struct scsi_target *starget = scsi_target(sdev);
    1318                 :      23739 :         unsigned int busy;
    1319                 :            : 
    1320         [ -  + ]:      23739 :         if (starget->single_lun) {
    1321                 :          0 :                 spin_lock_irq(shost->host_lock);
    1322   [ #  #  #  # ]:          0 :                 if (starget->starget_sdev_user &&
    1323                 :            :                     starget->starget_sdev_user != sdev) {
    1324                 :          0 :                         spin_unlock_irq(shost->host_lock);
    1325                 :          0 :                         return 0;
    1326                 :            :                 }
    1327                 :          0 :                 starget->starget_sdev_user = sdev;
    1328                 :          0 :                 spin_unlock_irq(shost->host_lock);
    1329                 :            :         }
    1330                 :            : 
    1331         [ -  + ]:      23739 :         if (starget->can_queue <= 0)
    1332                 :            :                 return 1;
    1333                 :            : 
    1334                 :          0 :         busy = atomic_inc_return(&starget->target_busy) - 1;
    1335         [ #  # ]:          0 :         if (atomic_read(&starget->target_blocked) > 0) {
    1336         [ #  # ]:          0 :                 if (busy)
    1337                 :          0 :                         goto starved;
    1338                 :            : 
    1339                 :            :                 /*
    1340                 :            :                  * unblock after target_blocked iterates to zero
    1341                 :            :                  */
    1342         [ #  # ]:          0 :                 if (atomic_dec_return(&starget->target_blocked) > 0)
    1343                 :          0 :                         goto out_dec;
    1344                 :            : 
    1345                 :          0 :                 SCSI_LOG_MLQUEUE(3, starget_printk(KERN_INFO, starget,
    1346                 :          0 :                                  "unblocking target at zero depth\n"));
    1347                 :            :         }
    1348                 :            : 
    1349         [ #  # ]:          0 :         if (busy >= starget->can_queue)
    1350                 :          0 :                 goto starved;
    1351                 :            : 
    1352                 :            :         return 1;
    1353                 :            : 
    1354                 :          0 : starved:
    1355                 :          0 :         spin_lock_irq(shost->host_lock);
    1356                 :          0 :         list_move_tail(&sdev->starved_entry, &shost->starved_list);
    1357                 :          0 :         spin_unlock_irq(shost->host_lock);
    1358                 :          0 : out_dec:
    1359         [ #  # ]:          0 :         if (starget->can_queue > 0)
    1360                 :          0 :                 atomic_dec(&starget->target_busy);
    1361                 :            :         return 0;
    1362                 :            : }
    1363                 :            : 
    1364                 :            : /*
    1365                 :            :  * scsi_host_queue_ready: if we can send requests to shost, return 1 else
    1366                 :            :  * return 0. We must end up running the queue again whenever 0 is
    1367                 :            :  * returned, else IO can hang.
    1368                 :            :  */
    1369                 :            : static inline int scsi_host_queue_ready(struct request_queue *q,
    1370                 :            :                                    struct Scsi_Host *shost,
    1371                 :            :                                    struct scsi_device *sdev,
    1372                 :            :                                    struct scsi_cmnd *cmd)
    1373                 :            : {
    1374                 :            :         if (scsi_host_in_recovery(shost))
    1375                 :            :                 return 0;
    1376                 :            : 
    1377                 :            :         if (atomic_read(&shost->host_blocked) > 0) {
    1378                 :            :                 if (scsi_host_busy(shost) > 0)
    1379                 :            :                         goto starved;
    1380                 :            : 
    1381                 :            :                 /*
    1382                 :            :                  * unblock after host_blocked iterates to zero
    1383                 :            :                  */
    1384                 :            :                 if (atomic_dec_return(&shost->host_blocked) > 0)
    1385                 :            :                         goto out_dec;
    1386                 :            : 
    1387                 :            :                 SCSI_LOG_MLQUEUE(3,
    1388                 :            :                         shost_printk(KERN_INFO, shost,
    1389                 :            :                                      "unblocking host at zero depth\n"));
    1390                 :            :         }
    1391                 :            : 
    1392                 :            :         if (shost->host_self_blocked)
    1393                 :            :                 goto starved;
    1394                 :            : 
    1395                 :            :         /* We're OK to process the command, so we can't be starved */
    1396                 :            :         if (!list_empty(&sdev->starved_entry)) {
    1397                 :            :                 spin_lock_irq(shost->host_lock);
    1398                 :            :                 if (!list_empty(&sdev->starved_entry))
    1399                 :            :                         list_del_init(&sdev->starved_entry);
    1400                 :            :                 spin_unlock_irq(shost->host_lock);
    1401                 :            :         }
    1402                 :            : 
    1403                 :            :         __set_bit(SCMD_STATE_INFLIGHT, &cmd->state);
    1404                 :            : 
    1405                 :            :         return 1;
    1406                 :            : 
    1407                 :            : starved:
    1408                 :            :         spin_lock_irq(shost->host_lock);
    1409                 :            :         if (list_empty(&sdev->starved_entry))
    1410                 :            :                 list_add_tail(&sdev->starved_entry, &shost->starved_list);
    1411                 :            :         spin_unlock_irq(shost->host_lock);
    1412                 :            : out_dec:
    1413                 :            :         scsi_dec_host_busy(shost, cmd);
    1414                 :            :         return 0;
    1415                 :            : }
    1416                 :            : 
    1417                 :            : /*
    1418                 :            :  * Busy state exporting function for request stacking drivers.
    1419                 :            :  *
    1420                 :            :  * For efficiency, no lock is taken to check the busy state of
    1421                 :            :  * shost/starget/sdev, since the returned value is not guaranteed and
    1422                 :            :  * may be changed after request stacking drivers call the function,
    1423                 :            :  * regardless of taking lock or not.
    1424                 :            :  *
    1425                 :            :  * When scsi can't dispatch I/Os anymore and needs to kill I/Os scsi
    1426                 :            :  * needs to return 'not busy'. Otherwise, request stacking drivers
    1427                 :            :  * may hold requests forever.
    1428                 :            :  */
    1429                 :          0 : static bool scsi_mq_lld_busy(struct request_queue *q)
    1430                 :            : {
    1431                 :          0 :         struct scsi_device *sdev = q->queuedata;
    1432                 :          0 :         struct Scsi_Host *shost;
    1433                 :            : 
    1434         [ #  # ]:          0 :         if (blk_queue_dying(q))
    1435                 :            :                 return false;
    1436                 :            : 
    1437                 :          0 :         shost = sdev->host;
    1438                 :            : 
    1439                 :            :         /*
    1440                 :            :          * Ignore host/starget busy state.
    1441                 :            :          * Since block layer does not have a concept of fairness across
    1442                 :            :          * multiple queues, congestion of host/starget needs to be handled
    1443                 :            :          * in SCSI layer.
    1444                 :            :          */
    1445   [ #  #  #  # ]:          0 :         if (scsi_host_in_recovery(shost) || scsi_device_is_busy(sdev))
    1446                 :          0 :                 return true;
    1447                 :            : 
    1448                 :            :         return false;
    1449                 :            : }
    1450                 :            : 
    1451                 :      23529 : static void scsi_softirq_done(struct request *rq)
    1452                 :            : {
    1453                 :      23529 :         struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
    1454                 :      23529 :         unsigned long wait_for = (cmd->allowed + 1) * rq->timeout;
    1455                 :      23529 :         int disposition;
    1456                 :            : 
    1457                 :      23529 :         INIT_LIST_HEAD(&cmd->eh_entry);
    1458                 :            : 
    1459                 :      23529 :         atomic_inc(&cmd->device->iodone_cnt);
    1460         [ +  + ]:      23529 :         if (cmd->result)
    1461                 :         63 :                 atomic_inc(&cmd->device->ioerr_cnt);
    1462                 :            : 
    1463                 :      23529 :         disposition = scsi_decide_disposition(cmd);
    1464         [ -  + ]:      23529 :         if (disposition != SUCCESS &&
    1465         [ #  # ]:          0 :             time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) {
    1466                 :          0 :                 scmd_printk(KERN_ERR, cmd,
    1467                 :            :                             "timing out command, waited %lus\n",
    1468                 :            :                             wait_for/HZ);
    1469                 :          0 :                 disposition = SUCCESS;
    1470                 :            :         }
    1471                 :            : 
    1472   [ +  -  -  - ]:      23529 :         scsi_log_completion(cmd, disposition);
    1473                 :            : 
    1474   [ +  -  -  - ]:      23529 :         switch (disposition) {
    1475                 :      23529 :                 case SUCCESS:
    1476                 :      23529 :                         scsi_finish_command(cmd);
    1477                 :      23529 :                         break;
    1478                 :            :                 case NEEDS_RETRY:
    1479                 :          0 :                         scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
    1480                 :            :                         break;
    1481                 :            :                 case ADD_TO_MLQUEUE:
    1482                 :          0 :                         scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
    1483                 :            :                         break;
    1484                 :          0 :                 default:
    1485                 :          0 :                         scsi_eh_scmd_add(cmd);
    1486                 :          0 :                         break;
    1487                 :            :         }
    1488                 :      23529 : }
    1489                 :            : 
    1490                 :            : /**
    1491                 :            :  * scsi_dispatch_command - Dispatch a command to the low-level driver.
    1492                 :            :  * @cmd: command block we are dispatching.
    1493                 :            :  *
    1494                 :            :  * Return: nonzero return request was rejected and device's queue needs to be
    1495                 :            :  * plugged.
    1496                 :            :  */
    1497                 :      23739 : static int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
    1498                 :            : {
    1499                 :      23739 :         struct Scsi_Host *host = cmd->device->host;
    1500                 :      23739 :         int rtn = 0;
    1501                 :            : 
    1502                 :      23739 :         atomic_inc(&cmd->device->iorequest_cnt);
    1503                 :            : 
    1504                 :            :         /* check if the device is still usable */
    1505         [ -  + ]:      23739 :         if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
    1506                 :            :                 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
    1507                 :            :                  * returns an immediate error upwards, and signals
    1508                 :            :                  * that the device is no longer present */
    1509                 :          0 :                 cmd->result = DID_NO_CONNECT << 16;
    1510                 :          0 :                 goto done;
    1511                 :            :         }
    1512                 :            : 
    1513                 :            :         /* Check to see if the scsi lld made this device blocked. */
    1514         [ +  - ]:      23739 :         if (unlikely(scsi_device_blocked(cmd->device))) {
    1515                 :            :                 /*
    1516                 :            :                  * in blocked state, the command is just put back on
    1517                 :            :                  * the device queue.  The suspend state has already
    1518                 :            :                  * blocked the queue so future requests should not
    1519                 :            :                  * occur until the device transitions out of the
    1520                 :            :                  * suspend state.
    1521                 :            :                  */
    1522                 :            :                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
    1523                 :            :                         "queuecommand : device blocked\n"));
    1524                 :            :                 return SCSI_MLQUEUE_DEVICE_BUSY;
    1525                 :            :         }
    1526                 :            : 
    1527                 :            :         /* Store the LUN value in cmnd, if needed. */
    1528         [ +  + ]:      23739 :         if (cmd->device->lun_in_cdb)
    1529                 :        105 :                 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
    1530                 :        105 :                                (cmd->device->lun << 5 & 0xe0);
    1531                 :            : 
    1532         [ -  + ]:      23739 :         scsi_log_send(cmd);
    1533                 :            : 
    1534                 :            :         /*
    1535                 :            :          * Before we queue this command, check if the command
    1536                 :            :          * length exceeds what the host adapter can handle.
    1537                 :            :          */
    1538         [ -  + ]:      23739 :         if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
    1539                 :          0 :                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
    1540                 :            :                                "queuecommand : command too long. "
    1541                 :            :                                "cdb_size=%d host->max_cmd_len=%d\n",
    1542                 :          0 :                                cmd->cmd_len, cmd->device->host->max_cmd_len));
    1543                 :          0 :                 cmd->result = (DID_ABORT << 16);
    1544                 :          0 :                 goto done;
    1545                 :            :         }
    1546                 :            : 
    1547         [ -  + ]:      23739 :         if (unlikely(host->shost_state == SHOST_DEL)) {
    1548                 :          0 :                 cmd->result = (DID_NO_CONNECT << 16);
    1549                 :          0 :                 goto done;
    1550                 :            : 
    1551                 :            :         }
    1552                 :            : 
    1553                 :      23739 :         trace_scsi_dispatch_cmd_start(cmd);
    1554                 :      23739 :         rtn = host->hostt->queuecommand(host, cmd);
    1555         [ -  + ]:      23739 :         if (rtn) {
    1556                 :          0 :                 trace_scsi_dispatch_cmd_error(cmd, rtn);
    1557                 :          0 :                 if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
    1558         [ #  # ]:          0 :                     rtn != SCSI_MLQUEUE_TARGET_BUSY)
    1559                 :          0 :                         rtn = SCSI_MLQUEUE_HOST_BUSY;
    1560                 :            : 
    1561                 :            :                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
    1562                 :            :                         "queuecommand : request rejected\n"));
    1563                 :            :         }
    1564                 :            : 
    1565                 :            :         return rtn;
    1566                 :          0 :  done:
    1567                 :          0 :         cmd->scsi_done(cmd);
    1568                 :          0 :         return 0;
    1569                 :            : }
    1570                 :            : 
    1571                 :            : /* Size in bytes of the sg-list stored in the scsi-mq command-private data. */
    1572                 :         42 : static unsigned int scsi_mq_inline_sgl_size(struct Scsi_Host *shost)
    1573                 :            : {
    1574                 :         42 :         return min_t(unsigned int, shost->sg_tablesize, SCSI_INLINE_SG_CNT) *
    1575                 :            :                 sizeof(struct scatterlist);
    1576                 :            : }
    1577                 :            : 
    1578                 :      23739 : static blk_status_t scsi_mq_prep_fn(struct request *req)
    1579                 :            : {
    1580                 :      23739 :         struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
    1581                 :      23739 :         struct scsi_device *sdev = req->q->queuedata;
    1582                 :      23739 :         struct Scsi_Host *shost = sdev->host;
    1583                 :      23739 :         struct scatterlist *sg;
    1584                 :            : 
    1585                 :      23739 :         scsi_init_command(sdev, cmd);
    1586                 :            : 
    1587                 :      23739 :         cmd->request = req;
    1588                 :      23739 :         cmd->tag = req->tag;
    1589                 :      23739 :         cmd->prot_op = SCSI_PROT_NORMAL;
    1590                 :            : 
    1591                 :      23739 :         sg = (void *)cmd + sizeof(struct scsi_cmnd) + shost->hostt->cmd_size;
    1592                 :      23739 :         cmd->sdb.table.sgl = sg;
    1593                 :            : 
    1594         [ -  + ]:      23739 :         if (scsi_host_get_prot(shost)) {
    1595                 :          0 :                 memset(cmd->prot_sdb, 0, sizeof(struct scsi_data_buffer));
    1596                 :            : 
    1597                 :          0 :                 cmd->prot_sdb->table.sgl =
    1598                 :          0 :                         (struct scatterlist *)(cmd->prot_sdb + 1);
    1599                 :            :         }
    1600                 :            : 
    1601                 :      23739 :         blk_mq_start_request(req);
    1602                 :            : 
    1603                 :      23739 :         return scsi_setup_cmnd(sdev, req);
    1604                 :            : }
    1605                 :            : 
    1606                 :      23529 : static void scsi_mq_done(struct scsi_cmnd *cmd)
    1607                 :            : {
    1608         [ +  - ]:      23529 :         if (unlikely(test_and_set_bit(SCMD_STATE_COMPLETE, &cmd->state)))
    1609                 :            :                 return;
    1610                 :      23529 :         trace_scsi_dispatch_cmd_done(cmd);
    1611                 :            : 
    1612                 :            :         /*
    1613                 :            :          * If the block layer didn't complete the request due to a timeout
    1614                 :            :          * injection, scsi must clear its internal completed state so that the
    1615                 :            :          * timeout handler will see it needs to escalate its own error
    1616                 :            :          * recovery.
    1617                 :            :          */
    1618         [ -  + ]:      23529 :         if (unlikely(!blk_mq_complete_request(cmd->request)))
    1619                 :          0 :                 clear_bit(SCMD_STATE_COMPLETE, &cmd->state);
    1620                 :            : }
    1621                 :            : 
    1622                 :        988 : static void scsi_mq_put_budget(struct blk_mq_hw_ctx *hctx)
    1623                 :            : {
    1624                 :        988 :         struct request_queue *q = hctx->queue;
    1625                 :        988 :         struct scsi_device *sdev = q->queuedata;
    1626                 :            : 
    1627                 :        988 :         atomic_dec(&sdev->device_busy);
    1628                 :        988 : }
    1629                 :            : 
    1630                 :      26267 : static bool scsi_mq_get_budget(struct blk_mq_hw_ctx *hctx)
    1631                 :            : {
    1632                 :      26267 :         struct request_queue *q = hctx->queue;
    1633                 :      26267 :         struct scsi_device *sdev = q->queuedata;
    1634                 :            : 
    1635         [ +  + ]:      26267 :         if (scsi_dev_queue_ready(q, sdev))
    1636                 :            :                 return true;
    1637                 :            : 
    1638   [ +  +  +  - ]:       1540 :         if (atomic_read(&sdev->device_busy) == 0 && !scsi_device_blocked(sdev))
    1639                 :          1 :                 blk_mq_delay_run_hw_queue(hctx, SCSI_QUEUE_DELAY);
    1640                 :            :         return false;
    1641                 :            : }
    1642                 :            : 
    1643                 :      23739 : static blk_status_t scsi_queue_rq(struct blk_mq_hw_ctx *hctx,
    1644                 :            :                          const struct blk_mq_queue_data *bd)
    1645                 :            : {
    1646                 :      23739 :         struct request *req = bd->rq;
    1647                 :      23739 :         struct request_queue *q = req->q;
    1648                 :      23739 :         struct scsi_device *sdev = q->queuedata;
    1649                 :      23739 :         struct Scsi_Host *shost = sdev->host;
    1650         [ +  + ]:      23739 :         struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
    1651                 :      23739 :         blk_status_t ret;
    1652                 :      23739 :         int reason;
    1653                 :            : 
    1654                 :            :         /*
    1655                 :            :          * If the device is not in running state we will reject some or all
    1656                 :            :          * commands.
    1657                 :            :          */
    1658         [ +  + ]:      23739 :         if (unlikely(sdev->sdev_state != SDEV_RUNNING)) {
    1659                 :        105 :                 ret = scsi_prep_state_check(sdev, req);
    1660         [ -  + ]:        105 :                 if (ret != BLK_STS_OK)
    1661                 :          0 :                         goto out_put_budget;
    1662                 :            :         }
    1663                 :            : 
    1664                 :      23739 :         ret = BLK_STS_RESOURCE;
    1665         [ -  + ]:      23739 :         if (!scsi_target_queue_ready(shost, sdev))
    1666                 :          0 :                 goto out_put_budget;
    1667         [ -  + ]:      23739 :         if (!scsi_host_queue_ready(q, shost, sdev, cmd))
    1668                 :          0 :                 goto out_dec_target_busy;
    1669                 :            : 
    1670         [ +  - ]:      23739 :         if (!(req->rq_flags & RQF_DONTPREP)) {
    1671                 :      23739 :                 ret = scsi_mq_prep_fn(req);
    1672         [ -  + ]:      23739 :                 if (ret != BLK_STS_OK)
    1673                 :          0 :                         goto out_dec_host_busy;
    1674                 :      23739 :                 req->rq_flags |= RQF_DONTPREP;
    1675                 :            :         } else {
    1676                 :          0 :                 clear_bit(SCMD_STATE_COMPLETE, &cmd->state);
    1677                 :          0 :                 blk_mq_start_request(req);
    1678                 :            :         }
    1679                 :            : 
    1680                 :      23739 :         cmd->flags &= SCMD_PRESERVED_FLAGS;
    1681         [ +  + ]:      23739 :         if (sdev->simple_tags)
    1682                 :      23004 :                 cmd->flags |= SCMD_TAGGED;
    1683         [ +  - ]:      23739 :         if (bd->last)
    1684                 :      23739 :                 cmd->flags |= SCMD_LAST;
    1685                 :            : 
    1686                 :      23739 :         scsi_init_cmd_errh(cmd);
    1687                 :      23739 :         cmd->scsi_done = scsi_mq_done;
    1688                 :            : 
    1689                 :      23739 :         reason = scsi_dispatch_cmd(cmd);
    1690         [ -  + ]:      23739 :         if (reason) {
    1691                 :          0 :                 scsi_set_blocked(cmd, reason);
    1692                 :          0 :                 ret = BLK_STS_RESOURCE;
    1693                 :          0 :                 goto out_dec_host_busy;
    1694                 :            :         }
    1695                 :            : 
    1696                 :            :         return BLK_STS_OK;
    1697                 :            : 
    1698                 :          0 : out_dec_host_busy:
    1699                 :          0 :         scsi_dec_host_busy(shost, cmd);
    1700                 :          0 : out_dec_target_busy:
    1701         [ #  # ]:          0 :         if (scsi_target(sdev)->can_queue > 0)
    1702                 :          0 :                 atomic_dec(&scsi_target(sdev)->target_busy);
    1703                 :          0 : out_put_budget:
    1704                 :          0 :         scsi_mq_put_budget(hctx);
    1705      [ #  #  # ]:          0 :         switch (ret) {
    1706                 :            :         case BLK_STS_OK:
    1707                 :            :                 break;
    1708                 :          0 :         case BLK_STS_RESOURCE:
    1709   [ #  #  #  # ]:          0 :                 if (atomic_read(&sdev->device_busy) ||
    1710         [ #  # ]:          0 :                     scsi_device_blocked(sdev))
    1711                 :            :                         ret = BLK_STS_DEV_RESOURCE;
    1712                 :            :                 break;
    1713                 :          0 :         default:
    1714         [ #  # ]:          0 :                 if (unlikely(!scsi_device_online(sdev)))
    1715                 :          0 :                         scsi_req(req)->result = DID_NO_CONNECT << 16;
    1716                 :            :                 else
    1717                 :          0 :                         scsi_req(req)->result = DID_ERROR << 16;
    1718                 :            :                 /*
    1719                 :            :                  * Make sure to release all allocated resources when
    1720                 :            :                  * we hit an error, as we will never see this command
    1721                 :            :                  * again.
    1722                 :            :                  */
    1723         [ #  # ]:          0 :                 if (req->rq_flags & RQF_DONTPREP)
    1724                 :          0 :                         scsi_mq_uninit_cmd(cmd);
    1725                 :            :                 break;
    1726                 :            :         }
    1727                 :            :         return ret;
    1728                 :            : }
    1729                 :            : 
    1730                 :        210 : static enum blk_eh_timer_return scsi_timeout(struct request *req,
    1731                 :            :                 bool reserved)
    1732                 :            : {
    1733         [ +  - ]:        210 :         if (reserved)
    1734                 :            :                 return BLK_EH_RESET_TIMER;
    1735                 :        210 :         return scsi_times_out(req);
    1736                 :            : }
    1737                 :            : 
    1738                 :        231 : static int scsi_mq_init_request(struct blk_mq_tag_set *set, struct request *rq,
    1739                 :            :                                 unsigned int hctx_idx, unsigned int numa_node)
    1740                 :            : {
    1741                 :        231 :         struct Scsi_Host *shost = set->driver_data;
    1742                 :        231 :         const bool unchecked_isa_dma = shost->unchecked_isa_dma;
    1743         [ -  + ]:        231 :         struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
    1744                 :        231 :         struct scatterlist *sg;
    1745                 :            : 
    1746         [ -  + ]:        231 :         if (unchecked_isa_dma)
    1747                 :          0 :                 cmd->flags |= SCMD_UNCHECKED_ISA_DMA;
    1748         [ -  + ]:        231 :         cmd->sense_buffer = scsi_alloc_sense_buffer(unchecked_isa_dma,
    1749                 :            :                                                     GFP_KERNEL, numa_node);
    1750         [ +  - ]:        231 :         if (!cmd->sense_buffer)
    1751                 :            :                 return -ENOMEM;
    1752                 :        231 :         cmd->req.sense = cmd->sense_buffer;
    1753                 :            : 
    1754         [ -  + ]:        231 :         if (scsi_host_get_prot(shost)) {
    1755                 :          0 :                 sg = (void *)cmd + sizeof(struct scsi_cmnd) +
    1756                 :          0 :                         shost->hostt->cmd_size;
    1757                 :          0 :                 cmd->prot_sdb = (void *)sg + scsi_mq_inline_sgl_size(shost);
    1758                 :            :         }
    1759                 :            : 
    1760                 :            :         return 0;
    1761                 :            : }
    1762                 :            : 
    1763                 :          0 : static void scsi_mq_exit_request(struct blk_mq_tag_set *set, struct request *rq,
    1764                 :            :                                  unsigned int hctx_idx)
    1765                 :            : {
    1766         [ #  # ]:          0 :         struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
    1767                 :            : 
    1768         [ #  # ]:          0 :         scsi_free_sense_buffer(cmd->flags & SCMD_UNCHECKED_ISA_DMA,
    1769                 :            :                                cmd->sense_buffer);
    1770                 :          0 : }
    1771                 :            : 
    1772                 :         42 : static int scsi_map_queues(struct blk_mq_tag_set *set)
    1773                 :            : {
    1774                 :         42 :         struct Scsi_Host *shost = container_of(set, struct Scsi_Host, tag_set);
    1775                 :            : 
    1776         [ -  + ]:         42 :         if (shost->hostt->map_queues)
    1777                 :          0 :                 return shost->hostt->map_queues(shost);
    1778                 :         42 :         return blk_mq_map_queues(&set->map[HCTX_TYPE_DEFAULT]);
    1779                 :            : }
    1780                 :            : 
    1781                 :         63 : void __scsi_init_queue(struct Scsi_Host *shost, struct request_queue *q)
    1782                 :            : {
    1783                 :         63 :         struct device *dev = shost->dma_dev;
    1784                 :            : 
    1785                 :            :         /*
    1786                 :            :          * this limit is imposed by hardware restrictions
    1787                 :            :          */
    1788                 :         63 :         blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize,
    1789                 :            :                                         SG_MAX_SEGMENTS));
    1790                 :            : 
    1791         [ -  + ]:         63 :         if (scsi_host_prot_dma(shost)) {
    1792                 :          0 :                 shost->sg_prot_tablesize =
    1793         [ #  # ]:          0 :                         min_not_zero(shost->sg_prot_tablesize,
    1794                 :            :                                      (unsigned short)SCSI_MAX_PROT_SG_SEGMENTS);
    1795         [ #  # ]:          0 :                 BUG_ON(shost->sg_prot_tablesize < shost->sg_tablesize);
    1796                 :            :                 blk_queue_max_integrity_segments(q, shost->sg_prot_tablesize);
    1797                 :            :         }
    1798                 :            : 
    1799         [ +  - ]:         63 :         if (dev->dma_mask) {
    1800                 :         63 :                 shost->max_sectors = min_t(unsigned int, shost->max_sectors,
    1801                 :            :                                 dma_max_mapping_size(dev) >> SECTOR_SHIFT);
    1802                 :            :         }
    1803                 :         63 :         blk_queue_max_hw_sectors(q, shost->max_sectors);
    1804         [ -  + ]:         63 :         if (shost->unchecked_isa_dma)
    1805                 :          0 :                 blk_queue_bounce_limit(q, BLK_BOUNCE_ISA);
    1806                 :         63 :         blk_queue_segment_boundary(q, shost->dma_boundary);
    1807         [ +  - ]:         63 :         dma_set_seg_boundary(dev, shost->dma_boundary);
    1808                 :            : 
    1809                 :         63 :         blk_queue_max_segment_size(q, shost->max_segment_size);
    1810                 :         63 :         blk_queue_virt_boundary(q, shost->virt_boundary_mask);
    1811         [ +  - ]:         63 :         dma_set_max_seg_size(dev, queue_max_segment_size(q));
    1812                 :            : 
    1813                 :            :         /*
    1814                 :            :          * Set a reasonable default alignment:  The larger of 32-byte (dword),
    1815                 :            :          * which is a common minimum for HBAs, and the minimum DMA alignment,
    1816                 :            :          * which is set by the platform.
    1817                 :            :          *
    1818                 :            :          * Devices that require a bigger alignment can increase it later.
    1819                 :            :          */
    1820                 :         63 :         blk_queue_dma_alignment(q, max(4, dma_get_cache_alignment()) - 1);
    1821                 :         63 : }
    1822                 :            : EXPORT_SYMBOL_GPL(__scsi_init_queue);
    1823                 :            : 
    1824                 :            : static const struct blk_mq_ops scsi_mq_ops_no_commit = {
    1825                 :            :         .get_budget     = scsi_mq_get_budget,
    1826                 :            :         .put_budget     = scsi_mq_put_budget,
    1827                 :            :         .queue_rq       = scsi_queue_rq,
    1828                 :            :         .complete       = scsi_softirq_done,
    1829                 :            :         .timeout        = scsi_timeout,
    1830                 :            : #ifdef CONFIG_BLK_DEBUG_FS
    1831                 :            :         .show_rq        = scsi_show_rq,
    1832                 :            : #endif
    1833                 :            :         .init_request   = scsi_mq_init_request,
    1834                 :            :         .exit_request   = scsi_mq_exit_request,
    1835                 :            :         .initialize_rq_fn = scsi_initialize_rq,
    1836                 :            :         .cleanup_rq     = scsi_cleanup_rq,
    1837                 :            :         .busy           = scsi_mq_lld_busy,
    1838                 :            :         .map_queues     = scsi_map_queues,
    1839                 :            : };
    1840                 :            : 
    1841                 :            : 
    1842                 :          0 : static void scsi_commit_rqs(struct blk_mq_hw_ctx *hctx)
    1843                 :            : {
    1844                 :          0 :         struct request_queue *q = hctx->queue;
    1845                 :          0 :         struct scsi_device *sdev = q->queuedata;
    1846                 :          0 :         struct Scsi_Host *shost = sdev->host;
    1847                 :            : 
    1848                 :          0 :         shost->hostt->commit_rqs(shost, hctx->queue_num);
    1849                 :          0 : }
    1850                 :            : 
    1851                 :            : static const struct blk_mq_ops scsi_mq_ops = {
    1852                 :            :         .get_budget     = scsi_mq_get_budget,
    1853                 :            :         .put_budget     = scsi_mq_put_budget,
    1854                 :            :         .queue_rq       = scsi_queue_rq,
    1855                 :            :         .commit_rqs     = scsi_commit_rqs,
    1856                 :            :         .complete       = scsi_softirq_done,
    1857                 :            :         .timeout        = scsi_timeout,
    1858                 :            : #ifdef CONFIG_BLK_DEBUG_FS
    1859                 :            :         .show_rq        = scsi_show_rq,
    1860                 :            : #endif
    1861                 :            :         .init_request   = scsi_mq_init_request,
    1862                 :            :         .exit_request   = scsi_mq_exit_request,
    1863                 :            :         .initialize_rq_fn = scsi_initialize_rq,
    1864                 :            :         .cleanup_rq     = scsi_cleanup_rq,
    1865                 :            :         .busy           = scsi_mq_lld_busy,
    1866                 :            :         .map_queues     = scsi_map_queues,
    1867                 :            : };
    1868                 :            : 
    1869                 :         63 : struct request_queue *scsi_mq_alloc_queue(struct scsi_device *sdev)
    1870                 :            : {
    1871                 :         63 :         sdev->request_queue = blk_mq_init_queue(&sdev->host->tag_set);
    1872         [ +  - ]:         63 :         if (IS_ERR(sdev->request_queue))
    1873                 :            :                 return NULL;
    1874                 :            : 
    1875                 :         63 :         sdev->request_queue->queuedata = sdev;
    1876                 :         63 :         __scsi_init_queue(sdev->host, sdev->request_queue);
    1877                 :         63 :         blk_queue_flag_set(QUEUE_FLAG_SCSI_PASSTHROUGH, sdev->request_queue);
    1878                 :         63 :         return sdev->request_queue;
    1879                 :            : }
    1880                 :            : 
    1881                 :         42 : int scsi_mq_setup_tags(struct Scsi_Host *shost)
    1882                 :            : {
    1883                 :         42 :         unsigned int cmd_size, sgl_size;
    1884                 :            : 
    1885                 :         42 :         sgl_size = max_t(unsigned int, sizeof(struct scatterlist),
    1886                 :            :                                 scsi_mq_inline_sgl_size(shost));
    1887                 :         42 :         cmd_size = sizeof(struct scsi_cmnd) + shost->hostt->cmd_size + sgl_size;
    1888         [ -  + ]:         42 :         if (scsi_host_get_prot(shost))
    1889                 :          0 :                 cmd_size += sizeof(struct scsi_data_buffer) +
    1890                 :            :                         sizeof(struct scatterlist) * SCSI_INLINE_PROT_SG_CNT;
    1891                 :            : 
    1892                 :         42 :         memset(&shost->tag_set, 0, sizeof(shost->tag_set));
    1893         [ -  + ]:         42 :         if (shost->hostt->commit_rqs)
    1894                 :          0 :                 shost->tag_set.ops = &scsi_mq_ops;
    1895                 :            :         else
    1896                 :         42 :                 shost->tag_set.ops = &scsi_mq_ops_no_commit;
    1897                 :         42 :         shost->tag_set.nr_hw_queues = shost->nr_hw_queues ? : 1;
    1898                 :         42 :         shost->tag_set.queue_depth = shost->can_queue;
    1899                 :         42 :         shost->tag_set.cmd_size = cmd_size;
    1900                 :         42 :         shost->tag_set.numa_node = NUMA_NO_NODE;
    1901                 :         42 :         shost->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
    1902                 :         42 :         shost->tag_set.flags |=
    1903                 :         42 :                 BLK_ALLOC_POLICY_TO_MQ_FLAG(shost->hostt->tag_alloc_policy);
    1904                 :         42 :         shost->tag_set.driver_data = shost;
    1905                 :            : 
    1906                 :         42 :         return blk_mq_alloc_tag_set(&shost->tag_set);
    1907                 :            : }
    1908                 :            : 
    1909                 :          0 : void scsi_mq_destroy_tags(struct Scsi_Host *shost)
    1910                 :            : {
    1911                 :          0 :         blk_mq_free_tag_set(&shost->tag_set);
    1912                 :          0 : }
    1913                 :            : 
    1914                 :            : /**
    1915                 :            :  * scsi_device_from_queue - return sdev associated with a request_queue
    1916                 :            :  * @q: The request queue to return the sdev from
    1917                 :            :  *
    1918                 :            :  * Return the sdev associated with a request queue or NULL if the
    1919                 :            :  * request_queue does not reference a SCSI device.
    1920                 :            :  */
    1921                 :          0 : struct scsi_device *scsi_device_from_queue(struct request_queue *q)
    1922                 :            : {
    1923                 :          0 :         struct scsi_device *sdev = NULL;
    1924                 :            : 
    1925   [ #  #  #  # ]:          0 :         if (q->mq_ops == &scsi_mq_ops_no_commit ||
    1926                 :            :             q->mq_ops == &scsi_mq_ops)
    1927                 :          0 :                 sdev = q->queuedata;
    1928   [ #  #  #  # ]:          0 :         if (!sdev || !get_device(&sdev->sdev_gendev))
    1929                 :            :                 sdev = NULL;
    1930                 :            : 
    1931                 :          0 :         return sdev;
    1932                 :            : }
    1933                 :            : EXPORT_SYMBOL_GPL(scsi_device_from_queue);
    1934                 :            : 
    1935                 :            : /*
    1936                 :            :  * Function:    scsi_block_requests()
    1937                 :            :  *
    1938                 :            :  * Purpose:     Utility function used by low-level drivers to prevent further
    1939                 :            :  *              commands from being queued to the device.
    1940                 :            :  *
    1941                 :            :  * Arguments:   shost       - Host in question
    1942                 :            :  *
    1943                 :            :  * Returns:     Nothing
    1944                 :            :  *
    1945                 :            :  * Lock status: No locks are assumed held.
    1946                 :            :  *
    1947                 :            :  * Notes:       There is no timer nor any other means by which the requests
    1948                 :            :  *              get unblocked other than the low-level driver calling
    1949                 :            :  *              scsi_unblock_requests().
    1950                 :            :  */
    1951                 :          0 : void scsi_block_requests(struct Scsi_Host *shost)
    1952                 :            : {
    1953                 :          0 :         shost->host_self_blocked = 1;
    1954                 :          0 : }
    1955                 :            : EXPORT_SYMBOL(scsi_block_requests);
    1956                 :            : 
    1957                 :            : /*
    1958                 :            :  * Function:    scsi_unblock_requests()
    1959                 :            :  *
    1960                 :            :  * Purpose:     Utility function used by low-level drivers to allow further
    1961                 :            :  *              commands from being queued to the device.
    1962                 :            :  *
    1963                 :            :  * Arguments:   shost       - Host in question
    1964                 :            :  *
    1965                 :            :  * Returns:     Nothing
    1966                 :            :  *
    1967                 :            :  * Lock status: No locks are assumed held.
    1968                 :            :  *
    1969                 :            :  * Notes:       There is no timer nor any other means by which the requests
    1970                 :            :  *              get unblocked other than the low-level driver calling
    1971                 :            :  *              scsi_unblock_requests().
    1972                 :            :  *
    1973                 :            :  *              This is done as an API function so that changes to the
    1974                 :            :  *              internals of the scsi mid-layer won't require wholesale
    1975                 :            :  *              changes to drivers that use this feature.
    1976                 :            :  */
    1977                 :          0 : void scsi_unblock_requests(struct Scsi_Host *shost)
    1978                 :            : {
    1979                 :          0 :         shost->host_self_blocked = 0;
    1980                 :          0 :         scsi_run_host_queues(shost);
    1981                 :          0 : }
    1982                 :            : EXPORT_SYMBOL(scsi_unblock_requests);
    1983                 :            : 
    1984                 :         21 : int __init scsi_init_queue(void)
    1985                 :            : {
    1986                 :         21 :         scsi_sdb_cache = kmem_cache_create("scsi_data_buffer",
    1987                 :            :                                            sizeof(struct scsi_data_buffer),
    1988                 :            :                                            0, 0, NULL);
    1989         [ -  + ]:         21 :         if (!scsi_sdb_cache) {
    1990                 :          0 :                 printk(KERN_ERR "SCSI: can't init scsi sdb cache\n");
    1991                 :          0 :                 return -ENOMEM;
    1992                 :            :         }
    1993                 :            : 
    1994                 :            :         return 0;
    1995                 :            : }
    1996                 :            : 
    1997                 :          0 : void scsi_exit_queue(void)
    1998                 :            : {
    1999                 :          0 :         kmem_cache_destroy(scsi_sense_cache);
    2000                 :          0 :         kmem_cache_destroy(scsi_sense_isadma_cache);
    2001                 :          0 :         kmem_cache_destroy(scsi_sdb_cache);
    2002                 :          0 : }
    2003                 :            : 
    2004                 :            : /**
    2005                 :            :  *      scsi_mode_select - issue a mode select
    2006                 :            :  *      @sdev:  SCSI device to be queried
    2007                 :            :  *      @pf:    Page format bit (1 == standard, 0 == vendor specific)
    2008                 :            :  *      @sp:    Save page bit (0 == don't save, 1 == save)
    2009                 :            :  *      @modepage: mode page being requested
    2010                 :            :  *      @buffer: request buffer (may not be smaller than eight bytes)
    2011                 :            :  *      @len:   length of request buffer.
    2012                 :            :  *      @timeout: command timeout
    2013                 :            :  *      @retries: number of retries before failing
    2014                 :            :  *      @data: returns a structure abstracting the mode header data
    2015                 :            :  *      @sshdr: place to put sense data (or NULL if no sense to be collected).
    2016                 :            :  *              must be SCSI_SENSE_BUFFERSIZE big.
    2017                 :            :  *
    2018                 :            :  *      Returns zero if successful; negative error number or scsi
    2019                 :            :  *      status on error
    2020                 :            :  *
    2021                 :            :  */
    2022                 :            : int
    2023                 :          0 : scsi_mode_select(struct scsi_device *sdev, int pf, int sp, int modepage,
    2024                 :            :                  unsigned char *buffer, int len, int timeout, int retries,
    2025                 :            :                  struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr)
    2026                 :            : {
    2027                 :          0 :         unsigned char cmd[10];
    2028                 :          0 :         unsigned char *real_buffer;
    2029                 :          0 :         int ret;
    2030                 :            : 
    2031                 :          0 :         memset(cmd, 0, sizeof(cmd));
    2032         [ #  # ]:          0 :         cmd[1] = (pf ? 0x10 : 0) | (sp ? 0x01 : 0);
    2033                 :            : 
    2034         [ #  # ]:          0 :         if (sdev->use_10_for_ms) {
    2035         [ #  # ]:          0 :                 if (len > 65535)
    2036                 :            :                         return -EINVAL;
    2037         [ #  # ]:          0 :                 real_buffer = kmalloc(8 + len, GFP_KERNEL);
    2038         [ #  # ]:          0 :                 if (!real_buffer)
    2039                 :            :                         return -ENOMEM;
    2040                 :          0 :                 memcpy(real_buffer + 8, buffer, len);
    2041                 :          0 :                 len += 8;
    2042                 :          0 :                 real_buffer[0] = 0;
    2043                 :          0 :                 real_buffer[1] = 0;
    2044                 :          0 :                 real_buffer[2] = data->medium_type;
    2045                 :          0 :                 real_buffer[3] = data->device_specific;
    2046                 :          0 :                 real_buffer[4] = data->longlba ? 0x01 : 0;
    2047                 :          0 :                 real_buffer[5] = 0;
    2048                 :          0 :                 real_buffer[6] = data->block_descriptor_length >> 8;
    2049                 :          0 :                 real_buffer[7] = data->block_descriptor_length;
    2050                 :            : 
    2051                 :          0 :                 cmd[0] = MODE_SELECT_10;
    2052                 :          0 :                 cmd[7] = len >> 8;
    2053                 :          0 :                 cmd[8] = len;
    2054                 :            :         } else {
    2055   [ #  #  #  #  :          0 :                 if (len > 255 || data->block_descriptor_length > 255 ||
                   #  # ]
    2056                 :            :                     data->longlba)
    2057                 :            :                         return -EINVAL;
    2058                 :            : 
    2059         [ #  # ]:          0 :                 real_buffer = kmalloc(4 + len, GFP_KERNEL);
    2060         [ #  # ]:          0 :                 if (!real_buffer)
    2061                 :            :                         return -ENOMEM;
    2062                 :          0 :                 memcpy(real_buffer + 4, buffer, len);
    2063                 :          0 :                 len += 4;
    2064                 :          0 :                 real_buffer[0] = 0;
    2065                 :          0 :                 real_buffer[1] = data->medium_type;
    2066                 :          0 :                 real_buffer[2] = data->device_specific;
    2067                 :          0 :                 real_buffer[3] = data->block_descriptor_length;
    2068                 :            :                 
    2069                 :            : 
    2070                 :          0 :                 cmd[0] = MODE_SELECT;
    2071                 :          0 :                 cmd[4] = len;
    2072                 :            :         }
    2073                 :            : 
    2074                 :          0 :         ret = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, real_buffer, len,
    2075                 :            :                                sshdr, timeout, retries, NULL);
    2076                 :          0 :         kfree(real_buffer);
    2077                 :          0 :         return ret;
    2078                 :            : }
    2079                 :            : EXPORT_SYMBOL_GPL(scsi_mode_select);
    2080                 :            : 
    2081                 :            : /**
    2082                 :            :  *      scsi_mode_sense - issue a mode sense, falling back from 10 to six bytes if necessary.
    2083                 :            :  *      @sdev:  SCSI device to be queried
    2084                 :            :  *      @dbd:   set if mode sense will allow block descriptors to be returned
    2085                 :            :  *      @modepage: mode page being requested
    2086                 :            :  *      @buffer: request buffer (may not be smaller than eight bytes)
    2087                 :            :  *      @len:   length of request buffer.
    2088                 :            :  *      @timeout: command timeout
    2089                 :            :  *      @retries: number of retries before failing
    2090                 :            :  *      @data: returns a structure abstracting the mode header data
    2091                 :            :  *      @sshdr: place to put sense data (or NULL if no sense to be collected).
    2092                 :            :  *              must be SCSI_SENSE_BUFFERSIZE big.
    2093                 :            :  *
    2094                 :            :  *      Returns zero if unsuccessful, or the header offset (either 4
    2095                 :            :  *      or 8 depending on whether a six or ten byte command was
    2096                 :            :  *      issued) if successful.
    2097                 :            :  */
    2098                 :            : int
    2099                 :        399 : scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
    2100                 :            :                   unsigned char *buffer, int len, int timeout, int retries,
    2101                 :            :                   struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr)
    2102                 :            : {
    2103                 :        399 :         unsigned char cmd[12];
    2104                 :        399 :         int use_10_for_ms;
    2105                 :        399 :         int header_length;
    2106                 :        399 :         int result, retry_count = retries;
    2107                 :        399 :         struct scsi_sense_hdr my_sshdr;
    2108                 :            : 
    2109                 :        399 :         memset(data, 0, sizeof(*data));
    2110                 :        399 :         memset(&cmd[0], 0, 12);
    2111                 :            : 
    2112         [ -  + ]:        399 :         dbd = sdev->set_dbd_for_ms ? 8 : dbd;
    2113                 :        399 :         cmd[1] = dbd & 0x18;        /* allows DBD and LLBA bits */
    2114                 :        399 :         cmd[2] = modepage;
    2115                 :            : 
    2116                 :            :         /* caller might not be interested in sense, but we need it */
    2117         [ +  + ]:        399 :         if (!sshdr)
    2118                 :        147 :                 sshdr = &my_sshdr;
    2119                 :            : 
    2120                 :        399 :  retry:
    2121                 :        399 :         use_10_for_ms = sdev->use_10_for_ms;
    2122                 :            : 
    2123         [ +  - ]:        399 :         if (use_10_for_ms) {
    2124                 :        399 :                 if (len < 8)
    2125                 :            :                         len = 8;
    2126                 :            : 
    2127                 :        399 :                 cmd[0] = MODE_SENSE_10;
    2128                 :        399 :                 cmd[8] = len;
    2129                 :        399 :                 header_length = 8;
    2130                 :            :         } else {
    2131                 :          0 :                 if (len < 4)
    2132                 :            :                         len = 4;
    2133                 :            : 
    2134                 :          0 :                 cmd[0] = MODE_SENSE;
    2135                 :          0 :                 cmd[4] = len;
    2136                 :          0 :                 header_length = 4;
    2137                 :            :         }
    2138                 :            : 
    2139                 :        399 :         memset(buffer, 0, len);
    2140                 :            : 
    2141                 :        399 :         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
    2142                 :            :                                   sshdr, timeout, retries, NULL);
    2143                 :            : 
    2144                 :            :         /* This code looks awful: what it's doing is making sure an
    2145                 :            :          * ILLEGAL REQUEST sense return identifies the actual command
    2146                 :            :          * byte as the problem.  MODE_SENSE commands can return
    2147                 :            :          * ILLEGAL REQUEST if the code page isn't supported */
    2148                 :            : 
    2149         [ +  - ]:        399 :         if (use_10_for_ms && !scsi_status_is_good(result) &&
    2150         [ #  # ]:          0 :             driver_byte(result) == DRIVER_SENSE) {
    2151   [ #  #  #  # ]:          0 :                 if (scsi_sense_valid(sshdr)) {
    2152         [ #  # ]:          0 :                         if ((sshdr->sense_key == ILLEGAL_REQUEST) &&
    2153   [ #  #  #  # ]:          0 :                             (sshdr->asc == 0x20) && (sshdr->ascq == 0)) {
    2154                 :            :                                 /* 
    2155                 :            :                                  * Invalid command operation code
    2156                 :            :                                  */
    2157                 :          0 :                                 sdev->use_10_for_ms = 0;
    2158                 :          0 :                                 goto retry;
    2159                 :            :                         }
    2160                 :            :                 }
    2161                 :            :         }
    2162                 :            : 
    2163         [ -  + ]:        399 :         if(scsi_status_is_good(result)) {
    2164   [ -  +  -  -  :        399 :                 if (unlikely(buffer[0] == 0x86 && buffer[1] == 0x0b &&
                   -  - ]
    2165                 :            :                              (modepage == 6 || modepage == 8))) {
    2166                 :            :                         /* Initio breakage? */
    2167                 :          0 :                         header_length = 0;
    2168                 :          0 :                         data->length = 13;
    2169                 :          0 :                         data->medium_type = 0;
    2170                 :          0 :                         data->device_specific = 0;
    2171                 :          0 :                         data->longlba = 0;
    2172                 :          0 :                         data->block_descriptor_length = 0;
    2173         [ +  - ]:        399 :                 } else if(use_10_for_ms) {
    2174                 :        399 :                         data->length = buffer[0]*256 + buffer[1] + 2;
    2175                 :        399 :                         data->medium_type = buffer[2];
    2176                 :        399 :                         data->device_specific = buffer[3];
    2177                 :        399 :                         data->longlba = buffer[4] & 0x01;
    2178                 :        399 :                         data->block_descriptor_length = buffer[6]*256
    2179                 :        399 :                                 + buffer[7];
    2180                 :            :                 } else {
    2181                 :          0 :                         data->length = buffer[0] + 1;
    2182                 :          0 :                         data->medium_type = buffer[1];
    2183                 :          0 :                         data->device_specific = buffer[2];
    2184                 :          0 :                         data->block_descriptor_length = buffer[3];
    2185                 :            :                 }
    2186                 :        399 :                 data->header_length = header_length;
    2187   [ #  #  #  # ]:          0 :         } else if ((status_byte(result) == CHECK_CONDITION) &&
    2188                 :          0 :                    scsi_sense_valid(sshdr) &&
    2189   [ #  #  #  # ]:          0 :                    sshdr->sense_key == UNIT_ATTENTION && retry_count) {
    2190                 :          0 :                 retry_count--;
    2191                 :          0 :                 goto retry;
    2192                 :            :         }
    2193                 :            : 
    2194                 :        399 :         return result;
    2195                 :            : }
    2196                 :            : EXPORT_SYMBOL(scsi_mode_sense);
    2197                 :            : 
    2198                 :            : /**
    2199                 :            :  *      scsi_test_unit_ready - test if unit is ready
    2200                 :            :  *      @sdev:  scsi device to change the state of.
    2201                 :            :  *      @timeout: command timeout
    2202                 :            :  *      @retries: number of retries before failing
    2203                 :            :  *      @sshdr: outpout pointer for decoded sense information.
    2204                 :            :  *
    2205                 :            :  *      Returns zero if unsuccessful or an error if TUR failed.  For
    2206                 :            :  *      removable media, UNIT_ATTENTION sets ->changed flag.
    2207                 :            :  **/
    2208                 :            : int
    2209                 :        210 : scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries,
    2210                 :            :                      struct scsi_sense_hdr *sshdr)
    2211                 :            : {
    2212                 :        210 :         char cmd[] = {
    2213                 :            :                 TEST_UNIT_READY, 0, 0, 0, 0, 0,
    2214                 :            :         };
    2215                 :        210 :         int result;
    2216                 :            : 
    2217                 :            :         /* try to eat the UNIT_ATTENTION if there are enough retries */
    2218                 :        210 :         do {
    2219                 :        210 :                 result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0, sshdr,
    2220                 :            :                                           timeout, 1, NULL);
    2221   [ +  -  +  - ]:        420 :                 if (sdev->removable && scsi_sense_valid(sshdr) &&
    2222         [ -  + ]:        210 :                     sshdr->sense_key == UNIT_ATTENTION)
    2223                 :          0 :                         sdev->changed = 1;
    2224         [ +  - ]:        210 :         } while (scsi_sense_valid(sshdr) &&
    2225   [ +  -  -  +  :        210 :                  sshdr->sense_key == UNIT_ATTENTION && --retries);
                   -  - ]
    2226                 :            : 
    2227                 :        210 :         return result;
    2228                 :            : }
    2229                 :            : EXPORT_SYMBOL(scsi_test_unit_ready);
    2230                 :            : 
    2231                 :            : /**
    2232                 :            :  *      scsi_device_set_state - Take the given device through the device state model.
    2233                 :            :  *      @sdev:  scsi device to change the state of.
    2234                 :            :  *      @state: state to change to.
    2235                 :            :  *
    2236                 :            :  *      Returns zero if successful or an error if the requested
    2237                 :            :  *      transition is illegal.
    2238                 :            :  */
    2239                 :            : int
    2240                 :         63 : scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state)
    2241                 :            : {
    2242                 :         63 :         enum scsi_device_state oldstate = sdev->sdev_state;
    2243                 :            : 
    2244         [ +  - ]:         63 :         if (state == oldstate)
    2245                 :            :                 return 0;
    2246                 :            : 
    2247   [ -  +  -  -  :         63 :         switch (state) {
             -  -  -  -  
                      - ]
    2248                 :          0 :         case SDEV_CREATED:
    2249         [ #  # ]:          0 :                 switch (oldstate) {
    2250                 :            :                 case SDEV_CREATED_BLOCK:
    2251                 :            :                         break;
    2252                 :          0 :                 default:
    2253                 :          0 :                         goto illegal;
    2254                 :            :                 }
    2255                 :            :                 break;
    2256                 :            :                         
    2257                 :         63 :         case SDEV_RUNNING:
    2258         [ -  + ]:         63 :                 switch (oldstate) {
    2259                 :            :                 case SDEV_CREATED:
    2260                 :            :                 case SDEV_OFFLINE:
    2261                 :            :                 case SDEV_TRANSPORT_OFFLINE:
    2262                 :            :                 case SDEV_QUIESCE:
    2263                 :            :                 case SDEV_BLOCK:
    2264                 :            :                         break;
    2265                 :          0 :                 default:
    2266                 :          0 :                         goto illegal;
    2267                 :            :                 }
    2268                 :            :                 break;
    2269                 :            : 
    2270                 :          0 :         case SDEV_QUIESCE:
    2271   [ #  #  #  # ]:          0 :                 switch (oldstate) {
    2272                 :            :                 case SDEV_RUNNING:
    2273                 :            :                 case SDEV_OFFLINE:
    2274                 :            :                 case SDEV_TRANSPORT_OFFLINE:
    2275                 :            :                         break;
    2276                 :          0 :                 default:
    2277                 :          0 :                         goto illegal;
    2278                 :            :                 }
    2279                 :            :                 break;
    2280                 :            : 
    2281                 :          0 :         case SDEV_OFFLINE:
    2282                 :            :         case SDEV_TRANSPORT_OFFLINE:
    2283         [ #  # ]:          0 :                 switch (oldstate) {
    2284                 :            :                 case SDEV_CREATED:
    2285                 :            :                 case SDEV_RUNNING:
    2286                 :            :                 case SDEV_QUIESCE:
    2287                 :            :                 case SDEV_BLOCK:
    2288                 :            :                         break;
    2289                 :          0 :                 default:
    2290                 :          0 :                         goto illegal;
    2291                 :            :                 }
    2292                 :            :                 break;
    2293                 :            : 
    2294                 :          0 :         case SDEV_BLOCK:
    2295   [ #  #  #  # ]:          0 :                 switch (oldstate) {
    2296                 :            :                 case SDEV_RUNNING:
    2297                 :            :                 case SDEV_CREATED_BLOCK:
    2298                 :            :                 case SDEV_OFFLINE:
    2299                 :            :                         break;
    2300                 :          0 :                 default:
    2301                 :          0 :                         goto illegal;
    2302                 :            :                 }
    2303                 :            :                 break;
    2304                 :            : 
    2305                 :          0 :         case SDEV_CREATED_BLOCK:
    2306   [ #  #  #  # ]:          0 :                 switch (oldstate) {
    2307                 :            :                 case SDEV_CREATED:
    2308                 :            :                         break;
    2309                 :          0 :                 default:
    2310                 :          0 :                         goto illegal;
    2311                 :            :                 }
    2312                 :            :                 break;
    2313                 :            : 
    2314                 :          0 :         case SDEV_CANCEL:
    2315         [ #  # ]:          0 :                 switch (oldstate) {
    2316                 :            :                 case SDEV_CREATED:
    2317                 :            :                 case SDEV_RUNNING:
    2318                 :            :                 case SDEV_QUIESCE:
    2319                 :            :                 case SDEV_OFFLINE:
    2320                 :            :                 case SDEV_TRANSPORT_OFFLINE:
    2321                 :            :                         break;
    2322                 :          0 :                 default:
    2323                 :          0 :                         goto illegal;
    2324                 :            :                 }
    2325                 :            :                 break;
    2326                 :            : 
    2327                 :          0 :         case SDEV_DEL:
    2328         [ #  # ]:          0 :                 switch (oldstate) {
    2329                 :            :                 case SDEV_CREATED:
    2330                 :            :                 case SDEV_RUNNING:
    2331                 :            :                 case SDEV_OFFLINE:
    2332                 :            :                 case SDEV_TRANSPORT_OFFLINE:
    2333                 :            :                 case SDEV_CANCEL:
    2334                 :            :                 case SDEV_BLOCK:
    2335                 :            :                 case SDEV_CREATED_BLOCK:
    2336                 :            :                         break;
    2337                 :          0 :                 default:
    2338                 :          0 :                         goto illegal;
    2339                 :            :                 }
    2340                 :            :                 break;
    2341                 :            : 
    2342                 :            :         }
    2343                 :         63 :         sdev->sdev_state = state;
    2344                 :         63 :         return 0;
    2345                 :            : 
    2346                 :         63 :  illegal:
    2347                 :            :         SCSI_LOG_ERROR_RECOVERY(1,
    2348                 :            :                                 sdev_printk(KERN_ERR, sdev,
    2349                 :            :                                             "Illegal state transition %s->%s",
    2350                 :            :                                             scsi_device_state_name(oldstate),
    2351                 :            :                                             scsi_device_state_name(state))
    2352                 :            :                                 );
    2353                 :            :         return -EINVAL;
    2354                 :            : }
    2355                 :            : EXPORT_SYMBOL(scsi_device_set_state);
    2356                 :            : 
    2357                 :            : /**
    2358                 :            :  *      sdev_evt_emit - emit a single SCSI device uevent
    2359                 :            :  *      @sdev: associated SCSI device
    2360                 :            :  *      @evt: event to emit
    2361                 :            :  *
    2362                 :            :  *      Send a single uevent (scsi_event) to the associated scsi_device.
    2363                 :            :  */
    2364                 :            : static void scsi_evt_emit(struct scsi_device *sdev, struct scsi_event *evt)
    2365                 :            : {
    2366                 :            :         int idx = 0;
    2367                 :            :         char *envp[3];
    2368                 :            : 
    2369                 :            :         switch (evt->evt_type) {
    2370                 :            :         case SDEV_EVT_MEDIA_CHANGE:
    2371                 :            :                 envp[idx++] = "SDEV_MEDIA_CHANGE=1";
    2372                 :            :                 break;
    2373                 :            :         case SDEV_EVT_INQUIRY_CHANGE_REPORTED:
    2374                 :            :                 scsi_rescan_device(&sdev->sdev_gendev);
    2375                 :            :                 envp[idx++] = "SDEV_UA=INQUIRY_DATA_HAS_CHANGED";
    2376                 :            :                 break;
    2377                 :            :         case SDEV_EVT_CAPACITY_CHANGE_REPORTED:
    2378                 :            :                 envp[idx++] = "SDEV_UA=CAPACITY_DATA_HAS_CHANGED";
    2379                 :            :                 break;
    2380                 :            :         case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:
    2381                 :            :                envp[idx++] = "SDEV_UA=THIN_PROVISIONING_SOFT_THRESHOLD_REACHED";
    2382                 :            :                 break;
    2383                 :            :         case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:
    2384                 :            :                 envp[idx++] = "SDEV_UA=MODE_PARAMETERS_CHANGED";
    2385                 :            :                 break;
    2386                 :            :         case SDEV_EVT_LUN_CHANGE_REPORTED:
    2387                 :            :                 envp[idx++] = "SDEV_UA=REPORTED_LUNS_DATA_HAS_CHANGED";
    2388                 :            :                 break;
    2389                 :            :         case SDEV_EVT_ALUA_STATE_CHANGE_REPORTED:
    2390                 :            :                 envp[idx++] = "SDEV_UA=ASYMMETRIC_ACCESS_STATE_CHANGED";
    2391                 :            :                 break;
    2392                 :            :         case SDEV_EVT_POWER_ON_RESET_OCCURRED:
    2393                 :            :                 envp[idx++] = "SDEV_UA=POWER_ON_RESET_OCCURRED";
    2394                 :            :                 break;
    2395                 :            :         default:
    2396                 :            :                 /* do nothing */
    2397                 :            :                 break;
    2398                 :            :         }
    2399                 :            : 
    2400                 :            :         envp[idx++] = NULL;
    2401                 :            : 
    2402                 :            :         kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp);
    2403                 :            : }
    2404                 :            : 
    2405                 :            : /**
    2406                 :            :  *      sdev_evt_thread - send a uevent for each scsi event
    2407                 :            :  *      @work: work struct for scsi_device
    2408                 :            :  *
    2409                 :            :  *      Dispatch queued events to their associated scsi_device kobjects
    2410                 :            :  *      as uevents.
    2411                 :            :  */
    2412                 :          0 : void scsi_evt_thread(struct work_struct *work)
    2413                 :            : {
    2414                 :          0 :         struct scsi_device *sdev;
    2415                 :          0 :         enum scsi_device_event evt_type;
    2416                 :          0 :         LIST_HEAD(event_list);
    2417                 :            : 
    2418                 :          0 :         sdev = container_of(work, struct scsi_device, event_work);
    2419                 :            : 
    2420         [ #  # ]:          0 :         for (evt_type = SDEV_EVT_FIRST; evt_type <= SDEV_EVT_LAST; evt_type++)
    2421         [ #  # ]:          0 :                 if (test_and_clear_bit(evt_type, sdev->pending_events))
    2422                 :          0 :                         sdev_evt_send_simple(sdev, evt_type, GFP_KERNEL);
    2423                 :            : 
    2424                 :          0 :         while (1) {
    2425                 :          0 :                 struct scsi_event *evt;
    2426                 :          0 :                 struct list_head *this, *tmp;
    2427                 :          0 :                 unsigned long flags;
    2428                 :            : 
    2429                 :          0 :                 spin_lock_irqsave(&sdev->list_lock, flags);
    2430         [ #  # ]:          0 :                 list_splice_init(&sdev->event_list, &event_list);
    2431                 :          0 :                 spin_unlock_irqrestore(&sdev->list_lock, flags);
    2432                 :            : 
    2433         [ #  # ]:          0 :                 if (list_empty(&event_list))
    2434                 :            :                         break;
    2435                 :            : 
    2436         [ #  # ]:          0 :                 list_for_each_safe(this, tmp, &event_list) {
    2437                 :          0 :                         evt = list_entry(this, struct scsi_event, node);
    2438                 :          0 :                         list_del(&evt->node);
    2439                 :          0 :                         scsi_evt_emit(sdev, evt);
    2440                 :          0 :                         kfree(evt);
    2441                 :            :                 }
    2442                 :            :         }
    2443                 :          0 : }
    2444                 :            : 
    2445                 :            : /**
    2446                 :            :  *      sdev_evt_send - send asserted event to uevent thread
    2447                 :            :  *      @sdev: scsi_device event occurred on
    2448                 :            :  *      @evt: event to send
    2449                 :            :  *
    2450                 :            :  *      Assert scsi device event asynchronously.
    2451                 :            :  */
    2452                 :          0 : void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt)
    2453                 :            : {
    2454                 :          0 :         unsigned long flags;
    2455                 :            : 
    2456                 :            : #if 0
    2457                 :            :         /* FIXME: currently this check eliminates all media change events
    2458                 :            :          * for polled devices.  Need to update to discriminate between AN
    2459                 :            :          * and polled events */
    2460                 :            :         if (!test_bit(evt->evt_type, sdev->supported_events)) {
    2461                 :            :                 kfree(evt);
    2462                 :            :                 return;
    2463                 :            :         }
    2464                 :            : #endif
    2465                 :            : 
    2466                 :          0 :         spin_lock_irqsave(&sdev->list_lock, flags);
    2467                 :          0 :         list_add_tail(&evt->node, &sdev->event_list);
    2468                 :          0 :         schedule_work(&sdev->event_work);
    2469                 :          0 :         spin_unlock_irqrestore(&sdev->list_lock, flags);
    2470                 :          0 : }
    2471                 :            : EXPORT_SYMBOL_GPL(sdev_evt_send);
    2472                 :            : 
    2473                 :            : /**
    2474                 :            :  *      sdev_evt_alloc - allocate a new scsi event
    2475                 :            :  *      @evt_type: type of event to allocate
    2476                 :            :  *      @gfpflags: GFP flags for allocation
    2477                 :            :  *
    2478                 :            :  *      Allocates and returns a new scsi_event.
    2479                 :            :  */
    2480                 :          0 : struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
    2481                 :            :                                   gfp_t gfpflags)
    2482                 :            : {
    2483                 :          0 :         struct scsi_event *evt = kzalloc(sizeof(struct scsi_event), gfpflags);
    2484   [ #  #  #  # ]:          0 :         if (!evt)
    2485                 :            :                 return NULL;
    2486                 :            : 
    2487                 :          0 :         evt->evt_type = evt_type;
    2488                 :          0 :         INIT_LIST_HEAD(&evt->node);
    2489                 :            : 
    2490                 :            :         /* evt_type-specific initialization, if any */
    2491                 :          0 :         switch (evt_type) {
    2492                 :            :         case SDEV_EVT_MEDIA_CHANGE:
    2493                 :            :         case SDEV_EVT_INQUIRY_CHANGE_REPORTED:
    2494                 :            :         case SDEV_EVT_CAPACITY_CHANGE_REPORTED:
    2495                 :            :         case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:
    2496                 :            :         case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:
    2497                 :            :         case SDEV_EVT_LUN_CHANGE_REPORTED:
    2498                 :            :         case SDEV_EVT_ALUA_STATE_CHANGE_REPORTED:
    2499                 :            :         case SDEV_EVT_POWER_ON_RESET_OCCURRED:
    2500                 :            :         default:
    2501                 :            :                 /* do nothing */
    2502                 :          0 :                 break;
    2503                 :            :         }
    2504                 :            : 
    2505                 :          0 :         return evt;
    2506                 :            : }
    2507                 :            : EXPORT_SYMBOL_GPL(sdev_evt_alloc);
    2508                 :            : 
    2509                 :            : /**
    2510                 :            :  *      sdev_evt_send_simple - send asserted event to uevent thread
    2511                 :            :  *      @sdev: scsi_device event occurred on
    2512                 :            :  *      @evt_type: type of event to send
    2513                 :            :  *      @gfpflags: GFP flags for allocation
    2514                 :            :  *
    2515                 :            :  *      Assert scsi device event asynchronously, given an event type.
    2516                 :            :  */
    2517                 :          0 : void sdev_evt_send_simple(struct scsi_device *sdev,
    2518                 :            :                           enum scsi_device_event evt_type, gfp_t gfpflags)
    2519                 :            : {
    2520                 :          0 :         struct scsi_event *evt = sdev_evt_alloc(evt_type, gfpflags);
    2521                 :          0 :         if (!evt) {
    2522                 :          0 :                 sdev_printk(KERN_ERR, sdev, "event %d eaten due to OOM\n",
    2523                 :            :                             evt_type);
    2524                 :          0 :                 return;
    2525                 :            :         }
    2526                 :            : 
    2527                 :          0 :         sdev_evt_send(sdev, evt);
    2528                 :            : }
    2529                 :            : EXPORT_SYMBOL_GPL(sdev_evt_send_simple);
    2530                 :            : 
    2531                 :            : /**
    2532                 :            :  *      scsi_device_quiesce - Block user issued commands.
    2533                 :            :  *      @sdev:  scsi device to quiesce.
    2534                 :            :  *
    2535                 :            :  *      This works by trying to transition to the SDEV_QUIESCE state
    2536                 :            :  *      (which must be a legal transition).  When the device is in this
    2537                 :            :  *      state, only special requests will be accepted, all others will
    2538                 :            :  *      be deferred.  Since special requests may also be requeued requests,
    2539                 :            :  *      a successful return doesn't guarantee the device will be 
    2540                 :            :  *      totally quiescent.
    2541                 :            :  *
    2542                 :            :  *      Must be called with user context, may sleep.
    2543                 :            :  *
    2544                 :            :  *      Returns zero if unsuccessful or an error if not.
    2545                 :            :  */
    2546                 :            : int
    2547                 :          0 : scsi_device_quiesce(struct scsi_device *sdev)
    2548                 :            : {
    2549                 :          0 :         struct request_queue *q = sdev->request_queue;
    2550                 :          0 :         int err;
    2551                 :            : 
    2552                 :            :         /*
    2553                 :            :          * It is allowed to call scsi_device_quiesce() multiple times from
    2554                 :            :          * the same context but concurrent scsi_device_quiesce() calls are
    2555                 :            :          * not allowed.
    2556                 :            :          */
    2557   [ #  #  #  #  :          0 :         WARN_ON_ONCE(sdev->quiesced_by && sdev->quiesced_by != current);
                   #  # ]
    2558                 :            : 
    2559         [ #  # ]:          0 :         if (sdev->quiesced_by == current)
    2560                 :            :                 return 0;
    2561                 :            : 
    2562                 :          0 :         blk_set_pm_only(q);
    2563                 :            : 
    2564                 :          0 :         blk_mq_freeze_queue(q);
    2565                 :            :         /*
    2566                 :            :          * Ensure that the effect of blk_set_pm_only() will be visible
    2567                 :            :          * for percpu_ref_tryget() callers that occur after the queue
    2568                 :            :          * unfreeze even if the queue was already frozen before this function
    2569                 :            :          * was called. See also https://lwn.net/Articles/573497/.
    2570                 :            :          */
    2571                 :          0 :         synchronize_rcu();
    2572                 :          0 :         blk_mq_unfreeze_queue(q);
    2573                 :            : 
    2574                 :          0 :         mutex_lock(&sdev->state_mutex);
    2575         [ #  # ]:          0 :         err = scsi_device_set_state(sdev, SDEV_QUIESCE);
    2576                 :          0 :         if (err == 0)
    2577                 :          0 :                 sdev->quiesced_by = current;
    2578                 :            :         else
    2579                 :          0 :                 blk_clear_pm_only(q);
    2580                 :          0 :         mutex_unlock(&sdev->state_mutex);
    2581                 :            : 
    2582                 :          0 :         return err;
    2583                 :            : }
    2584                 :            : EXPORT_SYMBOL(scsi_device_quiesce);
    2585                 :            : 
    2586                 :            : /**
    2587                 :            :  *      scsi_device_resume - Restart user issued commands to a quiesced device.
    2588                 :            :  *      @sdev:  scsi device to resume.
    2589                 :            :  *
    2590                 :            :  *      Moves the device from quiesced back to running and restarts the
    2591                 :            :  *      queues.
    2592                 :            :  *
    2593                 :            :  *      Must be called with user context, may sleep.
    2594                 :            :  */
    2595                 :          0 : void scsi_device_resume(struct scsi_device *sdev)
    2596                 :            : {
    2597                 :            :         /* check if the device state was mutated prior to resume, and if
    2598                 :            :          * so assume the state is being managed elsewhere (for example
    2599                 :            :          * device deleted during suspend)
    2600                 :            :          */
    2601                 :          0 :         mutex_lock(&sdev->state_mutex);
    2602         [ #  # ]:          0 :         if (sdev->quiesced_by) {
    2603                 :          0 :                 sdev->quiesced_by = NULL;
    2604                 :          0 :                 blk_clear_pm_only(sdev->request_queue);
    2605                 :            :         }
    2606         [ #  # ]:          0 :         if (sdev->sdev_state == SDEV_QUIESCE)
    2607                 :          0 :                 scsi_device_set_state(sdev, SDEV_RUNNING);
    2608                 :          0 :         mutex_unlock(&sdev->state_mutex);
    2609                 :          0 : }
    2610                 :            : EXPORT_SYMBOL(scsi_device_resume);
    2611                 :            : 
    2612                 :            : static void
    2613                 :          0 : device_quiesce_fn(struct scsi_device *sdev, void *data)
    2614                 :            : {
    2615                 :          0 :         scsi_device_quiesce(sdev);
    2616                 :          0 : }
    2617                 :            : 
    2618                 :            : void
    2619                 :          0 : scsi_target_quiesce(struct scsi_target *starget)
    2620                 :            : {
    2621                 :          0 :         starget_for_each_device(starget, NULL, device_quiesce_fn);
    2622                 :          0 : }
    2623                 :            : EXPORT_SYMBOL(scsi_target_quiesce);
    2624                 :            : 
    2625                 :            : static void
    2626                 :          0 : device_resume_fn(struct scsi_device *sdev, void *data)
    2627                 :            : {
    2628                 :          0 :         scsi_device_resume(sdev);
    2629                 :          0 : }
    2630                 :            : 
    2631                 :            : void
    2632                 :          0 : scsi_target_resume(struct scsi_target *starget)
    2633                 :            : {
    2634                 :          0 :         starget_for_each_device(starget, NULL, device_resume_fn);
    2635                 :          0 : }
    2636                 :            : EXPORT_SYMBOL(scsi_target_resume);
    2637                 :            : 
    2638                 :            : /**
    2639                 :            :  * scsi_internal_device_block_nowait - try to transition to the SDEV_BLOCK state
    2640                 :            :  * @sdev: device to block
    2641                 :            :  *
    2642                 :            :  * Pause SCSI command processing on the specified device. Does not sleep.
    2643                 :            :  *
    2644                 :            :  * Returns zero if successful or a negative error code upon failure.
    2645                 :            :  *
    2646                 :            :  * Notes:
    2647                 :            :  * This routine transitions the device to the SDEV_BLOCK state (which must be
    2648                 :            :  * a legal transition). When the device is in this state, command processing
    2649                 :            :  * is paused until the device leaves the SDEV_BLOCK state. See also
    2650                 :            :  * scsi_internal_device_unblock_nowait().
    2651                 :            :  */
    2652                 :          0 : int scsi_internal_device_block_nowait(struct scsi_device *sdev)
    2653                 :            : {
    2654                 :          0 :         struct request_queue *q = sdev->request_queue;
    2655                 :          0 :         int err = 0;
    2656                 :            : 
    2657         [ #  # ]:          0 :         err = scsi_device_set_state(sdev, SDEV_BLOCK);
    2658                 :          0 :         if (err) {
    2659         [ #  # ]:          0 :                 err = scsi_device_set_state(sdev, SDEV_CREATED_BLOCK);
    2660                 :            : 
    2661                 :          0 :                 if (err)
    2662                 :          0 :                         return err;
    2663                 :            :         }
    2664                 :            : 
    2665                 :            :         /* 
    2666                 :            :          * The device has transitioned to SDEV_BLOCK.  Stop the
    2667                 :            :          * block layer from calling the midlayer with this device's
    2668                 :            :          * request queue. 
    2669                 :            :          */
    2670                 :          0 :         blk_mq_quiesce_queue_nowait(q);
    2671                 :          0 :         return 0;
    2672                 :            : }
    2673                 :            : EXPORT_SYMBOL_GPL(scsi_internal_device_block_nowait);
    2674                 :            : 
    2675                 :            : /**
    2676                 :            :  * scsi_internal_device_block - try to transition to the SDEV_BLOCK state
    2677                 :            :  * @sdev: device to block
    2678                 :            :  *
    2679                 :            :  * Pause SCSI command processing on the specified device and wait until all
    2680                 :            :  * ongoing scsi_request_fn() / scsi_queue_rq() calls have finished. May sleep.
    2681                 :            :  *
    2682                 :            :  * Returns zero if successful or a negative error code upon failure.
    2683                 :            :  *
    2684                 :            :  * Note:
    2685                 :            :  * This routine transitions the device to the SDEV_BLOCK state (which must be
    2686                 :            :  * a legal transition). When the device is in this state, command processing
    2687                 :            :  * is paused until the device leaves the SDEV_BLOCK state. See also
    2688                 :            :  * scsi_internal_device_unblock().
    2689                 :            :  */
    2690                 :          0 : static int scsi_internal_device_block(struct scsi_device *sdev)
    2691                 :            : {
    2692                 :          0 :         struct request_queue *q = sdev->request_queue;
    2693                 :          0 :         int err;
    2694                 :            : 
    2695                 :          0 :         mutex_lock(&sdev->state_mutex);
    2696                 :          0 :         err = scsi_internal_device_block_nowait(sdev);
    2697         [ #  # ]:          0 :         if (err == 0)
    2698                 :          0 :                 blk_mq_quiesce_queue(q);
    2699                 :          0 :         mutex_unlock(&sdev->state_mutex);
    2700                 :            : 
    2701                 :          0 :         return err;
    2702                 :            : }
    2703                 :            :  
    2704                 :          0 : void scsi_start_queue(struct scsi_device *sdev)
    2705                 :            : {
    2706                 :          0 :         struct request_queue *q = sdev->request_queue;
    2707                 :            : 
    2708                 :          0 :         blk_mq_unquiesce_queue(q);
    2709                 :          0 : }
    2710                 :            : 
    2711                 :            : /**
    2712                 :            :  * scsi_internal_device_unblock_nowait - resume a device after a block request
    2713                 :            :  * @sdev:       device to resume
    2714                 :            :  * @new_state:  state to set the device to after unblocking
    2715                 :            :  *
    2716                 :            :  * Restart the device queue for a previously suspended SCSI device. Does not
    2717                 :            :  * sleep.
    2718                 :            :  *
    2719                 :            :  * Returns zero if successful or a negative error code upon failure.
    2720                 :            :  *
    2721                 :            :  * Notes:
    2722                 :            :  * This routine transitions the device to the SDEV_RUNNING state or to one of
    2723                 :            :  * the offline states (which must be a legal transition) allowing the midlayer
    2724                 :            :  * to goose the queue for this device.
    2725                 :            :  */
    2726                 :          0 : int scsi_internal_device_unblock_nowait(struct scsi_device *sdev,
    2727                 :            :                                         enum scsi_device_state new_state)
    2728                 :            : {
    2729         [ #  # ]:          0 :         switch (new_state) {
    2730                 :            :         case SDEV_RUNNING:
    2731                 :            :         case SDEV_TRANSPORT_OFFLINE:
    2732                 :          0 :                 break;
    2733                 :            :         default:
    2734                 :            :                 return -EINVAL;
    2735                 :            :         }
    2736                 :            : 
    2737                 :            :         /*
    2738                 :            :          * Try to transition the scsi device to SDEV_RUNNING or one of the
    2739                 :            :          * offlined states and goose the device queue if successful.
    2740                 :            :          */
    2741   [ #  #  #  # ]:          0 :         switch (sdev->sdev_state) {
    2742                 :          0 :         case SDEV_BLOCK:
    2743                 :            :         case SDEV_TRANSPORT_OFFLINE:
    2744                 :          0 :                 sdev->sdev_state = new_state;
    2745                 :          0 :                 break;
    2746                 :          0 :         case SDEV_CREATED_BLOCK:
    2747         [ #  # ]:          0 :                 if (new_state == SDEV_TRANSPORT_OFFLINE ||
    2748                 :            :                     new_state == SDEV_OFFLINE)
    2749                 :          0 :                         sdev->sdev_state = new_state;
    2750                 :            :                 else
    2751                 :          0 :                         sdev->sdev_state = SDEV_CREATED;
    2752                 :            :                 break;
    2753                 :            :         case SDEV_CANCEL:
    2754                 :            :         case SDEV_OFFLINE:
    2755                 :            :                 break;
    2756                 :            :         default:
    2757                 :            :                 return -EINVAL;
    2758                 :            :         }
    2759                 :          0 :         scsi_start_queue(sdev);
    2760                 :            : 
    2761                 :          0 :         return 0;
    2762                 :            : }
    2763                 :            : EXPORT_SYMBOL_GPL(scsi_internal_device_unblock_nowait);
    2764                 :            : 
    2765                 :            : /**
    2766                 :            :  * scsi_internal_device_unblock - resume a device after a block request
    2767                 :            :  * @sdev:       device to resume
    2768                 :            :  * @new_state:  state to set the device to after unblocking
    2769                 :            :  *
    2770                 :            :  * Restart the device queue for a previously suspended SCSI device. May sleep.
    2771                 :            :  *
    2772                 :            :  * Returns zero if successful or a negative error code upon failure.
    2773                 :            :  *
    2774                 :            :  * Notes:
    2775                 :            :  * This routine transitions the device to the SDEV_RUNNING state or to one of
    2776                 :            :  * the offline states (which must be a legal transition) allowing the midlayer
    2777                 :            :  * to goose the queue for this device.
    2778                 :            :  */
    2779                 :          0 : static int scsi_internal_device_unblock(struct scsi_device *sdev,
    2780                 :            :                                         enum scsi_device_state new_state)
    2781                 :            : {
    2782                 :          0 :         int ret;
    2783                 :            : 
    2784                 :          0 :         mutex_lock(&sdev->state_mutex);
    2785                 :          0 :         ret = scsi_internal_device_unblock_nowait(sdev, new_state);
    2786                 :          0 :         mutex_unlock(&sdev->state_mutex);
    2787                 :            : 
    2788                 :          0 :         return ret;
    2789                 :            : }
    2790                 :            : 
    2791                 :            : static void
    2792                 :          0 : device_block(struct scsi_device *sdev, void *data)
    2793                 :            : {
    2794                 :          0 :         int ret;
    2795                 :            : 
    2796                 :          0 :         ret = scsi_internal_device_block(sdev);
    2797                 :            : 
    2798   [ #  #  #  #  :          0 :         WARN_ONCE(ret, "scsi_internal_device_block(%s) failed: ret = %d\n",
                   #  # ]
    2799                 :            :                   dev_name(&sdev->sdev_gendev), ret);
    2800                 :          0 : }
    2801                 :            : 
    2802                 :            : static int
    2803                 :          0 : target_block(struct device *dev, void *data)
    2804                 :            : {
    2805         [ #  # ]:          0 :         if (scsi_is_target_device(dev))
    2806                 :          0 :                 starget_for_each_device(to_scsi_target(dev), NULL,
    2807                 :            :                                         device_block);
    2808                 :          0 :         return 0;
    2809                 :            : }
    2810                 :            : 
    2811                 :            : void
    2812                 :          0 : scsi_target_block(struct device *dev)
    2813                 :            : {
    2814         [ #  # ]:          0 :         if (scsi_is_target_device(dev))
    2815                 :          0 :                 starget_for_each_device(to_scsi_target(dev), NULL,
    2816                 :            :                                         device_block);
    2817                 :            :         else
    2818                 :          0 :                 device_for_each_child(dev, NULL, target_block);
    2819                 :          0 : }
    2820                 :            : EXPORT_SYMBOL_GPL(scsi_target_block);
    2821                 :            : 
    2822                 :            : static void
    2823                 :          0 : device_unblock(struct scsi_device *sdev, void *data)
    2824                 :            : {
    2825                 :          0 :         scsi_internal_device_unblock(sdev, *(enum scsi_device_state *)data);
    2826                 :          0 : }
    2827                 :            : 
    2828                 :            : static int
    2829                 :          0 : target_unblock(struct device *dev, void *data)
    2830                 :            : {
    2831         [ #  # ]:          0 :         if (scsi_is_target_device(dev))
    2832                 :          0 :                 starget_for_each_device(to_scsi_target(dev), data,
    2833                 :            :                                         device_unblock);
    2834                 :          0 :         return 0;
    2835                 :            : }
    2836                 :            : 
    2837                 :            : void
    2838                 :          0 : scsi_target_unblock(struct device *dev, enum scsi_device_state new_state)
    2839                 :            : {
    2840         [ #  # ]:          0 :         if (scsi_is_target_device(dev))
    2841                 :          0 :                 starget_for_each_device(to_scsi_target(dev), &new_state,
    2842                 :            :                                         device_unblock);
    2843                 :            :         else
    2844                 :          0 :                 device_for_each_child(dev, &new_state, target_unblock);
    2845                 :          0 : }
    2846                 :            : EXPORT_SYMBOL_GPL(scsi_target_unblock);
    2847                 :            : 
    2848                 :            : /**
    2849                 :            :  * scsi_kmap_atomic_sg - find and atomically map an sg-elemnt
    2850                 :            :  * @sgl:        scatter-gather list
    2851                 :            :  * @sg_count:   number of segments in sg
    2852                 :            :  * @offset:     offset in bytes into sg, on return offset into the mapped area
    2853                 :            :  * @len:        bytes to map, on return number of bytes mapped
    2854                 :            :  *
    2855                 :            :  * Returns virtual address of the start of the mapped page
    2856                 :            :  */
    2857                 :          0 : void *scsi_kmap_atomic_sg(struct scatterlist *sgl, int sg_count,
    2858                 :            :                           size_t *offset, size_t *len)
    2859                 :            : {
    2860                 :          0 :         int i;
    2861                 :          0 :         size_t sg_len = 0, len_complete = 0;
    2862                 :          0 :         struct scatterlist *sg;
    2863                 :          0 :         struct page *page;
    2864                 :            : 
    2865         [ #  # ]:          0 :         WARN_ON(!irqs_disabled());
    2866                 :            : 
    2867         [ #  # ]:          0 :         for_each_sg(sgl, sg, sg_count, i) {
    2868                 :          0 :                 len_complete = sg_len; /* Complete sg-entries */
    2869                 :          0 :                 sg_len += sg->length;
    2870         [ #  # ]:          0 :                 if (sg_len > *offset)
    2871                 :            :                         break;
    2872                 :            :         }
    2873                 :            : 
    2874         [ #  # ]:          0 :         if (unlikely(i == sg_count)) {
    2875                 :          0 :                 printk(KERN_ERR "%s: Bytes in sg: %zu, requested offset %zu, "
    2876                 :            :                         "elements %d\n",
    2877                 :            :                        __func__, sg_len, *offset, sg_count);
    2878                 :          0 :                 WARN_ON(1);
    2879                 :          0 :                 return NULL;
    2880                 :            :         }
    2881                 :            : 
    2882                 :            :         /* Offset starting from the beginning of first page in this sg-entry */
    2883                 :          0 :         *offset = *offset - len_complete + sg->offset;
    2884                 :            : 
    2885                 :            :         /* Assumption: contiguous pages can be accessed as "page + i" */
    2886         [ #  # ]:          0 :         page = nth_page(sg_page(sg), (*offset >> PAGE_SHIFT));
    2887                 :          0 :         *offset &= ~PAGE_MASK;
    2888                 :            : 
    2889                 :            :         /* Bytes in this sg-entry from *offset to the end of the page */
    2890                 :          0 :         sg_len = PAGE_SIZE - *offset;
    2891         [ #  # ]:          0 :         if (*len > sg_len)
    2892                 :          0 :                 *len = sg_len;
    2893                 :            : 
    2894                 :          0 :         return kmap_atomic(page);
    2895                 :            : }
    2896                 :            : EXPORT_SYMBOL(scsi_kmap_atomic_sg);
    2897                 :            : 
    2898                 :            : /**
    2899                 :            :  * scsi_kunmap_atomic_sg - atomically unmap a virtual address, previously mapped with scsi_kmap_atomic_sg
    2900                 :            :  * @virt:       virtual address to be unmapped
    2901                 :            :  */
    2902                 :          0 : void scsi_kunmap_atomic_sg(void *virt)
    2903                 :            : {
    2904                 :          0 :         kunmap_atomic(virt);
    2905                 :          0 : }
    2906                 :            : EXPORT_SYMBOL(scsi_kunmap_atomic_sg);
    2907                 :            : 
    2908                 :          0 : void sdev_disable_disk_events(struct scsi_device *sdev)
    2909                 :            : {
    2910                 :          0 :         atomic_inc(&sdev->disk_events_disable_depth);
    2911                 :          0 : }
    2912                 :            : EXPORT_SYMBOL(sdev_disable_disk_events);
    2913                 :            : 
    2914                 :          0 : void sdev_enable_disk_events(struct scsi_device *sdev)
    2915                 :            : {
    2916   [ #  #  #  # ]:          0 :         if (WARN_ON_ONCE(atomic_read(&sdev->disk_events_disable_depth) <= 0))
    2917                 :            :                 return;
    2918                 :          0 :         atomic_dec(&sdev->disk_events_disable_depth);
    2919                 :            : }
    2920                 :            : EXPORT_SYMBOL(sdev_enable_disk_events);
    2921                 :            : 
    2922                 :            : /**
    2923                 :            :  * scsi_vpd_lun_id - return a unique device identification
    2924                 :            :  * @sdev: SCSI device
    2925                 :            :  * @id:   buffer for the identification
    2926                 :            :  * @id_len:  length of the buffer
    2927                 :            :  *
    2928                 :            :  * Copies a unique device identification into @id based
    2929                 :            :  * on the information in the VPD page 0x83 of the device.
    2930                 :            :  * The string will be formatted as a SCSI name string.
    2931                 :            :  *
    2932                 :            :  * Returns the length of the identification or error on failure.
    2933                 :            :  * If the identifier is longer than the supplied buffer the actual
    2934                 :            :  * identifier length is returned and the buffer is not zero-padded.
    2935                 :            :  */
    2936                 :          0 : int scsi_vpd_lun_id(struct scsi_device *sdev, char *id, size_t id_len)
    2937                 :            : {
    2938                 :          0 :         u8 cur_id_type = 0xff;
    2939                 :          0 :         u8 cur_id_size = 0;
    2940                 :          0 :         const unsigned char *d, *cur_id_str;
    2941                 :          0 :         const struct scsi_vpd *vpd_pg83;
    2942                 :          0 :         int id_size = -EINVAL;
    2943                 :            : 
    2944                 :          0 :         rcu_read_lock();
    2945         [ #  # ]:          0 :         vpd_pg83 = rcu_dereference(sdev->vpd_pg83);
    2946         [ #  # ]:          0 :         if (!vpd_pg83) {
    2947                 :          0 :                 rcu_read_unlock();
    2948                 :          0 :                 return -ENXIO;
    2949                 :            :         }
    2950                 :            : 
    2951                 :            :         /*
    2952                 :            :          * Look for the correct descriptor.
    2953                 :            :          * Order of preference for lun descriptor:
    2954                 :            :          * - SCSI name string
    2955                 :            :          * - NAA IEEE Registered Extended
    2956                 :            :          * - EUI-64 based 16-byte
    2957                 :            :          * - EUI-64 based 12-byte
    2958                 :            :          * - NAA IEEE Registered
    2959                 :            :          * - NAA IEEE Extended
    2960                 :            :          * - T10 Vendor ID
    2961                 :            :          * as longer descriptors reduce the likelyhood
    2962                 :            :          * of identification clashes.
    2963                 :            :          */
    2964                 :            : 
    2965                 :            :         /* The id string must be at least 20 bytes + terminating NULL byte */
    2966         [ #  # ]:          0 :         if (id_len < 21) {
    2967                 :          0 :                 rcu_read_unlock();
    2968                 :          0 :                 return -EINVAL;
    2969                 :            :         }
    2970                 :            : 
    2971                 :          0 :         memset(id, 0, id_len);
    2972                 :          0 :         d = vpd_pg83->data + 4;
    2973         [ #  # ]:          0 :         while (d < vpd_pg83->data + vpd_pg83->len) {
    2974                 :            :                 /* Skip designators not referring to the LUN */
    2975         [ #  # ]:          0 :                 if ((d[1] & 0x30) != 0x00)
    2976                 :          0 :                         goto next_desig;
    2977                 :            : 
    2978   [ #  #  #  #  :          0 :                 switch (d[1] & 0xf) {
                      # ]
    2979                 :          0 :                 case 0x1:
    2980                 :            :                         /* T10 Vendor ID */
    2981         [ #  # ]:          0 :                         if (cur_id_size > d[3])
    2982                 :            :                                 break;
    2983                 :            :                         /* Prefer anything */
    2984         [ #  # ]:          0 :                         if (cur_id_type > 0x01 && cur_id_type != 0xff)
    2985                 :            :                                 break;
    2986                 :          0 :                         cur_id_size = d[3];
    2987         [ #  # ]:          0 :                         if (cur_id_size + 4 > id_len)
    2988                 :          0 :                                 cur_id_size = id_len - 4;
    2989                 :          0 :                         cur_id_str = d + 4;
    2990                 :          0 :                         cur_id_type = d[1] & 0xf;
    2991                 :          0 :                         id_size = snprintf(id, id_len, "t10.%*pE",
    2992                 :            :                                            cur_id_size, cur_id_str);
    2993                 :          0 :                         break;
    2994                 :          0 :                 case 0x2:
    2995                 :            :                         /* EUI-64 */
    2996         [ #  # ]:          0 :                         if (cur_id_size > d[3])
    2997                 :            :                                 break;
    2998                 :            :                         /* Prefer NAA IEEE Registered Extended */
    2999   [ #  #  #  # ]:          0 :                         if (cur_id_type == 0x3 &&
    3000                 :            :                             cur_id_size == d[3])
    3001                 :            :                                 break;
    3002                 :          0 :                         cur_id_size = d[3];
    3003                 :          0 :                         cur_id_str = d + 4;
    3004                 :          0 :                         cur_id_type = d[1] & 0xf;
    3005   [ #  #  #  # ]:          0 :                         switch (cur_id_size) {
    3006                 :          0 :                         case 8:
    3007                 :          0 :                                 id_size = snprintf(id, id_len,
    3008                 :            :                                                    "eui.%8phN",
    3009                 :            :                                                    cur_id_str);
    3010                 :          0 :                                 break;
    3011                 :          0 :                         case 12:
    3012                 :          0 :                                 id_size = snprintf(id, id_len,
    3013                 :            :                                                    "eui.%12phN",
    3014                 :            :                                                    cur_id_str);
    3015                 :          0 :                                 break;
    3016                 :          0 :                         case 16:
    3017                 :          0 :                                 id_size = snprintf(id, id_len,
    3018                 :            :                                                    "eui.%16phN",
    3019                 :            :                                                    cur_id_str);
    3020                 :          0 :                                 break;
    3021                 :            :                         default:
    3022                 :            :                                 cur_id_size = 0;
    3023                 :            :                                 break;
    3024                 :            :                         }
    3025                 :            :                         break;
    3026                 :          0 :                 case 0x3:
    3027                 :            :                         /* NAA */
    3028         [ #  # ]:          0 :                         if (cur_id_size > d[3])
    3029                 :            :                                 break;
    3030                 :          0 :                         cur_id_size = d[3];
    3031                 :          0 :                         cur_id_str = d + 4;
    3032                 :          0 :                         cur_id_type = d[1] & 0xf;
    3033      [ #  #  # ]:          0 :                         switch (cur_id_size) {
    3034                 :          0 :                         case 8:
    3035                 :          0 :                                 id_size = snprintf(id, id_len,
    3036                 :            :                                                    "naa.%8phN",
    3037                 :            :                                                    cur_id_str);
    3038                 :          0 :                                 break;
    3039                 :          0 :                         case 16:
    3040                 :          0 :                                 id_size = snprintf(id, id_len,
    3041                 :            :                                                    "naa.%16phN",
    3042                 :            :                                                    cur_id_str);
    3043                 :          0 :                                 break;
    3044                 :            :                         default:
    3045                 :            :                                 cur_id_size = 0;
    3046                 :            :                                 break;
    3047                 :            :                         }
    3048                 :            :                         break;
    3049                 :          0 :                 case 0x8:
    3050                 :            :                         /* SCSI name string */
    3051         [ #  # ]:          0 :                         if (cur_id_size + 4 > d[3])
    3052                 :            :                                 break;
    3053                 :            :                         /* Prefer others for truncated descriptor */
    3054   [ #  #  #  # ]:          0 :                         if (cur_id_size && d[3] > id_len)
    3055                 :            :                                 break;
    3056                 :          0 :                         cur_id_size = id_size = d[3];
    3057                 :          0 :                         cur_id_str = d + 4;
    3058                 :          0 :                         cur_id_type = d[1] & 0xf;
    3059         [ #  # ]:          0 :                         if (cur_id_size >= id_len)
    3060                 :          0 :                                 cur_id_size = id_len - 1;
    3061                 :          0 :                         memcpy(id, cur_id_str, cur_id_size);
    3062                 :            :                         /* Decrease priority for truncated descriptor */
    3063         [ #  # ]:          0 :                         if (cur_id_size != id_size)
    3064                 :          0 :                                 cur_id_size = 6;
    3065                 :            :                         break;
    3066                 :            :                 default:
    3067                 :            :                         break;
    3068                 :            :                 }
    3069                 :          0 : next_desig:
    3070                 :          0 :                 d += d[3] + 4;
    3071                 :            :         }
    3072                 :          0 :         rcu_read_unlock();
    3073                 :            : 
    3074                 :          0 :         return id_size;
    3075                 :            : }
    3076                 :            : EXPORT_SYMBOL(scsi_vpd_lun_id);
    3077                 :            : 
    3078                 :            : /*
    3079                 :            :  * scsi_vpd_tpg_id - return a target port group identifier
    3080                 :            :  * @sdev: SCSI device
    3081                 :            :  *
    3082                 :            :  * Returns the Target Port Group identifier from the information
    3083                 :            :  * froom VPD page 0x83 of the device.
    3084                 :            :  *
    3085                 :            :  * Returns the identifier or error on failure.
    3086                 :            :  */
    3087                 :          0 : int scsi_vpd_tpg_id(struct scsi_device *sdev, int *rel_id)
    3088                 :            : {
    3089                 :          0 :         const unsigned char *d;
    3090                 :          0 :         const struct scsi_vpd *vpd_pg83;
    3091                 :          0 :         int group_id = -EAGAIN, rel_port = -1;
    3092                 :            : 
    3093                 :          0 :         rcu_read_lock();
    3094         [ #  # ]:          0 :         vpd_pg83 = rcu_dereference(sdev->vpd_pg83);
    3095         [ #  # ]:          0 :         if (!vpd_pg83) {
    3096                 :          0 :                 rcu_read_unlock();
    3097                 :          0 :                 return -ENXIO;
    3098                 :            :         }
    3099                 :            : 
    3100                 :          0 :         d = vpd_pg83->data + 4;
    3101         [ #  # ]:          0 :         while (d < vpd_pg83->data + vpd_pg83->len) {
    3102      [ #  #  # ]:          0 :                 switch (d[1] & 0xf) {
    3103                 :          0 :                 case 0x4:
    3104                 :            :                         /* Relative target port */
    3105                 :          0 :                         rel_port = get_unaligned_be16(&d[6]);
    3106                 :          0 :                         break;
    3107                 :          0 :                 case 0x5:
    3108                 :            :                         /* Target port group */
    3109                 :          0 :                         group_id = get_unaligned_be16(&d[6]);
    3110                 :          0 :                         break;
    3111                 :            :                 default:
    3112                 :            :                         break;
    3113                 :            :                 }
    3114                 :          0 :                 d += d[3] + 4;
    3115                 :            :         }
    3116                 :          0 :         rcu_read_unlock();
    3117                 :            : 
    3118   [ #  #  #  # ]:          0 :         if (group_id >= 0 && rel_id && rel_port != -1)
    3119                 :          0 :                 *rel_id = rel_port;
    3120                 :            : 
    3121                 :            :         return group_id;
    3122                 :            : }
    3123                 :            : EXPORT_SYMBOL(scsi_vpd_tpg_id);

Generated by: LCOV version 1.14