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_string_fns.h>
28 #include <rte_pdump.h>
30 #define CMD_LINE_OPT_PDUMP "pdump"
31 #define PDUMP_PORT_ARG "port"
32 #define PDUMP_PCI_ARG "device_id"
33 #define PDUMP_QUEUE_ARG "queue"
34 #define PDUMP_DIR_ARG "dir"
35 #define PDUMP_RX_DEV_ARG "rx-dev"
36 #define PDUMP_TX_DEV_ARG "tx-dev"
37 #define PDUMP_RING_SIZE_ARG "ring-size"
38 #define PDUMP_MSIZE_ARG "mbuf-size"
39 #define PDUMP_NUM_MBUFS_ARG "total-num-mbufs"
41 #define VDEV_NAME_FMT "net_pcap_%s_%d"
42 #define VDEV_PCAP_ARGS_FMT "tx_pcap=%s"
43 #define VDEV_IFACE_ARGS_FMT "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 static const char * const 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];
139 static int num_tuples;
140 static struct rte_eth_conf port_conf_default;
141 static volatile uint8_t quit_signal;
143 /**< display usage */
145 pdump_usage(const char *prgname)
147 printf("usage: %s [EAL options] -- --pdump "
148 "'(port=<port id> | device_id=<pci id or vdev name>),"
149 "(queue=<queue_id>),"
150 "(rx-dev=<iface or pcap file> |"
151 " tx-dev=<iface or pcap file>,"
152 "[ring-size=<ring size>default:16384],"
153 "[mbuf-size=<mbuf data size>default:2176],"
154 "[total-num-mbufs=<number of mbufs>default:65535]'\n",
159 parse_device_id(const char *key __rte_unused, const char *value,
162 struct pdump_tuples *pt = extra_args;
164 pt->device_id = strdup(value);
165 pt->dump_by_type = DEVICE_ID;
171 parse_queue(const char *key __rte_unused, const char *value, void *extra_args)
174 struct pdump_tuples *pt = extra_args;
176 if (!strcmp(value, "*"))
177 pt->queue = RTE_PDUMP_ALL_QUEUES;
179 n = strtoul(value, NULL, 10);
180 pt->queue = (uint16_t) n;
186 parse_rxtxdev(const char *key, const char *value, void *extra_args)
189 struct pdump_tuples *pt = extra_args;
191 if (!strcmp(key, PDUMP_RX_DEV_ARG)) {
192 strlcpy(pt->rx_dev, value, sizeof(pt->rx_dev));
193 /* identify the tx stream type for pcap vdev */
194 if (if_nametoindex(pt->rx_dev))
195 pt->rx_vdev_stream_type = IFACE;
196 } else if (!strcmp(key, PDUMP_TX_DEV_ARG)) {
197 strlcpy(pt->tx_dev, value, sizeof(pt->tx_dev));
198 /* identify the tx stream type for pcap vdev */
199 if (if_nametoindex(pt->tx_dev))
200 pt->tx_vdev_stream_type = IFACE;
207 parse_uint_value(const char *key, const char *value, void *extra_args)
216 t = strtoul(value, &end, 10);
218 if (errno != 0 || end[0] != 0 || t < v->min || t > v->max) {
219 printf("invalid value:\"%s\" for key:\"%s\", "
220 "value must be >= %"PRIu64" and <= %"PRIu64"\n",
221 value, key, v->min, v->max);
224 if (!strcmp(key, PDUMP_RING_SIZE_ARG) && !POWEROF2(t)) {
225 printf("invalid value:\"%s\" for key:\"%s\", "
226 "value must be power of 2\n", value, key);
238 parse_pdump(const char *optarg)
240 struct rte_kvargs *kvlist;
241 int ret = 0, cnt1, cnt2;
242 struct pdump_tuples *pt;
243 struct parse_val v = {0};
245 pt = &pdump_t[num_tuples];
247 /* initial check for invalid arguments */
248 kvlist = rte_kvargs_parse(optarg, valid_pdump_arguments);
249 if (kvlist == NULL) {
250 printf("--pdump=\"%s\": invalid argument passed\n", optarg);
254 /* port/device_id parsing and validation */
255 cnt1 = rte_kvargs_count(kvlist, PDUMP_PORT_ARG);
256 cnt2 = rte_kvargs_count(kvlist, PDUMP_PCI_ARG);
257 if (!((cnt1 == 1 && cnt2 == 0) || (cnt1 == 0 && cnt2 == 1))) {
258 printf("--pdump=\"%s\": must have either port or "
259 "device_id argument\n", optarg);
262 } else if (cnt1 == 1) {
264 v.max = RTE_MAX_ETHPORTS-1;
265 ret = rte_kvargs_process(kvlist, PDUMP_PORT_ARG,
266 &parse_uint_value, &v);
269 pt->port = (uint16_t) v.val;
270 pt->dump_by_type = PORT_ID;
271 } else if (cnt2 == 1) {
272 ret = rte_kvargs_process(kvlist, PDUMP_PCI_ARG,
273 &parse_device_id, pt);
278 /* queue parsing and validation */
279 cnt1 = rte_kvargs_count(kvlist, PDUMP_QUEUE_ARG);
281 printf("--pdump=\"%s\": must have queue argument\n", optarg);
285 ret = rte_kvargs_process(kvlist, PDUMP_QUEUE_ARG, &parse_queue, pt);
289 /* rx-dev and tx-dev parsing and validation */
290 cnt1 = rte_kvargs_count(kvlist, PDUMP_RX_DEV_ARG);
291 cnt2 = rte_kvargs_count(kvlist, PDUMP_TX_DEV_ARG);
292 if (cnt1 == 0 && cnt2 == 0) {
293 printf("--pdump=\"%s\": must have either rx-dev or "
294 "tx-dev argument\n", optarg);
297 } else if (cnt1 == 1 && cnt2 == 1) {
298 ret = rte_kvargs_process(kvlist, PDUMP_RX_DEV_ARG,
302 ret = rte_kvargs_process(kvlist, PDUMP_TX_DEV_ARG,
306 /* if captured packets has to send to the same vdev */
307 if (!strcmp(pt->rx_dev, pt->tx_dev))
308 pt->single_pdump_dev = true;
309 pt->dir = RTE_PDUMP_FLAG_RXTX;
310 } else if (cnt1 == 1) {
311 ret = rte_kvargs_process(kvlist, PDUMP_RX_DEV_ARG,
315 pt->dir = RTE_PDUMP_FLAG_RX;
316 } else if (cnt2 == 1) {
317 ret = rte_kvargs_process(kvlist, PDUMP_TX_DEV_ARG,
321 pt->dir = RTE_PDUMP_FLAG_TX;
325 /* ring_size parsing and validation */
326 cnt1 = rte_kvargs_count(kvlist, PDUMP_RING_SIZE_ARG);
329 v.max = RTE_RING_SZ_MASK-1;
330 ret = rte_kvargs_process(kvlist, PDUMP_RING_SIZE_ARG,
331 &parse_uint_value, &v);
334 pt->ring_size = (uint32_t) v.val;
336 pt->ring_size = RING_SIZE;
338 /* mbuf_data_size parsing and validation */
339 cnt1 = rte_kvargs_count(kvlist, PDUMP_MSIZE_ARG);
343 ret = rte_kvargs_process(kvlist, PDUMP_MSIZE_ARG,
344 &parse_uint_value, &v);
347 pt->mbuf_data_size = (uint16_t) v.val;
349 pt->mbuf_data_size = RTE_MBUF_DEFAULT_BUF_SIZE;
351 /* total_num_mbufs parsing and validation */
352 cnt1 = rte_kvargs_count(kvlist, PDUMP_NUM_MBUFS_ARG);
356 ret = rte_kvargs_process(kvlist, PDUMP_NUM_MBUFS_ARG,
357 &parse_uint_value, &v);
360 pt->total_num_mbufs = (uint16_t) v.val;
362 pt->total_num_mbufs = MBUFS_PER_POOL;
367 rte_kvargs_free(kvlist);
371 /* Parse the argument given in the command line of the application */
373 launch_args_parse(int argc, char **argv, char *prgname)
377 static struct option long_option[] = {
383 pdump_usage(prgname);
385 /* Parse command line */
386 while ((opt = getopt_long(argc, argv, " ",
387 long_option, &option_index)) != EOF) {
390 if (!strncmp(long_option[option_index].name,
392 sizeof(CMD_LINE_OPT_PDUMP))) {
393 ret = parse_pdump(optarg);
395 pdump_usage(prgname);
401 pdump_usage(prgname);
410 print_pdump_stats(void)
413 struct pdump_tuples *pt;
415 for (i = 0; i < num_tuples; i++) {
416 printf("##### PDUMP DEBUG STATS #####\n");
418 printf(" -packets dequeued: %"PRIu64"\n",
419 pt->stats.dequeue_pkts);
420 printf(" -packets transmitted to vdev: %"PRIu64"\n",
422 printf(" -packets freed: %"PRIu64"\n",
423 pt->stats.freed_pkts);
428 disable_pdump(struct pdump_tuples *pt)
430 if (pt->dump_by_type == DEVICE_ID)
431 rte_pdump_disable_by_deviceid(pt->device_id, pt->queue,
433 else if (pt->dump_by_type == PORT_ID)
434 rte_pdump_disable(pt->port, pt->queue, pt->dir);
438 pdump_rxtx(struct rte_ring *ring, uint16_t vdev_id, struct pdump_stats *stats)
440 /* write input packets of port to vdev for pdump */
441 struct rte_mbuf *rxtx_bufs[BURST_SIZE];
443 /* first dequeue packets from ring of primary process */
444 const uint16_t nb_in_deq = rte_ring_dequeue_burst(ring,
445 (void *)rxtx_bufs, BURST_SIZE, NULL);
446 stats->dequeue_pkts += nb_in_deq;
449 /* then sent on vdev */
450 uint16_t nb_in_txd = rte_eth_tx_burst(
452 0, rxtx_bufs, nb_in_deq);
453 stats->tx_pkts += nb_in_txd;
455 if (unlikely(nb_in_txd < nb_in_deq)) {
457 rte_pktmbuf_free(rxtx_bufs[nb_in_txd]);
459 } while (++nb_in_txd < nb_in_deq);
465 free_ring_data(struct rte_ring *ring, uint16_t vdev_id,
466 struct pdump_stats *stats)
468 while (rte_ring_count(ring))
469 pdump_rxtx(ring, vdev_id, stats);
476 struct pdump_tuples *pt;
478 for (i = 0; i < num_tuples; i++) {
486 rte_ring_free(pt->rx_ring);
488 rte_ring_free(pt->tx_ring);
493 cleanup_pdump_resources(void)
496 struct pdump_tuples *pt;
497 char name[RTE_ETH_NAME_MAX_LEN];
499 /* disable pdump and free the pdump_tuple resources */
500 for (i = 0; i < num_tuples; i++) {
503 /* remove callbacks */
507 * transmit rest of the enqueued packets of the rings on to
508 * the vdev, in order to release mbufs to the mepool.
510 if (pt->dir & RTE_PDUMP_FLAG_RX)
511 free_ring_data(pt->rx_ring, pt->rx_vdev_id, &pt->stats);
512 if (pt->dir & RTE_PDUMP_FLAG_TX)
513 free_ring_data(pt->tx_ring, pt->tx_vdev_id, &pt->stats);
515 /* Remove the vdev(s) created */
516 if (pt->dir & RTE_PDUMP_FLAG_RX) {
517 rte_eth_dev_get_name_by_port(pt->rx_vdev_id, name);
518 rte_eal_hotplug_remove("vdev", name);
521 if (pt->single_pdump_dev)
524 if (pt->dir & RTE_PDUMP_FLAG_TX) {
525 rte_eth_dev_get_name_by_port(pt->tx_vdev_id, name);
526 rte_eal_hotplug_remove("vdev", name);
534 signal_handler(int sig_num)
536 if (sig_num == SIGINT) {
537 printf("\n\nSignal %d received, preparing to exit...\n",
544 configure_vdev(uint16_t port_id)
546 struct ether_addr addr;
547 const uint16_t rxRings = 0, txRings = 1;
551 if (!rte_eth_dev_is_valid_port(port_id))
554 ret = rte_eth_dev_configure(port_id, rxRings, txRings,
557 rte_exit(EXIT_FAILURE, "dev config failed\n");
559 for (q = 0; q < txRings; q++) {
560 ret = rte_eth_tx_queue_setup(port_id, q, TX_DESC_PER_QUEUE,
561 rte_eth_dev_socket_id(port_id), NULL);
563 rte_exit(EXIT_FAILURE, "queue setup failed\n");
566 ret = rte_eth_dev_start(port_id);
568 rte_exit(EXIT_FAILURE, "dev start failed\n");
570 rte_eth_macaddr_get(port_id, &addr);
571 printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
572 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
574 addr.addr_bytes[0], addr.addr_bytes[1],
575 addr.addr_bytes[2], addr.addr_bytes[3],
576 addr.addr_bytes[4], addr.addr_bytes[5]);
578 rte_eth_promiscuous_enable(port_id);
584 create_mp_ring_vdev(void)
588 struct pdump_tuples *pt = NULL;
589 struct rte_mempool *mbuf_pool = NULL;
590 char vdev_name[SIZE];
591 char vdev_args[SIZE];
592 char ring_name[SIZE];
593 char mempool_name[SIZE];
595 for (i = 0; i < num_tuples; i++) {
597 snprintf(mempool_name, SIZE, MP_NAME, i);
598 mbuf_pool = rte_mempool_lookup(mempool_name);
599 if (mbuf_pool == NULL) {
601 mbuf_pool = rte_pktmbuf_pool_create(mempool_name,
603 MBUF_POOL_CACHE_SIZE, 0,
606 if (mbuf_pool == NULL) {
608 rte_exit(EXIT_FAILURE,
609 "Mempool creation failed: %s\n",
610 rte_strerror(rte_errno));
615 if (pt->dir == RTE_PDUMP_FLAG_RXTX) {
616 /* if captured packets has to send to the same vdev */
618 snprintf(ring_name, SIZE, RX_RING, i);
619 pt->rx_ring = rte_ring_create(ring_name, pt->ring_size,
621 if (pt->rx_ring == NULL) {
623 rte_exit(EXIT_FAILURE, "%s:%s:%d\n",
624 rte_strerror(rte_errno),
629 snprintf(ring_name, SIZE, TX_RING, i);
630 pt->tx_ring = rte_ring_create(ring_name, pt->ring_size,
632 if (pt->tx_ring == NULL) {
634 rte_exit(EXIT_FAILURE, "%s:%s:%d\n",
635 rte_strerror(rte_errno),
640 snprintf(vdev_name, sizeof(vdev_name),
641 VDEV_NAME_FMT, RX_STR, i);
642 (pt->rx_vdev_stream_type == IFACE) ?
643 snprintf(vdev_args, sizeof(vdev_args),
644 VDEV_IFACE_ARGS_FMT, pt->rx_dev) :
645 snprintf(vdev_args, sizeof(vdev_args),
646 VDEV_PCAP_ARGS_FMT, pt->rx_dev);
647 if (rte_eal_hotplug_add("vdev", vdev_name,
650 rte_exit(EXIT_FAILURE,
651 "vdev creation failed:%s:%d\n",
654 if (rte_eth_dev_get_port_by_name(vdev_name,
656 rte_eal_hotplug_remove("vdev", vdev_name);
658 rte_exit(EXIT_FAILURE,
659 "cannot find added vdev %s:%s:%d\n",
660 vdev_name, __func__, __LINE__);
662 pt->rx_vdev_id = portid;
665 configure_vdev(pt->rx_vdev_id);
667 if (pt->single_pdump_dev)
668 pt->tx_vdev_id = portid;
670 snprintf(vdev_name, sizeof(vdev_name),
671 VDEV_NAME_FMT, TX_STR, i);
672 (pt->rx_vdev_stream_type == IFACE) ?
673 snprintf(vdev_args, sizeof(vdev_args),
674 VDEV_IFACE_ARGS_FMT, pt->tx_dev) :
675 snprintf(vdev_args, sizeof(vdev_args),
676 VDEV_PCAP_ARGS_FMT, pt->tx_dev);
677 if (rte_eal_hotplug_add("vdev", vdev_name,
680 rte_exit(EXIT_FAILURE,
681 "vdev creation failed:"
682 "%s:%d\n", __func__, __LINE__);
684 if (rte_eth_dev_get_port_by_name(vdev_name,
686 rte_eal_hotplug_remove("vdev",
689 rte_exit(EXIT_FAILURE,
690 "cannot find added vdev %s:%s:%d\n",
691 vdev_name, __func__, __LINE__);
693 pt->tx_vdev_id = portid;
696 configure_vdev(pt->tx_vdev_id);
698 } else if (pt->dir == RTE_PDUMP_FLAG_RX) {
701 snprintf(ring_name, SIZE, RX_RING, i);
702 pt->rx_ring = rte_ring_create(ring_name, pt->ring_size,
704 if (pt->rx_ring == NULL) {
706 rte_exit(EXIT_FAILURE, "%s\n",
707 rte_strerror(rte_errno));
710 snprintf(vdev_name, sizeof(vdev_name),
711 VDEV_NAME_FMT, RX_STR, i);
712 (pt->rx_vdev_stream_type == IFACE) ?
713 snprintf(vdev_args, sizeof(vdev_args),
714 VDEV_IFACE_ARGS_FMT, pt->rx_dev) :
715 snprintf(vdev_args, sizeof(vdev_args),
716 VDEV_PCAP_ARGS_FMT, pt->rx_dev);
717 if (rte_eal_hotplug_add("vdev", vdev_name,
720 rte_exit(EXIT_FAILURE,
721 "vdev creation failed:%s:%d\n",
724 if (rte_eth_dev_get_port_by_name(vdev_name,
726 rte_eal_hotplug_remove("vdev", vdev_name);
728 rte_exit(EXIT_FAILURE,
729 "cannot find added vdev %s:%s:%d\n",
730 vdev_name, __func__, __LINE__);
732 pt->rx_vdev_id = portid;
734 configure_vdev(pt->rx_vdev_id);
735 } else if (pt->dir == RTE_PDUMP_FLAG_TX) {
738 snprintf(ring_name, SIZE, TX_RING, i);
739 pt->tx_ring = rte_ring_create(ring_name, pt->ring_size,
741 if (pt->tx_ring == NULL) {
743 rte_exit(EXIT_FAILURE, "%s\n",
744 rte_strerror(rte_errno));
747 snprintf(vdev_name, sizeof(vdev_name),
748 VDEV_NAME_FMT, TX_STR, i);
749 (pt->tx_vdev_stream_type == IFACE) ?
750 snprintf(vdev_args, sizeof(vdev_args),
751 VDEV_IFACE_ARGS_FMT, pt->tx_dev) :
752 snprintf(vdev_args, sizeof(vdev_args),
753 VDEV_PCAP_ARGS_FMT, pt->tx_dev);
754 if (rte_eal_hotplug_add("vdev", vdev_name,
757 rte_exit(EXIT_FAILURE,
758 "vdev creation failed\n");
760 if (rte_eth_dev_get_port_by_name(vdev_name,
762 rte_eal_hotplug_remove("vdev", vdev_name);
764 rte_exit(EXIT_FAILURE,
765 "cannot find added vdev %s:%s:%d\n",
766 vdev_name, __func__, __LINE__);
768 pt->tx_vdev_id = portid;
771 configure_vdev(pt->tx_vdev_id);
780 struct pdump_tuples *pt;
781 int ret = 0, ret1 = 0;
783 for (i = 0; i < num_tuples; i++) {
785 if (pt->dir == RTE_PDUMP_FLAG_RXTX) {
786 if (pt->dump_by_type == DEVICE_ID) {
787 ret = rte_pdump_enable_by_deviceid(
793 ret1 = rte_pdump_enable_by_deviceid(
799 } else if (pt->dump_by_type == PORT_ID) {
800 ret = rte_pdump_enable(pt->port, pt->queue,
802 pt->rx_ring, pt->mp, NULL);
803 ret1 = rte_pdump_enable(pt->port, pt->queue,
805 pt->tx_ring, pt->mp, NULL);
807 } else if (pt->dir == RTE_PDUMP_FLAG_RX) {
808 if (pt->dump_by_type == DEVICE_ID)
809 ret = rte_pdump_enable_by_deviceid(
812 pt->dir, pt->rx_ring,
814 else if (pt->dump_by_type == PORT_ID)
815 ret = rte_pdump_enable(pt->port, pt->queue,
817 pt->rx_ring, pt->mp, NULL);
818 } else if (pt->dir == RTE_PDUMP_FLAG_TX) {
819 if (pt->dump_by_type == DEVICE_ID)
820 ret = rte_pdump_enable_by_deviceid(
824 pt->tx_ring, pt->mp, NULL);
825 else if (pt->dump_by_type == PORT_ID)
826 ret = rte_pdump_enable(pt->port, pt->queue,
828 pt->tx_ring, pt->mp, NULL);
830 if (ret < 0 || ret1 < 0) {
831 cleanup_pdump_resources();
832 rte_exit(EXIT_FAILURE, "%s\n", rte_strerror(rte_errno));
841 struct pdump_tuples *pt;
843 while (!quit_signal) {
844 for (i = 0; i < num_tuples; i++) {
846 if (pt->dir & RTE_PDUMP_FLAG_RX)
847 pdump_rxtx(pt->rx_ring, pt->rx_vdev_id,
849 if (pt->dir & RTE_PDUMP_FLAG_TX)
850 pdump_rxtx(pt->tx_ring, pt->tx_vdev_id,
857 main(int argc, char **argv)
863 char n_flag[] = "-n4";
864 char mp_flag[] = "--proc-type=secondary";
865 char *argp[argc + 2];
867 /* catch ctrl-c so we can print on exit */
868 signal(SIGINT, signal_handler);
874 for (i = 1; i < argc; i++)
875 argp[i + 2] = argv[i];
879 diag = rte_eal_init(argc, argp);
881 rte_panic("Cannot init EAL\n");
883 if (rte_eth_dev_count_avail() == 0)
884 rte_exit(EXIT_FAILURE, "No Ethernet ports - bye\n");
889 /* parse app arguments */
891 ret = launch_args_parse(argc, argv, argp[0]);
893 rte_exit(EXIT_FAILURE, "Invalid argument\n");
896 /* create mempool, ring and vdevs info */
897 create_mp_ring_vdev();
901 cleanup_pdump_resources();
902 /* dump debug stats */
905 ret = rte_eal_cleanup();
907 printf("Error from rte_eal_cleanup(), %d\n", ret);