1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <stdint.h> 37 #include <inttypes.h> 38 #include <string.h> 39 #include <sys/queue.h> 40 #include <stdarg.h> 41 #include <errno.h> 42 #include <getopt.h> 43 44 #include <netinet/in.h> 45 #include <linux/if.h> 46 #include <linux/if_tun.h> 47 #include <fcntl.h> 48 #include <sys/ioctl.h> 49 #include <unistd.h> 50 #include <signal.h> 51 52 #include <rte_common.h> 53 #include <rte_log.h> 54 #include <rte_memory.h> 55 #include <rte_memcpy.h> 56 #include <rte_memzone.h> 57 #include <rte_eal.h> 58 #include <rte_per_lcore.h> 59 #include <rte_launch.h> 60 #include <rte_atomic.h> 61 #include <rte_lcore.h> 62 #include <rte_branch_prediction.h> 63 #include <rte_interrupts.h> 64 #include <rte_pci.h> 65 #include <rte_debug.h> 66 #include <rte_ether.h> 67 #include <rte_ethdev.h> 68 #include <rte_log.h> 69 #include <rte_mempool.h> 70 #include <rte_mbuf.h> 71 #include <rte_string_fns.h> 72 #include <rte_cycles.h> 73 #include <rte_malloc.h> 74 #include <rte_kni.h> 75 76 /* Macros for printing using RTE_LOG */ 77 #define RTE_LOGTYPE_APP RTE_LOGTYPE_USER1 78 79 /* Max size of a single packet */ 80 #define MAX_PACKET_SZ 2048 81 82 /* Size of the data buffer in each mbuf */ 83 #define MBUF_DATA_SZ (MAX_PACKET_SZ + RTE_PKTMBUF_HEADROOM) 84 85 /* Number of mbufs in mempool that is created */ 86 #define NB_MBUF (8192 * 16) 87 88 /* How many packets to attempt to read from NIC in one go */ 89 #define PKT_BURST_SZ 32 90 91 /* How many objects (mbufs) to keep in per-lcore mempool cache */ 92 #define MEMPOOL_CACHE_SZ PKT_BURST_SZ 93 94 /* Number of RX ring descriptors */ 95 #define NB_RXD 128 96 97 /* Number of TX ring descriptors */ 98 #define NB_TXD 512 99 100 /* Total octets in ethernet header */ 101 #define KNI_ENET_HEADER_SIZE 14 102 103 /* Total octets in the FCS */ 104 #define KNI_ENET_FCS_SIZE 4 105 106 #define KNI_US_PER_SECOND 1000000 107 #define KNI_SECOND_PER_DAY 86400 108 109 #define KNI_MAX_KTHREAD 32 110 /* 111 * Structure of port parameters 112 */ 113 struct kni_port_params { 114 uint8_t port_id;/* Port ID */ 115 unsigned lcore_rx; /* lcore ID for RX */ 116 unsigned lcore_tx; /* lcore ID for TX */ 117 uint32_t nb_lcore_k; /* Number of lcores for KNI multi kernel threads */ 118 uint32_t nb_kni; /* Number of KNI devices to be created */ 119 unsigned lcore_k[KNI_MAX_KTHREAD]; /* lcore ID list for kthreads */ 120 struct rte_kni *kni[KNI_MAX_KTHREAD]; /* KNI context pointers */ 121 } __rte_cache_aligned; 122 123 static struct kni_port_params *kni_port_params_array[RTE_MAX_ETHPORTS]; 124 125 126 /* Options for configuring ethernet port */ 127 static struct rte_eth_conf port_conf = { 128 .rxmode = { 129 .header_split = 0, /* Header Split disabled */ 130 .hw_ip_checksum = 0, /* IP checksum offload disabled */ 131 .hw_vlan_filter = 0, /* VLAN filtering disabled */ 132 .jumbo_frame = 0, /* Jumbo Frame Support disabled */ 133 .hw_strip_crc = 0, /* CRC stripped by hardware */ 134 }, 135 .txmode = { 136 .mq_mode = ETH_MQ_TX_NONE, 137 }, 138 }; 139 140 /* Mempool for mbufs */ 141 static struct rte_mempool * pktmbuf_pool = NULL; 142 143 /* Mask of enabled ports */ 144 static uint32_t ports_mask = 0; 145 /* Ports set in promiscuous mode off by default. */ 146 static int promiscuous_on = 0; 147 148 /* Structure type for recording kni interface specific stats */ 149 struct kni_interface_stats { 150 /* number of pkts received from NIC, and sent to KNI */ 151 uint64_t rx_packets; 152 153 /* number of pkts received from NIC, but failed to send to KNI */ 154 uint64_t rx_dropped; 155 156 /* number of pkts received from KNI, and sent to NIC */ 157 uint64_t tx_packets; 158 159 /* number of pkts received from KNI, but failed to send to NIC */ 160 uint64_t tx_dropped; 161 }; 162 163 /* kni device statistics array */ 164 static struct kni_interface_stats kni_stats[RTE_MAX_ETHPORTS]; 165 166 static int kni_change_mtu(uint8_t port_id, unsigned new_mtu); 167 static int kni_config_network_interface(uint8_t port_id, uint8_t if_up); 168 169 static rte_atomic32_t kni_stop = RTE_ATOMIC32_INIT(0); 170 171 /* Print out statistics on packets handled */ 172 static void 173 print_stats(void) 174 { 175 uint8_t i; 176 177 printf("\n**KNI example application statistics**\n" 178 "====== ============== ============ ============ ============ ============\n" 179 " Port Lcore(RX/TX) rx_packets rx_dropped tx_packets tx_dropped\n" 180 "------ -------------- ------------ ------------ ------------ ------------\n"); 181 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 182 if (!kni_port_params_array[i]) 183 continue; 184 185 printf("%7d %10u/%2u %13"PRIu64" %13"PRIu64" %13"PRIu64" " 186 "%13"PRIu64"\n", i, 187 kni_port_params_array[i]->lcore_rx, 188 kni_port_params_array[i]->lcore_tx, 189 kni_stats[i].rx_packets, 190 kni_stats[i].rx_dropped, 191 kni_stats[i].tx_packets, 192 kni_stats[i].tx_dropped); 193 } 194 printf("====== ============== ============ ============ ============ ============\n"); 195 } 196 197 /* Custom handling of signals to handle stats and kni processing */ 198 static void 199 signal_handler(int signum) 200 { 201 /* When we receive a USR1 signal, print stats */ 202 if (signum == SIGUSR1) { 203 print_stats(); 204 } 205 206 /* When we receive a USR2 signal, reset stats */ 207 if (signum == SIGUSR2) { 208 memset(&kni_stats, 0, sizeof(kni_stats)); 209 printf("\n**Statistics have been reset**\n"); 210 return; 211 } 212 213 /* When we receive a RTMIN or SIGINT signal, stop kni processing */ 214 if (signum == SIGRTMIN || signum == SIGINT){ 215 printf("SIGRTMIN is received, and the KNI processing is " 216 "going to stop\n"); 217 rte_atomic32_inc(&kni_stop); 218 return; 219 } 220 } 221 222 static void 223 kni_burst_free_mbufs(struct rte_mbuf **pkts, unsigned num) 224 { 225 unsigned i; 226 227 if (pkts == NULL) 228 return; 229 230 for (i = 0; i < num; i++) { 231 rte_pktmbuf_free(pkts[i]); 232 pkts[i] = NULL; 233 } 234 } 235 236 /** 237 * Interface to burst rx and enqueue mbufs into rx_q 238 */ 239 static void 240 kni_ingress(struct kni_port_params *p) 241 { 242 uint8_t i, port_id; 243 unsigned nb_rx, num; 244 uint32_t nb_kni; 245 struct rte_mbuf *pkts_burst[PKT_BURST_SZ]; 246 247 if (p == NULL) 248 return; 249 250 nb_kni = p->nb_kni; 251 port_id = p->port_id; 252 for (i = 0; i < nb_kni; i++) { 253 /* Burst rx from eth */ 254 nb_rx = rte_eth_rx_burst(port_id, 0, pkts_burst, PKT_BURST_SZ); 255 if (unlikely(nb_rx > PKT_BURST_SZ)) { 256 RTE_LOG(ERR, APP, "Error receiving from eth\n"); 257 return; 258 } 259 /* Burst tx to kni */ 260 num = rte_kni_tx_burst(p->kni[i], pkts_burst, nb_rx); 261 kni_stats[port_id].rx_packets += num; 262 263 rte_kni_handle_request(p->kni[i]); 264 if (unlikely(num < nb_rx)) { 265 /* Free mbufs not tx to kni interface */ 266 kni_burst_free_mbufs(&pkts_burst[num], nb_rx - num); 267 kni_stats[port_id].rx_dropped += nb_rx - num; 268 } 269 } 270 } 271 272 /** 273 * Interface to dequeue mbufs from tx_q and burst tx 274 */ 275 static void 276 kni_egress(struct kni_port_params *p) 277 { 278 uint8_t i, port_id; 279 unsigned nb_tx, num; 280 uint32_t nb_kni; 281 struct rte_mbuf *pkts_burst[PKT_BURST_SZ]; 282 283 if (p == NULL) 284 return; 285 286 nb_kni = p->nb_kni; 287 port_id = p->port_id; 288 for (i = 0; i < nb_kni; i++) { 289 /* Burst rx from kni */ 290 num = rte_kni_rx_burst(p->kni[i], pkts_burst, PKT_BURST_SZ); 291 if (unlikely(num > PKT_BURST_SZ)) { 292 RTE_LOG(ERR, APP, "Error receiving from KNI\n"); 293 return; 294 } 295 /* Burst tx to eth */ 296 nb_tx = rte_eth_tx_burst(port_id, 0, pkts_burst, (uint16_t)num); 297 kni_stats[port_id].tx_packets += nb_tx; 298 if (unlikely(nb_tx < num)) { 299 /* Free mbufs not tx to NIC */ 300 kni_burst_free_mbufs(&pkts_burst[nb_tx], num - nb_tx); 301 kni_stats[port_id].tx_dropped += num - nb_tx; 302 } 303 } 304 } 305 306 static int 307 main_loop(__rte_unused void *arg) 308 { 309 uint8_t i, nb_ports = rte_eth_dev_count(); 310 int32_t f_stop; 311 const unsigned lcore_id = rte_lcore_id(); 312 enum lcore_rxtx { 313 LCORE_NONE, 314 LCORE_RX, 315 LCORE_TX, 316 LCORE_MAX 317 }; 318 enum lcore_rxtx flag = LCORE_NONE; 319 320 for (i = 0; i < nb_ports; i++) { 321 if (!kni_port_params_array[i]) 322 continue; 323 if (kni_port_params_array[i]->lcore_rx == (uint8_t)lcore_id) { 324 flag = LCORE_RX; 325 break; 326 } else if (kni_port_params_array[i]->lcore_tx == 327 (uint8_t)lcore_id) { 328 flag = LCORE_TX; 329 break; 330 } 331 } 332 333 if (flag == LCORE_RX) { 334 RTE_LOG(INFO, APP, "Lcore %u is reading from port %d\n", 335 kni_port_params_array[i]->lcore_rx, 336 kni_port_params_array[i]->port_id); 337 while (1) { 338 f_stop = rte_atomic32_read(&kni_stop); 339 if (f_stop) 340 break; 341 kni_ingress(kni_port_params_array[i]); 342 } 343 } else if (flag == LCORE_TX) { 344 RTE_LOG(INFO, APP, "Lcore %u is writing to port %d\n", 345 kni_port_params_array[i]->lcore_tx, 346 kni_port_params_array[i]->port_id); 347 while (1) { 348 f_stop = rte_atomic32_read(&kni_stop); 349 if (f_stop) 350 break; 351 kni_egress(kni_port_params_array[i]); 352 } 353 } else 354 RTE_LOG(INFO, APP, "Lcore %u has nothing to do\n", lcore_id); 355 356 return 0; 357 } 358 359 /* Display usage instructions */ 360 static void 361 print_usage(const char *prgname) 362 { 363 RTE_LOG(INFO, APP, "\nUsage: %s [EAL options] -- -p PORTMASK -P " 364 "[--config (port,lcore_rx,lcore_tx,lcore_kthread...)" 365 "[,(port,lcore_rx,lcore_tx,lcore_kthread...)]]\n" 366 " -p PORTMASK: hex bitmask of ports to use\n" 367 " -P : enable promiscuous mode\n" 368 " --config (port,lcore_rx,lcore_tx,lcore_kthread...): " 369 "port and lcore configurations\n", 370 prgname); 371 } 372 373 /* Convert string to unsigned number. 0 is returned if error occurs */ 374 static uint32_t 375 parse_unsigned(const char *portmask) 376 { 377 char *end = NULL; 378 unsigned long num; 379 380 num = strtoul(portmask, &end, 16); 381 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0')) 382 return 0; 383 384 return (uint32_t)num; 385 } 386 387 static void 388 print_config(void) 389 { 390 uint32_t i, j; 391 struct kni_port_params **p = kni_port_params_array; 392 393 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 394 if (!p[i]) 395 continue; 396 RTE_LOG(DEBUG, APP, "Port ID: %d\n", p[i]->port_id); 397 RTE_LOG(DEBUG, APP, "Rx lcore ID: %u, Tx lcore ID: %u\n", 398 p[i]->lcore_rx, p[i]->lcore_tx); 399 for (j = 0; j < p[i]->nb_lcore_k; j++) 400 RTE_LOG(DEBUG, APP, "Kernel thread lcore ID: %u\n", 401 p[i]->lcore_k[j]); 402 } 403 } 404 405 static int 406 parse_config(const char *arg) 407 { 408 const char *p, *p0 = arg; 409 char s[256], *end; 410 unsigned size; 411 enum fieldnames { 412 FLD_PORT = 0, 413 FLD_LCORE_RX, 414 FLD_LCORE_TX, 415 _NUM_FLD = KNI_MAX_KTHREAD + 3, 416 }; 417 int i, j, nb_token; 418 char *str_fld[_NUM_FLD]; 419 unsigned long int_fld[_NUM_FLD]; 420 uint8_t port_id, nb_kni_port_params = 0; 421 422 memset(&kni_port_params_array, 0, sizeof(kni_port_params_array)); 423 while (((p = strchr(p0, '(')) != NULL) && 424 nb_kni_port_params < RTE_MAX_ETHPORTS) { 425 p++; 426 if ((p0 = strchr(p, ')')) == NULL) 427 goto fail; 428 size = p0 - p; 429 if (size >= sizeof(s)) { 430 printf("Invalid config parameters\n"); 431 goto fail; 432 } 433 snprintf(s, sizeof(s), "%.*s", size, p); 434 nb_token = rte_strsplit(s, sizeof(s), str_fld, _NUM_FLD, ','); 435 if (nb_token <= FLD_LCORE_TX) { 436 printf("Invalid config parameters\n"); 437 goto fail; 438 } 439 for (i = 0; i < nb_token; i++) { 440 errno = 0; 441 int_fld[i] = strtoul(str_fld[i], &end, 0); 442 if (errno != 0 || end == str_fld[i]) { 443 printf("Invalid config parameters\n"); 444 goto fail; 445 } 446 } 447 448 i = 0; 449 port_id = (uint8_t)int_fld[i++]; 450 if (port_id >= RTE_MAX_ETHPORTS) { 451 printf("Port ID %d could not exceed the maximum %d\n", 452 port_id, RTE_MAX_ETHPORTS); 453 goto fail; 454 } 455 if (kni_port_params_array[port_id]) { 456 printf("Port %d has been configured\n", port_id); 457 goto fail; 458 } 459 kni_port_params_array[port_id] = 460 rte_zmalloc("KNI_port_params", 461 sizeof(struct kni_port_params), RTE_CACHE_LINE_SIZE); 462 kni_port_params_array[port_id]->port_id = port_id; 463 kni_port_params_array[port_id]->lcore_rx = 464 (uint8_t)int_fld[i++]; 465 kni_port_params_array[port_id]->lcore_tx = 466 (uint8_t)int_fld[i++]; 467 if (kni_port_params_array[port_id]->lcore_rx >= RTE_MAX_LCORE || 468 kni_port_params_array[port_id]->lcore_tx >= RTE_MAX_LCORE) { 469 printf("lcore_rx %u or lcore_tx %u ID could not " 470 "exceed the maximum %u\n", 471 kni_port_params_array[port_id]->lcore_rx, 472 kni_port_params_array[port_id]->lcore_tx, 473 (unsigned)RTE_MAX_LCORE); 474 goto fail; 475 } 476 for (j = 0; i < nb_token && j < KNI_MAX_KTHREAD; i++, j++) 477 kni_port_params_array[port_id]->lcore_k[j] = 478 (uint8_t)int_fld[i]; 479 kni_port_params_array[port_id]->nb_lcore_k = j; 480 } 481 print_config(); 482 483 return 0; 484 485 fail: 486 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 487 if (kni_port_params_array[i]) { 488 rte_free(kni_port_params_array[i]); 489 kni_port_params_array[i] = NULL; 490 } 491 } 492 493 return -1; 494 } 495 496 static int 497 validate_parameters(uint32_t portmask) 498 { 499 uint32_t i; 500 501 if (!portmask) { 502 printf("No port configured in port mask\n"); 503 return -1; 504 } 505 506 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 507 if (((portmask & (1 << i)) && !kni_port_params_array[i]) || 508 (!(portmask & (1 << i)) && kni_port_params_array[i])) 509 rte_exit(EXIT_FAILURE, "portmask is not consistent " 510 "to port ids specified in --config\n"); 511 512 if (kni_port_params_array[i] && !rte_lcore_is_enabled(\ 513 (unsigned)(kni_port_params_array[i]->lcore_rx))) 514 rte_exit(EXIT_FAILURE, "lcore id %u for " 515 "port %d receiving not enabled\n", 516 kni_port_params_array[i]->lcore_rx, 517 kni_port_params_array[i]->port_id); 518 519 if (kni_port_params_array[i] && !rte_lcore_is_enabled(\ 520 (unsigned)(kni_port_params_array[i]->lcore_tx))) 521 rte_exit(EXIT_FAILURE, "lcore id %u for " 522 "port %d transmitting not enabled\n", 523 kni_port_params_array[i]->lcore_tx, 524 kni_port_params_array[i]->port_id); 525 526 } 527 528 return 0; 529 } 530 531 #define CMDLINE_OPT_CONFIG "config" 532 533 /* Parse the arguments given in the command line of the application */ 534 static int 535 parse_args(int argc, char **argv) 536 { 537 int opt, longindex, ret = 0; 538 const char *prgname = argv[0]; 539 static struct option longopts[] = { 540 {CMDLINE_OPT_CONFIG, required_argument, NULL, 0}, 541 {NULL, 0, NULL, 0} 542 }; 543 544 /* Disable printing messages within getopt() */ 545 opterr = 0; 546 547 /* Parse command line */ 548 while ((opt = getopt_long(argc, argv, "p:P", longopts, 549 &longindex)) != EOF) { 550 switch (opt) { 551 case 'p': 552 ports_mask = parse_unsigned(optarg); 553 break; 554 case 'P': 555 promiscuous_on = 1; 556 break; 557 case 0: 558 if (!strncmp(longopts[longindex].name, 559 CMDLINE_OPT_CONFIG, 560 sizeof(CMDLINE_OPT_CONFIG))) { 561 ret = parse_config(optarg); 562 if (ret) { 563 printf("Invalid config\n"); 564 print_usage(prgname); 565 return -1; 566 } 567 } 568 break; 569 default: 570 print_usage(prgname); 571 rte_exit(EXIT_FAILURE, "Invalid option specified\n"); 572 } 573 } 574 575 /* Check that options were parsed ok */ 576 if (validate_parameters(ports_mask) < 0) { 577 print_usage(prgname); 578 rte_exit(EXIT_FAILURE, "Invalid parameters\n"); 579 } 580 581 return ret; 582 } 583 584 /* Initialize KNI subsystem */ 585 static void 586 init_kni(void) 587 { 588 unsigned int num_of_kni_ports = 0, i; 589 struct kni_port_params **params = kni_port_params_array; 590 591 /* Calculate the maximum number of KNI interfaces that will be used */ 592 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 593 if (kni_port_params_array[i]) { 594 num_of_kni_ports += (params[i]->nb_lcore_k ? 595 params[i]->nb_lcore_k : 1); 596 } 597 } 598 599 /* Invoke rte KNI init to preallocate the ports */ 600 rte_kni_init(num_of_kni_ports); 601 } 602 603 /* Initialise a single port on an Ethernet device */ 604 static void 605 init_port(uint8_t port) 606 { 607 int ret; 608 609 /* Initialise device and RX/TX queues */ 610 RTE_LOG(INFO, APP, "Initialising port %u ...\n", (unsigned)port); 611 fflush(stdout); 612 ret = rte_eth_dev_configure(port, 1, 1, &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_rx_queue_setup(port, 0, NB_RXD, 618 rte_eth_dev_socket_id(port), NULL, pktmbuf_pool); 619 if (ret < 0) 620 rte_exit(EXIT_FAILURE, "Could not setup up RX queue for " 621 "port%u (%d)\n", (unsigned)port, ret); 622 623 ret = rte_eth_tx_queue_setup(port, 0, NB_TXD, 624 rte_eth_dev_socket_id(port), NULL); 625 if (ret < 0) 626 rte_exit(EXIT_FAILURE, "Could not setup up TX queue for " 627 "port%u (%d)\n", (unsigned)port, ret); 628 629 ret = rte_eth_dev_start(port); 630 if (ret < 0) 631 rte_exit(EXIT_FAILURE, "Could not start port%u (%d)\n", 632 (unsigned)port, ret); 633 634 if (promiscuous_on) 635 rte_eth_promiscuous_enable(port); 636 } 637 638 /* Check the link status of all ports in up to 9s, and print them finally */ 639 static void 640 check_all_ports_link_status(uint8_t port_num, uint32_t port_mask) 641 { 642 #define CHECK_INTERVAL 100 /* 100ms */ 643 #define MAX_CHECK_TIME 90 /* 9s (90 * 100ms) in total */ 644 uint8_t portid, count, all_ports_up, print_flag = 0; 645 struct rte_eth_link link; 646 647 printf("\nChecking link status\n"); 648 fflush(stdout); 649 for (count = 0; count <= MAX_CHECK_TIME; count++) { 650 all_ports_up = 1; 651 for (portid = 0; portid < port_num; portid++) { 652 if ((port_mask & (1 << portid)) == 0) 653 continue; 654 memset(&link, 0, sizeof(link)); 655 rte_eth_link_get_nowait(portid, &link); 656 /* print link status if flag set */ 657 if (print_flag == 1) { 658 if (link.link_status) 659 printf("Port %d Link Up - speed %u " 660 "Mbps - %s\n", (uint8_t)portid, 661 (unsigned)link.link_speed, 662 (link.link_duplex == ETH_LINK_FULL_DUPLEX) ? 663 ("full-duplex") : ("half-duplex\n")); 664 else 665 printf("Port %d Link Down\n", 666 (uint8_t)portid); 667 continue; 668 } 669 /* clear all_ports_up flag if any link down */ 670 if (link.link_status == ETH_LINK_DOWN) { 671 all_ports_up = 0; 672 break; 673 } 674 } 675 /* after finally printing all link status, get out */ 676 if (print_flag == 1) 677 break; 678 679 if (all_ports_up == 0) { 680 printf("."); 681 fflush(stdout); 682 rte_delay_ms(CHECK_INTERVAL); 683 } 684 685 /* set the print_flag if all ports up or timeout */ 686 if (all_ports_up == 1 || count == (MAX_CHECK_TIME - 1)) { 687 print_flag = 1; 688 printf("done\n"); 689 } 690 } 691 } 692 693 /* Callback for request of changing MTU */ 694 static int 695 kni_change_mtu(uint8_t port_id, unsigned new_mtu) 696 { 697 int ret; 698 struct rte_eth_conf conf; 699 700 if (port_id >= rte_eth_dev_count()) { 701 RTE_LOG(ERR, APP, "Invalid port id %d\n", port_id); 702 return -EINVAL; 703 } 704 705 RTE_LOG(INFO, APP, "Change MTU of port %d to %u\n", port_id, new_mtu); 706 707 /* Stop specific port */ 708 rte_eth_dev_stop(port_id); 709 710 memcpy(&conf, &port_conf, sizeof(conf)); 711 /* Set new MTU */ 712 if (new_mtu > ETHER_MAX_LEN) 713 conf.rxmode.jumbo_frame = 1; 714 else 715 conf.rxmode.jumbo_frame = 0; 716 717 /* mtu + length of header + length of FCS = max pkt length */ 718 conf.rxmode.max_rx_pkt_len = new_mtu + KNI_ENET_HEADER_SIZE + 719 KNI_ENET_FCS_SIZE; 720 ret = rte_eth_dev_configure(port_id, 1, 1, &conf); 721 if (ret < 0) { 722 RTE_LOG(ERR, APP, "Fail to reconfigure port %d\n", port_id); 723 return ret; 724 } 725 726 /* Restart specific port */ 727 ret = rte_eth_dev_start(port_id); 728 if (ret < 0) { 729 RTE_LOG(ERR, APP, "Fail to restart port %d\n", port_id); 730 return ret; 731 } 732 733 return 0; 734 } 735 736 /* Callback for request of configuring network interface up/down */ 737 static int 738 kni_config_network_interface(uint8_t port_id, uint8_t if_up) 739 { 740 int ret = 0; 741 742 if (port_id >= rte_eth_dev_count() || port_id >= RTE_MAX_ETHPORTS) { 743 RTE_LOG(ERR, APP, "Invalid port id %d\n", port_id); 744 return -EINVAL; 745 } 746 747 RTE_LOG(INFO, APP, "Configure network interface of %d %s\n", 748 port_id, if_up ? "up" : "down"); 749 750 if (if_up != 0) { /* Configure network interface up */ 751 rte_eth_dev_stop(port_id); 752 ret = rte_eth_dev_start(port_id); 753 } else /* Configure network interface down */ 754 rte_eth_dev_stop(port_id); 755 756 if (ret < 0) 757 RTE_LOG(ERR, APP, "Failed to start port %d\n", port_id); 758 759 return ret; 760 } 761 762 static int 763 kni_alloc(uint8_t port_id) 764 { 765 uint8_t i; 766 struct rte_kni *kni; 767 struct rte_kni_conf conf; 768 struct kni_port_params **params = kni_port_params_array; 769 770 if (port_id >= RTE_MAX_ETHPORTS || !params[port_id]) 771 return -1; 772 773 params[port_id]->nb_kni = params[port_id]->nb_lcore_k ? 774 params[port_id]->nb_lcore_k : 1; 775 776 for (i = 0; i < params[port_id]->nb_kni; i++) { 777 /* Clear conf at first */ 778 memset(&conf, 0, sizeof(conf)); 779 if (params[port_id]->nb_lcore_k) { 780 snprintf(conf.name, RTE_KNI_NAMESIZE, 781 "vEth%u_%u", port_id, i); 782 conf.core_id = params[port_id]->lcore_k[i]; 783 conf.force_bind = 1; 784 } else 785 snprintf(conf.name, RTE_KNI_NAMESIZE, 786 "vEth%u", port_id); 787 conf.group_id = (uint16_t)port_id; 788 conf.mbuf_size = MAX_PACKET_SZ; 789 /* 790 * The first KNI device associated to a port 791 * is the master, for multiple kernel thread 792 * environment. 793 */ 794 if (i == 0) { 795 struct rte_kni_ops ops; 796 struct rte_eth_dev_info dev_info; 797 798 memset(&dev_info, 0, sizeof(dev_info)); 799 rte_eth_dev_info_get(port_id, &dev_info); 800 conf.addr = dev_info.pci_dev->addr; 801 conf.id = dev_info.pci_dev->id; 802 803 memset(&ops, 0, sizeof(ops)); 804 ops.port_id = port_id; 805 ops.change_mtu = kni_change_mtu; 806 ops.config_network_if = kni_config_network_interface; 807 808 kni = rte_kni_alloc(pktmbuf_pool, &conf, &ops); 809 } else 810 kni = rte_kni_alloc(pktmbuf_pool, &conf, NULL); 811 812 if (!kni) 813 rte_exit(EXIT_FAILURE, "Fail to create kni for " 814 "port: %d\n", port_id); 815 params[port_id]->kni[i] = kni; 816 } 817 818 return 0; 819 } 820 821 static int 822 kni_free_kni(uint8_t port_id) 823 { 824 uint8_t i; 825 struct kni_port_params **p = kni_port_params_array; 826 827 if (port_id >= RTE_MAX_ETHPORTS || !p[port_id]) 828 return -1; 829 830 for (i = 0; i < p[port_id]->nb_kni; i++) { 831 if (rte_kni_release(p[port_id]->kni[i])) 832 printf("Fail to release kni\n"); 833 p[port_id]->kni[i] = NULL; 834 } 835 rte_eth_dev_stop(port_id); 836 837 return 0; 838 } 839 840 /* Initialise ports/queues etc. and start main loop on each core */ 841 int 842 main(int argc, char** argv) 843 { 844 int ret; 845 uint8_t nb_sys_ports, port; 846 unsigned i; 847 848 /* Associate signal_hanlder function with USR signals */ 849 signal(SIGUSR1, signal_handler); 850 signal(SIGUSR2, signal_handler); 851 signal(SIGRTMIN, signal_handler); 852 signal(SIGINT, signal_handler); 853 854 /* Initialise EAL */ 855 ret = rte_eal_init(argc, argv); 856 if (ret < 0) 857 rte_exit(EXIT_FAILURE, "Could not initialise EAL (%d)\n", ret); 858 argc -= ret; 859 argv += ret; 860 861 /* Parse application arguments (after the EAL ones) */ 862 ret = parse_args(argc, argv); 863 if (ret < 0) 864 rte_exit(EXIT_FAILURE, "Could not parse input parameters\n"); 865 866 /* Create the mbuf pool */ 867 pktmbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", NB_MBUF, 868 MEMPOOL_CACHE_SZ, 0, MBUF_DATA_SZ, rte_socket_id()); 869 if (pktmbuf_pool == NULL) { 870 rte_exit(EXIT_FAILURE, "Could not initialise mbuf pool\n"); 871 return -1; 872 } 873 874 /* Get number of ports found in scan */ 875 nb_sys_ports = rte_eth_dev_count(); 876 if (nb_sys_ports == 0) 877 rte_exit(EXIT_FAILURE, "No supported Ethernet device found\n"); 878 879 /* Check if the configured port ID is valid */ 880 for (i = 0; i < RTE_MAX_ETHPORTS; i++) 881 if (kni_port_params_array[i] && i >= nb_sys_ports) 882 rte_exit(EXIT_FAILURE, "Configured invalid " 883 "port ID %u\n", i); 884 885 /* Initialize KNI subsystem */ 886 init_kni(); 887 888 /* Initialise each port */ 889 for (port = 0; port < nb_sys_ports; port++) { 890 /* Skip ports that are not enabled */ 891 if (!(ports_mask & (1 << port))) 892 continue; 893 init_port(port); 894 895 if (port >= RTE_MAX_ETHPORTS) 896 rte_exit(EXIT_FAILURE, "Can not use more than " 897 "%d ports for kni\n", RTE_MAX_ETHPORTS); 898 899 kni_alloc(port); 900 } 901 check_all_ports_link_status(nb_sys_ports, ports_mask); 902 903 /* Launch per-lcore function on every lcore */ 904 rte_eal_mp_remote_launch(main_loop, NULL, CALL_MASTER); 905 RTE_LCORE_FOREACH_SLAVE(i) { 906 if (rte_eal_wait_lcore(i) < 0) 907 return -1; 908 } 909 910 /* Release resources */ 911 for (port = 0; port < nb_sys_ports; port++) { 912 if (!(ports_mask & (1 << port))) 913 continue; 914 kni_free_kni(port); 915 } 916 #ifdef RTE_LIBRTE_XEN_DOM0 917 rte_kni_close(); 918 #endif 919 for (i = 0; i < RTE_MAX_ETHPORTS; i++) 920 if (kni_port_params_array[i]) { 921 rte_free(kni_port_params_array[i]); 922 kni_port_params_array[i] = NULL; 923 } 924 925 return 0; 926 } 927