Linux3.10.0块IO子系统流程（5）-- 为SCSI命令准备聚散列表

SCSI数据缓冲区组织成聚散列表的形式。Linux内核中表示聚散列表的基本数据结构是scatterlist，虽然名字中有list，但它只对应一个内存缓冲区，聚散列表就是多个scatterlist的组合。这种组合是链表+数组的结合。这是因为他使用的内存以页面为基本单位分配，每个页面相当于一个scatterlist。每个scatterlist以链表方式组织起来。

 /*
 * Function:    scsi_init_io()
 *
 * Purpose:     SCSI I/O initialize function.
 *
 * Arguments:   cmd   - Command descriptor we wish to initialize
 *
 * Returns:     0 on success
 *        BLKPREP_DEFER if the failure is retryable
 *        BLKPREP_KILL if the failure is fatal
 */
 int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
 {
     struct request *rq = cmd->request;

     // 初始化sg列表
     int error = scsi_init_sgtable(rq, &cmd->sdb, gfp_mask);
     if (error)
         goto err_exit;

     // 如果是双向请求，则为关联的request分配SCSI数据缓冲区，用于另一方向的数据传输，然后调用scsi_init_sgtable分配聚散列表，最后进行映射
     if (blk_bidi_rq(rq)) {
         struct scsi_data_buffer *bidi_sdb = kmem_cache_zalloc(
             scsi_sdb_cache, GFP_ATOMIC);
         if (!bidi_sdb) {
             error = BLKPREP_DEFER;
             goto err_exit;
         }

         rq->next_rq->special = bidi_sdb;
         error = scsi_init_sgtable(rq->next_rq, bidi_sdb, GFP_ATOMIC);
         if (error)
             goto err_exit;
     }

     /*
      * 如果是完整性请求，即原始bio中带有完整性载荷，则调用blk_rq_count_integrity_sg计算完整性数据段的数目
      * 然后调用scsi_alloc_sgtable分配聚散列表，再调用blk_rq_map_integrity_sg将完整性数据映射到这个聚散列表，最后更新聚散列表已映射的项数
      * 实际上，完整性请求的处理过程概括了scsi_init_sgtable的操作流程，它实际上是这个过程的一个封装
      * 即调用scsi_alloc_sgtable分配指定数据数据段的聚散列表，然后调用blk_rq_map_sg进行映射，最后更新列表已映射的项数
      */
     if (blk_integrity_rq(rq)) {
         struct scsi_data_buffer *prot_sdb = cmd->prot_sdb;
         int ivecs, count;

         BUG_ON(prot_sdb == NULL);
         ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio);

         if (scsi_alloc_sgtable(prot_sdb, ivecs, gfp_mask)) {
             error = BLKPREP_DEFER;
             goto err_exit;
         }

         count = blk_rq_map_integrity_sg(rq->q, rq->bio,
                         prot_sdb->table.sgl);
         BUG_ON(unlikely(count > ivecs));
         BUG_ON(unlikely(count > queue_max_integrity_segments(rq->q)));

         cmd->prot_sdb = prot_sdb;
         cmd->prot_sdb->table.nents = count;
     }

     return BLKPREP_OK ;

 err_exit:
     scsi_release_buffers(cmd);
     cmd->request->special = NULL;
     scsi_put_command(cmd);
     return error;
 }

blk_rq_map_sg函数如下：

 /*
  * map a request to scatterlist, return number of sg entries setup. Caller
  * must make sure sg can hold rq->nr_phys_segments entries
  */
 int blk_rq_map_sg(struct request_queue *q, struct request *rq,
           struct scatterlist *sglist)
 {
     struct bio_vec *bvec, *bvprv;
     struct req_iterator iter;
     struct scatterlist *sg;
     int nsegs, cluster;

     nsegs = ;
     cluster = blk_queue_cluster(q);

     /*
      * for each bio in rq
      */
     bvprv = NULL;
     sg = NULL;
     rq_for_each_segment(bvec, rq, iter) {
         __blk_segment_map_sg(q, bvec, sglist, &bvprv, &sg,
                      &nsegs, &cluster);
     } /* segments in rq */

     if (unlikely(rq->cmd_flags & REQ_COPY_USER) &&
         (blk_rq_bytes(rq) & q->dma_pad_mask)) {
         unsigned int pad_len =
             (q->dma_pad_mask & ~blk_rq_bytes(rq)) + ;

         sg->length += pad_len;
         rq->extra_len += pad_len;
     }

     if (q->dma_drain_size && q->dma_drain_needed(rq)) {
         if (rq->cmd_flags & REQ_WRITE)
             memset(q->dma_drain_buffer, , q->dma_drain_size);

         sg->page_link &= ~0x02;
         sg = sg_next(sg);
         sg_set_page(sg, virt_to_page(q->dma_drain_buffer),
                 q->dma_drain_size,
                 ((unsigned long)q->dma_drain_buffer) &
                 (PAGE_SIZE - ));
         nsegs++;
         rq->extra_len += q->dma_drain_size;
     }

     if (sg)
         sg_mark_end(sg);

     return nsegs;
 }

在bio处理过程中的两次合并，第一个合并由IO调度算法负责，它将在磁盘扇区上连续的请求合并到一个request中。第二次合并出现在SCSI策略例程，如果低层驱动支持，则进而将内存中连续的段合并为聚散列表中的一项，如下图，两个bio（每个bio有两段请求）在经过两个合并之后，聚散列表最终有三个项目。