1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2015 Intel Corporation
3 */
4
5 /*
6 * This application is a simple Layer 2 PTP v2 client. It shows delta values
7 * which are used to synchronize the PHC clock. if the "-T 1" parameter is
8 * passed to the application the Linux kernel clock is also synchronized.
9 */
10
11 #include <stdint.h>
12 #include <inttypes.h>
13 #include <rte_eal.h>
14 #include <rte_ethdev.h>
15 #include <rte_cycles.h>
16 #include <rte_lcore.h>
17 #include <rte_mbuf.h>
18 #include <rte_ip.h>
19 #include <limits.h>
20 #include <sys/time.h>
21 #include <getopt.h>
22
23 #define RX_RING_SIZE 1024
24 #define TX_RING_SIZE 1024
25
26 #define NUM_MBUFS 8191
27 #define MBUF_CACHE_SIZE 250
28
29 /* Values for the PTP messageType field. */
30 #define SYNC 0x0
31 #define DELAY_REQ 0x1
32 #define PDELAY_REQ 0x2
33 #define PDELAY_RESP 0x3
34 #define FOLLOW_UP 0x8
35 #define DELAY_RESP 0x9
36 #define PDELAY_RESP_FOLLOW_UP 0xA
37 #define ANNOUNCE 0xB
38 #define SIGNALING 0xC
39 #define MANAGEMENT 0xD
40
41 #define NSEC_PER_SEC 1000000000L
42 #define KERNEL_TIME_ADJUST_LIMIT 20000
43 #define PTP_PROTOCOL 0x88F7
44
45 struct rte_mempool *mbuf_pool;
46 uint32_t ptp_enabled_port_mask;
47 uint8_t ptp_enabled_port_nb;
48 static uint8_t ptp_enabled_ports[RTE_MAX_ETHPORTS];
49
50 static const struct rte_eth_conf port_conf_default = {
51 .rxmode = {
52 .max_rx_pkt_len = RTE_ETHER_MAX_LEN,
53 },
54 };
55
56 static const struct rte_ether_addr ether_multicast = {
57 .addr_bytes = {0x01, 0x1b, 0x19, 0x0, 0x0, 0x0}
58 };
59
60 /* Structs used for PTP handling. */
61 struct tstamp {
62 uint16_t sec_msb;
63 uint32_t sec_lsb;
64 uint32_t ns;
65 } __rte_packed;
66
67 struct clock_id {
68 uint8_t id[8];
69 };
70
71 struct port_id {
72 struct clock_id clock_id;
73 uint16_t port_number;
74 } __rte_packed;
75
76 struct ptp_header {
77 uint8_t msg_type;
78 uint8_t ver;
79 uint16_t message_length;
80 uint8_t domain_number;
81 uint8_t reserved1;
82 uint8_t flag_field[2];
83 int64_t correction;
84 uint32_t reserved2;
85 struct port_id source_port_id;
86 uint16_t seq_id;
87 uint8_t control;
88 int8_t log_message_interval;
89 } __rte_packed;
90
91 struct sync_msg {
92 struct ptp_header hdr;
93 struct tstamp origin_tstamp;
94 } __rte_packed;
95
96 struct follow_up_msg {
97 struct ptp_header hdr;
98 struct tstamp precise_origin_tstamp;
99 uint8_t suffix[0];
100 } __rte_packed;
101
102 struct delay_req_msg {
103 struct ptp_header hdr;
104 struct tstamp origin_tstamp;
105 } __rte_packed;
106
107 struct delay_resp_msg {
108 struct ptp_header hdr;
109 struct tstamp rx_tstamp;
110 struct port_id req_port_id;
111 uint8_t suffix[0];
112 } __rte_packed;
113
114 struct ptp_message {
115 union {
116 struct ptp_header header;
117 struct sync_msg sync;
118 struct delay_req_msg delay_req;
119 struct follow_up_msg follow_up;
120 struct delay_resp_msg delay_resp;
121 } __rte_packed;
122 };
123
124 struct ptpv2_data_slave_ordinary {
125 struct rte_mbuf *m;
126 struct timespec tstamp1;
127 struct timespec tstamp2;
128 struct timespec tstamp3;
129 struct timespec tstamp4;
130 struct clock_id client_clock_id;
131 struct clock_id master_clock_id;
132 struct timeval new_adj;
133 int64_t delta;
134 uint16_t portid;
135 uint16_t seqID_SYNC;
136 uint16_t seqID_FOLLOWUP;
137 uint8_t ptpset;
138 uint8_t kernel_time_set;
139 uint16_t current_ptp_port;
140 };
141
142 static struct ptpv2_data_slave_ordinary ptp_data;
143
timespec64_to_ns(const struct timespec * ts)144 static inline uint64_t timespec64_to_ns(const struct timespec *ts)
145 {
146 return ((uint64_t) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
147 }
148
149 static struct timeval
ns_to_timeval(int64_t nsec)150 ns_to_timeval(int64_t nsec)
151 {
152 struct timespec t_spec = {0, 0};
153 struct timeval t_eval = {0, 0};
154 int32_t rem;
155
156 if (nsec == 0)
157 return t_eval;
158 rem = nsec % NSEC_PER_SEC;
159 t_spec.tv_sec = nsec / NSEC_PER_SEC;
160
161 if (rem < 0) {
162 t_spec.tv_sec--;
163 rem += NSEC_PER_SEC;
164 }
165
166 t_spec.tv_nsec = rem;
167 t_eval.tv_sec = t_spec.tv_sec;
168 t_eval.tv_usec = t_spec.tv_nsec / 1000;
169
170 return t_eval;
171 }
172
173 /*
174 * Initializes a given port using global settings and with the RX buffers
175 * coming from the mbuf_pool passed as a parameter.
176 */
177 static inline int
port_init(uint16_t port,struct rte_mempool * mbuf_pool)178 port_init(uint16_t port, struct rte_mempool *mbuf_pool)
179 {
180 struct rte_eth_dev_info dev_info;
181 struct rte_eth_conf port_conf = port_conf_default;
182 const uint16_t rx_rings = 1;
183 const uint16_t tx_rings = 1;
184 int retval;
185 uint16_t q;
186 uint16_t nb_rxd = RX_RING_SIZE;
187 uint16_t nb_txd = TX_RING_SIZE;
188
189 if (!rte_eth_dev_is_valid_port(port))
190 return -1;
191
192 retval = rte_eth_dev_info_get(port, &dev_info);
193 if (retval != 0) {
194 printf("Error during getting device (port %u) info: %s\n",
195 port, strerror(-retval));
196
197 return retval;
198 }
199
200 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
201 port_conf.txmode.offloads |=
202 DEV_TX_OFFLOAD_MBUF_FAST_FREE;
203 /* Force full Tx path in the driver, required for IEEE1588 */
204 port_conf.txmode.offloads |= DEV_TX_OFFLOAD_MULTI_SEGS;
205
206 /* Configure the Ethernet device. */
207 retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
208 if (retval != 0)
209 return retval;
210
211 retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &nb_rxd, &nb_txd);
212 if (retval != 0)
213 return retval;
214
215 /* Allocate and set up 1 RX queue per Ethernet port. */
216 for (q = 0; q < rx_rings; q++) {
217 retval = rte_eth_rx_queue_setup(port, q, nb_rxd,
218 rte_eth_dev_socket_id(port), NULL, mbuf_pool);
219
220 if (retval < 0)
221 return retval;
222 }
223
224 /* Allocate and set up 1 TX queue per Ethernet port. */
225 for (q = 0; q < tx_rings; q++) {
226 struct rte_eth_txconf *txconf;
227
228 txconf = &dev_info.default_txconf;
229 txconf->offloads = port_conf.txmode.offloads;
230
231 retval = rte_eth_tx_queue_setup(port, q, nb_txd,
232 rte_eth_dev_socket_id(port), txconf);
233 if (retval < 0)
234 return retval;
235 }
236
237 /* Start the Ethernet port. */
238 retval = rte_eth_dev_start(port);
239 if (retval < 0)
240 return retval;
241
242 /* Enable timesync timestamping for the Ethernet device */
243 retval = rte_eth_timesync_enable(port);
244 if (retval < 0) {
245 printf("Timesync enable failed: %d\n", retval);
246 return retval;
247 }
248
249 /* Enable RX in promiscuous mode for the Ethernet device. */
250 retval = rte_eth_promiscuous_enable(port);
251 if (retval != 0) {
252 printf("Promiscuous mode enable failed: %s\n",
253 rte_strerror(-retval));
254 return retval;
255 }
256
257 return 0;
258 }
259
260 static void
print_clock_info(struct ptpv2_data_slave_ordinary * ptp_data)261 print_clock_info(struct ptpv2_data_slave_ordinary *ptp_data)
262 {
263 int64_t nsec;
264 struct timespec net_time, sys_time;
265
266 printf("Master Clock id: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
267 ptp_data->master_clock_id.id[0],
268 ptp_data->master_clock_id.id[1],
269 ptp_data->master_clock_id.id[2],
270 ptp_data->master_clock_id.id[3],
271 ptp_data->master_clock_id.id[4],
272 ptp_data->master_clock_id.id[5],
273 ptp_data->master_clock_id.id[6],
274 ptp_data->master_clock_id.id[7]);
275
276 printf("\nT2 - Slave Clock. %lds %ldns",
277 (ptp_data->tstamp2.tv_sec),
278 (ptp_data->tstamp2.tv_nsec));
279
280 printf("\nT1 - Master Clock. %lds %ldns ",
281 ptp_data->tstamp1.tv_sec,
282 (ptp_data->tstamp1.tv_nsec));
283
284 printf("\nT3 - Slave Clock. %lds %ldns",
285 ptp_data->tstamp3.tv_sec,
286 (ptp_data->tstamp3.tv_nsec));
287
288 printf("\nT4 - Master Clock. %lds %ldns ",
289 ptp_data->tstamp4.tv_sec,
290 (ptp_data->tstamp4.tv_nsec));
291
292 printf("\nDelta between master and slave clocks:%"PRId64"ns\n",
293 ptp_data->delta);
294
295 clock_gettime(CLOCK_REALTIME, &sys_time);
296 rte_eth_timesync_read_time(ptp_data->current_ptp_port, &net_time);
297
298 time_t ts = net_time.tv_sec;
299
300 printf("\n\nComparison between Linux kernel Time and PTP:");
301
302 printf("\nCurrent PTP Time: %.24s %.9ld ns",
303 ctime(&ts), net_time.tv_nsec);
304
305 nsec = (int64_t)timespec64_to_ns(&net_time) -
306 (int64_t)timespec64_to_ns(&sys_time);
307 ptp_data->new_adj = ns_to_timeval(nsec);
308
309 gettimeofday(&ptp_data->new_adj, NULL);
310
311 time_t tp = ptp_data->new_adj.tv_sec;
312
313 printf("\nCurrent SYS Time: %.24s %.6ld ns",
314 ctime(&tp), ptp_data->new_adj.tv_usec);
315
316 printf("\nDelta between PTP and Linux Kernel time:%"PRId64"ns\n",
317 nsec);
318
319 printf("[Ctrl+C to quit]\n");
320
321 /* Clear screen and put cursor in column 1, row 1 */
322 printf("\033[2J\033[1;1H");
323 }
324
325 static int64_t
delta_eval(struct ptpv2_data_slave_ordinary * ptp_data)326 delta_eval(struct ptpv2_data_slave_ordinary *ptp_data)
327 {
328 int64_t delta;
329 uint64_t t1 = 0;
330 uint64_t t2 = 0;
331 uint64_t t3 = 0;
332 uint64_t t4 = 0;
333
334 t1 = timespec64_to_ns(&ptp_data->tstamp1);
335 t2 = timespec64_to_ns(&ptp_data->tstamp2);
336 t3 = timespec64_to_ns(&ptp_data->tstamp3);
337 t4 = timespec64_to_ns(&ptp_data->tstamp4);
338
339 delta = -((int64_t)((t2 - t1) - (t4 - t3))) / 2;
340
341 return delta;
342 }
343
344 /*
345 * Parse the PTP SYNC message.
346 */
347 static void
parse_sync(struct ptpv2_data_slave_ordinary * ptp_data,uint16_t rx_tstamp_idx)348 parse_sync(struct ptpv2_data_slave_ordinary *ptp_data, uint16_t rx_tstamp_idx)
349 {
350 struct ptp_header *ptp_hdr;
351
352 ptp_hdr = (struct ptp_header *)(rte_pktmbuf_mtod(ptp_data->m, char *)
353 + sizeof(struct rte_ether_hdr));
354 ptp_data->seqID_SYNC = rte_be_to_cpu_16(ptp_hdr->seq_id);
355
356 if (ptp_data->ptpset == 0) {
357 rte_memcpy(&ptp_data->master_clock_id,
358 &ptp_hdr->source_port_id.clock_id,
359 sizeof(struct clock_id));
360 ptp_data->ptpset = 1;
361 }
362
363 if (memcmp(&ptp_hdr->source_port_id.clock_id,
364 &ptp_hdr->source_port_id.clock_id,
365 sizeof(struct clock_id)) == 0) {
366
367 if (ptp_data->ptpset == 1)
368 rte_eth_timesync_read_rx_timestamp(ptp_data->portid,
369 &ptp_data->tstamp2, rx_tstamp_idx);
370 }
371
372 }
373
374 /*
375 * Parse the PTP FOLLOWUP message and send DELAY_REQ to the main clock.
376 */
377 static void
parse_fup(struct ptpv2_data_slave_ordinary * ptp_data)378 parse_fup(struct ptpv2_data_slave_ordinary *ptp_data)
379 {
380 struct rte_ether_hdr *eth_hdr;
381 struct rte_ether_addr eth_addr;
382 struct ptp_header *ptp_hdr;
383 struct clock_id *client_clkid;
384 struct ptp_message *ptp_msg;
385 struct rte_mbuf *created_pkt;
386 struct tstamp *origin_tstamp;
387 struct rte_ether_addr eth_multicast = ether_multicast;
388 size_t pkt_size;
389 int wait_us;
390 struct rte_mbuf *m = ptp_data->m;
391 int ret;
392
393 eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
394 ptp_hdr = (struct ptp_header *)(rte_pktmbuf_mtod(m, char *)
395 + sizeof(struct rte_ether_hdr));
396 if (memcmp(&ptp_data->master_clock_id,
397 &ptp_hdr->source_port_id.clock_id,
398 sizeof(struct clock_id)) != 0)
399 return;
400
401 ptp_data->seqID_FOLLOWUP = rte_be_to_cpu_16(ptp_hdr->seq_id);
402 ptp_msg = (struct ptp_message *) (rte_pktmbuf_mtod(m, char *) +
403 sizeof(struct rte_ether_hdr));
404
405 origin_tstamp = &ptp_msg->follow_up.precise_origin_tstamp;
406 ptp_data->tstamp1.tv_nsec = ntohl(origin_tstamp->ns);
407 ptp_data->tstamp1.tv_sec =
408 ((uint64_t)ntohl(origin_tstamp->sec_lsb)) |
409 (((uint64_t)ntohs(origin_tstamp->sec_msb)) << 32);
410
411 if (ptp_data->seqID_FOLLOWUP == ptp_data->seqID_SYNC) {
412 ret = rte_eth_macaddr_get(ptp_data->portid, ð_addr);
413 if (ret != 0) {
414 printf("\nCore %u: port %u failed to get MAC address: %s\n",
415 rte_lcore_id(), ptp_data->portid,
416 rte_strerror(-ret));
417 return;
418 }
419
420 created_pkt = rte_pktmbuf_alloc(mbuf_pool);
421 pkt_size = sizeof(struct rte_ether_hdr) +
422 sizeof(struct ptp_message);
423 created_pkt->data_len = pkt_size;
424 created_pkt->pkt_len = pkt_size;
425 eth_hdr = rte_pktmbuf_mtod(created_pkt, struct rte_ether_hdr *);
426 rte_ether_addr_copy(ð_addr, ð_hdr->s_addr);
427
428 /* Set multicast address 01-1B-19-00-00-00. */
429 rte_ether_addr_copy(ð_multicast, ð_hdr->d_addr);
430
431 eth_hdr->ether_type = htons(PTP_PROTOCOL);
432 ptp_msg = (struct ptp_message *)
433 (rte_pktmbuf_mtod(created_pkt, char *) +
434 sizeof(struct rte_ether_hdr));
435
436 ptp_msg->delay_req.hdr.seq_id = htons(ptp_data->seqID_SYNC);
437 ptp_msg->delay_req.hdr.msg_type = DELAY_REQ;
438 ptp_msg->delay_req.hdr.ver = 2;
439 ptp_msg->delay_req.hdr.control = 1;
440 ptp_msg->delay_req.hdr.log_message_interval = 127;
441 ptp_msg->delay_req.hdr.message_length =
442 htons(sizeof(struct delay_req_msg));
443 ptp_msg->delay_req.hdr.domain_number = ptp_hdr->domain_number;
444
445 /* Set up clock id. */
446 client_clkid =
447 &ptp_msg->delay_req.hdr.source_port_id.clock_id;
448
449 client_clkid->id[0] = eth_hdr->s_addr.addr_bytes[0];
450 client_clkid->id[1] = eth_hdr->s_addr.addr_bytes[1];
451 client_clkid->id[2] = eth_hdr->s_addr.addr_bytes[2];
452 client_clkid->id[3] = 0xFF;
453 client_clkid->id[4] = 0xFE;
454 client_clkid->id[5] = eth_hdr->s_addr.addr_bytes[3];
455 client_clkid->id[6] = eth_hdr->s_addr.addr_bytes[4];
456 client_clkid->id[7] = eth_hdr->s_addr.addr_bytes[5];
457
458 rte_memcpy(&ptp_data->client_clock_id,
459 client_clkid,
460 sizeof(struct clock_id));
461
462 /* Enable flag for hardware timestamping. */
463 created_pkt->ol_flags |= PKT_TX_IEEE1588_TMST;
464
465 /*Read value from NIC to prevent latching with old value. */
466 rte_eth_timesync_read_tx_timestamp(ptp_data->portid,
467 &ptp_data->tstamp3);
468
469 /* Transmit the packet. */
470 rte_eth_tx_burst(ptp_data->portid, 0, &created_pkt, 1);
471
472 wait_us = 0;
473 ptp_data->tstamp3.tv_nsec = 0;
474 ptp_data->tstamp3.tv_sec = 0;
475
476 /* Wait at least 1 us to read TX timestamp. */
477 while ((rte_eth_timesync_read_tx_timestamp(ptp_data->portid,
478 &ptp_data->tstamp3) < 0) && (wait_us < 1000)) {
479 rte_delay_us(1);
480 wait_us++;
481 }
482 }
483 }
484
485 /*
486 * Update the kernel time with the difference between it and the current NIC
487 * time.
488 */
489 static inline void
update_kernel_time(void)490 update_kernel_time(void)
491 {
492 int64_t nsec;
493 struct timespec net_time, sys_time;
494
495 clock_gettime(CLOCK_REALTIME, &sys_time);
496 rte_eth_timesync_read_time(ptp_data.current_ptp_port, &net_time);
497
498 nsec = (int64_t)timespec64_to_ns(&net_time) -
499 (int64_t)timespec64_to_ns(&sys_time);
500
501 ptp_data.new_adj = ns_to_timeval(nsec);
502
503 /*
504 * If difference between kernel time and system time in NIC is too big
505 * (more than +/- 20 microseconds), use clock_settime to set directly
506 * the kernel time, as adjtime is better for small adjustments (takes
507 * longer to adjust the time).
508 */
509
510 if (nsec > KERNEL_TIME_ADJUST_LIMIT || nsec < -KERNEL_TIME_ADJUST_LIMIT)
511 clock_settime(CLOCK_REALTIME, &net_time);
512 else
513 adjtime(&ptp_data.new_adj, 0);
514
515
516 }
517
518 /*
519 * Parse the DELAY_RESP message.
520 */
521 static void
parse_drsp(struct ptpv2_data_slave_ordinary * ptp_data)522 parse_drsp(struct ptpv2_data_slave_ordinary *ptp_data)
523 {
524 struct rte_mbuf *m = ptp_data->m;
525 struct ptp_message *ptp_msg;
526 struct tstamp *rx_tstamp;
527 uint16_t seq_id;
528
529 ptp_msg = (struct ptp_message *) (rte_pktmbuf_mtod(m, char *) +
530 sizeof(struct rte_ether_hdr));
531 seq_id = rte_be_to_cpu_16(ptp_msg->delay_resp.hdr.seq_id);
532 if (memcmp(&ptp_data->client_clock_id,
533 &ptp_msg->delay_resp.req_port_id.clock_id,
534 sizeof(struct clock_id)) == 0) {
535 if (seq_id == ptp_data->seqID_FOLLOWUP) {
536 rx_tstamp = &ptp_msg->delay_resp.rx_tstamp;
537 ptp_data->tstamp4.tv_nsec = ntohl(rx_tstamp->ns);
538 ptp_data->tstamp4.tv_sec =
539 ((uint64_t)ntohl(rx_tstamp->sec_lsb)) |
540 (((uint64_t)ntohs(rx_tstamp->sec_msb)) << 32);
541
542 /* Evaluate the delta for adjustment. */
543 ptp_data->delta = delta_eval(ptp_data);
544
545 rte_eth_timesync_adjust_time(ptp_data->portid,
546 ptp_data->delta);
547
548 ptp_data->current_ptp_port = ptp_data->portid;
549
550 /* Update kernel time if enabled in app parameters. */
551 if (ptp_data->kernel_time_set == 1)
552 update_kernel_time();
553
554
555
556 }
557 }
558 }
559
560 /* This function processes PTP packets, implementing slave PTP IEEE1588 L2
561 * functionality.
562 */
563 static void
parse_ptp_frames(uint16_t portid,struct rte_mbuf * m)564 parse_ptp_frames(uint16_t portid, struct rte_mbuf *m) {
565 struct ptp_header *ptp_hdr;
566 struct rte_ether_hdr *eth_hdr;
567 uint16_t eth_type;
568
569 eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
570 eth_type = rte_be_to_cpu_16(eth_hdr->ether_type);
571
572 if (eth_type == PTP_PROTOCOL) {
573 ptp_data.m = m;
574 ptp_data.portid = portid;
575 ptp_hdr = (struct ptp_header *)(rte_pktmbuf_mtod(m, char *)
576 + sizeof(struct rte_ether_hdr));
577
578 switch (ptp_hdr->msg_type) {
579 case SYNC:
580 parse_sync(&ptp_data, m->timesync);
581 break;
582 case FOLLOW_UP:
583 parse_fup(&ptp_data);
584 break;
585 case DELAY_RESP:
586 parse_drsp(&ptp_data);
587 print_clock_info(&ptp_data);
588 break;
589 default:
590 break;
591 }
592 }
593 }
594
595 /*
596 * The lcore main. This is the main thread that does the work, reading from an
597 * input port and writing to an output port.
598 */
599 static __rte_noreturn void
lcore_main(void)600 lcore_main(void)
601 {
602 uint16_t portid;
603 unsigned nb_rx;
604 struct rte_mbuf *m;
605
606 /*
607 * Check that the port is on the same NUMA node as the polling thread
608 * for best performance.
609 */
610 printf("\nCore %u Waiting for SYNC packets. [Ctrl+C to quit]\n",
611 rte_lcore_id());
612
613 /* Run until the application is quit or killed. */
614
615 while (1) {
616 /* Read packet from RX queues. */
617 for (portid = 0; portid < ptp_enabled_port_nb; portid++) {
618
619 portid = ptp_enabled_ports[portid];
620 nb_rx = rte_eth_rx_burst(portid, 0, &m, 1);
621
622 if (likely(nb_rx == 0))
623 continue;
624
625 if (m->ol_flags & PKT_RX_IEEE1588_PTP)
626 parse_ptp_frames(portid, m);
627
628 rte_pktmbuf_free(m);
629 }
630 }
631 }
632
633 static void
print_usage(const char * prgname)634 print_usage(const char *prgname)
635 {
636 printf("%s [EAL options] -- -p PORTMASK -T VALUE\n"
637 " -T VALUE: 0 - Disable, 1 - Enable Linux Clock"
638 " Synchronization (0 default)\n"
639 " -p PORTMASK: hexadecimal bitmask of ports to configure\n",
640 prgname);
641 }
642
643 static int
ptp_parse_portmask(const char * portmask)644 ptp_parse_portmask(const char *portmask)
645 {
646 char *end = NULL;
647 unsigned long pm;
648
649 /* Parse the hexadecimal string. */
650 pm = strtoul(portmask, &end, 16);
651
652 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
653 return 0;
654
655 return pm;
656 }
657
658 static int
parse_ptp_kernel(const char * param)659 parse_ptp_kernel(const char *param)
660 {
661 char *end = NULL;
662 unsigned long pm;
663
664 /* Parse the hexadecimal string. */
665 pm = strtoul(param, &end, 16);
666
667 if ((param[0] == '\0') || (end == NULL) || (*end != '\0'))
668 return -1;
669 if (pm == 0)
670 return 0;
671
672 return 1;
673 }
674
675 /* Parse the commandline arguments. */
676 static int
ptp_parse_args(int argc,char ** argv)677 ptp_parse_args(int argc, char **argv)
678 {
679 int opt, ret;
680 char **argvopt;
681 int option_index;
682 char *prgname = argv[0];
683 static struct option lgopts[] = { {NULL, 0, 0, 0} };
684
685 argvopt = argv;
686
687 while ((opt = getopt_long(argc, argvopt, "p:T:",
688 lgopts, &option_index)) != EOF) {
689
690 switch (opt) {
691
692 /* Portmask. */
693 case 'p':
694 ptp_enabled_port_mask = ptp_parse_portmask(optarg);
695 if (ptp_enabled_port_mask == 0) {
696 printf("invalid portmask\n");
697 print_usage(prgname);
698 return -1;
699 }
700 break;
701 /* Time synchronization. */
702 case 'T':
703 ret = parse_ptp_kernel(optarg);
704 if (ret < 0) {
705 print_usage(prgname);
706 return -1;
707 }
708
709 ptp_data.kernel_time_set = ret;
710 break;
711
712 default:
713 print_usage(prgname);
714 return -1;
715 }
716 }
717
718 argv[optind-1] = prgname;
719
720 optind = 1; /* Reset getopt lib. */
721
722 return 0;
723 }
724
725 /*
726 * The main function, which does initialization and calls the per-lcore
727 * functions.
728 */
729 int
main(int argc,char * argv[])730 main(int argc, char *argv[])
731 {
732 unsigned nb_ports;
733
734 uint16_t portid;
735
736 /* Initialize the Environment Abstraction Layer (EAL). */
737 int ret = rte_eal_init(argc, argv);
738
739 if (ret < 0)
740 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
741
742 memset(&ptp_data, '\0', sizeof(struct ptpv2_data_slave_ordinary));
743
744 argc -= ret;
745 argv += ret;
746
747 ret = ptp_parse_args(argc, argv);
748 if (ret < 0)
749 rte_exit(EXIT_FAILURE, "Error with PTP initialization\n");
750
751 /* Check that there is an even number of ports to send/receive on. */
752 nb_ports = rte_eth_dev_count_avail();
753
754 /* Creates a new mempool in memory to hold the mbufs. */
755 mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", NUM_MBUFS * nb_ports,
756 MBUF_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
757
758 if (mbuf_pool == NULL)
759 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
760
761 /* Initialize all ports. */
762 RTE_ETH_FOREACH_DEV(portid) {
763 if ((ptp_enabled_port_mask & (1 << portid)) != 0) {
764 if (port_init(portid, mbuf_pool) == 0) {
765 ptp_enabled_ports[ptp_enabled_port_nb] = portid;
766 ptp_enabled_port_nb++;
767 } else {
768 rte_exit(EXIT_FAILURE,
769 "Cannot init port %"PRIu8 "\n",
770 portid);
771 }
772 } else
773 printf("Skipping disabled port %u\n", portid);
774 }
775
776 if (ptp_enabled_port_nb == 0) {
777 rte_exit(EXIT_FAILURE,
778 "All available ports are disabled."
779 " Please set portmask.\n");
780 }
781
782 if (rte_lcore_count() > 1)
783 printf("\nWARNING: Too many lcores enabled. Only 1 used.\n");
784
785 /* Call lcore_main on the main core only. */
786 lcore_main();
787
788 return 0;
789 }
790