request处理

1.bio结构体的作用就是指明要读或写块设备的哪些地址及长度，所以它最主要的成员就是bio_vec数组，一个bio_vec对应一个地址和长度（即，一块区域），bio_vec数组的作用就是读或写指明的多个块设备区域。


2.bio被传递到io调度层时，就会被转换成request结构体，一个request可能包含多个读取地址区域相邻的bio从而提高读写性能。


3.块设备所包含的gendisk结构中包含一个request_queue，这个队列就是用来接收io调度层发送过来的request。


4.gendisk结构的request_queue队列包含各种回调函数来处理整个request的生命流程：
queue的各种回调函数:
/* request process function - 处理request函数 */
request_fn_proc*request_fn;
/* make request function - 将bio转化为request函数 */
make_request_fn*make_request_fn;
/* prepare request function - 创建request时执行的函数 */
prep_rq_fn *prep_rq_fn;
/* unprepared request function -  */
unprep_rq_fn *unprep_rq_fn;
/* merge bio_vec function - 合并bio到一个request */
merge_bvec_fn *merge_bvec_fn;
/* 软中断处理函数，request处理完成时的回调函数 */
softirq_done_fn*softirq_done_fn;
/* 超时处理函数 */
rq_timed_out_fn*rq_timed_out_fn;
dma_drain_needed_fn*dma_drain_needed;
lld_busy_fn *lld_busy_fn;


进入block层的接口：generic_make_request
/**
 * generic_make_request - hand a buffer to its device driver for I/O
 * @bio:  The bio describing the location in memory and on the device.
 *
 * generic_make_request() is used to make I/O requests of block
 * devices. It is passed a &struct bio, which describes the I/O that needs
 * to be done.
 *
 * generic_make_request() does not return any status.  The
 * success/failure status of the request, along with notification of
 * completion, is delivered asynchronously through the bio->bi_end_io
 * function described (one day) else where.
 *
 * The caller of generic_make_request must make sure that bi_io_vec
 * are set to describe the memory buffer, and that bi_dev and bi_sector are
 * set to describe the device address, and the
 * bi_end_io and optionally bi_private are set to describe how
 * completion notification should be signaled.
 *
 * generic_make_request and the drivers it calls may use bi_next if this
 * bio happens to be merged with someone else, and may resubmit the bio to
 * a lower device by calling into generic_make_request recursively, which
 * means the bio should NOT be touched after the call to ->make_request_fn.
 */
void generic_make_request(struct bio *bio)
{
struct bio_list bio_list_on_stack;


if (!generic_make_request_checks(bio))
return;


/*
* We only want one ->make_request_fn to be active at a time, else
* stack usage with stacked devices could be a problem.  So use
* current->bio_list to keep a list of requests submited by a
* make_request_fn function.  current->bio_list is also used as a
* flag to say if generic_make_request is currently active in this
* task or not.  If it is NULL, then no make_request is active.  If
* it is non-NULL, then a make_request is active, and new requests
* should be added at the tail
*/
if (current->bio_list) {
bio_list_add(current->bio_list, bio);
return;
}


/* following loop may be a bit non-obvious, and so deserves some
* explanation.
* Before entering the loop, bio->bi_next is NULL (as all callers
* ensure that) so we have a list with a single bio.
* We pretend that we have just taken it off a longer list, so
* we assign bio_list to a pointer to the bio_list_on_stack,
* thus initialising the bio_list of new bios to be
* added.  ->make_request() may indeed add some more bios
* through a recursive call to generic_make_request.  If it
* did, we find a non-NULL value in bio_list and re-enter the loop
* from the top.  In this case we really did just take the bio
* of the top of the list (no pretending) and so remove it from
* bio_list, and call into ->make_request() again.
*/
BUG_ON(bio->bi_next);
bio_list_init(&bio_list_on_stack);
current->bio_list = &bio_list_on_stack;
do {
struct request_queue *q = bdev_get_queue(bio->bi_bdev);


q->make_request_fn(q, bio);


bio = bio_list_pop(current->bio_list);
} while (bio);
current->bio_list = NULL; /* deactivate */
}


block层默认创建request的函数：blk_make_request
/**
 * blk_make_request - given a bio, allocate a corresponding struct request.
 * @q: target request queue
 * @bio:  The bio describing the memory mappings that will be submitted for IO.
 *        It may be a chained-bio properly constructed by block/bio layer.
 * @gfp_mask: gfp flags to be used for memory allocation
 *
 * blk_make_request is the parallel of generic_make_request for BLOCK_PC
 * type commands. Where the struct request needs to be farther initialized by
 * the caller. It is passed a &struct bio, which describes the memory info of
 * the I/O transfer.
 *
 * The caller of blk_make_request must make sure that bi_io_vec
 * are set to describe the memory buffers. That bio_data_dir() will return
 * the needed direction of the request. (And all bio's in the passed bio-chain
 * are properly set accordingly)
 *
 * If called under none-sleepable conditions, mapped bio buffers must not
 * need bouncing, by calling the appropriate masked or flagged allocator,
 * suitable for the target device. Otherwise the call to blk_queue_bounce will
 * BUG.
 *
 * WARNING: When allocating/cloning a bio-chain, careful consideration should be
 * given to how you allocate bios. In particular, you cannot use __GFP_WAIT for
 * anything but the first bio in the chain. Otherwise you risk waiting for IO
 * completion of a bio that hasn't been submitted yet, thus resulting in a
 * deadlock. Alternatively bios should be allocated using bio_kmalloc() instead
 * of bio_alloc(), as that avoids the mempool deadlock.
 * If possible a big IO should be split into smaller parts when allocation
 * fails. Partial allocation should not be an error, or you risk a live-lock.
 */
struct request *blk_make_request(struct request_queue *q, struct bio *bio,
gfp_t gfp_mask)
{
struct request *rq = blk_get_request(q, bio_data_dir(bio), gfp_mask);


if (unlikely(!rq))
return ERR_PTR(-ENOMEM);


for_each_bio(bio) {
struct bio *bounce_bio = bio;
int ret;


blk_queue_bounce(q, &bounce_bio);
ret = blk_rq_append_bio(q, rq, bounce_bio);
if (unlikely(ret)) {
blk_put_request(rq);
return ERR_PTR(ret);
}
}


return rq;
}


block层通用执行request函数：blk_execute_rq


/**
 * blk_execute_rq - insert a request into queue for execution
 * @q: queue to insert the request in
 * @bd_disk: matching gendisk
 * @rq: request to insert
 * @at_head:    insert request at head or tail of queue
 *
 * Description:
 *    Insert a fully prepared request at the back of the I/O scheduler queue
 *    for execution and wait for completion.
 */
int blk_execute_rq(struct request_queue *q, struct gendisk *bd_disk,
  struct request *rq, int at_head)
{
DECLARE_COMPLETION_ONSTACK(wait);
char sense[SCSI_SENSE_BUFFERSIZE];
int err = 0;
unsigned long hang_check;


/*
* we need an extra reference to the request, so we can look at
* it after io completion
*/
rq->ref_count++;


if (!rq->sense) {
memset(sense, 0, sizeof(sense));
rq->sense = sense;
rq->sense_len = 0;
}


rq->end_io_data = &wait;
blk_execute_rq_nowait(q, bd_disk, rq, at_head, blk_end_sync_rq);


/* Prevent hang_check timer from firing at us during very long I/O */
hang_check = sysctl_hung_task_timeout_secs;
if (hang_check)
while (!wait_for_completion_io_timeout(&wait, hang_check * (HZ/2)));
else
wait_for_completion_io(&wait);


if (rq->errors)
err = -EIO;


return err;
}




/* return id (s/n) string for *disk to *id_str
 */
static int virtblk_get_id(struct gendisk *disk, char *id_str)
{
struct virtio_blk *vblk = disk->private_data;
struct request *req;
struct bio *bio;
int err;
/* 创建一个bio，并且把id_str转换为块设备可理解的页地址，然后将地址添加到bio的成员bio_vec结构体数组中（该数组一个元素就是一个bio_vec结构体变量，一个变量就对应一个起始地址和长度，因此该数组就对应几块存储区），因为id_str的长度可能会需要几个页，所以bio_vec结构体数组元素的个数也就是id_str占用的页数 */
bio = bio_map_kern(vblk->disk->queue, id_str, VIRTIO_BLK_ID_BYTES,
  GFP_KERNEL);
if (IS_ERR(bio))
return PTR_ERR(bio);


req = blk_make_request(vblk->disk->queue, bio, GFP_KERNEL);
if (IS_ERR(req)) {
bio_put(bio);
return PTR_ERR(req);
}


req->cmd_type = REQ_TYPE_SPECIAL;
err = blk_execute_rq(vblk->disk->queue, vblk->disk, req, false);
blk_put_request(req);


return err;
}