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 <stdint.h> 35 #include <sys/queue.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <stdio.h> 39 #include <assert.h> 40 #include <errno.h> 41 #include <signal.h> 42 #include <stdarg.h> 43 #include <inttypes.h> 44 #include <getopt.h> 45 46 #include <rte_common.h> 47 #include <rte_log.h> 48 #include <rte_memory.h> 49 #include <rte_memcpy.h> 50 #include <rte_memzone.h> 51 #include <rte_tailq.h> 52 #include <rte_eal.h> 53 #include <rte_per_lcore.h> 54 #include <rte_launch.h> 55 #include <rte_atomic.h> 56 #include <rte_cycles.h> 57 #include <rte_prefetch.h> 58 #include <rte_lcore.h> 59 #include <rte_per_lcore.h> 60 #include <rte_branch_prediction.h> 61 #include <rte_interrupts.h> 62 #include <rte_pci.h> 63 #include <rte_random.h> 64 #include <rte_debug.h> 65 #include <rte_ether.h> 66 #include <rte_ethdev.h> 67 #include <rte_ring.h> 68 #include <rte_log.h> 69 #include <rte_mempool.h> 70 #include <rte_mbuf.h> 71 #include <rte_memcpy.h> 72 73 #include "main.h" 74 75 /* basic constants used in application */ 76 #define NUM_QUEUES 128 77 78 #define NUM_MBUFS 64*1024 79 #define MBUF_CACHE_SIZE 64 80 #define MBUF_SIZE (2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM) 81 82 #define INVALID_PORT_ID 0xFF 83 84 /* mask of enabled ports */ 85 static uint32_t enabled_port_mask = 0; 86 87 /* number of pools (if user does not specify any, 16 by default */ 88 static enum rte_eth_nb_pools num_pools = ETH_16_POOLS; 89 90 /* 91 * RX and TX Prefetch, Host, and Write-back threshold values should be 92 * carefully set for optimal performance. Consult the network 93 * controller's datasheet and supporting DPDK documentation for guidance 94 * on how these parameters should be set. 95 */ 96 /* Default configuration for rx and tx thresholds etc. */ 97 static const struct rte_eth_rxconf rx_conf_default = { 98 .rx_thresh = { 99 .pthresh = 8, 100 .hthresh = 8, 101 .wthresh = 4, 102 }, 103 }; 104 105 /* 106 * These default values are optimized for use with the Intel(R) 82599 10 GbE 107 * Controller and the DPDK ixgbe PMD. Consider using other values for other 108 * network controllers and/or network drivers. 109 */ 110 static const struct rte_eth_txconf tx_conf_default = { 111 .tx_thresh = { 112 .pthresh = 36, 113 .hthresh = 0, 114 .wthresh = 0, 115 }, 116 .tx_free_thresh = 0, /* Use PMD default values */ 117 .tx_rs_thresh = 0, /* Use PMD default values */ 118 }; 119 120 /* empty vmdq+dcb configuration structure. Filled in programatically */ 121 static const struct rte_eth_conf vmdq_dcb_conf_default = { 122 .rxmode = { 123 .mq_mode = ETH_MQ_RX_VMDQ_DCB, 124 .split_hdr_size = 0, 125 .header_split = 0, /**< Header Split disabled */ 126 .hw_ip_checksum = 0, /**< IP checksum offload disabled */ 127 .hw_vlan_filter = 0, /**< VLAN filtering disabled */ 128 .jumbo_frame = 0, /**< Jumbo Frame Support disabled */ 129 }, 130 .txmode = { 131 .mq_mode = ETH_MQ_TX_NONE, 132 }, 133 .rx_adv_conf = { 134 /* 135 * should be overridden separately in code with 136 * appropriate values 137 */ 138 .vmdq_dcb_conf = { 139 .nb_queue_pools = ETH_16_POOLS, 140 .enable_default_pool = 0, 141 .default_pool = 0, 142 .nb_pool_maps = 0, 143 .pool_map = {{0, 0},}, 144 .dcb_queue = {0}, 145 }, 146 }, 147 }; 148 149 static uint8_t ports[RTE_MAX_ETHPORTS]; 150 static unsigned num_ports = 0; 151 152 /* array used for printing out statistics */ 153 volatile unsigned long rxPackets[ NUM_QUEUES ] = {0}; 154 155 const uint16_t vlan_tags[] = { 156 0, 1, 2, 3, 4, 5, 6, 7, 157 8, 9, 10, 11, 12, 13, 14, 15, 158 16, 17, 18, 19, 20, 21, 22, 23, 159 24, 25, 26, 27, 28, 29, 30, 31 160 }; 161 162 /* Builds up the correct configuration for vmdq+dcb based on the vlan tags array 163 * given above, and the number of traffic classes available for use. */ 164 static inline int 165 get_eth_conf(struct rte_eth_conf *eth_conf, enum rte_eth_nb_pools num_pools) 166 { 167 struct rte_eth_vmdq_dcb_conf conf; 168 unsigned i; 169 170 if (num_pools != ETH_16_POOLS && num_pools != ETH_32_POOLS ) return -1; 171 172 conf.nb_queue_pools = num_pools; 173 conf.enable_default_pool = 0; 174 conf.default_pool = 0; /* set explicit value, even if not used */ 175 conf.nb_pool_maps = sizeof( vlan_tags )/sizeof( vlan_tags[ 0 ]); 176 for (i = 0; i < conf.nb_pool_maps; i++){ 177 conf.pool_map[i].vlan_id = vlan_tags[ i ]; 178 conf.pool_map[i].pools = 1 << (i % num_pools); 179 } 180 for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++){ 181 conf.dcb_queue[i] = (uint8_t)(i % (NUM_QUEUES/num_pools)); 182 } 183 (void)(rte_memcpy(eth_conf, &vmdq_dcb_conf_default, sizeof(*eth_conf))); 184 (void)(rte_memcpy(ð_conf->rx_adv_conf.vmdq_dcb_conf, &conf, 185 sizeof(eth_conf->rx_adv_conf.vmdq_dcb_conf))); 186 return 0; 187 } 188 189 /* 190 * Initialises a given port using global settings and with the rx buffers 191 * coming from the mbuf_pool passed as parameter 192 */ 193 static inline int 194 port_init(uint8_t port, struct rte_mempool *mbuf_pool) 195 { 196 struct rte_eth_conf port_conf; 197 const uint16_t rxRings = ETH_VMDQ_DCB_NUM_QUEUES, 198 txRings = (uint16_t)rte_lcore_count(); 199 const uint16_t rxRingSize = 128, txRingSize = 512; 200 int retval; 201 uint16_t q; 202 203 retval = get_eth_conf(&port_conf, num_pools); 204 if (retval < 0) 205 return retval; 206 207 if (port >= rte_eth_dev_count()) return -1; 208 209 retval = rte_eth_dev_configure(port, rxRings, txRings, &port_conf); 210 if (retval != 0) 211 return retval; 212 213 for (q = 0; q < rxRings; q ++) { 214 retval = rte_eth_rx_queue_setup(port, q, rxRingSize, 215 rte_eth_dev_socket_id(port), &rx_conf_default, 216 mbuf_pool); 217 if (retval < 0) 218 return retval; 219 } 220 221 for (q = 0; q < txRings; q ++) { 222 retval = rte_eth_tx_queue_setup(port, q, txRingSize, 223 rte_eth_dev_socket_id(port), &tx_conf_default); 224 if (retval < 0) 225 return retval; 226 } 227 228 retval = rte_eth_dev_start(port); 229 if (retval < 0) 230 return retval; 231 232 struct ether_addr addr; 233 rte_eth_macaddr_get(port, &addr); 234 printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8 235 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n", 236 (unsigned)port, 237 addr.addr_bytes[0], addr.addr_bytes[1], addr.addr_bytes[2], 238 addr.addr_bytes[3], addr.addr_bytes[4], addr.addr_bytes[5]); 239 240 return 0; 241 } 242 243 /* Check num_pools parameter and set it if OK*/ 244 static int 245 vmdq_parse_num_pools(const char *q_arg) 246 { 247 char *end = NULL; 248 int n; 249 250 /* parse number string */ 251 n = strtol(q_arg, &end, 10); 252 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0')) 253 return -1; 254 if (n != 16 && n != 32) 255 return -1; 256 if (n == 16) 257 num_pools = ETH_16_POOLS; 258 else 259 num_pools = ETH_32_POOLS; 260 261 return 0; 262 } 263 264 static int 265 parse_portmask(const char *portmask) 266 { 267 char *end = NULL; 268 unsigned long pm; 269 270 /* parse hexadecimal string */ 271 pm = strtoul(portmask, &end, 16); 272 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0')) 273 return -1; 274 275 if (pm == 0) 276 return -1; 277 278 return pm; 279 } 280 281 /* Display usage */ 282 static void 283 vmdq_usage(const char *prgname) 284 { 285 printf("%s [EAL options] -- -p PORTMASK]\n" 286 " --nb-pools NP: number of pools (16 default, 32)\n", 287 prgname); 288 } 289 290 /* Parse the argument (num_pools) given in the command line of the application */ 291 static int 292 vmdq_parse_args(int argc, char **argv) 293 { 294 int opt; 295 int option_index; 296 unsigned i; 297 const char *prgname = argv[0]; 298 static struct option long_option[] = { 299 {"nb-pools", required_argument, NULL, 0}, 300 {NULL, 0, 0, 0} 301 }; 302 303 /* Parse command line */ 304 while ((opt = getopt_long(argc, argv, "p:",long_option,&option_index)) != EOF) { 305 switch (opt) { 306 /* portmask */ 307 case 'p': 308 enabled_port_mask = parse_portmask(optarg); 309 if (enabled_port_mask == 0) { 310 printf("invalid portmask\n"); 311 vmdq_usage(prgname); 312 return -1; 313 } 314 break; 315 case 0: 316 if (vmdq_parse_num_pools(optarg) == -1){ 317 printf("invalid number of pools\n"); 318 vmdq_usage(prgname); 319 return -1; 320 } 321 break; 322 default: 323 vmdq_usage(prgname); 324 return -1; 325 } 326 } 327 328 for(i = 0; i < RTE_MAX_ETHPORTS; i++) 329 { 330 if (enabled_port_mask & (1 << i)) 331 ports[num_ports++] = (uint8_t)i; 332 } 333 334 if (num_ports < 2 || num_ports % 2) { 335 printf("Current enabled port number is %u," 336 "but it should be even and at least 2\n",num_ports); 337 return -1; 338 } 339 340 return 0; 341 } 342 343 344 #ifndef RTE_EXEC_ENV_BAREMETAL 345 /* When we receive a HUP signal, print out our stats */ 346 static void 347 sighup_handler(int signum) 348 { 349 unsigned q; 350 for (q = 0; q < NUM_QUEUES; q ++) { 351 if (q % (NUM_QUEUES/num_pools) == 0) 352 printf("\nPool %u: ", q/(NUM_QUEUES/num_pools)); 353 printf("%lu ", rxPackets[ q ]); 354 } 355 printf("\nFinished handling signal %d\n", signum); 356 } 357 #endif 358 359 /* 360 * Main thread that does the work, reading from INPUT_PORT 361 * and writing to OUTPUT_PORT 362 */ 363 static __attribute__((noreturn)) int 364 lcore_main(void *arg) 365 { 366 const uintptr_t core_num = (uintptr_t)arg; 367 const unsigned num_cores = rte_lcore_count(); 368 uint16_t startQueue = (uint16_t)(core_num * (NUM_QUEUES/num_cores)); 369 uint16_t endQueue = (uint16_t)(startQueue + (NUM_QUEUES/num_cores)); 370 uint16_t q, i, p; 371 372 printf("Core %u(lcore %u) reading queues %i-%i\n", (unsigned)core_num, 373 rte_lcore_id(), startQueue, endQueue - 1); 374 375 for (;;) { 376 struct rte_mbuf *buf[32]; 377 const uint16_t buf_size = sizeof(buf) / sizeof(buf[0]); 378 for (p = 0; p < num_ports; p++) { 379 const uint8_t src = ports[p]; 380 const uint8_t dst = ports[p ^ 1]; /* 0 <-> 1, 2 <-> 3 etc */ 381 382 if ((src == INVALID_PORT_ID) || (dst == INVALID_PORT_ID)) 383 continue; 384 385 for (q = startQueue; q < endQueue; q++) { 386 const uint16_t rxCount = rte_eth_rx_burst(src, 387 q, buf, buf_size); 388 if (rxCount == 0) 389 continue; 390 rxPackets[q] += rxCount; 391 392 const uint16_t txCount = rte_eth_tx_burst(dst, 393 (uint16_t)core_num, buf, rxCount); 394 if (txCount != rxCount) { 395 for (i = txCount; i < rxCount; i++) 396 rte_pktmbuf_free(buf[i]); 397 } 398 } 399 } 400 } 401 } 402 403 /* 404 * Update the global var NUM_PORTS and array PORTS according to system ports number 405 * and return valid ports number 406 */ 407 static unsigned check_ports_num(unsigned nb_ports) 408 { 409 unsigned valid_num_ports = num_ports; 410 unsigned portid; 411 412 if (num_ports > nb_ports) { 413 printf("\nSpecified port number(%u) exceeds total system port number(%u)\n", 414 num_ports, nb_ports); 415 num_ports = nb_ports; 416 } 417 418 for (portid = 0; portid < num_ports; portid ++) { 419 if (ports[portid] >= nb_ports) { 420 printf("\nSpecified port ID(%u) exceeds max system port ID(%u)\n", 421 ports[portid], (nb_ports - 1)); 422 ports[portid] = INVALID_PORT_ID; 423 valid_num_ports --; 424 } 425 } 426 return valid_num_ports; 427 } 428 429 430 /* Main function, does initialisation and calls the per-lcore functions */ 431 int 432 MAIN(int argc, char *argv[]) 433 { 434 unsigned cores; 435 struct rte_mempool *mbuf_pool; 436 unsigned lcore_id; 437 uintptr_t i; 438 int ret; 439 unsigned nb_ports, valid_num_ports; 440 uint8_t portid; 441 442 #ifndef RTE_EXEC_ENV_BAREMETAL 443 signal(SIGHUP, sighup_handler); 444 #endif 445 446 /* init EAL */ 447 ret = rte_eal_init(argc, argv); 448 if (ret < 0) 449 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n"); 450 argc -= ret; 451 argv += ret; 452 453 /* parse app arguments */ 454 ret = vmdq_parse_args(argc, argv); 455 if (ret < 0) 456 rte_exit(EXIT_FAILURE, "Invalid VMDQ argument\n"); 457 458 if (rte_ixgbe_pmd_init() != 0 || 459 rte_eal_pci_probe() != 0) 460 rte_exit(EXIT_FAILURE, "Error with NIC driver initialization\n"); 461 462 cores = rte_lcore_count(); 463 if ((cores & (cores - 1)) != 0 || cores > 128) { 464 rte_exit(EXIT_FAILURE,"This program can only run on an even" 465 "number of cores(1-128)\n\n"); 466 } 467 468 nb_ports = rte_eth_dev_count(); 469 if (nb_ports > RTE_MAX_ETHPORTS) 470 nb_ports = RTE_MAX_ETHPORTS; 471 472 /* 473 * Update the global var NUM_PORTS and global array PORTS 474 * and get value of var VALID_NUM_PORTS according to system ports number 475 */ 476 valid_num_ports = check_ports_num(nb_ports); 477 478 if (valid_num_ports < 2 || valid_num_ports % 2) { 479 printf("Current valid ports number is %u\n", valid_num_ports); 480 rte_exit(EXIT_FAILURE, "Error with valid ports number is not even or less than 2\n"); 481 } 482 483 mbuf_pool = rte_mempool_create("MBUF_POOL", NUM_MBUFS * nb_ports, 484 MBUF_SIZE, MBUF_CACHE_SIZE, 485 sizeof(struct rte_pktmbuf_pool_private), 486 rte_pktmbuf_pool_init, NULL, 487 rte_pktmbuf_init, NULL, 488 rte_socket_id(), 0); 489 if (mbuf_pool == NULL) 490 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n"); 491 492 /* initialize all ports */ 493 for (portid = 0; portid < nb_ports; portid++) { 494 /* skip ports that are not enabled */ 495 if ((enabled_port_mask & (1 << portid)) == 0) { 496 printf("\nSkipping disabled port %d\n", portid); 497 continue; 498 } 499 if (port_init(portid, mbuf_pool) != 0) 500 rte_exit(EXIT_FAILURE, "Cannot initialize network ports\n"); 501 } 502 503 /* call lcore_main() on every slave lcore */ 504 i = 0; 505 RTE_LCORE_FOREACH_SLAVE(lcore_id) { 506 rte_eal_remote_launch(lcore_main, (void*)i++, lcore_id); 507 } 508 /* call on master too */ 509 (void) lcore_main((void*)i); 510 511 return 0; 512 } 513