net: add rte prefix to ether structures

[dpdk.git] / app / pdump / main.c

diff --git a/app/pdump/main.c b/app/pdump/main.c
index ccf2a1d..80dc924 100644 (file)
--- a/app/pdump/main.c
+++ b/app/pdump/main.c
@@ -28,6 +28,9 @@
 #include <rte_pdump.h>
 
 #define CMD_LINE_OPT_PDUMP "pdump"
+#define CMD_LINE_OPT_PDUMP_NUM 256
+#define CMD_LINE_OPT_MULTI "multi"
+#define CMD_LINE_OPT_MULTI_NUM 257
 #define PDUMP_PORT_ARG "port"
 #define PDUMP_PCI_ARG "device_id"
 #define PDUMP_QUEUE_ARG "queue"
@@ -139,12 +142,15 @@ struct parse_val {
 static int num_tuples;
 static struct rte_eth_conf port_conf_default;
 static volatile uint8_t quit_signal;
+static uint8_t multiple_core_capture;
 
 /**< display usage */
 static void
 pdump_usage(const char *prgname)
 {
-       printf("usage: %s [EAL options] -- --pdump "
+       printf("usage: %s [EAL options]"
+                       " --["CMD_LINE_OPT_MULTI"]\n"
+                       " --"CMD_LINE_OPT_PDUMP" "
                        "'(port=<port id> | device_id=<pci id or vdev name>),"
                        "(queue=<queue_id>),"
                        "(rx-dev=<iface or pcap file> |"
@@ -189,12 +195,12 @@ parse_rxtxdev(const char *key, const char *value, void *extra_args)
        struct pdump_tuples *pt = extra_args;
 
        if (!strcmp(key, PDUMP_RX_DEV_ARG)) {
-               snprintf(pt->rx_dev, sizeof(pt->rx_dev), "%s", value);
+               strlcpy(pt->rx_dev, value, sizeof(pt->rx_dev));
                /* identify the tx stream type for pcap vdev */
                if (if_nametoindex(pt->rx_dev))
                        pt->rx_vdev_stream_type = IFACE;
        } else if (!strcmp(key, PDUMP_TX_DEV_ARG)) {
-               snprintf(pt->tx_dev, sizeof(pt->tx_dev), "%s", value);
+               strlcpy(pt->tx_dev, value, sizeof(pt->tx_dev));
                /* identify the tx stream type for pcap vdev */
                if (if_nametoindex(pt->tx_dev))
                        pt->tx_vdev_stream_type = IFACE;
@@ -375,7 +381,8 @@ launch_args_parse(int argc, char **argv, char *prgname)
        int opt, ret;
        int option_index;
        static struct option long_option[] = {
-               {"pdump", 1, 0, 0},
+               {CMD_LINE_OPT_PDUMP, 1, 0, CMD_LINE_OPT_PDUMP_NUM},
+               {CMD_LINE_OPT_MULTI, 0, 0, CMD_LINE_OPT_MULTI_NUM},
                {NULL, 0, 0, 0}
        };
 
@@ -386,17 +393,16 @@ launch_args_parse(int argc, char **argv, char *prgname)
        while ((opt = getopt_long(argc, argv, " ",
                        long_option, &option_index)) != EOF) {
                switch (opt) {
-               case 0:
-                       if (!strncmp(long_option[option_index].name,
-                                       CMD_LINE_OPT_PDUMP,
-                                       sizeof(CMD_LINE_OPT_PDUMP))) {
-                               ret = parse_pdump(optarg);
-                               if (ret) {
-                                       pdump_usage(prgname);
-                                       return -1;
-                               }
+               case CMD_LINE_OPT_PDUMP_NUM:
+                       ret = parse_pdump(optarg);
+                       if (ret) {
+                               pdump_usage(prgname);
+                               return -1;
                        }
                        break;
+               case CMD_LINE_OPT_MULTI_NUM:
+                       multiple_core_capture = 1;
+                       break;
                default:
                        pdump_usage(prgname);
                        return -1;
@@ -543,7 +549,7 @@ signal_handler(int sig_num)
 static inline int
 configure_vdev(uint16_t port_id)
 {
-       struct ether_addr addr;
+       struct rte_ether_addr addr;
        const uint16_t rxRings = 0, txRings = 1;
        int ret;
        uint16_t q;
@@ -834,23 +840,74 @@ enable_pdump(void)
        }
 }
 
+static inline void
+pdump_packets(struct pdump_tuples *pt)
+{
+       if (pt->dir & RTE_PDUMP_FLAG_RX)
+               pdump_rxtx(pt->rx_ring, pt->rx_vdev_id, &pt->stats);
+       if (pt->dir & RTE_PDUMP_FLAG_TX)
+               pdump_rxtx(pt->tx_ring, pt->tx_vdev_id, &pt->stats);
+}
+
+static int
+dump_packets_core(void *arg)
+{
+       struct pdump_tuples *pt = (struct pdump_tuples *) arg;
+
+       printf(" core (%u); port %u device (%s) queue %u\n",
+                       rte_lcore_id(), pt->port, pt->device_id, pt->queue);
+       fflush(stdout);
+
+       while (!quit_signal)
+               pdump_packets(pt);
+
+       return 0;
+}
+
 static inline void
 dump_packets(void)
 {
        int i;
-       struct pdump_tuples *pt;
+       uint32_t lcore_id = 0;
+
+       if (!multiple_core_capture) {
+               printf(" core (%u), capture for (%d) tuples\n",
+                               rte_lcore_id(), num_tuples);
+
+               for (i = 0; i < num_tuples; i++)
+                       printf(" - port %u device (%s) queue %u\n",
+                               pdump_t[i].port,
+                               pdump_t[i].device_id,
+                               pdump_t[i].queue);
 
-       while (!quit_signal) {
-               for (i = 0; i < num_tuples; i++) {
-                       pt = &pdump_t[i];
-                       if (pt->dir & RTE_PDUMP_FLAG_RX)
-                               pdump_rxtx(pt->rx_ring, pt->rx_vdev_id,
-                                       &pt->stats);
-                       if (pt->dir & RTE_PDUMP_FLAG_TX)
-                               pdump_rxtx(pt->tx_ring, pt->tx_vdev_id,
-                                       &pt->stats);
+               while (!quit_signal) {
+                       for (i = 0; i < num_tuples; i++)
+                               pdump_packets(&pdump_t[i]);
                }
+
+               return;
+       }
+
+       /* check if there enough core */
+       if ((uint32_t)num_tuples >= rte_lcore_count()) {
+               printf("Insufficient cores to run parallel!\n");
+               return;
        }
+
+       lcore_id = rte_get_next_lcore(lcore_id, 1, 0);
+
+       for (i = 0; i < num_tuples; i++) {
+               rte_eal_remote_launch(dump_packets_core,
+                               &pdump_t[i], lcore_id);
+               lcore_id = rte_get_next_lcore(lcore_id, 1, 0);
+
+               if (rte_eal_wait_lcore(lcore_id) < 0)
+                       rte_exit(EXIT_FAILURE, "failed to wait\n");
+       }
+
+       /* master core */
+       while (!quit_signal)
+               ;
 }
 
 int
@@ -860,23 +917,21 @@ main(int argc, char **argv)
        int ret;
        int i;
 
-       char c_flag[] = "-c1";
        char n_flag[] = "-n4";
        char mp_flag[] = "--proc-type=secondary";
-       char *argp[argc + 3];
+       char *argp[argc + 2];
 
        /* catch ctrl-c so we can print on exit */
        signal(SIGINT, signal_handler);
 
        argp[0] = argv[0];
-       argp[1] = c_flag;
-       argp[2] = n_flag;
-       argp[3] = mp_flag;
+       argp[1] = n_flag;
+       argp[2] = mp_flag;
 
        for (i = 1; i < argc; i++)
-               argp[i + 3] = argv[i];
+               argp[i + 2] = argv[i];
 
-       argc += 3;
+       argc += 2;
 
        diag = rte_eal_init(argc, argp);
        if (diag < 0)
@@ -886,7 +941,7 @@ main(int argc, char **argv)
                rte_exit(EXIT_FAILURE, "No Ethernet ports - bye\n");
 
        argc -= diag;
-       argv += (diag - 3);
+       argv += (diag - 2);
 
        /* parse app arguments */
        if (argc > 1) {