@@ -998,6 +998,12 @@ CONFIG_RTE_KNI_PREEMPT_DEFAULT=y
#
CONFIG_RTE_LIBRTE_PDUMP=y
+#
+# Compile the pcapng library
+#
+CONFIG_RTE_LIBRTE_PCAPNG=y
+
+#
#
# Compile vhost user library
#
@@ -102,6 +102,8 @@ DIRS-$(CONFIG_RTE_LIBRTE_REORDER) += librte_reorder
DEPDIRS-librte_reorder := librte_eal librte_mempool librte_mbuf
DIRS-$(CONFIG_RTE_LIBRTE_PDUMP) += librte_pdump
DEPDIRS-librte_pdump := librte_eal librte_mempool librte_mbuf librte_ethdev
+DIRS-$(CONFIG_RTE_LIBRTE_PCAPNG) += librte_pcapng
+DEPDIRS-librte_pcapng := librte_eal librte_mbuf librte_ethdev librte_net
DIRS-$(CONFIG_RTE_LIBRTE_GSO) += librte_gso
DEPDIRS-librte_gso := librte_eal librte_mbuf librte_ethdev librte_net
DEPDIRS-librte_gso += librte_mempool
new file mode 100644
@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright(c) 2019 Microsoft Corporation
+
+include $(RTE_SDK)/mk/rte.vars.mk
+
+# library name
+LIB = librte_pcapng.a
+
+CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR) -O3
+CFLAGS += -DALLOW_EXPERIMENTAL_API
+
+EXPORT_MAP := rte_pcapng_version.map
+
+LIBABIVER := 1
+
+# all source are stored in SRCS-y
+SRCS-$(CONFIG_RTE_LIBRTE_PCAPNG) := rte_pcapng.c
+
+# install includes
+SYMLINK-$(CONFIG_RTE_LIBRTE_MBUF)-include := rte_pcapng.h
+
+include $(RTE_SDK)/mk/rte.lib.mk
new file mode 100644
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright(c) 2019 Microsoft Corporation
+
+version = 1
+sources = files('rte_pcapng.c')
+headers = files('rte_pcapng.h')
+
+allow_experimental_apis = true
+
+deps += ['ethdev']
new file mode 100644
@@ -0,0 +1,112 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2019 Microsoft Corporation
+ *
+ * Pcapng protocol data structures
+ * from Draft RFC
+ */
+
+enum pcapng_block_types {
+ PCAPNG_INTERFACE_BLOCK = 1,
+ PCAPNG_PACKET_BLOCK, /* Obsolete */
+ PCAPNG_SIMPLE_PACKET_BLOCK,
+ PCAPNG_NAME_RESOLUTION_BLOCK,
+ PCAPNG_INTERFACE_STATS_BLOCK,
+ PCAPNG_ENHANCED_PACKET_BLOCK,
+
+ PCAPNG_SECTION_BLOCK = 0x0A0D0D0A,
+};
+
+struct pcapng_option {
+ uint16_t code;
+ uint16_t length;
+ uint8_t data[];
+};
+
+#define PCAPNG_BYTE_ORDER_MAGIC 0x1A2B3C4D
+#define PCAPNG_MAJOR_VERS 1
+#define PCAPNG_MINOR_VERS 0
+
+enum pcapng_opt {
+ PCAPNG_OPT_END = 0,
+ PCAPNG_OPT_COMMENT = 1,
+};
+
+struct pcapng_section_header {
+ uint32_t block_type;
+ uint32_t block_length;
+ uint32_t byte_order_magic;
+ uint16_t major_version;
+ uint16_t minor_version;
+ uint64_t section_length;
+};
+
+enum pcapng_section_opt {
+ PCAPNG_SHB_HARDWARE = 2,
+ PCAPNG_SHB_OS = 3,
+ PCAPNG_SHB_USERAPPL = 4,
+};
+
+struct pcapng_interface_block {
+ uint32_t block_type; /* 1 */
+ uint32_t block_length;
+ uint16_t link_type;
+ uint16_t reserved;
+ uint32_t snap_len;
+};
+
+enum pcapng_interface_options {
+ PCAPNG_IFB_NAME = 2,
+ PCAPNG_IFB_DESCRIPTION,
+ PCAPNG_IFB_IPV4ADDR,
+ PCAPNG_IFB_IPV6ADDR,
+ PCAPNG_IFB_MACADDR,
+ PCAPNG_IFB_EUIADDR,
+ PCAPNG_IFB_SPEED,
+ PCAPNG_IFB_TSRESOL,
+ PCAPNG_IFB_TZONE,
+ PCAPNG_IFB_FILTER,
+ PCAPNG_IFB_OS,
+ PCAPNG_IFB_FCSLEN,
+ PCAPNG_IFB_TSOFFSET,
+ PCAPNG_IFB_HARDWARE,
+};
+
+struct pcapng_enhance_packet_block {
+ uint32_t block_type; /* 6 */
+ uint32_t block_length;
+ uint32_t interface_id;
+ uint32_t timestamp_hi;
+ uint32_t timestamp_lo;
+ uint32_t capture_length;
+ uint32_t original_length;
+};
+
+enum pcapng_epb_options {
+ PCAPNG_EPB_FLAGS = 2,
+ PCAPNG_EPB_HASH,
+ PCAPNG_EPB_DROPS
+};
+
+struct pcapng_simple_packet {
+ uint32_t block_type; /* 3 */
+ uint32_t block_length;
+ uint32_t packet_length;
+};
+
+struct pcapng_statistics {
+ uint32_t block_type; /* 5 */
+ uint32_t block_length;
+ uint32_t interface_id;
+ uint32_t timestamp_hi;
+ uint32_t timestamp_lo;
+};
+
+enum pcapng_isb_options {
+ PCAPNG_ISB_STARTTIME = 2,
+ PCAPNG_ISB_ENDTIME,
+ PCAPNG_ISB_IFRECV,
+ PCAPNG_ISB_IFDROP,
+ PCAPNG_ISB_FILTERACCEPT,
+ PCAPNG_ISB_OSDROP,
+ PCAPNG_ISB_USRDELIV
+};
new file mode 100644
@@ -0,0 +1,449 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2019 Microsoft Corporation
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/uio.h>
+#include <sys/utsname.h>
+#include <net/if.h>
+
+#include <rte_config.h>
+#include <rte_ethdev.h>
+#include <rte_mbuf.h>
+#include <rte_cycles.h>
+#include <rte_version.h>
+#include <rte_pcapng.h>
+#include <rte_malloc.h>
+
+#include "pcapng_proto.h"
+
+/* conversion from DPDK speed to PCAPNG */
+#define PCAPNG_MBPS_SPEED 1000000ull
+
+#define PCAPNG_MAX_COMMENT 256
+
+#define NS_PER_US 1000ul
+#define US_PER_SEC 1000ul
+#define NS_PER_SEC (NS_PER_US * US_PER_SEC)
+
+/* Private state for the library */
+struct rte_pcapng {
+ int outfd; /* output file */
+
+ uint64_t tsc_t0; /* TSC cycles when opened */
+ uint32_t tsc_per_us; /* TSC cycles per microsecond */
+ uint64_t tsc_offset; /* nanosecond since 1970 */
+
+ uint32_t next_index;
+ uint32_t port_index[RTE_MAX_ETHPORTS];
+};
+
+/* length of option including padding */
+static size_t pcapng_optlen(uint16_t len)
+{
+ return RTE_ALIGN(sizeof(struct pcapng_option) + len,
+ sizeof(uint32_t));
+}
+
+/* build TLV option and return location of next */
+static struct pcapng_option *
+pcapng_add_option(struct pcapng_option *popt, uint16_t code,
+ const void *data, uint16_t len)
+{
+ popt->code = code;
+ popt->length = len;
+ memcpy(popt->data, data, len);
+
+ return (struct pcapng_option *)((uint8_t *)popt + pcapng_optlen(len));
+}
+
+/*
+ * Convert from DPDK timestamp (tsc cycles)
+ * to what Pcapng uses (nanosecond since 1 Jan 1970 UTC)
+ */
+static inline uint64_t tsc_to_timestamp(const rte_pcapng_t *self,
+ uint64_t tsc)
+{
+ uint64_t ticks = tsc - self->tsc_t0;
+
+ return (ticks * NS_PER_US) / self->tsc_per_us + self->tsc_offset;
+}
+
+/*
+ * Write required initial section header describing the capture
+ */
+static int
+write_section_block(rte_pcapng_t *self,
+ const char *os, const char *hw,
+ const char *app, const char *comment)
+{
+ struct pcapng_section_header *hdr;
+ struct pcapng_option *opt;
+ void *buf;
+ size_t len;
+ ssize_t cc;
+
+ len = sizeof(*hdr);
+ if (hw)
+ len += pcapng_optlen(strlen(hw));
+ if (os)
+ len += pcapng_optlen(strlen(os));
+ if (app)
+ len += pcapng_optlen(strlen(app));
+ if (comment)
+ len += pcapng_optlen(strlen(comment));
+
+ len += pcapng_optlen(0);
+ len += sizeof(uint32_t);
+
+ buf = calloc(1, len);
+ if (!buf)
+ return -1;
+
+ hdr = (struct pcapng_section_header *)buf;
+ *hdr = (struct pcapng_section_header) {
+ .block_type = PCAPNG_SECTION_BLOCK,
+ .block_length = len,
+ .byte_order_magic = PCAPNG_BYTE_ORDER_MAGIC,
+ .major_version = PCAPNG_MAJOR_VERS,
+ .minor_version = PCAPNG_MINOR_VERS,
+ .section_length = UINT64_MAX,
+ };
+ hdr->block_length = len;
+
+ opt = (struct pcapng_option *)(hdr + 1);
+ if (comment)
+ opt = pcapng_add_option(opt, PCAPNG_OPT_COMMENT,
+ comment, strlen(comment));
+ if (hw)
+ opt = pcapng_add_option(opt, PCAPNG_SHB_HARDWARE,
+ hw, strlen(hw));
+ if (os)
+ opt = pcapng_add_option(opt, PCAPNG_SHB_OS,
+ os, strlen(os));
+ if (app)
+ opt = pcapng_add_option(opt, PCAPNG_SHB_USERAPPL,
+ app, strlen(app));
+
+ opt = pcapng_add_option(opt, PCAPNG_OPT_END, NULL, 0);
+ /* clone block_length after option */
+ memcpy(opt, &hdr->block_length, sizeof(uint32_t));
+
+ cc = write(self->outfd, buf, len);
+ free(buf);
+
+ return cc;
+}
+
+static int
+capture_header(rte_pcapng_t *self,
+ const char *os, const char *hw,
+ const char *app, const char *comment)
+{
+ char osbuf[256];
+
+ if (app == NULL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (os == NULL) {
+ struct utsname uts;
+
+ uname(&uts);
+ snprintf(osbuf, sizeof(osbuf),
+ "%s %s", uts.sysname, uts.release);
+ os = osbuf;
+ }
+
+ if (hw == NULL)
+ hw = rte_version();
+
+ if (write_section_block(self, os, hw, app, comment) > 0)
+ return 0;
+ else
+ return -1;
+}
+
+static ssize_t
+write_interface_block(rte_pcapng_t *self, const char *if_name,
+ uint64_t if_speed, const uint8_t *mac_addr,
+ const char *if_hw, const char *comment)
+{
+ struct pcapng_interface_block *hdr;
+ struct pcapng_option *opt;
+ const uint8_t tsresol = 9; /* nanosecond resolution */
+ size_t len = sizeof(*hdr);
+ ssize_t cc;
+ void *buf;
+
+ len += pcapng_optlen(sizeof(tsresol));
+ if (if_name)
+ len += pcapng_optlen(strlen(if_name));
+ if (mac_addr)
+ len += pcapng_optlen(6);
+ if (if_speed)
+ len += pcapng_optlen(sizeof(uint64_t));
+ if (if_hw)
+ len += pcapng_optlen(strlen(if_hw));
+ if (comment)
+ len += pcapng_optlen(strlen(comment));
+
+ len += pcapng_optlen(0);
+ len += sizeof(uint32_t);
+ buf = calloc(1, len);
+ if (!buf)
+ return -ENOMEM;
+
+ hdr = (struct pcapng_interface_block *)buf;
+ hdr->block_type = PCAPNG_INTERFACE_BLOCK;
+ hdr->link_type = 1; /* Ethernet */
+ hdr->block_length = len;
+
+ opt = (struct pcapng_option *)(hdr + 1);
+ if (if_name)
+ opt = pcapng_add_option(opt, PCAPNG_IFB_NAME,
+ if_name, strlen(if_name));
+ if (mac_addr)
+ opt = pcapng_add_option(opt, PCAPNG_IFB_MACADDR,
+ mac_addr, RTE_ETHER_ADDR_LEN);
+ if (if_speed)
+ opt = pcapng_add_option(opt, PCAPNG_IFB_SPEED,
+ &if_speed, sizeof(uint64_t));
+ opt = pcapng_add_option(opt, PCAPNG_IFB_TSRESOL,
+ &tsresol, sizeof(tsresol));
+ if (if_hw)
+ opt = pcapng_add_option(opt, PCAPNG_IFB_HARDWARE,
+ if_hw, strlen(if_hw));
+ if (comment)
+ opt = pcapng_add_option(opt, PCAPNG_OPT_COMMENT,
+ comment, strlen(comment));
+
+ opt = pcapng_add_option(opt, PCAPNG_OPT_END, NULL, 0);
+
+ memcpy(opt, &hdr->block_length, sizeof(uint32_t));
+ cc = write(self->outfd, buf, len);
+ free(buf);
+
+ return cc;
+}
+
+int
+rte_pcapng_add_interface(rte_pcapng_t *self, uint16_t port,
+ const char *comment, uint32_t flags)
+{
+ struct rte_eth_dev_info dev_info;
+ struct rte_ether_addr macaddr;
+ const struct rte_device *dev;
+ struct rte_eth_link link;
+ char ifname[IF_NAMESIZE];
+ char ifhw[256];
+ uint64_t speed = 0;
+ int cc;
+
+ if (flags != 0) {
+ rte_errno = EINVAL;
+ return -1;
+ }
+
+ rte_eth_dev_info_get(port, &dev_info);
+
+ /* make something like an interface name */
+ if (if_indextoname(dev_info.if_index, ifname) == NULL)
+ snprintf(ifname, IF_NAMESIZE, "dpdk:%u", port);
+
+ /* make a useful device hardware string */
+ dev = dev_info.device;
+ if (dev)
+ snprintf(ifhw, sizeof(ifhw),
+ "%s-%s", dev->bus->name, dev->name);
+
+ /* DPDK reports in units of Mbps */
+ rte_eth_link_get(port, &link);
+ if (link.link_status == ETH_LINK_UP)
+ speed = link.link_speed * PCAPNG_MBPS_SPEED;
+
+ rte_eth_macaddr_get(port, &macaddr);
+
+ cc = write_interface_block(self, ifname, speed,
+ macaddr.addr_bytes,
+ dev ? ifhw : NULL,
+ comment);
+ if (cc < 0) {
+ rte_errno = errno;
+ return -1;
+ }
+
+ self->port_index[port] = self->next_index++;
+ return 0;
+}
+
+/* Create new pcapng writer handle */
+rte_pcapng_t *
+rte_pcapng_fdopen(int fd,
+ const char *osname, const char *hardware,
+ const char *appname, const char *comment,
+ uint32_t flags)
+{
+ rte_pcapng_t *self;
+ struct timeval tv;
+
+ if (flags != 0) {
+ rte_errno = EINVAL;
+ return NULL;
+ }
+
+ self = rte_zmalloc("pcapng", sizeof(*self), 0);
+ if (!self) {
+ rte_errno = ENOMEM;
+ return NULL;
+ }
+
+ self->outfd = fd;
+
+ /* compute clock offsets */
+ self->tsc_t0 = rte_rdtsc();
+ self->tsc_per_us = rte_get_tsc_hz() / US_PER_SEC;
+ gettimeofday(&tv, NULL);
+ self->tsc_offset = (tv.tv_sec * US_PER_SEC + tv.tv_usec) * NS_PER_US;
+
+ if (capture_header(self, osname, hardware,
+ appname, comment) < 0)
+ goto error;
+
+ return self;
+
+error:
+ close(self->outfd);
+ rte_errno = errno;
+ rte_free(self);
+ return NULL;
+}
+
+void
+rte_pcapng_close(rte_pcapng_t *self)
+{
+ close(self->outfd);
+ rte_free(self);
+}
+
+int
+rte_pcapng_dump_packet(rte_pcapng_t *self, uint16_t port,
+ const struct rte_mbuf *m,
+ enum rte_pcapng_direction dir,
+ const char *comment)
+{
+ struct pcapng_enhance_packet_block hdr;
+ uint32_t snap_len, padded_len, pad_bytes;
+ uint64_t ts = tsc_to_timestamp(self, m->timestamp);
+ static uint64_t zero_pad;
+ struct pcapng_option *opt;
+ uint32_t flags = dir;
+ uint32_t options[512];
+ uint16_t i;
+ struct iovec iov[m->nb_segs + 4];
+ size_t len, optlen;
+
+#ifdef RTE_LIBRTE_ETHDEV_DEBUG
+ RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
+#endif
+ /* only handle single segment mbuf */
+ snap_len = rte_pktmbuf_data_len(m);
+ padded_len = RTE_ALIGN(snap_len, sizeof(uint32_t));
+ pad_bytes = padded_len - snap_len;
+
+ len = sizeof(hdr) + padded_len + sizeof(uint32_t);
+ opt = (struct pcapng_option *)options;
+
+ opt = pcapng_add_option(opt, PCAPNG_EPB_FLAGS,
+ &flags, sizeof(flags));
+
+ if (comment)
+ opt = pcapng_add_option(opt, PCAPNG_OPT_COMMENT, comment,
+ strnlen(comment, PCAPNG_MAX_COMMENT));
+
+ optlen = (char *)opt - (char *)options;
+ len += optlen;
+
+ hdr.block_type = PCAPNG_ENHANCED_PACKET_BLOCK;
+ hdr.block_length = len;
+
+ hdr.interface_id = self->port_index[port];
+ hdr.timestamp_hi = ts >> 32;
+ hdr.timestamp_lo = (uint32_t)ts;
+ hdr.capture_length = snap_len;
+ hdr.original_length = rte_pktmbuf_pkt_len(m);
+
+ iov[0].iov_base = &hdr;
+ iov[0].iov_len = sizeof(hdr);
+
+ for (i = 1; m; ++i, m = m->next) {
+ iov[i].iov_base = rte_pktmbuf_mtod(m, void *);
+ iov[i].iov_len = rte_pktmbuf_data_len(m);
+ }
+
+ if (pad_bytes > 0) {
+ iov[i].iov_base = &zero_pad;
+ iov[i].iov_len = pad_bytes;
+ ++i;
+ }
+
+ iov[i].iov_base = options;
+ iov[i].iov_len = optlen;
+ ++i;
+
+ iov[i].iov_base = &hdr.block_length;
+ iov[i].iov_len = sizeof(uint32_t);
+ ++i;
+
+ if (unlikely(writev(self->outfd, iov, i) < 0)) {
+ rte_errno = errno;
+ return -1;
+ }
+
+ return 0;
+}
+
+int
+rte_pcapng_dump_tx(rte_pcapng_t *out, uint16_t port,
+ struct rte_mbuf *pkts[], uint32_t nb_pkts)
+{
+ uint32_t i;
+ int r = 0;
+
+ for (i = 0; i < nb_pkts; i++) {
+ struct rte_mbuf *m = pkts[i];
+
+ r = rte_pcapng_dump_packet(out, port, m,
+ RTE_PCAPNG_DIR_OUTBOUND, NULL);
+ if (unlikely(r < 0))
+ break;
+ }
+
+ return r;
+}
+
+int
+rte_pcapng_dump_rx(rte_pcapng_t *out,
+ struct rte_mbuf *pkts[], uint32_t nb_pkts)
+{
+ uint32_t i;
+ int r = 0;
+
+ for (i = 0; i < nb_pkts; i++) {
+ struct rte_mbuf *m = pkts[i];
+
+ r = rte_pcapng_dump_packet(out, m->port, m,
+ RTE_PCAPNG_DIR_INBOUND, NULL);
+ if (unlikely(r < 0))
+ break;
+ }
+ return r;
+}
new file mode 100644
@@ -0,0 +1,132 @@
+/*
+ * Simple library to write files in Pcap-ng format.
+ * Copyright(c) 2019 Microsoft Corporation
+ * All rights reserved.
+ */
+
+
+/* Handle used for functions in this library. */
+typedef struct rte_pcapng rte_pcapng_t;
+
+/**
+ * Open new packet capture file
+ *
+ * @param fd
+ * file descriptor
+ * @param osname
+ * Operating system name.
+ * If NULL will be filled in based on result of utsname.
+ * @param hardware
+ * Hardware information.
+ * If NULL will be filled in with DPDK version.
+ * @param appname
+ * Applicaton name.
+ * @param comment
+ * Comment for the file (optional can be NULL)
+ * @param flags
+ * Options for capture (reserved must be 0)
+ * @return
+ * handle to library, or NULL in case of error (and rte_errno is set).
+ */
+__rte_experimental
+rte_pcapng_t *
+rte_pcapng_fdopen(int fd,
+ const char *osname, const char *hardware,
+ const char *appname, const char *comment,
+ uint32_t flags);
+
+
+enum rte_pcapng_direction {
+ RTE_PCAPNG_DIR_UNKNOWN = 0,
+ RTE_PCAPNG_DIR_INBOUND = 1,
+ RTE_PCAPNG_DIR_OUTBOUND = 2,
+};
+
+/**
+ * Add interface to capture file
+ * This must be done after opening and before dumping any packets.
+ * Call once for each port being followed.
+ *
+ * @param out
+ * The handle to the packet capture file
+ * @param port
+ * The Ethernet port being captured.
+ * @param comment
+ * Comment for the file (optional can be NULL)
+ * @param flags
+ * Options for capture (reserved must be 0)
+ * @return
+ * 0 on success, -1 on failure (and rte_errno is set).
+ */
+__rte_experimental
+int
+rte_pcapng_add_interface(rte_pcapng_t *self, uint16_t port,
+ const char *comment, uint32_t flags);
+
+/**
+ * Record packet in capture file
+ *
+ * @param out
+ * The handle to the packet capture file
+ * @param port
+ * The Ethernet port on which the packet is being sent.
+ * @param m
+ * The packet to record
+ * @param dir
+ * Direction in/out or unknown
+ * @param comment
+ * Comment to add to record
+ * @return
+ * 0 on success, -1 on failure
+ */
+__rte_experimental
+int
+rte_pcapng_dump_packet(rte_pcapng_t *self, uint16_t port,
+ const struct rte_mbuf *m,
+ enum rte_pcapng_direction dir,
+ const char *comment);
+/**
+ * Dump packets to be transmitted.
+ *
+ * @param out
+ * The handle to the packet capture file
+ * @param port_id
+ * The Ethernet port on which the packet is being sent.
+ * @param pkts
+ * The packets to be recorded.
+ * @param nb_pkts
+ * The number of packets in the burst pointed to by "pkts".
+ * @return
+ * 0 on success, -1 on failure (and rte_errno is set).
+ */
+__rte_experimental
+int
+rte_pcapng_dump_tx(rte_pcapng_t *out, uint16_t port,
+ struct rte_mbuf *pkts[], uint32_t nb_pkts);
+
+/**
+ * Dump a packets received.
+ *
+ * @param out
+ * The handle to the packet capture file
+ * @param pkts
+ * The packets to be recorded.
+ * @param nb_pkts
+ * The number of packets in the burst pointed to by "pkts".
+ * @return
+ * 0 on success, -1 on failure (and rte_errno is set).
+ */
+__rte_experimental
+int
+rte_pcapng_dump_rx(rte_pcapng_t *out,
+ struct rte_mbuf *pkts[], uint32_t nb_pkts);
+
+/**
+ * Close capture file
+ *
+ * @param self
+ * handle to library
+ */
+__rte_experimental
+void
+rte_pcapng_close(rte_pcapng_t *self);
new file mode 100644
@@ -0,0 +1,12 @@
+EXPERIMENTAL {
+ global:
+
+ rte_pcapng_fdopen;
+ rte_pcapng_add_interface;
+ rte_pcapng_dump_packet;
+ rte_pcapng_dump_tx;
+ rte_pcapng_dump_rx;
+ rte_pcapng_close;
+
+ local: *;
+};
@@ -21,7 +21,7 @@ libraries = [
'distributor', 'efd', 'eventdev',
'gro', 'gso', 'ip_frag', 'jobstats',
'kni', 'latencystats', 'lpm', 'member',
- 'power', 'pdump', 'rawdev',
+ 'power', 'pdump', 'rawdev', 'pcapng',
'rcu', 'reorder', 'sched', 'security', 'stack', 'vhost',
# ipsec lib depends on net, crypto and security
'ipsec',
@@ -42,6 +42,7 @@ _LDLIBS-$(CONFIG_RTE_LIBRTE_PORT) += -lrte_port
_LDLIBS-$(CONFIG_RTE_LIBRTE_PORT) += --no-whole-archive
_LDLIBS-$(CONFIG_RTE_LIBRTE_PDUMP) += -lrte_pdump
+_LDLIBS-$(CONFIG_RTE_LIBRTE_PCAPNG) += -lrte_pcapng
_LDLIBS-$(CONFIG_RTE_LIBRTE_DISTRIBUTOR) += -lrte_distributor
_LDLIBS-$(CONFIG_RTE_LIBRTE_IP_FRAG) += -lrte_ip_frag
_LDLIBS-$(CONFIG_RTE_LIBRTE_METER) += -lrte_meter