1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2016 Intel Corporation 3 */ 4 5 #include <signal.h> 6 #include <getopt.h> 7 8 #include <rte_eal.h> 9 #include <rte_common.h> 10 #include <rte_errno.h> 11 #include <rte_ethdev.h> 12 #include <rte_lcore.h> 13 #include <rte_malloc.h> 14 #include <rte_mbuf.h> 15 #include <rte_mempool.h> 16 #include <rte_ring.h> 17 #include <rte_reorder.h> 18 19 #define RX_DESC_PER_QUEUE 1024 20 #define TX_DESC_PER_QUEUE 1024 21 22 #define MAX_PKTS_BURST 32 23 #define REORDER_BUFFER_SIZE 8192 24 #define MBUF_PER_POOL 65535 25 #define MBUF_POOL_CACHE_SIZE 250 26 27 #define RING_SIZE 16384 28 29 /* Macros for printing using RTE_LOG */ 30 #define RTE_LOGTYPE_REORDERAPP RTE_LOGTYPE_USER1 31 32 unsigned int portmask; 33 unsigned int disable_reorder; 34 unsigned int insight_worker; 35 volatile uint8_t quit_signal; 36 37 static struct rte_mempool *mbuf_pool; 38 39 static struct rte_eth_conf port_conf_default; 40 41 struct worker_thread_args { 42 struct rte_ring *ring_in; 43 struct rte_ring *ring_out; 44 }; 45 46 struct send_thread_args { 47 struct rte_ring *ring_in; 48 struct rte_reorder_buffer *buffer; 49 }; 50 51 volatile struct app_stats { 52 struct { 53 uint64_t rx_pkts; 54 uint64_t enqueue_pkts; 55 uint64_t enqueue_failed_pkts; 56 } rx __rte_cache_aligned; 57 58 struct { 59 uint64_t dequeue_pkts; 60 uint64_t enqueue_pkts; 61 uint64_t enqueue_failed_pkts; 62 } wkr __rte_cache_aligned; 63 64 struct { 65 uint64_t dequeue_pkts; 66 /* Too early pkts transmitted directly w/o reordering */ 67 uint64_t early_pkts_txtd_woro; 68 /* Too early pkts failed from direct transmit */ 69 uint64_t early_pkts_tx_failed_woro; 70 uint64_t ro_tx_pkts; 71 uint64_t ro_tx_failed_pkts; 72 } tx __rte_cache_aligned; 73 } app_stats; 74 75 /* per worker lcore stats */ 76 struct wkr_stats_per { 77 uint64_t deq_pkts; 78 uint64_t enq_pkts; 79 uint64_t enq_failed_pkts; 80 } __rte_cache_aligned; 81 82 static struct wkr_stats_per wkr_stats[RTE_MAX_LCORE] = { {0} }; 83 /** 84 * Get the last enabled lcore ID 85 * 86 * @return 87 * The last enabled lcore ID. 88 */ 89 static unsigned int 90 get_last_lcore_id(void) 91 { 92 int i; 93 94 for (i = RTE_MAX_LCORE - 1; i >= 0; i--) 95 if (rte_lcore_is_enabled(i)) 96 return i; 97 return 0; 98 } 99 100 /** 101 * Get the previous enabled lcore ID 102 * @param id 103 * The current lcore ID 104 * @return 105 * The previous enabled lcore ID or the current lcore 106 * ID if it is the first available core. 107 */ 108 static unsigned int 109 get_previous_lcore_id(unsigned int id) 110 { 111 int i; 112 113 for (i = id - 1; i >= 0; i--) 114 if (rte_lcore_is_enabled(i)) 115 return i; 116 return id; 117 } 118 119 static inline void 120 pktmbuf_free_bulk(struct rte_mbuf *mbuf_table[], unsigned n) 121 { 122 unsigned int i; 123 124 for (i = 0; i < n; i++) 125 rte_pktmbuf_free(mbuf_table[i]); 126 } 127 128 /* display usage */ 129 static void 130 print_usage(const char *prgname) 131 { 132 printf("%s [EAL options] -- -p PORTMASK\n" 133 " -p PORTMASK: hexadecimal bitmask of ports to configure\n", 134 prgname); 135 } 136 137 static int 138 parse_portmask(const char *portmask) 139 { 140 unsigned long pm; 141 char *end = NULL; 142 143 /* parse hexadecimal string */ 144 pm = strtoul(portmask, &end, 16); 145 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0')) 146 return -1; 147 148 if (pm == 0) 149 return -1; 150 151 return pm; 152 } 153 154 /* Parse the argument given in the command line of the application */ 155 static int 156 parse_args(int argc, char **argv) 157 { 158 int opt; 159 int option_index; 160 char **argvopt; 161 char *prgname = argv[0]; 162 static struct option lgopts[] = { 163 {"disable-reorder", 0, 0, 0}, 164 {"insight-worker", 0, 0, 0}, 165 {NULL, 0, 0, 0} 166 }; 167 168 argvopt = argv; 169 170 while ((opt = getopt_long(argc, argvopt, "p:", 171 lgopts, &option_index)) != EOF) { 172 switch (opt) { 173 /* portmask */ 174 case 'p': 175 portmask = parse_portmask(optarg); 176 if (portmask == 0) { 177 printf("invalid portmask\n"); 178 print_usage(prgname); 179 return -1; 180 } 181 break; 182 /* long options */ 183 case 0: 184 if (!strcmp(lgopts[option_index].name, "disable-reorder")) { 185 printf("reorder disabled\n"); 186 disable_reorder = 1; 187 } 188 if (!strcmp(lgopts[option_index].name, 189 "insight-worker")) { 190 printf("print all worker statistics\n"); 191 insight_worker = 1; 192 } 193 break; 194 default: 195 print_usage(prgname); 196 return -1; 197 } 198 } 199 if (optind <= 1) { 200 print_usage(prgname); 201 return -1; 202 } 203 204 argv[optind-1] = prgname; 205 optind = 1; /* reset getopt lib */ 206 return 0; 207 } 208 209 /* 210 * Tx buffer error callback 211 */ 212 static void 213 flush_tx_error_callback(struct rte_mbuf **unsent, uint16_t count, 214 void *userdata __rte_unused) { 215 216 /* free the mbufs which failed from transmit */ 217 app_stats.tx.ro_tx_failed_pkts += count; 218 RTE_LOG_DP(DEBUG, REORDERAPP, "%s:Packet loss with tx_burst\n", __func__); 219 pktmbuf_free_bulk(unsent, count); 220 221 } 222 223 static inline int 224 free_tx_buffers(struct rte_eth_dev_tx_buffer *tx_buffer[]) { 225 uint16_t port_id; 226 227 /* initialize buffers for all ports */ 228 RTE_ETH_FOREACH_DEV(port_id) { 229 /* skip ports that are not enabled */ 230 if ((portmask & (1 << port_id)) == 0) 231 continue; 232 233 rte_free(tx_buffer[port_id]); 234 } 235 return 0; 236 } 237 238 static inline int 239 configure_tx_buffers(struct rte_eth_dev_tx_buffer *tx_buffer[]) 240 { 241 uint16_t port_id; 242 int ret; 243 244 /* initialize buffers for all ports */ 245 RTE_ETH_FOREACH_DEV(port_id) { 246 /* skip ports that are not enabled */ 247 if ((portmask & (1 << port_id)) == 0) 248 continue; 249 250 /* Initialize TX buffers */ 251 tx_buffer[port_id] = rte_zmalloc_socket("tx_buffer", 252 RTE_ETH_TX_BUFFER_SIZE(MAX_PKTS_BURST), 0, 253 rte_eth_dev_socket_id(port_id)); 254 if (tx_buffer[port_id] == NULL) 255 rte_exit(EXIT_FAILURE, "Cannot allocate buffer for tx on port %u\n", 256 port_id); 257 258 rte_eth_tx_buffer_init(tx_buffer[port_id], MAX_PKTS_BURST); 259 260 ret = rte_eth_tx_buffer_set_err_callback(tx_buffer[port_id], 261 flush_tx_error_callback, NULL); 262 if (ret < 0) 263 rte_exit(EXIT_FAILURE, 264 "Cannot set error callback for tx buffer on port %u\n", 265 port_id); 266 } 267 return 0; 268 } 269 270 static inline int 271 configure_eth_port(uint16_t port_id) 272 { 273 struct rte_ether_addr addr; 274 const uint16_t rxRings = 1, txRings = 1; 275 int ret; 276 uint16_t q; 277 uint16_t nb_rxd = RX_DESC_PER_QUEUE; 278 uint16_t nb_txd = TX_DESC_PER_QUEUE; 279 struct rte_eth_dev_info dev_info; 280 struct rte_eth_txconf txconf; 281 struct rte_eth_conf port_conf = port_conf_default; 282 283 if (!rte_eth_dev_is_valid_port(port_id)) 284 return -1; 285 286 ret = rte_eth_dev_info_get(port_id, &dev_info); 287 if (ret != 0) { 288 printf("Error during getting device (port %u) info: %s\n", 289 port_id, strerror(-ret)); 290 return ret; 291 } 292 293 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE) 294 port_conf.txmode.offloads |= 295 DEV_TX_OFFLOAD_MBUF_FAST_FREE; 296 ret = rte_eth_dev_configure(port_id, rxRings, txRings, &port_conf_default); 297 if (ret != 0) 298 return ret; 299 300 ret = rte_eth_dev_adjust_nb_rx_tx_desc(port_id, &nb_rxd, &nb_txd); 301 if (ret != 0) 302 return ret; 303 304 for (q = 0; q < rxRings; q++) { 305 ret = rte_eth_rx_queue_setup(port_id, q, nb_rxd, 306 rte_eth_dev_socket_id(port_id), NULL, 307 mbuf_pool); 308 if (ret < 0) 309 return ret; 310 } 311 312 txconf = dev_info.default_txconf; 313 txconf.offloads = port_conf.txmode.offloads; 314 for (q = 0; q < txRings; q++) { 315 ret = rte_eth_tx_queue_setup(port_id, q, nb_txd, 316 rte_eth_dev_socket_id(port_id), &txconf); 317 if (ret < 0) 318 return ret; 319 } 320 321 ret = rte_eth_dev_start(port_id); 322 if (ret < 0) 323 return ret; 324 325 ret = rte_eth_macaddr_get(port_id, &addr); 326 if (ret != 0) { 327 printf("Failed to get MAC address (port %u): %s\n", 328 port_id, rte_strerror(-ret)); 329 return ret; 330 } 331 332 printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8 333 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n", 334 port_id, 335 addr.addr_bytes[0], addr.addr_bytes[1], 336 addr.addr_bytes[2], addr.addr_bytes[3], 337 addr.addr_bytes[4], addr.addr_bytes[5]); 338 339 ret = rte_eth_promiscuous_enable(port_id); 340 if (ret != 0) 341 return ret; 342 343 return 0; 344 } 345 346 static void 347 print_stats(void) 348 { 349 uint16_t i; 350 struct rte_eth_stats eth_stats; 351 unsigned int lcore_id, last_lcore_id, master_lcore_id, end_w_lcore_id; 352 353 last_lcore_id = get_last_lcore_id(); 354 master_lcore_id = rte_get_master_lcore(); 355 end_w_lcore_id = get_previous_lcore_id(last_lcore_id); 356 357 printf("\nRX thread stats:\n"); 358 printf(" - Pkts rxd: %"PRIu64"\n", 359 app_stats.rx.rx_pkts); 360 printf(" - Pkts enqd to workers ring: %"PRIu64"\n", 361 app_stats.rx.enqueue_pkts); 362 363 for (lcore_id = 0; lcore_id <= end_w_lcore_id; lcore_id++) { 364 if (insight_worker 365 && rte_lcore_is_enabled(lcore_id) 366 && lcore_id != master_lcore_id) { 367 printf("\nWorker thread stats on core [%u]:\n", 368 lcore_id); 369 printf(" - Pkts deqd from workers ring: %"PRIu64"\n", 370 wkr_stats[lcore_id].deq_pkts); 371 printf(" - Pkts enqd to tx ring: %"PRIu64"\n", 372 wkr_stats[lcore_id].enq_pkts); 373 printf(" - Pkts enq to tx failed: %"PRIu64"\n", 374 wkr_stats[lcore_id].enq_failed_pkts); 375 } 376 377 app_stats.wkr.dequeue_pkts += wkr_stats[lcore_id].deq_pkts; 378 app_stats.wkr.enqueue_pkts += wkr_stats[lcore_id].enq_pkts; 379 app_stats.wkr.enqueue_failed_pkts += 380 wkr_stats[lcore_id].enq_failed_pkts; 381 } 382 383 printf("\nWorker thread stats:\n"); 384 printf(" - Pkts deqd from workers ring: %"PRIu64"\n", 385 app_stats.wkr.dequeue_pkts); 386 printf(" - Pkts enqd to tx ring: %"PRIu64"\n", 387 app_stats.wkr.enqueue_pkts); 388 printf(" - Pkts enq to tx failed: %"PRIu64"\n", 389 app_stats.wkr.enqueue_failed_pkts); 390 391 printf("\nTX stats:\n"); 392 printf(" - Pkts deqd from tx ring: %"PRIu64"\n", 393 app_stats.tx.dequeue_pkts); 394 printf(" - Ro Pkts transmitted: %"PRIu64"\n", 395 app_stats.tx.ro_tx_pkts); 396 printf(" - Ro Pkts tx failed: %"PRIu64"\n", 397 app_stats.tx.ro_tx_failed_pkts); 398 printf(" - Pkts transmitted w/o reorder: %"PRIu64"\n", 399 app_stats.tx.early_pkts_txtd_woro); 400 printf(" - Pkts tx failed w/o reorder: %"PRIu64"\n", 401 app_stats.tx.early_pkts_tx_failed_woro); 402 403 RTE_ETH_FOREACH_DEV(i) { 404 rte_eth_stats_get(i, ð_stats); 405 printf("\nPort %u stats:\n", i); 406 printf(" - Pkts in: %"PRIu64"\n", eth_stats.ipackets); 407 printf(" - Pkts out: %"PRIu64"\n", eth_stats.opackets); 408 printf(" - In Errs: %"PRIu64"\n", eth_stats.ierrors); 409 printf(" - Out Errs: %"PRIu64"\n", eth_stats.oerrors); 410 printf(" - Mbuf Errs: %"PRIu64"\n", eth_stats.rx_nombuf); 411 } 412 } 413 414 static void 415 int_handler(int sig_num) 416 { 417 printf("Exiting on signal %d\n", sig_num); 418 quit_signal = 1; 419 } 420 421 /** 422 * This thread receives mbufs from the port and affects them an internal 423 * sequence number to keep track of their order of arrival through an 424 * mbuf structure. 425 * The mbufs are then passed to the worker threads via the rx_to_workers 426 * ring. 427 */ 428 static int 429 rx_thread(struct rte_ring *ring_out) 430 { 431 uint32_t seqn = 0; 432 uint16_t i, ret = 0; 433 uint16_t nb_rx_pkts; 434 uint16_t port_id; 435 struct rte_mbuf *pkts[MAX_PKTS_BURST]; 436 437 RTE_LOG(INFO, REORDERAPP, "%s() started on lcore %u\n", __func__, 438 rte_lcore_id()); 439 440 while (!quit_signal) { 441 442 RTE_ETH_FOREACH_DEV(port_id) { 443 if ((portmask & (1 << port_id)) != 0) { 444 445 /* receive packets */ 446 nb_rx_pkts = rte_eth_rx_burst(port_id, 0, 447 pkts, MAX_PKTS_BURST); 448 if (nb_rx_pkts == 0) { 449 RTE_LOG_DP(DEBUG, REORDERAPP, 450 "%s():Received zero packets\n", __func__); 451 continue; 452 } 453 app_stats.rx.rx_pkts += nb_rx_pkts; 454 455 /* mark sequence number */ 456 for (i = 0; i < nb_rx_pkts; ) 457 pkts[i++]->seqn = seqn++; 458 459 /* enqueue to rx_to_workers ring */ 460 ret = rte_ring_enqueue_burst(ring_out, 461 (void *)pkts, nb_rx_pkts, NULL); 462 app_stats.rx.enqueue_pkts += ret; 463 if (unlikely(ret < nb_rx_pkts)) { 464 app_stats.rx.enqueue_failed_pkts += 465 (nb_rx_pkts-ret); 466 pktmbuf_free_bulk(&pkts[ret], nb_rx_pkts - ret); 467 } 468 } 469 } 470 } 471 return 0; 472 } 473 474 /** 475 * This thread takes bursts of packets from the rx_to_workers ring and 476 * Changes the input port value to output port value. And feds it to 477 * workers_to_tx 478 */ 479 static int 480 worker_thread(void *args_ptr) 481 { 482 const uint16_t nb_ports = rte_eth_dev_count_avail(); 483 uint16_t i, ret = 0; 484 uint16_t burst_size = 0; 485 struct worker_thread_args *args; 486 struct rte_mbuf *burst_buffer[MAX_PKTS_BURST] = { NULL }; 487 struct rte_ring *ring_in, *ring_out; 488 const unsigned xor_val = (nb_ports > 1); 489 unsigned int core_id = rte_lcore_id(); 490 491 args = (struct worker_thread_args *) args_ptr; 492 ring_in = args->ring_in; 493 ring_out = args->ring_out; 494 495 RTE_LOG(INFO, REORDERAPP, "%s() started on lcore %u\n", __func__, 496 core_id); 497 498 while (!quit_signal) { 499 500 /* dequeue the mbufs from rx_to_workers ring */ 501 burst_size = rte_ring_dequeue_burst(ring_in, 502 (void *)burst_buffer, MAX_PKTS_BURST, NULL); 503 if (unlikely(burst_size == 0)) 504 continue; 505 506 wkr_stats[core_id].deq_pkts += burst_size; 507 508 /* just do some operation on mbuf */ 509 for (i = 0; i < burst_size;) 510 burst_buffer[i++]->port ^= xor_val; 511 512 /* enqueue the modified mbufs to workers_to_tx ring */ 513 ret = rte_ring_enqueue_burst(ring_out, (void *)burst_buffer, 514 burst_size, NULL); 515 wkr_stats[core_id].enq_pkts += ret; 516 if (unlikely(ret < burst_size)) { 517 /* Return the mbufs to their respective pool, dropping packets */ 518 wkr_stats[core_id].enq_failed_pkts += burst_size - ret; 519 pktmbuf_free_bulk(&burst_buffer[ret], burst_size - ret); 520 } 521 } 522 return 0; 523 } 524 525 /** 526 * Dequeue mbufs from the workers_to_tx ring and reorder them before 527 * transmitting. 528 */ 529 static int 530 send_thread(struct send_thread_args *args) 531 { 532 int ret; 533 unsigned int i, dret; 534 uint16_t nb_dq_mbufs; 535 uint8_t outp; 536 unsigned sent; 537 struct rte_mbuf *mbufs[MAX_PKTS_BURST]; 538 struct rte_mbuf *rombufs[MAX_PKTS_BURST] = {NULL}; 539 static struct rte_eth_dev_tx_buffer *tx_buffer[RTE_MAX_ETHPORTS]; 540 541 RTE_LOG(INFO, REORDERAPP, "%s() started on lcore %u\n", __func__, rte_lcore_id()); 542 543 configure_tx_buffers(tx_buffer); 544 545 while (!quit_signal) { 546 547 /* deque the mbufs from workers_to_tx ring */ 548 nb_dq_mbufs = rte_ring_dequeue_burst(args->ring_in, 549 (void *)mbufs, MAX_PKTS_BURST, NULL); 550 551 if (unlikely(nb_dq_mbufs == 0)) 552 continue; 553 554 app_stats.tx.dequeue_pkts += nb_dq_mbufs; 555 556 for (i = 0; i < nb_dq_mbufs; i++) { 557 /* send dequeued mbufs for reordering */ 558 ret = rte_reorder_insert(args->buffer, mbufs[i]); 559 560 if (ret == -1 && rte_errno == ERANGE) { 561 /* Too early pkts should be transmitted out directly */ 562 RTE_LOG_DP(DEBUG, REORDERAPP, 563 "%s():Cannot reorder early packet " 564 "direct enqueuing to TX\n", __func__); 565 outp = mbufs[i]->port; 566 if ((portmask & (1 << outp)) == 0) { 567 rte_pktmbuf_free(mbufs[i]); 568 continue; 569 } 570 if (rte_eth_tx_burst(outp, 0, (void *)mbufs[i], 1) != 1) { 571 rte_pktmbuf_free(mbufs[i]); 572 app_stats.tx.early_pkts_tx_failed_woro++; 573 } else 574 app_stats.tx.early_pkts_txtd_woro++; 575 } else if (ret == -1 && rte_errno == ENOSPC) { 576 /** 577 * Early pkts just outside of window should be dropped 578 */ 579 rte_pktmbuf_free(mbufs[i]); 580 } 581 } 582 583 /* 584 * drain MAX_PKTS_BURST of reordered 585 * mbufs for transmit 586 */ 587 dret = rte_reorder_drain(args->buffer, rombufs, MAX_PKTS_BURST); 588 for (i = 0; i < dret; i++) { 589 590 struct rte_eth_dev_tx_buffer *outbuf; 591 uint8_t outp1; 592 593 outp1 = rombufs[i]->port; 594 /* skip ports that are not enabled */ 595 if ((portmask & (1 << outp1)) == 0) { 596 rte_pktmbuf_free(rombufs[i]); 597 continue; 598 } 599 600 outbuf = tx_buffer[outp1]; 601 sent = rte_eth_tx_buffer(outp1, 0, outbuf, rombufs[i]); 602 if (sent) 603 app_stats.tx.ro_tx_pkts += sent; 604 } 605 } 606 607 free_tx_buffers(tx_buffer); 608 609 return 0; 610 } 611 612 /** 613 * Dequeue mbufs from the workers_to_tx ring and transmit them 614 */ 615 static int 616 tx_thread(struct rte_ring *ring_in) 617 { 618 uint32_t i, dqnum; 619 uint8_t outp; 620 unsigned sent; 621 struct rte_mbuf *mbufs[MAX_PKTS_BURST]; 622 struct rte_eth_dev_tx_buffer *outbuf; 623 static struct rte_eth_dev_tx_buffer *tx_buffer[RTE_MAX_ETHPORTS]; 624 625 RTE_LOG(INFO, REORDERAPP, "%s() started on lcore %u\n", __func__, 626 rte_lcore_id()); 627 628 configure_tx_buffers(tx_buffer); 629 630 while (!quit_signal) { 631 632 /* deque the mbufs from workers_to_tx ring */ 633 dqnum = rte_ring_dequeue_burst(ring_in, 634 (void *)mbufs, MAX_PKTS_BURST, NULL); 635 636 if (unlikely(dqnum == 0)) 637 continue; 638 639 app_stats.tx.dequeue_pkts += dqnum; 640 641 for (i = 0; i < dqnum; i++) { 642 outp = mbufs[i]->port; 643 /* skip ports that are not enabled */ 644 if ((portmask & (1 << outp)) == 0) { 645 rte_pktmbuf_free(mbufs[i]); 646 continue; 647 } 648 649 outbuf = tx_buffer[outp]; 650 sent = rte_eth_tx_buffer(outp, 0, outbuf, mbufs[i]); 651 if (sent) 652 app_stats.tx.ro_tx_pkts += sent; 653 } 654 } 655 656 return 0; 657 } 658 659 int 660 main(int argc, char **argv) 661 { 662 int ret; 663 unsigned nb_ports; 664 unsigned int lcore_id, last_lcore_id, master_lcore_id; 665 uint16_t port_id; 666 uint16_t nb_ports_available; 667 struct worker_thread_args worker_args = {NULL, NULL}; 668 struct send_thread_args send_args = {NULL, NULL}; 669 struct rte_ring *rx_to_workers; 670 struct rte_ring *workers_to_tx; 671 672 /* catch ctrl-c so we can print on exit */ 673 signal(SIGINT, int_handler); 674 675 /* Initialize EAL */ 676 ret = rte_eal_init(argc, argv); 677 if (ret < 0) 678 return -1; 679 680 argc -= ret; 681 argv += ret; 682 683 /* Parse the application specific arguments */ 684 ret = parse_args(argc, argv); 685 if (ret < 0) 686 return -1; 687 688 /* Check if we have enought cores */ 689 if (rte_lcore_count() < 3) 690 rte_exit(EXIT_FAILURE, "Error, This application needs at " 691 "least 3 logical cores to run:\n" 692 "1 lcore for packet RX\n" 693 "1 lcore for packet TX\n" 694 "and at least 1 lcore for worker threads\n"); 695 696 nb_ports = rte_eth_dev_count_avail(); 697 if (nb_ports == 0) 698 rte_exit(EXIT_FAILURE, "Error: no ethernet ports detected\n"); 699 if (nb_ports != 1 && (nb_ports & 1)) 700 rte_exit(EXIT_FAILURE, "Error: number of ports must be even, except " 701 "when using a single port\n"); 702 703 mbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", MBUF_PER_POOL, 704 MBUF_POOL_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, 705 rte_socket_id()); 706 if (mbuf_pool == NULL) 707 rte_exit(EXIT_FAILURE, "%s\n", rte_strerror(rte_errno)); 708 709 nb_ports_available = nb_ports; 710 711 /* initialize all ports */ 712 RTE_ETH_FOREACH_DEV(port_id) { 713 /* skip ports that are not enabled */ 714 if ((portmask & (1 << port_id)) == 0) { 715 printf("\nSkipping disabled port %d\n", port_id); 716 nb_ports_available--; 717 continue; 718 } 719 /* init port */ 720 printf("Initializing port %u... done\n", port_id); 721 722 if (configure_eth_port(port_id) != 0) 723 rte_exit(EXIT_FAILURE, "Cannot initialize port %"PRIu8"\n", 724 port_id); 725 } 726 727 if (!nb_ports_available) { 728 rte_exit(EXIT_FAILURE, 729 "All available ports are disabled. Please set portmask.\n"); 730 } 731 732 /* Create rings for inter core communication */ 733 rx_to_workers = rte_ring_create("rx_to_workers", RING_SIZE, rte_socket_id(), 734 RING_F_SP_ENQ); 735 if (rx_to_workers == NULL) 736 rte_exit(EXIT_FAILURE, "%s\n", rte_strerror(rte_errno)); 737 738 workers_to_tx = rte_ring_create("workers_to_tx", RING_SIZE, rte_socket_id(), 739 RING_F_SC_DEQ); 740 if (workers_to_tx == NULL) 741 rte_exit(EXIT_FAILURE, "%s\n", rte_strerror(rte_errno)); 742 743 if (!disable_reorder) { 744 send_args.buffer = rte_reorder_create("PKT_RO", rte_socket_id(), 745 REORDER_BUFFER_SIZE); 746 if (send_args.buffer == NULL) 747 rte_exit(EXIT_FAILURE, "%s\n", rte_strerror(rte_errno)); 748 } 749 750 last_lcore_id = get_last_lcore_id(); 751 master_lcore_id = rte_get_master_lcore(); 752 753 worker_args.ring_in = rx_to_workers; 754 worker_args.ring_out = workers_to_tx; 755 756 /* Start worker_thread() on all the available slave cores but the last 1 */ 757 for (lcore_id = 0; lcore_id <= get_previous_lcore_id(last_lcore_id); lcore_id++) 758 if (rte_lcore_is_enabled(lcore_id) && lcore_id != master_lcore_id) 759 rte_eal_remote_launch(worker_thread, (void *)&worker_args, 760 lcore_id); 761 762 if (disable_reorder) { 763 /* Start tx_thread() on the last slave core */ 764 rte_eal_remote_launch((lcore_function_t *)tx_thread, workers_to_tx, 765 last_lcore_id); 766 } else { 767 send_args.ring_in = workers_to_tx; 768 /* Start send_thread() on the last slave core */ 769 rte_eal_remote_launch((lcore_function_t *)send_thread, 770 (void *)&send_args, last_lcore_id); 771 } 772 773 /* Start rx_thread() on the master core */ 774 rx_thread(rx_to_workers); 775 776 RTE_LCORE_FOREACH_SLAVE(lcore_id) { 777 if (rte_eal_wait_lcore(lcore_id) < 0) 778 return -1; 779 } 780 781 print_stats(); 782 return 0; 783 } 784