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_cycles.h>
24 #include <rte_prefetch.h>
25 #include <rte_lcore.h>
26 #include <rte_per_lcore.h>
27 #include <rte_branch_prediction.h>
28 #include <rte_interrupts.h>
29 #include <rte_random.h>
30 #include <rte_debug.h>
31 #include <rte_ether.h>
32 #include <rte_ethdev.h>
33 #include <rte_mempool.h>
36 #define MAX_QUEUES 1024
38 * 1024 queues require to meet the needs of a large number of vmdq_pools.
39 * (RX/TX_queue_nb * RX/TX_ring_descriptors_nb) per port.
41 #define NUM_MBUFS_PER_PORT (MAX_QUEUES * RTE_MAX(RTE_TEST_RX_DESC_DEFAULT, \
42 RTE_TEST_TX_DESC_DEFAULT))
43 #define MBUF_CACHE_SIZE 64
45 #define MAX_PKT_BURST 32
48 * Configurable number of RX/TX ring descriptors
50 #define RTE_TEST_RX_DESC_DEFAULT 1024
51 #define RTE_TEST_TX_DESC_DEFAULT 1024
53 #define INVALID_PORT_ID 0xFF
55 /* mask of enabled ports */
56 static uint32_t enabled_port_mask;
58 /* number of pools (if user does not specify any, 8 by default */
59 static uint32_t num_queues = 8;
60 static uint32_t num_pools = 8;
61 static uint8_t rss_enable;
63 /* Default structure for VMDq. 8< */
65 /* empty vmdq configuration structure. Filled in programatically */
66 static const struct rte_eth_conf vmdq_conf_default = {
68 .mq_mode = RTE_ETH_MQ_RX_VMDQ_ONLY,
73 .mq_mode = RTE_ETH_MQ_TX_NONE,
77 * should be overridden separately in code with
81 .nb_queue_pools = RTE_ETH_8_POOLS,
82 .enable_default_pool = 0,
85 .pool_map = {{0, 0},},
89 /* >8 End of Empty vdmq configuration structure. */
91 static unsigned lcore_ids[RTE_MAX_LCORE];
92 static uint16_t ports[RTE_MAX_ETHPORTS];
93 static unsigned num_ports; /**< The number of ports specified in command line */
95 /* array used for printing out statistics */
96 volatile unsigned long rxPackets[MAX_QUEUES] = {0};
99 const uint16_t vlan_tags[] = {
100 0, 1, 2, 3, 4, 5, 6, 7,
101 8, 9, 10, 11, 12, 13, 14, 15,
102 16, 17, 18, 19, 20, 21, 22, 23,
103 24, 25, 26, 27, 28, 29, 30, 31,
104 32, 33, 34, 35, 36, 37, 38, 39,
105 40, 41, 42, 43, 44, 45, 46, 47,
106 48, 49, 50, 51, 52, 53, 54, 55,
107 56, 57, 58, 59, 60, 61, 62, 63,
109 /* >8 End of vlan_tags. */
111 const uint16_t num_vlans = RTE_DIM(vlan_tags);
112 static uint16_t num_pf_queues, num_vmdq_queues;
113 static uint16_t vmdq_pool_base, vmdq_queue_base;
115 /* Pool mac address template. 8< */
117 /* pool mac addr template, pool mac addr is like: 52 54 00 12 port# pool# */
118 static struct rte_ether_addr pool_addr_template = {
119 .addr_bytes = {0x52, 0x54, 0x00, 0x12, 0x00, 0x00}
121 /* >8 End of mac addr template. */
123 /* ethernet addresses of ports */
124 static struct rte_ether_addr vmdq_ports_eth_addr[RTE_MAX_ETHPORTS];
126 #define MAX_QUEUE_NUM_10G 128
127 #define MAX_QUEUE_NUM_1G 8
128 #define MAX_POOL_MAP_NUM_10G 64
129 #define MAX_POOL_MAP_NUM_1G 32
130 #define MAX_POOL_NUM_10G 64
131 #define MAX_POOL_NUM_1G 8
133 * Builds up the correct configuration for vmdq based on the vlan tags array
134 * given above, and determine the queue number and pool map number according to
138 /* Building correct configuration for vdmq. 8< */
140 get_eth_conf(struct rte_eth_conf *eth_conf, uint32_t num_pools)
142 struct rte_eth_vmdq_rx_conf conf;
145 conf.nb_queue_pools = (enum rte_eth_nb_pools)num_pools;
146 conf.nb_pool_maps = num_pools;
147 conf.enable_default_pool = 0;
148 conf.default_pool = 0; /* set explicit value, even if not used */
150 for (i = 0; i < conf.nb_pool_maps; i++) {
151 conf.pool_map[i].vlan_id = vlan_tags[i];
152 conf.pool_map[i].pools = (1UL << (i % num_pools));
155 (void)(rte_memcpy(eth_conf, &vmdq_conf_default, sizeof(*eth_conf)));
156 (void)(rte_memcpy(ð_conf->rx_adv_conf.vmdq_rx_conf, &conf,
157 sizeof(eth_conf->rx_adv_conf.vmdq_rx_conf)));
159 eth_conf->rxmode.mq_mode = RTE_ETH_MQ_RX_VMDQ_RSS;
160 eth_conf->rx_adv_conf.rss_conf.rss_hf = RTE_ETH_RSS_IP |
169 * Initialises a given port using global settings and with the rx buffers
170 * coming from the mbuf_pool passed as parameter
173 port_init(uint16_t port, struct rte_mempool *mbuf_pool)
175 struct rte_eth_dev_info dev_info;
176 struct rte_eth_rxconf *rxconf;
177 struct rte_eth_txconf *txconf;
178 struct rte_eth_conf port_conf;
179 uint16_t rxRings, txRings;
180 uint16_t rxRingSize = RTE_TEST_RX_DESC_DEFAULT;
181 uint16_t txRingSize = RTE_TEST_TX_DESC_DEFAULT;
184 uint16_t queues_per_pool;
185 uint32_t max_nb_pools;
189 * The max pool number from dev_info will be used to validate the pool
190 * number specified in cmd line
192 retval = rte_eth_dev_info_get(port, &dev_info);
194 printf("Error during getting device (port %u) info: %s\n",
195 port, strerror(-retval));
199 max_nb_pools = (uint32_t)dev_info.max_vmdq_pools;
201 * We allow to process part of VMDQ pools specified by num_pools in
204 if (num_pools > max_nb_pools) {
205 printf("num_pools %d >max_nb_pools %d\n",
206 num_pools, max_nb_pools);
209 retval = get_eth_conf(&port_conf, max_nb_pools);
214 * NIC queues are divided into pf queues and vmdq queues.
216 /* There is assumption here all ports have the same configuration! */
217 num_pf_queues = dev_info.max_rx_queues - dev_info.vmdq_queue_num;
218 queues_per_pool = dev_info.vmdq_queue_num / dev_info.max_vmdq_pools;
219 num_vmdq_queues = num_pools * queues_per_pool;
220 num_queues = num_pf_queues + num_vmdq_queues;
221 vmdq_queue_base = dev_info.vmdq_queue_base;
222 vmdq_pool_base = dev_info.vmdq_pool_base;
224 printf("pf queue num: %u, configured vmdq pool num: %u,"
225 " each vmdq pool has %u queues\n",
226 num_pf_queues, num_pools, queues_per_pool);
227 printf("vmdq queue base: %d pool base %d\n",
228 vmdq_queue_base, vmdq_pool_base);
229 if (!rte_eth_dev_is_valid_port(port))
232 rss_hf_tmp = port_conf.rx_adv_conf.rss_conf.rss_hf;
233 port_conf.rx_adv_conf.rss_conf.rss_hf &=
234 dev_info.flow_type_rss_offloads;
235 if (port_conf.rx_adv_conf.rss_conf.rss_hf != rss_hf_tmp) {
236 printf("Port %u modified RSS hash function based on hardware support,"
237 "requested:%#"PRIx64" configured:%#"PRIx64"\n",
240 port_conf.rx_adv_conf.rss_conf.rss_hf);
244 * Though in this example, we only receive packets from the first queue
245 * of each pool and send packets through first rte_lcore_count() tx
246 * queues of vmdq queues, all queues including pf queues are setup.
247 * This is because VMDQ queues doesn't always start from zero, and the
248 * PMD layer doesn't support selectively initialising part of rx/tx
251 rxRings = (uint16_t)dev_info.max_rx_queues;
252 txRings = (uint16_t)dev_info.max_tx_queues;
254 retval = rte_eth_dev_info_get(port, &dev_info);
256 printf("Error during getting device (port %u) info: %s\n",
257 port, strerror(-retval));
261 if (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE)
262 port_conf.txmode.offloads |=
263 RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE;
264 retval = rte_eth_dev_configure(port, rxRings, txRings, &port_conf);
268 retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &rxRingSize,
272 if (RTE_MAX(rxRingSize, txRingSize) > RTE_MAX(RTE_TEST_RX_DESC_DEFAULT,
273 RTE_TEST_TX_DESC_DEFAULT)) {
274 printf("Mbuf pool has an insufficient size for port %u.\n",
279 rxconf = &dev_info.default_rxconf;
280 rxconf->rx_drop_en = 1;
281 txconf = &dev_info.default_txconf;
282 txconf->offloads = port_conf.txmode.offloads;
283 for (q = 0; q < rxRings; q++) {
284 retval = rte_eth_rx_queue_setup(port, q, rxRingSize,
285 rte_eth_dev_socket_id(port),
289 printf("initialise rx queue %d failed\n", q);
294 for (q = 0; q < txRings; q++) {
295 retval = rte_eth_tx_queue_setup(port, q, txRingSize,
296 rte_eth_dev_socket_id(port),
299 printf("initialise tx queue %d failed\n", q);
304 retval = rte_eth_dev_start(port);
306 printf("port %d start failed\n", port);
310 retval = rte_eth_macaddr_get(port, &vmdq_ports_eth_addr[port]);
312 printf("port %d MAC address get failed: %s\n", port,
313 rte_strerror(-retval));
316 printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
317 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
319 RTE_ETHER_ADDR_BYTES(&vmdq_ports_eth_addr[port]));
322 * Set mac for each pool.
323 * There is no default mac for the pools in i40.
324 * Removes this after i40e fixes this issue.
326 for (q = 0; q < num_pools; q++) {
327 struct rte_ether_addr mac;
328 mac = pool_addr_template;
329 mac.addr_bytes[4] = port;
330 mac.addr_bytes[5] = q;
331 printf("Port %u vmdq pool %u set mac " RTE_ETHER_ADDR_PRT_FMT "\n",
332 port, q, RTE_ETHER_ADDR_BYTES(&mac));
333 retval = rte_eth_dev_mac_addr_add(port, &mac,
336 printf("mac addr add failed at pool %d\n", q);
343 /* >8 End of get_eth_conf. */
345 /* Check num_pools parameter and set it if OK*/
347 vmdq_parse_num_pools(const char *q_arg)
352 /* parse number string */
353 n = strtol(q_arg, &end, 10);
354 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0'))
357 if (num_pools > num_vlans) {
358 printf("num_pools %d > num_vlans %d\n", num_pools, num_vlans);
369 parse_portmask(const char *portmask)
374 /* parse hexadecimal string */
375 pm = strtoul(portmask, &end, 16);
376 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
384 vmdq_usage(const char *prgname)
386 printf("%s [EAL options] -- -p PORTMASK]\n"
387 " --nb-pools NP: number of pools\n"
388 " --enable-rss: enable RSS (disabled by default)\n",
392 /* Parse the argument (num_pools) given in the command line of the application */
394 vmdq_parse_args(int argc, char **argv)
399 const char *prgname = argv[0];
400 static struct option long_option[] = {
401 {"nb-pools", required_argument, NULL, 0},
402 {"enable-rss", 0, NULL, 0},
406 /* Parse command line */
407 while ((opt = getopt_long(argc, argv, "p:", long_option,
408 &option_index)) != EOF) {
412 enabled_port_mask = parse_portmask(optarg);
413 if (enabled_port_mask == 0) {
414 printf("invalid portmask\n");
420 if (!strcmp(long_option[option_index].name,
422 if (vmdq_parse_num_pools(optarg) == -1) {
423 printf("invalid number of pools\n");
429 if (!strcmp(long_option[option_index].name,
440 for (i = 0; i < RTE_MAX_ETHPORTS; i++) {
441 if (enabled_port_mask & (1 << i))
442 ports[num_ports++] = (uint8_t)i;
445 if (num_ports < 2 || num_ports % 2) {
446 printf("Current enabled port number is %u,"
447 "but it should be even and at least 2\n", num_ports);
455 update_mac_address(struct rte_mbuf *m, unsigned dst_port)
457 struct rte_ether_hdr *eth;
460 eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
462 /* 02:00:00:00:00:xx */
463 tmp = ð->dst_addr.addr_bytes[0];
464 *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
467 rte_ether_addr_copy(&vmdq_ports_eth_addr[dst_port], ð->src_addr);
470 /* When we receive a HUP signal, print out our stats */
472 sighup_handler(int signum)
474 unsigned int q = vmdq_queue_base;
475 for (; q < num_queues; q++) {
476 if ((q - vmdq_queue_base) % (num_vmdq_queues / num_pools) == 0)
477 printf("\nPool %u: ", (q - vmdq_queue_base) /
478 (num_vmdq_queues / num_pools));
479 printf("%lu ", rxPackets[q]);
481 printf("\nFinished handling signal %d\n", signum);
485 * Main thread that does the work, reading from INPUT_PORT
486 * and writing to OUTPUT_PORT
489 lcore_main(__rte_unused void *dummy)
491 const uint16_t lcore_id = (uint16_t)rte_lcore_id();
492 const uint16_t num_cores = (uint16_t)rte_lcore_count();
493 uint16_t core_id = 0;
494 uint16_t startQueue, endQueue;
496 const uint16_t remainder = (uint16_t)(num_vmdq_queues % num_cores);
498 for (i = 0; i < num_cores; i++)
499 if (lcore_ids[i] == lcore_id) {
504 if (remainder != 0) {
505 if (core_id < remainder) {
506 startQueue = (uint16_t)(core_id *
507 (num_vmdq_queues / num_cores + 1));
508 endQueue = (uint16_t)(startQueue +
509 (num_vmdq_queues / num_cores) + 1);
511 startQueue = (uint16_t)(core_id *
512 (num_vmdq_queues / num_cores) +
514 endQueue = (uint16_t)(startQueue +
515 (num_vmdq_queues / num_cores));
518 startQueue = (uint16_t)(core_id *
519 (num_vmdq_queues / num_cores));
520 endQueue = (uint16_t)(startQueue +
521 (num_vmdq_queues / num_cores));
524 /* vmdq queue idx doesn't always start from zero.*/
525 startQueue += vmdq_queue_base;
526 endQueue += vmdq_queue_base;
527 printf("core %u(lcore %u) reading queues %i-%i\n", (unsigned)core_id,
528 (unsigned)lcore_id, startQueue, endQueue - 1);
530 if (startQueue == endQueue) {
531 printf("lcore %u has nothing to do\n", lcore_id);
536 struct rte_mbuf *buf[MAX_PKT_BURST];
537 const uint16_t buf_size = RTE_DIM(buf);
539 for (p = 0; p < num_ports; p++) {
540 const uint8_t sport = ports[p];
541 /* 0 <-> 1, 2 <-> 3 etc */
542 const uint8_t dport = ports[p ^ 1];
543 if ((sport == INVALID_PORT_ID) || (dport == INVALID_PORT_ID))
546 for (q = startQueue; q < endQueue; q++) {
547 const uint16_t rxCount = rte_eth_rx_burst(sport,
550 if (unlikely(rxCount == 0))
553 rxPackets[q] += rxCount;
555 for (i = 0; i < rxCount; i++)
556 update_mac_address(buf[i], dport);
558 const uint16_t txCount = rte_eth_tx_burst(dport,
559 vmdq_queue_base + core_id,
563 if (txCount != rxCount) {
564 for (i = txCount; i < rxCount; i++)
565 rte_pktmbuf_free(buf[i]);
573 * Update the global var NUM_PORTS and array PORTS according to system ports number
574 * and return valid ports number
576 static unsigned check_ports_num(unsigned nb_ports)
578 unsigned valid_num_ports = num_ports;
581 if (num_ports > nb_ports) {
582 printf("\nSpecified port number(%u) exceeds total system port number(%u)\n",
583 num_ports, nb_ports);
584 num_ports = nb_ports;
587 for (portid = 0; portid < num_ports; portid++) {
588 if (!rte_eth_dev_is_valid_port(ports[portid])) {
589 printf("\nSpecified port ID(%u) is not valid\n",
591 ports[portid] = INVALID_PORT_ID;
595 return valid_num_ports;
598 /* Main function, does initialisation and calls the per-lcore functions */
600 main(int argc, char *argv[])
602 struct rte_mempool *mbuf_pool;
603 unsigned lcore_id, core_id = 0;
605 unsigned nb_ports, valid_num_ports;
608 signal(SIGHUP, sighup_handler);
611 ret = rte_eal_init(argc, argv);
613 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
617 /* parse app arguments */
618 ret = vmdq_parse_args(argc, argv);
620 rte_exit(EXIT_FAILURE, "Invalid VMDQ argument\n");
622 for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++)
623 if (rte_lcore_is_enabled(lcore_id))
624 lcore_ids[core_id++] = lcore_id;
626 if (rte_lcore_count() > RTE_MAX_LCORE)
627 rte_exit(EXIT_FAILURE, "Not enough cores\n");
629 nb_ports = rte_eth_dev_count_avail();
632 * Update the global var NUM_PORTS and global array PORTS
633 * and get value of var VALID_NUM_PORTS according to system ports number
635 valid_num_ports = check_ports_num(nb_ports);
637 if (valid_num_ports < 2 || valid_num_ports % 2) {
638 printf("Current valid ports number is %u\n", valid_num_ports);
639 rte_exit(EXIT_FAILURE, "Error with valid ports number is not even or less than 2\n");
642 mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
643 NUM_MBUFS_PER_PORT * nb_ports, MBUF_CACHE_SIZE,
644 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
645 if (mbuf_pool == NULL)
646 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
648 /* initialize all ports */
649 RTE_ETH_FOREACH_DEV(portid) {
650 /* skip ports that are not enabled */
651 if ((enabled_port_mask & (1 << portid)) == 0) {
652 printf("\nSkipping disabled port %d\n", portid);
655 if (port_init(portid, mbuf_pool) != 0)
656 rte_exit(EXIT_FAILURE, "Cannot initialize network ports\n");
659 /* call lcore_main() on every lcore */
660 rte_eal_mp_remote_launch(lcore_main, NULL, CALL_MAIN);
661 RTE_LCORE_FOREACH_WORKER(lcore_id) {
662 if (rte_eal_wait_lcore(lcore_id) < 0)
666 /* clean up the EAL */