1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2016 Intel Corporation 3 */ 4 5 #include <stdio.h> 6 #include <stdlib.h> 7 #include <string.h> 8 #include <stdint.h> 9 #include <inttypes.h> 10 #include <sys/types.h> 11 #include <sys/queue.h> 12 #include <netinet/in.h> 13 #include <setjmp.h> 14 #include <stdarg.h> 15 #include <ctype.h> 16 #include <errno.h> 17 #include <getopt.h> 18 19 #include <rte_common.h> 20 #include <rte_log.h> 21 #include <rte_malloc.h> 22 #include <rte_memory.h> 23 #include <rte_memcpy.h> 24 #include <rte_eal.h> 25 #include <rte_launch.h> 26 #include <rte_atomic.h> 27 #include <rte_cycles.h> 28 #include <rte_prefetch.h> 29 #include <rte_lcore.h> 30 #include <rte_per_lcore.h> 31 #include <rte_branch_prediction.h> 32 #include <rte_interrupts.h> 33 #include <rte_random.h> 34 #include <rte_debug.h> 35 #include <rte_ether.h> 36 #include <rte_ethdev.h> 37 #include <rte_mempool.h> 38 #include <rte_mbuf.h> 39 40 #define RTE_LOGTYPE_LSI RTE_LOGTYPE_USER1 41 42 #define NB_MBUF 8192 43 44 #define MAX_PKT_BURST 32 45 #define BURST_TX_DRAIN_US 100 /* TX drain every ~100us */ 46 47 /* 48 * Configurable number of RX/TX ring descriptors 49 */ 50 #define RTE_TEST_RX_DESC_DEFAULT 1024 51 #define RTE_TEST_TX_DESC_DEFAULT 1024 52 static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT; 53 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT; 54 55 /* ethernet addresses of ports */ 56 static struct rte_ether_addr lsi_ports_eth_addr[RTE_MAX_ETHPORTS]; 57 58 /* mask of enabled ports */ 59 static uint32_t lsi_enabled_port_mask = 0; 60 61 static unsigned int lsi_rx_queue_per_lcore = 1; 62 63 /* destination port for L2 forwarding */ 64 static unsigned lsi_dst_ports[RTE_MAX_ETHPORTS] = {0}; 65 66 #define MAX_PKT_BURST 32 67 68 #define MAX_RX_QUEUE_PER_LCORE 16 69 #define MAX_TX_QUEUE_PER_PORT 16 70 struct lcore_queue_conf { 71 unsigned n_rx_port; 72 unsigned rx_port_list[MAX_RX_QUEUE_PER_LCORE]; 73 unsigned tx_queue_id; 74 } __rte_cache_aligned; 75 struct lcore_queue_conf lcore_queue_conf[RTE_MAX_LCORE]; 76 77 struct rte_eth_dev_tx_buffer *tx_buffer[RTE_MAX_ETHPORTS]; 78 79 static struct rte_eth_conf port_conf = { 80 .rxmode = { 81 .split_hdr_size = 0, 82 }, 83 .txmode = { 84 .mq_mode = ETH_MQ_TX_NONE, 85 }, 86 .intr_conf = { 87 .lsc = 1, /**< lsc interrupt feature enabled */ 88 }, 89 }; 90 91 struct rte_mempool * lsi_pktmbuf_pool = NULL; 92 93 /* Per-port statistics struct */ 94 struct lsi_port_statistics { 95 uint64_t tx; 96 uint64_t rx; 97 uint64_t dropped; 98 } __rte_cache_aligned; 99 struct lsi_port_statistics port_statistics[RTE_MAX_ETHPORTS]; 100 101 /* A tsc-based timer responsible for triggering statistics printout */ 102 #define TIMER_MILLISECOND 2000000ULL /* around 1ms at 2 Ghz */ 103 #define MAX_TIMER_PERIOD 86400 /* 1 day max */ 104 static int64_t timer_period = 10 * TIMER_MILLISECOND * 1000; /* default period is 10 seconds */ 105 106 /* Print out statistics on packets dropped */ 107 static void 108 print_stats(void) 109 { 110 struct rte_eth_link link; 111 uint64_t total_packets_dropped, total_packets_tx, total_packets_rx; 112 uint16_t portid; 113 114 total_packets_dropped = 0; 115 total_packets_tx = 0; 116 total_packets_rx = 0; 117 118 const char clr[] = { 27, '[', '2', 'J', '\0' }; 119 const char topLeft[] = { 27, '[', '1', ';', '1', 'H','\0' }; 120 int link_get_err; 121 122 /* Clear screen and move to top left */ 123 printf("%s%s", clr, topLeft); 124 125 printf("\nPort statistics ===================================="); 126 127 for (portid = 0; portid < RTE_MAX_ETHPORTS; portid++) { 128 /* skip ports that are not enabled */ 129 if ((lsi_enabled_port_mask & (1 << portid)) == 0) 130 continue; 131 132 memset(&link, 0, sizeof(link)); 133 link_get_err = rte_eth_link_get_nowait(portid, &link); 134 printf("\nStatistics for port %u ------------------------------" 135 "\nLink status: %25s" 136 "\nLink speed: %26u" 137 "\nLink duplex: %25s" 138 "\nPackets sent: %24"PRIu64 139 "\nPackets received: %20"PRIu64 140 "\nPackets dropped: %21"PRIu64, 141 portid, 142 link_get_err < 0 ? "Link get failed" : 143 (link.link_status ? "Link up" : "Link down"), 144 link_get_err < 0 ? 0 : 145 (unsigned int)link.link_speed, 146 link_get_err < 0 ? "Link get failed" : 147 (link.link_duplex == ETH_LINK_FULL_DUPLEX ? \ 148 "full-duplex" : "half-duplex"), 149 port_statistics[portid].tx, 150 port_statistics[portid].rx, 151 port_statistics[portid].dropped); 152 153 total_packets_dropped += port_statistics[portid].dropped; 154 total_packets_tx += port_statistics[portid].tx; 155 total_packets_rx += port_statistics[portid].rx; 156 } 157 printf("\nAggregate statistics ===============================" 158 "\nTotal packets sent: %18"PRIu64 159 "\nTotal packets received: %14"PRIu64 160 "\nTotal packets dropped: %15"PRIu64, 161 total_packets_tx, 162 total_packets_rx, 163 total_packets_dropped); 164 printf("\n====================================================\n"); 165 } 166 167 static void 168 lsi_simple_forward(struct rte_mbuf *m, unsigned portid) 169 { 170 struct rte_ether_hdr *eth; 171 void *tmp; 172 unsigned dst_port = lsi_dst_ports[portid]; 173 int sent; 174 struct rte_eth_dev_tx_buffer *buffer; 175 176 eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); 177 178 /* 02:00:00:00:00:xx */ 179 tmp = ð->d_addr.addr_bytes[0]; 180 *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40); 181 182 /* src addr */ 183 rte_ether_addr_copy(&lsi_ports_eth_addr[dst_port], ð->s_addr); 184 185 buffer = tx_buffer[dst_port]; 186 sent = rte_eth_tx_buffer(dst_port, 0, buffer, m); 187 if (sent) 188 port_statistics[dst_port].tx += sent; 189 } 190 191 /* main processing loop */ 192 static void 193 lsi_main_loop(void) 194 { 195 struct rte_mbuf *pkts_burst[MAX_PKT_BURST]; 196 struct rte_mbuf *m; 197 unsigned lcore_id; 198 unsigned sent; 199 uint64_t prev_tsc, diff_tsc, cur_tsc, timer_tsc; 200 unsigned i, j, portid, nb_rx; 201 struct lcore_queue_conf *qconf; 202 const uint64_t drain_tsc = (rte_get_tsc_hz() + US_PER_S - 1) / US_PER_S * 203 BURST_TX_DRAIN_US; 204 struct rte_eth_dev_tx_buffer *buffer; 205 206 prev_tsc = 0; 207 timer_tsc = 0; 208 209 lcore_id = rte_lcore_id(); 210 qconf = &lcore_queue_conf[lcore_id]; 211 212 if (qconf->n_rx_port == 0) { 213 RTE_LOG(INFO, LSI, "lcore %u has nothing to do\n", lcore_id); 214 return; 215 } 216 217 RTE_LOG(INFO, LSI, "entering main loop on lcore %u\n", lcore_id); 218 219 for (i = 0; i < qconf->n_rx_port; i++) { 220 221 portid = qconf->rx_port_list[i]; 222 RTE_LOG(INFO, LSI, " -- lcoreid=%u portid=%u\n", lcore_id, 223 portid); 224 } 225 226 while (1) { 227 228 cur_tsc = rte_rdtsc(); 229 230 /* 231 * TX burst queue drain 232 */ 233 diff_tsc = cur_tsc - prev_tsc; 234 if (unlikely(diff_tsc > drain_tsc)) { 235 236 for (i = 0; i < qconf->n_rx_port; i++) { 237 238 portid = lsi_dst_ports[qconf->rx_port_list[i]]; 239 buffer = tx_buffer[portid]; 240 241 sent = rte_eth_tx_buffer_flush(portid, 0, buffer); 242 if (sent) 243 port_statistics[portid].tx += sent; 244 245 } 246 247 /* if timer is enabled */ 248 if (timer_period > 0) { 249 250 /* advance the timer */ 251 timer_tsc += diff_tsc; 252 253 /* if timer has reached its timeout */ 254 if (unlikely(timer_tsc >= (uint64_t) timer_period)) { 255 256 /* do this only on master core */ 257 if (lcore_id == rte_get_master_lcore()) { 258 print_stats(); 259 /* reset the timer */ 260 timer_tsc = 0; 261 } 262 } 263 } 264 265 prev_tsc = cur_tsc; 266 } 267 268 /* 269 * Read packet from RX queues 270 */ 271 for (i = 0; i < qconf->n_rx_port; i++) { 272 273 portid = qconf->rx_port_list[i]; 274 nb_rx = rte_eth_rx_burst((uint8_t) portid, 0, 275 pkts_burst, MAX_PKT_BURST); 276 277 port_statistics[portid].rx += nb_rx; 278 279 for (j = 0; j < nb_rx; j++) { 280 m = pkts_burst[j]; 281 rte_prefetch0(rte_pktmbuf_mtod(m, void *)); 282 lsi_simple_forward(m, portid); 283 } 284 } 285 } 286 } 287 288 static int 289 lsi_launch_one_lcore(__attribute__((unused)) void *dummy) 290 { 291 lsi_main_loop(); 292 return 0; 293 } 294 295 /* display usage */ 296 static void 297 lsi_usage(const char *prgname) 298 { 299 printf("%s [EAL options] -- -p PORTMASK [-q NQ]\n" 300 " -p PORTMASK: hexadecimal bitmask of ports to configure\n" 301 " -q NQ: number of queue (=ports) per lcore (default is 1)\n" 302 " -T PERIOD: statistics will be refreshed each PERIOD seconds (0 to disable, 10 default, 86400 maximum)\n", 303 prgname); 304 } 305 306 static int 307 lsi_parse_portmask(const char *portmask) 308 { 309 char *end = NULL; 310 unsigned long pm; 311 312 /* parse hexadecimal string */ 313 pm = strtoul(portmask, &end, 16); 314 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0')) 315 return -1; 316 317 if (pm == 0) 318 return -1; 319 320 return pm; 321 } 322 323 static unsigned int 324 lsi_parse_nqueue(const char *q_arg) 325 { 326 char *end = NULL; 327 unsigned long n; 328 329 /* parse hexadecimal string */ 330 n = strtoul(q_arg, &end, 10); 331 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0')) 332 return 0; 333 if (n == 0) 334 return 0; 335 if (n >= MAX_RX_QUEUE_PER_LCORE) 336 return 0; 337 338 return n; 339 } 340 341 static int 342 lsi_parse_timer_period(const char *q_arg) 343 { 344 char *end = NULL; 345 int n; 346 347 /* parse number string */ 348 n = strtol(q_arg, &end, 10); 349 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0')) 350 return -1; 351 if (n >= MAX_TIMER_PERIOD) 352 return -1; 353 354 return n; 355 } 356 357 /* Parse the argument given in the command line of the application */ 358 static int 359 lsi_parse_args(int argc, char **argv) 360 { 361 int opt, ret; 362 char **argvopt; 363 int option_index; 364 char *prgname = argv[0]; 365 static struct option lgopts[] = { 366 {NULL, 0, 0, 0} 367 }; 368 369 argvopt = argv; 370 371 while ((opt = getopt_long(argc, argvopt, "p:q:T:", 372 lgopts, &option_index)) != EOF) { 373 374 switch (opt) { 375 /* portmask */ 376 case 'p': 377 lsi_enabled_port_mask = lsi_parse_portmask(optarg); 378 if (lsi_enabled_port_mask == 0) { 379 printf("invalid portmask\n"); 380 lsi_usage(prgname); 381 return -1; 382 } 383 break; 384 385 /* nqueue */ 386 case 'q': 387 lsi_rx_queue_per_lcore = lsi_parse_nqueue(optarg); 388 if (lsi_rx_queue_per_lcore == 0) { 389 printf("invalid queue number\n"); 390 lsi_usage(prgname); 391 return -1; 392 } 393 break; 394 395 /* timer period */ 396 case 'T': 397 timer_period = lsi_parse_timer_period(optarg) * 1000 * TIMER_MILLISECOND; 398 if (timer_period < 0) { 399 printf("invalid timer period\n"); 400 lsi_usage(prgname); 401 return -1; 402 } 403 break; 404 405 /* long options */ 406 case 0: 407 lsi_usage(prgname); 408 return -1; 409 410 default: 411 lsi_usage(prgname); 412 return -1; 413 } 414 } 415 416 if (optind >= 0) 417 argv[optind-1] = prgname; 418 419 ret = optind-1; 420 optind = 1; /* reset getopt lib */ 421 return ret; 422 } 423 424 /** 425 * It will be called as the callback for specified port after a LSI interrupt 426 * has been fully handled. This callback needs to be implemented carefully as 427 * it will be called in the interrupt host thread which is different from the 428 * application main thread. 429 * 430 * @param port_id 431 * Port id. 432 * @param type 433 * event type. 434 * @param param 435 * Pointer to(address of) the parameters. 436 * 437 * @return 438 * int. 439 */ 440 static int 441 lsi_event_callback(uint16_t port_id, enum rte_eth_event_type type, void *param, 442 void *ret_param) 443 { 444 struct rte_eth_link link; 445 int ret; 446 447 RTE_SET_USED(param); 448 RTE_SET_USED(ret_param); 449 450 printf("\n\nIn registered callback...\n"); 451 printf("Event type: %s\n", type == RTE_ETH_EVENT_INTR_LSC ? "LSC interrupt" : "unknown event"); 452 ret = rte_eth_link_get_nowait(port_id, &link); 453 if (ret < 0) { 454 printf("Failed link get on port %d: %s\n", 455 port_id, rte_strerror(-ret)); 456 return ret; 457 } 458 if (link.link_status) { 459 printf("Port %d Link Up - speed %u Mbps - %s\n\n", 460 port_id, (unsigned)link.link_speed, 461 (link.link_duplex == ETH_LINK_FULL_DUPLEX) ? 462 ("full-duplex") : ("half-duplex")); 463 } else 464 printf("Port %d Link Down\n\n", port_id); 465 466 return 0; 467 } 468 469 /* Check the link status of all ports in up to 9s, and print them finally */ 470 static void 471 check_all_ports_link_status(uint16_t port_num, uint32_t port_mask) 472 { 473 #define CHECK_INTERVAL 100 /* 100ms */ 474 #define MAX_CHECK_TIME 90 /* 9s (90 * 100ms) in total */ 475 uint8_t count, all_ports_up, print_flag = 0; 476 uint16_t portid; 477 struct rte_eth_link link; 478 int ret; 479 480 printf("\nChecking link status"); 481 fflush(stdout); 482 for (count = 0; count <= MAX_CHECK_TIME; count++) { 483 all_ports_up = 1; 484 for (portid = 0; portid < port_num; portid++) { 485 if ((port_mask & (1 << portid)) == 0) 486 continue; 487 memset(&link, 0, sizeof(link)); 488 ret = rte_eth_link_get_nowait(portid, &link); 489 if (ret < 0) { 490 all_ports_up = 0; 491 if (print_flag == 1) 492 printf("Port %u link get failed: %s\n", 493 portid, rte_strerror(-ret)); 494 continue; 495 } 496 /* print link status if flag set */ 497 if (print_flag == 1) { 498 if (link.link_status) 499 printf( 500 "Port%d Link Up. Speed %u Mbps - %s\n", 501 portid, link.link_speed, 502 (link.link_duplex == ETH_LINK_FULL_DUPLEX) ? 503 ("full-duplex") : ("half-duplex\n")); 504 else 505 printf("Port %d Link Down\n", portid); 506 continue; 507 } 508 /* clear all_ports_up flag if any link down */ 509 if (link.link_status == ETH_LINK_DOWN) { 510 all_ports_up = 0; 511 break; 512 } 513 } 514 /* after finally printing all link status, get out */ 515 if (print_flag == 1) 516 break; 517 518 if (all_ports_up == 0) { 519 printf("."); 520 fflush(stdout); 521 rte_delay_ms(CHECK_INTERVAL); 522 } 523 524 /* set the print_flag if all ports up or timeout */ 525 if (all_ports_up == 1 || count == (MAX_CHECK_TIME - 1)) { 526 print_flag = 1; 527 printf("done\n"); 528 } 529 } 530 } 531 532 int 533 main(int argc, char **argv) 534 { 535 struct lcore_queue_conf *qconf; 536 int ret; 537 uint16_t nb_ports; 538 uint16_t portid, portid_last = 0; 539 unsigned lcore_id, rx_lcore_id; 540 unsigned nb_ports_in_mask = 0; 541 542 /* init EAL */ 543 ret = rte_eal_init(argc, argv); 544 if (ret < 0) 545 rte_exit(EXIT_FAILURE, "rte_eal_init failed"); 546 argc -= ret; 547 argv += ret; 548 549 /* parse application arguments (after the EAL ones) */ 550 ret = lsi_parse_args(argc, argv); 551 if (ret < 0) 552 rte_exit(EXIT_FAILURE, "Invalid arguments"); 553 554 /* create the mbuf pool */ 555 lsi_pktmbuf_pool = 556 rte_pktmbuf_pool_create("mbuf_pool", NB_MBUF, 32, 0, 557 RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); 558 if (lsi_pktmbuf_pool == NULL) 559 rte_panic("Cannot init mbuf pool\n"); 560 561 nb_ports = rte_eth_dev_count_avail(); 562 if (nb_ports == 0) 563 rte_panic("No Ethernet port - bye\n"); 564 565 /* 566 * Each logical core is assigned a dedicated TX queue on each port. 567 */ 568 for (portid = 0; portid < nb_ports; portid++) { 569 /* skip ports that are not enabled */ 570 if ((lsi_enabled_port_mask & (1 << portid)) == 0) 571 continue; 572 573 /* save the destination port id */ 574 if (nb_ports_in_mask % 2) { 575 lsi_dst_ports[portid] = portid_last; 576 lsi_dst_ports[portid_last] = portid; 577 } 578 else 579 portid_last = portid; 580 581 nb_ports_in_mask++; 582 } 583 if (nb_ports_in_mask < 2 || nb_ports_in_mask % 2) 584 rte_exit(EXIT_FAILURE, "Current enabled port number is %u, " 585 "but it should be even and at least 2\n", 586 nb_ports_in_mask); 587 588 rx_lcore_id = 0; 589 qconf = &lcore_queue_conf[rx_lcore_id]; 590 591 /* Initialize the port/queue configuration of each logical core */ 592 for (portid = 0; portid < nb_ports; portid++) { 593 /* skip ports that are not enabled */ 594 if ((lsi_enabled_port_mask & (1 << portid)) == 0) 595 continue; 596 597 /* get the lcore_id for this port */ 598 while (rte_lcore_is_enabled(rx_lcore_id) == 0 || 599 lcore_queue_conf[rx_lcore_id].n_rx_port == 600 lsi_rx_queue_per_lcore) { 601 602 rx_lcore_id++; 603 if (rx_lcore_id >= RTE_MAX_LCORE) 604 rte_exit(EXIT_FAILURE, "Not enough cores\n"); 605 } 606 if (qconf != &lcore_queue_conf[rx_lcore_id]) 607 /* Assigned a new logical core in the loop above. */ 608 qconf = &lcore_queue_conf[rx_lcore_id]; 609 610 qconf->rx_port_list[qconf->n_rx_port] = portid; 611 qconf->n_rx_port++; 612 printf("Lcore %u: RX port %u\n",rx_lcore_id, (unsigned) portid); 613 } 614 615 /* Initialise each port */ 616 for (portid = 0; portid < nb_ports; portid++) { 617 struct rte_eth_rxconf rxq_conf; 618 struct rte_eth_txconf txq_conf; 619 struct rte_eth_conf local_port_conf = port_conf; 620 struct rte_eth_dev_info dev_info; 621 622 /* skip ports that are not enabled */ 623 if ((lsi_enabled_port_mask & (1 << portid)) == 0) { 624 printf("Skipping disabled port %u\n", (unsigned) portid); 625 continue; 626 } 627 /* init port */ 628 printf("Initializing port %u... ", (unsigned) portid); 629 fflush(stdout); 630 631 ret = rte_eth_dev_info_get(portid, &dev_info); 632 if (ret != 0) 633 rte_exit(EXIT_FAILURE, 634 "Error during getting device (port %u) info: %s\n", 635 portid, strerror(-ret)); 636 637 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE) 638 local_port_conf.txmode.offloads |= 639 DEV_TX_OFFLOAD_MBUF_FAST_FREE; 640 ret = rte_eth_dev_configure(portid, 1, 1, &local_port_conf); 641 if (ret < 0) 642 rte_exit(EXIT_FAILURE, "Cannot configure device: err=%d, port=%u\n", 643 ret, (unsigned) portid); 644 645 ret = rte_eth_dev_adjust_nb_rx_tx_desc(portid, &nb_rxd, 646 &nb_txd); 647 if (ret < 0) 648 rte_exit(EXIT_FAILURE, 649 "rte_eth_dev_adjust_nb_rx_tx_desc: err=%d, port=%u\n", 650 ret, (unsigned) portid); 651 652 /* register lsi interrupt callback, need to be after 653 * rte_eth_dev_configure(). if (intr_conf.lsc == 0), no 654 * lsc interrupt will be present, and below callback to 655 * be registered will never be called. 656 */ 657 rte_eth_dev_callback_register(portid, 658 RTE_ETH_EVENT_INTR_LSC, lsi_event_callback, NULL); 659 660 ret = rte_eth_macaddr_get(portid, 661 &lsi_ports_eth_addr[portid]); 662 if (ret < 0) 663 rte_exit(EXIT_FAILURE, 664 "rte_eth_macaddr_get: err=%d, port=%u\n", 665 ret, (unsigned int)portid); 666 667 /* init one RX queue */ 668 fflush(stdout); 669 rxq_conf = dev_info.default_rxconf; 670 rxq_conf.offloads = local_port_conf.rxmode.offloads; 671 ret = rte_eth_rx_queue_setup(portid, 0, nb_rxd, 672 rte_eth_dev_socket_id(portid), 673 &rxq_conf, 674 lsi_pktmbuf_pool); 675 if (ret < 0) 676 rte_exit(EXIT_FAILURE, "rte_eth_rx_queue_setup: err=%d, port=%u\n", 677 ret, (unsigned) portid); 678 679 /* init one TX queue logical core on each port */ 680 fflush(stdout); 681 txq_conf = dev_info.default_txconf; 682 txq_conf.offloads = local_port_conf.txmode.offloads; 683 ret = rte_eth_tx_queue_setup(portid, 0, nb_txd, 684 rte_eth_dev_socket_id(portid), 685 &txq_conf); 686 if (ret < 0) 687 rte_exit(EXIT_FAILURE, "rte_eth_tx_queue_setup: err=%d,port=%u\n", 688 ret, (unsigned) portid); 689 690 /* Initialize TX buffers */ 691 tx_buffer[portid] = rte_zmalloc_socket("tx_buffer", 692 RTE_ETH_TX_BUFFER_SIZE(MAX_PKT_BURST), 0, 693 rte_eth_dev_socket_id(portid)); 694 if (tx_buffer[portid] == NULL) 695 rte_exit(EXIT_FAILURE, "Cannot allocate buffer for tx on port %u\n", 696 (unsigned) portid); 697 698 rte_eth_tx_buffer_init(tx_buffer[portid], MAX_PKT_BURST); 699 700 ret = rte_eth_tx_buffer_set_err_callback(tx_buffer[portid], 701 rte_eth_tx_buffer_count_callback, 702 &port_statistics[portid].dropped); 703 if (ret < 0) 704 rte_exit(EXIT_FAILURE, "Cannot set error callback for " 705 "tx buffer on port %u\n", (unsigned) portid); 706 707 /* Start device */ 708 ret = rte_eth_dev_start(portid); 709 if (ret < 0) 710 rte_exit(EXIT_FAILURE, "rte_eth_dev_start: err=%d, port=%u\n", 711 ret, (unsigned) portid); 712 printf("done:\n"); 713 714 ret = rte_eth_promiscuous_enable(portid); 715 if (ret != 0) 716 rte_exit(EXIT_FAILURE, 717 "rte_eth_promiscuous_enable: err=%s, port=%u\n", 718 rte_strerror(-ret), portid); 719 720 printf("Port %u, MAC address: %02X:%02X:%02X:%02X:%02X:%02X\n\n", 721 (unsigned) portid, 722 lsi_ports_eth_addr[portid].addr_bytes[0], 723 lsi_ports_eth_addr[portid].addr_bytes[1], 724 lsi_ports_eth_addr[portid].addr_bytes[2], 725 lsi_ports_eth_addr[portid].addr_bytes[3], 726 lsi_ports_eth_addr[portid].addr_bytes[4], 727 lsi_ports_eth_addr[portid].addr_bytes[5]); 728 729 /* initialize port stats */ 730 memset(&port_statistics, 0, sizeof(port_statistics)); 731 } 732 733 check_all_ports_link_status(nb_ports, lsi_enabled_port_mask); 734 735 /* launch per-lcore init on every lcore */ 736 rte_eal_mp_remote_launch(lsi_launch_one_lcore, NULL, CALL_MASTER); 737 RTE_LCORE_FOREACH_SLAVE(lcore_id) { 738 if (rte_eal_wait_lcore(lcore_id) < 0) 739 return -1; 740 } 741 742 return 0; 743 } 744