projects/linux·blob master · refs

448 lines · 10.1 KiB

1#include <errno.h>
2#include <error.h>
3#include <getopt.h>
4#include <stdbool.h>
5#include <stdio.h>
6#include <stdlib.h>
7#include <string.h>
8#include <unistd.h>
9
10#include <sys/time.h>
11#include <sys/socket.h>
12#include <sys/select.h>
13#include <sys/ioctl.h>
14#include <arpa/inet.h>
15#include <net/if.h>
16
17#include <asm/types.h>
18#include <linux/net_tstamp.h>
19#include <linux/errqueue.h>
20
21#include "kselftest.h"
22
23struct options {
24 int so_timestamp;
25 int so_timestampns;
26 int so_timestamping;
27};
28
29struct tstamps {
30 bool tstamp;
31 bool tstampns;
32 bool swtstamp;
33 bool hwtstamp;
34};
35
36struct socket_type {
37 char *friendly_name;
38 int type;
39 int protocol;
40 bool enabled;
41};
42
43struct test_case {
44 struct options sockopt;
45 struct tstamps expected;
46 bool enabled;
47 bool warn_on_fail;
48};
49
50struct sof_flag {
51 int mask;
52 char *name;
53};
54
55static struct sof_flag sof_flags[] = {
56#define SOF_FLAG(f) { f, #f }
57 SOF_FLAG(SOF_TIMESTAMPING_SOFTWARE),
58 SOF_FLAG(SOF_TIMESTAMPING_RX_SOFTWARE),
59 SOF_FLAG(SOF_TIMESTAMPING_RX_HARDWARE),
60 SOF_FLAG(SOF_TIMESTAMPING_OPT_RX_FILTER),
61 SOF_FLAG(SOF_TIMESTAMPING_RAW_HARDWARE),
62};
63
64static struct socket_type socket_types[] = {
65 { "ip", SOCK_RAW, IPPROTO_EGP },
66 { "udp", SOCK_DGRAM, IPPROTO_UDP },
67 { "tcp", SOCK_STREAM, IPPROTO_TCP },
68};
69
70static struct test_case test_cases[] = {
71 { {}, {} },
72 {
73 { .so_timestamp = 1 },
74 { .tstamp = true }
75 },
76 {
77 { .so_timestampns = 1 },
78 { .tstampns = true }
79 },
80 {
81 { .so_timestamp = 1, .so_timestampns = 1 },
82 { .tstampns = true }
83 },
84 {
85 { .so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE },
86 {}
87 },
88 {
89 /* Loopback device does not support hw timestamps. */
90 { .so_timestamping = SOF_TIMESTAMPING_RX_HARDWARE },
91 {}
92 },
93 {
94 { .so_timestamping = SOF_TIMESTAMPING_SOFTWARE },
95 .warn_on_fail = true
96 },
97 {
98 { .so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE
99 | SOF_TIMESTAMPING_RX_HARDWARE },
100 {}
101 },
102 {
103 { .so_timestamping = SOF_TIMESTAMPING_RAW_HARDWARE
104 | SOF_TIMESTAMPING_OPT_RX_FILTER },
105 {}
106 },
107 {
108 { .so_timestamping = SOF_TIMESTAMPING_SOFTWARE
109 | SOF_TIMESTAMPING_OPT_RX_FILTER },
110 {}
111 },
112 {
113 { .so_timestamping = SOF_TIMESTAMPING_SOFTWARE
114 | SOF_TIMESTAMPING_RX_SOFTWARE
115 | SOF_TIMESTAMPING_OPT_RX_FILTER },
116 { .swtstamp = true }
117 },
118 {
119 { .so_timestamping = SOF_TIMESTAMPING_SOFTWARE
120 | SOF_TIMESTAMPING_RX_SOFTWARE },
121 { .swtstamp = true }
122 },
123 {
124 { .so_timestamp = 1, .so_timestamping = SOF_TIMESTAMPING_SOFTWARE
125 | SOF_TIMESTAMPING_RX_SOFTWARE },
126 { .tstamp = true, .swtstamp = true }
127 },
128};
129
130static struct option long_options[] = {
131 { "list_tests", no_argument, 0, 'l' },
132 { "test_num", required_argument, 0, 'n' },
133 { "op_size", required_argument, 0, 's' },
134 { "tcp", no_argument, 0, 't' },
135 { "udp", no_argument, 0, 'u' },
136 { "ip", no_argument, 0, 'i' },
137 { "strict", no_argument, 0, 'S' },
138 { "ipv4", no_argument, 0, '4' },
139 { "ipv6", no_argument, 0, '6' },
140 { NULL, 0, NULL, 0 },
141};
142
143static int next_port = 19999;
144static int op_size = 10 * 1024;
145
146void print_test_case(struct test_case *t)
147{
148 int f = 0;
149
150 printf("sockopts {");
151 if (t->sockopt.so_timestamp)
152 printf(" SO_TIMESTAMP ");
153 if (t->sockopt.so_timestampns)
154 printf(" SO_TIMESTAMPNS ");
155 if (t->sockopt.so_timestamping) {
156 printf(" SO_TIMESTAMPING: {");
157 for (f = 0; f < ARRAY_SIZE(sof_flags); f++)
158 if (t->sockopt.so_timestamping & sof_flags[f].mask)
159 printf(" %s |", sof_flags[f].name);
160 printf("}");
161 }
162 printf("} expected cmsgs: {");
163 if (t->expected.tstamp)
164 printf(" SCM_TIMESTAMP ");
165 if (t->expected.tstampns)
166 printf(" SCM_TIMESTAMPNS ");
167 if (t->expected.swtstamp || t->expected.hwtstamp) {
168 printf(" SCM_TIMESTAMPING {");
169 if (t->expected.swtstamp)
170 printf("0");
171 if (t->expected.swtstamp && t->expected.hwtstamp)
172 printf(",");
173 if (t->expected.hwtstamp)
174 printf("2");
175 printf("}");
176 }
177 printf("}\n");
178}
179
180void do_send(int src)
181{
182 int r;
183 char *buf = malloc(op_size);
184
185 memset(buf, 'z', op_size);
186 r = write(src, buf, op_size);
187 if (r < 0)
188 error(1, errno, "Failed to sendmsg");
189
190 free(buf);
191}
192
193bool do_recv(int rcv, int read_size, struct tstamps expected)
194{
195 const int CMSG_SIZE = 1024;
196
197 struct scm_timestamping *ts;
198 struct tstamps actual = {};
199 char cmsg_buf[CMSG_SIZE];
200 struct iovec recv_iov;
201 struct cmsghdr *cmsg;
202 bool failed = false;
203 struct msghdr hdr;
204 int flags = 0;
205 int r;
206
207 memset(&hdr, 0, sizeof(hdr));
208 hdr.msg_iov = &recv_iov;
209 hdr.msg_iovlen = 1;
210 recv_iov.iov_base = malloc(read_size);
211 recv_iov.iov_len = read_size;
212
213 hdr.msg_control = cmsg_buf;
214 hdr.msg_controllen = sizeof(cmsg_buf);
215
216 r = recvmsg(rcv, &hdr, flags);
217 if (r < 0)
218 error(1, errno, "Failed to recvmsg");
219 if (r != read_size)
220 error(1, 0, "Only received %d bytes of payload.", r);
221
222 if (hdr.msg_flags & (MSG_TRUNC | MSG_CTRUNC))
223 error(1, 0, "Message was truncated.");
224
225 for (cmsg = CMSG_FIRSTHDR(&hdr); cmsg != NULL;
226 cmsg = CMSG_NXTHDR(&hdr, cmsg)) {
227 if (cmsg->cmsg_level != SOL_SOCKET)
228 error(1, 0, "Unexpected cmsg_level %d",
229 cmsg->cmsg_level);
230 switch (cmsg->cmsg_type) {
231 case SCM_TIMESTAMP:
232 actual.tstamp = true;
233 break;
234 case SCM_TIMESTAMPNS:
235 actual.tstampns = true;
236 break;
237 case SCM_TIMESTAMPING:
238 ts = (struct scm_timestamping *)CMSG_DATA(cmsg);
239 actual.swtstamp = !!ts->ts[0].tv_sec;
240 if (ts->ts[1].tv_sec != 0)
241 error(0, 0, "ts[1] should not be set.");
242 actual.hwtstamp = !!ts->ts[2].tv_sec;
243 break;
244 default:
245 error(1, 0, "Unexpected cmsg_type %d", cmsg->cmsg_type);
246 }
247 }
248
249#define VALIDATE(field) \
250 do { \
251 if (expected.field != actual.field) { \
252 if (expected.field) \
253 error(0, 0, "Expected " #field " to be set."); \
254 else \
255 error(0, 0, \
256 "Expected " #field " to not be set."); \
257 failed = true; \
258 } \
259 } while (0)
260
261 VALIDATE(tstamp);
262 VALIDATE(tstampns);
263 VALIDATE(swtstamp);
264 VALIDATE(hwtstamp);
265#undef VALIDATE
266
267 free(recv_iov.iov_base);
268
269 return failed;
270}
271
272void config_so_flags(int rcv, struct options o)
273{
274 int on = 1;
275
276 if (setsockopt(rcv, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
277 error(1, errno, "Failed to enable SO_REUSEADDR");
278
279 if (o.so_timestamp &&
280 setsockopt(rcv, SOL_SOCKET, SO_TIMESTAMP,
281 &o.so_timestamp, sizeof(o.so_timestamp)) < 0)
282 error(1, errno, "Failed to enable SO_TIMESTAMP");
283
284 if (o.so_timestampns &&
285 setsockopt(rcv, SOL_SOCKET, SO_TIMESTAMPNS,
286 &o.so_timestampns, sizeof(o.so_timestampns)) < 0)
287 error(1, errno, "Failed to enable SO_TIMESTAMPNS");
288
289 if (o.so_timestamping &&
290 setsockopt(rcv, SOL_SOCKET, SO_TIMESTAMPING,
291 &o.so_timestamping, sizeof(o.so_timestamping)) < 0)
292 error(1, errno, "Failed to set SO_TIMESTAMPING");
293}
294
295bool run_test_case(struct socket_type *s, int test_num, char ip_version,
296 bool strict)
297{
298 union {
299 struct sockaddr_in6 addr6;
300 struct sockaddr_in addr4;
301 struct sockaddr addr_un;
302 } addr;
303 int read_size = op_size;
304 int src, dst, rcv, port;
305 socklen_t addr_size;
306 bool failed = false;
307
308 port = (s->type == SOCK_RAW) ? 0 : next_port++;
309 memset(&addr, 0, sizeof(addr));
310 if (ip_version == '4') {
311 addr.addr4.sin_family = AF_INET;
312 addr.addr4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
313 addr.addr4.sin_port = htons(port);
314 addr_size = sizeof(addr.addr4);
315 if (s->type == SOCK_RAW)
316 read_size += 20; /* for IPv4 header */
317 } else {
318 addr.addr6.sin6_family = AF_INET6;
319 addr.addr6.sin6_addr = in6addr_loopback;
320 addr.addr6.sin6_port = htons(port);
321 addr_size = sizeof(addr.addr6);
322 }
323 printf("Starting testcase %d over ipv%c...\n", test_num, ip_version);
324 src = socket(addr.addr_un.sa_family, s->type,
325 s->protocol);
326 if (src < 0)
327 error(1, errno, "Failed to open src socket");
328
329 dst = socket(addr.addr_un.sa_family, s->type,
330 s->protocol);
331 if (dst < 0)
332 error(1, errno, "Failed to open dst socket");
333
334 if (bind(dst, &addr.addr_un, addr_size) < 0)
335 error(1, errno, "Failed to bind to port %d", port);
336
337 if (s->type == SOCK_STREAM && (listen(dst, 1) < 0))
338 error(1, errno, "Failed to listen");
339
340 if (connect(src, &addr.addr_un, addr_size) < 0)
341 error(1, errno, "Failed to connect");
342
343 if (s->type == SOCK_STREAM) {
344 rcv = accept(dst, NULL, NULL);
345 if (rcv < 0)
346 error(1, errno, "Failed to accept");
347 close(dst);
348 } else {
349 rcv = dst;
350 }
351
352 config_so_flags(rcv, test_cases[test_num].sockopt);
353 usleep(20000); /* setsockopt for SO_TIMESTAMPING is asynchronous */
354 do_send(src);
355
356 failed = do_recv(rcv, read_size, test_cases[test_num].expected);
357
358 close(rcv);
359 close(src);
360
361 if (failed) {
362 printf("FAILURE in testcase %d over ipv%c ", test_num,
363 ip_version);
364 print_test_case(&test_cases[test_num]);
365 if (!strict && test_cases[test_num].warn_on_fail)
366 failed = false;
367 }
368 return failed;
369}
370
371int main(int argc, char **argv)
372{
373 bool all_protocols = true;
374 bool all_tests = true;
375 bool cfg_ipv4 = false;
376 bool cfg_ipv6 = false;
377 bool strict = false;
378 int arg_index = 0;
379 int failures = 0;
380 int s, t, opt;
381
382 while ((opt = getopt_long(argc, argv, "", long_options,
383 &arg_index)) != -1) {
384 switch (opt) {
385 case 'l':
386 for (t = 0; t < ARRAY_SIZE(test_cases); t++) {
387 printf("%d\t", t);
388 print_test_case(&test_cases[t]);
389 }
390 return 0;
391 case 'n':
392 t = atoi(optarg);
393 if (t >= ARRAY_SIZE(test_cases))
394 error(1, 0, "Invalid test case: %d", t);
395 all_tests = false;
396 test_cases[t].enabled = true;
397 break;
398 case 's':
399 op_size = atoi(optarg);
400 break;
401 case 't':
402 all_protocols = false;
403 socket_types[2].enabled = true;
404 break;
405 case 'u':
406 all_protocols = false;
407 socket_types[1].enabled = true;
408 break;
409 case 'i':
410 all_protocols = false;
411 socket_types[0].enabled = true;
412 break;
413 case 'S':
414 strict = true;
415 break;
416 case '4':
417 cfg_ipv4 = true;
418 break;
419 case '6':
420 cfg_ipv6 = true;
421 break;
422 default:
423 error(1, 0, "Failed to parse parameters.");
424 }
425 }
426
427 for (s = 0; s < ARRAY_SIZE(socket_types); s++) {
428 if (!all_protocols && !socket_types[s].enabled)
429 continue;
430
431 printf("Testing %s...\n", socket_types[s].friendly_name);
432 for (t = 0; t < ARRAY_SIZE(test_cases); t++) {
433 if (!all_tests && !test_cases[t].enabled)
434 continue;
435 if (cfg_ipv4 || !cfg_ipv6)
436 if (run_test_case(&socket_types[s], t, '4',
437 strict))
438 failures++;
439 if (cfg_ipv6 || !cfg_ipv4)
440 if (run_test_case(&socket_types[s], t, '6',
441 strict))
442 failures++;
443 }
444 }
445 if (!failures)
446 printf("PASSED.\n");
447 return failures;
448}