DPDK patches and discussions
 help / color / mirror / Atom feed
From: Stephen Hemminger <stephen@networkplumber.org>
To: dev@dpdk.org
Cc: Stephen Hemminger <stephen@networkplumber.org>
Subject: [PATCH v8 2/7] net: add new packet dissector
Date: Mon, 16 Sep 2024 20:27:59 -0700	[thread overview]
Message-ID: <20240917033117.66346-3-stephen@networkplumber.org> (raw)
In-Reply-To: <20240917033117.66346-1-stephen@networkplumber.org>

The function rte_dissect_mbuf is used to decode the contents
of an mbuf into ah uman readable format similar to what tshark uses.

For now, handles IP, IPv6, TCP, UDP, ICMP and ARP.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 lib/net/meson.build   |   2 +
 lib/net/rte_dissect.c | 428 ++++++++++++++++++++++++++++++++++++++++++
 lib/net/rte_dissect.h |  45 +++++
 lib/net/version.map   |   7 +
 4 files changed, 482 insertions(+)
 create mode 100644 lib/net/rte_dissect.c
 create mode 100644 lib/net/rte_dissect.h

diff --git a/lib/net/meson.build b/lib/net/meson.build
index 0b69138949..48edf17ea3 100644
--- a/lib/net/meson.build
+++ b/lib/net/meson.build
@@ -2,6 +2,7 @@
 # Copyright(c) 2017-2020 Intel Corporation
 
 headers = files(
+        'rte_dissect.h',
         'rte_ip.h',
         'rte_tcp.h',
         'rte_udp.h',
@@ -30,6 +31,7 @@ headers = files(
 
 sources = files(
         'rte_arp.c',
+        'rte_dissect.c',
         'rte_ether.c',
         'rte_net.c',
         'rte_net_crc.c',
diff --git a/lib/net/rte_dissect.c b/lib/net/rte_dissect.c
new file mode 100644
index 0000000000..de9e8f4c56
--- /dev/null
+++ b/lib/net/rte_dissect.c
@@ -0,0 +1,428 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2024 Stephen Hemminger <stephen@networkplumber.org>
+ *
+ * Print packets in format similar to tshark.
+ * Output should be one line per mbuf
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <rte_arp.h>
+#include <rte_branch_prediction.h>
+#include <rte_byteorder.h>
+#include <rte_common.h>
+#include <rte_dissect.h>
+#include <rte_ether.h>
+#include <rte_icmp.h>
+#include <rte_ip.h>
+#include <rte_mbuf.h>
+#include <rte_tcp.h>
+#include <rte_udp.h>
+#include <rte_vxlan.h>
+
+/* Forward declaration - Ethernet can be nested */
+static int
+dissect_eth(char *buf, size_t size, const struct rte_mbuf *mb,
+	    uint32_t offset, uint32_t dump_len);
+
+/*
+ * Read data from segmented mbuf and put it into buf , but stop if would go past max length
+ * See rte_pktmbuf_read()
+ */
+static const void *
+dissect_read(const struct rte_mbuf *m, uint32_t offset, uint32_t len,
+	     void *buf, uint32_t dump_len)
+{
+
+	/* If this header would be past the requested length */
+	if (dump_len > 0 && offset + len > dump_len)
+		return NULL;
+
+	return rte_pktmbuf_read(m, offset, len, buf);
+}
+
+/*
+ * Print to string buffer and adjust result
+ * Returns true on success, false if buffer is exhausted.
+ */
+static __rte_format_printf(3, 4) int
+dissect_print(char **buf, size_t *sz, const char *fmt, ...)
+{
+	va_list ap;
+	int count;
+
+	va_start(ap, fmt);
+	count = vsnprintf(*buf, *sz, fmt, ap);
+	va_end(ap);
+
+	/* error or string is full */
+	if (count < 0 || count >= (int)*sz) {
+		*sz = 0;
+	} else {
+		*buf += count;
+		*sz -= count;
+	}
+	return count;
+}
+
+static int
+dissect_arp(char *buf, size_t size, const struct rte_mbuf *mb,
+	    uint32_t offset, uint32_t dump_len)
+{
+	const struct rte_arp_hdr *arp;
+	struct rte_arp_hdr _arp;
+	int count = 0;
+	char abuf[64];
+
+	arp = dissect_read(mb, offset, sizeof(_arp), &_arp, dump_len);
+	if (arp == NULL)
+		return snprintf(buf, size, "Missing ARP header");
+
+	offset += sizeof(_arp);
+
+	uint16_t ar_op = rte_be_to_cpu_16(arp->arp_opcode);
+	switch (ar_op) {
+	case RTE_ARP_OP_REQUEST:
+		inet_ntop(AF_INET, &arp->arp_data.arp_tip, abuf, sizeof(abuf));
+		count += dissect_print(&buf, &size, "Who has %s? ", abuf);
+
+		rte_ether_format_addr(abuf, sizeof(abuf), &arp->arp_data.arp_sha);
+		count += dissect_print(&buf, &size, "Tell %s ", abuf);
+		break;
+
+	case RTE_ARP_OP_REPLY:
+		inet_ntop(AF_INET, &arp->arp_data.arp_sip, abuf, sizeof(abuf));
+		count += dissect_print(&buf, &size, "%s is at", abuf);
+
+		rte_ether_format_addr(abuf, sizeof(abuf), &arp->arp_data.arp_sha);
+		count += dissect_print(&buf, &size, "%s ", abuf);
+		break;
+
+	case RTE_ARP_OP_INVREQUEST:
+		rte_ether_format_addr(abuf, sizeof(abuf), &arp->arp_data.arp_tha);
+		count += dissect_print(&buf, &size, "Who is %s? ", abuf);
+
+		rte_ether_format_addr(abuf, sizeof(abuf), &arp->arp_data.arp_sha);
+		count += dissect_print(&buf, &size, "Tell %s ", abuf);
+		break;
+
+	case RTE_ARP_OP_INVREPLY:
+		rte_ether_format_addr(abuf, sizeof(buf), &arp->arp_data.arp_sha);
+		count += dissect_print(&buf, &size, "%s is at ", abuf);
+
+		inet_ntop(AF_INET, &arp->arp_data.arp_sip, abuf, sizeof(abuf));
+		count += dissect_print(&buf, &size, "%s ", abuf);
+		break;
+
+	default:
+		count += dissect_print(&buf, &size, "Unknown ARP %#x ", ar_op);
+		break;
+	}
+
+	return count;
+}
+
+static int
+dissect_vxlan(char *buf, size_t size, const struct rte_mbuf *mb, uint32_t offset, uint32_t dump_len)
+{
+	const struct rte_vxlan_hdr *vxlan;
+	struct rte_vxlan_hdr _vxlan;
+	int count = 0;
+
+	vxlan = dissect_read(mb, offset, sizeof(_vxlan), &_vxlan, dump_len);
+	if (vxlan == NULL)
+		return snprintf(buf, size, "Missing VXLAN header");
+
+	offset += sizeof(_vxlan);
+
+	if (vxlan->flag_i) {
+		uint32_t vni = rte_be_to_cpu_32(vxlan->vx_vni);
+
+		count += dissect_print(&buf, &size, "%#x ", vni >> 8);
+	}
+
+	count += dissect_eth(buf, size, mb, offset, dump_len);
+	return count;
+}
+
+static int
+dissect_udp(char *buf, size_t size, const struct rte_mbuf *mb, uint32_t offset, uint32_t dump_len)
+{
+	const struct rte_udp_hdr *udph;
+	struct rte_udp_hdr _udp;
+	uint16_t src_port, dst_port, len;
+
+	udph = dissect_read(mb, offset, sizeof(_udp), &_udp, dump_len);
+	if (udph == NULL)
+		return snprintf(buf, size, "Missing UDP header");
+
+	offset += sizeof(_udp);
+	src_port = rte_be_to_cpu_16(udph->src_port);
+	dst_port = rte_be_to_cpu_16(udph->dst_port);
+	len = rte_be_to_cpu_16(udph->dgram_len);
+
+	switch (dst_port) {
+	case RTE_VXLAN_DEFAULT_PORT:
+		return dissect_vxlan(buf, size, mb, offset, dump_len);
+	default:
+		return dissect_print(&buf, &size, "UDP %u %u → %u ", len, src_port, dst_port);
+	}
+}
+
+static int
+dissect_tcp(char *buf, size_t size, const struct rte_mbuf *mb, uint32_t offset, uint32_t dump_len)
+{
+	const struct rte_tcp_hdr *tcph;
+	struct rte_tcp_hdr _tcp;
+	uint16_t src_port, dst_port;
+	int count;
+
+	tcph = dissect_read(mb, offset, sizeof(_tcp), &_tcp, dump_len);
+	if (tcph == NULL)
+		return snprintf(buf, size, "Missing TCP header");
+
+	offset += sizeof(_tcp);
+	src_port = rte_be_to_cpu_16(tcph->src_port);
+	dst_port = rte_be_to_cpu_16(tcph->dst_port);
+
+	count = dissect_print(&buf, &size, "TCP %u → %u", src_port, dst_port);
+
+#define PRINT_TCP_FLAG(flag) do {					\
+	if (tcph->tcp_flags & RTE_TCP_ ## flag ## _FLAG)		\
+		count += dissect_print(&buf, &size, " [ " #flag " ]");	\
+	} while (0)
+
+	PRINT_TCP_FLAG(URG);
+	PRINT_TCP_FLAG(ACK);
+	PRINT_TCP_FLAG(RST);
+	PRINT_TCP_FLAG(SYN);
+	PRINT_TCP_FLAG(FIN);
+#undef PRINT_TCP_FLAG
+
+	count += dissect_print(&buf, &size, "Seq=%u Ack=%u Win=%u ",
+			       rte_be_to_cpu_16(tcph->sent_seq),
+			       rte_be_to_cpu_16(tcph->recv_ack),
+			       rte_be_to_cpu_16(tcph->rx_win));
+	return count;
+}
+
+static int
+dissect_icmp(char *buf, size_t size, const struct rte_mbuf *mb, uint32_t offset, uint32_t dump_len)
+{
+	const struct rte_icmp_hdr *icmp;
+	struct rte_icmp_hdr _icmp;
+	static const char * const icmp_types[256] = {
+		[RTE_IP_ICMP_ECHO_REPLY]     = "ICMP Echo Reply",
+		[RTE_IP_ICMP_DEST_UNREACH]   = "ICMP Destination Unreachable",
+		[RTE_IP_ICMP_SOURCE_QUENCH]  = "ICMP Source Quench",
+		[RTE_IP_ICMP_REDIRECT]       = "ICMP Redirect",
+		[RTE_IP_ICMP_ECHO_REQUEST]   = "ICMP Echo Request",
+		[RTE_IP_ICMP_TIME_EXCEEDED]  = "ICMP Time Exceeded",
+		[RTE_IP_ICMP_PARAMETERPROB]  = "ICMP Parameter Problem",
+		[RTE_IP_ICMP_TIMESTAMP]      = "ICMP Timestamp Request",
+		[RTE_IP_ICMP_TIMESTAMPREPLY] = "ICMP Timestamp Reply",
+		[RTE_IP_ICMP_INFO_REQUEST]   = "ICMP Info Request",
+		[RTE_IP_ICMP_INFO_REPLY]     = "ICMP Info Reply",
+
+		[RTE_ICMP6_ECHO_REPLY]     = "ICMPv6 Echo Reply",
+		[RTE_ICMP6_ECHO_REQUEST]   = "ICMPv6 Echo Request",
+		[RTE_ND_ROUTER_SOLICIT]    = "ICMPv6 Router Solicitation",
+		[RTE_ND_ROUTER_ADVERT]     = "ICMPv6 Router Advertisement",
+		[RTE_ND_NEIGHBOR_SOLICIT]  = "ICMPv6 Neighbor Solicitation",
+		[RTE_ND_NEIGHBOR_ADVERT]   = "ICMPv6 Neighbor Advertisement",
+	};
+
+	icmp = dissect_read(mb, offset, sizeof(_icmp), &_icmp, dump_len);
+	if (icmp == NULL)
+		return snprintf(buf, size, "Missing ICMP header");
+
+	offset += sizeof(_icmp);
+	const char *name = icmp_types[icmp->icmp_type];
+	if (name != NULL)
+		return dissect_print(&buf, &size, "%s ", name);
+	else
+		return dissect_print(&buf, &size, "ICMP %u ", icmp->icmp_type);
+}
+
+static int
+dissect_ipv4(char *buf, size_t size, const struct rte_mbuf *mb,
+	     uint32_t offset, uint32_t dump_len)
+{
+	const struct rte_ipv4_hdr *ip_hdr;
+	struct rte_ipv4_hdr _ip_hdr;
+	char sbuf[INET_ADDRSTRLEN], dbuf[INET_ADDRSTRLEN];
+	int count;
+
+	ip_hdr = dissect_read(mb, offset, sizeof(_ip_hdr), &_ip_hdr, dump_len);
+	if (ip_hdr == NULL)
+		return snprintf(buf, size, "Missing IP header");
+
+	inet_ntop(AF_INET, &ip_hdr->src_addr, sbuf, sizeof(sbuf));
+	inet_ntop(AF_INET, &ip_hdr->dst_addr, dbuf, sizeof(dbuf));
+	count = dissect_print(&buf, &size, "%s → %s ", sbuf, dbuf);
+
+	offset += ip_hdr->ihl * 4;
+	switch (ip_hdr->next_proto_id) {
+	case IPPROTO_UDP:
+		count += dissect_udp(buf, size, mb, offset, dump_len);
+		break;
+	case IPPROTO_TCP:
+		count += dissect_tcp(buf, size, mb, offset, dump_len);
+		break;
+	case IPPROTO_ICMP:
+		count += dissect_icmp(buf, size, mb, offset, dump_len);
+		break;
+	default:
+		/* TODO dissect tunnels */
+		count += dissect_print(&buf, &size, "IP %#x ", ip_hdr->next_proto_id);
+	}
+	return count;
+}
+
+static int
+dissect_ipv6(char *buf, size_t size, const struct rte_mbuf *mb,
+	     uint32_t offset, uint32_t dump_len)
+{
+	const struct rte_ipv6_hdr *ip6_hdr;
+	struct rte_ipv6_hdr _ip6_hdr;
+	char sbuf[INET6_ADDRSTRLEN], dbuf[INET6_ADDRSTRLEN];
+	uint16_t proto;
+	unsigned int i;
+	int count;
+
+	ip6_hdr = dissect_read(mb, offset, sizeof(_ip6_hdr), &_ip6_hdr, dump_len);
+	if (ip6_hdr == NULL)
+		return snprintf(buf, size, "Missing IPv6 header");
+
+	offset += sizeof(*ip6_hdr);
+	inet_ntop(AF_INET6, ip6_hdr->src_addr, sbuf, sizeof(sbuf));
+	inet_ntop(AF_INET6, ip6_hdr->dst_addr, dbuf, sizeof(dbuf));
+	count = dissect_print(&buf, &size, "%s → %s ", sbuf, dbuf);
+
+#define MAX_EXT_HDRS 5
+	proto = ip6_hdr->proto;
+	for (i = 0; i < MAX_EXT_HDRS; i++) {
+		switch (proto) {
+		case IPPROTO_UDP:
+			count += dissect_udp(buf, size, mb, offset, dump_len);
+			return count;
+
+		case IPPROTO_TCP:
+			count += dissect_tcp(buf, size, mb, offset, dump_len);
+			return count;
+
+		case IPPROTO_ICMPV6:
+			count += dissect_icmp(buf, size, mb, offset, dump_len);
+			return count;
+
+		case IPPROTO_HOPOPTS:
+		case IPPROTO_ROUTING:
+		case IPPROTO_DSTOPTS:
+		{
+			const struct rte_ipv6_routing_ext *xh;
+			struct rte_ipv6_routing_ext _xh;
+
+			xh = dissect_read(mb, offset, sizeof(xh), &_xh, dump_len);
+			if (xh == NULL)
+				return count;
+
+			offset += (xh->hdr_len + 1) * 8;
+			proto = xh->next_hdr;
+			continue;
+		}
+
+		case IPPROTO_FRAGMENT:
+			count += dissect_print(&buf, &size, "%s", "FRAG ");
+			return count;
+
+		case IPPROTO_NONE:
+			count += dissect_print(&buf, &size, "%s", "NONE ");
+			return count;
+
+		default:
+			count += dissect_print(&buf, &size, "IPv6 %#x ", proto);
+			return count;
+		}
+	}
+	return count;
+}
+
+/*
+ * Format up a string describing contents of packet in tshark like style.
+ */
+static int
+dissect_eth(char *buf, size_t size, const struct rte_mbuf *mb,
+	    uint32_t offset, uint32_t dump_len)
+{
+	const struct rte_ether_hdr *eth_hdr;
+	struct rte_ether_hdr _eth_hdr;
+	uint16_t eth_type;
+	int count = 0;
+	char sbuf[RTE_ETHER_ADDR_FMT_SIZE], dbuf[RTE_ETHER_ADDR_FMT_SIZE];
+
+	eth_hdr = dissect_read(mb, offset, sizeof(_eth_hdr), &_eth_hdr, dump_len);
+	if (unlikely(eth_hdr == NULL))
+		return snprintf(buf, size, "Missing ETH header");
+
+	offset += sizeof(*eth_hdr);
+	eth_type = rte_be_to_cpu_16(eth_hdr->ether_type);
+	if (eth_type == RTE_ETHER_TYPE_VLAN || eth_type == RTE_ETHER_TYPE_QINQ) {
+		const struct rte_vlan_hdr *vh;
+		struct rte_vlan_hdr _vh;
+
+		vh = dissect_read(mb, offset, sizeof(_vh), &_vh, dump_len);
+		if (unlikely(vh == NULL))
+			return snprintf(buf, size, "Missing VLAN header");
+
+		eth_type = vh->eth_proto;
+		offset += sizeof(*vh);
+
+		count += dissect_print(&buf, &size, "%s %#x ",
+				       (eth_type == RTE_ETHER_TYPE_VLAN) ? "VLAN" : "QINQ",
+				       rte_be_to_cpu_16(vh->vlan_tci));
+	}
+
+	switch (eth_type) {
+	case RTE_ETHER_TYPE_ARP:
+		rte_ether_format_addr(sbuf, sizeof(sbuf), &eth_hdr->src_addr);
+		rte_ether_format_addr(dbuf, sizeof(dbuf), &eth_hdr->dst_addr);
+		count += dissect_print(&buf, &size, "%s → %s ARP ", sbuf, dbuf);
+		count += dissect_arp(buf, size,  mb, offset, dump_len);
+		break;
+
+	case RTE_ETHER_TYPE_IPV4:
+		count += dissect_ipv4(buf, size, mb, offset, dump_len);
+		break;
+
+	case RTE_ETHER_TYPE_IPV6:
+		count += dissect_ipv6(buf, size, mb, offset, dump_len);
+		break;
+
+	default:
+		count += dissect_print(&buf, &size, "ETH %#x ", eth_type);
+	}
+
+	return count;
+}
+
+int
+rte_dissect_mbuf(char *buf, size_t size, const struct rte_mbuf *m, uint32_t dump_len)
+{
+	int count;
+
+	count = dissect_eth(buf, size, m, 0, dump_len);
+	if (count <= 0)
+		return count;
+
+	/* output was truncated, but redact the trailing blank */
+	if (count >= (int)size)
+		return count - 1;
+
+	if (buf[count] == ' ')
+		buf[count--] = '\0';
+
+	return count;
+}
diff --git a/lib/net/rte_dissect.h b/lib/net/rte_dissect.h
new file mode 100644
index 0000000000..343e9daa4d
--- /dev/null
+++ b/lib/net/rte_dissect.h
@@ -0,0 +1,45 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2024 Stephen Hemminger <stephen@networkplumber.org>
+ */
+
+#ifndef _RTE_NET_DISSECT_H_
+#define _RTE_NET_DISSECT_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdint.h>
+
+#include <rte_compat.h>
+
+struct rte_mbuf;
+
+/**
+ *
+ * Format description of packet to a string buffer
+ *
+ * @param buf
+ *   A pointer to buffer for the resulting line.
+ * @param size
+ *   The format buffer size.
+ * @param m
+ *   The packet mbuf.
+ * @param dump_len
+ *   Maximum offset in packet to examine.
+ *   If is zero then dump the whole packet.
+ * @return
+ *   Returns the number of bytes printed (excluding null byte at end of string).
+ *   if output was truncated returns the number of bytes that would have been printed.
+ */
+__rte_experimental
+int
+rte_dissect_mbuf(char *buf, size_t size, const struct rte_mbuf *m, uint32_t dump_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* _RTE_NET_DISSECT_H_ */
diff --git a/lib/net/version.map b/lib/net/version.map
index bec4ce23ea..9a27339df5 100644
--- a/lib/net/version.map
+++ b/lib/net/version.map
@@ -12,3 +12,10 @@ DPDK_25 {
 
 	local: *;
 };
+
+EXPERIMENTAL {
+	global:
+
+	# added in 24.11
+	rte_dissect_mbuf;
+};
-- 
2.45.2


  parent reply	other threads:[~2024-09-17  3:31 UTC|newest]

Thread overview: 63+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2024-03-12 22:01 [PATCH] test-pmd: add more packet decode options (verbose) Stephen Hemminger
2024-03-13 21:49 ` Stephen Hemminger
2024-07-05  7:13 ` David Marchand
2024-07-23  2:44 ` [PATCH v2 0/3] Add packet dissector Stephen Hemminger
2024-07-23  2:44   ` [PATCH v2 1/3] net: add new " Stephen Hemminger
2024-07-23  2:44   ` [PATCH v2 2/3] test: add test for " Stephen Hemminger
2024-07-23  2:44   ` [PATCH v2 3/3] test-pmd: add more packet verbose decode options Stephen Hemminger
2024-07-23 20:33 ` [PATCH v3 0/3] add packet dissector function Stephen Hemminger
2024-07-23 20:33   ` [PATCH v3 1/3] net: add new packet dissector Stephen Hemminger
2024-07-23 20:33   ` [PATCH v3 2/3] test: add test for " Stephen Hemminger
2024-07-23 20:33   ` [PATCH v3 3/3] test-pmd: add more packet verbose decode options Stephen Hemminger
2024-07-24 18:46 ` [PATCH v4 0/3] Add packet dissector Stephen Hemminger
2024-07-24 18:46   ` [PATCH v4 1/3] net: add new " Stephen Hemminger
2024-07-24 18:46   ` [PATCH v4 2/3] test: add test for " Stephen Hemminger
2024-07-24 18:46   ` [PATCH v4 3/3] test-pmd: add more packet verbose decode options Stephen Hemminger
2024-08-01 19:04 ` [PATCH v5 0/4] Add network packet dissector Stephen Hemminger
2024-08-01 19:04   ` [PATCH v5 1/4] net: add more icmp types Stephen Hemminger
2024-08-01 19:04   ` [PATCH v5 2/4] net: add new packet dissector Stephen Hemminger
2024-08-01 19:04   ` [PATCH v5 3/4] test: add test for " Stephen Hemminger
2024-08-02  8:38     ` Bruce Richardson
2024-08-02 15:31       ` Stephen Hemminger
2024-08-02 18:06       ` Stephen Hemminger
2024-08-01 19:04   ` [PATCH v5 4/4] test-pmd: add more packet verbose decode options Stephen Hemminger
2024-08-02 18:07 ` [PATCH v6 0/4] Add network packet dissector Stephen Hemminger
2024-08-02 18:07   ` [PATCH v6 1/4] net: add more icmp types Stephen Hemminger
2024-08-02 18:07   ` [PATCH v6 2/4] net: add new packet dissector Stephen Hemminger
2024-08-02 18:07   ` [PATCH v6 3/4] test: add test for " Stephen Hemminger
2024-08-02 18:07   ` [PATCH v6 4/4] test-pmd: add more packet verbose decode options Stephen Hemminger
2024-08-02 19:56 ` [PATCH v7 0/4] Add network packet dissector Stephen Hemminger
2024-08-02 19:56   ` [PATCH v7 1/4] net: add more icmp types Stephen Hemminger
2024-08-02 19:56   ` [PATCH v7 2/4] net: add new packet dissector Stephen Hemminger
2024-08-02 19:56   ` [PATCH v7 3/4] test: add test for " Stephen Hemminger
2024-08-02 19:56   ` [PATCH v7 4/4] test-pmd: add more packet verbose decode options Stephen Hemminger
2024-08-20 13:42     ` Alex Chapman
2024-08-20 15:54       ` Stephen Hemminger
2024-08-22  9:04         ` Paul Szczepanek
2024-09-28 18:36           ` Stephen Hemminger
2024-09-17  3:27 ` [PATCH v8 0/7] Test-pmd packet decode enhancements Stephen Hemminger
2024-09-17  3:27   ` [PATCH v8 1/7] net: add more icmp types Stephen Hemminger
2024-09-17  3:27   ` Stephen Hemminger [this message]
2024-09-17  3:28   ` [PATCH v8 3/7] test: add test for packet dissector Stephen Hemminger
2024-09-17  3:28   ` [PATCH v8 4/7] test-pmd: add option to redirect packet log Stephen Hemminger
2024-09-17  3:28   ` [PATCH v8 5/7] test-pmd: add hex decode Stephen Hemminger
2024-09-17  3:28   ` [PATCH v8 6/7] test-pmd: add packet dissect format Stephen Hemminger
2024-09-17  3:28   ` [PATCH v8 7/7] test-pmd: add a JSON packet output Stephen Hemminger
2024-09-28 16:18 ` [PATCH v9 0/8] test-pmd packet decoding enhancements Stephen Hemminger
2024-09-28 16:18   ` [PATCH v9 1/8] net: add more icmp types Stephen Hemminger
2024-09-28 16:18   ` [PATCH v9 2/8] net: add new packet dissector Stephen Hemminger
2024-09-28 16:18   ` [PATCH v9 3/8] mbuf: decode the hash and fdir info in rte_pktmbuf_dump Stephen Hemminger
2024-09-28 16:18   ` [PATCH v9 4/8] test: add test for packet dissector Stephen Hemminger
2024-09-28 16:18   ` [PATCH v9 5/8] test-pmd: add option to redirect packet log Stephen Hemminger
2024-09-28 16:18   ` [PATCH v9 6/8] test-pmd: add hex decode Stephen Hemminger
2024-09-28 16:18   ` [PATCH v9 7/8] test-pmd: add packet dissect format Stephen Hemminger
2024-09-28 16:18   ` [PATCH v9 8/8] test-pmd: add a JSON packet output Stephen Hemminger
2024-10-28  2:19 ` [PATCH v10 0/8] test-pmd packet decoding enhancements Stephen Hemminger
2024-10-28  2:19   ` [PATCH v10 1/8] net: add more icmp types Stephen Hemminger
2024-10-28  2:19   ` [PATCH v10 2/8] net: add new packet dissector Stephen Hemminger
2024-10-28  2:19   ` [PATCH v10 3/8] mbuf: decode the hash and fdir info in rte_pktmbuf_dump Stephen Hemminger
2024-10-28  2:19   ` [PATCH v10 4/8] test: add test for packet dissector Stephen Hemminger
2024-10-28  2:19   ` [PATCH v10 5/8] test-pmd: add option to redirect packet log Stephen Hemminger
2024-10-28  2:19   ` [PATCH v10 6/8] test-pmd: add hex decode Stephen Hemminger
2024-10-28  2:19   ` [PATCH v10 7/8] test-pmd: add packet dissect format Stephen Hemminger
2024-10-28  2:19   ` [PATCH v10 8/8] test-pmd: add a JSON packet output Stephen Hemminger

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20240917033117.66346-3-stephen@networkplumber.org \
    --to=stephen@networkplumber.org \
    --cc=dev@dpdk.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).