1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2016 Intel Corporation
16 #include <rte_common.h>
17 #include <rte_debug.h>
18 #include <rte_ethdev.h>
19 #include <rte_memory.h>
20 #include <rte_lcore.h>
21 #include <rte_branch_prediction.h>
22 #include <rte_errno.h>
24 #include <rte_kvargs.h>
25 #include <rte_mempool.h>
27 #include <rte_pdump.h>
29 #define CMD_LINE_OPT_PDUMP "pdump"
30 #define PDUMP_PORT_ARG "port"
31 #define PDUMP_PCI_ARG "device_id"
32 #define PDUMP_QUEUE_ARG "queue"
33 #define PDUMP_DIR_ARG "dir"
34 #define PDUMP_RX_DEV_ARG "rx-dev"
35 #define PDUMP_TX_DEV_ARG "tx-dev"
36 #define PDUMP_RING_SIZE_ARG "ring-size"
37 #define PDUMP_MSIZE_ARG "mbuf-size"
38 #define PDUMP_NUM_MBUFS_ARG "total-num-mbufs"
39 #define CMD_LINE_OPT_SER_SOCK_PATH "server-socket-path"
40 #define CMD_LINE_OPT_CLI_SOCK_PATH "client-socket-path"
42 #define VDEV_PCAP "net_pcap_%s_%d,tx_pcap=%s"
43 #define VDEV_IFACE "net_pcap_%s_%d,tx_iface=%s"
44 #define TX_STREAM_SIZE 64
46 #define MP_NAME "pdump_pool_%d"
48 #define RX_RING "rx_ring_%d"
49 #define TX_RING "tx_ring_%d"
54 /* Maximum long option length for option parsing. */
55 #define APP_ARG_TCPDUMP_MAX_TUPLES 54
56 #define MBUF_POOL_CACHE_SIZE 250
57 #define TX_DESC_PER_QUEUE 512
58 #define RX_DESC_PER_QUEUE 128
59 #define MBUFS_PER_POOL 65535
60 #define MAX_LONG_OPT_SZ 64
61 #define RING_SIZE 16384
66 /* true if x is a power of 2 */
67 #define POWEROF2(x) ((((x)-1) & (x)) == 0)
84 const char *valid_pdump_arguments[] = {
98 uint64_t dequeue_pkts;
103 struct pdump_tuples {
108 char rx_dev[TX_STREAM_SIZE];
109 char tx_dev[TX_STREAM_SIZE];
111 uint16_t mbuf_data_size;
112 uint32_t total_num_mbufs;
114 /* params for library API call */
116 struct rte_mempool *mp;
117 struct rte_ring *rx_ring;
118 struct rte_ring *tx_ring;
120 /* params for packet dumping */
121 enum pdump_by dump_by_type;
124 enum pcap_stream rx_vdev_stream_type;
125 enum pcap_stream tx_vdev_stream_type;
126 bool single_pdump_dev;
129 struct pdump_stats stats;
130 } __rte_cache_aligned;
131 static struct pdump_tuples pdump_t[APP_ARG_TCPDUMP_MAX_TUPLES];
140 static struct rte_eth_conf port_conf_default;
141 volatile uint8_t quit_signal;
142 static char server_socket_path[PATH_MAX];
143 static char client_socket_path[PATH_MAX];
145 /**< display usage */
147 pdump_usage(const char *prgname)
149 printf("usage: %s [EAL options] -- --pdump "
150 "'(port=<port id> | device_id=<pci id or vdev name>),"
151 "(queue=<queue_id>),"
152 "(rx-dev=<iface or pcap file> |"
153 " tx-dev=<iface or pcap file>,"
154 "[ring-size=<ring size>default:16384],"
155 "[mbuf-size=<mbuf data size>default:2176],"
156 "[total-num-mbufs=<number of mbufs>default:65535]'\n"
157 "[--server-socket-path=<server socket dir>"
158 "default:/var/run/.dpdk/ (or) ~/.dpdk/]\n"
159 "[--client-socket-path=<client socket dir>"
160 "default:/var/run/.dpdk/ (or) ~/.dpdk/]\n",
165 parse_device_id(const char *key __rte_unused, const char *value,
168 struct pdump_tuples *pt = extra_args;
170 pt->device_id = strdup(value);
171 pt->dump_by_type = DEVICE_ID;
177 parse_queue(const char *key __rte_unused, const char *value, void *extra_args)
180 struct pdump_tuples *pt = extra_args;
182 if (!strcmp(value, "*"))
183 pt->queue = RTE_PDUMP_ALL_QUEUES;
185 n = strtoul(value, NULL, 10);
186 pt->queue = (uint16_t) n;
192 parse_rxtxdev(const char *key, const char *value, void *extra_args)
195 struct pdump_tuples *pt = extra_args;
197 if (!strcmp(key, PDUMP_RX_DEV_ARG)) {
198 snprintf(pt->rx_dev, sizeof(pt->rx_dev), "%s", value);
199 /* identify the tx stream type for pcap vdev */
200 if (if_nametoindex(pt->rx_dev))
201 pt->rx_vdev_stream_type = IFACE;
202 } else if (!strcmp(key, PDUMP_TX_DEV_ARG)) {
203 snprintf(pt->tx_dev, sizeof(pt->tx_dev), "%s", value);
204 /* identify the tx stream type for pcap vdev */
205 if (if_nametoindex(pt->tx_dev))
206 pt->tx_vdev_stream_type = IFACE;
213 parse_uint_value(const char *key, const char *value, void *extra_args)
222 t = strtoul(value, &end, 10);
224 if (errno != 0 || end[0] != 0 || t < v->min || t > v->max) {
225 printf("invalid value:\"%s\" for key:\"%s\", "
226 "value must be >= %"PRIu64" and <= %"PRIu64"\n",
227 value, key, v->min, v->max);
230 if (!strcmp(key, PDUMP_RING_SIZE_ARG) && !POWEROF2(t)) {
231 printf("invalid value:\"%s\" for key:\"%s\", "
232 "value must be power of 2\n", value, key);
244 parse_pdump(const char *optarg)
246 struct rte_kvargs *kvlist;
247 int ret = 0, cnt1, cnt2;
248 struct pdump_tuples *pt;
249 struct parse_val v = {0};
251 pt = &pdump_t[num_tuples];
253 /* initial check for invalid arguments */
254 kvlist = rte_kvargs_parse(optarg, valid_pdump_arguments);
255 if (kvlist == NULL) {
256 printf("--pdump=\"%s\": invalid argument passed\n", optarg);
260 /* port/device_id parsing and validation */
261 cnt1 = rte_kvargs_count(kvlist, PDUMP_PORT_ARG);
262 cnt2 = rte_kvargs_count(kvlist, PDUMP_PCI_ARG);
263 if (!((cnt1 == 1 && cnt2 == 0) || (cnt1 == 0 && cnt2 == 1))) {
264 printf("--pdump=\"%s\": must have either port or "
265 "device_id argument\n", optarg);
268 } else if (cnt1 == 1) {
270 v.max = RTE_MAX_ETHPORTS-1;
271 ret = rte_kvargs_process(kvlist, PDUMP_PORT_ARG,
272 &parse_uint_value, &v);
275 pt->port = (uint8_t) v.val;
276 pt->dump_by_type = PORT_ID;
277 } else if (cnt2 == 1) {
278 ret = rte_kvargs_process(kvlist, PDUMP_PCI_ARG,
279 &parse_device_id, pt);
284 /* queue parsing and validation */
285 cnt1 = rte_kvargs_count(kvlist, PDUMP_QUEUE_ARG);
287 printf("--pdump=\"%s\": must have queue argument\n", optarg);
291 ret = rte_kvargs_process(kvlist, PDUMP_QUEUE_ARG, &parse_queue, pt);
295 /* rx-dev and tx-dev parsing and validation */
296 cnt1 = rte_kvargs_count(kvlist, PDUMP_RX_DEV_ARG);
297 cnt2 = rte_kvargs_count(kvlist, PDUMP_TX_DEV_ARG);
298 if (cnt1 == 0 && cnt2 == 0) {
299 printf("--pdump=\"%s\": must have either rx-dev or "
300 "tx-dev argument\n", optarg);
303 } else if (cnt1 == 1 && cnt2 == 1) {
304 ret = rte_kvargs_process(kvlist, PDUMP_RX_DEV_ARG,
308 ret = rte_kvargs_process(kvlist, PDUMP_TX_DEV_ARG,
312 /* if captured packets has to send to the same vdev */
313 if (!strcmp(pt->rx_dev, pt->tx_dev))
314 pt->single_pdump_dev = true;
315 pt->dir = RTE_PDUMP_FLAG_RXTX;
316 } else if (cnt1 == 1) {
317 ret = rte_kvargs_process(kvlist, PDUMP_RX_DEV_ARG,
321 pt->dir = RTE_PDUMP_FLAG_RX;
322 } else if (cnt2 == 1) {
323 ret = rte_kvargs_process(kvlist, PDUMP_TX_DEV_ARG,
327 pt->dir = RTE_PDUMP_FLAG_TX;
331 /* ring_size parsing and validation */
332 cnt1 = rte_kvargs_count(kvlist, PDUMP_RING_SIZE_ARG);
335 v.max = RTE_RING_SZ_MASK-1;
336 ret = rte_kvargs_process(kvlist, PDUMP_RING_SIZE_ARG,
337 &parse_uint_value, &v);
340 pt->ring_size = (uint32_t) v.val;
342 pt->ring_size = RING_SIZE;
344 /* mbuf_data_size parsing and validation */
345 cnt1 = rte_kvargs_count(kvlist, PDUMP_MSIZE_ARG);
349 ret = rte_kvargs_process(kvlist, PDUMP_MSIZE_ARG,
350 &parse_uint_value, &v);
353 pt->mbuf_data_size = (uint16_t) v.val;
355 pt->mbuf_data_size = RTE_MBUF_DEFAULT_BUF_SIZE;
357 /* total_num_mbufs parsing and validation */
358 cnt1 = rte_kvargs_count(kvlist, PDUMP_NUM_MBUFS_ARG);
362 ret = rte_kvargs_process(kvlist, PDUMP_NUM_MBUFS_ARG,
363 &parse_uint_value, &v);
366 pt->total_num_mbufs = (uint16_t) v.val;
368 pt->total_num_mbufs = MBUFS_PER_POOL;
373 rte_kvargs_free(kvlist);
377 /* Parse the argument given in the command line of the application */
379 launch_args_parse(int argc, char **argv, char *prgname)
383 static struct option long_option[] = {
385 {"server-socket-path", 1, 0, 0},
386 {"client-socket-path", 1, 0, 0},
391 pdump_usage(prgname);
393 /* Parse command line */
394 while ((opt = getopt_long(argc, argv, " ",
395 long_option, &option_index)) != EOF) {
398 if (!strncmp(long_option[option_index].name,
400 sizeof(CMD_LINE_OPT_PDUMP))) {
401 ret = parse_pdump(optarg);
403 pdump_usage(prgname);
408 if (!strncmp(long_option[option_index].name,
409 CMD_LINE_OPT_SER_SOCK_PATH,
410 sizeof(CMD_LINE_OPT_SER_SOCK_PATH))) {
411 snprintf(server_socket_path,
412 sizeof(server_socket_path), "%s",
416 if (!strncmp(long_option[option_index].name,
417 CMD_LINE_OPT_CLI_SOCK_PATH,
418 sizeof(CMD_LINE_OPT_CLI_SOCK_PATH))) {
419 snprintf(client_socket_path,
420 sizeof(client_socket_path), "%s",
426 pdump_usage(prgname);
435 print_pdump_stats(void)
438 struct pdump_tuples *pt;
440 for (i = 0; i < num_tuples; i++) {
441 printf("##### PDUMP DEBUG STATS #####\n");
443 printf(" -packets dequeued: %"PRIu64"\n",
444 pt->stats.dequeue_pkts);
445 printf(" -packets transmitted to vdev: %"PRIu64"\n",
447 printf(" -packets freed: %"PRIu64"\n",
448 pt->stats.freed_pkts);
453 disable_pdump(struct pdump_tuples *pt)
455 if (pt->dump_by_type == DEVICE_ID)
456 rte_pdump_disable_by_deviceid(pt->device_id, pt->queue,
458 else if (pt->dump_by_type == PORT_ID)
459 rte_pdump_disable(pt->port, pt->queue, pt->dir);
463 pdump_rxtx(struct rte_ring *ring, uint8_t vdev_id, struct pdump_stats *stats)
465 /* write input packets of port to vdev for pdump */
466 struct rte_mbuf *rxtx_bufs[BURST_SIZE];
468 /* first dequeue packets from ring of primary process */
469 const uint16_t nb_in_deq = rte_ring_dequeue_burst(ring,
470 (void *)rxtx_bufs, BURST_SIZE, NULL);
471 stats->dequeue_pkts += nb_in_deq;
474 /* then sent on vdev */
475 uint16_t nb_in_txd = rte_eth_tx_burst(
477 0, rxtx_bufs, nb_in_deq);
478 stats->tx_pkts += nb_in_txd;
480 if (unlikely(nb_in_txd < nb_in_deq)) {
482 rte_pktmbuf_free(rxtx_bufs[nb_in_txd]);
484 } while (++nb_in_txd < nb_in_deq);
490 free_ring_data(struct rte_ring *ring, uint8_t vdev_id,
491 struct pdump_stats *stats)
493 while (rte_ring_count(ring))
494 pdump_rxtx(ring, vdev_id, stats);
501 struct pdump_tuples *pt;
503 for (i = 0; i < num_tuples; i++) {
511 rte_ring_free(pt->rx_ring);
513 rte_ring_free(pt->tx_ring);
518 cleanup_pdump_resources(void)
521 struct pdump_tuples *pt;
523 /* disable pdump and free the pdump_tuple resources */
524 for (i = 0; i < num_tuples; i++) {
527 /* remove callbacks */
531 * transmit rest of the enqueued packets of the rings on to
532 * the vdev, in order to release mbufs to the mepool.
534 if (pt->dir & RTE_PDUMP_FLAG_RX)
535 free_ring_data(pt->rx_ring, pt->rx_vdev_id, &pt->stats);
536 if (pt->dir & RTE_PDUMP_FLAG_TX)
537 free_ring_data(pt->tx_ring, pt->tx_vdev_id, &pt->stats);
543 signal_handler(int sig_num)
545 if (sig_num == SIGINT) {
546 printf("\n\nSignal %d received, preparing to exit...\n",
553 configure_vdev(uint16_t port_id)
555 struct ether_addr addr;
556 const uint16_t rxRings = 0, txRings = 1;
557 const uint8_t nb_ports = rte_eth_dev_count();
561 if (port_id > nb_ports)
564 ret = rte_eth_dev_configure(port_id, rxRings, txRings,
567 rte_exit(EXIT_FAILURE, "dev config failed\n");
569 for (q = 0; q < txRings; q++) {
570 ret = rte_eth_tx_queue_setup(port_id, q, TX_DESC_PER_QUEUE,
571 rte_eth_dev_socket_id(port_id), NULL);
573 rte_exit(EXIT_FAILURE, "queue setup failed\n");
576 ret = rte_eth_dev_start(port_id);
578 rte_exit(EXIT_FAILURE, "dev start failed\n");
580 rte_eth_macaddr_get(port_id, &addr);
581 printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
582 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
584 addr.addr_bytes[0], addr.addr_bytes[1],
585 addr.addr_bytes[2], addr.addr_bytes[3],
586 addr.addr_bytes[4], addr.addr_bytes[5]);
588 rte_eth_promiscuous_enable(port_id);
594 create_mp_ring_vdev(void)
598 struct pdump_tuples *pt = NULL;
599 struct rte_mempool *mbuf_pool = NULL;
600 char vdev_args[SIZE];
601 char ring_name[SIZE];
602 char mempool_name[SIZE];
604 for (i = 0; i < num_tuples; i++) {
606 snprintf(mempool_name, SIZE, MP_NAME, i);
607 mbuf_pool = rte_mempool_lookup(mempool_name);
608 if (mbuf_pool == NULL) {
610 mbuf_pool = rte_pktmbuf_pool_create(mempool_name,
612 MBUF_POOL_CACHE_SIZE, 0,
615 if (mbuf_pool == NULL) {
617 rte_exit(EXIT_FAILURE,
618 "Mempool creation failed: %s\n",
619 rte_strerror(rte_errno));
624 if (pt->dir == RTE_PDUMP_FLAG_RXTX) {
625 /* if captured packets has to send to the same vdev */
627 snprintf(ring_name, SIZE, RX_RING, i);
628 pt->rx_ring = rte_ring_create(ring_name, pt->ring_size,
630 if (pt->rx_ring == NULL) {
632 rte_exit(EXIT_FAILURE, "%s:%s:%d\n",
633 rte_strerror(rte_errno),
638 snprintf(ring_name, SIZE, TX_RING, i);
639 pt->tx_ring = rte_ring_create(ring_name, pt->ring_size,
641 if (pt->tx_ring == NULL) {
643 rte_exit(EXIT_FAILURE, "%s:%s:%d\n",
644 rte_strerror(rte_errno),
649 (pt->rx_vdev_stream_type == IFACE) ?
650 snprintf(vdev_args, SIZE, VDEV_IFACE, RX_STR, i,
652 snprintf(vdev_args, SIZE, VDEV_PCAP, RX_STR, i,
654 if (rte_eth_dev_attach(vdev_args, &portid) < 0) {
656 rte_exit(EXIT_FAILURE,
657 "vdev creation failed:%s:%d\n",
660 pt->rx_vdev_id = portid;
663 configure_vdev(pt->rx_vdev_id);
665 if (pt->single_pdump_dev)
666 pt->tx_vdev_id = portid;
668 (pt->tx_vdev_stream_type == IFACE) ?
669 snprintf(vdev_args, SIZE, VDEV_IFACE, TX_STR, i,
671 snprintf(vdev_args, SIZE, VDEV_PCAP, TX_STR, i,
673 if (rte_eth_dev_attach(vdev_args,
676 rte_exit(EXIT_FAILURE,
677 "vdev creation failed:"
678 "%s:%d\n", __func__, __LINE__);
680 pt->tx_vdev_id = portid;
683 configure_vdev(pt->tx_vdev_id);
685 } else if (pt->dir == RTE_PDUMP_FLAG_RX) {
688 snprintf(ring_name, SIZE, RX_RING, i);
689 pt->rx_ring = rte_ring_create(ring_name, pt->ring_size,
691 if (pt->rx_ring == NULL) {
693 rte_exit(EXIT_FAILURE, "%s\n",
694 rte_strerror(rte_errno));
697 (pt->rx_vdev_stream_type == IFACE) ?
698 snprintf(vdev_args, SIZE, VDEV_IFACE, RX_STR, i,
700 snprintf(vdev_args, SIZE, VDEV_PCAP, RX_STR, i,
702 if (rte_eth_dev_attach(vdev_args, &portid) < 0) {
704 rte_exit(EXIT_FAILURE,
705 "vdev creation failed:%s:%d\n",
708 pt->rx_vdev_id = portid;
710 configure_vdev(pt->rx_vdev_id);
711 } else if (pt->dir == RTE_PDUMP_FLAG_TX) {
714 snprintf(ring_name, SIZE, TX_RING, i);
715 pt->tx_ring = rte_ring_create(ring_name, pt->ring_size,
717 if (pt->tx_ring == NULL) {
719 rte_exit(EXIT_FAILURE, "%s\n",
720 rte_strerror(rte_errno));
723 (pt->tx_vdev_stream_type == IFACE) ?
724 snprintf(vdev_args, SIZE, VDEV_IFACE, TX_STR, i,
726 snprintf(vdev_args, SIZE, VDEV_PCAP, TX_STR, i,
728 if (rte_eth_dev_attach(vdev_args, &portid) < 0) {
730 rte_exit(EXIT_FAILURE,
731 "vdev creation failed\n");
733 pt->tx_vdev_id = portid;
736 configure_vdev(pt->tx_vdev_id);
745 struct pdump_tuples *pt;
746 int ret = 0, ret1 = 0;
748 if (server_socket_path[0] != 0)
749 ret = rte_pdump_set_socket_dir(server_socket_path,
750 RTE_PDUMP_SOCKET_SERVER);
751 if (ret == 0 && client_socket_path[0] != 0) {
752 ret = rte_pdump_set_socket_dir(client_socket_path,
753 RTE_PDUMP_SOCKET_CLIENT);
756 cleanup_pdump_resources();
757 rte_exit(EXIT_FAILURE,
758 "failed to set socket paths of server:%s, "
764 for (i = 0; i < num_tuples; i++) {
766 if (pt->dir == RTE_PDUMP_FLAG_RXTX) {
767 if (pt->dump_by_type == DEVICE_ID) {
768 ret = rte_pdump_enable_by_deviceid(
774 ret1 = rte_pdump_enable_by_deviceid(
780 } else if (pt->dump_by_type == PORT_ID) {
781 ret = rte_pdump_enable(pt->port, pt->queue,
783 pt->rx_ring, pt->mp, NULL);
784 ret1 = rte_pdump_enable(pt->port, pt->queue,
786 pt->tx_ring, pt->mp, NULL);
788 } else if (pt->dir == RTE_PDUMP_FLAG_RX) {
789 if (pt->dump_by_type == DEVICE_ID)
790 ret = rte_pdump_enable_by_deviceid(
793 pt->dir, pt->rx_ring,
795 else if (pt->dump_by_type == PORT_ID)
796 ret = rte_pdump_enable(pt->port, pt->queue,
798 pt->rx_ring, pt->mp, NULL);
799 } else if (pt->dir == RTE_PDUMP_FLAG_TX) {
800 if (pt->dump_by_type == DEVICE_ID)
801 ret = rte_pdump_enable_by_deviceid(
805 pt->tx_ring, pt->mp, NULL);
806 else if (pt->dump_by_type == PORT_ID)
807 ret = rte_pdump_enable(pt->port, pt->queue,
809 pt->tx_ring, pt->mp, NULL);
811 if (ret < 0 || ret1 < 0) {
812 cleanup_pdump_resources();
813 rte_exit(EXIT_FAILURE, "%s\n", rte_strerror(rte_errno));
822 struct pdump_tuples *pt;
824 while (!quit_signal) {
825 for (i = 0; i < num_tuples; i++) {
827 if (pt->dir & RTE_PDUMP_FLAG_RX)
828 pdump_rxtx(pt->rx_ring, pt->rx_vdev_id,
830 if (pt->dir & RTE_PDUMP_FLAG_TX)
831 pdump_rxtx(pt->tx_ring, pt->tx_vdev_id,
838 main(int argc, char **argv)
844 char c_flag[] = "-c1";
845 char n_flag[] = "-n4";
846 char mp_flag[] = "--proc-type=secondary";
847 char *argp[argc + 3];
849 /* catch ctrl-c so we can print on exit */
850 signal(SIGINT, signal_handler);
857 for (i = 1; i < argc; i++)
858 argp[i + 3] = argv[i];
862 diag = rte_eal_init(argc, argp);
864 rte_panic("Cannot init EAL\n");
869 /* parse app arguments */
871 ret = launch_args_parse(argc, argv, argp[0]);
873 rte_exit(EXIT_FAILURE, "Invalid argument\n");
876 /* create mempool, ring and vdevs info */
877 create_mp_ring_vdev();
881 cleanup_pdump_resources();
882 /* dump debug stats */
885 ret = rte_eal_cleanup();
887 printf("Error from rte_eal_cleanup(), %d\n", ret);