The existing interfaces for getting network packages time stamped are:* SO_TIMESTAMP Generate time stamp for each incoming packet using the (not necessarily monotonous!) system time. Result is returned via recv_msg() in a control message as timeval (usec resolution).* SO_TIMESTAMPNS Same time stamping mechanism as SO_TIMESTAMP, but returns result as timespec (nsec resolution).* IP_MULTICAST_LOOP + SO_TIMESTAMP[NS] Only for multicasts: approximate send time stamp by receiving the looped packet and using its receive time stamp.The following interface complements the existing ones: receive timestamps can be generated and returned for arbitrary packets and muchcloser to the point where the packet is really sent. Time stamps canbe generated in software (as before) or in hardware (if the hardwarehas such a feature).SO_TIMESTAMPING:Instructs the socket layer which kind of information is wanted. Theparameter is an integer with some of the following bits set. Settingother bits is an error and doesn't change the current state.SOF_TIMESTAMPING_TX_HARDWARE: try to obtain send time stamp in hardwareSOF_TIMESTAMPING_TX_SOFTWARE: if SOF_TIMESTAMPING_TX_HARDWARE is off or fails, then do it in softwareSOF_TIMESTAMPING_RX_HARDWARE: return the original, unmodified time stamp as generated by the hardwareSOF_TIMESTAMPING_RX_SOFTWARE: if SOF_TIMESTAMPING_RX_HARDWARE is off or fails, then do it in softwareSOF_TIMESTAMPING_RAW_HARDWARE: return original raw hardware time stampSOF_TIMESTAMPING_SYS_HARDWARE: return hardware time stamp transformed to the system time baseSOF_TIMESTAMPING_SOFTWARE: return system time stamp generated in softwareSOF_TIMESTAMPING_TX/RX determine how time stamps are generated.SOF_TIMESTAMPING_RAW/SYS determine how they are reported in thefollowing control message:struct scm_timestamping {struct timespec systime;struct timespec hwtimetrans;struct timespec hwtimeraw;};recvmsg() can be used to get this control message for regular incomingpackets. For send time stamps the outgoing packet is looped back tothe socket's error queue with the send time stamp(s) attached. It canbe received with recvmsg(flags=MSG_ERRQUEUE). The call returns theoriginal outgoing packet data including all headers preprended down toand including the link layer, the scm_timestamping control message anda sock_extended_err control message with ee_errno==ENOMSG andee_origin==SO_EE_ORIGIN_TIMESTAMPING. A socket with such a pendingbounced packet is ready for reading as far as select() is concerned.If the outgoing packet has to be fragmented, then only the firstfragment is time stamped and returned to the sending socket.All three values correspond to the same event in time, but weregenerated in different ways. Each of these values may be empty (= allzero), in which case no such value was available. If the applicationis not interested in some of these values, they can be left blank toavoid the potential overhead of calculating them.systime is the value of the system time at that moment. Thiscorresponds to the value also returned via SO_TIMESTAMP[NS]. If thetime stamp was generated by hardware, then this field isempty. Otherwise it is filled in if SOF_TIMESTAMPING_SOFTWARE isset.hwtimeraw is the original hardware time stamp. Filled in ifSOF_TIMESTAMPING_RAW_HARDWARE is set. No assumptions about itsrelation to system time should be made.hwtimetrans is the hardware time stamp transformed so that itcorresponds as good as possible to system time. This correlation isnot perfect; as a consequence, sorting packets received via differentNICs by their hwtimetrans may differ from the order in which they werereceived. hwtimetrans may be non-monotonic even for the same NIC.Filled in if SOF_TIMESTAMPING_SYS_HARDWARE is set. Requires supportby the network device and will be empty without that support.SIOCSHWTSTAMP:Hardware time stamping must also be initialized for each device driverthat is expected to do hardware time stamping. The parameter is defined in/include/linux/net_tstamp.h as:struct hwtstamp_config {int flags;/** no flags defined right now, must be zero */int tx_type;/** HWTSTAMP_TX_* */int rx_filter;/** HWTSTAMP_FILTER_* */};Desired behavior is passed into the kernel and to a specific device bycalling ioctl(SIOCSHWTSTAMP) with a pointer to a struct ifreq whoseifr_data points to a struct hwtstamp_config. The tx_type andrx_filter are hints to the driver what it is expected to do. Ifthe requested fine-grained filtering for incoming packets is notsupported, the driver may time stamp more than just the requested typesof packets.A driver which supports hardware time stamping shall update the structwith the actual, possibly more permissive configuration. If therequested packets cannot be time stamped, then nothing should bechanged and ERANGE shall be returned (in contrast to EINVAL, whichindicates that SIOCSHWTSTAMP is not supported at all).Only a processes with admin rights may change the configuration. Userspace is responsible to ensure that multiple processes don't interferewith each other and that the settings are reset./** possible values for hwtstamp_config->tx_type */enum {/** * no outgoing packet will need hardware time stamping; * should a packet arrive which asks for it, no hardware * time stamping will be done */HWTSTAMP_TX_OFF,/** * enables hardware time stamping for outgoing packets; * the sender of the packet decides which are to be * time stamped by setting SOF_TIMESTAMPING_TX_SOFTWARE * before sending the packet */HWTSTAMP_TX_ON,};/** possible values for hwtstamp_config->rx_filter */enum {/** time stamp no incoming packet at all */HWTSTAMP_FILTER_NONE,/** time stamp any incoming packet */HWTSTAMP_FILTER_ALL,/** return value: time stamp all packets requested plus some others */HWTSTAMP_FILTER_SOME,/** PTP v1, UDP, any kind of event packet */HWTSTAMP_FILTER_PTP_V1_L4_EVENT,/** for the complete list of values, please check * the include file /include/linux/net_tstamp.h */};DEVICE IMPLEMENTATIONA driver which supports hardware time stamping must support theSIOCSHWTSTAMP ioctl and update the supplied struct hwtstamp_config withthe actual values as described in the section on SIOCSHWTSTAMP.Time stamps for received packets must be stored in the skb. To get a pointerto the shared time stamp structure of the skb call skb_hwtstamps(). Thenset the time stamps in the structure:struct skb_shared_hwtstamps {/** hardware time stamp transformed into duration * since arbitrary point in time */ktime_thwtstamp;ktime_tsyststamp; /** hwtstamp transformed to system time base */};Time stamps for outgoing packets are to be generated as follows:- In hard_start_xmit(), check if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) is set no-zero. If yes, then the driver is expected to do hardware time stamping.- If this is possible for the skb and requested, then declare that the driver is doing the time stamping by setting the flag SKBTX_IN_PROGRESS in skb_shinfo(skb)->tx_flags , e.g. with skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS; You might want to keep a pointer to the associated skb for the next step and not free the skb. A driver not supporting hardware time stamping doesn't do that. A driver must never touch sk_buff::tstamp! It is used to store software generated time stamps by the network subsystem.- As soon as the driver has sent the packet and/or obtained a hardware time stamp for it, it passes the time stamp back by calling skb_hwtstamp_tx() with the original skb, the raw hardware time stamp. skb_hwtstamp_tx() clones the original skb and adds the timestamps, therefore the original skb has to be freed now. If obtaining the hardware time stamp somehow fails, then the driver should not fall back to software time stamping. The rationale is that this would occur at a later time in the processing pipeline than other software time stamping and therefore could lead to unexpected deltas between time stamps.- If the driver did not set the SKBTX_IN_PROGRESS flag (see above), then dev_hard_start_xmit() checks whether software time stamping is wanted as fallback and potentially generates the time stamp./* * This program demonstrates how the various time stamping features in * the Linux kernel work. It emulates the behavior of a PTP * implementation in stand-alone master mode by sending PTPv1 Sync * multicasts once every second. It looks for similar packets, but * beyond that doesn't actually implement PTP. * * Outgoing packets are time stamped with SO_TIMESTAMPING with or * without hardware support. * * Incoming packets are time stamped with SO_TIMESTAMPING with or * without hardware support, SIOCGSTAMP[NS] (per-socket time stamp) and * SO_TIMESTAMP[NS]. * * Copyright (C) 2009 Intel Corporation. * Author: Patrick Ohly <patrick.ohly@intel.com> * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, * version 2, as published by the Free Software Foundation. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. */#include <stdio.h>#include <stdlib.h>#include <errno.h>#include <string.h>#include <sys/time.h>#include <sys/socket.h>#include <sys/select.h>#include <sys/ioctl.h>#include <arpa/inet.h>#include <net/if.h>#include "asm/types.h"#include "linux/net_tstamp.h"#include "linux/errqueue.h"#ifndef SO_TIMESTAMPING# define SO_TIMESTAMPING 37# define SCM_TIMESTAMPING SO_TIMESTAMPING#endif#ifndef SO_TIMESTAMPNS# define SO_TIMESTAMPNS 35#endif#ifndef SIOCGSTAMPNS# define SIOCGSTAMPNS 0x8907#endif#ifndef SIOCSHWTSTAMP# define SIOCSHWTSTAMP 0x89b0#endifstatic void usage(const char *error){if (error)printf("invalid option: %s\n", error);printf("timestamping interface option*\n\n" "Options:\n" " IP_MULTICAST_LOOP - looping outgoing multicasts\n" " SO_TIMESTAMP - normal software time stamping, ms resolution\n" " SO_TIMESTAMPNS - more accurate software time stamping\n" " SOF_TIMESTAMPING_TX_HARDWARE - hardware time stamping of outgoing packets\n" " SOF_TIMESTAMPING_TX_SOFTWARE - software fallback for outgoing packets\n" " SOF_TIMESTAMPING_RX_HARDWARE - hardware time stamping of incoming packets\n" " SOF_TIMESTAMPING_RX_SOFTWARE - software fallback for incoming packets\n" " SOF_TIMESTAMPING_SOFTWARE - request reporting of software time stamps\n" " SOF_TIMESTAMPING_SYS_HARDWARE - request reporting of transformed HW time stamps\n" " SOF_TIMESTAMPING_RAW_HARDWARE - request reporting of raw HW time stamps\n" " SIOCGSTAMP - check last socket time stamp\n" " SIOCGSTAMPNS - more accurate socket time stamp\n");exit(1);}static void bail(const char *error){printf("%s: %s\n", error, strerror(errno));exit(1);}static const unsigned char sync[] = {0x00, 0x01, 0x00, 0x01,0x5f, 0x44, 0x46, 0x4c,0x54, 0x00, 0x00, 0x00,0x00, 0x00, 0x00, 0x00,0x00, 0x00, 0x00, 0x00,0x01, 0x01,/* fake uuid */0x00, 0x01,0x02, 0x03, 0x04, 0x05,0x00, 0x01, 0x00, 0x37,0x00, 0x00, 0x00, 0x08,0x00, 0x00, 0x00, 0x00,0x49, 0x05, 0xcd, 0x01,0x29, 0xb1, 0x8d, 0xb0,0x00, 0x00, 0x00, 0x00,0x00, 0x01,/* fake uuid */0x00, 0x01,0x02, 0x03, 0x04, 0x05,0x00, 0x00, 0x00, 0x37,0x00, 0x00, 0x00, 0x04,0x44, 0x46, 0x4c, 0x54,0x00, 0x00, 0xf0, 0x60,0x00, 0x01, 0x00, 0x00,0x00, 0x00, 0x00, 0x01,0x00, 0x00, 0xf0, 0x60,0x00, 0x00, 0x00, 0x00,0x00, 0x00, 0x00, 0x04,0x44, 0x46, 0x4c, 0x54,0x00, 0x01,/* fake uuid */0x00, 0x01,0x02, 0x03, 0x04, 0x05,0x00, 0x00, 0x00, 0x00,0x00, 0x00, 0x00, 0x00,0x00, 0x00, 0x00, 0x00,0x00, 0x00, 0x00, 0x00};static void sendpacket(int sock, struct sockaddr *addr, socklen_t addr_len){struct timeval now;int res;res = sendto(sock, sync, sizeof(sync), 0,addr, addr_len);gettimeofday(&now, 0);if (res < 0)printf("%s: %s\n", "send", strerror(errno));elseprintf("%ld.%06ld: sent %d bytes\n", (long)now.tv_sec, (long)now.tv_usec, res);}static void printpacket(struct msghdr *msg, int res,char *data,int sock, int recvmsg_flags,int siocgstamp, int siocgstampns){struct sockaddr_in *from_addr = (struct sockaddr_in *)msg->msg_name;struct cmsghdr *cmsg;struct timeval tv;struct timespec ts;struct timeval now;gettimeofday(&now, 0);printf("%ld.%06ld: received %s data, %d bytes from %s, %d bytes control messages\n", (long)now.tv_sec, (long)now.tv_usec, (recvmsg_flags & MSG_ERRQUEUE) ? "error" : "regular", res, inet_ntoa(from_addr->sin_addr), msg->msg_controllen);for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {printf(" cmsg len %d: ", cmsg->cmsg_len);switch (cmsg->cmsg_level) {case SOL_SOCKET:printf("SOL_SOCKET ");switch (cmsg->cmsg_type) {case SO_TIMESTAMP: {struct timeval *stamp =(struct timeval *)CMSG_DATA(cmsg);printf("SO_TIMESTAMP %ld.%06ld", (long)stamp->tv_sec, (long)stamp->tv_usec);break;}case SO_TIMESTAMPNS: {struct timespec *stamp =(struct timespec *)CMSG_DATA(cmsg);printf("SO_TIMESTAMPNS %ld.%09ld", (long)stamp->tv_sec, (long)stamp->tv_nsec);break;}case SO_TIMESTAMPING: {struct timespec *stamp =(struct timespec *)CMSG_DATA(cmsg);printf("SO_TIMESTAMPING ");printf("SW %ld.%09ld ", (long)stamp->tv_sec, (long)stamp->tv_nsec);stamp++;printf("HW transformed %ld.%09ld ", (long)stamp->tv_sec, (long)stamp->tv_nsec);stamp++;printf("HW raw %ld.%09ld", (long)stamp->tv_sec, (long)stamp->tv_nsec);break;}default:printf("type %d", cmsg->cmsg_type);break;}break;case IPPROTO_IP:printf("IPPROTO_IP ");switch (cmsg->cmsg_type) {case IP_RECVERR: {struct sock_extended_err *err =(struct sock_extended_err *)CMSG_DATA(cmsg);printf("IP_RECVERR ee_errno '%s' ee_origin %d => %s",strerror(err->ee_errno),err->ee_origin,#ifdef SO_EE_ORIGIN_TIMESTAMPINGerr->ee_origin == SO_EE_ORIGIN_TIMESTAMPING ?"bounced packet" : "unexpected origin"#else"probably SO_EE_ORIGIN_TIMESTAMPING"#endif);if (res < sizeof(sync))printf(" => truncated data?!");else if (!memcmp(sync, data + res - sizeof(sync),sizeof(sync)))printf(" => GOT OUR DATA BACK (HURRAY!)");break;}case IP_PKTINFO: {struct in_pktinfo *pktinfo =(struct in_pktinfo *)CMSG_DATA(cmsg);printf("IP_PKTINFO interface index %u",pktinfo->ipi_ifindex);break;}default:printf("type %d", cmsg->cmsg_type);break;}break;default:printf("level %d type %d",cmsg->cmsg_level,cmsg->cmsg_type);break;}printf("\n");}if (siocgstamp) {if (ioctl(sock, SIOCGSTAMP, &tv))printf(" %s: %s\n", "SIOCGSTAMP", strerror(errno));elseprintf("SIOCGSTAMP %ld.%06ld\n", (long)tv.tv_sec, (long)tv.tv_usec);}if (siocgstampns) {if (ioctl(sock, SIOCGSTAMPNS, &ts))printf(" %s: %s\n", "SIOCGSTAMPNS", strerror(errno));elseprintf("SIOCGSTAMPNS %ld.%09ld\n", (long)ts.tv_sec, (long)ts.tv_nsec);}}static void recvpacket(int sock, int recvmsg_flags, int siocgstamp, int siocgstampns){char data[256];struct msghdr msg;struct iovec entry;struct sockaddr_in from_addr;struct {struct cmsghdr cm;char control[512];} control;int res;memset(&msg, 0, sizeof(msg));msg.msg_iov = &entry;msg.msg_iovlen = 1;entry.iov_base = data;entry.iov_len = sizeof(data);msg.msg_name = (caddr_t)&from_addr;msg.msg_namelen = sizeof(from_addr);msg.msg_control = &control;msg.msg_controllen = sizeof(control);res = recvmsg(sock, &msg, recvmsg_flags|MSG_DONTWAIT);if (res < 0) {printf("%s %s: %s\n", "recvmsg", (recvmsg_flags & MSG_ERRQUEUE) ? "error" : "regular", strerror(errno));} else {printpacket(&msg, res, data, sock, recvmsg_flags, siocgstamp, siocgstampns);}}int main(int argc, char **argv){int so_timestamping_flags = 0;int so_timestamp = 0;int so_timestampns = 0;int siocgstamp = 0;int siocgstampns = 0;int ip_multicast_loop = 0;char *interface;int i;int enabled = 1;int sock;struct ifreq device;struct ifreq hwtstamp;struct hwtstamp_config hwconfig, hwconfig_requested;struct sockaddr_in addr;struct ip_mreq imr;struct in_addr iaddr;int val;socklen_t len;struct timeval next;so_timestamping_flags = SOF_TIMESTAMPING_TX_HARDWARE;interface = strdup("wru1");sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);if (socket < 0)bail("socket");memset(&device, 0, sizeof(device));strncpy(device.ifr_name, interface, sizeof(device.ifr_name));if (ioctl(sock, SIOCGIFADDR, &device) < 0)bail("getting interface IP address");memset(&hwtstamp, 0, sizeof(hwtstamp));strncpy(hwtstamp.ifr_name, interface, sizeof(hwtstamp.ifr_name));hwtstamp.ifr_data = (void *)&hwconfig;memset(&hwconfig, 0, sizeof(&hwconfig));hwconfig.tx_type = HWTSTAMP_TX_ON;hwconfig.rx_filter = HWTSTAMP_FILTER_NONE;hwconfig_requested = hwconfig;if (ioctl(sock, SIOCSHWTSTAMP, &hwtstamp) < 0) {bail("SIOCSHWTSTAMP");}/* bind to PTP port */addr.sin_family = AF_INET;addr.sin_addr.s_addr = htonl(INADDR_ANY);addr.sin_port = htons(319 /* PTP event port */);if (bind(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0)bail("bind");inet_aton("224.0.1.130", &iaddr); addr.sin_addr = iaddr;imr.imr_multiaddr.s_addr = iaddr.s_addr;imr.imr_interface.s_addr =((struct sockaddr_in *)&device.ifr_addr)->sin_addr.s_addr;if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF, &imr.imr_interface.s_addr, sizeof(struct in_addr)) < 0)bail("set multicast");/*if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, &imr, sizeof(struct ip_mreq)) < 0)bail("join multicast group");if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP, &ip_multicast_loop, sizeof(enabled)) < 0) {bail("loop multicast");}*//* set socket options for time stamping */if (so_timestamp &&setsockopt(sock, SOL_SOCKET, SO_TIMESTAMP, &enabled, sizeof(enabled)) < 0)bail("setsockopt SO_TIMESTAMP");if (so_timestampns &&setsockopt(sock, SOL_SOCKET, SO_TIMESTAMPNS, &enabled, sizeof(enabled)) < 0)bail("setsockopt SO_TIMESTAMPNS");if (so_timestamping_flags &&setsockopt(sock, SOL_SOCKET, SO_TIMESTAMPING, &so_timestamping_flags, sizeof(so_timestamping_flags)) < 0)bail("setsockopt SO_TIMESTAMPING");/* request IP_PKTINFO for debugging purposes *//*if (setsockopt(sock, SOL_IP, IP_PKTINFO, &enabled, sizeof(enabled)) < 0)printf("%s: %s\n", "setsockopt IP_PKTINFO", strerror(errno));len = sizeof(val);if (getsockopt(sock, SOL_SOCKET, SO_TIMESTAMP, &val, &len) < 0)printf("%s: %s\n", "getsockopt SO_TIMESTAMP", strerror(errno));elseprintf("SO_TIMESTAMP %d\n", val);if (getsockopt(sock, SOL_SOCKET, SO_TIMESTAMPNS, &val, &len) < 0)printf("%s: %s\n", "getsockopt SO_TIMESTAMPNS", strerror(errno));elseprintf("SO_TIMESTAMPNS %d\n", val);if (getsockopt(sock, SOL_SOCKET, SO_TIMESTAMPING, &val, &len) < 0) {printf("%s: %s\n", "getsockopt SO_TIMESTAMPING", strerror(errno));} else {printf("SO_TIMESTAMPING %d\n", val);if (val != so_timestamping_flags)printf(" not the expected value %d\n", so_timestamping_flags);}*//* send packets forever every five seconds */gettimeofday(&next, 0);next.tv_sec = (next.tv_sec + 1) / 5 * 5;next.tv_usec = 0;while (1) {struct timeval now;struct timeval delta;long delta_us;int res;fd_set readfs, errorfs;gettimeofday(&now, 0);delta_us = (long)(next.tv_sec - now.tv_sec) * 1000000 +(long)(next.tv_usec - now.tv_usec);if (delta_us > 0) {/* continue waiting for timeout or data */delta.tv_sec = delta_us / 1000000;delta.tv_usec = delta_us % 1000000;FD_ZERO(&readfs);FD_ZERO(&errorfs);FD_SET(sock, &readfs);FD_SET(sock, &errorfs);printf("%ld.%06ld: select %ldus\n", (long)now.tv_sec, (long)now.tv_usec, delta_us);res = select(sock + 1, &readfs, 0, &errorfs, &delta);gettimeofday(&now, 0);printf("%ld.%06ld: select returned: %d, %s\n", (long)now.tv_sec, (long)now.tv_usec, res, res < 0 ? strerror(errno) : "success");if (res > 0) {if (FD_ISSET(sock, &readfs))printf("ready for reading\n");if (FD_ISSET(sock, &errorfs))printf("has error\n");recvpacket(sock, 0, siocgstamp, siocgstampns);recvpacket(sock, MSG_ERRQUEUE, siocgstamp, siocgstampns); }} else {/* write one packet */sendpacket(sock, (struct sockaddr *)&addr, sizeof(addr));next.tv_sec += 5;continue;}}return 0;}
