Commit 2edc78b9 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'block-5.6-2020-02-28' of git://git.kernel.dk/linux-block 

Pull block fixes from Jens Axboe:

 - Passthrough insertion fix (Ming)

 - Kill off some unused arguments (John)

 - blktrace RCU fix (Jan)

 - Dead fields removal for null_blk (Dongli)

 - NVMe polled IO fix (Bijan)

* tag 'block-5.6-2020-02-28' of git://git.kernel.dk/linux-block:
  nvme-pci: Hold cq_poll_lock while completing CQEs
  blk-mq: Remove some unused function arguments
  null_blk: remove unused fields in 'nullb_cmd'
  blktrace: Protect q->blk_trace with RCU
  blk-mq: insert passthrough request into hctx->dispatch directly
parents 74dea5d9 5b8ea58b

block/blk-flush.c

+1 −1
Original line number Diff line number Diff line
@@ -412,7 +412,7 @@ void blk_insert_flush(struct request *rq) 
	 */

	if ((policy & REQ_FSEQ_DATA) &&

	    !(policy & (REQ_FSEQ_PREFLUSH | REQ_FSEQ_POSTFLUSH))) {

		blk_mq_request_bypass_insert(rq, false);

		blk_mq_request_bypass_insert(rq, false, false);

		return;

	}

block/blk-mq-sched.c

+15 −7
Original line number Diff line number Diff line
@@ -361,13 +361,19 @@ static bool blk_mq_sched_bypass_insert(struct blk_mq_hw_ctx *hctx, 
				       bool has_sched,

				       struct request *rq)

{

	/* dispatch flush rq directly */

	if (rq->rq_flags & RQF_FLUSH_SEQ) {

		spin_lock(&hctx->lock);

		list_add(&rq->queuelist, &hctx->dispatch);

		spin_unlock(&hctx->lock);

	/*

	 * dispatch flush and passthrough rq directly

	 *

	 * passthrough request has to be added to hctx->dispatch directly.

	 * For some reason, device may be in one situation which can't

	 * handle FS request, so STS_RESOURCE is always returned and the

	 * FS request will be added to hctx->dispatch. However passthrough

	 * request may be required at that time for fixing the problem. If

	 * passthrough request is added to scheduler queue, there isn't any

	 * chance to dispatch it given we prioritize requests in hctx->dispatch.

	 */

	if ((rq->rq_flags & RQF_FLUSH_SEQ) || blk_rq_is_passthrough(rq))

		return true;

	}



	if (has_sched)

		rq->rq_flags |= RQF_SORTED;
@@ -391,8 +397,10 @@ void blk_mq_sched_insert_request(struct request *rq, bool at_head, 


	WARN_ON(e && (rq->tag != -1));



	if (blk_mq_sched_bypass_insert(hctx, !!e, rq))

	if (blk_mq_sched_bypass_insert(hctx, !!e, rq)) {

		blk_mq_request_bypass_insert(rq, at_head, false);

		goto run;

	}



	if (e && e->type->ops.insert_requests) {

		LIST_HEAD(list);

block/blk-mq-tag.c

+2 −2
Original line number Diff line number Diff line
@@ -183,8 +183,8 @@ found_tag: 
	return tag + tag_offset;

}



void blk_mq_put_tag(struct blk_mq_hw_ctx *hctx, struct blk_mq_tags *tags,

		    struct blk_mq_ctx *ctx, unsigned int tag)

void blk_mq_put_tag(struct blk_mq_tags *tags, struct blk_mq_ctx *ctx,

		    unsigned int tag)

{

	if (!blk_mq_tag_is_reserved(tags, tag)) {

		const int real_tag = tag - tags->nr_reserved_tags;

block/blk-mq-tag.h

+2 −2
Original line number Diff line number Diff line
@@ -26,8 +26,8 @@ extern struct blk_mq_tags *blk_mq_init_tags(unsigned int nr_tags, unsigned int r 
extern void blk_mq_free_tags(struct blk_mq_tags *tags);



extern unsigned int blk_mq_get_tag(struct blk_mq_alloc_data *data);

extern void blk_mq_put_tag(struct blk_mq_hw_ctx *hctx, struct blk_mq_tags *tags,

			   struct blk_mq_ctx *ctx, unsigned int tag);

extern void blk_mq_put_tag(struct blk_mq_tags *tags, struct blk_mq_ctx *ctx,

			   unsigned int tag);

extern int blk_mq_tag_update_depth(struct blk_mq_hw_ctx *hctx,

					struct blk_mq_tags **tags,

					unsigned int depth, bool can_grow);

block/blk-mq.c

+15 −13
Original line number Diff line number Diff line
@@ -477,9 +477,9 @@ static void __blk_mq_free_request(struct request *rq) 
	blk_pm_mark_last_busy(rq);

	rq->mq_hctx = NULL;

	if (rq->tag != -1)

		blk_mq_put_tag(hctx, hctx->tags, ctx, rq->tag);

		blk_mq_put_tag(hctx->tags, ctx, rq->tag);

	if (sched_tag != -1)

		blk_mq_put_tag(hctx, hctx->sched_tags, ctx, sched_tag);

		blk_mq_put_tag(hctx->sched_tags, ctx, sched_tag);

	blk_mq_sched_restart(hctx);

	blk_queue_exit(q);

}
@@ -735,7 +735,7 @@ static void blk_mq_requeue_work(struct work_struct *work) 
		 * merge.

		 */

		if (rq->rq_flags & RQF_DONTPREP)

			blk_mq_request_bypass_insert(rq, false);

			blk_mq_request_bypass_insert(rq, false, false);

		else

			blk_mq_sched_insert_request(rq, true, false, false);

	}
@@ -1286,7 +1286,7 @@ bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list, 
			q->mq_ops->commit_rqs(hctx);



		spin_lock(&hctx->lock);

		list_splice_init(list, &hctx->dispatch);

		list_splice_tail_init(list, &hctx->dispatch);

		spin_unlock(&hctx->lock);



		/*
@@ -1677,11 +1677,15 @@ void __blk_mq_insert_request(struct blk_mq_hw_ctx *hctx, struct request *rq, 
 * Should only be used carefully, when the caller knows we want to

 * bypass a potential IO scheduler on the target device.

 */

void blk_mq_request_bypass_insert(struct request *rq, bool run_queue)

void blk_mq_request_bypass_insert(struct request *rq, bool at_head,

				  bool run_queue)

{

	struct blk_mq_hw_ctx *hctx = rq->mq_hctx;



	spin_lock(&hctx->lock);

	if (at_head)

		list_add(&rq->queuelist, &hctx->dispatch);

	else

		list_add_tail(&rq->queuelist, &hctx->dispatch);

	spin_unlock(&hctx->lock);
@@ -1849,7 +1853,7 @@ insert: 
	if (bypass_insert)

		return BLK_STS_RESOURCE;



	blk_mq_request_bypass_insert(rq, run_queue);

	blk_mq_request_bypass_insert(rq, false, run_queue);

	return BLK_STS_OK;

}
@@ -1876,7 +1880,7 @@ static void blk_mq_try_issue_directly(struct blk_mq_hw_ctx *hctx, 


	ret = __blk_mq_try_issue_directly(hctx, rq, cookie, false, true);

	if (ret == BLK_STS_RESOURCE || ret == BLK_STS_DEV_RESOURCE)

		blk_mq_request_bypass_insert(rq, true);

		blk_mq_request_bypass_insert(rq, false, true);

	else if (ret != BLK_STS_OK)

		blk_mq_end_request(rq, ret);
@@ -1910,7 +1914,7 @@ void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx, 
		if (ret != BLK_STS_OK) {

			if (ret == BLK_STS_RESOURCE ||

					ret == BLK_STS_DEV_RESOURCE) {

				blk_mq_request_bypass_insert(rq,

				blk_mq_request_bypass_insert(rq, false,

							list_empty(list));

				break;

			}
@@ -3398,7 +3402,6 @@ static void blk_mq_poll_stats_fn(struct blk_stat_callback *cb) 
}



static unsigned long blk_mq_poll_nsecs(struct request_queue *q,

				       struct blk_mq_hw_ctx *hctx,

				       struct request *rq)

{

	unsigned long ret = 0;
@@ -3431,7 +3434,6 @@ static unsigned long blk_mq_poll_nsecs(struct request_queue *q, 
}



static bool blk_mq_poll_hybrid_sleep(struct request_queue *q,

				     struct blk_mq_hw_ctx *hctx,

				     struct request *rq)

{

	struct hrtimer_sleeper hs;
@@ -3451,7 +3453,7 @@ static bool blk_mq_poll_hybrid_sleep(struct request_queue *q, 
	if (q->poll_nsec > 0)

		nsecs = q->poll_nsec;

	else

		nsecs = blk_mq_poll_nsecs(q, hctx, rq);

		nsecs = blk_mq_poll_nsecs(q, rq);



	if (!nsecs)

		return false;
@@ -3506,7 +3508,7 @@ static bool blk_mq_poll_hybrid(struct request_queue *q, 
			return false;

	}



	return blk_mq_poll_hybrid_sleep(q, hctx, rq);

	return blk_mq_poll_hybrid_sleep(q, rq);

}



/**

CRA Git | Maintained and supported by SUSTech CRA and CCSE