examples/vmdq_dcb: new port mask parameter

Signed-off-by: Intel

diff --git a/examples/vmdq_dcb/main.c b/examples/vmdq_dcb/main.c
index 67c6e88..3fbb297 100644 (file)
--- a/examples/vmdq_dcb/main.c
+++ b/examples/vmdq_dcb/main.c
@@ -79,8 +79,10 @@
 #define MBUF_CACHE_SIZE 64
 #define MBUF_SIZE (2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM)
 
-#define RX_PORT 0
-#define TX_PORT 1
+#define INVALID_PORT_ID 0xFF
+
+/* mask of enabled ports */
+static uint32_t enabled_port_mask = 0;
 
 /* number of pools (if user does not specify any, 16 by default */
 static enum rte_eth_nb_pools num_pools = ETH_16_POOLS;
@@ -144,6 +146,9 @@ static const struct rte_eth_conf vmdq_dcb_conf_default = {
        },
 };
 
+static uint8_t ports[RTE_MAX_ETHPORTS];
+static unsigned num_ports = 0;
+
 /* array used for printing out statistics */
 volatile unsigned long rxPackets[ NUM_QUEUES ] = {0};
 
@@ -256,12 +261,29 @@ vmdq_parse_num_pools(const char *q_arg)
        return 0;
 }
 
+static int
+parse_portmask(const char *portmask)
+{
+       char *end = NULL;
+       unsigned long pm;
+
+       /* parse hexadecimal string */
+       pm = strtoul(portmask, &end, 16);
+       if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
+               return -1;
+
+       if (pm == 0)
+               return -1;
+
+       return pm;
+}
+
 /* Display usage */
 static void
 vmdq_usage(const char *prgname)
 {
-       printf("%s [EAL options] -- [-nb-pools NP]\n"
-              "  -nb-pools NP: number of pools (16 default, 32)\n",
+       printf("%s [EAL options] -- -p PORTMASK]\n"
+              "  --nb-pools NP: number of pools (16 default, 32)\n",
               prgname);
 }
 
@@ -271,16 +293,25 @@ vmdq_parse_args(int argc, char **argv)
 {
        int opt;
        int option_index;
+       unsigned i;
        const char *prgname = argv[0];
-
        static struct option long_option[] = {
                {"nb-pools", required_argument, NULL, 0},
                {NULL, 0, 0, 0}
        };
 
        /* Parse command line */
-       while ((opt = getopt_long_only(argc, argv, "",long_option,&option_index)) != EOF) {
+       while ((opt = getopt_long(argc, argv, "p:",long_option,&option_index)) != EOF) {
                switch (opt) {
+               /* portmask */
+               case 'p':
+                       enabled_port_mask = parse_portmask(optarg);
+                       if (enabled_port_mask == 0) {
+                               printf("invalid portmask\n");
+                               vmdq_usage(prgname);
+                               return -1;
+                       }
+                       break;
                case 0:
                        if (vmdq_parse_num_pools(optarg) == -1){
                                printf("invalid number of pools\n");
@@ -293,9 +324,20 @@ vmdq_parse_args(int argc, char **argv)
                        return -1;
                }
        }
-       return 0;
 
+       for(i = 0; i < RTE_MAX_ETHPORTS; i++)
+       {
+               if (enabled_port_mask & (1 << i))
+                       ports[num_ports++] = (uint8_t)i;
+       }
+
+       if (num_ports < 2 || num_ports % 2) {
+               printf("Current enabled port number is %u,"
+                       "but it should be even and at least 2\n",num_ports);
+               return -1;
+       }
 
+       return 0;
 }
 
 
@@ -325,32 +367,66 @@ lcore_main(void *arg)
        const unsigned num_cores = rte_lcore_count();
        uint16_t startQueue = (uint16_t)(core_num * (NUM_QUEUES/num_cores));
        uint16_t endQueue = (uint16_t)(startQueue + (NUM_QUEUES/num_cores));
-       uint16_t q, i;
-
+       uint16_t q, i, p;
+       
        printf("Core %u(lcore %u) reading queues %i-%i\n", (unsigned)core_num,
               rte_lcore_id(), startQueue, endQueue - 1);
 
        for (;;) {
                struct rte_mbuf *buf[32];
                const uint16_t buf_size = sizeof(buf) / sizeof(buf[0]);
+               for (p = 0; p < num_ports; p++) {
+                       const uint8_t src = ports[p];
+                       const uint8_t dst = ports[p ^ 1]; /* 0 <-> 1, 2 <-> 3 etc */
 
-               for (q = startQueue; q < endQueue; q++) {
-                       const uint16_t rxCount = rte_eth_rx_burst(RX_PORT,
-                                       q, buf, buf_size);
-                       if (rxCount == 0)
+                       if ((src == INVALID_PORT_ID) || (dst == INVALID_PORT_ID))
                                continue;
-                       rxPackets[q] += rxCount;
 
-                       const uint16_t txCount = rte_eth_tx_burst(TX_PORT,
+                       for (q = startQueue; q < endQueue; q++) {
+                               const uint16_t rxCount = rte_eth_rx_burst(src,
+                                       q, buf, buf_size);
+                               if (rxCount == 0)
+                                       continue;
+                               rxPackets[q] += rxCount;
+
+                               const uint16_t txCount = rte_eth_tx_burst(dst,
                                        (uint16_t)core_num, buf, rxCount);
-                       if (txCount != rxCount) {
-                               for (i = txCount; i < rxCount; i++)
-                                       rte_pktmbuf_free(buf[i]);
+                               if (txCount != rxCount) {
+                                       for (i = txCount; i < rxCount; i++)
+                                               rte_pktmbuf_free(buf[i]);
+                               }
                        }
                }
        }
 }
 
+/* 
+ * Update the global var NUM_PORTS and array PORTS according to system ports number
+ * and return valid ports number
+ */
+static unsigned check_ports_num(unsigned nb_ports)
+{
+       unsigned valid_num_ports = num_ports;
+       unsigned portid;
+ 
+       if (num_ports > nb_ports) {
+               printf("\nSpecified port number(%u) exceeds total system port number(%u)\n",
+                       num_ports, nb_ports);
+               num_ports = nb_ports;
+       }
+ 
+       for (portid = 0; portid < num_ports; portid ++) {
+               if (ports[portid] >= nb_ports) {
+                       printf("\nSpecified port ID(%u) exceeds max system port ID(%u)\n",
+                               ports[portid], (nb_ports - 1));
+                       ports[portid] = INVALID_PORT_ID;
+                       valid_num_ports --;
+               }
+       }
+       return valid_num_ports;
+}
+
+
 /* Main function, does initialisation and calls the per-lcore functions */
 int
 MAIN(int argc, char *argv[])
@@ -360,6 +436,8 @@ MAIN(int argc, char *argv[])
        unsigned lcore_id;
        uintptr_t i;
        int ret;
+       unsigned nb_ports, valid_num_ports;
+       uint8_t portid;
 
 #ifndef RTE_EXEC_ENV_BAREMETAL
        signal(SIGHUP, sighup_handler);
@@ -380,14 +458,29 @@ MAIN(int argc, char *argv[])
        if (rte_ixgbe_pmd_init() != 0 ||
                        rte_eal_pci_probe() != 0)
                rte_exit(EXIT_FAILURE, "Error with NIC driver initialization\n");
-
+       
        cores = rte_lcore_count();
-       if ((cores & (cores - 1)) != 0 || cores > 16) {
-               rte_exit(EXIT_FAILURE,
-                        "This program can only run on 2,4,8 or 16 cores\n\n");
+       if ((cores & (cores - 1)) != 0 || cores > 128) {
+               rte_exit(EXIT_FAILURE,"This program can only run on an even"
+                               "number of cores(1-128)\n\n");
+       }
+       
+       nb_ports = rte_eth_dev_count();
+       if (nb_ports > RTE_MAX_ETHPORTS)
+               nb_ports = RTE_MAX_ETHPORTS;
+
+        /* 
+        * Update the global var NUM_PORTS and global array PORTS 
+        * and get value of var VALID_NUM_PORTS according to system ports number 
+        */
+       valid_num_ports = check_ports_num(nb_ports);
+ 
+       if (valid_num_ports < 2 || valid_num_ports % 2) {
+               printf("Current valid ports number is %u\n", valid_num_ports);
+               rte_exit(EXIT_FAILURE, "Error with valid ports number is not even or less than 2\n");
        }
 
-       mbuf_pool = rte_mempool_create("MBUF_POOL", NUM_MBUFS,
+       mbuf_pool = rte_mempool_create("MBUF_POOL", NUM_MBUFS * nb_ports,
                                       MBUF_SIZE, MBUF_CACHE_SIZE,
                                       sizeof(struct rte_pktmbuf_pool_private),
                                       rte_pktmbuf_pool_init, NULL,
@@ -396,9 +489,16 @@ MAIN(int argc, char *argv[])
        if (mbuf_pool == NULL)
                rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
 
-       if (port_init(RX_PORT, mbuf_pool) != 0 ||
-           port_init(TX_PORT, mbuf_pool) != 0)
-               rte_exit(EXIT_FAILURE, "Cannot initialize network ports\n");
+       /* initialize all ports */
+       for (portid = 0; portid < nb_ports; portid++) {
+               /* skip ports that are not enabled */
+               if ((enabled_port_mask & (1 << portid)) == 0) {
+                       printf("\nSkipping disabled port %d\n", portid);
+                       continue;
+               }
+               if (port_init(portid, mbuf_pool) != 0) 
+                       rte_exit(EXIT_FAILURE, "Cannot initialize network ports\n");
+       }
 
        /* call lcore_main() on every slave lcore */
        i = 0;