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