Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
io_uring/net: use struct io_br_sel->val as the recv finish value
Currently a pointer is passed in to the 'ret' in the receive handlers,
but since we already have a value field in io_br_sel, just use that.
This is also in preparation for needing to pass in struct io_br_sel
to io_recv_finish() anyway.
Link: https://lore.kernel.org/r/20250821020750.598432-10-axboe@kernel.dk
Signed-off-by: Jens Axboe <axboe@kernel.dk>
+19
-16
+19
-16
io_uring/net.c
+19
-16
io_uring/net.c
···
845
845
* Returns true if it is actually finished, or false if it should run
846
846
* again (for multishot).
847
847
*/
848
-
static inline bool io_recv_finish(struct io_kiocb *req, int *ret,
848
+
static inline bool io_recv_finish(struct io_kiocb *req,
849
849
struct io_async_msghdr *kmsg,
850
-
bool mshot_finished, unsigned issue_flags)
850
+
struct io_br_sel *sel, bool mshot_finished,
851
+
unsigned issue_flags)
851
852
{
852
853
struct io_sr_msg *sr = io_kiocb_to_cmd(req, struct io_sr_msg);
853
854
unsigned int cflags = 0;
···
856
855
if (kmsg->msg.msg_inq > 0)
857
856
cflags |= IORING_CQE_F_SOCK_NONEMPTY;
858
857
859
-
if (*ret > 0 && sr->flags & IORING_RECV_MSHOT_LIM) {
858
+
if (sel->val > 0 && sr->flags & IORING_RECV_MSHOT_LIM) {
860
859
/*
861
860
* If sr->len hits zero, the limit has been reached. Mark
862
861
* mshot as finished, and flag MSHOT_DONE as well to prevent
863
862
* a potential bundle from being retried.
864
863
*/
865
-
sr->mshot_total_len -= min_t(int, *ret, sr->mshot_total_len);
864
+
sr->mshot_total_len -= min_t(int, sel->val, sr->mshot_total_len);
866
865
if (!sr->mshot_total_len) {
867
866
sr->flags |= IORING_RECV_MSHOT_DONE;
868
867
mshot_finished = true;
···
870
869
}
871
870
872
871
if (sr->flags & IORING_RECVSEND_BUNDLE) {
873
-
size_t this_ret = *ret - sr->done_io;
872
+
size_t this_ret = sel->val - sr->done_io;
874
873
875
874
cflags |= io_put_kbufs(req, this_ret, req->buf_list, io_bundle_nbufs(kmsg, this_ret));
876
875
if (sr->flags & IORING_RECV_RETRY)
877
876
cflags = req->cqe.flags | (cflags & CQE_F_MASK);
878
-
if (sr->mshot_len && *ret >= sr->mshot_len)
877
+
if (sr->mshot_len && sel->val >= sr->mshot_len)
879
878
sr->flags |= IORING_RECV_MSHOT_CAP;
880
879
/* bundle with no more immediate buffers, we're done */
881
880
if (req->flags & REQ_F_BL_EMPTY)
···
894
893
return false;
895
894
}
896
895
} else {
897
-
cflags |= io_put_kbuf(req, *ret, req->buf_list);
896
+
cflags |= io_put_kbuf(req, sel->val, req->buf_list);
898
897
}
899
898
900
899
/*
···
902
901
* receive from this socket.
903
902
*/
904
903
if ((req->flags & REQ_F_APOLL_MULTISHOT) && !mshot_finished &&
905
-
io_req_post_cqe(req, *ret, cflags | IORING_CQE_F_MORE)) {
906
-
*ret = IOU_RETRY;
904
+
io_req_post_cqe(req, sel->val, cflags | IORING_CQE_F_MORE)) {
905
+
sel->val = IOU_RETRY;
907
906
io_mshot_prep_retry(req, kmsg);
908
907
/* Known not-empty or unknown state, retry */
909
908
if (cflags & IORING_CQE_F_SOCK_NONEMPTY || kmsg->msg.msg_inq < 0) {
···
915
914
sr->nr_multishot_loops = 0;
916
915
sr->flags &= ~IORING_RECV_MSHOT_CAP;
917
916
if (issue_flags & IO_URING_F_MULTISHOT)
918
-
*ret = IOU_REQUEUE;
917
+
sel->val = IOU_REQUEUE;
919
918
}
920
919
return true;
921
920
}
922
921
923
922
/* Finish the request / stop multishot. */
924
923
finish:
925
-
io_req_set_res(req, *ret, cflags);
926
-
*ret = IOU_COMPLETE;
924
+
io_req_set_res(req, sel->val, cflags);
925
+
sel->val = IOU_COMPLETE;
927
926
io_req_msg_cleanup(req, issue_flags);
928
927
return true;
929
928
}
···
1093
1092
else
1094
1093
io_kbuf_recycle(req, req->buf_list, issue_flags);
1095
1094
1096
-
if (!io_recv_finish(req, &ret, kmsg, mshot_finished, issue_flags))
1095
+
sel.val = ret;
1096
+
if (!io_recv_finish(req, kmsg, &sel, mshot_finished, issue_flags))
1097
1097
goto retry_multishot;
1098
1098
1099
-
return ret;
1099
+
return sel.val;
1100
1100
}
1101
1101
1102
1102
static int io_recv_buf_select(struct io_kiocb *req, struct io_async_msghdr *kmsg,
···
1242
1240
else
1243
1241
io_kbuf_recycle(req, req->buf_list, issue_flags);
1244
1242
1245
-
if (!io_recv_finish(req, &ret, kmsg, mshot_finished, issue_flags))
1243
+
sel.val = ret;
1244
+
if (!io_recv_finish(req, kmsg, &sel, mshot_finished, issue_flags))
1246
1245
goto retry_multishot;
1247
1246
1248
-
return ret;
1247
+
return sel.val;
1249
1248
}
1250
1249
1251
1250
int io_recvzc_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)