4 * Copyright(c) 2010-2016 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <sys/types.h>
40 #include <sys/queue.h>
41 #include <netinet/in.h>
48 #include <rte_common.h>
50 #include <rte_malloc.h>
51 #include <rte_memory.h>
52 #include <rte_memcpy.h>
53 #include <rte_memzone.h>
55 #include <rte_per_lcore.h>
56 #include <rte_launch.h>
57 #include <rte_atomic.h>
58 #include <rte_cycles.h>
59 #include <rte_prefetch.h>
60 #include <rte_lcore.h>
61 #include <rte_per_lcore.h>
62 #include <rte_branch_prediction.h>
63 #include <rte_interrupts.h>
65 #include <rte_random.h>
66 #include <rte_debug.h>
67 #include <rte_ether.h>
68 #include <rte_ethdev.h>
69 #include <rte_mempool.h>
71 #include <rte_timer.h>
72 #include <rte_keepalive.h>
76 #define RTE_LOGTYPE_L2FWD RTE_LOGTYPE_USER1
80 #define MAX_PKT_BURST 32
81 #define BURST_TX_DRAIN_US 100 /* TX drain every ~100us */
84 * Configurable number of RX/TX ring descriptors
86 #define RTE_TEST_RX_DESC_DEFAULT 128
87 #define RTE_TEST_TX_DESC_DEFAULT 512
88 static uint16_t nb_rxd
= RTE_TEST_RX_DESC_DEFAULT
;
89 static uint16_t nb_txd
= RTE_TEST_TX_DESC_DEFAULT
;
91 /* ethernet addresses of ports */
92 static struct ether_addr l2fwd_ports_eth_addr
[RTE_MAX_ETHPORTS
];
94 /* mask of enabled ports */
95 static uint32_t l2fwd_enabled_port_mask
;
97 /* list of enabled ports */
98 static uint32_t l2fwd_dst_ports
[RTE_MAX_ETHPORTS
];
100 static unsigned int l2fwd_rx_queue_per_lcore
= 1;
102 #define MAX_RX_QUEUE_PER_LCORE 16
103 #define MAX_TX_QUEUE_PER_PORT 16
104 struct lcore_queue_conf
{
106 unsigned rx_port_list
[MAX_RX_QUEUE_PER_LCORE
];
107 } __rte_cache_aligned
;
108 struct lcore_queue_conf lcore_queue_conf
[RTE_MAX_LCORE
];
110 struct rte_eth_dev_tx_buffer
*tx_buffer
[RTE_MAX_ETHPORTS
];
112 static const struct rte_eth_conf port_conf
= {
115 .header_split
= 0, /**< Header Split disabled */
116 .hw_ip_checksum
= 0, /**< IP checksum offload disabled */
117 .hw_vlan_filter
= 0, /**< VLAN filtering disabled */
118 .jumbo_frame
= 0, /**< Jumbo Frame Support disabled */
119 .hw_strip_crc
= 0, /**< CRC stripped by hardware */
122 .mq_mode
= ETH_MQ_TX_NONE
,
126 struct rte_mempool
*l2fwd_pktmbuf_pool
= NULL
;
128 /* Per-port statistics struct */
129 struct l2fwd_port_statistics
{
133 } __rte_cache_aligned
;
134 struct l2fwd_port_statistics port_statistics
[RTE_MAX_ETHPORTS
];
136 /* A tsc-based timer responsible for triggering statistics printout */
137 #define TIMER_MILLISECOND 1
138 #define MAX_TIMER_PERIOD 86400 /* 1 day max */
139 static int64_t timer_period
= 10 * TIMER_MILLISECOND
* 1000; /* 10 seconds */
140 static int64_t check_period
= 5; /* default check cycle is 5ms */
142 /* Keepalive structure */
143 struct rte_keepalive
*rte_global_keepalive_info
;
145 /* Print out statistics on packets dropped */
147 print_stats(__attribute__((unused
)) struct rte_timer
*ptr_timer
,
148 __attribute__((unused
)) void *ptr_data
)
150 uint64_t total_packets_dropped
, total_packets_tx
, total_packets_rx
;
153 total_packets_dropped
= 0;
154 total_packets_tx
= 0;
155 total_packets_rx
= 0;
157 const char clr
[] = { 27, '[', '2', 'J', '\0' };
158 const char topLeft
[] = { 27, '[', '1', ';', '1', 'H', '\0' };
160 /* Clear screen and move to top left */
161 printf("%s%s", clr
, topLeft
);
163 printf("\nPort statistics ====================================");
165 for (portid
= 0; portid
< RTE_MAX_ETHPORTS
; portid
++) {
166 /* skip disabled ports */
167 if ((l2fwd_enabled_port_mask
& (1 << portid
)) == 0)
169 printf("\nStatistics for port %u ------------------------------"
170 "\nPackets sent: %24"PRIu64
171 "\nPackets received: %20"PRIu64
172 "\nPackets dropped: %21"PRIu64
,
174 port_statistics
[portid
].tx
,
175 port_statistics
[portid
].rx
,
176 port_statistics
[portid
].dropped
);
178 total_packets_dropped
+= port_statistics
[portid
].dropped
;
179 total_packets_tx
+= port_statistics
[portid
].tx
;
180 total_packets_rx
+= port_statistics
[portid
].rx
;
182 printf("\nAggregate statistics ==============================="
183 "\nTotal packets sent: %18"PRIu64
184 "\nTotal packets received: %14"PRIu64
185 "\nTotal packets dropped: %15"PRIu64
,
188 total_packets_dropped
);
189 printf("\n====================================================\n");
193 l2fwd_simple_forward(struct rte_mbuf
*m
, unsigned portid
)
195 struct ether_hdr
*eth
;
199 struct rte_eth_dev_tx_buffer
*buffer
;
201 dst_port
= l2fwd_dst_ports
[portid
];
202 eth
= rte_pktmbuf_mtod(m
, struct ether_hdr
*);
204 /* 02:00:00:00:00:xx */
205 tmp
= ð
->d_addr
.addr_bytes
[0];
206 *((uint64_t *)tmp
) = 0x000000000002 + ((uint64_t)dst_port
<< 40);
209 ether_addr_copy(&l2fwd_ports_eth_addr
[dst_port
], ð
->s_addr
);
211 buffer
= tx_buffer
[dst_port
];
212 sent
= rte_eth_tx_buffer(dst_port
, 0, buffer
, m
);
214 port_statistics
[dst_port
].tx
+= sent
;
217 /* main processing loop */
219 l2fwd_main_loop(void)
221 struct rte_mbuf
*pkts_burst
[MAX_PKT_BURST
];
225 uint64_t prev_tsc
, diff_tsc
, cur_tsc
;
226 unsigned i
, j
, portid
, nb_rx
;
227 struct lcore_queue_conf
*qconf
;
228 const uint64_t drain_tsc
= (rte_get_tsc_hz() + US_PER_S
- 1)
229 / US_PER_S
* BURST_TX_DRAIN_US
;
230 struct rte_eth_dev_tx_buffer
*buffer
;
234 lcore_id
= rte_lcore_id();
235 qconf
= &lcore_queue_conf
[lcore_id
];
237 if (qconf
->n_rx_port
== 0) {
238 RTE_LOG(INFO
, L2FWD
, "lcore %u has nothing to do\n", lcore_id
);
242 RTE_LOG(INFO
, L2FWD
, "entering main loop on lcore %u\n", lcore_id
);
244 for (i
= 0; i
< qconf
->n_rx_port
; i
++) {
246 portid
= qconf
->rx_port_list
[i
];
247 RTE_LOG(INFO
, L2FWD
, " -- lcoreid=%u portid=%u\n", lcore_id
,
251 uint64_t tsc_initial
= rte_rdtsc();
252 uint64_t tsc_lifetime
= (rand()&0x07) * rte_get_tsc_hz();
255 /* Keepalive heartbeat */
256 rte_keepalive_mark_alive(rte_global_keepalive_info
);
258 cur_tsc
= rte_rdtsc();
261 * Die randomly within 7 secs for demo purposes if
264 if (check_period
> 0 && cur_tsc
- tsc_initial
> tsc_lifetime
)
268 * TX burst queue drain
270 diff_tsc
= cur_tsc
- prev_tsc
;
271 if (unlikely(diff_tsc
> drain_tsc
)) {
273 for (i
= 0; i
< qconf
->n_rx_port
; i
++) {
275 portid
= l2fwd_dst_ports
[qconf
->rx_port_list
[i
]];
276 buffer
= tx_buffer
[portid
];
278 sent
= rte_eth_tx_buffer_flush(portid
, 0, buffer
);
280 port_statistics
[portid
].tx
+= sent
;
288 * Read packet from RX queues
290 for (i
= 0; i
< qconf
->n_rx_port
; i
++) {
292 portid
= qconf
->rx_port_list
[i
];
293 nb_rx
= rte_eth_rx_burst((uint8_t) portid
, 0,
294 pkts_burst
, MAX_PKT_BURST
);
296 port_statistics
[portid
].rx
+= nb_rx
;
298 for (j
= 0; j
< nb_rx
; j
++) {
300 rte_prefetch0(rte_pktmbuf_mtod(m
, void *));
301 l2fwd_simple_forward(m
, portid
);
308 l2fwd_launch_one_lcore(__attribute__((unused
)) void *dummy
)
316 l2fwd_usage(const char *prgname
)
318 printf("%s [EAL options] -- -p PORTMASK [-q NQ]\n"
319 " -p PORTMASK: hexadecimal bitmask of ports to configure\n"
320 " -q NQ: number of queue (=ports) per lcore (default is 1)\n"
321 " -K PERIOD: Keepalive check period (5 default; 86400 max)\n"
322 " -T PERIOD: statistics will be refreshed each PERIOD seconds (0 to disable, 10 default, 86400 maximum)\n",
327 l2fwd_parse_portmask(const char *portmask
)
332 /* parse hexadecimal string */
333 pm
= strtoul(portmask
, &end
, 16);
334 if ((portmask
[0] == '\0') || (end
== NULL
) || (*end
!= '\0'))
344 l2fwd_parse_nqueue(const char *q_arg
)
349 /* parse hexadecimal string */
350 n
= strtoul(q_arg
, &end
, 10);
351 if ((q_arg
[0] == '\0') || (end
== NULL
) || (*end
!= '\0'))
355 if (n
>= MAX_RX_QUEUE_PER_LCORE
)
362 l2fwd_parse_timer_period(const char *q_arg
)
367 /* parse number string */
368 n
= strtol(q_arg
, &end
, 10);
369 if ((q_arg
[0] == '\0') || (end
== NULL
) || (*end
!= '\0'))
371 if (n
>= MAX_TIMER_PERIOD
)
378 l2fwd_parse_check_period(const char *q_arg
)
383 /* parse number string */
384 n
= strtol(q_arg
, &end
, 10);
385 if ((q_arg
[0] == '\0') || (end
== NULL
) || (*end
!= '\0'))
387 if (n
>= MAX_TIMER_PERIOD
)
393 /* Parse the argument given in the command line of the application */
395 l2fwd_parse_args(int argc
, char **argv
)
400 char *prgname
= argv
[0];
401 static struct option lgopts
[] = {
407 while ((opt
= getopt_long(argc
, argvopt
, "p:q:T:K:",
408 lgopts
, &option_index
)) != EOF
) {
413 l2fwd_enabled_port_mask
= l2fwd_parse_portmask(optarg
);
414 if (l2fwd_enabled_port_mask
== 0) {
415 printf("invalid portmask\n");
416 l2fwd_usage(prgname
);
423 l2fwd_rx_queue_per_lcore
= l2fwd_parse_nqueue(optarg
);
424 if (l2fwd_rx_queue_per_lcore
== 0) {
425 printf("invalid queue number\n");
426 l2fwd_usage(prgname
);
433 timer_period
= l2fwd_parse_timer_period(optarg
)
434 * (int64_t)(1000 * TIMER_MILLISECOND
);
435 if (timer_period
< 0) {
436 printf("invalid timer period\n");
437 l2fwd_usage(prgname
);
444 check_period
= l2fwd_parse_check_period(optarg
);
445 if (check_period
< 0) {
446 printf("invalid check period\n");
447 l2fwd_usage(prgname
);
454 l2fwd_usage(prgname
);
458 l2fwd_usage(prgname
);
464 argv
[optind
-1] = prgname
;
467 optind
= 0; /* reset getopt lib */
471 /* Check the link status of all ports in up to 9s, and print them finally */
473 check_all_ports_link_status(uint8_t port_num
, uint32_t port_mask
)
475 #define CHECK_INTERVAL 100 /* 100ms */
476 #define MAX_CHECK_TIME 90 /* 9s (90 * 100ms) in total */
477 uint8_t portid
, count
, all_ports_up
, print_flag
= 0;
478 struct rte_eth_link link
;
480 printf("\nChecking link status");
482 for (count
= 0; count
<= MAX_CHECK_TIME
; count
++) {
484 for (portid
= 0; portid
< port_num
; portid
++) {
485 if ((port_mask
& (1 << portid
)) == 0)
487 memset(&link
, 0, sizeof(link
));
488 rte_eth_link_get_nowait(portid
, &link
);
489 /* print link status if flag set */
490 if (print_flag
== 1) {
491 if (link
.link_status
)
492 printf("Port %d Link Up - speed %u "
493 "Mbps - %s\n", (uint8_t)portid
,
494 (unsigned)link
.link_speed
,
495 (link
.link_duplex
== ETH_LINK_FULL_DUPLEX
) ?
496 ("full-duplex") : ("half-duplex\n"));
498 printf("Port %d Link Down\n",
502 /* clear all_ports_up flag if any link down */
503 if (link
.link_status
== ETH_LINK_DOWN
) {
508 /* after finally printing all link status, get out */
512 if (all_ports_up
== 0) {
515 rte_delay_ms(CHECK_INTERVAL
);
518 /* set the print_flag if all ports up or timeout */
519 if (all_ports_up
== 1 || count
== (MAX_CHECK_TIME
- 1)) {
527 dead_core(__rte_unused
void *ptr_data
, const int id_core
)
529 printf("Dead core %i - restarting..\n", id_core
);
530 if (rte_eal_get_lcore_state(id_core
) == FINISHED
) {
531 rte_eal_wait_lcore(id_core
);
532 rte_eal_remote_launch(l2fwd_launch_one_lcore
, NULL
, id_core
);
534 printf("..false positive!\n");
539 relay_core_state(void *ptr_data
, const int id_core
,
540 const enum rte_keepalive_state core_state
, uint64_t last_alive
)
542 rte_keepalive_relayed_state((struct rte_keepalive_shm
*)ptr_data
,
543 id_core
, core_state
, last_alive
);
547 main(int argc
, char **argv
)
549 struct lcore_queue_conf
*qconf
;
550 struct rte_eth_dev_info dev_info
;
553 uint8_t nb_ports_available
;
554 uint8_t portid
, last_port
;
555 unsigned lcore_id
, rx_lcore_id
;
556 unsigned nb_ports_in_mask
= 0;
559 ret
= rte_eal_init(argc
, argv
);
561 rte_exit(EXIT_FAILURE
, "Invalid EAL arguments\n");
565 l2fwd_enabled_port_mask
= 0;
567 /* parse application arguments (after the EAL ones) */
568 ret
= l2fwd_parse_args(argc
, argv
);
570 rte_exit(EXIT_FAILURE
, "Invalid L2FWD arguments\n");
572 /* create the mbuf pool */
573 l2fwd_pktmbuf_pool
= rte_pktmbuf_pool_create("mbuf_pool", NB_MBUF
, 32,
574 0, RTE_MBUF_DEFAULT_BUF_SIZE
, rte_socket_id());
575 if (l2fwd_pktmbuf_pool
== NULL
)
576 rte_exit(EXIT_FAILURE
, "Cannot init mbuf pool\n");
578 nb_ports
= rte_eth_dev_count();
580 rte_exit(EXIT_FAILURE
, "No Ethernet ports - bye\n");
582 /* reset l2fwd_dst_ports */
583 for (portid
= 0; portid
< RTE_MAX_ETHPORTS
; portid
++)
584 l2fwd_dst_ports
[portid
] = 0;
588 * Each logical core is assigned a dedicated TX queue on each port.
590 for (portid
= 0; portid
< nb_ports
; portid
++) {
591 /* skip ports that are not enabled */
592 if ((l2fwd_enabled_port_mask
& (1 << portid
)) == 0)
595 if (nb_ports_in_mask
% 2) {
596 l2fwd_dst_ports
[portid
] = last_port
;
597 l2fwd_dst_ports
[last_port
] = portid
;
603 rte_eth_dev_info_get(portid
, &dev_info
);
605 if (nb_ports_in_mask
% 2) {
606 printf("Notice: odd number of ports in portmask.\n");
607 l2fwd_dst_ports
[last_port
] = last_port
;
613 /* Initialize the port/queue configuration of each logical core */
614 for (portid
= 0; portid
< nb_ports
; portid
++) {
615 /* skip ports that are not enabled */
616 if ((l2fwd_enabled_port_mask
& (1 << portid
)) == 0)
619 /* get the lcore_id for this port */
620 while (rte_lcore_is_enabled(rx_lcore_id
) == 0 ||
621 lcore_queue_conf
[rx_lcore_id
].n_rx_port
==
622 l2fwd_rx_queue_per_lcore
) {
624 if (rx_lcore_id
>= RTE_MAX_LCORE
)
625 rte_exit(EXIT_FAILURE
, "Not enough cores\n");
628 if (qconf
!= &lcore_queue_conf
[rx_lcore_id
])
629 /* Assigned a new logical core in the loop above. */
630 qconf
= &lcore_queue_conf
[rx_lcore_id
];
632 qconf
->rx_port_list
[qconf
->n_rx_port
] = portid
;
634 printf("Lcore %u: RX port %u\n",
635 rx_lcore_id
, (unsigned) portid
);
638 nb_ports_available
= nb_ports
;
640 /* Initialise each port */
641 for (portid
= 0; portid
< nb_ports
; portid
++) {
642 /* skip ports that are not enabled */
643 if ((l2fwd_enabled_port_mask
& (1 << portid
)) == 0) {
644 printf("Skipping disabled port %u\n",
646 nb_ports_available
--;
650 printf("Initializing port %u... ", (unsigned) portid
);
652 ret
= rte_eth_dev_configure(portid
, 1, 1, &port_conf
);
654 rte_exit(EXIT_FAILURE
,
655 "Cannot configure device: err=%d, port=%u\n",
656 ret
, (unsigned) portid
);
658 rte_eth_macaddr_get(portid
, &l2fwd_ports_eth_addr
[portid
]);
660 /* init one RX queue */
662 ret
= rte_eth_rx_queue_setup(portid
, 0, nb_rxd
,
663 rte_eth_dev_socket_id(portid
),
667 rte_exit(EXIT_FAILURE
,
668 "rte_eth_rx_queue_setup:err=%d, port=%u\n",
669 ret
, (unsigned) portid
);
671 /* init one TX queue on each port */
673 ret
= rte_eth_tx_queue_setup(portid
, 0, nb_txd
,
674 rte_eth_dev_socket_id(portid
),
677 rte_exit(EXIT_FAILURE
,
678 "rte_eth_tx_queue_setup:err=%d, port=%u\n",
679 ret
, (unsigned) portid
);
681 /* Initialize TX buffers */
682 tx_buffer
[portid
] = rte_zmalloc_socket("tx_buffer",
683 RTE_ETH_TX_BUFFER_SIZE(MAX_PKT_BURST
), 0,
684 rte_eth_dev_socket_id(portid
));
685 if (tx_buffer
[portid
] == NULL
)
686 rte_exit(EXIT_FAILURE
, "Cannot allocate buffer for tx on port %u\n",
689 rte_eth_tx_buffer_init(tx_buffer
[portid
], MAX_PKT_BURST
);
691 ret
= rte_eth_tx_buffer_set_err_callback(tx_buffer
[portid
],
692 rte_eth_tx_buffer_count_callback
,
693 &port_statistics
[portid
].dropped
);
695 rte_exit(EXIT_FAILURE
, "Cannot set error callback for "
696 "tx buffer on port %u\n", (unsigned) portid
);
699 ret
= rte_eth_dev_start(portid
);
701 rte_exit(EXIT_FAILURE
,
702 "rte_eth_dev_start:err=%d, port=%u\n",
703 ret
, (unsigned) portid
);
705 rte_eth_promiscuous_enable(portid
);
707 printf("Port %u, MAC address: "
708 "%02X:%02X:%02X:%02X:%02X:%02X\n\n",
710 l2fwd_ports_eth_addr
[portid
].addr_bytes
[0],
711 l2fwd_ports_eth_addr
[portid
].addr_bytes
[1],
712 l2fwd_ports_eth_addr
[portid
].addr_bytes
[2],
713 l2fwd_ports_eth_addr
[portid
].addr_bytes
[3],
714 l2fwd_ports_eth_addr
[portid
].addr_bytes
[4],
715 l2fwd_ports_eth_addr
[portid
].addr_bytes
[5]);
717 /* initialize port stats */
718 memset(&port_statistics
, 0, sizeof(port_statistics
));
721 if (!nb_ports_available
) {
722 rte_exit(EXIT_FAILURE
,
723 "All available ports are disabled. Please set portmask.\n");
726 check_all_ports_link_status(nb_ports
, l2fwd_enabled_port_mask
);
728 struct rte_timer hb_timer
, stats_timer
;
730 rte_timer_subsystem_init();
731 rte_timer_init(&stats_timer
);
733 if (check_period
> 0) {
734 struct rte_keepalive_shm
*ka_shm
;
736 ka_shm
= rte_keepalive_shm_create();
738 rte_exit(EXIT_FAILURE
,
739 "rte_keepalive_shm_create() failed");
740 rte_global_keepalive_info
=
741 rte_keepalive_create(&dead_core
, ka_shm
);
742 if (rte_global_keepalive_info
== NULL
)
743 rte_exit(EXIT_FAILURE
, "init_keep_alive() failed");
744 rte_keepalive_register_relay_callback(rte_global_keepalive_info
,
745 relay_core_state
, ka_shm
);
746 rte_timer_init(&hb_timer
);
747 if (rte_timer_reset(&hb_timer
,
748 (check_period
* rte_get_timer_hz()) / 1000,
751 (void(*)(struct rte_timer
*, void*))
752 &rte_keepalive_dispatch_pings
,
753 rte_global_keepalive_info
755 rte_exit(EXIT_FAILURE
, "Keepalive setup failure.\n");
757 if (timer_period
> 0) {
758 if (rte_timer_reset(&stats_timer
,
759 (timer_period
* rte_get_timer_hz()) / 1000,
764 rte_exit(EXIT_FAILURE
, "Stats setup failure.\n");
766 /* launch per-lcore init on every slave lcore */
767 RTE_LCORE_FOREACH_SLAVE(lcore_id
) {
768 struct lcore_queue_conf
*qconf
= &lcore_queue_conf
[lcore_id
];
770 if (qconf
->n_rx_port
== 0)
772 "lcore %u has nothing to do\n",
776 rte_eal_remote_launch(
777 l2fwd_launch_one_lcore
,
781 rte_keepalive_register_core(rte_global_keepalive_info
,
790 RTE_LCORE_FOREACH_SLAVE(lcore_id
) {
791 if (rte_eal_wait_lcore(lcore_id
) < 0)