static ssize_t __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, int nr_page){

	...
	blk_start_plug(&plug);
	for(;;){
		//对bio作初始化，先忽略
		...
		
		submit_bio();
	}
	blk_finish_plug(&plug);
}	

//块设备排入bio请求函数 
//该接口作为通用的块设备处理bio请求的方式，主要思路是尽可能的将bio合并request中或者生成新的request。 

static blk_qc_t blk_queue_bio(struct request_queue *q, struct bio *bio)
{
+	//尝试将bio与plug队列中的request合并
+	if (!blk_queue_nomerges(q)) {
+		//如果合并成功，直接返回
+		if (blk_attempt_plug_merge(q, bio, &request_count, NULL))
+			return;
+	} else
+		request_count = blk_plug_queued_count(q);

		
    //尝试从调度队列中找到一个request可以让bio合并进去，这里的返回值由调度器决定
	switch (elv_merge(q, &req, bio)) {
	//向后合并
	case ELEVATOR_BACK_MERGE:
		if (!bio_attempt_back_merge(q, req, bio))
			break;
		elv_bio_merged(q, req, bio);
		free = attempt_back_merge(q, req);
		if (free)
			__blk_put_request(q, free);
		else
			elv_merged_request(q, req, ELEVATOR_BACK_MERGE);
		//合并后，直接解锁
		return;
	//向后合并
	case ELEVATOR_FRONT_MERGE:
		if (!bio_attempt_front_merge(q, req, bio))
			break;
		elv_bio_merged(q, req, bio);
		free = attempt_front_merge(q, req);
		if (free)
			__blk_put_request(q, free);
		else
			elv_merged_request(q, req, ELEVATOR_FRONT_MERGE);
		return;
	default:
		break;
	}

    //如果找不到可以合并的，那就bio自己作为一个新的request
    req = get_request_wait(q, rw_flags, bio);
    
+    //尝试把这个新的request加入到plug队列中
+	if (plug) {
+		if (!request_count || list_empty(&plug->list))
+			trace_block_plug(q);
+		else {
+			struct request *last = list_entry_rq(plug->list.prev);
+	
+			//如果plug队列中的请求书大于阈值（16），则说明缓存得太多了，要先把它们flush到request_queue中
+			if (request_count >= BLK_MAX_REQUEST_COUNT ||
+			    blk_rq_bytes(last) >= BLK_PLUG_FLUSH_SIZE) {
+	
+				// flush到request_queue中，也即泄流
+				blk_flush_plug_list(plug, false);
+				trace_block_plug(q);
+			}
+		}
+		// 插入到plugd队列里
+		list_add_tail(&req->queuelist, &plug->list);
+		blk_account_io_start(req, true);
+		return;
	}	
+	//没有启用plug，才会将request直接加入request_queue中
	//将该request加入调度队列
	add_acct_request(q, req, where);//默认where=ELEVATOR_INSERT_SORT
	__blk_run_queue(q)

void blk_flush_plug_list(struct blk_plug *plug, bool from_schedule)
{
    //对plug队列里的request进行排序，最终发往同一个设备的请求都会挨在一起，如1 1 1 3 3 4 4 4
    list_sort(NULL, &list, plug_rq_cmp);

    local_irq_save(flags);

    while (!list_empty(&list)) {
        rq = list_entry_rq(list.next);
        list_del_init(&rq->queuelist);
        BUG_ON(!rq->q);
        //判断前后两个请求是否发往同一个设备，若不是，说明同一个设备的请求都已经flush到request_queue了
        if (rq->q != q) {
            if (q)
            	//泄流，处理上一个设备的request_queue
                queue_unplugged(q, depth, from_schedule);
            q = rq->q;
            spin_lock(q->queue_lock);
        }
        //将该请求加入到request_queue中
        if (rq->cmd_flags & (REQ_FLUSH | REQ_FUA))
            __elv_add_request(q, rq, ELEVATOR_INSERT_FLUSH);
        else             
            __elv_add_request(q, rq, ELEVATOR_INSERT_SORT_MERGE);
    }
    //泄流最后一个队列
    if (q)
        queue_unplugged(q, depth, from_schedule);
    local_irq_restore(flags);
}

static void queue_unplugged(struct request_queue *q, unsigned int   depth, bool from_schedule) __releases(q->queue_lock)
{
    if (from_schedule)
        // 异步泄流        
        blk_run_queue_async(q);
    else 
    	// 同步泄流        
        __blk_run_queue(q);
    spin_unlock(q->queue_lock);
}

inline void __blk_run_queue_uncond(struct request_queue *q)
{
    if (unlikely(blk_queue_dead(q)))
        return;
     q->request_fn_active++;
     q->request_fn(q);
     q->request_fn_active--;
}

void blk_run_queue_async(struct request_queue *q)
{
    if (likely(!blk_queue_stopped(q) && !blk_queue_dead(q)))
        mod_delayed_work(kblockd_workqueue, &q->delay_work, 0);
}