Linux3.10.0块IO子系统流程（6）-- 派发SCSI命令到低层驱动

在SCSI策略例程中最后调用scsi_dispatch_cmd将SCSI命令描述符派发给低层驱动进行处理

 /**
 * scsi_dispatch_command - Dispatch a command to the low-level driver.
 * @cmd: command block we are dispatching.
 *
 * Return: nonzero return request was rejected and device's queue needs to be
 * plugged.
 */
 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
 {
     struct Scsi_Host *host = cmd->device->host;
     unsigned long timeout;
     int rtn = ;

     // 递增SCSI设备的IO请求统计数
     atomic_inc(&cmd->device->iorequest_cnt);

     /*
      * check if the device is still usable
      * 检测设备是否还可用。在此时，可能别的地方已经将设备状态置为SDEV_DEL，如果这样，我们将所有命令出错，将命令的结果标记为DID_NO_CONNECT，调用scsi_done结束
      */
     if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
         /* in SDEV_DEL we error all commands. DID_NO_CONNECT
          * returns an immediate error upwards, and signals
          * that the device is no longer present */
         cmd->result = DID_NO_CONNECT << ;
         scsi_done(cmd);
         /* return 0 (because the command has been processed) */
         goto out;
     }

     /* Check to see if the scsi lld made this device blocked. 检查SCSI低层驱动是否已经阻塞了这个设备*/
     if (unlikely(scsi_device_blocked(cmd->device))) {
         /*
          * in blocked state, the command is just put back on
          * the device queue.  The suspend state has already
          * blocked the queue so future requests should not
          * occur until the device transitions out of the
          * suspend state.
          */

         scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);

         SCSI_LOG_MLQUEUE(, printk("queuecommand : device blocked \n"));

         /*
          * NOTE: rtn is still zero here because we don't need the
          * queue to be plugged on return (it's already stopped)
          */
         goto out;
     }

     /*
      * If SCSI-2 or lower, store the LUN value in cmnd.
      */
     if (cmd->device->scsi_level <= SCSI_2 &&
         cmd->device->scsi_level != SCSI_UNKNOWN) {
         cmd->cmnd[] = (cmd->cmnd[] & 0x1f) |
                    (cmd->device->lun <<  & 0xe0);
     }

     /*
      * We will wait MIN_RESET_DELAY clock ticks after the last reset so we can avoid the drive not being ready.
      * 如果主机适配器的resetting被设置为1，表示其last_Reset域有效。也就是说，后者记录了主机适配器上次复位的时间。
      * 在复位后必须有2秒钟的延时，才能向这个主机适配器发送命令。
      */
     timeout = host->last_reset + MIN_RESET_DELAY;

     if (host->resetting && time_before(jiffies, timeout)) {
         int ticks_remaining = timeout - jiffies;
         /*
          * NOTE: This may be executed from within an interrupt
          * handler!  This is bad, but for now, it'll do.  The irq
          * level of the interrupt handler has been masked out by the
          * platform dependent interrupt handling code already, so the
          * sti() here will not cause another call to the SCSI host's
          * interrupt handler (assuming there is one irq-level per
          * host).
          */
         while (--ticks_remaining >= )
             mdelay( +  / HZ);
         host->resetting = ;
     }

     // 在提交SCSI命令之前输出信息
     scsi_log_send(cmd);

     /*
      * Before we queue this command, check if the command length exceeds what the host adapter can handle.
      * 在将命令排入队列之前，检查命令长度是否超过了主机适配器可以处理的最大长度，如果这样，将命令结果标记为DID_ABORT并返回
      */
     if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
         SCSI_LOG_MLQUEUE(,
             printk("queuecommand : command too long. "
                    "cdb_size=%d host->max_cmd_len=%d\n",
                    cmd->cmd_len, cmd->device->host->max_cmd_len));
         cmd->result = (DID_ABORT << );

         scsi_done(cmd);
         goto out;
     }

     /* 在获取锁的过程中，可能别的地方已经将主机适配器的状态设置为“删除”。如果这样，标记为DID_NO_CONNECT并返回*/
     if (unlikely(host->shost_state == SHOST_DEL)) {
         cmd->result = (DID_NO_CONNECT << );
         scsi_done(cmd);
     } else {
         trace_scsi_dispatch_cmd_start(cmd);
         cmd->scsi_done = scsi_done;
         rtn = host->hostt->queuecommand(host, cmd);    // 调用主机适配器模板的queuecommand回调，将SCSI命令排入低层设备驱动的队列，调用时传入scsi_done，以便低层驱动完成后回调
     }

     if (rtn) {
         trace_scsi_dispatch_cmd_error(cmd, rtn);
         if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
             rtn != SCSI_MLQUEUE_TARGET_BUSY)
             rtn = SCSI_MLQUEUE_HOST_BUSY;

         scsi_queue_insert(cmd, rtn);

         SCSI_LOG_MLQUEUE(,
             printk("queuecommand : request rejected\n"));
     }

 out:
     SCSI_LOG_MLQUEUE(, printk("leaving scsi_dispatch_cmnd()\n"));
     return rtn;
 }