Skip to contentSkip to conversation

fix failed linkchain code logic

PATCH In review Hao Xu 3 participants 6 messages Aug 27, 2021

Subsystems (2)
lore
Share & tools
lore

Hao Xu

author
#0 lore raw

v3 cover fix failed linkchain code logic

the first patch is code clean.
the second is the main one, which refactors linkchain failure path to fix a problem, detail in the commit message.

v1-->v2
- update patch with Pavel's suggestion.
v2-->v3
- move req->result initiation to better place
- add helpers for failing link node

Hao Xu (2):
io_uring: remove redundant req_set_fail()
io_uring: fix failed linkchain code logic

 fs/io_uring.c | 62 ++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 47 insertions(+), 15 deletions(-)
Signature · 1 line
2.24.4
author
#1 lore raw

PATCH v3 1/2 io_uring: remove redundant req_set_fail()

req_set_fail() in io_submit_sqe() is redundant, remove it.

---
 fs/io_uring.c | 1 -
 1 file changed, 1 deletion(-)
fs/io_uring.c +0 -1
index d9534c72dc4b..3598319b1340 100644
@@ -6631,7 +6631,6 @@ static int io_submit_sqe(struct io_ring_ctx *ctx, struct io_kiocb *req,
 fail_req:
 		if (link->head) {
 			/* fail even hard links since we don't submit */
-			req_set_fail(link->head);
 			io_req_complete_failed(link->head, -ECANCELED);
 			link->head = NULL;
 		}
Signature · 1 line
2.24.4
author
#2 lore raw

PATCH v3 2/2 io_uring: fix failed linkchain code logic

In reply to Hao Xu

Given a linkchain like this:
req0(link_flag)-->req1(link_flag)-->...-->reqn(no link_flag)

There is a problem:
- if some intermediate linked req like req1 's submittion fails, reqs after it won't be cancelled.

- sqpoll disabled: maybe it's ok since users can get the error info of req1 and stop submitting the following sqes.

- sqpoll enabled: definitely a problem, the following sqes will be submitted in the next round.

The solution is to refactor the code logic to:
- if a linked req's submittion fails, just mark it and the head(if it exists) as REQ_F_FAIL. Leverage req->result to indicate whether it is failed or cancelled.
- submit or fail the whole chain when we come to the end of it.

---
 fs/io_uring.c | 61 +++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 47 insertions(+), 14 deletions(-)
fs/io_uring.c +47 -14
index 3598319b1340..4c83ec227d85 100644
@@ -1175,6 +1175,12 @@ static inline void req_set_fail(struct io_kiocb *req)
 	req->flags |= REQ_F_FAIL;
 }
 
+static inline void req_fail_link_node(struct io_kiocb *req, int res)
+{
+	req_set_fail(req);
+	req->result = res;
+}
+
 static void io_ring_ctx_ref_free(struct percpu_ref *ref)
 {
 	struct io_ring_ctx *ctx = container_of(ref, struct io_ring_ctx, refs);
@@ -1931,11 +1937,16 @@ static void io_fail_links(struct io_kiocb *req)
 
 	req->link = NULL;
 	while (link) {
+		long res = -ECANCELED;
+
+		if (link->flags & REQ_F_FAIL)
+			res = link->result;
+
 		nxt = link->link;
 		link->link = NULL;
 
 		trace_io_uring_fail_link(req, link);
-		io_cqring_fill_event(link->ctx, link->user_data, -ECANCELED, 0);
+		io_cqring_fill_event(link->ctx, link->user_data, res, 0);
 		io_put_req_deferred(link);
 		link = nxt;
 	}
@@ -6519,8 +6530,10 @@ static inline void io_queue_sqe(struct io_kiocb *req)
 	if (unlikely(req->ctx->drain_active) && io_drain_req(req))
 		return;
 
-	if (likely(!(req->flags & REQ_F_FORCE_ASYNC))) {
+	if (likely(!(req->flags & (REQ_F_FORCE_ASYNC | REQ_F_FAIL)))) {
 		__io_queue_sqe(req);
+	} else if (req->flags & REQ_F_FAIL) {
+		io_req_complete_failed(req, req->result);
 	} else {
 		int ret = io_req_prep_async(req);
 
@@ -6629,19 +6642,34 @@ static int io_submit_sqe(struct io_ring_ctx *ctx, struct io_kiocb *req,
 	ret = io_init_req(ctx, req, sqe);
 	if (unlikely(ret)) {
 fail_req:
+		/* fail even hard links since we don't submit */
 		if (link->head) {
-			/* fail even hard links since we don't submit */
-			io_req_complete_failed(link->head, -ECANCELED);
-			link->head = NULL;
+			/*
+			 * we can judge a link req is failed or cancelled by if
+			 * REQ_F_FAIL is set, but the head is an exception since
+			 * it may be set REQ_F_FAIL because of other req's failure
+			 * so let's leverage req->result to distinguish if a head
+			 * is set REQ_F_FAIL because of its failure or other req's
+			 * failure so that we can set the correct ret code for it.
+			 * init result here to avoid affecting the normal path.
+			 */
+			if (!(link->head->flags & REQ_F_FAIL))
+				req_fail_link_node(link->head, -ECANCELED);
+		} else if (!(req->flags & (REQ_F_LINK | REQ_F_HARDLINK))) {
+			/*
+			 * the current req is a normal req, we should return
+			 * error and thus break the submittion loop.
+			 */
+			io_req_complete_failed(req, ret);
+			return ret;
 		}
-		io_req_complete_failed(req, ret);
-		return ret;
+		req_fail_link_node(req, ret);
+	} else {
+		ret = io_req_prep(req, sqe);
+		if (unlikely(ret))
+			goto fail_req;
 	}
 
-	ret = io_req_prep(req, sqe);
-	if (unlikely(ret))
-		goto fail_req;
-
 	/* don't need @sqe from now on */
 	trace_io_uring_submit_sqe(ctx, req, req->opcode, req->user_data,
 				  req->flags, true,
@@ -6657,9 +6685,14 @@ static int io_submit_sqe(struct io_ring_ctx *ctx, struct io_kiocb *req,
 	if (link->head) {
 		struct io_kiocb *head = link->head;
 
-		ret = io_req_prep_async(req);
-		if (unlikely(ret))
-			goto fail_req;
+		if (!(req->flags & REQ_F_FAIL)) {
+			ret = io_req_prep_async(req);
+			if (unlikely(ret)) {
+				req_fail_link_node(req, ret);
+				if (!(head->flags & REQ_F_FAIL))
+					req_fail_link_node(head, -ECANCELED);
+			}
+		}
 		trace_io_uring_link(ctx, req, head);
 		link->last->link = req;
 		link->last = req;
Signature · 1 line
2.24.4
Reviewed-by on the v3 series
#3 lore raw
In reply to Hao Xu
Quoted 3 lines · Hao Xu

the first patch is code clean.
the second is the main one, which refactors linkchain failure path to fix a problem, detail in the commit message.

Looks good, thanks

Quoted 13 lines

v1-->v2
- update patch with Pavel's suggestion.
v2-->v3
- move req->result initiation to better place
- add helpers for failing link node

Hao Xu (2):
io_uring: remove redundant req_set_fail()
io_uring: fix failed linkchain code logic

 fs/io_uring.c | 62 ++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 47 insertions(+), 15 deletions(-)
Signature · 1 line
Pavel Begunkov
maintainer
#4 lore raw
In reply to Hao Xu
Quoted 3 lines · Hao Xu

the first patch is code clean.
the second is the main one, which refactors linkchain failure path to fix a problem, detail in the commit message.

Thanks for pulling this one to completion - applied!

Signature · 1 line
Jens Axboe
author
#5 lore raw
Quoted 7 lines · Jens Axboe
Quoted 3 lines · Hao Xu

the first patch is code clean.
the second is the main one, which refactors linkchain failure path to fix a problem, detail in the commit message.

Thanks for pulling this one to completion - applied!

sorry for the delay.