Packets are captured at each graph node with the node and mbuf metadata
as part of the pcap.
This is inspired from VPP.
Signed-off-by: Amit Prakash Shukla <amitpraka...@marvell.com>
---
doc/guides/sample_app_ug/l3_forward_graph.rst | 3 +
examples/l3fwd-graph/main.c | 12 +
lib/graph/graph_pcap_trace.c | 337 ++++++++++++++++++
lib/graph/graph_populate.c | 6 +-
lib/graph/meson.build | 5 +-
lib/graph/rte_graph_pcap_trace.h | 149 ++++++++
lib/graph/rte_graph_worker.h | 6 +
7 files changed, 515 insertions(+), 3 deletions(-)
create mode 100644 lib/graph/graph_pcap_trace.c
create mode 100644 lib/graph/rte_graph_pcap_trace.h
diff --git a/doc/guides/sample_app_ug/l3_forward_graph.rst
b/doc/guides/sample_app_ug/l3_forward_graph.rst
index 0a3e0d44ec..cf199bcf81 100644
--- a/doc/guides/sample_app_ug/l3_forward_graph.rst
+++ b/doc/guides/sample_app_ug/l3_forward_graph.rst
@@ -51,6 +51,7 @@ The application has a number of command line options similar
to l3fwd::
[--max-pkt-len PKTLEN]
[--no-numa]
[--per-port-pool]
+ [--pcap-enable]
Where,
@@ -69,6 +70,8 @@ Where,
* ``--per-port-pool:`` Optional, set to use independent buffer pools per port.
Without this option, single buffer pool is used for all ports.
+* ``--pcap-enable:`` Optional, Enables packet capture in pcap format on each
node with mbuf and node metadata.
+
For example, consider a dual processor socket platform with 8 physical cores,
where cores 0-7 and 16-23 appear on socket 0,
while cores 8-15 and 24-31 appear on socket 1.
diff --git a/examples/l3fwd-graph/main.c b/examples/l3fwd-graph/main.c
index 6dcb6ee92b..b6408310aa 100644
--- a/examples/l3fwd-graph/main.c
+++ b/examples/l3fwd-graph/main.c
@@ -404,6 +404,7 @@ static const char short_options[] = "p:" /* portmask */
#define CMD_LINE_OPT_NO_NUMA "no-numa"
#define CMD_LINE_OPT_MAX_PKT_LEN "max-pkt-len"
#define CMD_LINE_OPT_PER_PORT_POOL "per-port-pool"
+#define CMD_LINE_OPT_PCAP_ENABLE "pcap-enable"
enum {
/* Long options mapped to a short option */
@@ -416,6 +417,7 @@ enum {
CMD_LINE_OPT_NO_NUMA_NUM,
CMD_LINE_OPT_MAX_PKT_LEN_NUM,
CMD_LINE_OPT_PARSE_PER_PORT_POOL,
+ CMD_LINE_OPT_PARSE_PCAP_ENABLE,
};
static const struct option lgopts[] = {
@@ -424,6 +426,7 @@ static const struct option lgopts[] = {
{CMD_LINE_OPT_NO_NUMA, 0, 0, CMD_LINE_OPT_NO_NUMA_NUM},
{CMD_LINE_OPT_MAX_PKT_LEN, 1, 0, CMD_LINE_OPT_MAX_PKT_LEN_NUM},
{CMD_LINE_OPT_PER_PORT_POOL, 0, 0, CMD_LINE_OPT_PARSE_PER_PORT_POOL},
+ {CMD_LINE_OPT_PCAP_ENABLE, 0, 0, CMD_LINE_OPT_PARSE_PCAP_ENABLE},
{NULL, 0, 0, 0},
};
@@ -498,6 +501,11 @@ parse_args(int argc, char **argv)
per_port_pool = 1;
break;
+ case CMD_LINE_OPT_PARSE_PCAP_ENABLE:
+ printf("Packet capture enabled\n");
+ set_pcap_trace(1);
+ break;
+
default:
print_usage(prgname);
return -1;
@@ -831,6 +839,7 @@ main(int argc, char **argv)
local_port_conf.txmode.offloads |=
RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE;
+ local_port_conf.rxmode.offloads |= RTE_ETH_RX_OFFLOAD_RSS_HASH;
local_port_conf.rx_adv_conf.rss_conf.rss_hf &=
dev_info.flow_type_rss_offloads;
if (local_port_conf.rx_adv_conf.rss_conf.rss_hf !=
@@ -1116,6 +1125,9 @@ main(int argc, char **argv)
}
/* >8 End of adding route to ip4 graph infa. */
+ if (is_pcap_trace_enable())
+ rte_graph_pcap_trace_init();
+
/* Launch per-lcore init on every worker lcore */
rte_eal_mp_remote_launch(graph_main_loop, NULL, SKIP_MAIN);
diff --git a/lib/graph/graph_pcap_trace.c b/lib/graph/graph_pcap_trace.c
new file mode 100644
index 0000000000..c5be07de6d
--- /dev/null
+++ b/lib/graph/graph_pcap_trace.c
@@ -0,0 +1,337 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(C) 2022 Marvell International Ltd.
+ */
+
+#include <unistd.h>
+#include <sys/time.h>
+#include <fcntl.h>
+
+#include <rte_malloc.h>
+#include <rte_mbuf.h>
+#include <rte_net.h>
+#include <rte_flow.h>
+
+#include "rte_graph_worker.h"
+
+#define RTE_PCAP_MAJOR_VERSION 1
+#define RTE_PCAP_MINOR_VERSION 0
+#define MAX_PKT_TO_CAPTURE 200
+#define MAX_PCAP_BUF_SZ 2048
+
+#define PCAP_DUMP_STR(buf, buf_size, cur_len, ...) \
+do { \
+ if (cur_len >= buf_size) \
+ break; \
+ cur_len += snprintf(buf + cur_len, buf_size - cur_len, __VA_ARGS__); \
+} while (0)
+
+#define PCAP_DUMP_DATA(dbuf, buf_size, cur_len, sbuf, len) \
+do { \
+ if ((cur_len + len) >= buf_size) \
+ break; \
+ rte_memcpy(dbuf + cur_len, sbuf, len); \
+ cur_len += len; \
+} while (0)
+
+static int pcap_trace_enable;
+static pcap_trace_t pcap_trace;
+
+static uint16_t pkt_metadata_dump(struct rte_mbuf *mbuf, char *buffer,
+ size_t buf_size, uint16_t cur_len);
+static int pcap_trace_close(void);
+static int pcap_trace_write(void);
+
+void
+rte_graph_pcap_trace_init(void)
+{
+ memset(&pcap_trace, 0, sizeof(pcap_trace_t));
+ rte_spinlock_init(&pcap_trace.lock);
+ pcap_trace.packet_type = PCAP_PACKET_TYPE_USER13;
+ pcap_trace.n_packets_to_capture = MAX_PKT_TO_CAPTURE;
+ pcap_trace.file_name = "/tmp/dpdk.pcap";
+ pcap_trace.pcap_data = NULL;
+}
+
+void
+set_pcap_trace(int val)
+{
+ pcap_trace_enable = val;
+}
+
+int
+is_pcap_trace_enable(void)
+{
+ return pcap_trace_enable;
+}
+
+static int
+pcap_trace_close(void)
+{
+ close(pcap_trace.file_descriptor);
+ pcap_trace.file_descriptor = -1;
+ return 0;
+}
+
+static int
+pcap_trace_write(void)
+{
+ pcap_file_header_t file_hdr;
+ int ret = 0;
+ int n;
+
+ if (!pcap_trace.file_name)
+ pcap_trace.file_name = "/tmp/dpdk.pcap";
+
+ pcap_trace.file_descriptor = open(pcap_trace.file_name,
+ O_CREAT | O_TRUNC | O_WRONLY, 0664);
+ if (pcap_trace.file_descriptor < 0) {
+ ret = 1;
+ goto done;
+ }
+ pcap_trace.n_pcap_data_written = 0;
+
+ /* Write file header. */
+ memset(&file_hdr, 0, sizeof(file_hdr));
+ file_hdr.magic = 0xa1b2c3d4;
+ file_hdr.major_version = 2;
+ file_hdr.minor_version = 4;
+ file_hdr.time_zone = 0;
+ file_hdr.max_packet_size_in_bytes = ((1 << 16) - 1);
+ file_hdr.packet_type = pcap_trace.packet_type;
+ n = write(pcap_trace.file_descriptor, &file_hdr, sizeof(file_hdr));
+ if (n != sizeof(file_hdr)) {
+ ret = 1;
+ goto done;
+ }
+
+ while (pcap_trace.n_bytes > pcap_trace.n_pcap_data_written) {
+ int n = pcap_trace.n_bytes - pcap_trace.n_pcap_data_written;
+
+ n = write(pcap_trace.file_descriptor,
+ (pcap_trace.pcap_data +
+ pcap_trace.n_pcap_data_written), n);
+
+ if (n < 0 && errno != 0) {
+ ret = 1;
+ goto done;
+ }
+
+ pcap_trace.n_pcap_data_written += n;
+ }
+
+ if (pcap_trace.n_pcap_data_written >= pcap_trace.n_bytes) {
+ rte_free(pcap_trace.pcap_data);
+ pcap_trace.pcap_data = NULL;
+ pcap_trace.n_pcap_data_written = 0;
+ }
+
+ if (pcap_trace.n_packets_captured >=
+ pcap_trace.n_packets_to_capture)
+ pcap_trace_close();
+
+done:
+ if (ret) {
+ if (pcap_trace.file_descriptor >= 0)
+ pcap_trace_close();
+ }
+
+ return ret;
+}
+
+static uint16_t
+pkt_metadata_dump(struct rte_mbuf *mbuf, char *buffer, size_t buf_size,
+ uint16_t cur_len)
+{
+ struct rte_flow_restore_info info = { 0, };
+ struct rte_net_hdr_lens hdr_lens;
+ struct rte_flow_error error;
+ uint32_t sw_packet_type;
+ uint64_t ol_flags;
+ char buf[256];
+ int ret;
+
+ ret = rte_flow_get_restore_info(mbuf->port, mbuf, &info, &error);
+ if (!ret) {
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "restore info:");
+
+ if (info.flags & RTE_FLOW_RESTORE_INFO_ENCAPSULATED)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "outer header present. ");
+ else
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "no outer header. ");
+ if (info.flags & RTE_FLOW_RESTORE_INFO_GROUP_ID)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "miss group %u", info.group_id);
+ else
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "no miss group");
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "\n");
+ }
+
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "pool=%s length=%u nb_segs=%d\n", mbuf->pool->name,
+ (unsigned int) mbuf->pkt_len, (int)mbuf->nb_segs);
+
+ ol_flags = mbuf->ol_flags;
+ if (ol_flags & RTE_MBUF_F_RX_RSS_HASH) {
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "RSS hash=0x%x\n",
+ (unsigned int) mbuf->hash.rss);
+ }
+
+ if (ol_flags & RTE_MBUF_F_RX_FDIR) {
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "FDIR matched ");
+ if (ol_flags & RTE_MBUF_F_RX_FDIR_ID)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "ID=0x%x\n", mbuf->hash.fdir.hi);
+ else if (ol_flags & RTE_MBUF_F_RX_FDIR_FLX)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "flex bytes=0x%08x %08x\n",
+ mbuf->hash.fdir.hi, mbuf->hash.fdir.lo);
+ else
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "hash=0x%x ID=0x%x\n",
+ mbuf->hash.fdir.hash, mbuf->hash.fdir.id);
+ }
+
+ if (ol_flags & RTE_MBUF_F_RX_QINQ)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "QinQ VLAN tci=0x%x, VLAN tci outer=0x%x\n",
+ mbuf->vlan_tci, mbuf->vlan_tci_outer);
+ else if (ol_flags & RTE_MBUF_F_RX_VLAN)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "VLAN tci=0x%x\n",
+ mbuf->vlan_tci);
+
+ if (mbuf->packet_type) {
+ rte_get_ptype_name(mbuf->packet_type, buf, sizeof(buf));
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "hw ptype: %s\n",
+ buf);
+ }
+
+ sw_packet_type = rte_net_get_ptype(mbuf, &hdr_lens, RTE_PTYPE_ALL_MASK);
+ rte_get_ptype_name(sw_packet_type, buf, sizeof(buf));
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "sw ptype: %s\n", buf);
+
+ if (sw_packet_type & RTE_PTYPE_L2_MASK)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "l2_len=%d ",
+ hdr_lens.l2_len);
+ if (sw_packet_type & RTE_PTYPE_L3_MASK)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "l3_len=%d ",
+ hdr_lens.l3_len);
+ if (sw_packet_type & RTE_PTYPE_L4_MASK)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "l4_len=%d ",
+ hdr_lens.l4_len);
+ if (sw_packet_type & RTE_PTYPE_TUNNEL_MASK)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "tunnel_len=%d ", hdr_lens.tunnel_len);
+ if (sw_packet_type & RTE_PTYPE_INNER_L2_MASK)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "inner_l2_len=%d ", hdr_lens.inner_l2_len);
+ if (sw_packet_type & RTE_PTYPE_INNER_L3_MASK)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "inner_l3_len=%d ", hdr_lens.inner_l3_len);
+ if (sw_packet_type & RTE_PTYPE_INNER_L4_MASK)
+ PCAP_DUMP_STR(buffer, buf_size, cur_len,
+ "inner_l4_len=%d ", hdr_lens.inner_l4_len);
+
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "\n");
+
+ rte_get_rx_ol_flag_list(mbuf->ol_flags, buf, sizeof(buf));
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "Rx ol_flags: %s\n", buf);
+
+ rte_get_tx_ol_flag_list(mbuf->ol_flags, buf, sizeof(buf));
+ PCAP_DUMP_STR(buffer, buf_size, cur_len, "Tx ol_flags: %s\n", buf);
+
+ /* Keep it last. */
+ buffer[cur_len++] = '\0';
+ return cur_len;
+}
+
+uint16_t
+rte_graph_pcap_trace_dispatch(struct rte_graph *graph __rte_unused,
+ struct rte_node *node, void **objs,
+ uint16_t nb_objs)
+{
+ struct rte_mbuf *mbuf;
+ pcap_packet_header_t *phdr;
+ pcap_version_hdr_t vhdr = {0};
+ struct timeval ts = {0};
+ char buffer[MAX_PCAP_BUF_SZ] = {0};
+ uint16_t total_len, n_bytes, cb_len;
+ uint8_t *pkt_data;
+ uint8_t *data;
+ int i;
+
+ gettimeofday(&ts, NULL);
+
+ for (i = 0; i < nb_objs; i++) {
+ if (pcap_trace.n_packets_captured >=
+ pcap_trace.n_packets_to_capture)
+ break;
+
+ mbuf = (struct rte_mbuf *)objs[i];
+
+ memset(buffer, 0, sizeof(buffer));
+ cb_len = 0;
+ total_len = 0;
+ n_bytes = 0;
+
+ vhdr.pcap_major_version = (uint8_t)RTE_PCAP_MAJOR_VERSION;
+ vhdr.pcap_minor_version = (uint8_t)RTE_PCAP_MINOR_VERSION;
+ PCAP_DUMP_DATA(buffer, MAX_PCAP_BUF_SZ, cb_len, &vhdr,
+ sizeof(pcap_version_hdr_t));
+
+ PCAP_DUMP_DATA(buffer, MAX_PCAP_BUF_SZ, cb_len, node->name,
+ (strlen(node->name) + 1));
+
+ PCAP_DUMP_DATA(buffer, MAX_PCAP_BUF_SZ, cb_len, node->ctx,
+ RTE_NODE_CTX_SZ);
+
+ cb_len = pkt_metadata_dump(mbuf, buffer, sizeof(buffer),
+ cb_len);
+
+ total_len = cb_len + mbuf->pkt_len +
+ sizeof(pcap_packet_header_t);
+ n_bytes = RTE_MIN((int)total_len, 16384);
+
+ rte_spinlock_lock(&pcap_trace.lock);
+
+ if (pcap_trace.pcap_data == NULL) {
+ pcap_trace.pcap_data = rte_malloc(NULL, n_bytes, 0);
+ phdr = (pcap_packet_header_t *)pcap_trace.pcap_data;
+ } else {
+ pcap_trace.pcap_data = rte_realloc(
+ pcap_trace.pcap_data,
+ (pcap_trace.n_bytes + n_bytes), 0);
+
+ phdr = (pcap_packet_header_t *)(pcap_trace.pcap_data +
+ pcap_trace.n_bytes);
+ }
+
+ phdr->time_in_sec = (uint32_t)ts.tv_sec;
+ phdr->time_in_usec = (uint32_t)ts.tv_usec;
+ phdr->n_packet_bytes_stored_in_file =
+ (n_bytes - sizeof(pcap_packet_header_t));
+ phdr->n_bytes_in_packet =
+ (total_len - sizeof(pcap_packet_header_t));
+ data = phdr->data;
+
+ rte_memcpy(data, buffer, cb_len);
+ data += cb_len;
+
+ pkt_data = rte_pktmbuf_mtod(mbuf, uint8_t *);
+ rte_memcpy(data, pkt_data, (RTE_MIN((n_bytes - cb_len),
+ mbuf->data_len)));
+
+ pcap_trace.n_bytes += n_bytes;
+ pcap_trace.n_packets_captured++;
+
+ if (pcap_trace.n_packets_captured == MAX_PKT_TO_CAPTURE)
+ pcap_trace_write();
+
+ rte_spinlock_unlock(&pcap_trace.lock);
+ }
+
+ return node->p_process(graph, node, objs, nb_objs);
+}
diff --git a/lib/graph/graph_populate.c b/lib/graph/graph_populate.c
index 102fd6c29b..36f81505df 100644
--- a/lib/graph/graph_populate.c
+++ b/lib/graph/graph_populate.c
@@ -75,7 +75,11 @@ graph_nodes_populate(struct graph *_graph)
memset(node, 0, sizeof(*node));
node->fence = RTE_GRAPH_FENCE;
node->off = off;
- node->process = graph_node->node->process;
+ if (is_pcap_trace_enable()) {
+ node->process = rte_graph_pcap_trace_dispatch;
+ node->p_process = graph_node->node->process;
+ } else
+ node->process = graph_node->node->process;
memcpy(node->name, graph_node->node->name, RTE_GRAPH_NAMESIZE);
pid = graph_node->node->parent_id;
if (pid != RTE_NODE_ID_INVALID) { /* Cloned node */
diff --git a/lib/graph/meson.build b/lib/graph/meson.build
index c7327549e8..6cd9d836d9 100644
--- a/lib/graph/meson.build
+++ b/lib/graph/meson.build
@@ -14,7 +14,8 @@ sources = files(
'graph_debug.c',
'graph_stats.c',
'graph_populate.c',
+ 'graph_pcap_trace.c',
)
-headers = files('rte_graph.h', 'rte_graph_worker.h')
+headers = files('rte_graph.h', 'rte_graph_worker.h', 'rte_graph_pcap_trace.h')
-deps += ['eal']
+deps += ['eal', 'mbuf', 'mempool', 'net', 'ethdev']
diff --git a/lib/graph/rte_graph_pcap_trace.h b/lib/graph/rte_graph_pcap_trace.h
new file mode 100644
index 0000000000..e2faf6205f
--- /dev/null
+++ b/lib/graph/rte_graph_pcap_trace.h
@@ -0,0 +1,149 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(C) 2022 Marvell International Ltd.
+ */
+
+#ifndef _DPDK_GRAPH_PCAP_TRACE_H_
+#define _DPDK_GRAPH_PCAP_TRACE_H_
+
+/**
+ * @file rte_graph_pcap_trace.h
+ *
+ * @warning
+ * @b EXPERIMENTAL:
+ * All functions in this file may be changed or removed without prior notice.
+ *
+ * This API enables to capture packet at each node with mbuf and node metadata.
+ *
+ */
+
+#include <rte_spinlock.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * User packet type used in pcap file is used by wireshark to lookup into the
+ * DLT table to know which protocol(s) to use for each DLT.
+ */
+typedef enum {
+ PCAP_PACKET_TYPE_USER0 = 147,
+ PCAP_PACKET_TYPE_USER1,
+ PCAP_PACKET_TYPE_USER2,
+ PCAP_PACKET_TYPE_USER3,
+ PCAP_PACKET_TYPE_USER4,
+ PCAP_PACKET_TYPE_USER5,
+ PCAP_PACKET_TYPE_USER6,
+ PCAP_PACKET_TYPE_USER7,
+ PCAP_PACKET_TYPE_USER8,
+ PCAP_PACKET_TYPE_USER9,
+ PCAP_PACKET_TYPE_USER10,
+ PCAP_PACKET_TYPE_USER11,
+ PCAP_PACKET_TYPE_USER12,
+ PCAP_PACKET_TYPE_USER13,
+ PCAP_PACKET_TYPE_USER14,
+ PCAP_PACKET_TYPE_USER15,
+} pcap_packet_type_t;
+
+/**
+ * Pcap file shall contain a header at the start of the file. Parameters are
+ * dissected by the wireshark to display the data.
+ */
+typedef struct pcap_file_header {
+ uint32_t magic;
+ uint16_t major_version;
+ uint16_t minor_version;
+ uint32_t time_zone;
+ uint32_t sigfigs;
+ uint32_t max_packet_size_in_bytes;
+ uint32_t packet_type;
+} pcap_file_header_t;
+
+/**
+ * Each packet shall be prepended by the packet header.
+ */
+typedef struct pcap_packet_header_t {
+ uint32_t time_in_sec;
+ uint32_t time_in_usec;
+ uint32_t n_packet_bytes_stored_in_file;
+ uint32_t n_bytes_in_packet;
+ /** Packet data follows. */
+ uint8_t data[0];
+} pcap_packet_header_t;
+
+/**
+ * Pcap version header.
+ */
+typedef struct pcap_version_hdr {
+ uint8_t pcap_major_version;
+ uint8_t pcap_minor_version;
+} pcap_version_hdr_t;
+
+/**
+ * Book-keeping of the packets captured.
+ */
+typedef struct pcap_trace {
+ rte_spinlock_t lock;
+ const char *file_name;
+ uint32_t n_packets_to_capture;
+ uint32_t n_bytes;
+ pcap_packet_type_t packet_type;
+ uint32_t n_packets_captured;
+ int file_descriptor;
+ uint32_t n_pcap_data_written;
+ uint8_t *pcap_data;
+} pcap_trace_t;
+
+/**
+ * Pcap trace enable/disable function.
+ *
+ * The function is called to enable/disable graph pcap trace functionality.
+ *
+ * @param val
+ * Value to be set to enable/disable graph pcap trace.
+ */
+void set_pcap_trace(int val);
+
+/**
+ * Check graph pcap trace is enable/disable.
+ *
+ * The function is called to check if the graph pcap trace is enabled/disabled.
+ *
+ * @return
+ * - 1: Enable
+ * - 0: Disable
+ */
+int is_pcap_trace_enable(void);
+
+/**
+ * Initialise graph pcap trace functionality.
+ *
+ * The function invoked when the graph pcap trace is enabled from the
+ * application.
+ *
+ */
+void rte_graph_pcap_trace_init(void);
+
+/**
+ * Capture mbuf metadata and node metadata to a pcap file.
+ *
+ * When graph pcap trace enabled, this function is invoked prior to each node
+ * and mbuf, node metadata is parsed and captured in a pcap file.
+ *
+ * @param graph
+ * Pointer to the graph object.
+ * @param node
+ * Pointer to the node object.
+ * @param objs
+ * Pointer to an array of objects to be processed.
+ * @param nb_objs
+ * Number of objects in the array.
+ */
+uint16_t rte_graph_pcap_trace_dispatch(struct rte_graph *graph __rte_unused,
+ struct rte_node *node, void **objs,
+ uint16_t nb_objs);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _DPDK_GRAPH_PCAP_TRACE_H_ */
diff --git a/lib/graph/rte_graph_worker.h b/lib/graph/rte_graph_worker.h
index fc6fee48c8..64c18421d5 100644
--- a/lib/graph/rte_graph_worker.h
+++ b/lib/graph/rte_graph_worker.h
@@ -24,6 +24,7 @@
#include <rte_memory.h>
#include "rte_graph.h"
+#include "rte_graph_pcap_trace.h"
#ifdef __cplusplus
extern "C" {
@@ -64,6 +65,11 @@ struct rte_node {
char parent[RTE_NODE_NAMESIZE]; /**< Parent node name. */
char name[RTE_NODE_NAMESIZE]; /**< Name of the node. */
+ union {
+ rte_node_process_t p_process; /**< Process function. */
+ uint64_t p_process_u64;
+ };
+
/* Fast path area */
#define RTE_NODE_CTX_SZ 16
uint8_t ctx[RTE_NODE_CTX_SZ] __rte_cache_aligned; /**< Node Context. */
--
2.25.1
