1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
17 #include <rte_common.h>
19 #include <rte_memory.h>
20 #include <rte_memcpy.h>
22 #include <rte_launch.h>
23 #include <rte_atomic.h>
24 #include <rte_cycles.h>
25 #include <rte_prefetch.h>
26 #include <rte_lcore.h>
27 #include <rte_per_lcore.h>
28 #include <rte_branch_prediction.h>
29 #include <rte_interrupts.h>
30 #include <rte_random.h>
31 #include <rte_debug.h>
32 #include <rte_ether.h>
33 #include <rte_ethdev.h>
34 #include <rte_mempool.h>
37 /* basic constants used in application */
38 #define MAX_QUEUES 1024
40 * 1024 queues require to meet the needs of a large number of vmdq_pools.
41 * (RX/TX_queue_nb * RX/TX_ring_descriptors_nb) per port.
43 #define NUM_MBUFS_PER_PORT (MAX_QUEUES * RTE_MAX(RTE_TEST_RX_DESC_DEFAULT, \
44 RTE_TEST_TX_DESC_DEFAULT))
45 #define MBUF_CACHE_SIZE 64
47 #define MAX_PKT_BURST 32
50 * Configurable number of RX/TX ring descriptors
52 #define RTE_TEST_RX_DESC_DEFAULT 1024
53 #define RTE_TEST_TX_DESC_DEFAULT 1024
55 #define INVALID_PORT_ID 0xFF
57 /* mask of enabled ports */
58 static uint32_t enabled_port_mask;
59 static uint16_t ports[RTE_MAX_ETHPORTS];
60 static unsigned num_ports;
62 /* number of pools (if user does not specify any, 32 by default */
63 static enum rte_eth_nb_pools num_pools = ETH_32_POOLS;
64 static enum rte_eth_nb_tcs num_tcs = ETH_4_TCS;
65 static uint16_t num_queues, num_vmdq_queues;
66 static uint16_t vmdq_pool_base, vmdq_queue_base;
67 static uint8_t rss_enable;
69 /* empty vmdq+dcb configuration structure. Filled in programatically */
70 static const struct rte_eth_conf vmdq_dcb_conf_default = {
72 .mq_mode = ETH_MQ_RX_VMDQ_DCB,
76 .mq_mode = ETH_MQ_TX_VMDQ_DCB,
79 * should be overridden separately in code with
84 .nb_queue_pools = ETH_32_POOLS,
85 .enable_default_pool = 0,
88 .pool_map = {{0, 0},},
93 /** Traffic class each UP mapped to. */
97 .nb_queue_pools = ETH_32_POOLS,
98 .enable_default_pool = 0,
101 .pool_map = {{0, 0},},
105 .vmdq_dcb_tx_conf = {
106 .nb_queue_pools = ETH_32_POOLS,
112 /* array used for printing out statistics */
113 volatile unsigned long rxPackets[MAX_QUEUES] = {0};
115 const uint16_t vlan_tags[] = {
116 0, 1, 2, 3, 4, 5, 6, 7,
117 8, 9, 10, 11, 12, 13, 14, 15,
118 16, 17, 18, 19, 20, 21, 22, 23,
119 24, 25, 26, 27, 28, 29, 30, 31
122 const uint16_t num_vlans = RTE_DIM(vlan_tags);
123 /* pool mac addr template, pool mac addr is like: 52 54 00 12 port# pool# */
124 static struct ether_addr pool_addr_template = {
125 .addr_bytes = {0x52, 0x54, 0x00, 0x12, 0x00, 0x00}
128 /* ethernet addresses of ports */
129 static struct ether_addr vmdq_ports_eth_addr[RTE_MAX_ETHPORTS];
131 /* Builds up the correct configuration for vmdq+dcb based on the vlan tags array
132 * given above, and the number of traffic classes available for use. */
134 get_eth_conf(struct rte_eth_conf *eth_conf)
136 struct rte_eth_vmdq_dcb_conf conf;
137 struct rte_eth_vmdq_rx_conf vmdq_conf;
138 struct rte_eth_dcb_rx_conf dcb_conf;
139 struct rte_eth_vmdq_dcb_tx_conf tx_conf;
142 conf.nb_queue_pools = (enum rte_eth_nb_pools)num_pools;
143 vmdq_conf.nb_queue_pools = (enum rte_eth_nb_pools)num_pools;
144 tx_conf.nb_queue_pools = (enum rte_eth_nb_pools)num_pools;
145 conf.nb_pool_maps = num_pools;
146 vmdq_conf.nb_pool_maps = num_pools;
147 conf.enable_default_pool = 0;
148 vmdq_conf.enable_default_pool = 0;
149 conf.default_pool = 0; /* set explicit value, even if not used */
150 vmdq_conf.default_pool = 0;
152 for (i = 0; i < conf.nb_pool_maps; i++) {
153 conf.pool_map[i].vlan_id = vlan_tags[i];
154 vmdq_conf.pool_map[i].vlan_id = vlan_tags[i];
155 conf.pool_map[i].pools = 1UL << i;
156 vmdq_conf.pool_map[i].pools = 1UL << i;
158 for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++){
159 conf.dcb_tc[i] = i % num_tcs;
160 dcb_conf.dcb_tc[i] = i % num_tcs;
161 tx_conf.dcb_tc[i] = i % num_tcs;
163 dcb_conf.nb_tcs = (enum rte_eth_nb_tcs)num_tcs;
164 (void)(rte_memcpy(eth_conf, &vmdq_dcb_conf_default, sizeof(*eth_conf)));
165 (void)(rte_memcpy(ð_conf->rx_adv_conf.vmdq_dcb_conf, &conf,
167 (void)(rte_memcpy(ð_conf->rx_adv_conf.dcb_rx_conf, &dcb_conf,
169 (void)(rte_memcpy(ð_conf->rx_adv_conf.vmdq_rx_conf, &vmdq_conf,
171 (void)(rte_memcpy(ð_conf->tx_adv_conf.vmdq_dcb_tx_conf, &tx_conf,
174 eth_conf->rxmode.mq_mode = ETH_MQ_RX_VMDQ_DCB_RSS;
175 eth_conf->rx_adv_conf.rss_conf.rss_hf = ETH_RSS_IP |
184 * Initialises a given port using global settings and with the rx buffers
185 * coming from the mbuf_pool passed as parameter
188 port_init(uint16_t port, struct rte_mempool *mbuf_pool)
190 struct rte_eth_dev_info dev_info;
191 struct rte_eth_conf port_conf = {0};
192 uint16_t rxRingSize = RTE_TEST_RX_DESC_DEFAULT;
193 uint16_t txRingSize = RTE_TEST_TX_DESC_DEFAULT;
196 uint16_t queues_per_pool;
197 uint32_t max_nb_pools;
198 struct rte_eth_txconf txq_conf;
202 * The max pool number from dev_info will be used to validate the pool
203 * number specified in cmd line
205 rte_eth_dev_info_get(port, &dev_info);
206 max_nb_pools = (uint32_t)dev_info.max_vmdq_pools;
208 * We allow to process part of VMDQ pools specified by num_pools in
211 if (num_pools > max_nb_pools) {
212 printf("num_pools %d >max_nb_pools %d\n",
213 num_pools, max_nb_pools);
218 * NIC queues are divided into pf queues and vmdq queues.
219 * There is assumption here all ports have the same configuration!
221 vmdq_queue_base = dev_info.vmdq_queue_base;
222 vmdq_pool_base = dev_info.vmdq_pool_base;
223 printf("vmdq queue base: %d pool base %d\n",
224 vmdq_queue_base, vmdq_pool_base);
225 if (vmdq_pool_base == 0) {
226 num_vmdq_queues = dev_info.max_rx_queues;
227 num_queues = dev_info.max_rx_queues;
228 if (num_tcs != num_vmdq_queues / num_pools) {
229 printf("nb_tcs %d is invalid considering with"
230 " nb_pools %d, nb_tcs * nb_pools should = %d\n",
231 num_tcs, num_pools, num_vmdq_queues);
235 queues_per_pool = dev_info.vmdq_queue_num /
236 dev_info.max_vmdq_pools;
237 if (num_tcs > queues_per_pool) {
238 printf("num_tcs %d > num of queues per pool %d\n",
239 num_tcs, queues_per_pool);
242 num_vmdq_queues = num_pools * queues_per_pool;
243 num_queues = vmdq_queue_base + num_vmdq_queues;
244 printf("Configured vmdq pool num: %u,"
245 " each vmdq pool has %u queues\n",
246 num_pools, queues_per_pool);
249 if (!rte_eth_dev_is_valid_port(port))
252 retval = get_eth_conf(&port_conf);
256 rte_eth_dev_info_get(port, &dev_info);
257 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
258 port_conf.txmode.offloads |=
259 DEV_TX_OFFLOAD_MBUF_FAST_FREE;
261 rss_hf_tmp = port_conf.rx_adv_conf.rss_conf.rss_hf;
262 port_conf.rx_adv_conf.rss_conf.rss_hf &=
263 dev_info.flow_type_rss_offloads;
264 if (port_conf.rx_adv_conf.rss_conf.rss_hf != rss_hf_tmp) {
265 printf("Port %u modified RSS hash function based on hardware support,"
266 "requested:%#"PRIx64" configured:%#"PRIx64"\n",
269 port_conf.rx_adv_conf.rss_conf.rss_hf);
273 * Though in this example, all queues including pf queues are setup.
274 * This is because VMDQ queues doesn't always start from zero, and the
275 * PMD layer doesn't support selectively initialising part of rx/tx
278 retval = rte_eth_dev_configure(port, num_queues, num_queues, &port_conf);
282 retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &rxRingSize,
286 if (RTE_MAX(rxRingSize, txRingSize) >
287 RTE_MAX(RTE_TEST_RX_DESC_DEFAULT, RTE_TEST_TX_DESC_DEFAULT)) {
288 printf("Mbuf pool has an insufficient size for port %u.\n",
293 for (q = 0; q < num_queues; q++) {
294 retval = rte_eth_rx_queue_setup(port, q, rxRingSize,
295 rte_eth_dev_socket_id(port),
299 printf("initialize rx queue %d failed\n", q);
304 txq_conf = dev_info.default_txconf;
305 txq_conf.offloads = port_conf.txmode.offloads;
306 for (q = 0; q < num_queues; q++) {
307 retval = rte_eth_tx_queue_setup(port, q, txRingSize,
308 rte_eth_dev_socket_id(port),
311 printf("initialize tx queue %d failed\n", q);
316 retval = rte_eth_dev_start(port);
318 printf("port %d start failed\n", port);
322 rte_eth_macaddr_get(port, &vmdq_ports_eth_addr[port]);
323 printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
324 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
326 vmdq_ports_eth_addr[port].addr_bytes[0],
327 vmdq_ports_eth_addr[port].addr_bytes[1],
328 vmdq_ports_eth_addr[port].addr_bytes[2],
329 vmdq_ports_eth_addr[port].addr_bytes[3],
330 vmdq_ports_eth_addr[port].addr_bytes[4],
331 vmdq_ports_eth_addr[port].addr_bytes[5]);
333 /* Set mac for each pool.*/
334 for (q = 0; q < num_pools; q++) {
335 struct ether_addr mac;
337 mac = pool_addr_template;
338 mac.addr_bytes[4] = port;
339 mac.addr_bytes[5] = q;
340 printf("Port %u vmdq pool %u set mac %02x:%02x:%02x:%02x:%02x:%02x\n",
342 mac.addr_bytes[0], mac.addr_bytes[1],
343 mac.addr_bytes[2], mac.addr_bytes[3],
344 mac.addr_bytes[4], mac.addr_bytes[5]);
345 retval = rte_eth_dev_mac_addr_add(port, &mac,
348 printf("mac addr add failed at pool %d\n", q);
356 /* Check num_pools parameter and set it if OK*/
358 vmdq_parse_num_pools(const char *q_arg)
363 /* parse number string */
364 n = strtol(q_arg, &end, 10);
365 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0'))
367 if (n != 16 && n != 32)
370 num_pools = ETH_16_POOLS;
372 num_pools = ETH_32_POOLS;
377 /* Check num_tcs parameter and set it if OK*/
379 vmdq_parse_num_tcs(const char *q_arg)
384 /* parse number string */
385 n = strtol(q_arg, &end, 10);
386 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0'))
389 if (n != 4 && n != 8)
400 parse_portmask(const char *portmask)
405 /* parse hexadecimal string */
406 pm = strtoul(portmask, &end, 16);
407 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
418 vmdq_usage(const char *prgname)
420 printf("%s [EAL options] -- -p PORTMASK]\n"
421 " --nb-pools NP: number of pools (32 default, 16)\n"
422 " --nb-tcs NP: number of TCs (4 default, 8)\n"
423 " --enable-rss: enable RSS (disabled by default)\n",
427 /* Parse the argument (num_pools) given in the command line of the application */
429 vmdq_parse_args(int argc, char **argv)
434 const char *prgname = argv[0];
435 static struct option long_option[] = {
436 {"nb-pools", required_argument, NULL, 0},
437 {"nb-tcs", required_argument, NULL, 0},
438 {"enable-rss", 0, NULL, 0},
442 /* Parse command line */
443 while ((opt = getopt_long(argc, argv, "p:", long_option,
444 &option_index)) != EOF) {
448 enabled_port_mask = parse_portmask(optarg);
449 if (enabled_port_mask == 0) {
450 printf("invalid portmask\n");
456 if (!strcmp(long_option[option_index].name, "nb-pools")) {
457 if (vmdq_parse_num_pools(optarg) == -1) {
458 printf("invalid number of pools\n");
463 if (!strcmp(long_option[option_index].name, "nb-tcs")) {
464 if (vmdq_parse_num_tcs(optarg) == -1) {
465 printf("invalid number of tcs\n");
470 if (!strcmp(long_option[option_index].name, "enable-rss"))
480 for (i = 0; i < RTE_MAX_ETHPORTS; i++) {
481 if (enabled_port_mask & (1 << i))
482 ports[num_ports++] = (uint8_t)i;
485 if (num_ports < 2 || num_ports % 2) {
486 printf("Current enabled port number is %u,"
487 " but it should be even and at least 2\n", num_ports);
495 update_mac_address(struct rte_mbuf *m, unsigned dst_port)
497 struct ether_hdr *eth;
500 eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
502 /* 02:00:00:00:00:xx */
503 tmp = ð->d_addr.addr_bytes[0];
504 *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
507 ether_addr_copy(&vmdq_ports_eth_addr[dst_port], ð->s_addr);
510 /* When we receive a HUP signal, print out our stats */
512 sighup_handler(int signum)
514 unsigned q = vmdq_queue_base;
516 for (; q < num_queues; q++) {
517 if (q % (num_vmdq_queues / num_pools) == 0)
518 printf("\nPool %u: ", (q - vmdq_queue_base) /
519 (num_vmdq_queues / num_pools));
520 printf("%lu ", rxPackets[q]);
522 printf("\nFinished handling signal %d\n", signum);
526 * Main thread that does the work, reading from INPUT_PORT
527 * and writing to OUTPUT_PORT
530 lcore_main(void *arg)
532 const uintptr_t core_num = (uintptr_t)arg;
533 const unsigned num_cores = rte_lcore_count();
534 uint16_t startQueue, endQueue;
536 const uint16_t quot = (uint16_t)(num_vmdq_queues / num_cores);
537 const uint16_t remainder = (uint16_t)(num_vmdq_queues % num_cores);
541 if (core_num < remainder) {
542 startQueue = (uint16_t)(core_num * (quot + 1));
543 endQueue = (uint16_t)(startQueue + quot + 1);
545 startQueue = (uint16_t)(core_num * quot + remainder);
546 endQueue = (uint16_t)(startQueue + quot);
549 startQueue = (uint16_t)(core_num * quot);
550 endQueue = (uint16_t)(startQueue + quot);
553 /* vmdq queue idx doesn't always start from zero.*/
554 startQueue += vmdq_queue_base;
555 endQueue += vmdq_queue_base;
556 printf("Core %u(lcore %u) reading queues %i-%i\n", (unsigned)core_num,
557 rte_lcore_id(), startQueue, endQueue - 1);
559 if (startQueue == endQueue) {
560 printf("lcore %u has nothing to do\n", (unsigned)core_num);
565 struct rte_mbuf *buf[MAX_PKT_BURST];
566 const uint16_t buf_size = sizeof(buf) / sizeof(buf[0]);
567 for (p = 0; p < num_ports; p++) {
568 const uint8_t src = ports[p];
569 const uint8_t dst = ports[p ^ 1]; /* 0 <-> 1, 2 <-> 3 etc */
571 if ((src == INVALID_PORT_ID) || (dst == INVALID_PORT_ID))
574 for (q = startQueue; q < endQueue; q++) {
575 const uint16_t rxCount = rte_eth_rx_burst(src,
578 if (unlikely(rxCount == 0))
581 rxPackets[q] += rxCount;
583 for (i = 0; i < rxCount; i++)
584 update_mac_address(buf[i], dst);
586 const uint16_t txCount = rte_eth_tx_burst(dst,
588 if (txCount != rxCount) {
589 for (i = txCount; i < rxCount; i++)
590 rte_pktmbuf_free(buf[i]);
598 * Update the global var NUM_PORTS and array PORTS according to system ports number
599 * and return valid ports number
601 static unsigned check_ports_num(unsigned nb_ports)
603 unsigned valid_num_ports = num_ports;
606 if (num_ports > nb_ports) {
607 printf("\nSpecified port number(%u) exceeds total system port number(%u)\n",
608 num_ports, nb_ports);
609 num_ports = nb_ports;
612 for (portid = 0; portid < num_ports; portid++) {
613 if (!rte_eth_dev_is_valid_port(ports[portid])) {
614 printf("\nSpecified port ID(%u) is not valid\n",
616 ports[portid] = INVALID_PORT_ID;
620 return valid_num_ports;
624 /* Main function, does initialisation and calls the per-lcore functions */
626 main(int argc, char *argv[])
629 struct rte_mempool *mbuf_pool;
633 unsigned nb_ports, valid_num_ports;
636 signal(SIGHUP, sighup_handler);
639 ret = rte_eal_init(argc, argv);
641 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
645 /* parse app arguments */
646 ret = vmdq_parse_args(argc, argv);
648 rte_exit(EXIT_FAILURE, "Invalid VMDQ argument\n");
650 cores = rte_lcore_count();
651 if ((cores & (cores - 1)) != 0 || cores > RTE_MAX_LCORE) {
652 rte_exit(EXIT_FAILURE,"This program can only run on an even"
653 " number of cores(1-%d)\n\n", RTE_MAX_LCORE);
656 nb_ports = rte_eth_dev_count_avail();
659 * Update the global var NUM_PORTS and global array PORTS
660 * and get value of var VALID_NUM_PORTS according to system ports number
662 valid_num_ports = check_ports_num(nb_ports);
664 if (valid_num_ports < 2 || valid_num_ports % 2) {
665 printf("Current valid ports number is %u\n", valid_num_ports);
666 rte_exit(EXIT_FAILURE, "Error with valid ports number is not even or less than 2\n");
669 mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
670 NUM_MBUFS_PER_PORT * nb_ports, MBUF_CACHE_SIZE,
671 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
672 if (mbuf_pool == NULL)
673 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
675 /* initialize all ports */
676 RTE_ETH_FOREACH_DEV(portid) {
677 /* skip ports that are not enabled */
678 if ((enabled_port_mask & (1 << portid)) == 0) {
679 printf("\nSkipping disabled port %d\n", portid);
682 if (port_init(portid, mbuf_pool) != 0)
683 rte_exit(EXIT_FAILURE, "Cannot initialize network ports\n");
686 /* call lcore_main() on every slave lcore */
688 RTE_LCORE_FOREACH_SLAVE(lcore_id) {
689 rte_eal_remote_launch(lcore_main, (void*)i++, lcore_id);
691 /* call on master too */
692 (void) lcore_main((void*)i);