Packet timestamping
Introduction
Many network interface cards (NICs, or network adapters) can generate a timestamp in their hardware whenever a packet is received or transmitted. The timestamp is generated using the NIC's own hardware clock. This feature is used in particular by the Precision Time Protocol (PTP), which is a time synchronization protocol. PTP makes provision to use such hardware timestamps within the protocol itself.
The timestamps can, for example, be used to compute the time spent by a packet within the network stack of the machine before being sent to or received from the wire. Those calculations can then be used by PTP to improve the accuracy of time synchronization. The packet timestamping support of network adapters is geared sometimes specifically for the PTP protocol. In other cases, a more general support is provided.
Timestamping APIs give Windows the ability to support the hardware timestamping capability of network adapters for the PTP version 2 protocol. Overall, the features include providing the ability to drivers of network adapters to support timestamps, and for user-mode applications to consume timestamps associated with packets through Windows Sockets (see Winsock timestamping). In addition, the ability to generate software timestamps is also available, which allows a network driver to generate timestamps in software. Such software timestamps are generated by NIC drivers using the kernel-mode equivalent of QueryPerformanceCounter (QPC). However, having both hardware and software timestamps enabled together isn't supported.
In particular, the Internet Protocol Helper (IP Helper) packet timestamping APIs described in this topic provide the ability for user-mode applications to determine the timestamping capability of a network adapter, and to query timestamps from the network adapter in the form of cross timestamps (described below).
Supporting Precision Time Protocol version 2
As mentioned, the main goal of timestamping support in Windows is to support the Precision Time Protocol version 2 (PTPv2) protocol. Within PTPv2, not all messages need a timestamp. In particular, PTP event messages do use timestamps. Currently, support is scoped to PTPv2 over User Datagram Protocol (UDP). PTP over raw ethernet isn't supported.
Timestamping is supported for PTPv2 operating in 2 step mode. 2 step refers to the mode in which the actual timestamps in the PTP packets aren't generated on the fly in the hardware, but are instead retrieved from the hardware and conveyed as separate messages (for example, using a follow-up message).
In summary, you can use the Internet Protocol Helper (IP Helper) packet timestamping APIs, together with Winsock's timestamping support, in a PTPv2 application to improve its time synchronization accuracy.
Retrieving the timestamping capabilities of a network adapter
An application such as a PTP time synchronization service needs to determine the timestamping capability of a network adapter. Using the retrieved capabilities, the application can then decide whether or not it wants to use timestamps.
Even if a network adapter does support timestamps, it's required to keep the ability turned off by default. An adapter turns on timestamping when instructed to do so. Windows provides APIs for an application to retrieve the hardware's capability, as well as which capabilities are turned on.
To retrieve the supported timestamp capabilities of a network adapter, you call the GetInterfaceSupportedTimestampCapabilities function, providing the locally unique identifier (LUID) of the network adapter, and in return retrieving the supported timestamping capabilities in the form of an INTERFACE_TIMESTAMP_CAPABILITIES object.
The code returned from GetInterfaceSupportedTimestampCapabilities indicates whether or not the call succeeded, and whether or not a populated INTERFACE_TIMESTAMP_CAPABILITIES value was retrieved.
To retrieve the currently enabled timestamp capabilities of a network adapter, you call the GetInterfaceActiveTimestampCapabilities function, providing the locally unique identifier (LUID) of the network adapter, and in return retrieving the enabled timestamping capabilities in the form of an INTERFACE_TIMESTAMP_CAPABILITIES object.
Again, the code returned from GetInterfaceActiveTimestampCapabilities indicates success or failure, and whether or not a valid INTERFACE_TIMESTAMP_CAPABILITIES value was retrieved.
Network adapters can support a variety of timestamping capabilities. For example, some adapters can timestamp every packet during send and receive, while others support only PTPv2 packets. The INTERFACE_TIMESTAMP_CAPABILITIES structure describes the exact capabilities that a network adapter supports.
Retrieving cross timestamps from a network adapter
When using hardware timestamps, a PTP application needs to establish a relation (for example, by using appropriate mathematical techniques) between the hardware clock of the network adapter and a system clock. This is necessary so that a value representing a time in one clock's unit can be converted into another clock's unit. Cross timestamps are provided for this purpose, and your application can sample cross timestamps periodically in order to establish such a relation.
To do that, call the CaptureInterfaceHardwareCrossTimestamp function, providing the locally unique identifier (LUID) of the network adapter, and in return retrieving the timestamp from the network adapter in the form of an INTERFACE_HARDWARE_CROSSTIMESTAMP object.
Timestamp capability change notifications
To be notified should the timestamp capabilities for a network adapter change, call the RegisterInterfaceTimestampConfigChange function, providing a pointer to the callback function that you've implemented, together with an optional caller-allocated context.
RegisterInterfaceTimestampConfigChange returns a handle that you can subsequently pass to UnregisterInterfaceTimestampConfigChange in order to unregister your callback function.
Code example 1—retrieving timestamp capabilities and cross timestamps
// main.cpp in a Console App project.
#include <stdio.h>
#include <winsock2.h>
#include <iphlpapi.h>
#pragma comment(lib, "Iphlpapi")
BOOL
IsPTPv2HardwareTimestampingSupportedForIPv4(PINTERFACE_TIMESTAMP_CAPABILITIES timestampCapabilities)
{
// Supported if both receive and transmit side support is present
if (((timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv4EventMessageReceive) ||
(timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv4AllMessageReceive) ||
(timestampCapabilities->HardwareCapabilities.AllReceive))
&&
((timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv4EventMessageTransmit) ||
(timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv4AllMessageTransmit) ||
(timestampCapabilities->HardwareCapabilities.TaggedTransmit) ||
(timestampCapabilities->HardwareCapabilities.AllTransmit)))
{
return TRUE;
}
return FALSE;
}
BOOL
IsPTPv2HardwareTimestampingSupportedForIPv6(PINTERFACE_TIMESTAMP_CAPABILITIES timestampCapabilities)
{
// Supported if both receive and transmit side support is present
if (((timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv6EventMessageReceive) ||
(timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv6AllMessageReceive) ||
(timestampCapabilities->HardwareCapabilities.AllReceive))
&&
((timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv6EventMessageTransmit) ||
(timestampCapabilities->HardwareCapabilities.PtpV2OverUdpIPv6AllMessageTransmit) ||
(timestampCapabilities->HardwareCapabilities.TaggedTransmit) ||
(timestampCapabilities->HardwareCapabilities.AllTransmit)))
{
return TRUE;
}
return FALSE;
}
enum SupportedTimestampType
{
TimestampTypeNone = 0,
TimestampTypeSoftware = 1,
TimestampTypeHardware = 2
};
// This function checks and returns the supported timestamp capabilities for an interface for
// a PTPv2 application
SupportedTimestampType
CheckActiveTimestampCapabilitiesForPtpv2(NET_LUID interfaceLuid)
{
DWORD result = NO_ERROR;
INTERFACE_TIMESTAMP_CAPABILITIES timestampCapabilities;
SupportedTimestampType supportedType = TimestampTypeNone;
result = GetInterfaceActiveTimestampCapabilities(
&interfaceLuid,
×tampCapabilities);
if (result != NO_ERROR)
{
printf("Error retrieving hardware timestamp capabilities: %d\n", result);
goto Exit;
}
if (IsPTPv2HardwareTimestampingSupportedForIPv4(×tampCapabilities) &&
IsPTPv2HardwareTimestampingSupportedForIPv6(×tampCapabilities))
{
supportedType = TimestampTypeHardware;
goto Exit;
}
else
{
if ((timestampCapabilities.SoftwareCapabilities.AllReceive) &&
((timestampCapabilities.SoftwareCapabilities.AllTransmit) ||
(timestampCapabilities.SoftwareCapabilities.TaggedTransmit)))
{
supportedType = TimestampTypeSoftware;
}
}
Exit:
return supportedType;
}
// Helper function which does the correlation between hardware and system clock
// using mathematical techniques
void ComputeCorrelationOfHardwareAndSystemTimestamps(INTERFACE_HARDWARE_CROSSTIMESTAMP *crossTimestamp);
// An application would call this function periodically to gather a set
// of matching timestamps for use in converting hardware timestamps to
// system timestamps
DWORD
RetrieveAndProcessCrossTimestamp(NET_LUID interfaceLuid)
{
DWORD result = NO_ERROR;
INTERFACE_HARDWARE_CROSSTIMESTAMP crossTimestamp;
result = CaptureInterfaceHardwareCrossTimestamp(
&interfaceLuid,
&crossTimestamp);
if (result != NO_ERROR)
{
printf("Error retrieving cross timestamp for the interface: %d\n", result);
goto Exit;
}
// Process crossTimestamp further to create a relation between the hardware clock
// of the NIC and the QPC values using appropriate mathematical techniques
ComputeCorrelationOfHardwareAndSystemTimestamps(&crossTimestamp);
Exit:
return result;
}
int main()
{
}
Code example 2—registering for timestamp capability change notifications
This example shows how your application could use timestamps end to end.
// main.cpp in a Console App project.
#include <stdlib.h>
#include <stdio.h>
#include <winsock2.h>
#include <mswsock.h>
#include <iphlpapi.h>
#include <mstcpip.h>
#pragma comment(lib, "Ws2_32")
#pragma comment(lib, "Iphlpapi")
// Globals and function declarations used by the application.
// The sample functions and skeletons demonstrate:
// - Checking timestamp configuration for an interface to determine if timestamping can be used
// - If timestamping is enabled, starts tracking changes in timestamp configuration
// - Performing correlation between hardware and system timestamps using cross timestamps
// on a separate thread depending on the timestamp type configured
// - Receiving a packet and computing the latency between when the timestamp
// was generated on packet reception, and when the packet was received by
// the application through the socket
// The sample tries to demonstrate how an application could use timestamps. It is not thread safe
// and does not do exhaustive error checking.
// Lot of the functions are provided as skeletons, or only declared and invoked
// but are not defined. It is up to
// the application to implement these suitably.
// An application could use the functions below by e.g.
// - Call InitializeTimestampingForInterface for the interface it wants to track for timestamping capability.
// - Call EstimateReceiveLatency to estimate the receive latency of a packet depending on the timestamp
// type configured for the interface.
enum SupportedTimestampType
{
TimestampTypeNone = 0,
TimestampTypeSoftware = 1,
TimestampTypeHardware = 2
};
// interfaceBeingTracked is the interface the PTPv2 application
// intends to use for timestamping purpose.
wchar_t* interfaceBeingTracked;
// The active timestamping type determined for
// interfaceBeingTracked.
SupportedTimestampType timestampTypeEnabledForInterface;
HANDLE correlationThread;
HANDLE threadStopEvent;
HIFTIMESTAMPCHANGE TimestampChangeNotificationHandle = NULL;
// Function from sample above to check if an interface supports timestamping for PTPv2.
SupportedTimestampType CheckActiveTimestampCapabilitiesForPtpv2(NET_LUID interfaceLuid);
// Function from sample above to retrieve cross timestamps and process them further.
DWORD RetrieveAndProcessCrossTimestamp(NET_LUID interfaceLuid);
// Helper function which registers for timestamp configuration changes.
DWORD RegisterTimestampChangeNotifications();
// Callback function which is invoked when timestamp configuration changes
// for some network interface.
INTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACK TimestampConfigChangeCallback;
// Function which does the correlation between hardware and system clock
// using mathematical techniques. It is periodically invoked and provided
// a sample of cross timestamp to compute a correlation.
void ComputeCorrelationOfHardwareAndSystemTimestamps(INTERFACE_HARDWARE_CROSSTIMESTAMP *crossTimestamp);
// Helper function which converts a hardware timestamp from the NIC clock
// to system timestamp (QPC) values. It is assumed that this works together
// with the ComputeCorrelationOfHardwareAndSystemTimestamps function
// to derive the correlation.
ULONG64 ConvertHardwareTimestampToQpc(ULONG64 HardwareTimestamp);
// Start function of thread which periodically samples
// cross timestamps to correlate hardware and software timestamps.
DWORD WINAPI CorrelateHardwareAndSystemTimestamps(LPVOID);
// Helper function which starts a new thread at CorrelateHardwareAndSystemTimestamps.
DWORD StartCorrelatingHardwareAndSytemTimestamps();
// Helper function which restarts correlation when some change is detected.
DWORD RestartCorrelatingHardwareAndSystemTimestamps();
// Stops the correlation thread.
DWORD StopCorrelatingHardwareAndSystemTimestamps();
DWORD
FindInterfaceFromFriendlyName(wchar_t* friendlyName, NET_LUID* interfaceLuid)
{
DWORD result = 0;
ULONG flags = 0;
ULONG outBufLen = 0;
PIP_ADAPTER_ADDRESSES pAddresses = NULL;
PIP_ADAPTER_ADDRESSES currentAddresses = NULL;
result = GetAdaptersAddresses(0,
flags,
NULL,
pAddresses,
&outBufLen);
if (result == ERROR_BUFFER_OVERFLOW)
{
pAddresses = (PIP_ADAPTER_ADDRESSES)malloc(outBufLen);
result = GetAdaptersAddresses(0,
flags,
NULL,
pAddresses,
&outBufLen);
if (result != NO_ERROR)
{
goto Done;
}
}
else if (result != NO_ERROR)
{
goto Done;
}
currentAddresses = pAddresses;
while (currentAddresses != NULL)
{
if (wcscmp(friendlyName, currentAddresses->FriendlyName) == 0)
{
result = ConvertInterfaceIndexToLuid(currentAddresses->IfIndex, interfaceLuid);
goto Done;
}
currentAddresses = currentAddresses->Next;
}
result = ERROR_NOT_FOUND;
Done:
if (pAddresses != NULL)
{
free(pAddresses);
}
return result;
}
// This function checks if an interface is suitable for
// timestamping for PTPv2. If so, it registers for timestamp
// configuration changes and initializes some globals.
// If hardware timestamping is enabled it also starts
// correlation thread.
DWORD
InitializeTimestampingForInterface(wchar_t* friendlyName)
{
DWORD error;
SupportedTimestampType supportedType = TimestampTypeNone;
NET_LUID interfaceLuid;
error = FindInterfaceFromFriendlyName(friendlyName, &interfaceLuid);
if (error != 0)
{
return error;
}
supportedType = CheckActiveTimestampCapabilitiesForPtpv2(interfaceLuid);
if (supportedType != TimestampTypeNone)
{
error = RegisterTimestampChangeNotifications();
if (error != NO_ERROR)
{
return error;
}
if (supportedType == TimestampTypeHardware)
{
threadStopEvent = CreateEvent(
NULL,
FALSE,
FALSE,
NULL
);
if (threadStopEvent == NULL)
{
return GetLastError();
}
error = StartCorrelatingHardwareAndSytemTimestamps();
if (error != 0)
{
return error;
}
}
interfaceBeingTracked = friendlyName;
timestampTypeEnabledForInterface = supportedType;
return error;
}
return ERROR_NOT_SUPPORTED;
}
DWORD
RegisterTimestampChangeNotifications()
{
DWORD retcode = NO_ERROR;
// Register with NULL context
retcode = RegisterInterfaceTimestampConfigChange(TimestampConfigChangeCallback, NULL, &TimestampChangeNotificationHandle);
if (retcode != NO_ERROR)
{
printf("Error when calling RegisterIfTimestampConfigChange %d\n", retcode);
}
return retcode;
}
// The callback invoked when change in some interface’s timestamping configuration
// happens. The callback takes appropriate action based on the new capability of the
// interface. The callback assumes that there is only 1 NIC. If multiple NICs are being
// tracked for timestamping then the application would need to check all of them.
VOID
WINAPI
TimestampConfigChangeCallback(
_In_ PVOID /*CallerContext*/
)
{
SupportedTimestampType supportedType;
NET_LUID interfaceLuid;
DWORD error;
error = FindInterfaceFromFriendlyName(interfaceBeingTracked, &interfaceLuid);
if (error != NO_ERROR)
{
if (timestampTypeEnabledForInterface == TimestampTypeHardware)
{
StopCorrelatingHardwareAndSystemTimestamps();
timestampTypeEnabledForInterface = TimestampTypeNone;
}
return;
}
supportedType = CheckActiveTimestampCapabilitiesForPtpv2(interfaceLuid);
if ((supportedType == TimestampTypeHardware) &&
(timestampTypeEnabledForInterface == TimestampTypeHardware))
{
// NIC could have been restarted, restart the correlation between hardware and
// system timestamps.
RestartCorrelatingHardwareAndSystemTimestamps();
}
else if (supportedType == TimestampTypeHardware)
{
// Start thread correlating hardware and software timestamps
StartCorrelatingHardwareAndSytemTimestamps();
}
else if (supportedType != TimestampTypeHardware)
{
// Hardware timestamps are not enabled, stop correlation
StopCorrelatingHardwareAndSystemTimestamps();
}
timestampTypeEnabledForInterface = supportedType;
}
DWORD
StartCorrelatingHardwareAndSytemTimestamps()
{
// Create a new thread which starts at CorrelateHardwareAndSoftwareTimestamps
correlationThread = CreateThread(
NULL,
0,
CorrelateHardwareAndSystemTimestamps,
NULL,
0,
NULL);
if (correlationThread == NULL)
{
return GetLastError();
}
}
// Thread which periodically invokes functions to
// sample cross timestamps and use them to compute
// correlation between hardware and system timestamps.
DWORD WINAPI
CorrelateHardwareAndSystemTimestamps(LPVOID /*lpParameter*/)
{
DWORD error;
NET_LUID interfaceLuid;
DWORD result;
result = FindInterfaceFromFriendlyName(interfaceBeingTracked, &interfaceLuid);
if (result != 0)
{
return result;
}
while (TRUE)
{
error = RetrieveAndProcessCrossTimestamp(interfaceLuid);
// Sleep and repeat till the thread gets a signal to stop
result = WaitForSingleObject(threadStopEvent, 5000);
if (result != WAIT_TIMEOUT)
{
if (result == WAIT_OBJECT_0)
{
return 0;
}
else if (result == WAIT_FAILED)
{
return GetLastError();
}
return result;
}
}
}
DWORD
StopCorrelatingHardwareAndSystemTimestamps()
{
SetEvent(threadStopEvent);
return 0;
}
// Function which receives a packet and estimates the latency between the
// point at which receive timestamp (of appropriate type) was generated
// and when the packet was received in the app through the socket.
// The sample assumes that there is only 1 NIC in the system. This is the NIC which is tracked through
// interfaceBeingTracked for correlation purpose, and through which packets are being
// received by the socket.
// The recvmsg parameter is of type LPFN_WSARECVMSG and an application can
// retrieve it by issuing WSAIoctl
// with SIO_GET_EXTENSION_FUNCTION_POINTER control
// and WSAID_WSARECVMSG. Please refer to msdn.
void EstimateReceiveLatency(SOCKET sock, LPFN_WSARECVMSG recvmsg)
{
DWORD numBytes;
INT error;
CHAR data[512];
CHAR control[WSA_CMSG_SPACE(sizeof(UINT64))] = { 0 };
WSABUF dataBuf;
WSABUF controlBuf;
WSAMSG wsaMsg;
UINT64 socketTimestamp = 0;
ULONG64 appLevelTimestamp;
ULONG64 packetReceivedTimestamp;
dataBuf.buf = data;
dataBuf.len = sizeof(data);
controlBuf.buf = control;
controlBuf.len = sizeof(control);
wsaMsg.name = NULL;
wsaMsg.namelen = 0;
wsaMsg.lpBuffers = &dataBuf;
wsaMsg.dwBufferCount = 1;
wsaMsg.Control = controlBuf;
wsaMsg.dwFlags = 0;
// Configure rx timestamp reception.
TIMESTAMPING_CONFIG config = { 0 };
config.Flags |= TIMESTAMPING_FLAG_RX;
error =
WSAIoctl(
sock,
SIO_TIMESTAMPING,
&config,
sizeof(config),
NULL,
0,
&numBytes,
NULL,
NULL);
if (error == SOCKET_ERROR)
{
printf("WSAIoctl failed %d\n", WSAGetLastError());
return;
}
error =
recvmsg(
sock,
&wsaMsg,
&numBytes,
NULL,
NULL);
if (error == SOCKET_ERROR)
{
printf("recvmsg failed %d\n", WSAGetLastError());
return;
}
if (timestampTypeEnabledForInterface != TimestampTypeNone)
{
// Capture system timestamp (QPC) upon message reception.
LARGE_INTEGER t1;
QueryPerformanceCounter(&t1);
appLevelTimestamp = t1.QuadPart;
printf("received packet\n");
// Look for socket rx timestamp returned via control message.
BOOLEAN retrievedTimestamp = FALSE;
PCMSGHDR cmsg = WSA_CMSG_FIRSTHDR(&wsaMsg);
while (cmsg != NULL)
{
if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SO_TIMESTAMP)
{
socketTimestamp = *(PUINT64)WSA_CMSG_DATA(cmsg);
retrievedTimestamp = TRUE;
break;
}
cmsg = WSA_CMSG_NXTHDR(&wsaMsg, cmsg);
}
if (retrievedTimestamp)
{
// Compute socket receive path latency.
LARGE_INTEGER clockFrequency;
ULONG64 elapsedMicroseconds;
if (timestampTypeEnabledForInterface == TimestampTypeHardware)
{
packetReceivedTimestamp = ConvertHardwareTimestampToQpc(socketTimestamp);
}
else
{
packetReceivedTimestamp = socketTimestamp;
}
QueryPerformanceFrequency(&clockFrequency);
// Compute socket receive path latency.
elapsedMicroseconds = appLevelTimestamp - packetReceivedTimestamp;
elapsedMicroseconds *= 1000000;
elapsedMicroseconds /= clockFrequency.QuadPart;
printf("RX latency estimation: %lld microseconds\n",
elapsedMicroseconds);
}
else
{
printf("failed to retrieve RX timestamp\n");
}
}
}
int main()
{
}