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 is_mask[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
53 wait_for_var(&recv_thread_ready);
54
55 int s0 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
56 assert(s0 != -1);
57
58 struct sockaddr_in addr;
59
60 addr.sin_family = AF_INET;
61 addr.sin_port = data->port;
62 addr.sin_addr.s_addr = 0x0100007fU;
63
64 if (connect(s0, (struct sockaddr*)&addr, sizeof(addr)) != -1)
65 wait_for_var(&recv_thread_done);
66
67 close(s0);
68 return 0;
69 }
70
recv_thread(void * arg)71 void *recv_thread(void *arg)
72 {
73 struct data *data = arg;
74 struct io_uring_sqe *sqe;
75 struct io_uring ring;
76 int i, ret;
77
78 ret = io_uring_queue_init(8, &ring, 0);
79 assert(ret == 0);
80
81 int s0 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
82 assert(s0 != -1);
83
84 int32_t val = 1;
85 ret = setsockopt(s0, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val));
86 assert(ret != -1);
87 ret = setsockopt(s0, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
88 assert(ret != -1);
89
90 struct sockaddr_in addr;
91
92 addr.sin_family = AF_INET;
93 addr.sin_addr.s_addr = 0x0100007fU;
94
95 i = 0;
96 do {
97 data->port = 1025 + (rand() % 64510);
98 addr.sin_port = data->port;
99
100 if (bind(s0, (struct sockaddr*)&addr, sizeof(addr)) != -1)
101 break;
102 } while (++i < 100);
103
104 if (i >= 100) {
105 fprintf(stderr, "Can't find good port, skipped\n");
106 data->stop = 1;
107 signal_var(&recv_thread_ready);
108 goto out;
109 }
110
111 ret = listen(s0, 128);
112 assert(ret != -1);
113
114 signal_var(&recv_thread_ready);
115
116 sqe = io_uring_get_sqe(&ring);
117 assert(sqe != NULL);
118
119 io_uring_prep_poll_add(sqe, s0, POLLIN | POLLHUP | POLLERR);
120 sqe->flags |= IOSQE_IO_LINK;
121 sqe->user_data = 1;
122
123 sqe = io_uring_get_sqe(&ring);
124 assert(sqe != NULL);
125
126 struct __kernel_timespec ts;
127 ts.tv_sec = data->timeout / 1000000000;
128 ts.tv_nsec = data->timeout % 1000000000;
129 io_uring_prep_link_timeout(sqe, &ts, 0);
130 sqe->user_data = 2;
131
132 ret = io_uring_submit(&ring);
133 assert(ret == 2);
134
135 for (i = 0; i < 2; i++) {
136 struct io_uring_cqe *cqe;
137 int idx;
138
139 if (io_uring_wait_cqe(&ring, &cqe)) {
140 fprintf(stderr, "wait cqe failed\n");
141 goto err;
142 }
143 idx = cqe->user_data - 1;
144 if (data->is_mask[idx] && !(data->expected[idx] & cqe->res)) {
145 fprintf(stderr, "cqe %" PRIu64 " got %x, wanted mask %x\n",
146 (uint64_t) cqe->user_data, cqe->res,
147 data->expected[idx]);
148 goto err;
149 } else if (!data->is_mask[idx] && cqe->res != data->expected[idx]) {
150 fprintf(stderr, "cqe %" PRIu64 " got %d, wanted %d\n",
151 (uint64_t) cqe->user_data, cqe->res,
152 data->expected[idx]);
153 goto err;
154 }
155 io_uring_cqe_seen(&ring, cqe);
156 }
157
158 out:
159 signal_var(&recv_thread_done);
160 close(s0);
161 io_uring_queue_exit(&ring);
162 return NULL;
163 err:
164 signal_var(&recv_thread_done);
165 close(s0);
166 io_uring_queue_exit(&ring);
167 return (void *) 1;
168 }
169
test_poll_timeout(int do_connect,unsigned long timeout)170 static int test_poll_timeout(int do_connect, unsigned long timeout)
171 {
172 pthread_t t1, t2;
173 struct data d;
174 void *tret;
175 int ret = 0;
176
177 recv_thread_ready = 0;
178 recv_thread_done = 0;
179
180 memset(&d, 0, sizeof(d));
181 d.timeout = timeout;
182 if (!do_connect) {
183 d.expected[0] = -ECANCELED;
184 d.expected[1] = -ETIME;
185 } else {
186 d.expected[0] = POLLIN;
187 d.is_mask[0] = 1;
188 d.expected[1] = -ECANCELED;
189 }
190
191 pthread_create(&t1, NULL, recv_thread, &d);
192
193 if (do_connect)
194 pthread_create(&t2, NULL, send_thread, &d);
195
196 pthread_join(t1, &tret);
197 if (tret)
198 ret++;
199
200 if (do_connect) {
201 pthread_join(t2, &tret);
202 if (tret)
203 ret++;
204 }
205
206 return ret;
207 }
208
main(int argc,char * argv[])209 int main(int argc, char *argv[])
210 {
211 if (argc > 1)
212 return 0;
213
214 srand(getpid());
215
216 if (test_poll_timeout(0, 200000000)) {
217 fprintf(stderr, "poll timeout 0 failed\n");
218 return 1;
219 }
220
221 if (test_poll_timeout(1, 1000000000)) {
222 fprintf(stderr, "poll timeout 1 failed\n");
223 return 1;
224 }
225
226 return 0;
227 }
228