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 .rxmode = { 98 .ignore_offload_bitfield = 1, 99 .offloads = DEV_RX_OFFLOAD_CRC_STRIP, 100 }, 101 .txmode = { 102 .mq_mode = ETH_MQ_TX_NONE, 103 }, 104 }; 105 106 /* Mempool for mbufs */ 107 static struct rte_mempool * pktmbuf_pool = NULL; 108 109 /* Mask of enabled ports */ 110 static uint32_t ports_mask = 0; 111 /* Ports set in promiscuous mode off by default. */ 112 static int promiscuous_on = 0; 113 114 /* Structure type for recording kni interface specific stats */ 115 struct kni_interface_stats { 116 /* number of pkts received from NIC, and sent to KNI */ 117 uint64_t rx_packets; 118 119 /* number of pkts received from NIC, but failed to send to KNI */ 120 uint64_t rx_dropped; 121 122 /* number of pkts received from KNI, and sent to NIC */ 123 uint64_t tx_packets; 124 125 /* number of pkts received from KNI, but failed to send to NIC */ 126 uint64_t tx_dropped; 127 }; 128 129 /* kni device statistics array */ 130 static struct kni_interface_stats kni_stats[RTE_MAX_ETHPORTS]; 131 132 static int kni_change_mtu(uint16_t port_id, unsigned int new_mtu); 133 static int kni_config_network_interface(uint16_t port_id, uint8_t if_up); 134 static int kni_config_mac_address(uint16_t port_id, uint8_t mac_addr[]); 135 136 static rte_atomic32_t kni_stop = RTE_ATOMIC32_INIT(0); 137 138 /* Print out statistics on packets handled */ 139 static void 140 print_stats(void) 141 { 142 uint16_t i; 143 144 printf("\n**KNI example application statistics**\n" 145 "====== ============== ============ ============ ============ ============\n" 146 " Port Lcore(RX/TX) rx_packets rx_dropped tx_packets tx_dropped\n" 147 "------ -------------- ------------ ------------ ------------ ------------\n"); 148 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 149 if (!kni_port_params_array[i]) 150 continue; 151 152 printf("%7d %10u/%2u %13"PRIu64" %13"PRIu64" %13"PRIu64" " 153 "%13"PRIu64"\n", i, 154 kni_port_params_array[i]->lcore_rx, 155 kni_port_params_array[i]->lcore_tx, 156 kni_stats[i].rx_packets, 157 kni_stats[i].rx_dropped, 158 kni_stats[i].tx_packets, 159 kni_stats[i].tx_dropped); 160 } 161 printf("====== ============== ============ ============ ============ ============\n"); 162 } 163 164 /* Custom handling of signals to handle stats and kni processing */ 165 static void 166 signal_handler(int signum) 167 { 168 /* When we receive a USR1 signal, print stats */ 169 if (signum == SIGUSR1) { 170 print_stats(); 171 } 172 173 /* When we receive a USR2 signal, reset stats */ 174 if (signum == SIGUSR2) { 175 memset(&kni_stats, 0, sizeof(kni_stats)); 176 printf("\n**Statistics have been reset**\n"); 177 return; 178 } 179 180 /* When we receive a RTMIN or SIGINT signal, stop kni processing */ 181 if (signum == SIGRTMIN || signum == SIGINT){ 182 printf("SIGRTMIN is received, and the KNI processing is " 183 "going to stop\n"); 184 rte_atomic32_inc(&kni_stop); 185 return; 186 } 187 } 188 189 static void 190 kni_burst_free_mbufs(struct rte_mbuf **pkts, unsigned num) 191 { 192 unsigned i; 193 194 if (pkts == NULL) 195 return; 196 197 for (i = 0; i < num; i++) { 198 rte_pktmbuf_free(pkts[i]); 199 pkts[i] = NULL; 200 } 201 } 202 203 /** 204 * Interface to burst rx and enqueue mbufs into rx_q 205 */ 206 static void 207 kni_ingress(struct kni_port_params *p) 208 { 209 uint8_t i; 210 uint16_t port_id; 211 unsigned nb_rx, num; 212 uint32_t nb_kni; 213 struct rte_mbuf *pkts_burst[PKT_BURST_SZ]; 214 215 if (p == NULL) 216 return; 217 218 nb_kni = p->nb_kni; 219 port_id = p->port_id; 220 for (i = 0; i < nb_kni; i++) { 221 /* Burst rx from eth */ 222 nb_rx = rte_eth_rx_burst(port_id, 0, pkts_burst, PKT_BURST_SZ); 223 if (unlikely(nb_rx > PKT_BURST_SZ)) { 224 RTE_LOG(ERR, APP, "Error receiving from eth\n"); 225 return; 226 } 227 /* Burst tx to kni */ 228 num = rte_kni_tx_burst(p->kni[i], pkts_burst, nb_rx); 229 kni_stats[port_id].rx_packets += num; 230 231 rte_kni_handle_request(p->kni[i]); 232 if (unlikely(num < nb_rx)) { 233 /* Free mbufs not tx to kni interface */ 234 kni_burst_free_mbufs(&pkts_burst[num], nb_rx - num); 235 kni_stats[port_id].rx_dropped += nb_rx - num; 236 } 237 } 238 } 239 240 /** 241 * Interface to dequeue mbufs from tx_q and burst tx 242 */ 243 static void 244 kni_egress(struct kni_port_params *p) 245 { 246 uint8_t i; 247 uint16_t port_id; 248 unsigned nb_tx, num; 249 uint32_t nb_kni; 250 struct rte_mbuf *pkts_burst[PKT_BURST_SZ]; 251 252 if (p == NULL) 253 return; 254 255 nb_kni = p->nb_kni; 256 port_id = p->port_id; 257 for (i = 0; i < nb_kni; i++) { 258 /* Burst rx from kni */ 259 num = rte_kni_rx_burst(p->kni[i], pkts_burst, PKT_BURST_SZ); 260 if (unlikely(num > PKT_BURST_SZ)) { 261 RTE_LOG(ERR, APP, "Error receiving from KNI\n"); 262 return; 263 } 264 /* Burst tx to eth */ 265 nb_tx = rte_eth_tx_burst(port_id, 0, pkts_burst, (uint16_t)num); 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 uint8_t i, nb_ports = rte_eth_dev_count(); 279 int32_t f_stop; 280 const unsigned lcore_id = rte_lcore_id(); 281 enum lcore_rxtx { 282 LCORE_NONE, 283 LCORE_RX, 284 LCORE_TX, 285 LCORE_MAX 286 }; 287 enum lcore_rxtx flag = LCORE_NONE; 288 289 for (i = 0; i < nb_ports; i++) { 290 if (!kni_port_params_array[i]) 291 continue; 292 if (kni_port_params_array[i]->lcore_rx == (uint8_t)lcore_id) { 293 flag = LCORE_RX; 294 break; 295 } else if (kni_port_params_array[i]->lcore_tx == 296 (uint8_t)lcore_id) { 297 flag = LCORE_TX; 298 break; 299 } 300 } 301 302 if (flag == LCORE_RX) { 303 RTE_LOG(INFO, APP, "Lcore %u is reading from port %d\n", 304 kni_port_params_array[i]->lcore_rx, 305 kni_port_params_array[i]->port_id); 306 while (1) { 307 f_stop = rte_atomic32_read(&kni_stop); 308 if (f_stop) 309 break; 310 kni_ingress(kni_port_params_array[i]); 311 } 312 } else if (flag == LCORE_TX) { 313 RTE_LOG(INFO, APP, "Lcore %u is writing to port %d\n", 314 kni_port_params_array[i]->lcore_tx, 315 kni_port_params_array[i]->port_id); 316 while (1) { 317 f_stop = rte_atomic32_read(&kni_stop); 318 if (f_stop) 319 break; 320 kni_egress(kni_port_params_array[i]); 321 } 322 } else 323 RTE_LOG(INFO, APP, "Lcore %u has nothing to do\n", lcore_id); 324 325 return 0; 326 } 327 328 /* Display usage instructions */ 329 static void 330 print_usage(const char *prgname) 331 { 332 RTE_LOG(INFO, APP, "\nUsage: %s [EAL options] -- -p PORTMASK -P " 333 "[--config (port,lcore_rx,lcore_tx,lcore_kthread...)" 334 "[,(port,lcore_rx,lcore_tx,lcore_kthread...)]]\n" 335 " -p PORTMASK: hex bitmask of ports to use\n" 336 " -P : enable promiscuous mode\n" 337 " --config (port,lcore_rx,lcore_tx,lcore_kthread...): " 338 "port and lcore configurations\n", 339 prgname); 340 } 341 342 /* Convert string to unsigned number. 0 is returned if error occurs */ 343 static uint32_t 344 parse_unsigned(const char *portmask) 345 { 346 char *end = NULL; 347 unsigned long num; 348 349 num = strtoul(portmask, &end, 16); 350 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0')) 351 return 0; 352 353 return (uint32_t)num; 354 } 355 356 static void 357 print_config(void) 358 { 359 uint32_t i, j; 360 struct kni_port_params **p = kni_port_params_array; 361 362 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 363 if (!p[i]) 364 continue; 365 RTE_LOG(DEBUG, APP, "Port ID: %d\n", p[i]->port_id); 366 RTE_LOG(DEBUG, APP, "Rx lcore ID: %u, Tx lcore ID: %u\n", 367 p[i]->lcore_rx, p[i]->lcore_tx); 368 for (j = 0; j < p[i]->nb_lcore_k; j++) 369 RTE_LOG(DEBUG, APP, "Kernel thread lcore ID: %u\n", 370 p[i]->lcore_k[j]); 371 } 372 } 373 374 static int 375 parse_config(const char *arg) 376 { 377 const char *p, *p0 = arg; 378 char s[256], *end; 379 unsigned size; 380 enum fieldnames { 381 FLD_PORT = 0, 382 FLD_LCORE_RX, 383 FLD_LCORE_TX, 384 _NUM_FLD = KNI_MAX_KTHREAD + 3, 385 }; 386 int i, j, nb_token; 387 char *str_fld[_NUM_FLD]; 388 unsigned long int_fld[_NUM_FLD]; 389 uint16_t port_id, nb_kni_port_params = 0; 390 391 memset(&kni_port_params_array, 0, sizeof(kni_port_params_array)); 392 while (((p = strchr(p0, '(')) != NULL) && 393 nb_kni_port_params < RTE_MAX_ETHPORTS) { 394 p++; 395 if ((p0 = strchr(p, ')')) == NULL) 396 goto fail; 397 size = p0 - p; 398 if (size >= sizeof(s)) { 399 printf("Invalid config parameters\n"); 400 goto fail; 401 } 402 snprintf(s, sizeof(s), "%.*s", size, p); 403 nb_token = rte_strsplit(s, sizeof(s), str_fld, _NUM_FLD, ','); 404 if (nb_token <= FLD_LCORE_TX) { 405 printf("Invalid config parameters\n"); 406 goto fail; 407 } 408 for (i = 0; i < nb_token; i++) { 409 errno = 0; 410 int_fld[i] = strtoul(str_fld[i], &end, 0); 411 if (errno != 0 || end == str_fld[i]) { 412 printf("Invalid config parameters\n"); 413 goto fail; 414 } 415 } 416 417 i = 0; 418 port_id = int_fld[i++]; 419 if (port_id >= RTE_MAX_ETHPORTS) { 420 printf("Port ID %d could not exceed the maximum %d\n", 421 port_id, RTE_MAX_ETHPORTS); 422 goto fail; 423 } 424 if (kni_port_params_array[port_id]) { 425 printf("Port %d has been configured\n", port_id); 426 goto fail; 427 } 428 kni_port_params_array[port_id] = 429 rte_zmalloc("KNI_port_params", 430 sizeof(struct kni_port_params), RTE_CACHE_LINE_SIZE); 431 kni_port_params_array[port_id]->port_id = port_id; 432 kni_port_params_array[port_id]->lcore_rx = 433 (uint8_t)int_fld[i++]; 434 kni_port_params_array[port_id]->lcore_tx = 435 (uint8_t)int_fld[i++]; 436 if (kni_port_params_array[port_id]->lcore_rx >= RTE_MAX_LCORE || 437 kni_port_params_array[port_id]->lcore_tx >= RTE_MAX_LCORE) { 438 printf("lcore_rx %u or lcore_tx %u ID could not " 439 "exceed the maximum %u\n", 440 kni_port_params_array[port_id]->lcore_rx, 441 kni_port_params_array[port_id]->lcore_tx, 442 (unsigned)RTE_MAX_LCORE); 443 goto fail; 444 } 445 for (j = 0; i < nb_token && j < KNI_MAX_KTHREAD; i++, j++) 446 kni_port_params_array[port_id]->lcore_k[j] = 447 (uint8_t)int_fld[i]; 448 kni_port_params_array[port_id]->nb_lcore_k = j; 449 } 450 print_config(); 451 452 return 0; 453 454 fail: 455 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 456 if (kni_port_params_array[i]) { 457 rte_free(kni_port_params_array[i]); 458 kni_port_params_array[i] = NULL; 459 } 460 } 461 462 return -1; 463 } 464 465 static int 466 validate_parameters(uint32_t portmask) 467 { 468 uint32_t i; 469 470 if (!portmask) { 471 printf("No port configured in port mask\n"); 472 return -1; 473 } 474 475 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 476 if (((portmask & (1 << i)) && !kni_port_params_array[i]) || 477 (!(portmask & (1 << i)) && kni_port_params_array[i])) 478 rte_exit(EXIT_FAILURE, "portmask is not consistent " 479 "to port ids specified in --config\n"); 480 481 if (kni_port_params_array[i] && !rte_lcore_is_enabled(\ 482 (unsigned)(kni_port_params_array[i]->lcore_rx))) 483 rte_exit(EXIT_FAILURE, "lcore id %u for " 484 "port %d receiving not enabled\n", 485 kni_port_params_array[i]->lcore_rx, 486 kni_port_params_array[i]->port_id); 487 488 if (kni_port_params_array[i] && !rte_lcore_is_enabled(\ 489 (unsigned)(kni_port_params_array[i]->lcore_tx))) 490 rte_exit(EXIT_FAILURE, "lcore id %u for " 491 "port %d transmitting not enabled\n", 492 kni_port_params_array[i]->lcore_tx, 493 kni_port_params_array[i]->port_id); 494 495 } 496 497 return 0; 498 } 499 500 #define CMDLINE_OPT_CONFIG "config" 501 502 /* Parse the arguments given in the command line of the application */ 503 static int 504 parse_args(int argc, char **argv) 505 { 506 int opt, longindex, ret = 0; 507 const char *prgname = argv[0]; 508 static struct option longopts[] = { 509 {CMDLINE_OPT_CONFIG, required_argument, NULL, 0}, 510 {NULL, 0, NULL, 0} 511 }; 512 513 /* Disable printing messages within getopt() */ 514 opterr = 0; 515 516 /* Parse command line */ 517 while ((opt = getopt_long(argc, argv, "p:P", longopts, 518 &longindex)) != EOF) { 519 switch (opt) { 520 case 'p': 521 ports_mask = parse_unsigned(optarg); 522 break; 523 case 'P': 524 promiscuous_on = 1; 525 break; 526 case 0: 527 if (!strncmp(longopts[longindex].name, 528 CMDLINE_OPT_CONFIG, 529 sizeof(CMDLINE_OPT_CONFIG))) { 530 ret = parse_config(optarg); 531 if (ret) { 532 printf("Invalid config\n"); 533 print_usage(prgname); 534 return -1; 535 } 536 } 537 break; 538 default: 539 print_usage(prgname); 540 rte_exit(EXIT_FAILURE, "Invalid option specified\n"); 541 } 542 } 543 544 /* Check that options were parsed ok */ 545 if (validate_parameters(ports_mask) < 0) { 546 print_usage(prgname); 547 rte_exit(EXIT_FAILURE, "Invalid parameters\n"); 548 } 549 550 return ret; 551 } 552 553 /* Initialize KNI subsystem */ 554 static void 555 init_kni(void) 556 { 557 unsigned int num_of_kni_ports = 0, i; 558 struct kni_port_params **params = kni_port_params_array; 559 560 /* Calculate the maximum number of KNI interfaces that will be used */ 561 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 562 if (kni_port_params_array[i]) { 563 num_of_kni_ports += (params[i]->nb_lcore_k ? 564 params[i]->nb_lcore_k : 1); 565 } 566 } 567 568 /* Invoke rte KNI init to preallocate the ports */ 569 rte_kni_init(num_of_kni_ports); 570 } 571 572 /* Initialise a single port on an Ethernet device */ 573 static void 574 init_port(uint16_t port) 575 { 576 int ret; 577 uint16_t nb_rxd = NB_RXD; 578 uint16_t nb_txd = NB_TXD; 579 struct rte_eth_dev_info dev_info; 580 struct rte_eth_rxconf rxq_conf; 581 struct rte_eth_txconf txq_conf; 582 struct rte_eth_conf local_port_conf = port_conf; 583 584 /* Initialise device and RX/TX queues */ 585 RTE_LOG(INFO, APP, "Initialising port %u ...\n", (unsigned)port); 586 fflush(stdout); 587 rte_eth_dev_info_get(port, &dev_info); 588 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE) 589 local_port_conf.txmode.offloads |= 590 DEV_TX_OFFLOAD_MBUF_FAST_FREE; 591 ret = rte_eth_dev_configure(port, 1, 1, &local_port_conf); 592 if (ret < 0) 593 rte_exit(EXIT_FAILURE, "Could not configure port%u (%d)\n", 594 (unsigned)port, ret); 595 596 ret = rte_eth_dev_adjust_nb_rx_tx_desc(port, &nb_rxd, &nb_txd); 597 if (ret < 0) 598 rte_exit(EXIT_FAILURE, "Could not adjust number of descriptors " 599 "for port%u (%d)\n", (unsigned)port, ret); 600 601 rxq_conf = dev_info.default_rxconf; 602 rxq_conf.offloads = local_port_conf.rxmode.offloads; 603 ret = rte_eth_rx_queue_setup(port, 0, nb_rxd, 604 rte_eth_dev_socket_id(port), &rxq_conf, pktmbuf_pool); 605 if (ret < 0) 606 rte_exit(EXIT_FAILURE, "Could not setup up RX queue for " 607 "port%u (%d)\n", (unsigned)port, ret); 608 609 txq_conf = dev_info.default_txconf; 610 txq_conf.txq_flags = ETH_TXQ_FLAGS_IGNORE; 611 txq_conf.offloads = local_port_conf.txmode.offloads; 612 ret = rte_eth_tx_queue_setup(port, 0, nb_txd, 613 rte_eth_dev_socket_id(port), &txq_conf); 614 if (ret < 0) 615 rte_exit(EXIT_FAILURE, "Could not setup up TX queue for " 616 "port%u (%d)\n", (unsigned)port, ret); 617 618 ret = rte_eth_dev_start(port); 619 if (ret < 0) 620 rte_exit(EXIT_FAILURE, "Could not start port%u (%d)\n", 621 (unsigned)port, ret); 622 623 if (promiscuous_on) 624 rte_eth_promiscuous_enable(port); 625 } 626 627 /* Check the link status of all ports in up to 9s, and print them finally */ 628 static void 629 check_all_ports_link_status(uint16_t port_num, uint32_t port_mask) 630 { 631 #define CHECK_INTERVAL 100 /* 100ms */ 632 #define MAX_CHECK_TIME 90 /* 9s (90 * 100ms) in total */ 633 uint16_t portid; 634 uint8_t count, all_ports_up, print_flag = 0; 635 struct rte_eth_link link; 636 637 printf("\nChecking link status\n"); 638 fflush(stdout); 639 for (count = 0; count <= MAX_CHECK_TIME; count++) { 640 all_ports_up = 1; 641 for (portid = 0; portid < port_num; portid++) { 642 if ((port_mask & (1 << portid)) == 0) 643 continue; 644 memset(&link, 0, sizeof(link)); 645 rte_eth_link_get_nowait(portid, &link); 646 /* print link status if flag set */ 647 if (print_flag == 1) { 648 if (link.link_status) 649 printf( 650 "Port%d Link Up - speed %uMbps - %s\n", 651 portid, link.link_speed, 652 (link.link_duplex == ETH_LINK_FULL_DUPLEX) ? 653 ("full-duplex") : ("half-duplex\n")); 654 else 655 printf("Port %d Link Down\n", portid); 656 continue; 657 } 658 /* clear all_ports_up flag if any link down */ 659 if (link.link_status == ETH_LINK_DOWN) { 660 all_ports_up = 0; 661 break; 662 } 663 } 664 /* after finally printing all link status, get out */ 665 if (print_flag == 1) 666 break; 667 668 if (all_ports_up == 0) { 669 printf("."); 670 fflush(stdout); 671 rte_delay_ms(CHECK_INTERVAL); 672 } 673 674 /* set the print_flag if all ports up or timeout */ 675 if (all_ports_up == 1 || count == (MAX_CHECK_TIME - 1)) { 676 print_flag = 1; 677 printf("done\n"); 678 } 679 } 680 } 681 682 /* Callback for request of changing MTU */ 683 static int 684 kni_change_mtu(uint16_t port_id, unsigned int new_mtu) 685 { 686 int ret; 687 uint16_t nb_rxd = NB_RXD; 688 struct rte_eth_conf conf; 689 struct rte_eth_dev_info dev_info; 690 struct rte_eth_rxconf rxq_conf; 691 692 if (port_id >= rte_eth_dev_count()) { 693 RTE_LOG(ERR, APP, "Invalid port id %d\n", port_id); 694 return -EINVAL; 695 } 696 697 RTE_LOG(INFO, APP, "Change MTU of port %d to %u\n", port_id, new_mtu); 698 699 /* Stop specific port */ 700 rte_eth_dev_stop(port_id); 701 702 memcpy(&conf, &port_conf, sizeof(conf)); 703 /* Set new MTU */ 704 if (new_mtu > ETHER_MAX_LEN) 705 conf.rxmode.offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME; 706 else 707 conf.rxmode.offloads &= ~DEV_RX_OFFLOAD_JUMBO_FRAME; 708 709 /* mtu + length of header + length of FCS = max pkt length */ 710 conf.rxmode.max_rx_pkt_len = new_mtu + KNI_ENET_HEADER_SIZE + 711 KNI_ENET_FCS_SIZE; 712 ret = rte_eth_dev_configure(port_id, 1, 1, &conf); 713 if (ret < 0) { 714 RTE_LOG(ERR, APP, "Fail to reconfigure port %d\n", port_id); 715 return ret; 716 } 717 718 ret = rte_eth_dev_adjust_nb_rx_tx_desc(port_id, &nb_rxd, NULL); 719 if (ret < 0) 720 rte_exit(EXIT_FAILURE, "Could not adjust number of descriptors " 721 "for port%u (%d)\n", (unsigned int)port_id, 722 ret); 723 724 rte_eth_dev_info_get(port_id, &dev_info); 725 rxq_conf = dev_info.default_rxconf; 726 rxq_conf.offloads = conf.rxmode.offloads; 727 ret = rte_eth_rx_queue_setup(port_id, 0, nb_rxd, 728 rte_eth_dev_socket_id(port_id), &rxq_conf, pktmbuf_pool); 729 if (ret < 0) { 730 RTE_LOG(ERR, APP, "Fail to setup Rx queue of port %d\n", 731 port_id); 732 return ret; 733 } 734 735 /* Restart specific port */ 736 ret = rte_eth_dev_start(port_id); 737 if (ret < 0) { 738 RTE_LOG(ERR, APP, "Fail to restart port %d\n", port_id); 739 return ret; 740 } 741 742 return 0; 743 } 744 745 /* Callback for request of configuring network interface up/down */ 746 static int 747 kni_config_network_interface(uint16_t port_id, uint8_t if_up) 748 { 749 int ret = 0; 750 751 if (port_id >= rte_eth_dev_count() || port_id >= RTE_MAX_ETHPORTS) { 752 RTE_LOG(ERR, APP, "Invalid port id %d\n", port_id); 753 return -EINVAL; 754 } 755 756 RTE_LOG(INFO, APP, "Configure network interface of %d %s\n", 757 port_id, if_up ? "up" : "down"); 758 759 if (if_up != 0) { /* Configure network interface up */ 760 rte_eth_dev_stop(port_id); 761 ret = rte_eth_dev_start(port_id); 762 } else /* Configure network interface down */ 763 rte_eth_dev_stop(port_id); 764 765 if (ret < 0) 766 RTE_LOG(ERR, APP, "Failed to start port %d\n", port_id); 767 768 return ret; 769 } 770 771 static void 772 print_ethaddr(const char *name, struct ether_addr *mac_addr) 773 { 774 char buf[ETHER_ADDR_FMT_SIZE]; 775 ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, mac_addr); 776 RTE_LOG(INFO, APP, "\t%s%s\n", name, buf); 777 } 778 779 /* Callback for request of configuring mac address */ 780 static int 781 kni_config_mac_address(uint16_t port_id, uint8_t mac_addr[]) 782 { 783 int ret = 0; 784 785 if (port_id >= rte_eth_dev_count() || port_id >= RTE_MAX_ETHPORTS) { 786 RTE_LOG(ERR, APP, "Invalid port id %d\n", port_id); 787 return -EINVAL; 788 } 789 790 RTE_LOG(INFO, APP, "Configure mac address of %d\n", port_id); 791 print_ethaddr("Address:", (struct ether_addr *)mac_addr); 792 793 ret = rte_eth_dev_default_mac_addr_set(port_id, 794 (struct ether_addr *)mac_addr); 795 if (ret < 0) 796 RTE_LOG(ERR, APP, "Failed to config mac_addr for port %d\n", 797 port_id); 798 799 return ret; 800 } 801 802 static int 803 kni_alloc(uint16_t port_id) 804 { 805 uint8_t i; 806 struct rte_kni *kni; 807 struct rte_kni_conf conf; 808 struct kni_port_params **params = kni_port_params_array; 809 810 if (port_id >= RTE_MAX_ETHPORTS || !params[port_id]) 811 return -1; 812 813 params[port_id]->nb_kni = params[port_id]->nb_lcore_k ? 814 params[port_id]->nb_lcore_k : 1; 815 816 for (i = 0; i < params[port_id]->nb_kni; i++) { 817 /* Clear conf at first */ 818 memset(&conf, 0, sizeof(conf)); 819 if (params[port_id]->nb_lcore_k) { 820 snprintf(conf.name, RTE_KNI_NAMESIZE, 821 "vEth%u_%u", port_id, i); 822 conf.core_id = params[port_id]->lcore_k[i]; 823 conf.force_bind = 1; 824 } else 825 snprintf(conf.name, RTE_KNI_NAMESIZE, 826 "vEth%u", port_id); 827 conf.group_id = port_id; 828 conf.mbuf_size = MAX_PACKET_SZ; 829 /* 830 * The first KNI device associated to a port 831 * is the master, for multiple kernel thread 832 * environment. 833 */ 834 if (i == 0) { 835 struct rte_kni_ops ops; 836 struct rte_eth_dev_info dev_info; 837 838 memset(&dev_info, 0, sizeof(dev_info)); 839 rte_eth_dev_info_get(port_id, &dev_info); 840 841 if (dev_info.pci_dev) { 842 conf.addr = dev_info.pci_dev->addr; 843 conf.id = dev_info.pci_dev->id; 844 } 845 /* Get the interface default mac address */ 846 rte_eth_macaddr_get(port_id, 847 (struct ether_addr *)&conf.mac_addr); 848 849 rte_eth_dev_get_mtu(port_id, &conf.mtu); 850 851 memset(&ops, 0, sizeof(ops)); 852 ops.port_id = port_id; 853 ops.change_mtu = kni_change_mtu; 854 ops.config_network_if = kni_config_network_interface; 855 ops.config_mac_address = kni_config_mac_address; 856 857 kni = rte_kni_alloc(pktmbuf_pool, &conf, &ops); 858 } else 859 kni = rte_kni_alloc(pktmbuf_pool, &conf, NULL); 860 861 if (!kni) 862 rte_exit(EXIT_FAILURE, "Fail to create kni for " 863 "port: %d\n", port_id); 864 params[port_id]->kni[i] = kni; 865 } 866 867 return 0; 868 } 869 870 static int 871 kni_free_kni(uint16_t port_id) 872 { 873 uint8_t i; 874 struct kni_port_params **p = kni_port_params_array; 875 876 if (port_id >= RTE_MAX_ETHPORTS || !p[port_id]) 877 return -1; 878 879 for (i = 0; i < p[port_id]->nb_kni; i++) { 880 if (rte_kni_release(p[port_id]->kni[i])) 881 printf("Fail to release kni\n"); 882 p[port_id]->kni[i] = NULL; 883 } 884 rte_eth_dev_stop(port_id); 885 886 return 0; 887 } 888 889 /* Initialise ports/queues etc. and start main loop on each core */ 890 int 891 main(int argc, char** argv) 892 { 893 int ret; 894 uint16_t nb_sys_ports, port; 895 unsigned i; 896 897 /* Associate signal_hanlder function with USR signals */ 898 signal(SIGUSR1, signal_handler); 899 signal(SIGUSR2, signal_handler); 900 signal(SIGRTMIN, signal_handler); 901 signal(SIGINT, signal_handler); 902 903 /* Initialise EAL */ 904 ret = rte_eal_init(argc, argv); 905 if (ret < 0) 906 rte_exit(EXIT_FAILURE, "Could not initialise EAL (%d)\n", ret); 907 argc -= ret; 908 argv += ret; 909 910 /* Parse application arguments (after the EAL ones) */ 911 ret = parse_args(argc, argv); 912 if (ret < 0) 913 rte_exit(EXIT_FAILURE, "Could not parse input parameters\n"); 914 915 /* Create the mbuf pool */ 916 pktmbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", NB_MBUF, 917 MEMPOOL_CACHE_SZ, 0, MBUF_DATA_SZ, rte_socket_id()); 918 if (pktmbuf_pool == NULL) { 919 rte_exit(EXIT_FAILURE, "Could not initialise mbuf pool\n"); 920 return -1; 921 } 922 923 /* Get number of ports found in scan */ 924 nb_sys_ports = rte_eth_dev_count(); 925 if (nb_sys_ports == 0) 926 rte_exit(EXIT_FAILURE, "No supported Ethernet device found\n"); 927 928 /* Check if the configured port ID is valid */ 929 for (i = 0; i < RTE_MAX_ETHPORTS; i++) 930 if (kni_port_params_array[i] && i >= nb_sys_ports) 931 rte_exit(EXIT_FAILURE, "Configured invalid " 932 "port ID %u\n", i); 933 934 /* Initialize KNI subsystem */ 935 init_kni(); 936 937 /* Initialise each port */ 938 for (port = 0; port < nb_sys_ports; port++) { 939 /* Skip ports that are not enabled */ 940 if (!(ports_mask & (1 << port))) 941 continue; 942 init_port(port); 943 944 if (port >= RTE_MAX_ETHPORTS) 945 rte_exit(EXIT_FAILURE, "Can not use more than " 946 "%d ports for kni\n", RTE_MAX_ETHPORTS); 947 948 kni_alloc(port); 949 } 950 check_all_ports_link_status(nb_sys_ports, ports_mask); 951 952 /* Launch per-lcore function on every lcore */ 953 rte_eal_mp_remote_launch(main_loop, NULL, CALL_MASTER); 954 RTE_LCORE_FOREACH_SLAVE(i) { 955 if (rte_eal_wait_lcore(i) < 0) 956 return -1; 957 } 958 959 /* Release resources */ 960 for (port = 0; port < nb_sys_ports; port++) { 961 if (!(ports_mask & (1 << port))) 962 continue; 963 kni_free_kni(port); 964 } 965 for (i = 0; i < RTE_MAX_ETHPORTS; i++) 966 if (kni_port_params_array[i]) { 967 rte_free(kni_port_params_array[i]); 968 kni_port_params_array[i] = NULL; 969 } 970 971 return 0; 972 } 973