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