4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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.
35 #include <sys/queue.h>
46 #include <rte_common.h>
48 #include <rte_memory.h>
49 #include <rte_memcpy.h>
50 #include <rte_memzone.h>
52 #include <rte_per_lcore.h>
53 #include <rte_launch.h>
54 #include <rte_atomic.h>
55 #include <rte_cycles.h>
56 #include <rte_prefetch.h>
57 #include <rte_lcore.h>
58 #include <rte_per_lcore.h>
59 #include <rte_branch_prediction.h>
60 #include <rte_interrupts.h>
62 #include <rte_random.h>
63 #include <rte_debug.h>
64 #include <rte_ether.h>
65 #include <rte_ethdev.h>
67 #include <rte_mempool.h>
69 #include <rte_memcpy.h>
71 /* basic constants used in application */
72 #define MAX_QUEUES 1024
74 * 1024 queues require to meet the needs of a large number of vmdq_pools.
75 * (RX/TX_queue_nb * RX/TX_ring_descriptors_nb) per port.
77 #define NUM_MBUFS_PER_PORT (MAX_QUEUES * RTE_MAX(RTE_TEST_RX_DESC_DEFAULT, \
78 RTE_TEST_TX_DESC_DEFAULT))
79 #define MBUF_CACHE_SIZE 64
81 #define MAX_PKT_BURST 32
84 * Configurable number of RX/TX ring descriptors
86 #define RTE_TEST_RX_DESC_DEFAULT 128
87 #define RTE_TEST_TX_DESC_DEFAULT 512
89 #define INVALID_PORT_ID 0xFF
91 /* mask of enabled ports */
92 static uint32_t enabled_port_mask;
93 static uint8_t ports[RTE_MAX_ETHPORTS];
94 static unsigned num_ports;
96 /* number of pools (if user does not specify any, 32 by default */
97 static enum rte_eth_nb_pools num_pools = ETH_32_POOLS;
98 static enum rte_eth_nb_tcs num_tcs = ETH_4_TCS;
99 static uint16_t num_queues, num_vmdq_queues;
100 static uint16_t vmdq_pool_base, vmdq_queue_base;
101 static uint8_t rss_enable;
103 /* empty vmdq+dcb configuration structure. Filled in programatically */
104 static const struct rte_eth_conf vmdq_dcb_conf_default = {
106 .mq_mode = ETH_MQ_RX_VMDQ_DCB,
108 .header_split = 0, /**< Header Split disabled */
109 .hw_ip_checksum = 0, /**< IP checksum offload disabled */
110 .hw_vlan_filter = 0, /**< VLAN filtering disabled */
111 .jumbo_frame = 0, /**< Jumbo Frame Support disabled */
114 .mq_mode = ETH_MQ_TX_VMDQ_DCB,
117 * should be overridden separately in code with
122 .nb_queue_pools = ETH_32_POOLS,
123 .enable_default_pool = 0,
126 .pool_map = {{0, 0},},
131 /** Traffic class each UP mapped to. */
135 .nb_queue_pools = ETH_32_POOLS,
136 .enable_default_pool = 0,
139 .pool_map = {{0, 0},},
143 .vmdq_dcb_tx_conf = {
144 .nb_queue_pools = ETH_32_POOLS,
150 /* array used for printing out statistics */
151 volatile unsigned long rxPackets[MAX_QUEUES] = {0};
153 const uint16_t vlan_tags[] = {
154 0, 1, 2, 3, 4, 5, 6, 7,
155 8, 9, 10, 11, 12, 13, 14, 15,
156 16, 17, 18, 19, 20, 21, 22, 23,
157 24, 25, 26, 27, 28, 29, 30, 31
160 const uint16_t num_vlans = RTE_DIM(vlan_tags);
161 /* pool mac addr template, pool mac addr is like: 52 54 00 12 port# pool# */
162 static struct ether_addr pool_addr_template = {
163 .addr_bytes = {0x52, 0x54, 0x00, 0x12, 0x00, 0x00}
166 /* ethernet addresses of ports */
167 static struct ether_addr vmdq_ports_eth_addr[RTE_MAX_ETHPORTS];
169 /* Builds up the correct configuration for vmdq+dcb based on the vlan tags array
170 * given above, and the number of traffic classes available for use. */
172 get_eth_conf(struct rte_eth_conf *eth_conf)
174 struct rte_eth_vmdq_dcb_conf conf;
175 struct rte_eth_vmdq_rx_conf vmdq_conf;
176 struct rte_eth_dcb_rx_conf dcb_conf;
177 struct rte_eth_vmdq_dcb_tx_conf tx_conf;
180 conf.nb_queue_pools = (enum rte_eth_nb_pools)num_pools;
181 vmdq_conf.nb_queue_pools = (enum rte_eth_nb_pools)num_pools;
182 tx_conf.nb_queue_pools = (enum rte_eth_nb_pools)num_pools;
183 conf.nb_pool_maps = num_pools;
184 vmdq_conf.nb_pool_maps = num_pools;
185 conf.enable_default_pool = 0;
186 vmdq_conf.enable_default_pool = 0;
187 conf.default_pool = 0; /* set explicit value, even if not used */
188 vmdq_conf.default_pool = 0;
190 for (i = 0; i < conf.nb_pool_maps; i++) {
191 conf.pool_map[i].vlan_id = vlan_tags[i];
192 vmdq_conf.pool_map[i].vlan_id = vlan_tags[i];
193 conf.pool_map[i].pools = 1UL << i;
194 vmdq_conf.pool_map[i].pools = 1UL << i;
196 for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++){
197 conf.dcb_tc[i] = i % num_tcs;
198 dcb_conf.dcb_tc[i] = i % num_tcs;
199 tx_conf.dcb_tc[i] = i % num_tcs;
201 dcb_conf.nb_tcs = (enum rte_eth_nb_tcs)num_tcs;
202 (void)(rte_memcpy(eth_conf, &vmdq_dcb_conf_default, sizeof(*eth_conf)));
203 (void)(rte_memcpy(ð_conf->rx_adv_conf.vmdq_dcb_conf, &conf,
205 (void)(rte_memcpy(ð_conf->rx_adv_conf.dcb_rx_conf, &dcb_conf,
207 (void)(rte_memcpy(ð_conf->rx_adv_conf.vmdq_rx_conf, &vmdq_conf,
209 (void)(rte_memcpy(ð_conf->tx_adv_conf.vmdq_dcb_tx_conf, &tx_conf,
212 eth_conf->rxmode.mq_mode = ETH_MQ_RX_VMDQ_DCB_RSS;
213 eth_conf->rx_adv_conf.rss_conf.rss_hf = ETH_RSS_IP |
222 * Initialises a given port using global settings and with the rx buffers
223 * coming from the mbuf_pool passed as parameter
226 port_init(uint8_t port, struct rte_mempool *mbuf_pool)
228 struct rte_eth_dev_info dev_info;
229 struct rte_eth_conf port_conf = {0};
230 const uint16_t rxRingSize = RTE_TEST_RX_DESC_DEFAULT;
231 const uint16_t txRingSize = RTE_TEST_TX_DESC_DEFAULT;
234 uint16_t queues_per_pool;
235 uint32_t max_nb_pools;
238 * The max pool number from dev_info will be used to validate the pool
239 * number specified in cmd line
241 rte_eth_dev_info_get(port, &dev_info);
242 max_nb_pools = (uint32_t)dev_info.max_vmdq_pools;
244 * We allow to process part of VMDQ pools specified by num_pools in
247 if (num_pools > max_nb_pools) {
248 printf("num_pools %d >max_nb_pools %d\n",
249 num_pools, max_nb_pools);
254 * NIC queues are divided into pf queues and vmdq queues.
255 * There is assumption here all ports have the same configuration!
257 vmdq_queue_base = dev_info.vmdq_queue_base;
258 vmdq_pool_base = dev_info.vmdq_pool_base;
259 printf("vmdq queue base: %d pool base %d\n",
260 vmdq_queue_base, vmdq_pool_base);
261 if (vmdq_pool_base == 0) {
262 num_vmdq_queues = dev_info.max_rx_queues;
263 num_queues = dev_info.max_rx_queues;
264 if (num_tcs != num_vmdq_queues / num_pools) {
265 printf("nb_tcs %d is invalid considering with"
266 " nb_pools %d, nb_tcs * nb_pools should = %d\n",
267 num_tcs, num_pools, num_vmdq_queues);
271 queues_per_pool = dev_info.vmdq_queue_num /
272 dev_info.max_vmdq_pools;
273 if (num_tcs > queues_per_pool) {
274 printf("num_tcs %d > num of queues per pool %d\n",
275 num_tcs, queues_per_pool);
278 num_vmdq_queues = num_pools * queues_per_pool;
279 num_queues = vmdq_queue_base + num_vmdq_queues;
280 printf("Configured vmdq pool num: %u,"
281 " each vmdq pool has %u queues\n",
282 num_pools, queues_per_pool);
285 if (port >= rte_eth_dev_count())
288 retval = get_eth_conf(&port_conf);
293 * Though in this example, all queues including pf queues are setup.
294 * This is because VMDQ queues doesn't always start from zero, and the
295 * PMD layer doesn't support selectively initialising part of rx/tx
298 retval = rte_eth_dev_configure(port, num_queues, num_queues, &port_conf);
302 for (q = 0; q < num_queues; q++) {
303 retval = rte_eth_rx_queue_setup(port, q, rxRingSize,
304 rte_eth_dev_socket_id(port),
308 printf("initialize rx queue %d failed\n", q);
313 for (q = 0; q < num_queues; q++) {
314 retval = rte_eth_tx_queue_setup(port, q, txRingSize,
315 rte_eth_dev_socket_id(port),
318 printf("initialize tx queue %d failed\n", q);
323 retval = rte_eth_dev_start(port);
325 printf("port %d start failed\n", port);
329 rte_eth_macaddr_get(port, &vmdq_ports_eth_addr[port]);
330 printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
331 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
333 vmdq_ports_eth_addr[port].addr_bytes[0],
334 vmdq_ports_eth_addr[port].addr_bytes[1],
335 vmdq_ports_eth_addr[port].addr_bytes[2],
336 vmdq_ports_eth_addr[port].addr_bytes[3],
337 vmdq_ports_eth_addr[port].addr_bytes[4],
338 vmdq_ports_eth_addr[port].addr_bytes[5]);
340 /* Set mac for each pool.*/
341 for (q = 0; q < num_pools; q++) {
342 struct ether_addr mac;
344 mac = pool_addr_template;
345 mac.addr_bytes[4] = port;
346 mac.addr_bytes[5] = q;
347 printf("Port %u vmdq pool %u set mac %02x:%02x:%02x:%02x:%02x:%02x\n",
349 mac.addr_bytes[0], mac.addr_bytes[1],
350 mac.addr_bytes[2], mac.addr_bytes[3],
351 mac.addr_bytes[4], mac.addr_bytes[5]);
352 retval = rte_eth_dev_mac_addr_add(port, &mac,
355 printf("mac addr add failed at pool %d\n", q);
363 /* Check num_pools parameter and set it if OK*/
365 vmdq_parse_num_pools(const char *q_arg)
370 /* parse number string */
371 n = strtol(q_arg, &end, 10);
372 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0'))
374 if (n != 16 && n != 32)
377 num_pools = ETH_16_POOLS;
379 num_pools = ETH_32_POOLS;
384 /* Check num_tcs parameter and set it if OK*/
386 vmdq_parse_num_tcs(const char *q_arg)
391 /* parse number string */
392 n = strtol(q_arg, &end, 10);
393 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0'))
396 if (n != 4 && n != 8)
407 parse_portmask(const char *portmask)
412 /* parse hexadecimal string */
413 pm = strtoul(portmask, &end, 16);
414 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
425 vmdq_usage(const char *prgname)
427 printf("%s [EAL options] -- -p PORTMASK]\n"
428 " --nb-pools NP: number of pools (32 default, 16)\n"
429 " --nb-tcs NP: number of TCs (4 default, 8)\n"
430 " --enable-rss: enable RSS (disabled by default)\n",
434 /* Parse the argument (num_pools) given in the command line of the application */
436 vmdq_parse_args(int argc, char **argv)
441 const char *prgname = argv[0];
442 static struct option long_option[] = {
443 {"nb-pools", required_argument, NULL, 0},
444 {"nb-tcs", required_argument, NULL, 0},
445 {"enable-rss", 0, NULL, 0},
449 /* Parse command line */
450 while ((opt = getopt_long(argc, argv, "p:", long_option,
451 &option_index)) != EOF) {
455 enabled_port_mask = parse_portmask(optarg);
456 if (enabled_port_mask == 0) {
457 printf("invalid portmask\n");
463 if (!strcmp(long_option[option_index].name, "nb-pools")) {
464 if (vmdq_parse_num_pools(optarg) == -1) {
465 printf("invalid number of pools\n");
470 if (!strcmp(long_option[option_index].name, "nb-tcs")) {
471 if (vmdq_parse_num_tcs(optarg) == -1) {
472 printf("invalid number of tcs\n");
477 if (!strcmp(long_option[option_index].name, "enable-rss"))
487 for (i = 0; i < RTE_MAX_ETHPORTS; i++) {
488 if (enabled_port_mask & (1 << i))
489 ports[num_ports++] = (uint8_t)i;
492 if (num_ports < 2 || num_ports % 2) {
493 printf("Current enabled port number is %u,"
494 " but it should be even and at least 2\n", num_ports);
502 update_mac_address(struct rte_mbuf *m, unsigned dst_port)
504 struct ether_hdr *eth;
507 eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
509 /* 02:00:00:00:00:xx */
510 tmp = ð->d_addr.addr_bytes[0];
511 *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
514 ether_addr_copy(&vmdq_ports_eth_addr[dst_port], ð->s_addr);
517 /* When we receive a HUP signal, print out our stats */
519 sighup_handler(int signum)
521 unsigned q = vmdq_queue_base;
523 for (; q < num_queues; q++) {
524 if (q % (num_vmdq_queues / num_pools) == 0)
525 printf("\nPool %u: ", (q - vmdq_queue_base) /
526 (num_vmdq_queues / num_pools));
527 printf("%lu ", rxPackets[q]);
529 printf("\nFinished handling signal %d\n", signum);
533 * Main thread that does the work, reading from INPUT_PORT
534 * and writing to OUTPUT_PORT
537 lcore_main(void *arg)
539 const uintptr_t core_num = (uintptr_t)arg;
540 const unsigned num_cores = rte_lcore_count();
541 uint16_t startQueue, endQueue;
543 const uint16_t quot = (uint16_t)(num_vmdq_queues / num_cores);
544 const uint16_t remainder = (uint16_t)(num_vmdq_queues % num_cores);
548 if (core_num < remainder) {
549 startQueue = (uint16_t)(core_num * (quot + 1));
550 endQueue = (uint16_t)(startQueue + quot + 1);
552 startQueue = (uint16_t)(core_num * quot + remainder);
553 endQueue = (uint16_t)(startQueue + quot);
556 startQueue = (uint16_t)(core_num * quot);
557 endQueue = (uint16_t)(startQueue + quot);
560 /* vmdq queue idx doesn't always start from zero.*/
561 startQueue += vmdq_queue_base;
562 endQueue += vmdq_queue_base;
563 printf("Core %u(lcore %u) reading queues %i-%i\n", (unsigned)core_num,
564 rte_lcore_id(), startQueue, endQueue - 1);
566 if (startQueue == endQueue) {
567 printf("lcore %u has nothing to do\n", (unsigned)core_num);
572 struct rte_mbuf *buf[MAX_PKT_BURST];
573 const uint16_t buf_size = sizeof(buf) / sizeof(buf[0]);
574 for (p = 0; p < num_ports; p++) {
575 const uint8_t src = ports[p];
576 const uint8_t dst = ports[p ^ 1]; /* 0 <-> 1, 2 <-> 3 etc */
578 if ((src == INVALID_PORT_ID) || (dst == INVALID_PORT_ID))
581 for (q = startQueue; q < endQueue; q++) {
582 const uint16_t rxCount = rte_eth_rx_burst(src,
585 if (unlikely(rxCount == 0))
588 rxPackets[q] += rxCount;
590 for (i = 0; i < rxCount; i++)
591 update_mac_address(buf[i], dst);
593 const uint16_t txCount = rte_eth_tx_burst(dst,
595 if (txCount != rxCount) {
596 for (i = txCount; i < rxCount; i++)
597 rte_pktmbuf_free(buf[i]);
605 * Update the global var NUM_PORTS and array PORTS according to system ports number
606 * and return valid ports number
608 static unsigned check_ports_num(unsigned nb_ports)
610 unsigned valid_num_ports = num_ports;
613 if (num_ports > nb_ports) {
614 printf("\nSpecified port number(%u) exceeds total system port number(%u)\n",
615 num_ports, nb_ports);
616 num_ports = nb_ports;
619 for (portid = 0; portid < num_ports; portid++) {
620 if (ports[portid] >= nb_ports) {
621 printf("\nSpecified port ID(%u) exceeds max system port ID(%u)\n",
622 ports[portid], (nb_ports - 1));
623 ports[portid] = INVALID_PORT_ID;
627 return valid_num_ports;
631 /* Main function, does initialisation and calls the per-lcore functions */
633 main(int argc, char *argv[])
636 struct rte_mempool *mbuf_pool;
640 unsigned nb_ports, valid_num_ports;
643 signal(SIGHUP, sighup_handler);
646 ret = rte_eal_init(argc, argv);
648 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
652 /* parse app arguments */
653 ret = vmdq_parse_args(argc, argv);
655 rte_exit(EXIT_FAILURE, "Invalid VMDQ argument\n");
657 cores = rte_lcore_count();
658 if ((cores & (cores - 1)) != 0 || cores > RTE_MAX_LCORE) {
659 rte_exit(EXIT_FAILURE,"This program can only run on an even"
660 " number of cores(1-%d)\n\n", RTE_MAX_LCORE);
663 nb_ports = rte_eth_dev_count();
666 * Update the global var NUM_PORTS and global array PORTS
667 * and get value of var VALID_NUM_PORTS according to system ports number
669 valid_num_ports = check_ports_num(nb_ports);
671 if (valid_num_ports < 2 || valid_num_ports % 2) {
672 printf("Current valid ports number is %u\n", valid_num_ports);
673 rte_exit(EXIT_FAILURE, "Error with valid ports number is not even or less than 2\n");
676 mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
677 NUM_MBUFS_PER_PORT * nb_ports, MBUF_CACHE_SIZE,
678 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
679 if (mbuf_pool == NULL)
680 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
682 /* initialize all ports */
683 for (portid = 0; portid < nb_ports; portid++) {
684 /* skip ports that are not enabled */
685 if ((enabled_port_mask & (1 << portid)) == 0) {
686 printf("\nSkipping disabled port %d\n", portid);
689 if (port_init(portid, mbuf_pool) != 0)
690 rte_exit(EXIT_FAILURE, "Cannot initialize network ports\n");
693 /* call lcore_main() on every slave lcore */
695 RTE_LCORE_FOREACH_SLAVE(lcore_id) {
696 rte_eal_remote_launch(lcore_main, (void*)i++, lcore_id);
698 /* call on master too */
699 (void) lcore_main((void*)i);