1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2014 Intel Corporation 3 */ 4 5 #include <stdio.h> 6 #include <stdlib.h> 7 #include <stdint.h> 8 #include <inttypes.h> 9 #include <string.h> 10 #include <sys/queue.h> 11 #include <stdarg.h> 12 #include <errno.h> 13 #include <getopt.h> 14 15 #include <netinet/in.h> 16 #include <linux/if.h> 17 #include <linux/if_tun.h> 18 #include <fcntl.h> 19 #include <sys/ioctl.h> 20 #include <unistd.h> 21 #include <signal.h> 22 23 #include <rte_common.h> 24 #include <rte_log.h> 25 #include <rte_memory.h> 26 #include <rte_memcpy.h> 27 #include <rte_eal.h> 28 #include <rte_per_lcore.h> 29 #include <rte_launch.h> 30 #include <rte_atomic.h> 31 #include <rte_lcore.h> 32 #include <rte_branch_prediction.h> 33 #include <rte_interrupts.h> 34 #include <rte_bus_pci.h> 35 #include <rte_debug.h> 36 #include <rte_ether.h> 37 #include <rte_ethdev.h> 38 #include <rte_mempool.h> 39 #include <rte_mbuf.h> 40 #include <rte_string_fns.h> 41 #include <rte_cycles.h> 42 #include <rte_malloc.h> 43 #include <rte_kni.h> 44 45 /* Macros for printing using RTE_LOG */ 46 #define RTE_LOGTYPE_APP RTE_LOGTYPE_USER1 47 48 /* Max size of a single packet */ 49 #define MAX_PACKET_SZ 2048 50 51 /* Size of the data buffer in each mbuf */ 52 #define MBUF_DATA_SZ (MAX_PACKET_SZ + RTE_PKTMBUF_HEADROOM) 53 54 /* Number of mbufs in mempool that is created */ 55 #define NB_MBUF (8192 * 16) 56 57 /* How many packets to attempt to read from NIC in one go */ 58 #define PKT_BURST_SZ 32 59 60 /* How many objects (mbufs) to keep in per-lcore mempool cache */ 61 #define MEMPOOL_CACHE_SZ PKT_BURST_SZ 62 63 /* Number of RX ring descriptors */ 64 #define NB_RXD 1024 65 66 /* Number of TX ring descriptors */ 67 #define NB_TXD 1024 68 69 /* Total octets in ethernet header */ 70 #define KNI_ENET_HEADER_SIZE 14 71 72 /* Total octets in the FCS */ 73 #define KNI_ENET_FCS_SIZE 4 74 75 #define KNI_US_PER_SECOND 1000000 76 #define KNI_SECOND_PER_DAY 86400 77 78 #define KNI_MAX_KTHREAD 32 79 /* 80 * Structure of port parameters 81 */ 82 struct kni_port_params { 83 uint16_t port_id;/* Port ID */ 84 unsigned lcore_rx; /* lcore ID for RX */ 85 unsigned lcore_tx; /* lcore ID for TX */ 86 uint32_t nb_lcore_k; /* Number of lcores for KNI multi kernel threads */ 87 uint32_t nb_kni; /* Number of KNI devices to be created */ 88 unsigned lcore_k[KNI_MAX_KTHREAD]; /* lcore ID list for kthreads */ 89 struct rte_kni *kni[KNI_MAX_KTHREAD]; /* KNI context pointers */ 90 } __rte_cache_aligned; 91 92 static struct kni_port_params *kni_port_params_array[RTE_MAX_ETHPORTS]; 93 94 95 /* Options for configuring ethernet port */ 96 static struct rte_eth_conf port_conf = { 97 .txmode = { 98 .mq_mode = ETH_MQ_TX_NONE, 99 }, 100 }; 101 102 /* Mempool for mbufs */ 103 static struct rte_mempool * pktmbuf_pool = NULL; 104 105 /* Mask of enabled ports */ 106 static uint32_t ports_mask = 0; 107 /* Ports set in promiscuous mode off by default. */ 108 static int promiscuous_on = 0; 109 /* Monitor link status continually. off by default. */ 110 static int monitor_links; 111 112 /* Structure type for recording kni interface specific stats */ 113 struct kni_interface_stats { 114 /* number of pkts received from NIC, and sent to KNI */ 115 uint64_t rx_packets; 116 117 /* number of pkts received from NIC, but failed to send to KNI */ 118 uint64_t rx_dropped; 119 120 /* number of pkts received from KNI, and sent to NIC */ 121 uint64_t tx_packets; 122 123 /* number of pkts received from KNI, but failed to send to NIC */ 124 uint64_t tx_dropped; 125 }; 126 127 /* kni device statistics array */ 128 static struct kni_interface_stats kni_stats[RTE_MAX_ETHPORTS]; 129 130 static int kni_change_mtu(uint16_t port_id, unsigned int new_mtu); 131 static int kni_config_network_interface(uint16_t port_id, uint8_t if_up); 132 static int kni_config_mac_address(uint16_t port_id, uint8_t mac_addr[]); 133 134 static rte_atomic32_t kni_stop = RTE_ATOMIC32_INIT(0); 135 static rte_atomic32_t kni_pause = RTE_ATOMIC32_INIT(0); 136 137 /* Print out statistics on packets handled */ 138 static void 139 print_stats(void) 140 { 141 uint16_t i; 142 143 printf("\n**KNI example application statistics**\n" 144 "====== ============== ============ ============ ============ ============\n" 145 " Port Lcore(RX/TX) rx_packets rx_dropped tx_packets tx_dropped\n" 146 "------ -------------- ------------ ------------ ------------ ------------\n"); 147 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 148 if (!kni_port_params_array[i]) 149 continue; 150 151 printf("%7d %10u/%2u %13"PRIu64" %13"PRIu64" %13"PRIu64" " 152 "%13"PRIu64"\n", i, 153 kni_port_params_array[i]->lcore_rx, 154 kni_port_params_array[i]->lcore_tx, 155 kni_stats[i].rx_packets, 156 kni_stats[i].rx_dropped, 157 kni_stats[i].tx_packets, 158 kni_stats[i].tx_dropped); 159 } 160 printf("====== ============== ============ ============ ============ ============\n"); 161 } 162 163 /* Custom handling of signals to handle stats and kni processing */ 164 static void 165 signal_handler(int signum) 166 { 167 /* When we receive a USR1 signal, print stats */ 168 if (signum == SIGUSR1) { 169 print_stats(); 170 } 171 172 /* When we receive a USR2 signal, reset stats */ 173 if (signum == SIGUSR2) { 174 memset(&kni_stats, 0, sizeof(kni_stats)); 175 printf("\n** Statistics have been reset **\n"); 176 return; 177 } 178 179 /* When we receive a RTMIN or SIGINT signal, stop kni processing */ 180 if (signum == SIGRTMIN || signum == SIGINT){ 181 printf("\nSIGRTMIN/SIGINT received. KNI processing stopping.\n"); 182 rte_atomic32_inc(&kni_stop); 183 return; 184 } 185 } 186 187 static void 188 kni_burst_free_mbufs(struct rte_mbuf **pkts, unsigned num) 189 { 190 unsigned i; 191 192 if (pkts == NULL) 193 return; 194 195 for (i = 0; i < num; i++) { 196 rte_pktmbuf_free(pkts[i]); 197 pkts[i] = NULL; 198 } 199 } 200 201 /** 202 * Interface to burst rx and enqueue mbufs into rx_q 203 */ 204 static void 205 kni_ingress(struct kni_port_params *p) 206 { 207 uint8_t i; 208 uint16_t port_id; 209 unsigned nb_rx, num; 210 uint32_t nb_kni; 211 struct rte_mbuf *pkts_burst[PKT_BURST_SZ]; 212 213 if (p == NULL) 214 return; 215 216 nb_kni = p->nb_kni; 217 port_id = p->port_id; 218 for (i = 0; i < nb_kni; i++) { 219 /* Burst rx from eth */ 220 nb_rx = rte_eth_rx_burst(port_id, 0, pkts_burst, PKT_BURST_SZ); 221 if (unlikely(nb_rx > PKT_BURST_SZ)) { 222 RTE_LOG(ERR, APP, "Error receiving from eth\n"); 223 return; 224 } 225 /* Burst tx to kni */ 226 num = rte_kni_tx_burst(p->kni[i], pkts_burst, nb_rx); 227 if (num) 228 kni_stats[port_id].rx_packets += num; 229 230 rte_kni_handle_request(p->kni[i]); 231 if (unlikely(num < nb_rx)) { 232 /* Free mbufs not tx to kni interface */ 233 kni_burst_free_mbufs(&pkts_burst[num], nb_rx - num); 234 kni_stats[port_id].rx_dropped += nb_rx - num; 235 } 236 } 237 } 238 239 /** 240 * Interface to dequeue mbufs from tx_q and burst tx 241 */ 242 static void 243 kni_egress(struct kni_port_params *p) 244 { 245 uint8_t i; 246 uint16_t port_id; 247 unsigned nb_tx, num; 248 uint32_t nb_kni; 249 struct rte_mbuf *pkts_burst[PKT_BURST_SZ]; 250 251 if (p == NULL) 252 return; 253 254 nb_kni = p->nb_kni; 255 port_id = p->port_id; 256 for (i = 0; i < nb_kni; i++) { 257 /* Burst rx from kni */ 258 num = rte_kni_rx_burst(p->kni[i], pkts_burst, PKT_BURST_SZ); 259 if (unlikely(num > PKT_BURST_SZ)) { 260 RTE_LOG(ERR, APP, "Error receiving from KNI\n"); 261 return; 262 } 263 /* Burst tx to eth */ 264 nb_tx = rte_eth_tx_burst(port_id, 0, pkts_burst, (uint16_t)num); 265 if (nb_tx) 266 kni_stats[port_id].tx_packets += nb_tx; 267 if (unlikely(nb_tx < num)) { 268 /* Free mbufs not tx to NIC */ 269 kni_burst_free_mbufs(&pkts_burst[nb_tx], num - nb_tx); 270 kni_stats[port_id].tx_dropped += num - nb_tx; 271 } 272 } 273 } 274 275 static int 276 main_loop(__rte_unused void *arg) 277 { 278 uint16_t i; 279 int32_t f_stop; 280 int32_t f_pause; 281 const unsigned lcore_id = rte_lcore_id(); 282 enum lcore_rxtx { 283 LCORE_NONE, 284 LCORE_RX, 285 LCORE_TX, 286 LCORE_MAX 287 }; 288 enum lcore_rxtx flag = LCORE_NONE; 289 290 RTE_ETH_FOREACH_DEV(i) { 291 if (!kni_port_params_array[i]) 292 continue; 293 if (kni_port_params_array[i]->lcore_rx == (uint8_t)lcore_id) { 294 flag = LCORE_RX; 295 break; 296 } else if (kni_port_params_array[i]->lcore_tx == 297 (uint8_t)lcore_id) { 298 flag = LCORE_TX; 299 break; 300 } 301 } 302 303 if (flag == LCORE_RX) { 304 RTE_LOG(INFO, APP, "Lcore %u is reading from port %d\n", 305 kni_port_params_array[i]->lcore_rx, 306 kni_port_params_array[i]->port_id); 307 while (1) { 308 f_stop = rte_atomic32_read(&kni_stop); 309 f_pause = rte_atomic32_read(&kni_pause); 310 if (f_stop) 311 break; 312 if (f_pause) 313 continue; 314 kni_ingress(kni_port_params_array[i]); 315 } 316 } else if (flag == LCORE_TX) { 317 RTE_LOG(INFO, APP, "Lcore %u is writing to port %d\n", 318 kni_port_params_array[i]->lcore_tx, 319 kni_port_params_array[i]->port_id); 320 while (1) { 321 f_stop = rte_atomic32_read(&kni_stop); 322 f_pause = rte_atomic32_read(&kni_pause); 323 if (f_stop) 324 break; 325 if (f_pause) 326 continue; 327 kni_egress(kni_port_params_array[i]); 328 } 329 } else 330 RTE_LOG(INFO, APP, "Lcore %u has nothing to do\n", lcore_id); 331 332 return 0; 333 } 334 335 /* Display usage instructions */ 336 static void 337 print_usage(const char *prgname) 338 { 339 RTE_LOG(INFO, APP, "\nUsage: %s [EAL options] -- -p PORTMASK -P -m " 340 "[--config (port,lcore_rx,lcore_tx,lcore_kthread...)" 341 "[,(port,lcore_rx,lcore_tx,lcore_kthread...)]]\n" 342 " -p PORTMASK: hex bitmask of ports to use\n" 343 " -P : enable promiscuous mode\n" 344 " -m : enable monitoring of port carrier state\n" 345 " --config (port,lcore_rx,lcore_tx,lcore_kthread...): " 346 "port and lcore configurations\n", 347 prgname); 348 } 349 350 /* Convert string to unsigned number. 0 is returned if error occurs */ 351 static uint32_t 352 parse_unsigned(const char *portmask) 353 { 354 char *end = NULL; 355 unsigned long num; 356 357 num = strtoul(portmask, &end, 16); 358 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0')) 359 return 0; 360 361 return (uint32_t)num; 362 } 363 364 static void 365 print_config(void) 366 { 367 uint32_t i, j; 368 struct kni_port_params **p = kni_port_params_array; 369 370 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 371 if (!p[i]) 372 continue; 373 RTE_LOG(DEBUG, APP, "Port ID: %d\n", p[i]->port_id); 374 RTE_LOG(DEBUG, APP, "Rx lcore ID: %u, Tx lcore ID: %u\n", 375 p[i]->lcore_rx, p[i]->lcore_tx); 376 for (j = 0; j < p[i]->nb_lcore_k; j++) 377 RTE_LOG(DEBUG, APP, "Kernel thread lcore ID: %u\n", 378 p[i]->lcore_k[j]); 379 } 380 } 381 382 static int 383 parse_config(const char *arg) 384 { 385 const char *p, *p0 = arg; 386 char s[256], *end; 387 unsigned size; 388 enum fieldnames { 389 FLD_PORT = 0, 390 FLD_LCORE_RX, 391 FLD_LCORE_TX, 392 _NUM_FLD = KNI_MAX_KTHREAD + 3, 393 }; 394 int i, j, nb_token; 395 char *str_fld[_NUM_FLD]; 396 unsigned long int_fld[_NUM_FLD]; 397 uint16_t port_id, nb_kni_port_params = 0; 398 399 memset(&kni_port_params_array, 0, sizeof(kni_port_params_array)); 400 while (((p = strchr(p0, '(')) != NULL) && 401 nb_kni_port_params < RTE_MAX_ETHPORTS) { 402 p++; 403 if ((p0 = strchr(p, ')')) == NULL) 404 goto fail; 405 size = p0 - p; 406 if (size >= sizeof(s)) { 407 printf("Invalid config parameters\n"); 408 goto fail; 409 } 410 snprintf(s, sizeof(s), "%.*s", size, p); 411 nb_token = rte_strsplit(s, sizeof(s), str_fld, _NUM_FLD, ','); 412 if (nb_token <= FLD_LCORE_TX) { 413 printf("Invalid config parameters\n"); 414 goto fail; 415 } 416 for (i = 0; i < nb_token; i++) { 417 errno = 0; 418 int_fld[i] = strtoul(str_fld[i], &end, 0); 419 if (errno != 0 || end == str_fld[i]) { 420 printf("Invalid config parameters\n"); 421 goto fail; 422 } 423 } 424 425 i = 0; 426 port_id = int_fld[i++]; 427 if (port_id >= RTE_MAX_ETHPORTS) { 428 printf("Port ID %d could not exceed the maximum %d\n", 429 port_id, RTE_MAX_ETHPORTS); 430 goto fail; 431 } 432 if (kni_port_params_array[port_id]) { 433 printf("Port %d has been configured\n", port_id); 434 goto fail; 435 } 436 kni_port_params_array[port_id] = 437 rte_zmalloc("KNI_port_params", 438 sizeof(struct kni_port_params), RTE_CACHE_LINE_SIZE); 439 kni_port_params_array[port_id]->port_id = port_id; 440 kni_port_params_array[port_id]->lcore_rx = 441 (uint8_t)int_fld[i++]; 442 kni_port_params_array[port_id]->lcore_tx = 443 (uint8_t)int_fld[i++]; 444 if (kni_port_params_array[port_id]->lcore_rx >= RTE_MAX_LCORE || 445 kni_port_params_array[port_id]->lcore_tx >= RTE_MAX_LCORE) { 446 printf("lcore_rx %u or lcore_tx %u ID could not " 447 "exceed the maximum %u\n", 448 kni_port_params_array[port_id]->lcore_rx, 449 kni_port_params_array[port_id]->lcore_tx, 450 (unsigned)RTE_MAX_LCORE); 451 goto fail; 452 } 453 for (j = 0; i < nb_token && j < KNI_MAX_KTHREAD; i++, j++) 454 kni_port_params_array[port_id]->lcore_k[j] = 455 (uint8_t)int_fld[i]; 456 kni_port_params_array[port_id]->nb_lcore_k = j; 457 } 458 print_config(); 459 460 return 0; 461 462 fail: 463 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 464 if (kni_port_params_array[i]) { 465 rte_free(kni_port_params_array[i]); 466 kni_port_params_array[i] = NULL; 467 } 468 } 469 470 return -1; 471 } 472 473 static int 474 validate_parameters(uint32_t portmask) 475 { 476 uint32_t i; 477 478 if (!portmask) { 479 printf("No port configured in port mask\n"); 480 return -1; 481 } 482 483 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 484 if (((portmask & (1 << i)) && !kni_port_params_array[i]) || 485 (!(portmask & (1 << i)) && kni_port_params_array[i])) 486 rte_exit(EXIT_FAILURE, "portmask is not consistent " 487 "to port ids specified in --config\n"); 488 489 if (kni_port_params_array[i] && !rte_lcore_is_enabled(\ 490 (unsigned)(kni_port_params_array[i]->lcore_rx))) 491 rte_exit(EXIT_FAILURE, "lcore id %u for " 492 "port %d receiving not enabled\n", 493 kni_port_params_array[i]->lcore_rx, 494 kni_port_params_array[i]->port_id); 495 496 if (kni_port_params_array[i] && !rte_lcore_is_enabled(\ 497 (unsigned)(kni_port_params_array[i]->lcore_tx))) 498 rte_exit(EXIT_FAILURE, "lcore id %u for " 499 "port %d transmitting not enabled\n", 500 kni_port_params_array[i]->lcore_tx, 501 kni_port_params_array[i]->port_id); 502 503 } 504 505 return 0; 506 } 507 508 #define CMDLINE_OPT_CONFIG "config" 509 510 /* Parse the arguments given in the command line of the application */ 511 static int 512 parse_args(int argc, char **argv) 513 { 514 int opt, longindex, ret = 0; 515 const char *prgname = argv[0]; 516 static struct option longopts[] = { 517 {CMDLINE_OPT_CONFIG, required_argument, NULL, 0}, 518 {NULL, 0, NULL, 0} 519 }; 520 521 /* Disable printing messages within getopt() */ 522 opterr = 0; 523 524 /* Parse command line */ 525 while ((opt = getopt_long(argc, argv, "p:Pm", longopts, 526 &longindex)) != EOF) { 527 switch (opt) { 528 case 'p': 529 ports_mask = parse_unsigned(optarg); 530 break; 531 case 'P': 532 promiscuous_on = 1; 533 break; 534 case 'm': 535 monitor_links = 1; 536 break; 537 case 0: 538 if (!strncmp(longopts[longindex].name, 539 CMDLINE_OPT_CONFIG, 540 sizeof(CMDLINE_OPT_CONFIG))) { 541 ret = parse_config(optarg); 542 if (ret) { 543 printf("Invalid config\n"); 544 print_usage(prgname); 545 return -1; 546 } 547 } 548 break; 549 default: 550 print_usage(prgname); 551 rte_exit(EXIT_FAILURE, "Invalid option specified\n"); 552 } 553 } 554 555 /* Check that options were parsed ok */ 556 if (validate_parameters(ports_mask) < 0) { 557 print_usage(prgname); 558 rte_exit(EXIT_FAILURE, "Invalid parameters\n"); 559 } 560 561 return ret; 562 } 563 564 /* Initialize KNI subsystem */ 565 static void 566 init_kni(void) 567 { 568 unsigned int num_of_kni_ports = 0, i; 569 struct kni_port_params **params = kni_port_params_array; 570 571 /* Calculate the maximum number of KNI interfaces that will be used */ 572 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 573 if (kni_port_params_array[i]) { 574 num_of_kni_ports += (params[i]->nb_lcore_k ? 575 params[i]->nb_lcore_k : 1); 576 } 577 } 578 579 /* Invoke rte KNI init to preallocate the ports */ 580 rte_kni_init(num_of_kni_ports); 581 } 582 583 /* Initialise a single port on an Ethernet device */ 584 static void 585 init_port(uint16_t port) 586 { 587 int ret; 588 uint16_t nb_rxd = NB_RXD; 589 uint16_t nb_txd = NB_TXD; 590 struct rte_eth_dev_info dev_info; 591 struct rte_eth_rxconf rxq_conf; 592 struct rte_eth_txconf txq_conf; 593 struct rte_eth_conf local_port_conf = port_conf; 594 595 /* Initialise device and RX/TX queues */ 596 RTE_LOG(INFO, APP, "Initialising port %u ...\n", (unsigned)port); 597 fflush(stdout); 598 599 ret = rte_eth_dev_info_get(port, &dev_info); 600 if (ret != 0) 601 rte_exit(EXIT_FAILURE, 602 "Error during getting device (port %u) info: %s\n", 603 port, strerror(-ret)); 604 605 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE) 606 local_port_conf.txmode.offloads |= 607 DEV_TX_OFFLOAD_MBUF_FAST_FREE; 608 ret = rte_eth_dev_configure(port, 1, 1, &local_port_conf); 609 if (ret < 0) 610 rte_exit(EXIT_FAILURE, "Could not configure port%u (%d)\n", 611 (unsigned)port, ret); 612 613 ret = rte_eth_dev_adjust_nb_rx_tx_desc(port, &nb_rxd, &nb_txd); 614 if (ret < 0) 615 rte_exit(EXIT_FAILURE, "Could not adjust number of descriptors " 616 "for port%u (%d)\n", (unsigned)port, ret); 617 618 rxq_conf = dev_info.default_rxconf; 619 rxq_conf.offloads = local_port_conf.rxmode.offloads; 620 ret = rte_eth_rx_queue_setup(port, 0, nb_rxd, 621 rte_eth_dev_socket_id(port), &rxq_conf, pktmbuf_pool); 622 if (ret < 0) 623 rte_exit(EXIT_FAILURE, "Could not setup up RX queue for " 624 "port%u (%d)\n", (unsigned)port, ret); 625 626 txq_conf = dev_info.default_txconf; 627 txq_conf.offloads = local_port_conf.txmode.offloads; 628 ret = rte_eth_tx_queue_setup(port, 0, nb_txd, 629 rte_eth_dev_socket_id(port), &txq_conf); 630 if (ret < 0) 631 rte_exit(EXIT_FAILURE, "Could not setup up TX queue for " 632 "port%u (%d)\n", (unsigned)port, ret); 633 634 ret = rte_eth_dev_start(port); 635 if (ret < 0) 636 rte_exit(EXIT_FAILURE, "Could not start port%u (%d)\n", 637 (unsigned)port, ret); 638 639 if (promiscuous_on) { 640 ret = rte_eth_promiscuous_enable(port); 641 if (ret != 0) 642 rte_exit(EXIT_FAILURE, 643 "Could not enable promiscuous mode for port%u: %s\n", 644 port, rte_strerror(-ret)); 645 } 646 } 647 648 /* Check the link status of all ports in up to 9s, and print them finally */ 649 static void 650 check_all_ports_link_status(uint32_t port_mask) 651 { 652 #define CHECK_INTERVAL 100 /* 100ms */ 653 #define MAX_CHECK_TIME 90 /* 9s (90 * 100ms) in total */ 654 uint16_t portid; 655 uint8_t count, all_ports_up, print_flag = 0; 656 struct rte_eth_link link; 657 int ret; 658 659 printf("\nChecking link status\n"); 660 fflush(stdout); 661 for (count = 0; count <= MAX_CHECK_TIME; count++) { 662 all_ports_up = 1; 663 RTE_ETH_FOREACH_DEV(portid) { 664 if ((port_mask & (1 << portid)) == 0) 665 continue; 666 memset(&link, 0, sizeof(link)); 667 ret = rte_eth_link_get_nowait(portid, &link); 668 if (ret < 0) { 669 all_ports_up = 0; 670 if (print_flag == 1) 671 printf("Port %u link get failed: %s\n", 672 portid, rte_strerror(-ret)); 673 continue; 674 } 675 /* print link status if flag set */ 676 if (print_flag == 1) { 677 if (link.link_status) 678 printf( 679 "Port%d Link Up - speed %uMbps - %s\n", 680 portid, link.link_speed, 681 (link.link_duplex == ETH_LINK_FULL_DUPLEX) ? 682 ("full-duplex") : ("half-duplex\n")); 683 else 684 printf("Port %d Link Down\n", portid); 685 continue; 686 } 687 /* clear all_ports_up flag if any link down */ 688 if (link.link_status == ETH_LINK_DOWN) { 689 all_ports_up = 0; 690 break; 691 } 692 } 693 /* after finally printing all link status, get out */ 694 if (print_flag == 1) 695 break; 696 697 if (all_ports_up == 0) { 698 printf("."); 699 fflush(stdout); 700 rte_delay_ms(CHECK_INTERVAL); 701 } 702 703 /* set the print_flag if all ports up or timeout */ 704 if (all_ports_up == 1 || count == (MAX_CHECK_TIME - 1)) { 705 print_flag = 1; 706 printf("done\n"); 707 } 708 } 709 } 710 711 static void 712 log_link_state(struct rte_kni *kni, int prev, struct rte_eth_link *link) 713 { 714 if (kni == NULL || link == NULL) 715 return; 716 717 if (prev == ETH_LINK_DOWN && link->link_status == ETH_LINK_UP) { 718 RTE_LOG(INFO, APP, "%s NIC Link is Up %d Mbps %s %s.\n", 719 rte_kni_get_name(kni), 720 link->link_speed, 721 link->link_autoneg ? "(AutoNeg)" : "(Fixed)", 722 link->link_duplex ? "Full Duplex" : "Half Duplex"); 723 } else if (prev == ETH_LINK_UP && link->link_status == ETH_LINK_DOWN) { 724 RTE_LOG(INFO, APP, "%s NIC Link is Down.\n", 725 rte_kni_get_name(kni)); 726 } 727 } 728 729 /* 730 * Monitor the link status of all ports and update the 731 * corresponding KNI interface(s) 732 */ 733 static void * 734 monitor_all_ports_link_status(void *arg) 735 { 736 uint16_t portid; 737 struct rte_eth_link link; 738 unsigned int i; 739 struct kni_port_params **p = kni_port_params_array; 740 int prev; 741 (void) arg; 742 int ret; 743 744 while (monitor_links) { 745 rte_delay_ms(500); 746 RTE_ETH_FOREACH_DEV(portid) { 747 if ((ports_mask & (1 << portid)) == 0) 748 continue; 749 memset(&link, 0, sizeof(link)); 750 ret = rte_eth_link_get_nowait(portid, &link); 751 if (ret < 0) { 752 RTE_LOG(ERR, APP, 753 "Get link failed (port %u): %s\n", 754 portid, rte_strerror(-ret)); 755 continue; 756 } 757 for (i = 0; i < p[portid]->nb_kni; i++) { 758 prev = rte_kni_update_link(p[portid]->kni[i], 759 link.link_status); 760 log_link_state(p[portid]->kni[i], prev, &link); 761 } 762 } 763 } 764 return NULL; 765 } 766 767 /* Callback for request of changing MTU */ 768 static int 769 kni_change_mtu(uint16_t port_id, unsigned int new_mtu) 770 { 771 int ret; 772 uint16_t nb_rxd = NB_RXD; 773 struct rte_eth_conf conf; 774 struct rte_eth_dev_info dev_info; 775 struct rte_eth_rxconf rxq_conf; 776 777 if (!rte_eth_dev_is_valid_port(port_id)) { 778 RTE_LOG(ERR, APP, "Invalid port id %d\n", port_id); 779 return -EINVAL; 780 } 781 782 RTE_LOG(INFO, APP, "Change MTU of port %d to %u\n", port_id, new_mtu); 783 784 /* Stop specific port */ 785 rte_eth_dev_stop(port_id); 786 787 memcpy(&conf, &port_conf, sizeof(conf)); 788 /* Set new MTU */ 789 if (new_mtu > RTE_ETHER_MAX_LEN) 790 conf.rxmode.offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME; 791 else 792 conf.rxmode.offloads &= ~DEV_RX_OFFLOAD_JUMBO_FRAME; 793 794 /* mtu + length of header + length of FCS = max pkt length */ 795 conf.rxmode.max_rx_pkt_len = new_mtu + KNI_ENET_HEADER_SIZE + 796 KNI_ENET_FCS_SIZE; 797 ret = rte_eth_dev_configure(port_id, 1, 1, &conf); 798 if (ret < 0) { 799 RTE_LOG(ERR, APP, "Fail to reconfigure port %d\n", port_id); 800 return ret; 801 } 802 803 ret = rte_eth_dev_adjust_nb_rx_tx_desc(port_id, &nb_rxd, NULL); 804 if (ret < 0) 805 rte_exit(EXIT_FAILURE, "Could not adjust number of descriptors " 806 "for port%u (%d)\n", (unsigned int)port_id, 807 ret); 808 809 ret = rte_eth_dev_info_get(port_id, &dev_info); 810 if (ret != 0) { 811 RTE_LOG(ERR, APP, 812 "Error during getting device (port %u) info: %s\n", 813 port_id, strerror(-ret)); 814 815 return ret; 816 } 817 818 rxq_conf = dev_info.default_rxconf; 819 rxq_conf.offloads = conf.rxmode.offloads; 820 ret = rte_eth_rx_queue_setup(port_id, 0, nb_rxd, 821 rte_eth_dev_socket_id(port_id), &rxq_conf, pktmbuf_pool); 822 if (ret < 0) { 823 RTE_LOG(ERR, APP, "Fail to setup Rx queue of port %d\n", 824 port_id); 825 return ret; 826 } 827 828 /* Restart specific port */ 829 ret = rte_eth_dev_start(port_id); 830 if (ret < 0) { 831 RTE_LOG(ERR, APP, "Fail to restart port %d\n", port_id); 832 return ret; 833 } 834 835 return 0; 836 } 837 838 /* Callback for request of configuring network interface up/down */ 839 static int 840 kni_config_network_interface(uint16_t port_id, uint8_t if_up) 841 { 842 int ret = 0; 843 844 if (!rte_eth_dev_is_valid_port(port_id)) { 845 RTE_LOG(ERR, APP, "Invalid port id %d\n", port_id); 846 return -EINVAL; 847 } 848 849 RTE_LOG(INFO, APP, "Configure network interface of %d %s\n", 850 port_id, if_up ? "up" : "down"); 851 852 rte_atomic32_inc(&kni_pause); 853 854 if (if_up != 0) { /* Configure network interface up */ 855 rte_eth_dev_stop(port_id); 856 ret = rte_eth_dev_start(port_id); 857 } else /* Configure network interface down */ 858 rte_eth_dev_stop(port_id); 859 860 rte_atomic32_dec(&kni_pause); 861 862 if (ret < 0) 863 RTE_LOG(ERR, APP, "Failed to start port %d\n", port_id); 864 865 return ret; 866 } 867 868 static void 869 print_ethaddr(const char *name, struct rte_ether_addr *mac_addr) 870 { 871 char buf[RTE_ETHER_ADDR_FMT_SIZE]; 872 rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, mac_addr); 873 RTE_LOG(INFO, APP, "\t%s%s\n", name, buf); 874 } 875 876 /* Callback for request of configuring mac address */ 877 static int 878 kni_config_mac_address(uint16_t port_id, uint8_t mac_addr[]) 879 { 880 int ret = 0; 881 882 if (!rte_eth_dev_is_valid_port(port_id)) { 883 RTE_LOG(ERR, APP, "Invalid port id %d\n", port_id); 884 return -EINVAL; 885 } 886 887 RTE_LOG(INFO, APP, "Configure mac address of %d\n", port_id); 888 print_ethaddr("Address:", (struct rte_ether_addr *)mac_addr); 889 890 ret = rte_eth_dev_default_mac_addr_set(port_id, 891 (struct rte_ether_addr *)mac_addr); 892 if (ret < 0) 893 RTE_LOG(ERR, APP, "Failed to config mac_addr for port %d\n", 894 port_id); 895 896 return ret; 897 } 898 899 static int 900 kni_alloc(uint16_t port_id) 901 { 902 uint8_t i; 903 struct rte_kni *kni; 904 struct rte_kni_conf conf; 905 struct kni_port_params **params = kni_port_params_array; 906 int ret; 907 908 if (port_id >= RTE_MAX_ETHPORTS || !params[port_id]) 909 return -1; 910 911 params[port_id]->nb_kni = params[port_id]->nb_lcore_k ? 912 params[port_id]->nb_lcore_k : 1; 913 914 for (i = 0; i < params[port_id]->nb_kni; i++) { 915 /* Clear conf at first */ 916 memset(&conf, 0, sizeof(conf)); 917 if (params[port_id]->nb_lcore_k) { 918 snprintf(conf.name, RTE_KNI_NAMESIZE, 919 "vEth%u_%u", port_id, i); 920 conf.core_id = params[port_id]->lcore_k[i]; 921 conf.force_bind = 1; 922 } else 923 snprintf(conf.name, RTE_KNI_NAMESIZE, 924 "vEth%u", port_id); 925 conf.group_id = port_id; 926 conf.mbuf_size = MAX_PACKET_SZ; 927 /* 928 * The first KNI device associated to a port 929 * is the master, for multiple kernel thread 930 * environment. 931 */ 932 if (i == 0) { 933 struct rte_kni_ops ops; 934 struct rte_eth_dev_info dev_info; 935 936 ret = rte_eth_dev_info_get(port_id, &dev_info); 937 if (ret != 0) 938 rte_exit(EXIT_FAILURE, 939 "Error during getting device (port %u) info: %s\n", 940 port_id, strerror(-ret)); 941 942 /* Get the interface default mac address */ 943 ret = rte_eth_macaddr_get(port_id, 944 (struct rte_ether_addr *)&conf.mac_addr); 945 if (ret != 0) 946 rte_exit(EXIT_FAILURE, 947 "Failed to get MAC address (port %u): %s\n", 948 port_id, rte_strerror(-ret)); 949 950 rte_eth_dev_get_mtu(port_id, &conf.mtu); 951 952 memset(&ops, 0, sizeof(ops)); 953 ops.port_id = port_id; 954 ops.change_mtu = kni_change_mtu; 955 ops.config_network_if = kni_config_network_interface; 956 ops.config_mac_address = kni_config_mac_address; 957 958 kni = rte_kni_alloc(pktmbuf_pool, &conf, &ops); 959 } else 960 kni = rte_kni_alloc(pktmbuf_pool, &conf, NULL); 961 962 if (!kni) 963 rte_exit(EXIT_FAILURE, "Fail to create kni for " 964 "port: %d\n", port_id); 965 params[port_id]->kni[i] = kni; 966 } 967 968 return 0; 969 } 970 971 static int 972 kni_free_kni(uint16_t port_id) 973 { 974 uint8_t i; 975 struct kni_port_params **p = kni_port_params_array; 976 977 if (port_id >= RTE_MAX_ETHPORTS || !p[port_id]) 978 return -1; 979 980 for (i = 0; i < p[port_id]->nb_kni; i++) { 981 if (rte_kni_release(p[port_id]->kni[i])) 982 printf("Fail to release kni\n"); 983 p[port_id]->kni[i] = NULL; 984 } 985 rte_eth_dev_stop(port_id); 986 987 return 0; 988 } 989 990 /* Initialise ports/queues etc. and start main loop on each core */ 991 int 992 main(int argc, char** argv) 993 { 994 int ret; 995 uint16_t nb_sys_ports, port; 996 unsigned i; 997 void *retval; 998 pthread_t kni_link_tid; 999 int pid; 1000 1001 /* Associate signal_hanlder function with USR signals */ 1002 signal(SIGUSR1, signal_handler); 1003 signal(SIGUSR2, signal_handler); 1004 signal(SIGRTMIN, signal_handler); 1005 signal(SIGINT, signal_handler); 1006 1007 /* Initialise EAL */ 1008 ret = rte_eal_init(argc, argv); 1009 if (ret < 0) 1010 rte_exit(EXIT_FAILURE, "Could not initialise EAL (%d)\n", ret); 1011 argc -= ret; 1012 argv += ret; 1013 1014 /* Parse application arguments (after the EAL ones) */ 1015 ret = parse_args(argc, argv); 1016 if (ret < 0) 1017 rte_exit(EXIT_FAILURE, "Could not parse input parameters\n"); 1018 1019 /* Create the mbuf pool */ 1020 pktmbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", NB_MBUF, 1021 MEMPOOL_CACHE_SZ, 0, MBUF_DATA_SZ, rte_socket_id()); 1022 if (pktmbuf_pool == NULL) { 1023 rte_exit(EXIT_FAILURE, "Could not initialise mbuf pool\n"); 1024 return -1; 1025 } 1026 1027 /* Get number of ports found in scan */ 1028 nb_sys_ports = rte_eth_dev_count_avail(); 1029 if (nb_sys_ports == 0) 1030 rte_exit(EXIT_FAILURE, "No supported Ethernet device found\n"); 1031 1032 /* Check if the configured port ID is valid */ 1033 for (i = 0; i < RTE_MAX_ETHPORTS; i++) 1034 if (kni_port_params_array[i] && !rte_eth_dev_is_valid_port(i)) 1035 rte_exit(EXIT_FAILURE, "Configured invalid " 1036 "port ID %u\n", i); 1037 1038 /* Initialize KNI subsystem */ 1039 init_kni(); 1040 1041 /* Initialise each port */ 1042 RTE_ETH_FOREACH_DEV(port) { 1043 /* Skip ports that are not enabled */ 1044 if (!(ports_mask & (1 << port))) 1045 continue; 1046 init_port(port); 1047 1048 if (port >= RTE_MAX_ETHPORTS) 1049 rte_exit(EXIT_FAILURE, "Can not use more than " 1050 "%d ports for kni\n", RTE_MAX_ETHPORTS); 1051 1052 kni_alloc(port); 1053 } 1054 check_all_ports_link_status(ports_mask); 1055 1056 pid = getpid(); 1057 RTE_LOG(INFO, APP, "========================\n"); 1058 RTE_LOG(INFO, APP, "KNI Running\n"); 1059 RTE_LOG(INFO, APP, "kill -SIGUSR1 %d\n", pid); 1060 RTE_LOG(INFO, APP, " Show KNI Statistics.\n"); 1061 RTE_LOG(INFO, APP, "kill -SIGUSR2 %d\n", pid); 1062 RTE_LOG(INFO, APP, " Zero KNI Statistics.\n"); 1063 RTE_LOG(INFO, APP, "========================\n"); 1064 fflush(stdout); 1065 1066 ret = rte_ctrl_thread_create(&kni_link_tid, 1067 "KNI link status check", NULL, 1068 monitor_all_ports_link_status, NULL); 1069 if (ret < 0) 1070 rte_exit(EXIT_FAILURE, 1071 "Could not create link status thread!\n"); 1072 1073 /* Launch per-lcore function on every lcore */ 1074 rte_eal_mp_remote_launch(main_loop, NULL, CALL_MASTER); 1075 RTE_LCORE_FOREACH_SLAVE(i) { 1076 if (rte_eal_wait_lcore(i) < 0) 1077 return -1; 1078 } 1079 monitor_links = 0; 1080 pthread_join(kni_link_tid, &retval); 1081 1082 /* Release resources */ 1083 RTE_ETH_FOREACH_DEV(port) { 1084 if (!(ports_mask & (1 << port))) 1085 continue; 1086 kni_free_kni(port); 1087 } 1088 for (i = 0; i < RTE_MAX_ETHPORTS; i++) 1089 if (kni_port_params_array[i]) { 1090 rte_free(kni_port_params_array[i]); 1091 kni_port_params_array[i] = NULL; 1092 } 1093 1094 return 0; 1095 } 1096