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