1 /* SPDX-License-Identifier: MIT */
2 #include <errno.h>
3 #include <stdio.h>
4 #include <unistd.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <fcntl.h>
8 #include <assert.h>
9 #include <pthread.h>
10 #include <sys/socket.h>
11 #include <netinet/tcp.h>
12 #include <netinet/in.h>
13 #include <poll.h>
14
15 #include "liburing.h"
16
17 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
18 pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
19
20 static int recv_thread_ready = 0;
21 static int recv_thread_done = 0;
22
signal_var(int * var)23 static void signal_var(int *var)
24 {
25 pthread_mutex_lock(&mutex);
26 *var = 1;
27 pthread_cond_signal(&cond);
28 pthread_mutex_unlock(&mutex);
29 }
30
wait_for_var(int * var)31 static void wait_for_var(int *var)
32 {
33 pthread_mutex_lock(&mutex);
34
35 while (!*var)
36 pthread_cond_wait(&cond, &mutex);
37
38 pthread_mutex_unlock(&mutex);
39 }
40
41 struct data {
42 unsigned expected[2];
43 unsigned just_positive[2];
44 unsigned long timeout;
45 int port;
46 int stop;
47 };
48
send_thread(void * arg)49 static void *send_thread(void *arg)
50 {
51 struct data *data = arg;
52 int ret;
53
54 wait_for_var(&recv_thread_ready);
55
56 if (data->stop)
57 return NULL;
58
59 int s0 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
60 assert(s0 != -1);
61
62 struct sockaddr_in addr;
63
64 addr.sin_family = AF_INET;
65 addr.sin_port = data->port;
66 addr.sin_addr.s_addr = 0x0100007fU;
67
68 ret = connect(s0, (struct sockaddr*)&addr, sizeof(addr));
69 assert(ret != -1);
70
71 wait_for_var(&recv_thread_done);
72
73 close(s0);
74 return NULL;
75 }
76
recv_thread(void * arg)77 void *recv_thread(void *arg)
78 {
79 struct data *data = arg;
80 struct io_uring ring;
81 int i, ret;
82
83 ret = io_uring_queue_init(8, &ring, 0);
84 assert(ret == 0);
85
86 int s0 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
87 assert(s0 != -1);
88
89 int32_t val = 1;
90 ret = setsockopt(s0, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val));
91 assert(ret != -1);
92 ret = setsockopt(s0, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
93 assert(ret != -1);
94
95 struct sockaddr_in addr;
96
97 addr.sin_family = AF_INET;
98 addr.sin_addr.s_addr = 0x0100007fU;
99
100 i = 0;
101 do {
102 data->port = 1025 + (rand() % 64510);
103 addr.sin_port = data->port;
104
105 if (bind(s0, (struct sockaddr*)&addr, sizeof(addr)) != -1)
106 break;
107 } while (++i < 100);
108
109 if (i >= 100) {
110 printf("Can't find good port, skipped\n");
111 data->stop = 1;
112 signal_var(&recv_thread_ready);
113 goto out;
114 }
115
116 ret = listen(s0, 128);
117 assert(ret != -1);
118
119 signal_var(&recv_thread_ready);
120
121 struct io_uring_sqe *sqe;
122
123 sqe = io_uring_get_sqe(&ring);
124 assert(sqe != NULL);
125
126 io_uring_prep_accept(sqe, s0, NULL, NULL, 0);
127 sqe->flags |= IOSQE_IO_LINK;
128 sqe->user_data = 1;
129
130 sqe = io_uring_get_sqe(&ring);
131 assert(sqe != NULL);
132
133 struct __kernel_timespec ts;
134 ts.tv_sec = data->timeout / 1000000000;
135 ts.tv_nsec = data->timeout % 1000000000;
136 io_uring_prep_link_timeout(sqe, &ts, 0);
137 sqe->user_data = 2;
138
139 ret = io_uring_submit(&ring);
140 assert(ret == 2);
141
142 for (i = 0; i < 2; i++) {
143 struct io_uring_cqe *cqe;
144 int idx;
145
146 if (io_uring_wait_cqe(&ring, &cqe)) {
147 fprintf(stderr, "wait cqe failed\n");
148 goto err;
149 }
150 idx = cqe->user_data - 1;
151 if (cqe->res != data->expected[idx]) {
152 if (cqe->res > 0 && data->just_positive[idx])
153 goto ok;
154 if (cqe->res == -EBADF) {
155 fprintf(stdout, "Accept not supported, skipping\n");
156 data->stop = 1;
157 goto out;
158 }
159 fprintf(stderr, "cqe %" PRIu64 " got %d, wanted %d\n",
160 (uint64_t) cqe->user_data, cqe->res,
161 data->expected[idx]);
162 goto err;
163 }
164 ok:
165 if (cqe->user_data == 1 && cqe->res > 0)
166 close(cqe->res);
167
168 io_uring_cqe_seen(&ring, cqe);
169 }
170
171 signal_var(&recv_thread_done);
172
173 out:
174 close(s0);
175 return NULL;
176 err:
177 close(s0);
178 return (void *) 1;
179 }
180
test_accept_timeout(int do_connect,unsigned long timeout)181 static int test_accept_timeout(int do_connect, unsigned long timeout)
182 {
183 struct io_uring ring;
184 struct io_uring_params p = {};
185 pthread_t t1, t2;
186 struct data d;
187 void *tret;
188 int ret, fast_poll;
189
190 ret = io_uring_queue_init_params(1, &ring, &p);
191 if (ret) {
192 fprintf(stderr, "queue_init: %d\n", ret);
193 return 1;
194 };
195
196 fast_poll = (p.features & IORING_FEAT_FAST_POLL) != 0;
197 io_uring_queue_exit(&ring);
198
199 recv_thread_ready = 0;
200 recv_thread_done = 0;
201
202 memset(&d, 0, sizeof(d));
203 d.timeout = timeout;
204 if (!do_connect) {
205 if (fast_poll) {
206 d.expected[0] = -ECANCELED;
207 d.expected[1] = -ETIME;
208 } else {
209 d.expected[0] = -EINTR;
210 d.expected[1] = -EALREADY;
211 }
212 } else {
213 d.expected[0] = -1U;
214 d.just_positive[0] = 1;
215 d.expected[1] = -ECANCELED;
216 }
217
218 pthread_create(&t1, NULL, recv_thread, &d);
219
220 if (do_connect)
221 pthread_create(&t2, NULL, send_thread, &d);
222
223 pthread_join(t1, &tret);
224 if (tret)
225 ret++;
226
227 if (do_connect) {
228 pthread_join(t2, &tret);
229 if (tret)
230 ret++;
231 }
232
233 return ret;
234 }
235
main(int argc,char * argv[])236 int main(int argc, char *argv[])
237 {
238 if (argc > 1)
239 return 0;
240 if (test_accept_timeout(0, 200000000)) {
241 fprintf(stderr, "accept timeout 0 failed\n");
242 return 1;
243 }
244
245 if (test_accept_timeout(1, 1000000000)) {
246 fprintf(stderr, "accept and connect timeout 0 failed\n");
247 return 1;
248 }
249
250 return 0;
251 }
252