blk_sysfs.c

static struct queue_sysfs_entry queue_ra_entry = {.attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR },.show = queue_ra_show,.store = queue_ra_store,};static struct queue_sysfs_entry queue_max_sectors_entry = {.attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR },.show = queue_max_sectors_show,.store = queue_max_sectors_store,};

blk-map.c Functions related to mapping data to requests

static inline struct bio *bio_kmalloc(gfp_t gfp_mask, unsigned int nr_iovecs){return bio_alloc_bioset(gfp_mask, nr_iovecs, NULL);}

blk_rq_map_user_iov - map user data to a request, for REQ_TYPE_BLOCK_PC usage

scsi_ioctl.c

static int sg_io(struct request_queue *q, struct gendisk *bd_disk,

struct sg_io_hdr *hdr, fmode_t mode);

scst/sg.c

static int sg_start_req(Sg_request *srp, unsigned char *cmd);

 => scsi_dispatch_cmd

 => scsi_request_fn

 => __blk_run_queue_uncond

 => __blk_run_queue

 => blk_queue_bio

 => generic_make_request

 => submit_bio

 => submit_bh

 * 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.

submit_bio - submit a bio to the block device layer for I/O

void submit_bio(int rw, struct bio *bio);

void generic_make_request(struct bio *bio);

在每个进程的task_struct中，都包含有两个变量----struct bio *bio_list，实际的提交操作会由generic_make_request()调用__generic_make_request()函数完成。

/* stacked block device info */

 struct bio_list *bio_list;

/** * 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);		将bio发送给disk，调用blk_queue_bio				q->make_request_fn(q, bio); 		bio = bio_list_pop(current->bio_list);	} while (bio);	current->bio_list = NULL; /* deactivate */}

void blk_queue_bio(struct request_queue *q, struct bio *bio){	const bool sync = !!(bio->bi_rw & REQ_SYNC);	struct blk_plug *plug;	int el_ret, rw_flags, where = ELEVATOR_INSERT_SORT;	struct request *req;	unsigned int request_count = 0;	/*	 * low level driver can indicate that it wants pages above a	 * certain limit bounced to low memory (ie for highmem, or even	 * ISA dma in theory)	 */	blk_queue_bounce(q, &bio);	if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {		bio_endio(bio, -EIO);		return;	}	if (bio->bi_rw & (REQ_FLUSH | REQ_FUA)) {		spin_lock_irq(q->queue_lock);		where = ELEVATOR_INSERT_FLUSH;		goto get_rq;	}	/*	 * Check if we can merge with the plugged list before grabbing	 * any locks.	 */	if (blk_attempt_plug_merge(q, bio, &request_count))		return;	spin_lock_irq(q->queue_lock);	el_ret = elv_merge(q, &req, bio);	if (el_ret == ELEVATOR_BACK_MERGE) {		if (bio_attempt_back_merge(q, req, bio)) {			elv_bio_merged(q, req, bio);			if (!attempt_back_merge(q, req))				elv_merged_request(q, req, el_ret);			goto out_unlock;		}	} else if (el_ret == ELEVATOR_FRONT_MERGE) {		if (bio_attempt_front_merge(q, req, bio)) {			elv_bio_merged(q, req, bio);			if (!attempt_front_merge(q, req))				elv_merged_request(q, req, el_ret);			goto out_unlock;		}	}get_rq:	/*	 * This sync check and mask will be re-done in init_request_from_bio(),	 * but we need to set it earlier to expose the sync flag to the	 * rq allocator and io schedulers.	 */	rw_flags = bio_data_dir(bio);	if (sync)		rw_flags |= REQ_SYNC;	/*	 * Grab a free request. This is might sleep but can not fail.	 * Returns with the queue unlocked.	 */	req = get_request(q, rw_flags, bio, GFP_NOIO);	if (unlikely(!req)) {		bio_endio(bio, -ENODEV);	/* @q is dead */		goto out_unlock;	}	/*	 * After dropping the lock and possibly sleeping here, our request	 * may now be mergeable after it had proven unmergeable (above).	 * We don't worry about that case for efficiency. It won't happen	 * often, and the elevators are able to handle it.	 */	init_request_from_bio(req, bio);	if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags))		req->cpu = raw_smp_processor_id();	plug = current->plug;	if (plug) {		/*		 * If this is the first request added after a plug, fire		 * of a plug trace. If others have been added before, check		 * if we have multiple devices in this plug. If so, make a		 * note to sort the list before dispatch.		 */		if (list_empty(&plug->list))			trace_block_plug(q);		else {			if (request_count >= BLK_MAX_REQUEST_COUNT) {				blk_flush_plug_list(plug, false);				trace_block_plug(q);			}		}		list_add_tail(&req->queuelist, &plug->list);		blk_account_io_start(req, true);	} else {		spin_lock_irq(q->queue_lock);		add_acct_request(q, req, where);		__blk_run_queue(q);out_unlock:		spin_unlock_irq(q->queue_lock);	}}

/** * __blk_run_queue - run a single device queue * @q:	The queue to run * * Description: *    See @blk_run_queue. This variant must be called with the queue lock *    held and interrupts disabled. */void __blk_run_queue(struct request_queue *q){	if (unlikely(blk_queue_stopped(q)))		return;	__blk_run_queue_uncond(q);}

/**

 * __blk_run_queue_uncond - run a queue whether or not it has been stopped

 * @q:The queue to run

 *

 * Description:

 *    Invoke request handling on a queue if there are any pending requests.

 *    May be used to restart request handling after a request has completed.

 *    This variant runs the queue whether or not the queue has been

 *    stopped. Must be called with the queue lock held and interrupts

 *    disabled. See also @blk_run_queue.

 */

inline void __blk_run_queue_uncond(struct request_queue *q)

{

if (unlikely(blk_queue_dead(q)))

return;

/*

* Some request_fn implementations, e.g. scsi_request_fn(), unlock

* the queue lock internally. As a result multiple threads may be

* running such a request function concurrently. Keep track of the

* number of active request_fn invocations such that blk_drain_queue()

* can wait until all these request_fn calls have finished.

*/

q->request_fn_active++;

        调用请求处理函数

q->request_fn(q);

q->request_fn_active--;

}