[dpdk-dev,v4,5/9] lib/librte_pdump: add new library for packet capturing support

Message ID 1464039512-2683-6-git-send-email-reshma.pattan@intel.com
State Superseded, archived
Delegated to: Thomas Monjalon
Headers show

Commit Message

Reshma Pattan May 23, 2016, 9:38 p.m.
Added new library for packet capturing support.

Added public api rte_pdump_init, applications should call
this as part of their application setup to have packet
capturing framework ready.

Added public api rte_pdump_uninit to un initialize the packet
capturing framework.

Added public apis rte_pdump_enable and rte_pdump_disable to
enable and disable packet capturing on specific port and queue.

Added public apis rte_pdump_enable_by_deviceid and
rte_pdump_disable_by_deviceid to enable and disable packet
capturing on a specific device (pci address or name) and queue.

Signed-off-by: Reshma Pattan <reshma.pattan@intel.com>
---
 MAINTAINERS                            |   4 +
 config/common_base                     |   5 +
 lib/Makefile                           |   1 +
 lib/librte_pdump/Makefile              |  55 +++
 lib/librte_pdump/rte_pdump.c           | 816 +++++++++++++++++++++++++++++++++
 lib/librte_pdump/rte_pdump.h           | 186 ++++++++
 lib/librte_pdump/rte_pdump_version.map |  12 +
 mk/rte.app.mk                          |   1 +
 8 files changed, 1080 insertions(+)
 create mode 100644 lib/librte_pdump/Makefile
 create mode 100644 lib/librte_pdump/rte_pdump.c
 create mode 100644 lib/librte_pdump/rte_pdump.h
 create mode 100644 lib/librte_pdump/rte_pdump_version.map

Comments

Ananyev, Konstantin May 27, 2016, 1:39 p.m. | #1
Hi Reshma,

> 
> Added new library for packet capturing support.
> 
> Added public api rte_pdump_init, applications should call
> this as part of their application setup to have packet
> capturing framework ready.
> 
> Added public api rte_pdump_uninit to un initialize the packet
> capturing framework.
> 
> Added public apis rte_pdump_enable and rte_pdump_disable to
> enable and disable packet capturing on specific port and queue.
> 
> Added public apis rte_pdump_enable_by_deviceid and
> rte_pdump_disable_by_deviceid to enable and disable packet
> capturing on a specific device (pci address or name) and queue.
> 
> Signed-off-by: Reshma Pattan <reshma.pattan@intel.com>
> ---
>  MAINTAINERS                            |   4 +
>  config/common_base                     |   5 +
>  lib/Makefile                           |   1 +
>  lib/librte_pdump/Makefile              |  55 +++
>  lib/librte_pdump/rte_pdump.c           | 816 +++++++++++++++++++++++++++++++++
>  lib/librte_pdump/rte_pdump.h           | 186 ++++++++
>  lib/librte_pdump/rte_pdump_version.map |  12 +
>  mk/rte.app.mk                          |   1 +
>  8 files changed, 1080 insertions(+)
>  create mode 100644 lib/librte_pdump/Makefile
>  create mode 100644 lib/librte_pdump/rte_pdump.c
>  create mode 100644 lib/librte_pdump/rte_pdump.h
>  create mode 100644 lib/librte_pdump/rte_pdump_version.map
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 9dd0738..8656239 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -433,6 +433,10 @@ F: app/test/test_reorder*
>  F: examples/packet_ordering/
>  F: doc/guides/sample_app_ug/packet_ordering.rst
> 
> +Pdump
> +M: Reshma Pattan <reshma.pattan@intel.com>
> +F: lib/librte_pdump/
> +
>  Hierarchical scheduler
>  M: Cristian Dumitrescu <cristian.dumitrescu@intel.com>
>  F: lib/librte_sched/
> diff --git a/config/common_base b/config/common_base
> index 3535c6e..259bf0a 100644
> --- a/config/common_base
> +++ b/config/common_base
> @@ -484,6 +484,11 @@ CONFIG_RTE_LIBRTE_DISTRIBUTOR=y
>  CONFIG_RTE_LIBRTE_REORDER=y
> 
>  #
> +# Compile the pdump library
> +#
> +CONFIG_RTE_LIBRTE_PDUMP=y
> +
> +#
>  # Compile librte_port
>  #
>  CONFIG_RTE_LIBRTE_PORT=y
> diff --git a/lib/Makefile b/lib/Makefile
> index f254dba..ca7c02f 100644
> --- a/lib/Makefile
> +++ b/lib/Makefile
> @@ -57,6 +57,7 @@ DIRS-$(CONFIG_RTE_LIBRTE_PORT) += librte_port
>  DIRS-$(CONFIG_RTE_LIBRTE_TABLE) += librte_table
>  DIRS-$(CONFIG_RTE_LIBRTE_PIPELINE) += librte_pipeline
>  DIRS-$(CONFIG_RTE_LIBRTE_REORDER) += librte_reorder
> +DIRS-$(CONFIG_RTE_LIBRTE_PDUMP) += librte_pdump
> 
>  ifeq ($(CONFIG_RTE_EXEC_ENV_LINUXAPP),y)
>  DIRS-$(CONFIG_RTE_LIBRTE_KNI) += librte_kni
> diff --git a/lib/librte_pdump/Makefile b/lib/librte_pdump/Makefile
> new file mode 100644
> index 0000000..af81a28
> --- /dev/null
> +++ b/lib/librte_pdump/Makefile
> @@ -0,0 +1,55 @@
> +#   BSD LICENSE
> +#
> +#   Copyright(c) 2016 Intel Corporation. All rights reserved.
> +#   All rights reserved.
> +#
> +#   Redistribution and use in source and binary forms, with or without
> +#   modification, are permitted provided that the following conditions
> +#   are met:
> +#
> +#     * Redistributions of source code must retain the above copyright
> +#       notice, this list of conditions and the following disclaimer.
> +#     * Redistributions in binary form must reproduce the above copyright
> +#       notice, this list of conditions and the following disclaimer in
> +#       the documentation and/or other materials provided with the
> +#       distribution.
> +#     * Neither the name of Intel Corporation nor the names of its
> +#       contributors may be used to endorse or promote products derived
> +#       from this software without specific prior written permission.
> +#
> +#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> +#   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> +#   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> +#   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> +#   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> +#   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> +#   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> +#   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> +#   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> +#   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> +#   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +include $(RTE_SDK)/mk/rte.vars.mk
> +
> +# library name
> +LIB = librte_pdump.a
> +
> +CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR) -O3
> +CFLAGS += -D_GNU_SOURCE
> +
> +EXPORT_MAP := rte_pdump_version.map
> +
> +LIBABIVER := 1
> +
> +# all source are stored in SRCS-y
> +SRCS-$(CONFIG_RTE_LIBRTE_PDUMP) := rte_pdump.c
> +
> +# install this header file
> +SYMLINK-$(CONFIG_RTE_LIBRTE_PDUMP)-include := rte_pdump.h
> +
> +# this lib depends upon:
> +DEPDIRS-$(CONFIG_RTE_LIBRTE_PDUMP) += lib/librte_mbuf
> +DEPDIRS-$(CONFIG_RTE_LIBRTE_PDUMP) += lib/librte_eal
> +DEPDIRS-$(CONFIG_RTE_LIBRTE_PDUMP) += lib/librte_ether
> +
> +include $(RTE_SDK)/mk/rte.lib.mk
> diff --git a/lib/librte_pdump/rte_pdump.c b/lib/librte_pdump/rte_pdump.c
> new file mode 100644
> index 0000000..915cd37
> --- /dev/null
> +++ b/lib/librte_pdump/rte_pdump.c
> @@ -0,0 +1,816 @@
> +/*-
> + *   BSD LICENSE
> + *
> + *   Copyright(c) 2016 Intel Corporation. All rights reserved.
> + *   All rights reserved.
> + *
> + *   Redistribution and use in source and binary forms, with or without
> + *   modification, are permitted provided that the following conditions
> + *   are met:
> + *
> + *     * Redistributions of source code must retain the above copyright
> + *       notice, this list of conditions and the following disclaimer.
> + *     * Redistributions in binary form must reproduce the above copyright
> + *       notice, this list of conditions and the following disclaimer in
> + *       the documentation and/or other materials provided with the
> + *       distribution.
> + *     * Neither the name of Intel Corporation nor the names of its
> + *       contributors may be used to endorse or promote products derived
> + *       from this software without specific prior written permission.
> + *
> + *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> + *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> + *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> + *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> + *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> + *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> + *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> + *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> + *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> + *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> + *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +
> +#include <sys/socket.h>
> +#include <sys/un.h>
> +#include <sys/stat.h>
> +#include <unistd.h>
> +#include <sys/types.h>
> +#include <pthread.h>
> +#include <stdbool.h>
> +
> +#include <rte_memcpy.h>
> +#include <rte_mbuf.h>
> +#include <rte_ethdev.h>
> +#include <rte_lcore.h>
> +#include <rte_log.h>
> +#include <rte_errno.h>
> +#include <rte_pci.h>
> +
> +#include "rte_pdump.h"
> +
> +#define SOCKET_PATH_VAR_RUN "/var/run/pdump_sockets"
> +#define SOCKET_PATH_HOME "HOME/pdump_sockets"
> +#define SERVER_SOCKET "%s/pdump_server_socket"
> +#define CLIENT_SOCKET "%s/pdump_client_socket_%d_%u"
> +#define DEVICE_ID_SIZE 64
> +/* Macros for printing using RTE_LOG */
> +#define RTE_LOGTYPE_PDUMP RTE_LOGTYPE_USER1
> +
> +enum pdump_operation {
> +	DISABLE = 1,
> +	ENABLE = 2
> +};
> +
> +enum pdump_socktype {
> +	SERVER = 1,
> +	CLIENT = 2
> +};
> +
> +enum pdump_version {
> +	V1 = 1
> +};
> +
> +static pthread_t pdump_thread;
> +static int pdump_socket_fd;
> +
> +struct pdump_request {
> +	uint16_t ver;
> +	uint16_t op;
> +	uint32_t dir;

I understand why you named it 'dir' (as right now it could be only RX & TX),
but I think we better name it in a more generic way: flags or so.
There are 29 unused bits right now, and probably in future will use it
For something more than just traffic direction indication. 

> +	union pdump_data {
> +		struct enable_v1 {
> +			char device[DEVICE_ID_SIZE];
> +			uint16_t queue;
> +			struct rte_ring *ring;
> +			struct rte_mempool *mp;
> +			void *filter;
> +			bool is_pci_or_name;
> +		} en_v1;
> +		struct disable_v1 {
> +			char device[DEVICE_ID_SIZE];
> +			uint16_t queue;
> +			struct rte_ring *ring;
> +			struct rte_mempool *mp;
> +			void *filter;
> +			bool is_pci_or_name;
> +		} dis_v1;
> +	} data;
> +};
> +
> +struct pdump_response {
> +	uint16_t ver;
> +	uint16_t res_op;
> +	int32_t err_value;
> +};
> +
> +static struct pdump_rxtx_cbs {
> +	struct rte_ring *ring;
> +	struct rte_mempool *mp;
> +	struct rte_eth_rxtx_callback *cb;
> +	void *filter;
> +} rx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT],
> +tx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT];
> +
> +static inline int
> +pdump_pktmbuf_copy_data(struct rte_mbuf *seg, const struct rte_mbuf *m)
> +{
> +	if (rte_pktmbuf_tailroom(seg) < m->data_len) {
> +		RTE_LOG(ERR, PDUMP, "User mempool: insufficient data_len of mbuf\n");
> +		return -EINVAL;
> +	}
> +
> +	seg->port = m->port;
> +	seg->vlan_tci = m->vlan_tci;
> +	seg->hash = m->hash;
> +	seg->tx_offload = m->tx_offload;
> +	seg->ol_flags = m->ol_flags;
> +	seg->packet_type = m->packet_type;
> +	seg->vlan_tci_outer = m->vlan_tci_outer;
> +	seg->data_len = m->data_len;
> +	seg->pkt_len = seg->data_len;
> +	rte_memcpy(rte_pktmbuf_mtod(seg, void *),
> +			rte_pktmbuf_mtod(m, void *),
> +			rte_pktmbuf_data_len(seg));
> +
> +	__rte_mbuf_sanity_check(seg, 1);

And I don't think you need that sanity_check() here at all, as you call it anyway
in pdump_pktmbuf_copy().
But if you still like to have it there, then _sanity_check(seg, 0) seems enough here.

> +
> +	return 0;
> +}
> +
> +static inline struct rte_mbuf *
> +pdump_pktmbuf_copy(struct rte_mbuf *m, struct rte_mempool *mp)
> +{
> +	struct rte_mbuf *m_dup, *seg, **prev;
> +	uint32_t pktlen;
> +	uint8_t nseg;
> +
> +	m_dup = rte_pktmbuf_alloc(mp);
> +	if (unlikely(m_dup == NULL))
> +		return NULL;
> +
> +	seg = m_dup;
> +	prev = &seg->next;
> +	pktlen = m->pkt_len;
> +	nseg = 0;
> +
> +	do {
> +		nseg++;
> +		if (pdump_pktmbuf_copy_data(seg, m) < 0) {
> +			rte_pktmbuf_free(m_dup);
> +			return NULL;
> +		}
> +		*prev = seg;
> +		prev = &seg->next;
> +	} while ((m = m->next) != NULL &&
> +			(seg = rte_pktmbuf_alloc(mp)) != NULL);
> +
> +	*prev = NULL;
> +	m_dup->nb_segs = nseg;
> +	m_dup->pkt_len = pktlen;
> +
> +	/* Allocation of new indirect segment failed */
> +	if (unlikely(seg == NULL)) {
> +		rte_pktmbuf_free(m_dup);
> +		return NULL;
> +	}
> +
> +	__rte_mbuf_sanity_check(m_dup, 1);
> +	return m_dup;
> +}
> +
> +static inline void
> +pdump_copy(struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
> +{
> +	unsigned i;
> +	int ring_enq;
> +	uint16_t d_pkts = 0;
> +	struct rte_mbuf *dup_bufs[nb_pkts];
> +	struct pdump_rxtx_cbs *cbs;
> +	struct rte_ring *ring;
> +	struct rte_mempool *mp;
> +	struct rte_mbuf *p;
> +
> +	cbs  = user_params;
> +	ring = cbs->ring;
> +	mp = cbs->mp;
> +	for (i = 0; i < nb_pkts; i++) {
> +		p = pdump_pktmbuf_copy(pkts[i], mp);
> +		if (p)
> +			dup_bufs[d_pkts++] = p;
> +	}
> +
> +	ring_enq = rte_ring_enqueue_burst(ring, (void *)dup_bufs, d_pkts);
> +	if (unlikely(ring_enq < d_pkts)) {
> +		RTE_LOG(DEBUG, PDUMP, "only %d of packets enqueued to ring\n", ring_enq);
> +		do {
> +			rte_pktmbuf_free(dup_bufs[ring_enq]);
> +		} while (++ring_enq < d_pkts);
> +	}
> +}
> +
> +static uint16_t
> +pdump_rx(uint8_t port __rte_unused, uint16_t qidx __rte_unused,
> +	struct rte_mbuf **pkts, uint16_t nb_pkts, uint16_t max_pkts __rte_unused,
> +	void *user_params)
> +{
> +	pdump_copy(pkts, nb_pkts, user_params);
> +	return nb_pkts;
> +}
> +
> +static uint16_t
> +pdump_tx(uint8_t port __rte_unused, uint16_t qidx __rte_unused,
> +		struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
> +{
> +	pdump_copy(pkts, nb_pkts, user_params);
> +	return nb_pkts;
> +}
> +
> +static int
> +pdump_get_dombdf(char *device_id, char *domBDF)
> +{
> +	int ret;
> +	struct rte_pci_addr dev_addr = {0};
> +
> +	ret = eal_parse_pci_DomBDF(device_id, &dev_addr);
> +	if (ret < 0)
> +		return -1;
> +
> +	if (dev_addr.domain)
> +		snprintf(domBDF, DEVICE_ID_SIZE, "%u:%u:%u.%u", dev_addr.domain,
> +			dev_addr.bus, dev_addr.devid, dev_addr.function);
> +	else
> +		snprintf(domBDF, DEVICE_ID_SIZE, "%u:%u.%u", dev_addr.bus, dev_addr.devid,
> +			dev_addr.function);


Instead of implicitly assume that domBDF is at least DEVICE_ID_SIZE bytes long,
why just not pass its size as an extra parameter? 

> +
> +	return 0;
> +}
> +
> +static int
> +pdump_regitser_callbacks(uint32_t dir, uint16_t end_q,
> +			uint8_t port, uint16_t queue,
> +			struct rte_ring *ring, struct rte_mempool *mp,
> +			uint16_t operation)
> +{
> +
> +	uint16_t qid;
> +	struct pdump_rxtx_cbs *cbs = NULL;
> +
> +	qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
> +	for (; qid < end_q; qid++) {
> +		if ((dir & RTE_PDUMP_FLAG_RX) != 0)
> +			cbs = &rx_cbs[port][qid];
> +		if ((dir & RTE_PDUMP_FLAG_TX) != 0)
> +			cbs = &tx_cbs[port][qid];

In case you have dir == (RTE_PDUMP_FLAG_RX | RTE_PDUMP_FLAG_TX)
you'll overwrite your rx_cbs pointer with tx_cbs pointer.
I suppose you need 2 local vars: cbs_rx and cbs_tx here.
Again probably worth to have 2 helper functions:
pdump_regitser_rx_callback() and pdump_regitser_tx_callback()
and call them from that one. 
Or you'll never invoke that function with dir ==(RTE_PDUMP_FLAG_RX | RTE_PDUMP_FLAG_TX)?
If so, it porbably worth to put it into comments, though if it would be me, I still think it would
be good to split it in a way I mentioned above. 


> +		if (cbs && operation == ENABLE) {
> +			if (cbs->cb) {
> +				RTE_LOG(ERR, PDUMP,
> +						"failed to add callback for port=%d and "
> +						"queue=%d, callback already exists\n",
> +						port, qid);
> +				return -EEXIST;
> +			}
> +			cbs->ring = ring;
> +			cbs->mp = mp;
> +			if ((dir & RTE_PDUMP_FLAG_RX) != 0) {
> +				cbs->cb = rte_eth_add_first_rx_callback(port, qid,
> +									pdump_rx, cbs);
> +				if (cbs->cb == NULL) {
> +					RTE_LOG(ERR, PDUMP,
> +						"failed to add rx callback, errno=%d\n",
> +						rte_errno);
> +					return rte_errno;
> +				}
> +			}
> +			if ((dir & RTE_PDUMP_FLAG_TX) != 0) {
> +				cbs->cb = rte_eth_add_tx_callback(port, qid, pdump_tx,
> +									cbs);
> +				if (cbs->cb == NULL) {
> +					RTE_LOG(ERR, PDUMP,
> +						"failed to add tx callback, errno=%d\n",
> +						rte_errno);
> +					return rte_errno;
> +				}
> +			}
> +		}
> +		if (cbs && operation == DISABLE) {
> +			int ret;
> +
> +			if (cbs->cb == NULL) {
> +				RTE_LOG(ERR, PDUMP,
> +						"failed to delete non existing callback "
> +						"for port=%d and queue=%d\n", port, qid);
> +				return -EINVAL;
> +			}
> +			if ((dir & RTE_PDUMP_FLAG_RX) != 0) {
> +				ret = rte_eth_remove_rx_callback(port, qid, cbs->cb);
> +				if (ret < 0) {
> +					RTE_LOG(ERR, PDUMP,
> +						"failed to remove rx callback, errno=%d\n",
> +						rte_errno);
> +					return ret;
> +				}
> +			}
> +			if ((dir & RTE_PDUMP_FLAG_TX) != 0) {
> +				ret = rte_eth_remove_tx_callback(port, qid, cbs->cb);
> +				if (ret < 0) {
> +					RTE_LOG(ERR, PDUMP,
> +						"failed to remove tx callback, errno=%d\n",
> +						rte_errno);
> +					return ret;
> +				}
> +			}
> +			cbs->cb = NULL;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int
> +set_pdump_rxtx_cbs(struct pdump_request *p)
> +{
> +	uint16_t nb_rx_q, nb_tx_q = 0, end_q, queue;
> +	uint8_t port;
> +	int ret = 0;
> +	uint32_t dir;
> +	uint16_t operation;
> +	struct rte_ring *ring;
> +	struct rte_mempool *mp;
> +	char domBDF[DEVICE_ID_SIZE];
> +
> +	dir = p->dir;
> +	operation = p->op;
> +	if (operation == ENABLE) {
> +		if (p->data.en_v1.is_pci_or_name == true) {
> +			/* check if device is pci address or name */
> +			if (pdump_get_dombdf(p->data.en_v1.device, domBDF) == 0)
> +				ret = rte_eth_dev_get_port_by_name(domBDF, &port);
> +			else
> +				ret = rte_eth_dev_get_port_by_name(p->data.en_v1.device,
> +									&port);


Why we can't force client to have device name in predefined format?
Then you woudn't need that name conversion here.

> +			if (ret < 0) {
> +				RTE_LOG(ERR, PDUMP,
> +					"failed to get potid for device id=%s\n",
> +					p->data.en_v1.device);
> +				return -EINVAL;
> +			}
> +		} else /* if device is port id */
> +			port = atoi(p->data.en_v1.device);

Hmm, again why not make server to accept requests only by device id?
Then it would be client responsibility to do port to device id, and you can
get rid of some duplicated code here.

> +		queue = p->data.en_v1.queue;
> +		ring = p->data.en_v1.ring;
> +		mp = p->data.en_v1.mp;
> +	} else {
> +		if (p->data.dis_v1.is_pci_or_name == true) {
> +			/* check if device is pci address or name */
> +			if (pdump_get_dombdf(p->data.dis_v1.device, domBDF) == 0)
> +				ret = rte_eth_dev_get_port_by_name(domBDF, &port);
> +			else
> +				ret = rte_eth_dev_get_port_by_name(p->data.dis_v1.device,
> +									&port);
> +			if (ret < 0) {
> +				RTE_LOG(ERR, PDUMP,
> +					"failed to get potid for device id=%s\n",
> +					p->data.dis_v1.device);
> +				return -EINVAL;
> +			}
> +		} else /* if device is port id */
> +			port = atoi(p->data.dis_v1.device);
> +		queue = p->data.dis_v1.queue;
> +		ring = p->data.dis_v1.ring;
> +		mp = p->data.dis_v1.mp;
> +	}
> +
> +	/* validation if packet capture is for all queues */
> +	if (queue == RTE_PDUMP_ALL_QUEUES) {
> +		struct rte_eth_dev_info dev_info;
> +
> +		rte_eth_dev_info_get(port, &dev_info);
> +		nb_rx_q = dev_info.nb_rx_queues;
> +		nb_tx_q = dev_info.nb_tx_queues;
> +		if (nb_rx_q == 0 && dir == RTE_PDUMP_FLAG_RX) {
> +			RTE_LOG(ERR, PDUMP, "number of rx queues cannot be 0\n");
> +			return -EINVAL;
> +		}
> +		if (nb_tx_q == 0 && dir == RTE_PDUMP_FLAG_TX) {
> +			RTE_LOG(ERR, PDUMP, "number of tx queues cannot be 0\n");
> +			return -EINVAL;
> +		}
> +		if ((nb_tx_q == 0 || nb_rx_q == 0) && dir == RTE_PDUMP_FLAG_RXTX) {
> +			RTE_LOG(ERR, PDUMP, "both tx&rx queues must be non zero\n");
> +			return -EINVAL;
> +		}
> +	}
> +
> +	/* register RX callback for dir rx/rxtx */
> +	if (dir == RTE_PDUMP_FLAG_RX || dir == RTE_PDUMP_FLAG_RXTX) {

just if (dir & RTE_PDUMP_FLAG_RX)
?

> +		end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_rx_q : queue + 1;
> +		ret = pdump_regitser_callbacks(RTE_PDUMP_FLAG_RX, end_q, port, queue,
> +						ring, mp, operation);
> +		if (ret < 0)
> +			return ret;
> +	}
> +
> +	/* register TX callback for dir tx/rxtx */
> +	if (dir == RTE_PDUMP_FLAG_TX || dir == RTE_PDUMP_FLAG_RXTX) {
> +		end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_tx_q : queue + 1;
> +		ret = pdump_regitser_callbacks(RTE_PDUMP_FLAG_TX, end_q, port, queue,
> +						ring, mp, operation);
> +		if (ret < 0)
> +			return ret;
> +	}
> +
> +	return ret;
> +}
> +
> +/* get socket path (/var/run if root, $HOME otherwise) */
> +static void
> +pdump_get_socket_path(char *buffer, int bufsz, enum pdump_socktype type)
> +{
> +	const char *dir = SOCKET_PATH_VAR_RUN;
> +	const char *home_dir = getenv(SOCKET_PATH_HOME);
> +
> +	if (getuid() != 0 && home_dir != NULL)
> +		dir = home_dir;
> +
> +	mkdir(dir, 700);
> +	if (type == SERVER)
> +		snprintf(buffer, bufsz, SERVER_SOCKET, dir);
> +	else
> +		snprintf(buffer, bufsz, CLIENT_SOCKET, dir, getpid(),
> +				rte_sys_gettid());


Probably add internal_config.hugefile_prefix into the name too,
in case there is multiple primary DPDK procs running? 

Konstantin

> +}
> +
> +static int
> +pdump_create_server_socket(void)
> +{
> +	int ret, socket_fd;
> +	struct sockaddr_un addr;
> +	socklen_t addr_len;
> +
> +	pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path), SERVER);
> +	addr.sun_family = AF_UNIX;
> +
> +	/* remove if file already exists */
> +	unlink(addr.sun_path);
> +
> +	/* set up a server socket */
> +	socket_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
> +	if (socket_fd < 0) {
> +		RTE_LOG(ERR, PDUMP, "Failed to create server socket: %s, %s:%d\n",
> +			strerror(errno), __func__, __LINE__);
> +		return -1;
> +	}
> +
> +	addr_len = sizeof(struct sockaddr_un);
> +	ret = bind(socket_fd, (struct sockaddr *) &addr, addr_len);
> +	if (ret) {
> +		RTE_LOG(ERR, PDUMP, "Failed to bind to server socket: %s, %s:%d\n",
> +			strerror(errno), __func__, __LINE__);
> +		close(socket_fd);
> +		return -1;
> +	}
> +
> +	/* save the socket in local configuration */
> +	pdump_socket_fd = socket_fd;
> +
> +	return 0;
> +}
> +
> +static __attribute__((noreturn)) void *
> +pdump_thread_main(__rte_unused void *arg)
> +{
> +	struct sockaddr_un cli_addr;
> +	socklen_t cli_len;
> +	struct pdump_request cli_req;
> +	struct pdump_response resp;
> +	int n;
> +	int ret = 0;
> +
> +	/* host thread, never break out */
> +	for (;;) {
> +		/* recv client requests */
> +		cli_len = sizeof(cli_addr);
> +		n = recvfrom(pdump_socket_fd, &cli_req, sizeof(struct pdump_request), 0,
> +				(struct sockaddr *)&cli_addr, &cli_len);
> +		if (n < 0) {
> +			RTE_LOG(ERR, PDUMP, "failed to recv from client:%s, %s:%d\n",
> +					strerror(errno), __func__, __LINE__);
> +			continue;
> +		}
> +
> +		ret = set_pdump_rxtx_cbs(&cli_req);
> +
> +		resp.ver = cli_req.ver;
> +		resp.res_op = cli_req.op;
> +		resp.err_value = ret;
> +		n = sendto(pdump_socket_fd, &resp, sizeof(struct pdump_response),
> +			0, (struct sockaddr *)&cli_addr, cli_len);
> +		if (n < 0) {
> +			RTE_LOG(ERR, PDUMP, "failed to send to client:%s, %s:%d\n",
> +					strerror(errno), __func__, __LINE__);
> +		}
> +	}
> +}
> +
> +int
> +rte_pdump_init(void)
> +{
> +	int ret = 0;
> +	char thread_name[RTE_MAX_THREAD_NAME_LEN];
> +
> +	ret = pdump_create_server_socket();
> +	if (ret != 0) {
> +		RTE_LOG(ERR, PDUMP, "Failed to create server socket:%s:%d\n",
> +			__func__, __LINE__);
> +		return -1;
> +	}
> +
> +	/* create the host thread to wait/handle pdump requests */
> +	ret = pthread_create(&pdump_thread, NULL, pdump_thread_main, NULL);
> +	if (ret != 0) {
> +		RTE_LOG(ERR, PDUMP, "Failed to create the pdump thread:%s, %s:%d\n",
> +			strerror(errno), __func__, __LINE__);
> +		return -1;
> +	}
> +	/* Set thread_name for aid in debugging. */
> +	snprintf(thread_name, RTE_MAX_THREAD_NAME_LEN, "pdump-thread");
> +	ret = rte_thread_setname(pdump_thread, thread_name);
> +	if (ret != 0) {
> +		RTE_LOG(DEBUG, PDUMP,
> +				"Failed to set thread name for pdump handling\n");
> +	}
> +
> +	return 0;
> +}
> +
> +int
> +rte_pdump_uninit(void)
> +{
> +	int ret;
> +
> +	ret = pthread_cancel(pdump_thread);
> +	if (ret != 0) {
> +		RTE_LOG(ERR, PDUMP, "Failed to cancel the pdump thread:%s, %s:%d\n",
> +			strerror(errno), __func__, __LINE__);
> +		return -1;
> +	}
> +
> +	ret = close(pdump_socket_fd);
> +	if (ret != 0) {
> +		RTE_LOG(ERR, PDUMP, "Failed to close server socket: %s, %s:%d\n",
> +			strerror(errno), __func__, __LINE__);
> +		return -1;
> +	}
> +
> +	struct sockaddr_un addr;
> +
> +	pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path), SERVER);
> +	ret = unlink(addr.sun_path);
> +	if (ret != 0) {
> +		RTE_LOG(ERR, PDUMP, "Failed to remove server socket addr: %s, %s:%d\n",
> +			strerror(errno), __func__, __LINE__);
> +		return -1;
> +	}
> +
> +	return 0;
> +}
> +
> +static int
> +pdump_create_client_socket(struct pdump_request *p)
> +{
> +	int ret, socket_fd;
> +	int pid;
> +	int n;
> +	struct pdump_response server_resp;
> +	struct sockaddr_un addr, serv_addr, from;
> +	socklen_t addr_len, serv_len;
> +
> +	pid = getpid();
> +
> +	socket_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
> +	if (socket_fd < 0) {
> +		RTE_LOG(ERR, PDUMP, "client socket(): %s:pid(%d):tid(%u), %s:%d\n",
> +			strerror(errno), pid, rte_sys_gettid(), __func__, __LINE__);
> +		ret = errno;
> +		return ret;
> +	}
> +
> +	pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path), CLIENT);
> +	addr.sun_family = AF_UNIX;
> +	addr_len = sizeof(struct sockaddr_un);
> +
> +	do {
> +		ret = bind(socket_fd, (struct sockaddr *) &addr, addr_len);
> +		if (ret) {
> +			RTE_LOG(ERR, PDUMP, "client bind(): %s, %s:%d\n",
> +					strerror(errno), __func__, __LINE__);
> +			ret = errno;
> +			break;
> +		}
> +
> +		serv_len = sizeof(struct sockaddr_un);
> +		memset(&serv_addr, 0, sizeof(serv_addr));
> +		pdump_get_socket_path(serv_addr.sun_path, sizeof(serv_addr.sun_path),
> +					SERVER);
> +		serv_addr.sun_family = AF_UNIX;
> +
> +		n =  sendto(socket_fd, p, sizeof(struct pdump_request), 0,
> +				(struct sockaddr *)&serv_addr, serv_len);
> +		if (n < 0) {
> +			RTE_LOG(ERR, PDUMP, "failed to send to server:%s, %s:%d\n",
> +					strerror(errno), __func__, __LINE__);
> +			ret =  errno;
> +			break;
> +		}
> +
> +		n = recvfrom(socket_fd, &server_resp, sizeof(struct pdump_response), 0,
> +				(struct sockaddr *)&from, &serv_len);
> +		if (n < 0) {
> +			RTE_LOG(ERR, PDUMP, "failed to recv from server:%s, %s:%d\n",
> +					strerror(errno), __func__, __LINE__);
> +			ret = errno;
> +			break;
> +		}
> +		ret = server_resp.err_value;
> +	} while (0);
> +
> +	close(socket_fd);
> +	unlink(addr.sun_path);
> +	return ret;
> +}
> +
> +static int
> +pdump_validate_ring_mp(struct rte_ring *ring, struct rte_mempool *mp)
> +{
> +	if (ring == NULL || mp == NULL) {
> +		RTE_LOG(ERR, PDUMP, "NULL ring or mempool are passed %s:%d\n",
> +			__func__, __LINE__);
> +		rte_errno = EINVAL;
> +		return -1;
> +	}
> +	if (mp->flags & MEMPOOL_F_SP_PUT || mp->flags & MEMPOOL_F_SC_GET) {
> +		RTE_LOG(ERR, PDUMP, "mempool with either SP or SC settings"
> +			" is not valid for pdump, should have MP and MC settings\n");
> +		rte_errno = EINVAL;
> +		return -1;
> +	}
> +	if (ring->prod.sp_enqueue || ring->cons.sc_dequeue) {
> +		RTE_LOG(ERR, PDUMP, "ring with either SP or SC settings"
> +			" is not valid for pdump, should have MP and MC settings\n");
> +		rte_errno = EINVAL;
> +		return -1;
> +	}
> +
> +	return 0;
> +}
> +
> +static int
> +pdump_validate_dir(uint32_t dir)
> +{
> +	if (dir != RTE_PDUMP_FLAG_RX && dir != RTE_PDUMP_FLAG_TX &&
> +		dir != RTE_PDUMP_FLAG_RXTX) {
> +		RTE_LOG(ERR, PDUMP, "invalid direction, should be either rx/tx/rxtx\n");
> +		rte_errno = EINVAL;
> +		return -1;
> +	}
> +
> +	return 0;
> +}
> +
> +static int
> +pdump_validate_port(uint8_t port)
> +{
> +	if (port >= RTE_MAX_ETHPORTS) {
> +		RTE_LOG(ERR, PDUMP, "Invalid port id %u, %s:%d\n", port,
> +			__func__, __LINE__);
> +		rte_errno = EINVAL;
> +		return -1;
> +	}
> +
> +	return 0;
> +}
> +
> +static int
> +pdump_prepare_client_request(char *device, bool is_pci_or_name, uint16_t queue,
> +				uint32_t dir,
> +				uint16_t operation,
> +				struct rte_ring *ring,
> +				struct rte_mempool *mp,
> +				void *filter)
> +{
> +	int ret;
> +	struct pdump_request req = {.ver = 1,};
> +
> +	req.dir = dir;
> +	req.op =  operation;
> +	if ((operation & ENABLE) != 0) {
> +		strncpy(req.data.en_v1.device, device, strlen(device));
> +		req.data.en_v1.is_pci_or_name = is_pci_or_name;
> +		req.data.en_v1.queue = queue;
> +		req.data.en_v1.ring = ring;
> +		req.data.en_v1.mp = mp;
> +		req.data.en_v1.filter = filter;
> +	} else {
> +		strncpy(req.data.dis_v1.device, device, strlen(device));
> +		req.data.dis_v1.is_pci_or_name = is_pci_or_name;
> +		req.data.dis_v1.queue = queue;
> +		req.data.dis_v1.ring = NULL;
> +		req.data.dis_v1.mp = NULL;
> +		req.data.dis_v1.filter = NULL;
> +	}
> +
> +	ret = pdump_create_client_socket(&req);
> +	if (ret < 0) {
> +		RTE_LOG(ERR, PDUMP, "client request for pdump enable/disable failed\n");
> +		rte_errno = ret;
> +		return -1;
> +	}
> +
> +	return 0;
> +}
> +
> +int
> +rte_pdump_enable(uint8_t port, uint16_t queue, uint32_t dir,
> +			struct rte_ring *ring,
> +			struct rte_mempool *mp,
> +			void *filter)
> +{
> +
> +	int ret = 0;
> +	char device[DEVICE_ID_SIZE];
> +
> +	ret = pdump_validate_port(port);
> +	if (ret < 0)
> +		return ret;
> +	ret = pdump_validate_ring_mp(ring, mp);
> +	if (ret < 0)
> +		return ret;
> +	pdump_validate_dir(dir);
> +	if (ret < 0)
> +		return ret;
> +
> +	snprintf(device, sizeof(device), "%u", port);
> +	ret = pdump_prepare_client_request(device, false, queue, dir,
> +						ENABLE, ring, mp, filter);
> +
> +	return ret;
> +}
> +
> +int
> +rte_pdump_enable_by_deviceid(char *device_id, uint16_t queue,
> +				uint32_t dir,
> +				struct rte_ring *ring,
> +				struct rte_mempool *mp,
> +				void *filter)
> +{
> +	int ret = 0;
> +
> +	ret = pdump_validate_ring_mp(ring, mp);
> +	if (ret < 0)
> +		return ret;
> +	ret = pdump_validate_dir(dir);
> +	if (ret < 0)
> +		return ret;
> +
> +	ret = pdump_prepare_client_request(device_id, true, queue, dir,
> +						ENABLE, ring, mp, filter);
> +
> +	return ret;
> +}
> +
> +int
> +rte_pdump_disable(uint8_t port, uint16_t queue, uint32_t dir)
> +{
> +	int ret = 0;
> +	char device[DEVICE_ID_SIZE];
> +
> +	ret = pdump_validate_port(port);
> +	if (ret < 0)
> +		return ret;
> +	ret = pdump_validate_dir(dir);
> +	if (ret < 0)
> +		return ret;
> +
> +	snprintf(device, sizeof(device), "%u", port);
> +	ret = pdump_prepare_client_request(device, false, queue, dir,
> +						DISABLE, NULL, NULL, NULL);
> +
> +	return ret;
> +}
> +
> +int
> +rte_pdump_disable_by_deviceid(char *device_id, uint16_t queue,
> +				uint32_t dir)
> +{
> +	int ret = 0;
> +
> +	ret = pdump_validate_dir(dir);
> +	if (ret < 0)
> +		return ret;
> +
> +	ret = pdump_prepare_client_request(device_id, true, queue, dir,
> +						DISABLE, NULL, NULL, NULL);
> +
> +	return ret;
> +}
> diff --git a/lib/librte_pdump/rte_pdump.h b/lib/librte_pdump/rte_pdump.h
> new file mode 100644
> index 0000000..fcd02de
> --- /dev/null
> +++ b/lib/librte_pdump/rte_pdump.h
> @@ -0,0 +1,186 @@
> +/*-
> + *   BSD LICENSE
> + *
> + *   Copyright(c) 2016 Intel Corporation. All rights reserved.
> + *   All rights reserved.
> + *
> + *   Redistribution and use in source and binary forms, with or without
> + *   modification, are permitted provided that the following conditions
> + *   are met:
> + *
> + *     * Redistributions of source code must retain the above copyright
> + *       notice, this list of conditions and the following disclaimer.
> + *     * Redistributions in binary form must reproduce the above copyright
> + *       notice, this list of conditions and the following disclaimer in
> + *       the documentation and/or other materials provided with the
> + *       distribution.
> + *     * Neither the name of Intel Corporation nor the names of its
> + *       contributors may be used to endorse or promote products derived
> + *       from this software without specific prior written permission.
> + *
> + *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> + *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> + *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
> + *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
> + *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
> + *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
> + *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
> + *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
> + *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
> + *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> + *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +
> +#ifndef _RTE_PDUMP_H_
> +#define _RTE_PDUMP_H_
> +
> +/**
> + * @file
> + * RTE pdump
> + *
> + * packet dump library to provide packet capturing support on dpdk.
> + */
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +#define RTE_PDUMP_ALL_QUEUES UINT16_MAX
> +
> +enum {
> +	RTE_PDUMP_FLAG_RX = 1,  /* receive direction */
> +	RTE_PDUMP_FLAG_TX = 2,  /* transmit direction */
> +	/* both receive and transmit directions */
> +	RTE_PDUMP_FLAG_RXTX = (RTE_PDUMP_FLAG_RX|RTE_PDUMP_FLAG_TX)
> +};
> +
> +/**
> + * Initialize packet capturing handling
> + *
> + * Creates pthread and server socket for handling clients
> + * requests to enable/disable rxtx callbacks.
> + *
> + * @return
> + *    0 on success, -1 on error
> + */
> +int
> +rte_pdump_init(void);
> +
> +/**
> + * Un initialize packet capturing handling
> + *
> + * Cancels pthread, close server socket, removes server socket address.
> + *
> + * @return
> + *    0 on success, -1 on error
> + */
> +int
> +rte_pdump_uninit(void);
> +
> +/**
> + * Enables packet capturing on given port and queue.
> + *
> + * @param port
> + *  port on which packet capturing should be enabled.
> + * @param queue
> + *  queue of a given port on which packet capturing should be enabled.
> + *  users should pass on value UINT16_MAX to enable packet capturing on all
> + *  queues of a given port.
> + * @param dir
> + *  dir specifies RTE_PDUMP_FLAG_RX/RTE_PDUMP_FLAG_TX/RTE_PDUMP_FLAG_RXTX
> + *  on which packet capturing should be enabled for a given port and queue.
> + * @param ring
> + *  ring on which captured packets will be enqueued for user.
> + * @param mp
> + *  mempool on to which original packets will be mirrored or duplicated.
> + * @param filter
> + *  place holder for packet filtering.
> + *
> + * @return
> + *    0 on success, -1 on error, rte_errno is set accordingly.
> + */
> +
> +int
> +rte_pdump_enable(uint8_t port, uint16_t queue, uint32_t dir,
> +		struct rte_ring *ring,
> +		struct rte_mempool *mp,
> +		void *filter);
> +
> +/**
> + * Disables packet capturing on given port and queue.
> + *
> + * @param port
> + *  port on which packet capturing should be disabled.
> + * @param queue
> + *  queue of a given port on which packet capturing should be disabled.
> + *  users should pass on value UINT16_MAX to disable packet capturing on all
> + *  queues of a given port.
> + * @param dir
> + *  dir specifies RTE_PDUMP_FLAG_RX/RTE_PDUMP_FLAG_TX/RTE_PDUMP_FLAG_RXTX
> + *  on which packet capturing should be enabled for a given port and queue.
> + *
> + * @return
> + *    0 on success, -1 on error, rte_errno is set accordingly.
> + */
> +
> +int
> +rte_pdump_disable(uint8_t port, uint16_t queue, uint32_t dir);
> +
> +/**
> + * Enables packet capturing on given device id and queue.
> + * device_id can be name or pci address of device.
> + *
> + * @param device_id
> + *  device id on which packet capturing should be enabled.
> + * @param queue
> + *  queue of a given device id on which packet capturing should be enabled.
> + *  users should pass on value UINT16_MAX to enable packet capturing on all
> + *  queues of a given device id.
> + * @param dir
> + *  dir specifies RTE_PDUMP_FLAG_RX/RTE_PDUMP_FLAG_TX/RTE_PDUMP_FLAG_RXTX
> + *  on which packet capturing should be enabled for a given port and queue.
> + * @param ring
> + *  ring on which captured packets will be enqueued for user.
> + * @param mp
> + *  mempool on to which original packets will be mirrored or duplicated.
> + * @param filter
> + *  place holder for packet filtering.
> + *
> + * @return
> + *    0 on success, -1 on error, rte_errno is set accordingly.
> + */
> +
> +int
> +rte_pdump_enable_by_deviceid(char *device_id, uint16_t queue,
> +				uint32_t dir,
> +				struct rte_ring *ring,
> +				struct rte_mempool *mp,
> +				void *filter);
> +
> +/**
> + * Disables packet capturing on given device_id and queue.
> + * device_id can be name or pci address of device.
> + *
> + * @param device_id
> + *  pci address or name of the device on which packet capturing
> + *  should be disabled.
> + * @param queue
> + *  queue of a given device on which packet capturing should be disabled.
> + *  users should pass on value UINT16_MAX to disable packet capturing on all
> + *  queues of a given device id.
> + * @param dir
> + *  dir specifies RTE_PDUMP_FLAG_RX/RTE_PDUMP_FLAG_TX/RTE_PDUMP_FLAG_RXTX
> + *  on which packet capturing should be enabled for a given port and queue.
> + *
> + * @return
> + *    0 on success, -1 on error, rte_errno is set accordingly.
> + */
> +int
> +rte_pdump_disable_by_deviceid(char *device_id, uint16_t queue,
> +				uint32_t dir);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +
> +#endif /* _RTE_PDUMP_H_ */
> diff --git a/lib/librte_pdump/rte_pdump_version.map b/lib/librte_pdump/rte_pdump_version.map
> new file mode 100644
> index 0000000..3e744f3
> --- /dev/null
> +++ b/lib/librte_pdump/rte_pdump_version.map
> @@ -0,0 +1,12 @@
> +DPDK_16.07 {
> +	global:
> +
> +	rte_pdump_disable;
> +	rte_pdump_disable_by_deviceid;
> +	rte_pdump_enable;
> +	rte_pdump_enable_by_deviceid;
> +	rte_pdump_init;
> +	rte_pdump_uninit;
> +
> +	local: *;
> +};
> diff --git a/mk/rte.app.mk b/mk/rte.app.mk
> index b84b56d..f792f2a 100644
> --- a/mk/rte.app.mk
> +++ b/mk/rte.app.mk
> @@ -61,6 +61,7 @@ _LDLIBS-y += --whole-archive
> 
>  _LDLIBS-$(CONFIG_RTE_LIBRTE_DISTRIBUTOR)    += -lrte_distributor
>  _LDLIBS-$(CONFIG_RTE_LIBRTE_REORDER)        += -lrte_reorder
> +_LDLIBS-$(CONFIG_RTE_LIBRTE_PDUMP)          += -lrte_pdump
> 
>  ifeq ($(CONFIG_RTE_EXEC_ENV_LINUXAPP),y)
>  _LDLIBS-$(CONFIG_RTE_LIBRTE_KNI)            += -lrte_kni
> --
> 2.5.0
Reshma Pattan May 27, 2016, 2:54 p.m. | #2
> -----Original Message-----
> From: Ananyev, Konstantin
> Sent: Friday, May 27, 2016 2:39 PM
> To: Pattan, Reshma <reshma.pattan@intel.com>; dev@dpdk.org
> Cc: Pattan, Reshma <reshma.pattan@intel.com>
> Subject: RE: [dpdk-dev] [PATCH v4 5/9] lib/librte_pdump: add new library for
> packet capturing support
> 
> Hi Reshma,

> > +static int
> > +pdump_regitser_callbacks(uint32_t dir, uint16_t end_q,
> > +			uint8_t port, uint16_t queue,
> > +			struct rte_ring *ring, struct rte_mempool *mp,
> > +			uint16_t operation)
> > +{
> > +
> > +	uint16_t qid;
> > +	struct pdump_rxtx_cbs *cbs = NULL;
> > +
> > +	qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
> > +	for (; qid < end_q; qid++) {
> > +		if ((dir & RTE_PDUMP_FLAG_RX) != 0)
> > +			cbs = &rx_cbs[port][qid];
> > +		if ((dir & RTE_PDUMP_FLAG_TX) != 0)
> > +			cbs = &tx_cbs[port][qid];
> 
> In case you have dir == (RTE_PDUMP_FLAG_RX | RTE_PDUMP_FLAG_TX) you'll
> overwrite your rx_cbs pointer with tx_cbs pointer.
> I suppose you need 2 local vars: cbs_rx and cbs_tx here.
> Again probably worth to have 2 helper functions:
> pdump_regitser_rx_callback() and pdump_regitser_tx_callback() and call them
> from that one.
> Or you'll never invoke that function with dir ==(RTE_PDUMP_FLAG_RX |
> RTE_PDUMP_FLAG_TX)?
> If so, it porbably worth to put it into comments, though if it would be me, I still
> think it would be good to split it in a way I mentioned above.
> 

Yes,  I never invoke the function with dir ==(RTE_PDUMP_FLAG_RX | RTE_PDUMP_FLAG_TX).

> > +
> > +	dir = p->dir;
> > +	operation = p->op;
> > +	if (operation == ENABLE) {
> > +		if (p->data.en_v1.is_pci_or_name == true) {
> > +			/* check if device is pci address or name */
> > +			if (pdump_get_dombdf(p->data.en_v1.device, domBDF)
> == 0)
> > +				ret = rte_eth_dev_get_port_by_name(domBDF,
> &port);
> > +			else
> > +				ret = rte_eth_dev_get_port_by_name(p-
> >data.en_v1.device,
> > +
> 	&port);
> 
> 
> Why we can't force client to have device name in predefined format?
> Then you woudn't need that name conversion here.

You mean  I should do the conversion pdump_get_dombdf() in client and then pass that value to server?

> 
> > +			if (ret < 0) {
> > +				RTE_LOG(ERR, PDUMP,
> > +					"failed to get potid for device
> id=%s\n",
> > +					p->data.en_v1.device);
> > +				return -EINVAL;
> > +			}
> > +		} else /* if device is port id */
> > +			port = atoi(p->data.en_v1.device);
> 
> Hmm, again why not make server to accept requests only by device id?
> Then it would be client responsibility to do port to device id, and you can get rid
> of some duplicated code here.

If client is secondary process then  the same port id on primary and secondary processes might be mapping to different devices right? 
If so I cannot do port id to device name conversion in client.

Thanks,
Reshma
Ananyev, Konstantin May 27, 2016, 3:25 p.m. | #3
> -----Original Message-----
> From: Pattan, Reshma
> Sent: Friday, May 27, 2016 3:55 PM
> To: Ananyev, Konstantin; dev@dpdk.org
> Cc: Pattan, Reshma
> Subject: RE: [dpdk-dev] [PATCH v4 5/9] lib/librte_pdump: add new library for packet capturing support
> 
> 
> 
> > -----Original Message-----
> > From: Ananyev, Konstantin
> > Sent: Friday, May 27, 2016 2:39 PM
> > To: Pattan, Reshma <reshma.pattan@intel.com>; dev@dpdk.org
> > Cc: Pattan, Reshma <reshma.pattan@intel.com>
> > Subject: RE: [dpdk-dev] [PATCH v4 5/9] lib/librte_pdump: add new library for
> > packet capturing support
> >
> > Hi Reshma,
> 
> > > +static int
> > > +pdump_regitser_callbacks(uint32_t dir, uint16_t end_q,
> > > +			uint8_t port, uint16_t queue,
> > > +			struct rte_ring *ring, struct rte_mempool *mp,
> > > +			uint16_t operation)
> > > +{
> > > +
> > > +	uint16_t qid;
> > > +	struct pdump_rxtx_cbs *cbs = NULL;
> > > +
> > > +	qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
> > > +	for (; qid < end_q; qid++) {
> > > +		if ((dir & RTE_PDUMP_FLAG_RX) != 0)
> > > +			cbs = &rx_cbs[port][qid];
> > > +		if ((dir & RTE_PDUMP_FLAG_TX) != 0)
> > > +			cbs = &tx_cbs[port][qid];
> >
> > In case you have dir == (RTE_PDUMP_FLAG_RX | RTE_PDUMP_FLAG_TX) you'll
> > overwrite your rx_cbs pointer with tx_cbs pointer.
> > I suppose you need 2 local vars: cbs_rx and cbs_tx here.
> > Again probably worth to have 2 helper functions:
> > pdump_regitser_rx_callback() and pdump_regitser_tx_callback() and call them
> > from that one.
> > Or you'll never invoke that function with dir ==(RTE_PDUMP_FLAG_RX |
> > RTE_PDUMP_FLAG_TX)?
> > If so, it porbably worth to put it into comments, though if it would be me, I still
> > think it would be good to split it in a way I mentioned above.
> >
> 
> Yes,  I never invoke the function with dir ==(RTE_PDUMP_FLAG_RX | RTE_PDUMP_FLAG_TX).

Ok, then at least probably comment it somehow.
Though I still think 2 different variables (and might be functions) would be better.

> 
> > > +
> > > +	dir = p->dir;
> > > +	operation = p->op;
> > > +	if (operation == ENABLE) {
> > > +		if (p->data.en_v1.is_pci_or_name == true) {
> > > +			/* check if device is pci address or name */
> > > +			if (pdump_get_dombdf(p->data.en_v1.device, domBDF)
> > == 0)
> > > +				ret = rte_eth_dev_get_port_by_name(domBDF,
> > &port);
> > > +			else
> > > +				ret = rte_eth_dev_get_port_by_name(p-
> > >data.en_v1.device,
> > > +
> > 	&port);
> >
> >
> > Why we can't force client to have device name in predefined format?
> > Then you woudn't need that name conversion here.
> 
> You mean  I should do the conversion pdump_get_dombdf() in client and then pass that value to server?

Yes.

> 
> >
> > > +			if (ret < 0) {
> > > +				RTE_LOG(ERR, PDUMP,
> > > +					"failed to get potid for device
> > id=%s\n",
> > > +					p->data.en_v1.device);
> > > +				return -EINVAL;
> > > +			}
> > > +		} else /* if device is port id */
> > > +			port = atoi(p->data.en_v1.device);
> >
> > Hmm, again why not make server to accept requests only by device id?
> > Then it would be client responsibility to do port to device id, and you can get rid
> > of some duplicated code here.
> 
> If client is secondary process then  the same port id on primary and secondary processes might be mapping to different devices right?

Yes.

> If so I cannot do port id to device name conversion in client.


Ok, but the client can do either port_enable/disable by client port id,
or (if that device is not mapped on the client) by device_id.

Konstantin


> 
> Thanks,
> Reshma
Reshma Pattan May 31, 2016, 2:55 p.m. | #4
> -----Original Message-----
> From: Ananyev, Konstantin
> Sent: Friday, May 27, 2016 4:26 PM
> To: Pattan, Reshma <reshma.pattan@intel.com>; dev@dpdk.org
> Subject: RE: [dpdk-dev] [PATCH v4 5/9] lib/librte_pdump: add new library for
> packet capturing support
> 
> 
> 
> > -----Original Message-----
> > From: Pattan, Reshma
> > Sent: Friday, May 27, 2016 3:55 PM
> > To: Ananyev, Konstantin; dev@dpdk.org
> > Cc: Pattan, Reshma
> > Subject: RE: [dpdk-dev] [PATCH v4 5/9] lib/librte_pdump: add new
> > library for packet capturing support
> >
> >
> >
> > > -----Original Message-----
> > > From: Ananyev, Konstantin
> > > Sent: Friday, May 27, 2016 2:39 PM
> > > To: Pattan, Reshma <reshma.pattan@intel.com>; dev@dpdk.org
> > > Cc: Pattan, Reshma <reshma.pattan@intel.com>
> > > Subject: RE: [dpdk-dev] [PATCH v4 5/9] lib/librte_pdump: add new
> > > library for packet capturing support
> > >
> > > Hi Reshma,
> >
> > > > +static int
> > > > +pdump_regitser_callbacks(uint32_t dir, uint16_t end_q,
> > > > +			uint8_t port, uint16_t queue,
> > > > +			struct rte_ring *ring, struct rte_mempool *mp,
> > > > +			uint16_t operation)
> > > > +{
> > > > +
> > > > +	uint16_t qid;
> > > > +	struct pdump_rxtx_cbs *cbs = NULL;
> > > > +
> > > > +	qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
> > > > +	for (; qid < end_q; qid++) {
> > > > +		if ((dir & RTE_PDUMP_FLAG_RX) != 0)
> > > > +			cbs = &rx_cbs[port][qid];
> > > > +		if ((dir & RTE_PDUMP_FLAG_TX) != 0)
> > > > +			cbs = &tx_cbs[port][qid];
> > >
> > > In case you have dir == (RTE_PDUMP_FLAG_RX | RTE_PDUMP_FLAG_TX)
> > > you'll overwrite your rx_cbs pointer with tx_cbs pointer.
> > > I suppose you need 2 local vars: cbs_rx and cbs_tx here.
> > > Again probably worth to have 2 helper functions:
> > > pdump_regitser_rx_callback() and pdump_regitser_tx_callback() and
> > > call them from that one.
> > > Or you'll never invoke that function with dir ==(RTE_PDUMP_FLAG_RX |
> > > RTE_PDUMP_FLAG_TX)?
> > > If so, it porbably worth to put it into comments, though if it would
> > > be me, I still think it would be good to split it in a way I mentioned above.
> > >
> >
> > Yes,  I never invoke the function with dir ==(RTE_PDUMP_FLAG_RX |
> RTE_PDUMP_FLAG_TX).
> 
> Ok, then at least probably comment it somehow.
> Though I still think 2 different variables (and might be functions) would be
> better.
> 
> >

Ok, I will add a comment.

Thanks,
Reshma
Reshma Pattan May 31, 2016, 3 p.m. | #5
> -----Original Message-----
> From: Ananyev, Konstantin
> Sent: Friday, May 27, 2016 2:39 PM
> To: Pattan, Reshma <reshma.pattan@intel.com>; dev@dpdk.org
> Cc: Pattan, Reshma <reshma.pattan@intel.com>
> Subject: RE: [dpdk-dev] [PATCH v4 5/9] lib/librte_pdump: add new library for
> packet capturing support
> 
> > +/* get socket path (/var/run if root, $HOME otherwise) */ static void
> > +pdump_get_socket_path(char *buffer, int bufsz, enum pdump_socktype
> > +type) {
> > +	const char *dir = SOCKET_PATH_VAR_RUN;
> > +	const char *home_dir = getenv(SOCKET_PATH_HOME);
> > +
> > +	if (getuid() != 0 && home_dir != NULL)
> > +		dir = home_dir;
> > +
> > +	mkdir(dir, 700);
> > +	if (type == SERVER)
> > +		snprintf(buffer, bufsz, SERVER_SOCKET, dir);
> > +	else
> > +		snprintf(buffer, bufsz, CLIENT_SOCKET, dir, getpid(),
> > +				rte_sys_gettid());
> 
> 
> Probably add internal_config.hugefile_prefix into the name too, in case there is
> multiple primary DPDK procs running?
> 

Since there is no public api in rte_eal to get internal_config.hugefile_prefix info, this cannot be affixed to the server name.
 
> Konstantin

Patch

diff --git a/MAINTAINERS b/MAINTAINERS
index 9dd0738..8656239 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -433,6 +433,10 @@  F: app/test/test_reorder*
 F: examples/packet_ordering/
 F: doc/guides/sample_app_ug/packet_ordering.rst
 
+Pdump
+M: Reshma Pattan <reshma.pattan@intel.com>
+F: lib/librte_pdump/
+
 Hierarchical scheduler
 M: Cristian Dumitrescu <cristian.dumitrescu@intel.com>
 F: lib/librte_sched/
diff --git a/config/common_base b/config/common_base
index 3535c6e..259bf0a 100644
--- a/config/common_base
+++ b/config/common_base
@@ -484,6 +484,11 @@  CONFIG_RTE_LIBRTE_DISTRIBUTOR=y
 CONFIG_RTE_LIBRTE_REORDER=y
 
 #
+# Compile the pdump library
+#
+CONFIG_RTE_LIBRTE_PDUMP=y
+
+#
 # Compile librte_port
 #
 CONFIG_RTE_LIBRTE_PORT=y
diff --git a/lib/Makefile b/lib/Makefile
index f254dba..ca7c02f 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -57,6 +57,7 @@  DIRS-$(CONFIG_RTE_LIBRTE_PORT) += librte_port
 DIRS-$(CONFIG_RTE_LIBRTE_TABLE) += librte_table
 DIRS-$(CONFIG_RTE_LIBRTE_PIPELINE) += librte_pipeline
 DIRS-$(CONFIG_RTE_LIBRTE_REORDER) += librte_reorder
+DIRS-$(CONFIG_RTE_LIBRTE_PDUMP) += librte_pdump
 
 ifeq ($(CONFIG_RTE_EXEC_ENV_LINUXAPP),y)
 DIRS-$(CONFIG_RTE_LIBRTE_KNI) += librte_kni
diff --git a/lib/librte_pdump/Makefile b/lib/librte_pdump/Makefile
new file mode 100644
index 0000000..af81a28
--- /dev/null
+++ b/lib/librte_pdump/Makefile
@@ -0,0 +1,55 @@ 
+#   BSD LICENSE
+#
+#   Copyright(c) 2016 Intel Corporation. All rights reserved.
+#   All rights reserved.
+#
+#   Redistribution and use in source and binary forms, with or without
+#   modification, are permitted provided that the following conditions
+#   are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in
+#       the documentation and/or other materials provided with the
+#       distribution.
+#     * Neither the name of Intel Corporation nor the names of its
+#       contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+#   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+#   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+include $(RTE_SDK)/mk/rte.vars.mk
+
+# library name
+LIB = librte_pdump.a
+
+CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR) -O3
+CFLAGS += -D_GNU_SOURCE
+
+EXPORT_MAP := rte_pdump_version.map
+
+LIBABIVER := 1
+
+# all source are stored in SRCS-y
+SRCS-$(CONFIG_RTE_LIBRTE_PDUMP) := rte_pdump.c
+
+# install this header file
+SYMLINK-$(CONFIG_RTE_LIBRTE_PDUMP)-include := rte_pdump.h
+
+# this lib depends upon:
+DEPDIRS-$(CONFIG_RTE_LIBRTE_PDUMP) += lib/librte_mbuf
+DEPDIRS-$(CONFIG_RTE_LIBRTE_PDUMP) += lib/librte_eal
+DEPDIRS-$(CONFIG_RTE_LIBRTE_PDUMP) += lib/librte_ether
+
+include $(RTE_SDK)/mk/rte.lib.mk
diff --git a/lib/librte_pdump/rte_pdump.c b/lib/librte_pdump/rte_pdump.c
new file mode 100644
index 0000000..915cd37
--- /dev/null
+++ b/lib/librte_pdump/rte_pdump.c
@@ -0,0 +1,816 @@ 
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2016 Intel Corporation. All rights reserved.
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <pthread.h>
+#include <stdbool.h>
+
+#include <rte_memcpy.h>
+#include <rte_mbuf.h>
+#include <rte_ethdev.h>
+#include <rte_lcore.h>
+#include <rte_log.h>
+#include <rte_errno.h>
+#include <rte_pci.h>
+
+#include "rte_pdump.h"
+
+#define SOCKET_PATH_VAR_RUN "/var/run/pdump_sockets"
+#define SOCKET_PATH_HOME "HOME/pdump_sockets"
+#define SERVER_SOCKET "%s/pdump_server_socket"
+#define CLIENT_SOCKET "%s/pdump_client_socket_%d_%u"
+#define DEVICE_ID_SIZE 64
+/* Macros for printing using RTE_LOG */
+#define RTE_LOGTYPE_PDUMP RTE_LOGTYPE_USER1
+
+enum pdump_operation {
+	DISABLE = 1,
+	ENABLE = 2
+};
+
+enum pdump_socktype {
+	SERVER = 1,
+	CLIENT = 2
+};
+
+enum pdump_version {
+	V1 = 1
+};
+
+static pthread_t pdump_thread;
+static int pdump_socket_fd;
+
+struct pdump_request {
+	uint16_t ver;
+	uint16_t op;
+	uint32_t dir;
+	union pdump_data {
+		struct enable_v1 {
+			char device[DEVICE_ID_SIZE];
+			uint16_t queue;
+			struct rte_ring *ring;
+			struct rte_mempool *mp;
+			void *filter;
+			bool is_pci_or_name;
+		} en_v1;
+		struct disable_v1 {
+			char device[DEVICE_ID_SIZE];
+			uint16_t queue;
+			struct rte_ring *ring;
+			struct rte_mempool *mp;
+			void *filter;
+			bool is_pci_or_name;
+		} dis_v1;
+	} data;
+};
+
+struct pdump_response {
+	uint16_t ver;
+	uint16_t res_op;
+	int32_t err_value;
+};
+
+static struct pdump_rxtx_cbs {
+	struct rte_ring *ring;
+	struct rte_mempool *mp;
+	struct rte_eth_rxtx_callback *cb;
+	void *filter;
+} rx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT],
+tx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT];
+
+static inline int
+pdump_pktmbuf_copy_data(struct rte_mbuf *seg, const struct rte_mbuf *m)
+{
+	if (rte_pktmbuf_tailroom(seg) < m->data_len) {
+		RTE_LOG(ERR, PDUMP, "User mempool: insufficient data_len of mbuf\n");
+		return -EINVAL;
+	}
+
+	seg->port = m->port;
+	seg->vlan_tci = m->vlan_tci;
+	seg->hash = m->hash;
+	seg->tx_offload = m->tx_offload;
+	seg->ol_flags = m->ol_flags;
+	seg->packet_type = m->packet_type;
+	seg->vlan_tci_outer = m->vlan_tci_outer;
+	seg->data_len = m->data_len;
+	seg->pkt_len = seg->data_len;
+	rte_memcpy(rte_pktmbuf_mtod(seg, void *),
+			rte_pktmbuf_mtod(m, void *),
+			rte_pktmbuf_data_len(seg));
+
+	__rte_mbuf_sanity_check(seg, 1);
+
+	return 0;
+}
+
+static inline struct rte_mbuf *
+pdump_pktmbuf_copy(struct rte_mbuf *m, struct rte_mempool *mp)
+{
+	struct rte_mbuf *m_dup, *seg, **prev;
+	uint32_t pktlen;
+	uint8_t nseg;
+
+	m_dup = rte_pktmbuf_alloc(mp);
+	if (unlikely(m_dup == NULL))
+		return NULL;
+
+	seg = m_dup;
+	prev = &seg->next;
+	pktlen = m->pkt_len;
+	nseg = 0;
+
+	do {
+		nseg++;
+		if (pdump_pktmbuf_copy_data(seg, m) < 0) {
+			rte_pktmbuf_free(m_dup);
+			return NULL;
+		}
+		*prev = seg;
+		prev = &seg->next;
+	} while ((m = m->next) != NULL &&
+			(seg = rte_pktmbuf_alloc(mp)) != NULL);
+
+	*prev = NULL;
+	m_dup->nb_segs = nseg;
+	m_dup->pkt_len = pktlen;
+
+	/* Allocation of new indirect segment failed */
+	if (unlikely(seg == NULL)) {
+		rte_pktmbuf_free(m_dup);
+		return NULL;
+	}
+
+	__rte_mbuf_sanity_check(m_dup, 1);
+	return m_dup;
+}
+
+static inline void
+pdump_copy(struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
+{
+	unsigned i;
+	int ring_enq;
+	uint16_t d_pkts = 0;
+	struct rte_mbuf *dup_bufs[nb_pkts];
+	struct pdump_rxtx_cbs *cbs;
+	struct rte_ring *ring;
+	struct rte_mempool *mp;
+	struct rte_mbuf *p;
+
+	cbs  = user_params;
+	ring = cbs->ring;
+	mp = cbs->mp;
+	for (i = 0; i < nb_pkts; i++) {
+		p = pdump_pktmbuf_copy(pkts[i], mp);
+		if (p)
+			dup_bufs[d_pkts++] = p;
+	}
+
+	ring_enq = rte_ring_enqueue_burst(ring, (void *)dup_bufs, d_pkts);
+	if (unlikely(ring_enq < d_pkts)) {
+		RTE_LOG(DEBUG, PDUMP, "only %d of packets enqueued to ring\n", ring_enq);
+		do {
+			rte_pktmbuf_free(dup_bufs[ring_enq]);
+		} while (++ring_enq < d_pkts);
+	}
+}
+
+static uint16_t
+pdump_rx(uint8_t port __rte_unused, uint16_t qidx __rte_unused,
+	struct rte_mbuf **pkts, uint16_t nb_pkts, uint16_t max_pkts __rte_unused,
+	void *user_params)
+{
+	pdump_copy(pkts, nb_pkts, user_params);
+	return nb_pkts;
+}
+
+static uint16_t
+pdump_tx(uint8_t port __rte_unused, uint16_t qidx __rte_unused,
+		struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
+{
+	pdump_copy(pkts, nb_pkts, user_params);
+	return nb_pkts;
+}
+
+static int
+pdump_get_dombdf(char *device_id, char *domBDF)
+{
+	int ret;
+	struct rte_pci_addr dev_addr = {0};
+
+	ret = eal_parse_pci_DomBDF(device_id, &dev_addr);
+	if (ret < 0)
+		return -1;
+
+	if (dev_addr.domain)
+		snprintf(domBDF, DEVICE_ID_SIZE, "%u:%u:%u.%u", dev_addr.domain,
+			dev_addr.bus, dev_addr.devid, dev_addr.function);
+	else
+		snprintf(domBDF, DEVICE_ID_SIZE, "%u:%u.%u", dev_addr.bus, dev_addr.devid,
+			dev_addr.function);
+
+	return 0;
+}
+
+static int
+pdump_regitser_callbacks(uint32_t dir, uint16_t end_q,
+			uint8_t port, uint16_t queue,
+			struct rte_ring *ring, struct rte_mempool *mp,
+			uint16_t operation)
+{
+
+	uint16_t qid;
+	struct pdump_rxtx_cbs *cbs = NULL;
+
+	qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
+	for (; qid < end_q; qid++) {
+		if ((dir & RTE_PDUMP_FLAG_RX) != 0)
+			cbs = &rx_cbs[port][qid];
+		if ((dir & RTE_PDUMP_FLAG_TX) != 0)
+			cbs = &tx_cbs[port][qid];
+		if (cbs && operation == ENABLE) {
+			if (cbs->cb) {
+				RTE_LOG(ERR, PDUMP,
+						"failed to add callback for port=%d and "
+						"queue=%d, callback already exists\n",
+						port, qid);
+				return -EEXIST;
+			}
+			cbs->ring = ring;
+			cbs->mp = mp;
+			if ((dir & RTE_PDUMP_FLAG_RX) != 0) {
+				cbs->cb = rte_eth_add_first_rx_callback(port, qid,
+									pdump_rx, cbs);
+				if (cbs->cb == NULL) {
+					RTE_LOG(ERR, PDUMP,
+						"failed to add rx callback, errno=%d\n",
+						rte_errno);
+					return rte_errno;
+				}
+			}
+			if ((dir & RTE_PDUMP_FLAG_TX) != 0) {
+				cbs->cb = rte_eth_add_tx_callback(port, qid, pdump_tx,
+									cbs);
+				if (cbs->cb == NULL) {
+					RTE_LOG(ERR, PDUMP,
+						"failed to add tx callback, errno=%d\n",
+						rte_errno);
+					return rte_errno;
+				}
+			}
+		}
+		if (cbs && operation == DISABLE) {
+			int ret;
+
+			if (cbs->cb == NULL) {
+				RTE_LOG(ERR, PDUMP,
+						"failed to delete non existing callback "
+						"for port=%d and queue=%d\n", port, qid);
+				return -EINVAL;
+			}
+			if ((dir & RTE_PDUMP_FLAG_RX) != 0) {
+				ret = rte_eth_remove_rx_callback(port, qid, cbs->cb);
+				if (ret < 0) {
+					RTE_LOG(ERR, PDUMP,
+						"failed to remove rx callback, errno=%d\n",
+						rte_errno);
+					return ret;
+				}
+			}
+			if ((dir & RTE_PDUMP_FLAG_TX) != 0) {
+				ret = rte_eth_remove_tx_callback(port, qid, cbs->cb);
+				if (ret < 0) {
+					RTE_LOG(ERR, PDUMP,
+						"failed to remove tx callback, errno=%d\n",
+						rte_errno);
+					return ret;
+				}
+			}
+			cbs->cb = NULL;
+		}
+	}
+
+	return 0;
+}
+
+static int
+set_pdump_rxtx_cbs(struct pdump_request *p)
+{
+	uint16_t nb_rx_q, nb_tx_q = 0, end_q, queue;
+	uint8_t port;
+	int ret = 0;
+	uint32_t dir;
+	uint16_t operation;
+	struct rte_ring *ring;
+	struct rte_mempool *mp;
+	char domBDF[DEVICE_ID_SIZE];
+
+	dir = p->dir;
+	operation = p->op;
+	if (operation == ENABLE) {
+		if (p->data.en_v1.is_pci_or_name == true) {
+			/* check if device is pci address or name */
+			if (pdump_get_dombdf(p->data.en_v1.device, domBDF) == 0)
+				ret = rte_eth_dev_get_port_by_name(domBDF, &port);
+			else
+				ret = rte_eth_dev_get_port_by_name(p->data.en_v1.device,
+									&port);
+			if (ret < 0) {
+				RTE_LOG(ERR, PDUMP,
+					"failed to get potid for device id=%s\n",
+					p->data.en_v1.device);
+				return -EINVAL;
+			}
+		} else /* if device is port id */
+			port = atoi(p->data.en_v1.device);
+		queue = p->data.en_v1.queue;
+		ring = p->data.en_v1.ring;
+		mp = p->data.en_v1.mp;
+	} else {
+		if (p->data.dis_v1.is_pci_or_name == true) {
+			/* check if device is pci address or name */
+			if (pdump_get_dombdf(p->data.dis_v1.device, domBDF) == 0)
+				ret = rte_eth_dev_get_port_by_name(domBDF, &port);
+			else
+				ret = rte_eth_dev_get_port_by_name(p->data.dis_v1.device,
+									&port);
+			if (ret < 0) {
+				RTE_LOG(ERR, PDUMP,
+					"failed to get potid for device id=%s\n",
+					p->data.dis_v1.device);
+				return -EINVAL;
+			}
+		} else /* if device is port id */
+			port = atoi(p->data.dis_v1.device);
+		queue = p->data.dis_v1.queue;
+		ring = p->data.dis_v1.ring;
+		mp = p->data.dis_v1.mp;
+	}
+
+	/* validation if packet capture is for all queues */
+	if (queue == RTE_PDUMP_ALL_QUEUES) {
+		struct rte_eth_dev_info dev_info;
+
+		rte_eth_dev_info_get(port, &dev_info);
+		nb_rx_q = dev_info.nb_rx_queues;
+		nb_tx_q = dev_info.nb_tx_queues;
+		if (nb_rx_q == 0 && dir == RTE_PDUMP_FLAG_RX) {
+			RTE_LOG(ERR, PDUMP, "number of rx queues cannot be 0\n");
+			return -EINVAL;
+		}
+		if (nb_tx_q == 0 && dir == RTE_PDUMP_FLAG_TX) {
+			RTE_LOG(ERR, PDUMP, "number of tx queues cannot be 0\n");
+			return -EINVAL;
+		}
+		if ((nb_tx_q == 0 || nb_rx_q == 0) && dir == RTE_PDUMP_FLAG_RXTX) {
+			RTE_LOG(ERR, PDUMP, "both tx&rx queues must be non zero\n");
+			return -EINVAL;
+		}
+	}
+
+	/* register RX callback for dir rx/rxtx */
+	if (dir == RTE_PDUMP_FLAG_RX || dir == RTE_PDUMP_FLAG_RXTX) {
+		end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_rx_q : queue + 1;
+		ret = pdump_regitser_callbacks(RTE_PDUMP_FLAG_RX, end_q, port, queue,
+						ring, mp, operation);
+		if (ret < 0)
+			return ret;
+	}
+
+	/* register TX callback for dir tx/rxtx */
+	if (dir == RTE_PDUMP_FLAG_TX || dir == RTE_PDUMP_FLAG_RXTX) {
+		end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_tx_q : queue + 1;
+		ret = pdump_regitser_callbacks(RTE_PDUMP_FLAG_TX, end_q, port, queue,
+						ring, mp, operation);
+		if (ret < 0)
+			return ret;
+	}
+
+	return ret;
+}
+
+/* get socket path (/var/run if root, $HOME otherwise) */
+static void
+pdump_get_socket_path(char *buffer, int bufsz, enum pdump_socktype type)
+{
+	const char *dir = SOCKET_PATH_VAR_RUN;
+	const char *home_dir = getenv(SOCKET_PATH_HOME);
+
+	if (getuid() != 0 && home_dir != NULL)
+		dir = home_dir;
+
+	mkdir(dir, 700);
+	if (type == SERVER)
+		snprintf(buffer, bufsz, SERVER_SOCKET, dir);
+	else
+		snprintf(buffer, bufsz, CLIENT_SOCKET, dir, getpid(),
+				rte_sys_gettid());
+}
+
+static int
+pdump_create_server_socket(void)
+{
+	int ret, socket_fd;
+	struct sockaddr_un addr;
+	socklen_t addr_len;
+
+	pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path), SERVER);
+	addr.sun_family = AF_UNIX;
+
+	/* remove if file already exists */
+	unlink(addr.sun_path);
+
+	/* set up a server socket */
+	socket_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
+	if (socket_fd < 0) {
+		RTE_LOG(ERR, PDUMP, "Failed to create server socket: %s, %s:%d\n",
+			strerror(errno), __func__, __LINE__);
+		return -1;
+	}
+
+	addr_len = sizeof(struct sockaddr_un);
+	ret = bind(socket_fd, (struct sockaddr *) &addr, addr_len);
+	if (ret) {
+		RTE_LOG(ERR, PDUMP, "Failed to bind to server socket: %s, %s:%d\n",
+			strerror(errno), __func__, __LINE__);
+		close(socket_fd);
+		return -1;
+	}
+
+	/* save the socket in local configuration */
+	pdump_socket_fd = socket_fd;
+
+	return 0;
+}
+
+static __attribute__((noreturn)) void *
+pdump_thread_main(__rte_unused void *arg)
+{
+	struct sockaddr_un cli_addr;
+	socklen_t cli_len;
+	struct pdump_request cli_req;
+	struct pdump_response resp;
+	int n;
+	int ret = 0;
+
+	/* host thread, never break out */
+	for (;;) {
+		/* recv client requests */
+		cli_len = sizeof(cli_addr);
+		n = recvfrom(pdump_socket_fd, &cli_req, sizeof(struct pdump_request), 0,
+				(struct sockaddr *)&cli_addr, &cli_len);
+		if (n < 0) {
+			RTE_LOG(ERR, PDUMP, "failed to recv from client:%s, %s:%d\n",
+					strerror(errno), __func__, __LINE__);
+			continue;
+		}
+
+		ret = set_pdump_rxtx_cbs(&cli_req);
+
+		resp.ver = cli_req.ver;
+		resp.res_op = cli_req.op;
+		resp.err_value = ret;
+		n = sendto(pdump_socket_fd, &resp, sizeof(struct pdump_response),
+			0, (struct sockaddr *)&cli_addr, cli_len);
+		if (n < 0) {
+			RTE_LOG(ERR, PDUMP, "failed to send to client:%s, %s:%d\n",
+					strerror(errno), __func__, __LINE__);
+		}
+	}
+}
+
+int
+rte_pdump_init(void)
+{
+	int ret = 0;
+	char thread_name[RTE_MAX_THREAD_NAME_LEN];
+
+	ret = pdump_create_server_socket();
+	if (ret != 0) {
+		RTE_LOG(ERR, PDUMP, "Failed to create server socket:%s:%d\n",
+			__func__, __LINE__);
+		return -1;
+	}
+
+	/* create the host thread to wait/handle pdump requests */
+	ret = pthread_create(&pdump_thread, NULL, pdump_thread_main, NULL);
+	if (ret != 0) {
+		RTE_LOG(ERR, PDUMP, "Failed to create the pdump thread:%s, %s:%d\n",
+			strerror(errno), __func__, __LINE__);
+		return -1;
+	}
+	/* Set thread_name for aid in debugging. */
+	snprintf(thread_name, RTE_MAX_THREAD_NAME_LEN, "pdump-thread");
+	ret = rte_thread_setname(pdump_thread, thread_name);
+	if (ret != 0) {
+		RTE_LOG(DEBUG, PDUMP,
+				"Failed to set thread name for pdump handling\n");
+	}
+
+	return 0;
+}
+
+int
+rte_pdump_uninit(void)
+{
+	int ret;
+
+	ret = pthread_cancel(pdump_thread);
+	if (ret != 0) {
+		RTE_LOG(ERR, PDUMP, "Failed to cancel the pdump thread:%s, %s:%d\n",
+			strerror(errno), __func__, __LINE__);
+		return -1;
+	}
+
+	ret = close(pdump_socket_fd);
+	if (ret != 0) {
+		RTE_LOG(ERR, PDUMP, "Failed to close server socket: %s, %s:%d\n",
+			strerror(errno), __func__, __LINE__);
+		return -1;
+	}
+
+	struct sockaddr_un addr;
+
+	pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path), SERVER);
+	ret = unlink(addr.sun_path);
+	if (ret != 0) {
+		RTE_LOG(ERR, PDUMP, "Failed to remove server socket addr: %s, %s:%d\n",
+			strerror(errno), __func__, __LINE__);
+		return -1;
+	}
+
+	return 0;
+}
+
+static int
+pdump_create_client_socket(struct pdump_request *p)
+{
+	int ret, socket_fd;
+	int pid;
+	int n;
+	struct pdump_response server_resp;
+	struct sockaddr_un addr, serv_addr, from;
+	socklen_t addr_len, serv_len;
+
+	pid = getpid();
+
+	socket_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
+	if (socket_fd < 0) {
+		RTE_LOG(ERR, PDUMP, "client socket(): %s:pid(%d):tid(%u), %s:%d\n",
+			strerror(errno), pid, rte_sys_gettid(), __func__, __LINE__);
+		ret = errno;
+		return ret;
+	}
+
+	pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path), CLIENT);
+	addr.sun_family = AF_UNIX;
+	addr_len = sizeof(struct sockaddr_un);
+
+	do {
+		ret = bind(socket_fd, (struct sockaddr *) &addr, addr_len);
+		if (ret) {
+			RTE_LOG(ERR, PDUMP, "client bind(): %s, %s:%d\n",
+					strerror(errno), __func__, __LINE__);
+			ret = errno;
+			break;
+		}
+
+		serv_len = sizeof(struct sockaddr_un);
+		memset(&serv_addr, 0, sizeof(serv_addr));
+		pdump_get_socket_path(serv_addr.sun_path, sizeof(serv_addr.sun_path),
+					SERVER);
+		serv_addr.sun_family = AF_UNIX;
+
+		n =  sendto(socket_fd, p, sizeof(struct pdump_request), 0,
+				(struct sockaddr *)&serv_addr, serv_len);
+		if (n < 0) {
+			RTE_LOG(ERR, PDUMP, "failed to send to server:%s, %s:%d\n",
+					strerror(errno), __func__, __LINE__);
+			ret =  errno;
+			break;
+		}
+
+		n = recvfrom(socket_fd, &server_resp, sizeof(struct pdump_response), 0,
+				(struct sockaddr *)&from, &serv_len);
+		if (n < 0) {
+			RTE_LOG(ERR, PDUMP, "failed to recv from server:%s, %s:%d\n",
+					strerror(errno), __func__, __LINE__);
+			ret = errno;
+			break;
+		}
+		ret = server_resp.err_value;
+	} while (0);
+
+	close(socket_fd);
+	unlink(addr.sun_path);
+	return ret;
+}
+
+static int
+pdump_validate_ring_mp(struct rte_ring *ring, struct rte_mempool *mp)
+{
+	if (ring == NULL || mp == NULL) {
+		RTE_LOG(ERR, PDUMP, "NULL ring or mempool are passed %s:%d\n",
+			__func__, __LINE__);
+		rte_errno = EINVAL;
+		return -1;
+	}
+	if (mp->flags & MEMPOOL_F_SP_PUT || mp->flags & MEMPOOL_F_SC_GET) {
+		RTE_LOG(ERR, PDUMP, "mempool with either SP or SC settings"
+			" is not valid for pdump, should have MP and MC settings\n");
+		rte_errno = EINVAL;
+		return -1;
+	}
+	if (ring->prod.sp_enqueue || ring->cons.sc_dequeue) {
+		RTE_LOG(ERR, PDUMP, "ring with either SP or SC settings"
+			" is not valid for pdump, should have MP and MC settings\n");
+		rte_errno = EINVAL;
+		return -1;
+	}
+
+	return 0;
+}
+
+static int
+pdump_validate_dir(uint32_t dir)
+{
+	if (dir != RTE_PDUMP_FLAG_RX && dir != RTE_PDUMP_FLAG_TX &&
+		dir != RTE_PDUMP_FLAG_RXTX) {
+		RTE_LOG(ERR, PDUMP, "invalid direction, should be either rx/tx/rxtx\n");
+		rte_errno = EINVAL;
+		return -1;
+	}
+
+	return 0;
+}
+
+static int
+pdump_validate_port(uint8_t port)
+{
+	if (port >= RTE_MAX_ETHPORTS) {
+		RTE_LOG(ERR, PDUMP, "Invalid port id %u, %s:%d\n", port,
+			__func__, __LINE__);
+		rte_errno = EINVAL;
+		return -1;
+	}
+
+	return 0;
+}
+
+static int
+pdump_prepare_client_request(char *device, bool is_pci_or_name, uint16_t queue,
+				uint32_t dir,
+				uint16_t operation,
+				struct rte_ring *ring,
+				struct rte_mempool *mp,
+				void *filter)
+{
+	int ret;
+	struct pdump_request req = {.ver = 1,};
+
+	req.dir = dir;
+	req.op =  operation;
+	if ((operation & ENABLE) != 0) {
+		strncpy(req.data.en_v1.device, device, strlen(device));
+		req.data.en_v1.is_pci_or_name = is_pci_or_name;
+		req.data.en_v1.queue = queue;
+		req.data.en_v1.ring = ring;
+		req.data.en_v1.mp = mp;
+		req.data.en_v1.filter = filter;
+	} else {
+		strncpy(req.data.dis_v1.device, device, strlen(device));
+		req.data.dis_v1.is_pci_or_name = is_pci_or_name;
+		req.data.dis_v1.queue = queue;
+		req.data.dis_v1.ring = NULL;
+		req.data.dis_v1.mp = NULL;
+		req.data.dis_v1.filter = NULL;
+	}
+
+	ret = pdump_create_client_socket(&req);
+	if (ret < 0) {
+		RTE_LOG(ERR, PDUMP, "client request for pdump enable/disable failed\n");
+		rte_errno = ret;
+		return -1;
+	}
+
+	return 0;
+}
+
+int
+rte_pdump_enable(uint8_t port, uint16_t queue, uint32_t dir,
+			struct rte_ring *ring,
+			struct rte_mempool *mp,
+			void *filter)
+{
+
+	int ret = 0;
+	char device[DEVICE_ID_SIZE];
+
+	ret = pdump_validate_port(port);
+	if (ret < 0)
+		return ret;
+	ret = pdump_validate_ring_mp(ring, mp);
+	if (ret < 0)
+		return ret;
+	pdump_validate_dir(dir);
+	if (ret < 0)
+		return ret;
+
+	snprintf(device, sizeof(device), "%u", port);
+	ret = pdump_prepare_client_request(device, false, queue, dir,
+						ENABLE, ring, mp, filter);
+
+	return ret;
+}
+
+int
+rte_pdump_enable_by_deviceid(char *device_id, uint16_t queue,
+				uint32_t dir,
+				struct rte_ring *ring,
+				struct rte_mempool *mp,
+				void *filter)
+{
+	int ret = 0;
+
+	ret = pdump_validate_ring_mp(ring, mp);
+	if (ret < 0)
+		return ret;
+	ret = pdump_validate_dir(dir);
+	if (ret < 0)
+		return ret;
+
+	ret = pdump_prepare_client_request(device_id, true, queue, dir,
+						ENABLE, ring, mp, filter);
+
+	return ret;
+}
+
+int
+rte_pdump_disable(uint8_t port, uint16_t queue, uint32_t dir)
+{
+	int ret = 0;
+	char device[DEVICE_ID_SIZE];
+
+	ret = pdump_validate_port(port);
+	if (ret < 0)
+		return ret;
+	ret = pdump_validate_dir(dir);
+	if (ret < 0)
+		return ret;
+
+	snprintf(device, sizeof(device), "%u", port);
+	ret = pdump_prepare_client_request(device, false, queue, dir,
+						DISABLE, NULL, NULL, NULL);
+
+	return ret;
+}
+
+int
+rte_pdump_disable_by_deviceid(char *device_id, uint16_t queue,
+				uint32_t dir)
+{
+	int ret = 0;
+
+	ret = pdump_validate_dir(dir);
+	if (ret < 0)
+		return ret;
+
+	ret = pdump_prepare_client_request(device_id, true, queue, dir,
+						DISABLE, NULL, NULL, NULL);
+
+	return ret;
+}
diff --git a/lib/librte_pdump/rte_pdump.h b/lib/librte_pdump/rte_pdump.h
new file mode 100644
index 0000000..fcd02de
--- /dev/null
+++ b/lib/librte_pdump/rte_pdump.h
@@ -0,0 +1,186 @@ 
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2016 Intel Corporation. All rights reserved.
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _RTE_PDUMP_H_
+#define _RTE_PDUMP_H_
+
+/**
+ * @file
+ * RTE pdump
+ *
+ * packet dump library to provide packet capturing support on dpdk.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RTE_PDUMP_ALL_QUEUES UINT16_MAX
+
+enum {
+	RTE_PDUMP_FLAG_RX = 1,  /* receive direction */
+	RTE_PDUMP_FLAG_TX = 2,  /* transmit direction */
+	/* both receive and transmit directions */
+	RTE_PDUMP_FLAG_RXTX = (RTE_PDUMP_FLAG_RX|RTE_PDUMP_FLAG_TX)
+};
+
+/**
+ * Initialize packet capturing handling
+ *
+ * Creates pthread and server socket for handling clients
+ * requests to enable/disable rxtx callbacks.
+ *
+ * @return
+ *    0 on success, -1 on error
+ */
+int
+rte_pdump_init(void);
+
+/**
+ * Un initialize packet capturing handling
+ *
+ * Cancels pthread, close server socket, removes server socket address.
+ *
+ * @return
+ *    0 on success, -1 on error
+ */
+int
+rte_pdump_uninit(void);
+
+/**
+ * Enables packet capturing on given port and queue.
+ *
+ * @param port
+ *  port on which packet capturing should be enabled.
+ * @param queue
+ *  queue of a given port on which packet capturing should be enabled.
+ *  users should pass on value UINT16_MAX to enable packet capturing on all
+ *  queues of a given port.
+ * @param dir
+ *  dir specifies RTE_PDUMP_FLAG_RX/RTE_PDUMP_FLAG_TX/RTE_PDUMP_FLAG_RXTX
+ *  on which packet capturing should be enabled for a given port and queue.
+ * @param ring
+ *  ring on which captured packets will be enqueued for user.
+ * @param mp
+ *  mempool on to which original packets will be mirrored or duplicated.
+ * @param filter
+ *  place holder for packet filtering.
+ *
+ * @return
+ *    0 on success, -1 on error, rte_errno is set accordingly.
+ */
+
+int
+rte_pdump_enable(uint8_t port, uint16_t queue, uint32_t dir,
+		struct rte_ring *ring,
+		struct rte_mempool *mp,
+		void *filter);
+
+/**
+ * Disables packet capturing on given port and queue.
+ *
+ * @param port
+ *  port on which packet capturing should be disabled.
+ * @param queue
+ *  queue of a given port on which packet capturing should be disabled.
+ *  users should pass on value UINT16_MAX to disable packet capturing on all
+ *  queues of a given port.
+ * @param dir
+ *  dir specifies RTE_PDUMP_FLAG_RX/RTE_PDUMP_FLAG_TX/RTE_PDUMP_FLAG_RXTX
+ *  on which packet capturing should be enabled for a given port and queue.
+ *
+ * @return
+ *    0 on success, -1 on error, rte_errno is set accordingly.
+ */
+
+int
+rte_pdump_disable(uint8_t port, uint16_t queue, uint32_t dir);
+
+/**
+ * Enables packet capturing on given device id and queue.
+ * device_id can be name or pci address of device.
+ *
+ * @param device_id
+ *  device id on which packet capturing should be enabled.
+ * @param queue
+ *  queue of a given device id on which packet capturing should be enabled.
+ *  users should pass on value UINT16_MAX to enable packet capturing on all
+ *  queues of a given device id.
+ * @param dir
+ *  dir specifies RTE_PDUMP_FLAG_RX/RTE_PDUMP_FLAG_TX/RTE_PDUMP_FLAG_RXTX
+ *  on which packet capturing should be enabled for a given port and queue.
+ * @param ring
+ *  ring on which captured packets will be enqueued for user.
+ * @param mp
+ *  mempool on to which original packets will be mirrored or duplicated.
+ * @param filter
+ *  place holder for packet filtering.
+ *
+ * @return
+ *    0 on success, -1 on error, rte_errno is set accordingly.
+ */
+
+int
+rte_pdump_enable_by_deviceid(char *device_id, uint16_t queue,
+				uint32_t dir,
+				struct rte_ring *ring,
+				struct rte_mempool *mp,
+				void *filter);
+
+/**
+ * Disables packet capturing on given device_id and queue.
+ * device_id can be name or pci address of device.
+ *
+ * @param device_id
+ *  pci address or name of the device on which packet capturing
+ *  should be disabled.
+ * @param queue
+ *  queue of a given device on which packet capturing should be disabled.
+ *  users should pass on value UINT16_MAX to disable packet capturing on all
+ *  queues of a given device id.
+ * @param dir
+ *  dir specifies RTE_PDUMP_FLAG_RX/RTE_PDUMP_FLAG_TX/RTE_PDUMP_FLAG_RXTX
+ *  on which packet capturing should be enabled for a given port and queue.
+ *
+ * @return
+ *    0 on success, -1 on error, rte_errno is set accordingly.
+ */
+int
+rte_pdump_disable_by_deviceid(char *device_id, uint16_t queue,
+				uint32_t dir);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _RTE_PDUMP_H_ */
diff --git a/lib/librte_pdump/rte_pdump_version.map b/lib/librte_pdump/rte_pdump_version.map
new file mode 100644
index 0000000..3e744f3
--- /dev/null
+++ b/lib/librte_pdump/rte_pdump_version.map
@@ -0,0 +1,12 @@ 
+DPDK_16.07 {
+	global:
+
+	rte_pdump_disable;
+	rte_pdump_disable_by_deviceid;
+	rte_pdump_enable;
+	rte_pdump_enable_by_deviceid;
+	rte_pdump_init;
+	rte_pdump_uninit;
+
+	local: *;
+};
diff --git a/mk/rte.app.mk b/mk/rte.app.mk
index b84b56d..f792f2a 100644
--- a/mk/rte.app.mk
+++ b/mk/rte.app.mk
@@ -61,6 +61,7 @@  _LDLIBS-y += --whole-archive
 
 _LDLIBS-$(CONFIG_RTE_LIBRTE_DISTRIBUTOR)    += -lrte_distributor
 _LDLIBS-$(CONFIG_RTE_LIBRTE_REORDER)        += -lrte_reorder
+_LDLIBS-$(CONFIG_RTE_LIBRTE_PDUMP)          += -lrte_pdump
 
 ifeq ($(CONFIG_RTE_EXEC_ENV_LINUXAPP),y)
 _LDLIBS-$(CONFIG_RTE_LIBRTE_KNI)            += -lrte_kni