43. PTP Client Sample Application

The PTP (Precision Time Protocol) client sample application is a simple example of using the DPDK IEEE1588 API to communicate with a PTP time transmitter to synchronize the time on the NIC and, optionally, on the Linux system.

Note, PTP is a time syncing protocol and cannot be used within DPDK as a time-stamping mechanism. See the following for an explanation of the protocol: Precision Time Protocol.

43.1. Limitations

The PTP sample application is intended as a simple reference implementation of a PTP client using the DPDK IEEE1588 API. In order to keep the application simple the following assumptions are made:

  • The first discovered time transmitter is the main for the session.

  • Only L2 PTP packets are supported.

  • Only the PTP v2 protocol is supported.

  • Only the time receiver clock is implemented.

43.2. How the Application Works

../_images/ptpclient.svg

Fig. 43.1 PTP Synchronization Protocol

The PTP synchronization in the sample application works as follows:

  • Time transmitter sends Sync message - the time receiver saves it as T2.

  • Time transmitter sends Follow Up message and sends time of T1.

  • Time receiver sends Delay Request frame to PTP time transmitter and stores T3.

  • Time transmitter sends Delay Response T4 time which is time of received T3.

The adjustment for time receiver can be represented as:

adj = -[(T2-T1)-(T4 - T3)]/2

If the command line parameter -T 1 is used the application also synchronizes the PTP PHC clock with the Linux kernel clock.

If the command line parameter -c 1 is used, the application will also use the servo of the local clock. Only one type of servo is currently implemented, the PI controller. Default 0 (not used).

43.3. Compiling the Application

To compile the sample application see Compiling the Sample Applications.

The application is located in the ptpclient sub-directory.

43.4. Running the Application

To run the example in a linux environment:

./<build_dir>/examples/dpdk-ptpclient -l 1 -n 4 -- -p 0x1 -T 0 -c 1

Refer to DPDK Getting Started Guide for general information on running applications and the Environment Abstraction Layer (EAL) options.

  • -p portmask: Hexadecimal portmask.

  • -T 0: Update only the PTP time receiver clock.

  • -T 1: Update the PTP time receiver clock and synchronize the Linux Kernel to the PTP clock.

  • -c 0: Not used clock servo controller.

  • -c 1: The clock servo PI controller is used and the log will print information

    about time transmitter offset. Note that the PMD needs to support the rte_eth_timesync_adjust_freq() API to enable the servo controller.

Also, by adding -T 1 and -c 1, the time transmitter offset value printed in the log will slowly converge and eventually stabilise at the nanosecond level. The synchronisation accuracy is much higher compared to not using a servo controller.

43.5. Code Explanation

The following sections provide an explanation of the main components of the code.

All DPDK library functions used in the sample code are prefixed with rte_ and are explained in detail in the DPDK API Documentation.

43.5.1. The Main Function

The main() function performs the initialization and calls the execution threads for each lcore.

The first task is to initialize the Environment Abstraction Layer (EAL). The argc and argv arguments are provided to the rte_eal_init() function. The value returned is the number of parsed arguments:

int ret = rte_eal_init(argc, argv);

if (ret < 0)
	rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");

And than we parse application specific arguments

argc -= ret;
argv += ret;

force_quit = false;
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);

ret = ptp_parse_args(argc, argv);
if (ret < 0)
	rte_exit(EXIT_FAILURE, "Error with PTP initialization\n");

The main() also allocates a mempool to hold the mbufs (Message Buffers) used by the application:

mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", NUM_MBUFS * nb_ports,
	MBUF_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());

Mbufs are the packet buffer structure used by DPDK. They are explained in detail in the “Mbuf Library” section of the DPDK Programmer’s Guide.

The main() function also initializes all the ports using the user defined port_init() function with portmask provided by user:

RTE_ETH_FOREACH_DEV(portid) {
	if ((ptp_enabled_port_mask & (1 << portid)) != 0) {
		if (port_init(portid, mbuf_pool) == 0) {
			ptp_enabled_ports[ptp_enabled_port_nb] = portid;
			ptp_enabled_port_nb++;
		} else {
			rte_exit(EXIT_FAILURE,
				 "Cannot init port %"PRIu8 "\n",
				 portid);
		}
	} else
		printf("Skipping disabled port %u\n", portid);
}

Once the initialization is complete, the application is ready to launch a function on an lcore. In this example lcore_main() is called on a single lcore.

lcore_main();

The lcore_main() function is explained below.

43.5.2. The Lcores Main

As we saw above the main() function calls an application function on the available lcores.

The main work of the application is done within the loop:

for (portid = 0; portid < ptp_enabled_port_nb; portid++) {

	portid = ptp_enabled_ports[portid];
	nb_rx = rte_eth_rx_burst(portid, 0, &m, 1);

	if (likely(nb_rx == 0))
		continue;

	/* Packet is parsed to determine which type. 8< */
	if (m->ol_flags & RTE_MBUF_F_RX_IEEE1588_PTP)
		parse_ptp_frames(portid, m);
	/* >8 End of packet is parsed to determine which type. */

	rte_pktmbuf_free(m);
}

Packets are received one by one on the RX ports and, if required, PTP response packets are transmitted on the TX ports.

If the offload flags in the mbuf indicate that the packet is a PTP packet then the packet is parsed to determine which type:

if (m->ol_flags & RTE_MBUF_F_RX_IEEE1588_PTP)
	parse_ptp_frames(portid, m);

All packets are freed explicitly using rte_pktmbuf_free().

The forwarding loop can be interrupted and the application closed using Ctrl-C.

43.5.3. PTP parsing

The parse_ptp_frames() function processes PTP packets, implementing time receiver PTP IEEE1588 L2 functionality.

static void
parse_ptp_frames(uint16_t portid, struct rte_mbuf *m) {
	struct ptp_header *ptp_hdr;
	struct rte_ether_hdr *eth_hdr;
	uint16_t eth_type;

	eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
	eth_type = rte_be_to_cpu_16(eth_hdr->ether_type);

	if (eth_type == PTP_PROTOCOL) {
		ptp_data.m = m;
		ptp_data.portid = portid;
		ptp_hdr = rte_pktmbuf_mtod_offset(m, struct ptp_header *,
						  sizeof(struct rte_ether_hdr));

		switch (ptp_hdr->msg_type) {
		case SYNC:
			parse_sync(&ptp_data, m->timesync);
			break;
		case FOLLOW_UP:
			parse_fup(&ptp_data);
			break;
		case DELAY_RESP:
			parse_drsp(&ptp_data);
			print_clock_info(&ptp_data);
			break;
		default:
			break;
		}
	}
}

There are 3 types of packets on the RX path which we must parse to create a minimal implementation of the PTP time receiver client:

  • SYNC packet.

  • FOLLOW UP packet

  • DELAY RESPONSE packet.

When we parse the FOLLOW UP packet we also create and send a DELAY_REQUEST packet. Also when we parse the DELAY RESPONSE packet, and all conditions are met we adjust the PTP time receiver clock.