2 Copyright(c) 2015 Intel Corporation. All rights reserved.
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions
9 * Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
11 * Redistributions in binary form must reproduce the above copyright
12 notice, this list of conditions and the following disclaimer in
13 the documentation and/or other materials provided with the
15 * Neither the name of Intel Corporation nor the names of its
16 contributors may be used to endorse or promote products derived
17 from this software without specific prior written permission.
19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 PTP Client Sample Application
33 =============================
35 The PTP (Precision Time Protocol) client sample application is a simple
36 example of using the DPDK IEEE1588 API to communicate with a PTP master clock
37 to synchronize the time on the NIC and, optionally, on the Linux system.
39 Note, PTP is a time syncing protocol and cannot be used within DPDK as a
40 time-stamping mechanism. See the following for an explanation of the protocol:
41 `Precision Time Protocol
42 <https://en.wikipedia.org/wiki/Precision_Time_Protocol>`_.
48 The PTP sample application is intended as a simple reference implementation of
49 a PTP client using the DPDK IEEE1588 API.
50 In order to keep the application simple the following assumptions are made:
52 * The first discovered master is the master for the session.
53 * Only L2 PTP packets are supported.
54 * Only the PTP v2 protocol is supported.
55 * Only the slave clock is implemented.
58 How the Application Works
59 -------------------------
61 .. _figure_ptpclient_highlevel:
63 .. figure:: img/ptpclient.*
65 PTP Synchronization Protocol
67 The PTP synchronization in the sample application works as follows:
69 * Master sends *Sync* message - the slave saves it as T2.
70 * Master sends *Follow Up* message and sends time of T1.
71 * Slave sends *Delay Request* frame to PTP Master and stores T3.
72 * Master sends *Delay Response* T4 time which is time of received T3.
74 The adjustment for slave can be represented as:
76 adj = -[(T2-T1)-(T4 - T3)]/2
78 If the command line parameter ``-T 1`` is used the application also
79 synchronizes the PTP PHC clock with the Linux kernel clock.
82 Compiling the Application
83 -------------------------
85 To compile the application, export the path to the DPDK source tree and edit
86 the ``config/common_linuxapp`` configuration file to enable IEEE1588:
88 .. code-block:: console
90 export RTE_SDK=/path/to/rte_sdk
92 # Edit common_linuxapp and set the following options:
93 CONFIG_RTE_LIBRTE_IEEE1588=y
95 Set the target, for example:
97 .. code-block:: console
99 export RTE_TARGET=x86_64-native-linuxapp-gcc
101 See the *DPDK Getting Started* Guide for possible ``RTE_TARGET`` values.
103 Build the application as follows:
105 .. code-block:: console
108 make install T=$RTE_TARGET
110 # Compile the application.
111 cd ${RTE_SDK}/examples/ptpclient
115 Running the Application
116 -----------------------
118 To run the example in a ``linuxapp`` environment:
120 .. code-block:: console
122 ./build/ptpclient -c 2 -n 4 -- -p 0x1 -T 0
124 Refer to *DPDK Getting Started Guide* for general information on running
125 applications and the Environment Abstraction Layer (EAL) options.
127 * ``-p portmask``: Hexadecimal portmask.
128 * ``-T 0``: Update only the PTP slave clock.
129 * ``-T 1``: Update the PTP slave clock and synchronize the Linux Kernel to the PTP clock.
135 The following sections provide an explanation of the main components of the
138 All DPDK library functions used in the sample code are prefixed with ``rte_``
139 and are explained in detail in the *DPDK API Documentation*.
145 The ``main()`` function performs the initialization and calls the execution
146 threads for each lcore.
148 The first task is to initialize the Environment Abstraction Layer (EAL). The
149 ``argc`` and ``argv`` arguments are provided to the ``rte_eal_init()``
150 function. The value returned is the number of parsed arguments:
154 int ret = rte_eal_init(argc, argv);
156 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
158 And than we parse application specific arguments
165 ret = ptp_parse_args(argc, argv);
167 rte_exit(EXIT_FAILURE, "Error with PTP initialization\n");
169 The ``main()`` also allocates a mempool to hold the mbufs (Message Buffers)
170 used by the application:
174 mbuf_pool = rte_mempool_create("MBUF_POOL",
175 NUM_MBUFS * nb_ports,
178 sizeof(struct rte_pktmbuf_pool_private),
179 rte_pktmbuf_pool_init, NULL,
180 rte_pktmbuf_init, NULL,
184 Mbufs are the packet buffer structure used by DPDK. They are explained in
185 detail in the "Mbuf Library" section of the *DPDK Programmer's Guide*.
187 The ``main()`` function also initializes all the ports using the user defined
188 ``port_init()`` function with portmask provided by user:
192 for (portid = 0; portid < nb_ports; portid++)
193 if ((ptp_enabled_port_mask & (1 << portid)) != 0) {
195 if (port_init(portid, mbuf_pool) == 0) {
196 ptp_enabled_ports[ptp_enabled_port_nb] = portid;
197 ptp_enabled_port_nb++;
199 rte_exit(EXIT_FAILURE, "Cannot init port %"PRIu8 "\n",
205 Once the initialization is complete, the application is ready to launch a
206 function on an lcore. In this example ``lcore_main()`` is called on a single
213 The ``lcore_main()`` function is explained below.
219 As we saw above the ``main()`` function calls an application function on the
222 The main work of the application is done within the loop:
226 for (portid = 0; portid < ptp_enabled_port_nb; portid++) {
228 portid = ptp_enabled_ports[portid];
229 nb_rx = rte_eth_rx_burst(portid, 0, &m, 1);
231 if (likely(nb_rx == 0))
234 if (m->ol_flags & PKT_RX_IEEE1588_PTP)
235 parse_ptp_frames(portid, m);
240 Packets are received one by one on the RX ports and, if required, PTP response
241 packets are transmitted on the TX ports.
243 If the offload flags in the mbuf indicate that the packet is a PTP packet then
244 the packet is parsed to determine which type:
248 if (m->ol_flags & PKT_RX_IEEE1588_PTP)
249 parse_ptp_frames(portid, m);
252 All packets are freed explicitly using ``rte_pktmbuf_free()``.
254 The forwarding loop can be interrupted and the application closed using
261 The ``parse_ptp_frames()`` function processes PTP packets, implementing slave
262 PTP IEEE1588 L2 functionality.
267 parse_ptp_frames(uint8_t portid, struct rte_mbuf *m) {
268 struct ptp_header *ptp_hdr;
269 struct ether_hdr *eth_hdr;
272 eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
273 eth_type = rte_be_to_cpu_16(eth_hdr->ether_type);
275 if (eth_type == PTP_PROTOCOL) {
277 ptp_data.portid = portid;
278 ptp_hdr = (struct ptp_header *)(rte_pktmbuf_mtod(m, char *)
279 + sizeof(struct ether_hdr));
281 switch (ptp_hdr->msgtype) {
283 parse_sync(&ptp_data);
286 parse_fup(&ptp_data);
289 parse_drsp(&ptp_data);
290 print_clock_info(&ptp_data);
298 There are 3 types of packets on the RX path which we must parse to create a minimal
299 implementation of the PTP slave client:
303 * DELAY RESPONSE packet.
305 When we parse the *FOLLOW UP* packet we also create and send a *DELAY_REQUEST* packet.
306 Also when we parse the *DELAY RESPONSE* packet, and all conditions are met we adjust the PTP slave clock.