Linux3.10.0块IO子系统流程（7）– 请求处理完成

 1 static __init int blk_softirq_init(void)
 2 {
 3     int i;
 4 
 5     for_each_possible_cpu(i)
 6         INIT_LIST_HEAD(&per_cpu(blk_cpu_done, i));
 7 
 8     open_softirq(BLOCK_SOFTIRQ, blk_done_softirq);
 9     register_hotcpu_notifier(&blk_cpu_notifier);
10     return 0;
11 }

blk_softirq_init

 1 /*
 2 * Softirq action handler - move entries to local list and loop over them
 3 * while passing them to the queue registered handler.
 4 */
 5 static void blk_done_softirq(struct softirq_action *h)
 6 {
 7     struct list_head *cpu_list, local_list;
 8 
 9     local_irq_disable();
10     cpu_list = &__get_cpu_var(blk_cpu_done);
11     list_replace_init(cpu_list, &local_list);
12     local_irq_enable();
13 
14     while (!list_empty(&local_list)) {
15         struct request *rq;
16 
17         rq = list_entry(local_list.next, struct request, csd.list);
18         list_del_init(&rq->csd.list);
19         rq->q->softirq_done_fn(rq);
20     }
21 }

 1 static void scsi_softirq_done(struct request *rq)
 2 {
 3     struct scsi_cmnd *cmd = rq->special;
 4     unsigned long wait_for = (cmd->allowed + 1) * rq->timeout;
 5     int disposition;
 6 
 7     INIT_LIST_HEAD(&cmd->eh_entry);
 8 
 9     /* 首先修改所属SCSI设备的统计计数器，包括递增已完成命令计数器iodone_cnt和返回错误结果时递增已出错命令计数器ioerr_cnt */
10     atomic_inc(&cmd->device->iodone_cnt);
11     if (cmd->result)
12         atomic_inc(&cmd->device->ioerr_cnt);
13 
14     /*
15      * scsi_decide_disposition确定如何处理这条命令 
16      * SUCCESS：调用scsi_finish_command结束，后续继续分析
17      * NEEDS_RETRY：
18      * ADD_TO_MLQUEUE：后面两种情况都将命令重新排入请求队列，前者立即重试，后者经过一定延时后重试
19      * 其他返回值调用scsi_eh_scmd_add进入错误恢复。如果进入错误恢复流程，返回1，这种情况下无需再处理这条命令，如果返回0则只能调用scsi_finish_command结束
20      */
21     disposition = scsi_decide_disposition(cmd);
22     if (disposition != SUCCESS &&
23         time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) {
24         sdev_printk(KERN_ERR, cmd->device,
25                 "timing out command, waited %lus\n",
26                 wait_for/HZ);
27         disposition = SUCCESS;
28     }
29             
30     scsi_log_completion(cmd, disposition);
31 
32     switch (disposition) {
33         case SUCCESS:
34             scsi_finish_command(cmd);
35             break;
36         case NEEDS_RETRY:
37             scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
38             break;
39         case ADD_TO_MLQUEUE:
40             scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
41             break;
42         default:
43             if (!scsi_eh_scmd_add(cmd, 0))
44                 scsi_finish_command(cmd);
45     }
46 }

 1 /**
 2 * scsi_finish_command - cleanup and pass command back to upper layer
 3 * @cmd: the command
 4 *
 5 * Description: Pass command off to upper layer for finishing of I/O
 6 *              request, waking processes that are waiting on results,
 7 *              etc.
 8 */
 9 void scsi_finish_command(struct scsi_cmnd *cmd)
10 {
11     struct scsi_device *sdev = cmd->device;
12     struct scsi_target *starget = scsi_target(sdev);
13     struct Scsi_Host *shost = sdev->host;
14     struct scsi_driver *drv;
15     unsigned int good_bytes;
16 
17     scsi_device_unbusy(sdev);
18 
19         /*
20          * Clear the flags which say that the device/host is no longer
21          * capable of accepting new commands.  These are set in scsi_queue.c
22          * for both the queue full condition on a device, and for a
23          * host full condition on the host.
24      *
25      * XXX(hch): What about locking?
26          */
27         shost->host_blocked = 0;
28     starget->target_blocked = 0;
29         sdev->device_blocked = 0;
30 
31     /*
32      * If we have valid sense information, then some kind of recovery
33      * must have taken place.  Make a note of this.
34      */
35     if (SCSI_SENSE_VALID(cmd))
36         cmd->result |= (DRIVER_SENSE << 24);
37 
38     SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
39                 "Notifying upper driver of completion "
40                 "(result %x)\n", cmd->result));
41 
42     /*
43      * 要进行完成处理，首先必须知道SCSI已经成功完成的字节数，scsi_bufflen函数从SCSI数据缓冲区得到这个数据
44      * 如果请求不是来自SCSI公共服务层，那么它一定来自上层，也就表明处理这个请求的设备必定被绑定到了高层驱动，
45      * 如果定义了done回调，则调用它，对于SCSI磁盘高层驱动，对应实现为sd_done函数，这个函数返回调整后的已完成字节数
46      * 有了已完成字节数，就可以调用scsi_io_completion
47      */
48     good_bytes = scsi_bufflen(cmd);
49         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
50         int old_good_bytes = good_bytes;
51         drv = scsi_cmd_to_driver(cmd);
52         if (drv->done)
53             good_bytes = drv->done(cmd);
54         /*
55          * USB may not give sense identifying bad sector and
56          * simply return a residue instead, so subtract off the
57          * residue if drv->done() error processing indicates no
58          * change to the completion length.
59          */
60         if (good_bytes == old_good_bytes)
61             good_bytes -= scsi_get_resid(cmd);
62     }
63     scsi_io_completion(cmd, good_bytes);
64 }