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

block: refactor get_request[_wait]() 



Currently, there are two request allocation functions - get_request()
and get_request_wait().  The former tries to allocate a request once
and the latter keeps retrying until it succeeds.  The latter wraps the
former and keeps retrying until allocation succeeds.

The combination of two functions deliver fallible non-wait allocation,
fallible wait allocation and unfailing wait allocation.  However,
given that forward progress is guaranteed, fallible wait allocation
isn't all that useful and in fact nobody uses it.

This patch simplifies the interface as follows.

* get_request() is renamed to __get_request() and is only used by the
  wrapper function.

* get_request_wait() is renamed to get_request().  It now takes
  @gfp_mask and retries iff it contains %__GFP_WAIT.

This patch doesn't introduce any functional change and is to prepare
for further updates to request allocation path.

Signed-off-by: default avatarTejun Heo <tj@kernel.org>
Acked-by: default avatarVivek Goyal <vgoyal@redhat.com>
Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent 86072d81

block/blk-core.c

+35 −39
Original line number Diff line number Diff line
@@ -837,7 +837,7 @@ static struct io_context *rq_ioc(struct bio *bio) 
}



/**

 * get_request - get a free request

 * __get_request - get a free request

 * @q: request_queue to allocate request from

 * @rw_flags: RW and SYNC flags

 * @bio: bio to allocate request for (can be %NULL)
@@ -850,7 +850,7 @@ static struct io_context *rq_ioc(struct bio *bio) 
 * Returns %NULL on failure, with @q->queue_lock held.

 * Returns !%NULL on success, with @q->queue_lock *not held*.

 */

static struct request *get_request(struct request_queue *q, int rw_flags,

static struct request *__get_request(struct request_queue *q, int rw_flags,

				     struct bio *bio, gfp_t gfp_mask)

{

	struct request *rq;
@@ -1029,32 +1029,35 @@ rq_starved: 
}



/**

 * get_request_wait - get a free request with retry

 * get_request - get a free request

 * @q: request_queue to allocate request from

 * @rw_flags: RW and SYNC flags

 * @bio: bio to allocate request for (can be %NULL)

 * @gfp_mask: allocation mask

 *

 * Get a free request from @q.  This function keeps retrying under memory

 * pressure and fails iff @q is dead.

 * Get a free request from @q.  If %__GFP_WAIT is set in @gfp_mask, this

 * function keeps retrying under memory pressure and fails iff @q is dead.

 *

 * Must be callled with @q->queue_lock held and,

 * Returns %NULL on failure, with @q->queue_lock held.

 * Returns !%NULL on success, with @q->queue_lock *not held*.

 */

static struct request *get_request_wait(struct request_queue *q, int rw_flags,

					struct bio *bio)

static struct request *get_request(struct request_queue *q, int rw_flags,

				   struct bio *bio, gfp_t gfp_mask)

{

	const bool is_sync = rw_is_sync(rw_flags) != 0;

	struct request *rq;



	rq = get_request(q, rw_flags, bio, GFP_NOIO);

	while (!rq) {

	DEFINE_WAIT(wait);

	struct request_list *rl = &q->rq;

	struct request *rq;

retry:

	rq = __get_request(q, rw_flags, bio, gfp_mask);

	if (rq)

		return rq;



		if (unlikely(blk_queue_dead(q)))

	if (!(gfp_mask & __GFP_WAIT) || unlikely(blk_queue_dead(q)))

		return NULL;



	/* wait on @rl and retry */

	prepare_to_wait_exclusive(&rl->wait[is_sync], &wait,

				  TASK_UNINTERRUPTIBLE);
@@ -1064,10 +1067,9 @@ static struct request *get_request_wait(struct request_queue *q, int rw_flags, 
	io_schedule();



	/*

		 * After sleeping, we become a "batching" process and

		 * will be able to allocate at least one request, and

		 * up to a big batch of them for a small period time.

		 * See ioc_batching, ioc_set_batching

	 * After sleeping, we become a "batching" process and will be able

	 * to allocate at least one request, and up to a big batch of them

	 * for a small period time.  See ioc_batching, ioc_set_batching

	 */

	create_io_context(GFP_NOIO, q->node);

	ioc_set_batching(q, current->io_context);
@@ -1075,10 +1077,7 @@ static struct request *get_request_wait(struct request_queue *q, int rw_flags, 
	spin_lock_irq(q->queue_lock);

	finish_wait(&rl->wait[is_sync], &wait);



		rq = get_request(q, rw_flags, bio, GFP_NOIO);

	};



	return rq;

	goto retry;

}



struct request *blk_get_request(struct request_queue *q, int rw, gfp_t gfp_mask)
@@ -1088,9 +1087,6 @@ struct request *blk_get_request(struct request_queue *q, int rw, gfp_t gfp_mask) 
	BUG_ON(rw != READ && rw != WRITE);



	spin_lock_irq(q->queue_lock);

	if (gfp_mask & __GFP_WAIT)

		rq = get_request_wait(q, rw, NULL);

	else

	rq = get_request(q, rw, NULL, gfp_mask);

	if (!rq)

		spin_unlock_irq(q->queue_lock);
@@ -1481,7 +1477,7 @@ get_rq: 
	 * Grab a free request. This is might sleep but can not fail.

	 * Returns with the queue unlocked.

	 */

	req = get_request_wait(q, rw_flags, bio);

	req = get_request(q, rw_flags, bio, GFP_NOIO);

	if (unlikely(!req)) {

		bio_endio(bio, -ENODEV);	/* @q is dead */

		goto out_unlock;

CRA Git | Maintained and supported by SUSTech CRA and CCSE