Commit 9934c8c0 authored by Tejun Heo's avatar Tejun Heo Committed by Jens Axboe
Browse files

block: implement and enforce request peek/start/fetch 



Till now block layer allowed two separate modes of request execution.
A request is always acquired from the request queue via
elv_next_request().  After that, drivers are free to either dequeue it
or process it without dequeueing.  Dequeue allows elv_next_request()
to return the next request so that multiple requests can be in flight.

Executing requests without dequeueing has its merits mostly in
allowing drivers for simpler devices which can't do sg to deal with
segments only without considering request boundary.  However, the
benefit this brings is dubious and declining while the cost of the API
ambiguity is increasing.  Segment based drivers are usually for very
old or limited devices and as converting to dequeueing model isn't
difficult, it doesn't justify the API overhead it puts on block layer
and its more modern users.

Previous patches converted all block low level drivers to dequeueing
model.  This patch completes the API transition by...

* renaming elv_next_request() to blk_peek_request()

* renaming blkdev_dequeue_request() to blk_start_request()

* adding blk_fetch_request() which is combination of peek and start

* disallowing completion of queued (not started) requests

* applying new API to all LLDs

Renamings are for consistency and to break out of tree code so that
it's apparent that out of tree drivers need updating.

[ Impact: block request issue API cleanup, no functional change ]

Signed-off-by: default avatarTejun Heo <tj@kernel.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Mike Miller <mike.miller@hp.com>
Cc: unsik Kim <donari75@gmail.com>
Cc: Paul Clements <paul.clements@steeleye.com>
Cc: Tim Waugh <tim@cyberelk.net>
Cc: Geert Uytterhoeven <Geert.Uytterhoeven@sonycom.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Laurent Vivier <Laurent@lvivier.info>
Cc: Jeff Garzik <jgarzik@pobox.com>
Cc: Jeremy Fitzhardinge <jeremy@xensource.com>
Cc: Grant Likely <grant.likely@secretlab.ca>
Cc: Adrian McMenamin <adrian@mcmen.demon.co.uk>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Cc: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
Cc: Borislav Petkov <petkovbb@googlemail.com>
Cc: Sergei Shtylyov <sshtylyov@ru.mvista.com>
Cc: Alex Dubov <oakad@yahoo.com>
Cc: Pierre Ossman <drzeus@drzeus.cx>
Cc: David Woodhouse <dwmw2@infradead.org>
Cc: Markus Lidel <Markus.Lidel@shadowconnect.com>
Cc: Stefan Weinhuber <wein@de.ibm.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Pete Zaitcev <zaitcev@redhat.com>
Cc: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
Signed-off-by: default avatarJens Axboe <jens.axboe@oracle.com>
parent 23430468

arch/arm/plat-omap/mailbox.c

+3 −9
Original line number Diff line number Diff line
@@ -197,9 +197,7 @@ static void mbox_tx_work(struct work_struct *work) 
		struct omap_msg_tx_data *tx_data;



		spin_lock(q->queue_lock);

		rq = elv_next_request(q);

		if (rq)

			blkdev_dequeue_request(rq);

		rq = blk_fetch_request(q);

		spin_unlock(q->queue_lock);



		if (!rq)
@@ -242,9 +240,7 @@ static void mbox_rx_work(struct work_struct *work) 


	while (1) {

		spin_lock_irqsave(q->queue_lock, flags);

		rq = elv_next_request(q);

		if (rq)

			blkdev_dequeue_request(rq);

		rq = blk_fetch_request(q);

		spin_unlock_irqrestore(q->queue_lock, flags);

		if (!rq)

			break;
@@ -351,9 +347,7 @@ omap_mbox_read(struct device *dev, struct device_attribute *attr, char *buf) 


	while (1) {

		spin_lock_irqsave(q->queue_lock, flags);

		rq = elv_next_request(q);

		if (rq)

			blkdev_dequeue_request(rq);

		rq = blk_fetch_request(q);

		spin_unlock_irqrestore(q->queue_lock, flags);



		if (!rq)

arch/um/drivers/ubd_kern.c

+1 −2
Original line number Diff line number Diff line
@@ -1228,12 +1228,11 @@ static void do_ubd_request(struct request_queue *q) 
	while(1){

		struct ubd *dev = q->queuedata;

		if(dev->end_sg == 0){

			struct request *req = elv_next_request(q);

			struct request *req = blk_fetch_request(q);

			if(req == NULL)

				return;



			dev->request = req;

			blkdev_dequeue_request(req);

			dev->start_sg = 0;

			dev->end_sg = blk_rq_map_sg(q, req, dev->sg);

		}

block/blk-barrier.c

+2 −2
Original line number Diff line number Diff line
@@ -180,7 +180,7 @@ static inline bool start_ordered(struct request_queue *q, struct request **rqp) 
	}



	/* stash away the original request */

	elv_dequeue_request(q, rq);

	blk_dequeue_request(rq);

	q->orig_bar_rq = rq;

	rq = NULL;
@@ -248,7 +248,7 @@ bool blk_do_ordered(struct request_queue *q, struct request **rqp) 
			 * Queue ordering not supported.  Terminate

			 * with prejudice.

			 */

			elv_dequeue_request(q, rq);

			blk_dequeue_request(rq);

			__blk_end_request_all(rq, -EOPNOTSUPP);

			*rqp = NULL;

			return false;

block/blk-core.c

+77 −28
Original line number Diff line number Diff line
@@ -902,6 +902,8 @@ EXPORT_SYMBOL(blk_get_request); 
 */

void blk_requeue_request(struct request_queue *q, struct request *rq)

{

	BUG_ON(blk_queued_rq(rq));



	blk_delete_timer(rq);

	blk_clear_rq_complete(rq);

	trace_block_rq_requeue(q, rq);
@@ -1610,28 +1612,6 @@ int blk_insert_cloned_request(struct request_queue *q, struct request *rq) 
}

EXPORT_SYMBOL_GPL(blk_insert_cloned_request);



/**

 * blkdev_dequeue_request - dequeue request and start timeout timer

 * @req: request to dequeue

 *

 * Dequeue @req and start timeout timer on it.  This hands off the

 * request to the driver.

 *

 * Block internal functions which don't want to start timer should

 * call elv_dequeue_request().

 */

void blkdev_dequeue_request(struct request *req)

{

	elv_dequeue_request(req->q, req);



	/*

	 * We are now handing the request to the hardware, add the

	 * timeout handler.

	 */

	blk_add_timer(req);

}

EXPORT_SYMBOL(blkdev_dequeue_request);



static void blk_account_io_completion(struct request *req, unsigned int bytes)

{

	if (blk_do_io_stat(req)) {
@@ -1671,7 +1651,23 @@ static void blk_account_io_done(struct request *req) 
	}

}



struct request *elv_next_request(struct request_queue *q)

/**

 * blk_peek_request - peek at the top of a request queue

 * @q: request queue to peek at

 *

 * Description:

 *     Return the request at the top of @q.  The returned request

 *     should be started using blk_start_request() before LLD starts

 *     processing it.

 *

 * Return:

 *     Pointer to the request at the top of @q if available.  Null

 *     otherwise.

 *

 * Context:

 *     queue_lock must be held.

 */

struct request *blk_peek_request(struct request_queue *q)

{

	struct request *rq;

	int ret;
@@ -1748,10 +1744,12 @@ struct request *elv_next_request(struct request_queue *q) 


	return rq;

}

EXPORT_SYMBOL(elv_next_request);

EXPORT_SYMBOL(blk_peek_request);



void elv_dequeue_request(struct request_queue *q, struct request *rq)

void blk_dequeue_request(struct request *rq)

{

	struct request_queue *q = rq->q;



	BUG_ON(list_empty(&rq->queuelist));

	BUG_ON(ELV_ON_HASH(rq));
@@ -1766,6 +1764,58 @@ void elv_dequeue_request(struct request_queue *q, struct request *rq) 
		q->in_flight++;

}



/**

 * blk_start_request - start request processing on the driver

 * @req: request to dequeue

 *

 * Description:

 *     Dequeue @req and start timeout timer on it.  This hands off the

 *     request to the driver.

 *

 *     Block internal functions which don't want to start timer should

 *     call blk_dequeue_request().

 *

 * Context:

 *     queue_lock must be held.

 */

void blk_start_request(struct request *req)

{

	blk_dequeue_request(req);



	/*

	 * We are now handing the request to the hardware, add the

	 * timeout handler.

	 */

	blk_add_timer(req);

}

EXPORT_SYMBOL(blk_start_request);



/**

 * blk_fetch_request - fetch a request from a request queue

 * @q: request queue to fetch a request from

 *

 * Description:

 *     Return the request at the top of @q.  The request is started on

 *     return and LLD can start processing it immediately.

 *

 * Return:

 *     Pointer to the request at the top of @q if available.  Null

 *     otherwise.

 *

 * Context:

 *     queue_lock must be held.

 */

struct request *blk_fetch_request(struct request_queue *q)

{

	struct request *rq;



	rq = blk_peek_request(q);

	if (rq)

		blk_start_request(rq);

	return rq;

}

EXPORT_SYMBOL(blk_fetch_request);



/**

 * blk_update_request - Special helper function for request stacking drivers

 * @rq:	      the request being processed
@@ -1937,12 +1987,11 @@ static bool blk_update_bidi_request(struct request *rq, int error, 
 */

static void blk_finish_request(struct request *req, int error)

{

	BUG_ON(blk_queued_rq(req));



	if (blk_rq_tagged(req))

		blk_queue_end_tag(req->q, req);



	if (blk_queued_rq(req))

		elv_dequeue_request(req->q, req);



	if (unlikely(laptop_mode) && blk_fs_request(req))

		laptop_io_completion();

block/blk-tag.c

+1 −1
Original line number Diff line number Diff line
@@ -374,7 +374,7 @@ int blk_queue_start_tag(struct request_queue *q, struct request *rq) 
	rq->cmd_flags |= REQ_QUEUED;

	rq->tag = tag;

	bqt->tag_index[tag] = rq;

	blkdev_dequeue_request(rq);

	blk_start_request(rq);

	list_add(&rq->queuelist, &q->tag_busy_list);

	return 0;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE