1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * This program demonstrates how the various time stamping features in
4 * the Linux kernel work. It emulates the behavior of a PTP
5 * implementation in stand-alone master mode by sending PTPv1 Sync
6 * multicasts once every second. It looks for similar packets, but
7 * beyond that doesn't actually implement PTP.
8 *
9 * Outgoing packets are time stamped with SO_TIMESTAMPING with or
10 * without hardware support.
11 *
12 * Incoming packets are time stamped with SO_TIMESTAMPING with or
13 * without hardware support, SIOCGSTAMP[NS] (per-socket time stamp) and
14 * SO_TIMESTAMP[NS].
15 *
16 * Copyright (C) 2009 Intel Corporation.
17 * Author: Patrick Ohly <patrick.ohly@intel.com>
18 */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <errno.h>
23 #include <string.h>
24
25 #include <sys/time.h>
26 #include <sys/socket.h>
27 #include <sys/select.h>
28 #include <sys/ioctl.h>
29 #include <arpa/inet.h>
30 #include <net/if.h>
31
32 #include <asm/types.h>
33 #include <linux/net_tstamp.h>
34 #include <linux/errqueue.h>
35 #include <linux/sockios.h>
36
37 #ifndef SO_TIMESTAMPING
38 # define SO_TIMESTAMPING 37
39 # define SCM_TIMESTAMPING SO_TIMESTAMPING
40 #endif
41
42 #ifndef SO_TIMESTAMPNS
43 # define SO_TIMESTAMPNS 35
44 #endif
45
46 static void usage(const char *error)
47 {
48 if (error)
49 printf("invalid option: %s\n", error);
50 printf("timestamping <interface> [bind_phc_index] [option]*\n\n"
51 "Options:\n"
52 " IP_MULTICAST_LOOP - looping outgoing multicasts\n"
53 " SO_TIMESTAMP - normal software time stamping, ms resolution\n"
54 " SO_TIMESTAMPNS - more accurate software time stamping\n"
55 " SOF_TIMESTAMPING_TX_HARDWARE - hardware time stamping of outgoing packets\n"
56 " SOF_TIMESTAMPING_TX_SOFTWARE - software fallback for outgoing packets\n"
57 " SOF_TIMESTAMPING_RX_HARDWARE - hardware time stamping of incoming packets\n"
58 " SOF_TIMESTAMPING_RX_SOFTWARE - software fallback for incoming packets\n"
59 " SOF_TIMESTAMPING_SOFTWARE - request reporting of software time stamps\n"
60 " SOF_TIMESTAMPING_RAW_HARDWARE - request reporting of raw HW time stamps\n"
61 " SOF_TIMESTAMPING_BIND_PHC - request to bind a PHC of PTP vclock\n"
62 " SIOCGSTAMP - check last socket time stamp\n"
63 " SIOCGSTAMPNS - more accurate socket time stamp\n"
64 " PTPV2 - use PTPv2 messages\n");
65 exit(1);
66 }
67
68 static void bail(const char *error)
69 {
70 printf("%s: %s\n", error, strerror(errno));
71 exit(1);
72 }
73
74 static const unsigned char sync[] = {
75 0x00, 0x01, 0x00, 0x01,
76 0x5f, 0x44, 0x46, 0x4c,
77 0x54, 0x00, 0x00, 0x00,
78 0x00, 0x00, 0x00, 0x00,
79 0x00, 0x00, 0x00, 0x00,
80 0x01, 0x01,
81
82 /* fake uuid */
83 0x00, 0x01,
84 0x02, 0x03, 0x04, 0x05,
85
86 0x00, 0x01, 0x00, 0x37,
87 0x00, 0x00, 0x00, 0x08,
88 0x00, 0x00, 0x00, 0x00,
89 0x49, 0x05, 0xcd, 0x01,
90 0x29, 0xb1, 0x8d, 0xb0,
91 0x00, 0x00, 0x00, 0x00,
92 0x00, 0x01,
93
94 /* fake uuid */
95 0x00, 0x01,
96 0x02, 0x03, 0x04, 0x05,
97
98 0x00, 0x00, 0x00, 0x37,
99 0x00, 0x00, 0x00, 0x04,
100 0x44, 0x46, 0x4c, 0x54,
101 0x00, 0x00, 0xf0, 0x60,
102 0x00, 0x01, 0x00, 0x00,
103 0x00, 0x00, 0x00, 0x01,
104 0x00, 0x00, 0xf0, 0x60,
105 0x00, 0x00, 0x00, 0x00,
106 0x00, 0x00, 0x00, 0x04,
107 0x44, 0x46, 0x4c, 0x54,
108 0x00, 0x01,
109
110 /* fake uuid */
111 0x00, 0x01,
112 0x02, 0x03, 0x04, 0x05,
113
114 0x00, 0x00, 0x00, 0x00,
115 0x00, 0x00, 0x00, 0x00,
116 0x00, 0x00, 0x00, 0x00,
117 0x00, 0x00, 0x00, 0x00
118 };
119
120 static const unsigned char sync_v2[] = {
121 0x00, 0x02, 0x00, 0x2C,
122 0x00, 0x00, 0x02, 0x00,
123 0x00, 0x00, 0x00, 0x00,
124 0x00, 0x00, 0x00, 0x00,
125 0x00, 0x00, 0x00, 0x00,
126 0x00, 0x00, 0x00, 0xFF,
127 0xFE, 0x00, 0x00, 0x00,
128 0x00, 0x01, 0x00, 0x01,
129 0x00, 0x00, 0x00, 0x00,
130 0x00, 0x00, 0x00, 0x00,
131 0x00, 0x00, 0x00, 0x00,
132 };
133
134 static void sendpacket(int sock, struct sockaddr *addr, socklen_t addr_len, int ptpv2)
135 {
136 size_t sync_len = ptpv2 ? sizeof(sync_v2) : sizeof(sync);
137 const void *sync_p = ptpv2 ? sync_v2 : sync;
138 struct timeval now;
139 int res;
140
141 res = sendto(sock, sync_p, sync_len, 0, addr, addr_len);
142 gettimeofday(&now, 0);
143 if (res < 0)
144 printf("%s: %s\n", "send", strerror(errno));
145 else
146 printf("%ld.%06ld: sent %d bytes\n",
147 (long)now.tv_sec, (long)now.tv_usec,
148 res);
149 }
150
151 static void printpacket(struct msghdr *msg, int res,
152 char *data,
153 int sock, int recvmsg_flags,
154 int siocgstamp, int siocgstampns, int ptpv2)
155 {
156 struct sockaddr_in *from_addr = (struct sockaddr_in *)msg->msg_name;
157 size_t sync_len = ptpv2 ? sizeof(sync_v2) : sizeof(sync);
158 const void *sync_p = ptpv2 ? sync_v2 : sync;
159 struct cmsghdr *cmsg;
160 struct timeval tv;
161 struct timespec ts;
162 struct timeval now;
163
164 gettimeofday(&now, 0);
165
166 printf("%ld.%06ld: received %s data, %d bytes from %s, %zu bytes control messages\n",
167 (long)now.tv_sec, (long)now.tv_usec,
168 (recvmsg_flags & MSG_ERRQUEUE) ? "error" : "regular",
169 res,
170 inet_ntoa(from_addr->sin_addr),
171 msg->msg_controllen);
172 for (cmsg = CMSG_FIRSTHDR(msg);
173 cmsg;
174 cmsg = CMSG_NXTHDR(msg, cmsg)) {
175 printf(" cmsg len %zu: ", cmsg->cmsg_len);
176 switch (cmsg->cmsg_level) {
177 case SOL_SOCKET:
178 printf("SOL_SOCKET ");
179 switch (cmsg->cmsg_type) {
180 case SO_TIMESTAMP: {
181 struct timeval *stamp =
182 (struct timeval *)CMSG_DATA(cmsg);
183 printf("SO_TIMESTAMP %ld.%06ld",
184 (long)stamp->tv_sec,
185 (long)stamp->tv_usec);
186 break;
187 }
188 case SO_TIMESTAMPNS: {
189 struct timespec *stamp =
190 (struct timespec *)CMSG_DATA(cmsg);
191 printf("SO_TIMESTAMPNS %ld.%09ld",
192 (long)stamp->tv_sec,
193 (long)stamp->tv_nsec);
194 break;
195 }
196 case SO_TIMESTAMPING: {
197 struct timespec *stamp =
198 (struct timespec *)CMSG_DATA(cmsg);
199 printf("SO_TIMESTAMPING ");
200 printf("SW %ld.%09ld ",
201 (long)stamp->tv_sec,
202 (long)stamp->tv_nsec);
203 stamp++;
204 /* skip deprecated HW transformed */
205 stamp++;
206 printf("HW raw %ld.%09ld",
207 (long)stamp->tv_sec,
208 (long)stamp->tv_nsec);
209 break;
210 }
211 default:
212 printf("type %d", cmsg->cmsg_type);
213 break;
214 }
215 break;
216 case IPPROTO_IP:
217 printf("IPPROTO_IP ");
218 switch (cmsg->cmsg_type) {
219 case IP_RECVERR: {
220 struct sock_extended_err *err =
221 (struct sock_extended_err *)CMSG_DATA(cmsg);
222 printf("IP_RECVERR ee_errno '%s' ee_origin %d => %s",
223 strerror(err->ee_errno),
224 err->ee_origin,
225 #ifdef SO_EE_ORIGIN_TIMESTAMPING
226 err->ee_origin == SO_EE_ORIGIN_TIMESTAMPING ?
227 "bounced packet" : "unexpected origin"
228 #else
229 "probably SO_EE_ORIGIN_TIMESTAMPING"
230 #endif
231 );
232 if (res < sync_len)
233 printf(" => truncated data?!");
234 else if (!memcmp(sync_p, data + res - sync_len, sync_len))
235 printf(" => GOT OUR DATA BACK (HURRAY!)");
236 break;
237 }
238 case IP_PKTINFO: {
239 struct in_pktinfo *pktinfo =
240 (struct in_pktinfo *)CMSG_DATA(cmsg);
241 printf("IP_PKTINFO interface index %u",
242 pktinfo->ipi_ifindex);
243 break;
244 }
245 default:
246 printf("type %d", cmsg->cmsg_type);
247 break;
248 }
249 break;
250 default:
251 printf("level %d type %d",
252 cmsg->cmsg_level,
253 cmsg->cmsg_type);
254 break;
255 }
256 printf("\n");
257 }
258
259 if (siocgstamp) {
260 if (ioctl(sock, SIOCGSTAMP, &tv))
261 printf(" %s: %s\n", "SIOCGSTAMP", strerror(errno));
262 else
263 printf("SIOCGSTAMP %ld.%06ld\n",
264 (long)tv.tv_sec,
265 (long)tv.tv_usec);
266 }
267 if (siocgstampns) {
268 if (ioctl(sock, SIOCGSTAMPNS, &ts))
269 printf(" %s: %s\n", "SIOCGSTAMPNS", strerror(errno));
270 else
271 printf("SIOCGSTAMPNS %ld.%09ld\n",
272 (long)ts.tv_sec,
273 (long)ts.tv_nsec);
274 }
275 }
276
277 static void recvpacket(int sock, int recvmsg_flags,
278 int siocgstamp, int siocgstampns, int ptpv2)
279 {
280 char data[256];
281 struct msghdr msg;
282 struct iovec entry;
283 struct sockaddr_in from_addr;
284 struct {
285 struct cmsghdr cm;
286 char control[512];
287 } control;
288 int res;
289
290 memset(&msg, 0, sizeof(msg));
291 msg.msg_iov = &entry;
292 msg.msg_iovlen = 1;
293 entry.iov_base = data;
294 entry.iov_len = sizeof(data);
295 msg.msg_name = (caddr_t)&from_addr;
296 msg.msg_namelen = sizeof(from_addr);
297 msg.msg_control = &control;
298 msg.msg_controllen = sizeof(control);
299
300 res = recvmsg(sock, &msg, recvmsg_flags|MSG_DONTWAIT);
301 if (res < 0) {
302 printf("%s %s: %s\n",
303 "recvmsg",
304 (recvmsg_flags & MSG_ERRQUEUE) ? "error" : "regular",
305 strerror(errno));
306 } else {
307 printpacket(&msg, res, data,
308 sock, recvmsg_flags,
309 siocgstamp, siocgstampns, ptpv2);
310 }
311 }
312
313 int main(int argc, char **argv)
314 {
315 int so_timestamp = 0;
316 int so_timestampns = 0;
317 int siocgstamp = 0;
318 int siocgstampns = 0;
319 int ip_multicast_loop = 0;
320 int ptpv2 = 0;
321 char *interface;
322 int i;
323 int enabled = 1;
324 int sock;
325 struct ifreq device;
326 struct ifreq hwtstamp;
327 struct hwtstamp_config hwconfig, hwconfig_requested;
328 struct so_timestamping so_timestamping_get = { 0, 0 };
329 struct so_timestamping so_timestamping = { 0, 0 };
330 struct sockaddr_in addr;
331 struct ip_mreq imr;
332 struct in_addr iaddr;
333 int val;
334 socklen_t len;
335 struct timeval next;
336 size_t if_len;
337
338 if (argc < 2)
339 usage(0);
340 interface = argv[1];
341 if_len = strlen(interface);
342 if (if_len >= IFNAMSIZ) {
343 printf("interface name exceeds IFNAMSIZ\n");
344 exit(1);
345 }
346
347 if (argc >= 3 && sscanf(argv[2], "%d", &so_timestamping.bind_phc) == 1)
348 val = 3;
349 else
350 val = 2;
351
352 for (i = val; i < argc; i++) {
353 if (!strcasecmp(argv[i], "SO_TIMESTAMP"))
354 so_timestamp = 1;
355 else if (!strcasecmp(argv[i], "SO_TIMESTAMPNS"))
356 so_timestampns = 1;
357 else if (!strcasecmp(argv[i], "SIOCGSTAMP"))
358 siocgstamp = 1;
359 else if (!strcasecmp(argv[i], "SIOCGSTAMPNS"))
360 siocgstampns = 1;
361 else if (!strcasecmp(argv[i], "IP_MULTICAST_LOOP"))
362 ip_multicast_loop = 1;
363 else if (!strcasecmp(argv[i], "PTPV2"))
364 ptpv2 = 1;
365 else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_TX_HARDWARE"))
366 so_timestamping.flags |= SOF_TIMESTAMPING_TX_HARDWARE;
367 else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_TX_SOFTWARE"))
368 so_timestamping.flags |= SOF_TIMESTAMPING_TX_SOFTWARE;
369 else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_RX_HARDWARE"))
370 so_timestamping.flags |= SOF_TIMESTAMPING_RX_HARDWARE;
371 else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_RX_SOFTWARE"))
372 so_timestamping.flags |= SOF_TIMESTAMPING_RX_SOFTWARE;
373 else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_SOFTWARE"))
374 so_timestamping.flags |= SOF_TIMESTAMPING_SOFTWARE;
375 else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_RAW_HARDWARE"))
376 so_timestamping.flags |= SOF_TIMESTAMPING_RAW_HARDWARE;
377 else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_BIND_PHC"))
378 so_timestamping.flags |= SOF_TIMESTAMPING_BIND_PHC;
379 else
380 usage(argv[i]);
381 }
382
383 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
384 if (sock < 0)
385 bail("socket");
386
387 memset(&device, 0, sizeof(device));
388 memcpy(device.ifr_name, interface, if_len + 1);
389 if (ioctl(sock, SIOCGIFADDR, &device) < 0)
390 bail("getting interface IP address");
391
392 memset(&hwtstamp, 0, sizeof(hwtstamp));
393 memcpy(hwtstamp.ifr_name, interface, if_len + 1);
394 hwtstamp.ifr_data = (void *)&hwconfig;
395 memset(&hwconfig, 0, sizeof(hwconfig));
396 hwconfig.tx_type =
397 (so_timestamping.flags & SOF_TIMESTAMPING_TX_HARDWARE) ?
398 HWTSTAMP_TX_ON : HWTSTAMP_TX_OFF;
399 hwconfig.rx_filter =
400 (so_timestamping.flags & SOF_TIMESTAMPING_RX_HARDWARE) ?
401 ptpv2 ? HWTSTAMP_FILTER_PTP_V2_L4_SYNC :
402 HWTSTAMP_FILTER_PTP_V1_L4_SYNC : HWTSTAMP_FILTER_NONE;
403 hwconfig_requested = hwconfig;
404 if (ioctl(sock, SIOCSHWTSTAMP, &hwtstamp) < 0) {
405 if ((errno == EINVAL || errno == ENOTSUP) &&
406 hwconfig_requested.tx_type == HWTSTAMP_TX_OFF &&
407 hwconfig_requested.rx_filter == HWTSTAMP_FILTER_NONE)
408 printf("SIOCSHWTSTAMP: disabling hardware time stamping not possible\n");
409 else
410 bail("SIOCSHWTSTAMP");
411 }
412 printf("SIOCSHWTSTAMP: tx_type %d requested, got %d; rx_filter %d requested, got %d\n",
413 hwconfig_requested.tx_type, hwconfig.tx_type,
414 hwconfig_requested.rx_filter, hwconfig.rx_filter);
415
416 /* bind to PTP port */
417 addr.sin_family = AF_INET;
418 addr.sin_addr.s_addr = htonl(INADDR_ANY);
419 addr.sin_port = htons(319 /* PTP event port */);
420 if (bind(sock,
421 (struct sockaddr *)&addr,
422 sizeof(struct sockaddr_in)) < 0)
423 bail("bind");
424
425 if (setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, interface, if_len))
426 bail("bind device");
427
428 /* set multicast group for outgoing packets */
429 inet_aton("224.0.1.130", &iaddr); /* alternate PTP domain 1 */
430 addr.sin_addr = iaddr;
431 imr.imr_multiaddr.s_addr = iaddr.s_addr;
432 imr.imr_interface.s_addr =
433 ((struct sockaddr_in *)&device.ifr_addr)->sin_addr.s_addr;
434 if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
435 &imr.imr_interface.s_addr, sizeof(struct in_addr)) < 0)
436 bail("set multicast");
437
438 /* join multicast group, loop our own packet */
439 if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
440 &imr, sizeof(struct ip_mreq)) < 0)
441 bail("join multicast group");
442
443 if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP,
444 &ip_multicast_loop, sizeof(enabled)) < 0) {
445 bail("loop multicast");
446 }
447
448 /* set socket options for time stamping */
449 if (so_timestamp &&
450 setsockopt(sock, SOL_SOCKET, SO_TIMESTAMP,
451 &enabled, sizeof(enabled)) < 0)
452 bail("setsockopt SO_TIMESTAMP");
453
454 if (so_timestampns &&
455 setsockopt(sock, SOL_SOCKET, SO_TIMESTAMPNS,
456 &enabled, sizeof(enabled)) < 0)
457 bail("setsockopt SO_TIMESTAMPNS");
458
459 if (so_timestamping.flags &&
460 setsockopt(sock, SOL_SOCKET, SO_TIMESTAMPING, &so_timestamping,
461 sizeof(so_timestamping)) < 0)
462 bail("setsockopt SO_TIMESTAMPING");
463
464 /* request IP_PKTINFO for debugging purposes */
465 if (setsockopt(sock, SOL_IP, IP_PKTINFO,
466 &enabled, sizeof(enabled)) < 0)
467 printf("%s: %s\n", "setsockopt IP_PKTINFO", strerror(errno));
468
469 /* verify socket options */
470 len = sizeof(val);
471 if (getsockopt(sock, SOL_SOCKET, SO_TIMESTAMP, &val, &len) < 0)
472 printf("%s: %s\n", "getsockopt SO_TIMESTAMP", strerror(errno));
473 else
474 printf("SO_TIMESTAMP %d\n", val);
475
476 if (getsockopt(sock, SOL_SOCKET, SO_TIMESTAMPNS, &val, &len) < 0)
477 printf("%s: %s\n", "getsockopt SO_TIMESTAMPNS",
478 strerror(errno));
479 else
480 printf("SO_TIMESTAMPNS %d\n", val);
481
482 len = sizeof(so_timestamping_get);
483 if (getsockopt(sock, SOL_SOCKET, SO_TIMESTAMPING, &so_timestamping_get,
484 &len) < 0) {
485 printf("%s: %s\n", "getsockopt SO_TIMESTAMPING",
486 strerror(errno));
487 } else {
488 printf("SO_TIMESTAMPING flags %d, bind phc %d\n",
489 so_timestamping_get.flags, so_timestamping_get.bind_phc);
490 if (so_timestamping_get.flags != so_timestamping.flags ||
491 so_timestamping_get.bind_phc != so_timestamping.bind_phc)
492 printf(" not expected, flags %d, bind phc %d\n",
493 so_timestamping.flags, so_timestamping.bind_phc);
494 }
495
496 /* send packets forever every five seconds */
497 gettimeofday(&next, 0);
498 next.tv_sec = (next.tv_sec + 1) / 5 * 5;
499 next.tv_usec = 0;
500 while (1) {
501 struct timeval now;
502 struct timeval delta;
503 long delta_us;
504 int res;
505 fd_set readfs, errorfs;
506
507 gettimeofday(&now, 0);
508 delta_us = (long)(next.tv_sec - now.tv_sec) * 1000000 +
509 (long)(next.tv_usec - now.tv_usec);
510 if (delta_us > 0) {
511 /* continue waiting for timeout or data */
512 delta.tv_sec = delta_us / 1000000;
513 delta.tv_usec = delta_us % 1000000;
514
515 FD_ZERO(&readfs);
516 FD_ZERO(&errorfs);
517 FD_SET(sock, &readfs);
518 FD_SET(sock, &errorfs);
519 printf("%ld.%06ld: select %ldus\n",
520 (long)now.tv_sec, (long)now.tv_usec,
521 delta_us);
522 res = select(sock + 1, &readfs, 0, &errorfs, &delta);
523 gettimeofday(&now, 0);
524 printf("%ld.%06ld: select returned: %d, %s\n",
525 (long)now.tv_sec, (long)now.tv_usec,
526 res,
527 res < 0 ? strerror(errno) : "success");
528 if (res > 0) {
529 if (FD_ISSET(sock, &readfs))
530 printf("ready for reading\n");
531 if (FD_ISSET(sock, &errorfs))
532 printf("has error\n");
533 recvpacket(sock, 0,
534 siocgstamp,
535 siocgstampns, ptpv2);
536 recvpacket(sock, MSG_ERRQUEUE,
537 siocgstamp,
538 siocgstampns, ptpv2);
539 }
540 } else {
541 /* write one packet */
542 sendpacket(sock,
543 (struct sockaddr *)&addr,
544 sizeof(addr), ptpv2);
545 next.tv_sec += 5;
546 continue;
547 }
548 }
549
550 return 0;
551 }
552
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.