1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 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 16 * distribution. 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. 20 * 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. 32 */ 33 34 #include <stdint.h> 35 #include <sys/queue.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <stdio.h> 39 #include <assert.h> 40 #include <errno.h> 41 #include <signal.h> 42 #include <stdarg.h> 43 #include <inttypes.h> 44 #include <getopt.h> 45 46 #include <rte_common.h> 47 #include <rte_log.h> 48 #include <rte_memory.h> 49 #include <rte_memcpy.h> 50 #include <rte_eal.h> 51 #include <rte_launch.h> 52 #include <rte_atomic.h> 53 #include <rte_cycles.h> 54 #include <rte_prefetch.h> 55 #include <rte_lcore.h> 56 #include <rte_per_lcore.h> 57 #include <rte_branch_prediction.h> 58 #include <rte_interrupts.h> 59 #include <rte_pci.h> 60 #include <rte_random.h> 61 #include <rte_debug.h> 62 #include <rte_ether.h> 63 #include <rte_ethdev.h> 64 #include <rte_mempool.h> 65 #include <rte_mbuf.h> 66 67 #define MAX_QUEUES 1024 68 /* 69 * 1024 queues require to meet the needs of a large number of vmdq_pools. 70 * (RX/TX_queue_nb * RX/TX_ring_descriptors_nb) per port. 71 */ 72 #define NUM_MBUFS_PER_PORT (MAX_QUEUES * RTE_MAX(RTE_TEST_RX_DESC_DEFAULT, \ 73 RTE_TEST_TX_DESC_DEFAULT)) 74 #define MBUF_CACHE_SIZE 64 75 76 #define MAX_PKT_BURST 32 77 78 /* 79 * Configurable number of RX/TX ring descriptors 80 */ 81 #define RTE_TEST_RX_DESC_DEFAULT 128 82 #define RTE_TEST_TX_DESC_DEFAULT 512 83 84 #define INVALID_PORT_ID 0xFF 85 86 /* mask of enabled ports */ 87 static uint32_t enabled_port_mask; 88 89 /* number of pools (if user does not specify any, 8 by default */ 90 static uint32_t num_queues = 8; 91 static uint32_t num_pools = 8; 92 93 /* empty vmdq configuration structure. Filled in programatically */ 94 static const struct rte_eth_conf vmdq_conf_default = { 95 .rxmode = { 96 .mq_mode = ETH_MQ_RX_VMDQ_ONLY, 97 .split_hdr_size = 0, 98 .header_split = 0, /**< Header Split disabled */ 99 .hw_ip_checksum = 0, /**< IP checksum offload disabled */ 100 .hw_vlan_filter = 0, /**< VLAN filtering disabled */ 101 .jumbo_frame = 0, /**< Jumbo Frame Support disabled */ 102 }, 103 104 .txmode = { 105 .mq_mode = ETH_MQ_TX_NONE, 106 }, 107 .rx_adv_conf = { 108 /* 109 * should be overridden separately in code with 110 * appropriate values 111 */ 112 .vmdq_rx_conf = { 113 .nb_queue_pools = ETH_8_POOLS, 114 .enable_default_pool = 0, 115 .default_pool = 0, 116 .nb_pool_maps = 0, 117 .pool_map = {{0, 0},}, 118 }, 119 }, 120 }; 121 122 static unsigned lcore_ids[RTE_MAX_LCORE]; 123 static uint16_t ports[RTE_MAX_ETHPORTS]; 124 static unsigned num_ports; /**< The number of ports specified in command line */ 125 126 /* array used for printing out statistics */ 127 volatile unsigned long rxPackets[MAX_QUEUES] = {0}; 128 129 const uint16_t vlan_tags[] = { 130 0, 1, 2, 3, 4, 5, 6, 7, 131 8, 9, 10, 11, 12, 13, 14, 15, 132 16, 17, 18, 19, 20, 21, 22, 23, 133 24, 25, 26, 27, 28, 29, 30, 31, 134 32, 33, 34, 35, 36, 37, 38, 39, 135 40, 41, 42, 43, 44, 45, 46, 47, 136 48, 49, 50, 51, 52, 53, 54, 55, 137 56, 57, 58, 59, 60, 61, 62, 63, 138 }; 139 const uint16_t num_vlans = RTE_DIM(vlan_tags); 140 static uint16_t num_pf_queues, num_vmdq_queues; 141 static uint16_t vmdq_pool_base, vmdq_queue_base; 142 /* pool mac addr template, pool mac addr is like: 52 54 00 12 port# pool# */ 143 static struct ether_addr pool_addr_template = { 144 .addr_bytes = {0x52, 0x54, 0x00, 0x12, 0x00, 0x00} 145 }; 146 147 /* ethernet addresses of ports */ 148 static struct ether_addr vmdq_ports_eth_addr[RTE_MAX_ETHPORTS]; 149 150 #define MAX_QUEUE_NUM_10G 128 151 #define MAX_QUEUE_NUM_1G 8 152 #define MAX_POOL_MAP_NUM_10G 64 153 #define MAX_POOL_MAP_NUM_1G 32 154 #define MAX_POOL_NUM_10G 64 155 #define MAX_POOL_NUM_1G 8 156 /* 157 * Builds up the correct configuration for vmdq based on the vlan tags array 158 * given above, and determine the queue number and pool map number according to 159 * valid pool number 160 */ 161 static inline int 162 get_eth_conf(struct rte_eth_conf *eth_conf, uint32_t num_pools) 163 { 164 struct rte_eth_vmdq_rx_conf conf; 165 unsigned i; 166 167 conf.nb_queue_pools = (enum rte_eth_nb_pools)num_pools; 168 conf.nb_pool_maps = num_pools; 169 conf.enable_default_pool = 0; 170 conf.default_pool = 0; /* set explicit value, even if not used */ 171 172 for (i = 0; i < conf.nb_pool_maps; i++) { 173 conf.pool_map[i].vlan_id = vlan_tags[i]; 174 conf.pool_map[i].pools = (1UL << (i % num_pools)); 175 } 176 177 (void)(rte_memcpy(eth_conf, &vmdq_conf_default, sizeof(*eth_conf))); 178 (void)(rte_memcpy(ð_conf->rx_adv_conf.vmdq_rx_conf, &conf, 179 sizeof(eth_conf->rx_adv_conf.vmdq_rx_conf))); 180 return 0; 181 } 182 183 /* 184 * Initialises a given port using global settings and with the rx buffers 185 * coming from the mbuf_pool passed as parameter 186 */ 187 static inline int 188 port_init(uint16_t port, struct rte_mempool *mbuf_pool) 189 { 190 struct rte_eth_dev_info dev_info; 191 struct rte_eth_rxconf *rxconf; 192 struct rte_eth_conf port_conf; 193 uint16_t rxRings, txRings; 194 uint16_t rxRingSize = RTE_TEST_RX_DESC_DEFAULT; 195 uint16_t txRingSize = RTE_TEST_TX_DESC_DEFAULT; 196 int retval; 197 uint16_t q; 198 uint16_t queues_per_pool; 199 uint32_t max_nb_pools; 200 201 /* 202 * The max pool number from dev_info will be used to validate the pool 203 * number specified in cmd line 204 */ 205 rte_eth_dev_info_get(port, &dev_info); 206 max_nb_pools = (uint32_t)dev_info.max_vmdq_pools; 207 /* 208 * We allow to process part of VMDQ pools specified by num_pools in 209 * command line. 210 */ 211 if (num_pools > max_nb_pools) { 212 printf("num_pools %d >max_nb_pools %d\n", 213 num_pools, max_nb_pools); 214 return -1; 215 } 216 retval = get_eth_conf(&port_conf, max_nb_pools); 217 if (retval < 0) 218 return retval; 219 220 /* 221 * NIC queues are divided into pf queues and vmdq queues. 222 */ 223 /* There is assumption here all ports have the same configuration! */ 224 num_pf_queues = dev_info.max_rx_queues - dev_info.vmdq_queue_num; 225 queues_per_pool = dev_info.vmdq_queue_num / dev_info.max_vmdq_pools; 226 num_vmdq_queues = num_pools * queues_per_pool; 227 num_queues = num_pf_queues + num_vmdq_queues; 228 vmdq_queue_base = dev_info.vmdq_queue_base; 229 vmdq_pool_base = dev_info.vmdq_pool_base; 230 231 printf("pf queue num: %u, configured vmdq pool num: %u," 232 " each vmdq pool has %u queues\n", 233 num_pf_queues, num_pools, queues_per_pool); 234 printf("vmdq queue base: %d pool base %d\n", 235 vmdq_queue_base, vmdq_pool_base); 236 if (port >= rte_eth_dev_count()) 237 return -1; 238 239 /* 240 * Though in this example, we only receive packets from the first queue 241 * of each pool and send packets through first rte_lcore_count() tx 242 * queues of vmdq queues, all queues including pf queues are setup. 243 * This is because VMDQ queues doesn't always start from zero, and the 244 * PMD layer doesn't support selectively initialising part of rx/tx 245 * queues. 246 */ 247 rxRings = (uint16_t)dev_info.max_rx_queues; 248 txRings = (uint16_t)dev_info.max_tx_queues; 249 retval = rte_eth_dev_configure(port, rxRings, txRings, &port_conf); 250 if (retval != 0) 251 return retval; 252 253 retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &rxRingSize, 254 &txRingSize); 255 if (retval != 0) 256 return retval; 257 if (RTE_MAX(rxRingSize, txRingSize) > RTE_MAX(RTE_TEST_RX_DESC_DEFAULT, 258 RTE_TEST_TX_DESC_DEFAULT)) { 259 printf("Mbuf pool has an insufficient size for port %u.\n", 260 port); 261 return -1; 262 } 263 264 rte_eth_dev_info_get(port, &dev_info); 265 rxconf = &dev_info.default_rxconf; 266 rxconf->rx_drop_en = 1; 267 for (q = 0; q < rxRings; q++) { 268 retval = rte_eth_rx_queue_setup(port, q, rxRingSize, 269 rte_eth_dev_socket_id(port), 270 rxconf, 271 mbuf_pool); 272 if (retval < 0) { 273 printf("initialise rx queue %d failed\n", q); 274 return retval; 275 } 276 } 277 278 for (q = 0; q < txRings; q++) { 279 retval = rte_eth_tx_queue_setup(port, q, txRingSize, 280 rte_eth_dev_socket_id(port), 281 NULL); 282 if (retval < 0) { 283 printf("initialise tx queue %d failed\n", q); 284 return retval; 285 } 286 } 287 288 retval = rte_eth_dev_start(port); 289 if (retval < 0) { 290 printf("port %d start failed\n", port); 291 return retval; 292 } 293 294 rte_eth_macaddr_get(port, &vmdq_ports_eth_addr[port]); 295 printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8 296 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n", 297 (unsigned)port, 298 vmdq_ports_eth_addr[port].addr_bytes[0], 299 vmdq_ports_eth_addr[port].addr_bytes[1], 300 vmdq_ports_eth_addr[port].addr_bytes[2], 301 vmdq_ports_eth_addr[port].addr_bytes[3], 302 vmdq_ports_eth_addr[port].addr_bytes[4], 303 vmdq_ports_eth_addr[port].addr_bytes[5]); 304 305 /* 306 * Set mac for each pool. 307 * There is no default mac for the pools in i40. 308 * Removes this after i40e fixes this issue. 309 */ 310 for (q = 0; q < num_pools; q++) { 311 struct ether_addr mac; 312 mac = pool_addr_template; 313 mac.addr_bytes[4] = port; 314 mac.addr_bytes[5] = q; 315 printf("Port %u vmdq pool %u set mac %02x:%02x:%02x:%02x:%02x:%02x\n", 316 port, q, 317 mac.addr_bytes[0], mac.addr_bytes[1], 318 mac.addr_bytes[2], mac.addr_bytes[3], 319 mac.addr_bytes[4], mac.addr_bytes[5]); 320 retval = rte_eth_dev_mac_addr_add(port, &mac, 321 q + vmdq_pool_base); 322 if (retval) { 323 printf("mac addr add failed at pool %d\n", q); 324 return retval; 325 } 326 } 327 328 return 0; 329 } 330 331 /* Check num_pools parameter and set it if OK*/ 332 static int 333 vmdq_parse_num_pools(const char *q_arg) 334 { 335 char *end = NULL; 336 int n; 337 338 /* parse number string */ 339 n = strtol(q_arg, &end, 10); 340 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0')) 341 return -1; 342 343 if (num_pools > num_vlans) { 344 printf("num_pools %d > num_vlans %d\n", num_pools, num_vlans); 345 return -1; 346 } 347 348 num_pools = n; 349 350 return 0; 351 } 352 353 354 static int 355 parse_portmask(const char *portmask) 356 { 357 char *end = NULL; 358 unsigned long pm; 359 360 /* parse hexadecimal string */ 361 pm = strtoul(portmask, &end, 16); 362 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0')) 363 return -1; 364 365 if (pm == 0) 366 return -1; 367 368 return pm; 369 } 370 371 /* Display usage */ 372 static void 373 vmdq_usage(const char *prgname) 374 { 375 printf("%s [EAL options] -- -p PORTMASK]\n" 376 " --nb-pools NP: number of pools\n", 377 prgname); 378 } 379 380 /* Parse the argument (num_pools) given in the command line of the application */ 381 static int 382 vmdq_parse_args(int argc, char **argv) 383 { 384 int opt; 385 int option_index; 386 unsigned i; 387 const char *prgname = argv[0]; 388 static struct option long_option[] = { 389 {"nb-pools", required_argument, NULL, 0}, 390 {NULL, 0, 0, 0} 391 }; 392 393 /* Parse command line */ 394 while ((opt = getopt_long(argc, argv, "p:", long_option, 395 &option_index)) != EOF) { 396 switch (opt) { 397 /* portmask */ 398 case 'p': 399 enabled_port_mask = parse_portmask(optarg); 400 if (enabled_port_mask == 0) { 401 printf("invalid portmask\n"); 402 vmdq_usage(prgname); 403 return -1; 404 } 405 break; 406 case 0: 407 if (vmdq_parse_num_pools(optarg) == -1) { 408 printf("invalid number of pools\n"); 409 vmdq_usage(prgname); 410 return -1; 411 } 412 break; 413 414 default: 415 vmdq_usage(prgname); 416 return -1; 417 } 418 } 419 420 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 421 if (enabled_port_mask & (1 << i)) 422 ports[num_ports++] = (uint8_t)i; 423 } 424 425 if (num_ports < 2 || num_ports % 2) { 426 printf("Current enabled port number is %u," 427 "but it should be even and at least 2\n", num_ports); 428 return -1; 429 } 430 431 return 0; 432 } 433 434 static void 435 update_mac_address(struct rte_mbuf *m, unsigned dst_port) 436 { 437 struct ether_hdr *eth; 438 void *tmp; 439 440 eth = rte_pktmbuf_mtod(m, struct ether_hdr *); 441 442 /* 02:00:00:00:00:xx */ 443 tmp = ð->d_addr.addr_bytes[0]; 444 *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40); 445 446 /* src addr */ 447 ether_addr_copy(&vmdq_ports_eth_addr[dst_port], ð->s_addr); 448 } 449 450 /* When we receive a HUP signal, print out our stats */ 451 static void 452 sighup_handler(int signum) 453 { 454 unsigned q; 455 for (q = 0; q < num_queues; q++) { 456 if (q % (num_queues/num_pools) == 0) 457 printf("\nPool %u: ", q/(num_queues/num_pools)); 458 printf("%lu ", rxPackets[q]); 459 } 460 printf("\nFinished handling signal %d\n", signum); 461 } 462 463 /* 464 * Main thread that does the work, reading from INPUT_PORT 465 * and writing to OUTPUT_PORT 466 */ 467 static int 468 lcore_main(__attribute__((__unused__)) void *dummy) 469 { 470 const uint16_t lcore_id = (uint16_t)rte_lcore_id(); 471 const uint16_t num_cores = (uint16_t)rte_lcore_count(); 472 uint16_t core_id = 0; 473 uint16_t startQueue, endQueue; 474 uint16_t q, i, p; 475 const uint16_t remainder = (uint16_t)(num_vmdq_queues % num_cores); 476 477 for (i = 0; i < num_cores; i++) 478 if (lcore_ids[i] == lcore_id) { 479 core_id = i; 480 break; 481 } 482 483 if (remainder != 0) { 484 if (core_id < remainder) { 485 startQueue = (uint16_t)(core_id * 486 (num_vmdq_queues / num_cores + 1)); 487 endQueue = (uint16_t)(startQueue + 488 (num_vmdq_queues / num_cores) + 1); 489 } else { 490 startQueue = (uint16_t)(core_id * 491 (num_vmdq_queues / num_cores) + 492 remainder); 493 endQueue = (uint16_t)(startQueue + 494 (num_vmdq_queues / num_cores)); 495 } 496 } else { 497 startQueue = (uint16_t)(core_id * 498 (num_vmdq_queues / num_cores)); 499 endQueue = (uint16_t)(startQueue + 500 (num_vmdq_queues / num_cores)); 501 } 502 503 /* vmdq queue idx doesn't always start from zero.*/ 504 startQueue += vmdq_queue_base; 505 endQueue += vmdq_queue_base; 506 printf("core %u(lcore %u) reading queues %i-%i\n", (unsigned)core_id, 507 (unsigned)lcore_id, startQueue, endQueue - 1); 508 509 if (startQueue == endQueue) { 510 printf("lcore %u has nothing to do\n", lcore_id); 511 return 0; 512 } 513 514 for (;;) { 515 struct rte_mbuf *buf[MAX_PKT_BURST]; 516 const uint16_t buf_size = sizeof(buf) / sizeof(buf[0]); 517 518 for (p = 0; p < num_ports; p++) { 519 const uint8_t sport = ports[p]; 520 /* 0 <-> 1, 2 <-> 3 etc */ 521 const uint8_t dport = ports[p ^ 1]; 522 if ((sport == INVALID_PORT_ID) || (dport == INVALID_PORT_ID)) 523 continue; 524 525 for (q = startQueue; q < endQueue; q++) { 526 const uint16_t rxCount = rte_eth_rx_burst(sport, 527 q, buf, buf_size); 528 529 if (unlikely(rxCount == 0)) 530 continue; 531 532 rxPackets[q] += rxCount; 533 534 for (i = 0; i < rxCount; i++) 535 update_mac_address(buf[i], dport); 536 537 const uint16_t txCount = rte_eth_tx_burst(dport, 538 vmdq_queue_base + core_id, 539 buf, 540 rxCount); 541 542 if (txCount != rxCount) { 543 for (i = txCount; i < rxCount; i++) 544 rte_pktmbuf_free(buf[i]); 545 } 546 } 547 } 548 } 549 } 550 551 /* 552 * Update the global var NUM_PORTS and array PORTS according to system ports number 553 * and return valid ports number 554 */ 555 static unsigned check_ports_num(unsigned nb_ports) 556 { 557 unsigned valid_num_ports = num_ports; 558 unsigned portid; 559 560 if (num_ports > nb_ports) { 561 printf("\nSpecified port number(%u) exceeds total system port number(%u)\n", 562 num_ports, nb_ports); 563 num_ports = nb_ports; 564 } 565 566 for (portid = 0; portid < num_ports; portid++) { 567 if (ports[portid] >= nb_ports) { 568 printf("\nSpecified port ID(%u) exceeds max system port ID(%u)\n", 569 ports[portid], (nb_ports - 1)); 570 ports[portid] = INVALID_PORT_ID; 571 valid_num_ports--; 572 } 573 } 574 return valid_num_ports; 575 } 576 577 /* Main function, does initialisation and calls the per-lcore functions */ 578 int 579 main(int argc, char *argv[]) 580 { 581 struct rte_mempool *mbuf_pool; 582 unsigned lcore_id, core_id = 0; 583 int ret; 584 unsigned nb_ports, valid_num_ports; 585 uint16_t portid; 586 587 signal(SIGHUP, sighup_handler); 588 589 /* init EAL */ 590 ret = rte_eal_init(argc, argv); 591 if (ret < 0) 592 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n"); 593 argc -= ret; 594 argv += ret; 595 596 /* parse app arguments */ 597 ret = vmdq_parse_args(argc, argv); 598 if (ret < 0) 599 rte_exit(EXIT_FAILURE, "Invalid VMDQ argument\n"); 600 601 for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) 602 if (rte_lcore_is_enabled(lcore_id)) 603 lcore_ids[core_id++] = lcore_id; 604 605 if (rte_lcore_count() > RTE_MAX_LCORE) 606 rte_exit(EXIT_FAILURE, "Not enough cores\n"); 607 608 nb_ports = rte_eth_dev_count(); 609 610 /* 611 * Update the global var NUM_PORTS and global array PORTS 612 * and get value of var VALID_NUM_PORTS according to system ports number 613 */ 614 valid_num_ports = check_ports_num(nb_ports); 615 616 if (valid_num_ports < 2 || valid_num_ports % 2) { 617 printf("Current valid ports number is %u\n", valid_num_ports); 618 rte_exit(EXIT_FAILURE, "Error with valid ports number is not even or less than 2\n"); 619 } 620 621 mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", 622 NUM_MBUFS_PER_PORT * nb_ports, MBUF_CACHE_SIZE, 623 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); 624 if (mbuf_pool == NULL) 625 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n"); 626 627 /* initialize all ports */ 628 for (portid = 0; portid < nb_ports; portid++) { 629 /* skip ports that are not enabled */ 630 if ((enabled_port_mask & (1 << portid)) == 0) { 631 printf("\nSkipping disabled port %d\n", portid); 632 continue; 633 } 634 if (port_init(portid, mbuf_pool) != 0) 635 rte_exit(EXIT_FAILURE, "Cannot initialize network ports\n"); 636 } 637 638 /* call lcore_main() on every lcore */ 639 rte_eal_mp_remote_launch(lcore_main, NULL, CALL_MASTER); 640 RTE_LCORE_FOREACH_SLAVE(lcore_id) { 641 if (rte_eal_wait_lcore(lcore_id) < 0) 642 return -1; 643 } 644 645 return 0; 646 } 647