blk-core: fix queue stuck on attempt to submit request from unplug
Subsystems (2)
PATCH 1/1 blk-core: fix queue stuck on attempt to submit request from unplug
In case of several stacked block devices, which both were inited by blk_init_queue call, you can catch the queue stuck, if first device in stack makes bio submit being in a flush of a plug list.
Let's consider this regular scenario taking readahead into account (readahead.c:read_pages):
1. Start plug
2. Read pages in loop
3. Finish plug
This example generates backtrace as follows:
1. blk_start_plug
2. generic_make_request
q->make_request_fn
[blk_queue_bio]
if (current->plug)
list_add_tail(&req->queuelist, &plug->list);
3. blk_finish_plug
blk_flush_plug_list
queue_unplugged
__blk_run_queue
XXX_request_fn [some request handler of block device]
generic_make_request
q->make_request_fn
[blk_queue_bio]
if (current->plug)
list_add_tail(&req->queuelist, &plug->list);So the problem is, that on step 3. XXX_request_fn makes another request, which again will be put to plug list, because plug is till active, thus new request will be stuck forever in the queue.
How to fix?
Do flush plug list till it becomes empty.
--- block/blk-core.c | 10 ++++++++++ block/blk-mq.c | 13 +++++++++++++ 2 files changed, 23 insertions(+)
block/blk-core.c +10 -0
@@ -3151,6 +3151,7 @@ void blk_flush_plug_list(struct blk_plug *plug, bool from_schedule)LIST_HEAD (list);unsigned int depth; +repeat:flush_plug_callbacks (plug, from_schedule);if (!list_empty (&plug->mq_list))
@@ -3212,6 +3213,15 @@ void blk_flush_plug_list(struct blk_plug *plug, bool from_schedule)queue_unplugged (q, depth, from_schedule);local_irq_restore (flags); + +/* +* We have to repeat the whole flush till list becomes +* empty, because underlying block device can submit +* another bio which again will be put to plug list. +* To avoid stuck of these subsequent bios in the queue +* we have to flush till the end. +*/ + goto repeat; }void blk_finish_plug (struct blk_plug *plug)
block/blk-mq.c +13 -0
@@ -1091,6 +1091,10 @@ void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule)LIST_HEAD (ctx_list);unsigned int depth; +repeat: +if (list_empty (&plug->mq_list)) +return ; +list_splice_init (&plug->mq_list, &list);list_sort (NULL , &list, plug_ctx_cmp);
@@ -1127,6 +1131,15 @@ void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule)blk_mq_insert_requests (this_q, this_ctx, &ctx_list, depth, from_schedule); } + +/* +* We have to repeat the whole flush till list becomes +* empty, because underlying block device can submit +* another bio which again will be put to plug list. +* To avoid stuck of these subsequent bios in the queue +* we have to flush till the end. +*/ + goto repeat; }static void blk_mq_bio_to_request (struct request *rq,struct bio *bio)
Signature · 1 line
2.5.1
Jens Axboe
maintainerQuoted 30 lines · Roman Pen
In case of several stacked block devices, which both were inited by
blk_init_queuecall, you can catch the queue stuck, if first device in stack makes bio submit being in a flush of a plug list.Let's consider this regular scenario taking readahead into account (readahead.c:read_pages):
1. Start plug
2. Read pages in loop
3. Finish plugThis example generates backtrace as follows:
1.
blk_start_plug
2.generic_make_requestq->make_request_fn [blk_queue_bio] if (current->plug) list_add_tail(&req->queuelist, &plug->list); 3. blk_finish_plug blk_flush_plug_list queue_unplugged __blk_run_queue XXX_request_fn [some request handler of block device] generic_make_request q->make_request_fn [blk_queue_bio] if (current->plug) list_add_tail(&req->queuelist, &plug->list);
Quoted 7 lines
So the problem is, that on step 3.
XXX_request_fnmakes another request, which again will be put to plug list, because plug is till active, thus new request will be stuck forever in the queue.How to fix?
Do flush plug list till it becomes empty.
What devices submit IO from request_fn? Seems like something that would be better handled out of a make_request_fn hook for that device, which would also avoid this corner case.
Signature · 1 line
Jens Axboe
Quoted 38 lines · Jens Axboe
Quoted 37 lines · Roman Pen
In case of several stacked block devices, which both were inited by
blk_init_queuecall, you can catch the queue stuck, if first device in stack makes bio submit being in a flush of a plug list.Let's consider this regular scenario taking readahead into account (readahead.c:read_pages):
1. Start plug
2. Read pages in loop
3. Finish plugThis example generates backtrace as follows:
1.
blk_start_plug
2.generic_make_requestq->make_request_fn [blk_queue_bio] if (current->plug) list_add_tail(&req->queuelist, &plug->list); 3. blk_finish_plug blk_flush_plug_list queue_unplugged __blk_run_queue XXX_request_fn [some request handler of block device] generic_make_request q->make_request_fn [blk_queue_bio] if (current->plug) list_add_tail(&req->queuelist,
&plug->list);So the problem is, that on step 3.
XXX_request_fnmakes another request, which again will be put to plug list, because plug is till active, thus new request will be stuck forever in the queue.
Quoted 7 lines
Quoted 2 lines
How to fix?
Do flush plug list till it becomes empty.What devices submit IO from
request_fn? Seems like something that would be better handled out of amake_request_fnhook for that device, which would also avoid this corner case.
Practically, this stuck was observed while doing some experiments with md, which was switched from bio mode to request mode.
But what drawbacks has this loop-till-empty? Because it seems that those corner cases with plugging can be easily fixed. Or I am missing something?
Also e.g. flush_plug_callbacks() does exactly the same:
while (!list_empty(&plug->cb_list)) {
list_splice_init(&plug->cb_list, &callbacks);
while (!list_empty(&callbacks)) {
[...]
}
}--
Roman
Quoted 5 lines
--
Jens Axboe