[PATCH 00/12] net/pcap: cleanups and test

[PATCH 00/12] net/pcap: cleanups and test

[Stephen Hemminger]

This is a set of enhancements and tests to the PCAP PMD.
It started out when looking at the handling of timestamps
then realized lots of other cleanups were needed here.

Stephen Hemminger (12):
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: support MTU set
  net/pcap: use bool for flags
  net/pcap: support Tx offloads
  net/pcap: support nanosecond timestamp precision
  net/pcap: remove global variables
  net/pcap: avoid use of volatile
  net/pcap: optimize calculation of receive timestamp
  net/pcap: report receive clock
  net/pcap: cleanup MAC address handling
  net/pcap: support MAC address set
  test: add test for pcap PMD

 app/test/meson.build                  |    2 +
 app/test/test_pmd_pcap.c              | 1471 +++++++++++++++++++++++++
 drivers/net/pcap/pcap_ethdev.c        |  373 ++++---
 drivers/net/pcap/pcap_osdep.h         |    2 +
 drivers/net/pcap/pcap_osdep_freebsd.c |   60 +-
 drivers/net/pcap/pcap_osdep_linux.c   |   51 +-
 drivers/net/pcap/pcap_osdep_windows.c |    5 +
 7 files changed, 1830 insertions(+), 134 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH 01/12] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_osdep_freebsd.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..32e4a2bee7 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -8,9 +8,6 @@
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +38,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
-- 
2.51.0

[PATCH 02/12] net/pcap: support MTU set

[Stephen Hemminger]

When used as single interface useful to support pass through
of MTU setting to enable larger frames.

Cleanup the transmit logic so that if packet sent exceeds MTU
is an error.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        | 94 +++++++++++++++------------
 drivers/net/pcap/pcap_osdep.h         |  1 +
 drivers/net/pcap/pcap_osdep_freebsd.c | 26 ++++++++
 drivers/net/pcap/pcap_osdep_linux.c   | 21 ++++++
 drivers/net/pcap/pcap_osdep_windows.c |  5 ++
 5 files changed, 104 insertions(+), 43 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..f4cb444395 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -22,7 +22,7 @@
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
+#define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
 #define RTE_ETH_PCAP_PROMISC 1
 #define RTE_ETH_PCAP_TIMEOUT -1
 
@@ -377,46 +377,46 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	uint16_t mtu;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	mtu = rte_eth_devices[dumper_q->port_id].data->mtu;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint8_t temp_data[RTE_ETH_PCAP_SNAPLEN];
+		struct pcap_pkthdr header;
+
+		if (unlikely(len > mtu))
+			continue;
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
-		header.caplen = caplen;
+		header.caplen = len;
+
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
 		 * a pointer to temp_data after copying into it.
 		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+		const uint8_t *data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		pcap_dump((u_char *)dumper, &header, data);
 
 		num_tx++;
-		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
+		tx_bytes += len;
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -444,15 +444,15 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(nb_pkts == 0))
 		return 0;
 
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -462,52 +462,45 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	uint16_t mtu;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	mtu = rte_eth_devices[tx_queue->port_id].data->mtu;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint8_t temp_data[RTE_ETH_PCAP_SNAPLEN];
+
+		if (unlikely(len > mtu))
 			continue;
-		}
 
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
 		 * a pointer to temp_data after copying into it.
 		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
+		const uint8_t *data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+
+		if (likely(pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
+		}
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
+	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -745,6 +738,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 
 	return 0;
 }
@@ -1002,6 +997,18 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+
+	if (internals->single_iface)
+		return osdep_iface_mtu_set(internals->if_index, mtu);
+
+	return 0;
+}
+
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1015,6 +1022,7 @@ static const struct eth_dev_ops ops = {
 	.rx_queue_stop = eth_rx_queue_stop,
 	.tx_queue_stop = eth_tx_queue_stop,
 	.link_update = eth_link_update,
+	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
 };
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..3c8b7ff27b 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -14,5 +14,6 @@ extern int eth_pcap_logtype;
 
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
+int osdep_iface_mtu_set(int index, uint16_t mtu);
 
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 32e4a2bee7..0279dbf00b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,9 +4,12 @@
  * All rights reserved.
  */
 
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
+#include <sys/ioctl.h>
+#include <sys/sockio.h>
 
 #include "pcap_osdep.h"
 
@@ -54,3 +57,26 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	char ifname[IFNAMSIZ];
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	int s = socket(AF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	struct ifreq ifr = { 0 };
+	if (s < 0)
+		return -EINVAL;
+
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_mtu = mtu;
+
+	int ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..d180e9b4b4 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -40,3 +40,24 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+int
+osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	char ifname[IFNAMSIZ];
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	int s = socket(PF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	struct ifreq ifr = { .ifr_mtu = mtu };
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	int ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..fde0db9961 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -116,3 +116,8 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int osdep_iface_mtu_set(int index __rte_unused, uint16_t mtu __rte_unused)
+{
+	return -ENOTSUP;
+}
-- 
2.51.0

[PATCH 03/12] net/pcap: use bool for flags

[Stephen Hemminger]

Save some space by using bool for flag values.
Use common code to parse value of a boolean flag.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 73 +++++++++++++++++-----------------
 1 file changed, 36 insertions(+), 37 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f4cb444395..6a3e89aeab 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -5,6 +5,7 @@
  */
 
 #include <stdlib.h>
+#include <stdbool.h>
 #include <time.h>
 
 #include <pcap.h>
@@ -91,9 +92,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -103,25 +104,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -858,7 +859,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1180,31 +1181,29 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
+	bool *flag = extra_args;
+	/* table of possible representation of boolean */
+	static const char * const values[] = {
+		"false", "true",
+		"0", "1",
+		"disable", "enable",
+		"on", "off",
+	};
 
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
+	for (unsigned int i = 0; i < RTE_DIM(values); i++) {
+		if (strcmp(value, values[i]) == 0) {
+			*flag = !!(i & 1);
 
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+			PMD_LOG(INFO, "%s set to %s",
+				key, *flag ? "true" : "false");
+			return 0;
+		}
 	}
-	return 0;
+
+	PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+	return -1;
 }
 
 static int
@@ -1479,7 +1478,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1518,9 +1517,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
-- 
2.51.0

[PATCH 04/12] net/pcap: support Tx offloads

[Stephen Hemminger]

The driver already handles multi-segment mbufs but did not report
that in offload flags. Driver can easily insert vlan tag making
testing easier.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 6a3e89aeab..41c5bc638f 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -403,6 +403,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (unlikely(len > mtu))
 			continue;
 
+		if ((mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) && rte_vlan_insert(&mbuf))
+			continue;
+
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
@@ -485,6 +488,9 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (unlikely(len > mtu))
 			continue;
 
+		if ((mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) && rte_vlan_insert(&mbuf))
+			continue;
+
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
 		 * a pointer to temp_data after copying into it.
@@ -741,6 +747,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 
 	return 0;
 }
-- 
2.51.0

[PATCH 05/12] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Consistently support nanosecond timestamps across all the
variations of pcap PMD receive.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 103 +++++++++++++++++++++++++--------
 1 file changed, 79 insertions(+), 24 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 41c5bc638f..905ca62bd4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -19,13 +19,12 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
 #define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -68,6 +67,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -95,6 +95,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -299,7 +300,6 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (ret != 1) {
 			if (ret == PCAP_ERROR)
 				pcap_q->rx_stat.err_pkts++;
-
 			break;
 		}
 
@@ -325,10 +325,20 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * Although time stamp in struct pcap_pkthdr is defined as struct timeval,
+			 * it really is a timespec with nanosecond resolution.
+			 */
+			const struct timespec *ts = (struct timespec *)&header->ts;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(ts);
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -514,22 +524,57 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	int status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscious: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -576,7 +621,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -613,6 +659,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
 
+	if (internals->timestamp_offloading) {
+		int ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							     &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+	}
+
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
@@ -728,8 +783,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -749,6 +809,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -896,6 +957,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1446,13 +1508,6 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	start_cycles = rte_get_timer_cycles();
 	hz = rte_get_timer_hz();
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
-	}
-
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
 		eth_dev = rte_eth_dev_attach_secondary(name);
 		if (!eth_dev) {
-- 
2.51.0

[PATCH 06/12] net/pcap: remove global variables

[Stephen Hemminger]

Localize variables where possible.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 905ca62bd4..1658685a28 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -39,11 +39,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -526,6 +524,8 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	pcap_t *pc = pcap_create(iface, errbuf);
 	if (pc == NULL) {
 		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
@@ -621,6 +621,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1314,11 +1316,13 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * - and point eth_dev structure to new eth_dev_data structure
 	 */
 	*internals = (*eth_dev)->data->dev_private;
+
 	/*
 	 * Interface MAC = 02:70:63:61:70:<iface_idx>
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH 07/12] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics generates expensive atomic rmw
operations when not necessary.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 38 ++++++++++++++++++++++++++--------
 1 file changed, 29 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 1658685a28..175d6998f9 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -47,10 +47,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -267,6 +267,9 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	pcap_q->rx_stat.pkts += i;
 	pcap_q->rx_stat.bytes += rx_bytes;
 
+	/* ensure store operations of statistics are visible */
+	rte_atomic_thread_fence(rte_memory_order_release);
+
 	return i;
 }
 
@@ -345,6 +348,9 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	pcap_q->rx_stat.pkts += num_rx;
 	pcap_q->rx_stat.bytes += rx_bytes;
 
+	/* ensure store operations of statistics are visible */
+	rte_atomic_thread_fence(rte_memory_order_release);
+
 	return num_rx;
 }
 
@@ -440,6 +446,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	dumper_q->tx_stat.bytes += tx_bytes;
 	dumper_q->tx_stat.err_pkts += nb_pkts - num_tx;
 
+	/* ensure store operations of statistics are visible */
+	rte_atomic_thread_fence(rte_memory_order_release);
+
 	return nb_pkts;
 }
 
@@ -464,6 +473,9 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
+	/* ensure store operations of statistics are visible */
+	rte_atomic_thread_fence(rte_memory_order_release);
+
 	return nb_pkts;
 }
 
@@ -515,6 +527,9 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.bytes += tx_bytes;
 	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
 
+	/* ensure store operations of statistics are visible */
+	rte_atomic_thread_fence(rte_memory_order_release);
+
 	return nb_pkts;
 }
 
@@ -821,13 +836,16 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
+	/* ensure that current statistics are visible */
+	rte_atomic_thread_fence(rte_memory_order_acquire);
+
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
 			i < dev->data->nb_rx_queues; i++) {
 		if (qstats != NULL) {
@@ -884,6 +902,8 @@ eth_stats_reset(struct rte_eth_dev *dev)
 		internal->tx_queue[i].tx_stat.err_pkts = 0;
 	}
 
+	/* ensure store operations of statistics are visible */
+	rte_atomic_thread_fence(rte_memory_order_release);
 	return 0;
 }
 
-- 
2.51.0

[PATCH 08/12] net/pcap: optimize calculation of receive timestamp

[Stephen Hemminger]

Avoid doing slow instructions in receive path when calculating
timestamp. Give all packets in the same rx burst the same timestamp.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 175d6998f9..e283fb3787 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -20,6 +20,7 @@
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
 #include <rte_time.h>
+#include <rte_reciprocal.h>
 
 #include "pcap_osdep.h"
 
@@ -41,7 +42,7 @@
 
 static struct timespec start_time;
 static uint64_t start_cycles;
-static uint64_t hz;
+static struct rte_reciprocal_u64 hz_inv;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -362,8 +363,6 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
  * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
  * because `ts` goes directly to nanosecond-precision dump.
@@ -374,8 +373,10 @@ calculate_timestamp(struct timeval *ts) {
 	struct timespec cur_time;
 
 	cycles = rte_get_timer_cycles() - start_cycles;
-	cur_time.tv_sec = cycles / hz;
-	cur_time.tv_nsec = (cycles % hz) * NSEC_PER_SEC / hz;
+	cur_time.tv_sec = rte_reciprocal_divide_u64(cycles, &hz_inv);
+	/* compute remainder */
+	cycles -= cur_time.tv_sec * rte_get_timer_hz();
+	cur_time.tv_nsec = rte_reciprocal_divide_u64(cycles * NS_PER_S, &hz_inv);
 
 	ts->tv_sec = start_time.tv_sec + cur_time.tv_sec;
 	ts->tv_usec = start_time.tv_nsec + cur_time.tv_nsec;
@@ -394,6 +395,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	unsigned int i;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct pcap_pkthdr header;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_dumper_t *dumper;
@@ -406,13 +408,14 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
 		size_t len = rte_pktmbuf_pkt_len(mbuf);
 		uint8_t temp_data[RTE_ETH_PCAP_SNAPLEN];
-		struct pcap_pkthdr header;
 
 		if (unlikely(len > mtu))
 			continue;
@@ -420,7 +423,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if ((mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) && rte_vlan_insert(&mbuf))
 			continue;
 
-		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
 
@@ -1530,7 +1532,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 	timespec_get(&start_time, TIME_UTC);
 	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+
+	hz_inv = rte_reciprocal_value_u64(rte_get_timer_hz());
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
 		eth_dev = rte_eth_dev_attach_secondary(name);
-- 
2.51.0

[PATCH 09/12] net/pcap: report receive clock

[Stephen Hemminger]

Since this drive supports receive timestamping, provide a callback
so that the application can determine the clock rate for timestamp.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index e283fb3787..3eb313ebb8 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1103,6 +1103,16 @@ eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in UTC */
+static int
+eth_rx_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
 
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
@@ -1120,6 +1130,7 @@ static const struct eth_dev_ops ops = {
 	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.read_clock = eth_rx_clock,
 };
 
 static int
-- 
2.51.0

[PATCH 10/12] net/pcap: cleanup MAC address handling

[Stephen Hemminger]

Use rte_ether_addr structure to avoid memcpy and void *.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 3eb313ebb8..bf863e8708 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1383,9 +1383,9 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 
 static int
 eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
-		const unsigned int numa_node)
+		    const unsigned int numa_node)
 {
-	void *mac_addrs;
+	struct rte_ether_addr *mac_addrs;
 	struct rte_ether_addr mac;
 
 	if (osdep_iface_mac_get(if_name, &mac) < 0)
@@ -1396,7 +1396,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	rte_ether_addr_copy(&mac, mac_addrs);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
-- 
2.51.0

[PATCH 11/12] net/pcap: support MAC address set

[Stephen Hemminger]

When using pcap on a single interface, it is possible for
driver to proxy the mac address set operation.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        | 13 ++++++++++++
 drivers/net/pcap/pcap_osdep.h         |  1 +
 drivers/net/pcap/pcap_osdep_freebsd.c | 23 ++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c   | 30 ++++++++++++++++++++++++++-
 4 files changed, 66 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index bf863e8708..79f2e28fbc 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1103,6 +1103,18 @@ eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 	return 0;
 }
 
+static int
+eth_dev_macaddr_set(struct rte_eth_dev *dev, struct rte_ether_addr *addr)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+
+	if (internals->single_iface)
+		return osdep_iface_mac_set(internals->if_index, addr);
+	else
+		return -ENOTSUP;
+}
+
+
 /* Timestamp values in receive packets from libpcap are in UTC */
 static int
 eth_rx_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
@@ -1127,6 +1139,7 @@ static const struct eth_dev_ops ops = {
 	.rx_queue_stop = eth_rx_queue_stop,
 	.tx_queue_stop = eth_tx_queue_stop,
 	.link_update = eth_link_update,
+	.mac_addr_set = eth_dev_macaddr_set,
 	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 3c8b7ff27b..00944e0843 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -14,6 +14,7 @@ extern int eth_pcap_logtype;
 
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
+int osdep_iface_mac_set(int ifindex, const struct rte_ether_addr *mac);
 int osdep_iface_mtu_set(int index, uint16_t mtu);
 
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0279dbf00b..39227da63a 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -58,6 +58,29 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	return 0;
 }
 
+int
+osdep_iface_mac_set(int ifindex, const struct rte_ether_addr *mac)
+{
+	char ifname[IFNAMSIZ];
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	int s = socket(AF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	struct ifreq ifr = { 0 };
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_addr.sa_family = AF_LINK;
+	memcpy(ifr.ifr_addr.sa_data, mac, sizeof(*mac));
+
+	int ret = ioctl(s, SIOCSIFLLADDR, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
+
 int osdep_iface_mtu_set(int ifindex, uint16_t mtu)
 {
 	char ifname[IFNAMSIZ];
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index d180e9b4b4..d5a3855a0a 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,13 +4,18 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <errno.h>
 #include <net/if.h>
+#include <net/if_arp.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
 #include <rte_memcpy.h>
 #include <rte_string_fns.h>
+#include <rte_ether.h>
 
 #include "pcap_osdep.h"
 
@@ -41,6 +46,29 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	return 0;
 }
 
+int
+osdep_iface_mac_set(int ifindex, const struct rte_ether_addr *mac)
+{
+	char ifname[IFNAMSIZ];
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	int s = socket(AF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	struct ifreq ifr = { 0 };
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
+	memcpy(ifr.ifr_hwaddr.sa_data, mac, sizeof(*mac));
+
+	int ret = ioctl(s, SIOCSIFHWADDR, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
+
 int
 osdep_iface_mtu_set(int ifindex, uint16_t mtu)
 {
-- 
2.51.0

[PATCH 12/12] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests timestamps and
jumbo frame support.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build     |    2 +
 app/test/test_pmd_pcap.c | 1471 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 1473 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index efec42a6bf..6bc37a2f94 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['ethdev', 'net', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..1134404eb8
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,1471 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/*
+ * Helper: Get timestamp from mbuf using dynamic field
+ */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+				  rte_mbuf_timestamp_t *);
+}
+
+/*
+ * Helper: Check if mbuf has valid timestamp
+ */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	if (timestamp_dynfield_offset < 0)
+		return 0;
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/*
+ * Helper: Initialize timestamp dynamic field access
+ */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME,
+					  NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME,
+					 NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+
+	return 0;
+}
+
+/*
+ * Helper: Create a unique temporary file path
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		rte_memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+			   test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if network interface exists
+ */
+static int
+iface_exists(const char *name)
+{
+	struct ifreq ifr;
+	int sock, ret;
+
+	sock = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sock < 0)
+		return 0;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, name, IFNAMSIZ);
+	ret = ioctl(sock, SIOCGIFINDEX, &ifr);
+	close(sock);
+	return ret == 0;
+}
+
+/*
+ * Helper: Find a usable test interface
+ */
+static const char *
+find_test_iface(void)
+{
+	if (iface_exists("dummy0"))
+		return "dummy0";
+	if (iface_exists("lo"))
+		return "lo";
+	return NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	unlink(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	unlink(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: MTU configuration
+ */
+static int
+test_set_mtu(void)
+{
+	char devargs[256];
+	char mtu_tx_path[PATH_MAX];
+	uint16_t port_id;
+	static const uint16_t mtu_values[] = {1500, 9000, 1280};
+	int ret = 0;
+	size_t i;
+
+	printf("Testing MTU configuration\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_mtu_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(mtu_tx_path, sizeof(mtu_tx_path),
+				     "pcap_mtu_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, mtu_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_mtu", devargs, &port_id) == 0,
+		    "Failed to create MTU vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup MTU port");
+
+	for (i = 0; i < RTE_DIM(mtu_values); i++) {
+		uint16_t mtu;
+
+		ret = rte_eth_dev_set_mtu(port_id, mtu_values[i]);
+		if (ret != 0)
+			break;
+
+		TEST_ASSERT(rte_eth_dev_get_mtu(port_id, &mtu) == 0, "Failed to get MTU");
+		TEST_ASSERT_EQUAL(mtu, mtu_values[i], "MTU set mismatch for %u", mtu_values[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_mtu", port_id);
+	unlink(mtu_tx_path);
+
+	if (ret == 0) {
+		printf("MTU test completed\n");
+		return TEST_SUCCESS;
+	}
+
+	if (ret == -ENOTSUP) {
+		printf("MTU set not supported\n");
+		return TEST_SKIPPED;
+	}
+
+	printf("Failed to set MTU: %s", strerror(-ret));
+	return TEST_FAILED;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count, ret;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Set MTU to allow jumbo frames - PMD drops packets exceeding MTU */
+	ret = rte_eth_dev_set_mtu(port_id, PKT_SIZE_JUMBO);
+	if (ret != 0) {
+		printf("Failed to set MTU to %u: %s\n",
+		       PKT_SIZE_JUMBO, rte_strerror(-ret));
+		cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+		unlink(tx_path);
+		return TEST_SKIPPED;
+	}
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			unlink(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	unlink(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: MAC address with phy_mac option
+ */
+static int
+test_mac_address(void)
+{
+	struct rte_ether_addr orig_mac, new_mac, read_mac;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing MAC address configuration\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	if (strcmp(iface, "lo") == 0) {
+		printf("Need dummy interface to test setting mac address\n");
+		return TEST_SKIPPED;
+	}
+
+	snprintf(devargs, sizeof(devargs), "iface=%s,phy_mac=1", iface);
+	if (rte_vdev_init("net_pcap_mac", devargs) < 0) {
+		printf("Cannot create mac vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_mac", &port_id) == 0,
+		    "Failed to get mac port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup mac port");
+
+	ret = rte_eth_macaddr_get(port_id, &orig_mac);
+	TEST_ASSERT(ret == 0, "Failed to get original MAC");
+	printf("Original MAC: " RTE_ETHER_ADDR_PRT_FMT "\n",
+	       RTE_ETHER_ADDR_BYTES(&orig_mac));
+
+	/* Try to set a new MAC */
+	rte_eth_random_addr(new_mac.addr_bytes);
+
+	ret = rte_eth_dev_default_mac_addr_set(port_id, &new_mac);
+	if (ret == 0) {
+		rte_eth_macaddr_get(port_id, &read_mac);
+		printf("New MAC: " RTE_ETHER_ADDR_PRT_FMT "\n",
+		       RTE_ETHER_ADDR_BYTES(&read_mac));
+		/* Restore original */
+		rte_eth_dev_default_mac_addr_set(port_id, &orig_mac);
+		ret = TEST_SUCCESS;
+	} else if (ret == -ENOTSUP) {
+		printf("MAC change not supported\n");
+		ret = TEST_SKIPPED;
+	} else {
+		printf("MAC change failed: %s\n", rte_strerror(-ret));
+		ret = TEST_FAILED;
+	}
+
+	cleanup_pcap_vdev("net_pcap_mac", port_id);
+
+	printf("MAC address test completed\n");
+	return ret;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic (prev=%"PRIu64", curr=%"PRIu64")",
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	/* Cleanup temp files */
+	if (tx_pcap_path[0] != '\0')
+		unlink(tx_pcap_path);
+	if (rx_pcap_path[0] != '\0')
+		unlink(rx_pcap_path);
+	if (infinite_pcap_path[0] != '\0')
+		unlink(infinite_pcap_path);
+	if (timestamp_pcap_path[0] != '\0')
+		unlink(timestamp_pcap_path);
+	if (varied_pcap_path[0] != '\0')
+		unlink(varied_pcap_path);
+	if (jumbo_pcap_path[0] != '\0')
+		unlink(jumbo_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_set_mtu),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_mac_address),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, true, true, test_pmd_pcap);
-- 
2.51.0

RE: [PATCH 06/12] net/pcap: remove global variables

[Marat Khalili]

> -----Original Message-----
> From: Stephen Hemminger <stephen@networkplumber.org>
> Sent: Tuesday 6 January 2026 18:27
> To: dev@dpdk.org
> Cc: Stephen Hemminger <stephen@networkplumber.org>
> Subject: [PATCH 06/12] net/pcap: remove global variables
> 
> Localize variables where possible.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
>  drivers/net/pcap/pcap_ethdev.c | 8 ++++++--
>  1 file changed, 6 insertions(+), 2 deletions(-)
> 
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index 905ca62bd4..1658685a28 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -39,11 +39,9 @@
> 
>  #define RTE_PMD_PCAP_MAX_QUEUES 16
> 
> -static char errbuf[PCAP_ERRBUF_SIZE];
>  static struct timespec start_time;
>  static uint64_t start_cycles;
>  static uint64_t hz;
> -static uint8_t iface_idx;
> 
>  static uint64_t timestamp_rx_dynflag;
>  static int timestamp_dynfield_offset = -1;
> @@ -526,6 +524,8 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  static inline int
>  open_iface_live(const char *iface, pcap_t **pcap)
>  {
> +	char errbuf[PCAP_ERRBUF_SIZE];
> +
>  	pcap_t *pc = pcap_create(iface, errbuf);
>  	if (pc == NULL) {
>  		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
> @@ -621,6 +621,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
>  static int
>  open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
>  {
> +	char errbuf[PCAP_ERRBUF_SIZE];
> +
>  	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
>  							PCAP_TSTAMP_PRECISION_NANO, errbuf);
>  	if (*pcap == NULL) {
> @@ -1314,11 +1316,13 @@ pmd_init_internals(struct rte_vdev_device *vdev,
>  	 * - and point eth_dev structure to new eth_dev_data structure
>  	 */
>  	*internals = (*eth_dev)->data->dev_private;
> +
>  	/*
>  	 * Interface MAC = 02:70:63:61:70:<iface_idx>
>  	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
>  	 * where the middle 4 characters are converted to hex.
>  	 */
> +	static uint8_t iface_idx;
>  	(*internals)->eth_addr = (struct rte_ether_addr) {
>  		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
>  	};
> --
> 2.51.0

Acked-by: Marat Khalili <marat.khalili@huawei.com>

RE: [PATCH 03/12] net/pcap: use bool for flags

[Marat Khalili]

> -----Original Message-----
> From: Stephen Hemminger <stephen@networkplumber.org>
> Sent: Tuesday 6 January 2026 18:27
> To: dev@dpdk.org
> Cc: Stephen Hemminger <stephen@networkplumber.org>
> Subject: [PATCH 03/12] net/pcap: use bool for flags
> 
> Save some space by using bool for flag values.
> Use common code to parse value of a boolean flag.

Note that there might technically be some performance cost of this. Said that, 
since original code did not leave any comments why ints were used, let's think 
it was not on purpose, while bools are cleaner and less error-prone.

I however think that proper bool conversion should use true or false on 
assignment/initialization, not 1 or 0.

// snip

> @@ -1180,31 +1181,29 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
>  }
> 
>  static int
> -select_phy_mac(const char *key __rte_unused, const char *value,
> -		void *extra_args)
> +process_bool_flag(const char *key, const char *value, void *extra_args)

This function probably belongs in some common library. There is a similar code 
in lib/argparse/rte_argparse.c and lib/cmdline/cmdline_parse_bool.c that might 
benefit. Having some tests could also be useful.

I would also think of naming more, word "process" does not really convey much 
meaning. How about "parse_bool"?

>  {
> -	if (extra_args) {
> -		const int phy_mac = atoi(value);
> -		int *enable_phy_mac = extra_args;
> -
> -		if (phy_mac)
> -			*enable_phy_mac = 1;
> -	}
> -	return 0;
> -}
> +	bool *flag = extra_args;
> +	/* table of possible representation of boolean */
> +	static const char * const values[] = {
> +		"false", "true",
> +		"0", "1",
> +		"disable", "enable",
> +		"on", "off",

Last pair is swapped.

> +	};
> 
> -static int
> -get_infinite_rx_arg(const char *key __rte_unused,
> -		const char *value, void *extra_args)
> -{
> -	if (extra_args) {
> -		const int infinite_rx = atoi(value);
> -		int *enable_infinite_rx = extra_args;
> +	for (unsigned int i = 0; i < RTE_DIM(values); i++) {
> +		if (strcmp(value, values[i]) == 0) {

Maybe strcasecmp (just suggesting)?

> +			*flag = !!(i & 1);
> 
> -		if (infinite_rx > 0)
> -			*enable_infinite_rx = 1;
> +			PMD_LOG(INFO, "%s set to %s",
> +				key, *flag ? "true" : "false");

Should we have a common use {"false", "true"} inline function somewhere? 
Logging of infinite_rx in the same file could use it, as well as a few other 
places.

> +			return 0;
> +		}
>  	}
> -	return 0;
> +
> +	PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
> +	return -1;
>  }

RE: [PATCH 07/12] net/pcap: avoid use of volatile

[Marat Khalili]

> Using volatile for statistics generates expensive atomic rmw
> operations when not necessary.

I am not sure it is true, AFAIK volatile only affects the compiler. In this 
case it mostly guards against these variables being completely cached in 
registers. Your new version is actually more correct, but also potentially 
slower since general fence affects all reads or writes, not just counters in 
question. I think it is common among drivers to not guarantee visibility of 
the most recent counter values for the sake of performance.

> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
>  drivers/net/pcap/pcap_ethdev.c | 38 ++++++++++++++++++++++++++--------
>  1 file changed, 29 insertions(+), 9 deletions(-)
> 
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index 1658685a28..175d6998f9 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -47,10 +47,10 @@ static uint64_t timestamp_rx_dynflag;
>  static int timestamp_dynfield_offset = -1;
> 
>  struct queue_stat {
> -	volatile unsigned long pkts;
> -	volatile unsigned long bytes;
> -	volatile unsigned long err_pkts;
> -	volatile unsigned long rx_nombuf;
> +	uint64_t pkts;
> +	uint64_t bytes;
> +	uint64_t err_pkts;
> +	uint64_t rx_nombuf;
>  };
> 
>  struct queue_missed_stat {
> @@ -267,6 +267,9 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  	pcap_q->rx_stat.pkts += i;
>  	pcap_q->rx_stat.bytes += rx_bytes;
> 
> +	/* ensure store operations of statistics are visible */
> +	rte_atomic_thread_fence(rte_memory_order_release);
> +
>  	return i;
>  }
> 
> @@ -345,6 +348,9 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  	pcap_q->rx_stat.pkts += num_rx;
>  	pcap_q->rx_stat.bytes += rx_bytes;
> 
> +	/* ensure store operations of statistics are visible */
> +	rte_atomic_thread_fence(rte_memory_order_release);
> +
>  	return num_rx;
>  }
> 
> @@ -440,6 +446,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  	dumper_q->tx_stat.bytes += tx_bytes;
>  	dumper_q->tx_stat.err_pkts += nb_pkts - num_tx;
> 
> +	/* ensure store operations of statistics are visible */
> +	rte_atomic_thread_fence(rte_memory_order_release);
> +
>  	return nb_pkts;
>  }
> 
> @@ -464,6 +473,9 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  	tx_queue->tx_stat.pkts += nb_pkts;
>  	tx_queue->tx_stat.bytes += tx_bytes;
> 
> +	/* ensure store operations of statistics are visible */
> +	rte_atomic_thread_fence(rte_memory_order_release);
> +
>  	return nb_pkts;
>  }
> 
> @@ -515,6 +527,9 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  	tx_queue->tx_stat.bytes += tx_bytes;
>  	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
> 
> +	/* ensure store operations of statistics are visible */
> +	rte_atomic_thread_fence(rte_memory_order_release);
> +
>  	return nb_pkts;
>  }
> 
> @@ -821,13 +836,16 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
>  	      struct eth_queue_stats *qstats)
>  {
>  	unsigned int i;
> -	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
> -	unsigned long rx_missed_total = 0;
> -	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
> -	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
> -	unsigned long tx_packets_err_total = 0;
> +	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
> +	uint64_t rx_missed_total = 0;
> +	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
> +	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
> +	uint64_t tx_packets_err_total = 0;
>  	const struct pmd_internals *internal = dev->data->dev_private;
> 
> +	/* ensure that current statistics are visible */
> +	rte_atomic_thread_fence(rte_memory_order_acquire);
> +
>  	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
>  			i < dev->data->nb_rx_queues; i++) {
>  		if (qstats != NULL) {
> @@ -884,6 +902,8 @@ eth_stats_reset(struct rte_eth_dev *dev)
>  		internal->tx_queue[i].tx_stat.err_pkts = 0;
>  	}
> 
> +	/* ensure store operations of statistics are visible */
> +	rte_atomic_thread_fence(rte_memory_order_release);
>  	return 0;
>  }
> 
> --
> 2.51.0
> 

RE: [PATCH 08/12] net/pcap: optimize calculation of receive timestamp

[Marat Khalili]

> -----Original Message-----
> From: Stephen Hemminger <stephen@networkplumber.org>
> Sent: Tuesday 6 January 2026 18:27
> To: dev@dpdk.org
> Cc: Stephen Hemminger <stephen@networkplumber.org>
> Subject: [PATCH 08/12] net/pcap: optimize calculation of receive timestamp
> 
> Avoid doing slow instructions in receive path when calculating
> timestamp. Give all packets in the same rx burst the same timestamp.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
>  drivers/net/pcap/pcap_ethdev.c | 23 +++++++++++++----------
>  1 file changed, 13 insertions(+), 10 deletions(-)
> 
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index 175d6998f9..e283fb3787 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -20,6 +20,7 @@
>  #include <bus_vdev_driver.h>
>  #include <rte_os_shim.h>
>  #include <rte_time.h>
> +#include <rte_reciprocal.h>
> 
>  #include "pcap_osdep.h"
> 
> @@ -41,7 +42,7 @@
> 
>  static struct timespec start_time;
>  static uint64_t start_cycles;
> -static uint64_t hz;
> +static struct rte_reciprocal_u64 hz_inv;
> 
>  static uint64_t timestamp_rx_dynflag;
>  static int timestamp_dynfield_offset = -1;
> @@ -362,8 +363,6 @@ eth_null_rx(void *queue __rte_unused,
>  	return 0;
>  }
> 
> -#define NSEC_PER_SEC	1000000000L
> -
>  /*
>   * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
>   * because `ts` goes directly to nanosecond-precision dump.
> @@ -374,8 +373,10 @@ calculate_timestamp(struct timeval *ts) {
>  	struct timespec cur_time;
> 
>  	cycles = rte_get_timer_cycles() - start_cycles;
> -	cur_time.tv_sec = cycles / hz;
> -	cur_time.tv_nsec = (cycles % hz) * NSEC_PER_SEC / hz;
> +	cur_time.tv_sec = rte_reciprocal_divide_u64(cycles, &hz_inv);
> +	/* compute remainder */
> +	cycles -= cur_time.tv_sec * rte_get_timer_hz();

Can be made faster and safer by caching rte_get_timer_hz() result in current translation unit.

> +	cur_time.tv_nsec = rte_reciprocal_divide_u64(cycles * NS_PER_S, &hz_inv);
> 
>  	ts->tv_sec = start_time.tv_sec + cur_time.tv_sec;
>  	ts->tv_usec = start_time.tv_nsec + cur_time.tv_nsec;
> @@ -394,6 +395,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  	unsigned int i;
>  	struct pmd_process_private *pp;
>  	struct pcap_tx_queue *dumper_q = queue;
> +	struct pcap_pkthdr header;
>  	uint16_t num_tx = 0;
>  	uint32_t tx_bytes = 0;
>  	pcap_dumper_t *dumper;
> @@ -406,13 +408,14 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  	if (unlikely(dumper == NULL || nb_pkts == 0))
>  		return 0;
> 
> -	/* writes the nb_pkts packets to the previously opened pcap file
> -	 * dumper */
> +	/* all packets in burst have same timestamp */
> +	calculate_timestamp(&header.ts);
> +
> +	/* writes the nb_pkts packets to the previously opened pcap file dumper */
>  	for (i = 0; i < nb_pkts; i++) {
>  		struct rte_mbuf *mbuf = bufs[i];
>  		size_t len = rte_pktmbuf_pkt_len(mbuf);
>  		uint8_t temp_data[RTE_ETH_PCAP_SNAPLEN];
> -		struct pcap_pkthdr header;
> 
>  		if (unlikely(len > mtu))
>  			continue;
> @@ -420,7 +423,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  		if ((mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) && rte_vlan_insert(&mbuf))
>  			continue;
> 
> -		calculate_timestamp(&header.ts);
>  		header.len = len;
>  		header.caplen = len;
> 
> @@ -1530,7 +1532,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
> 
>  	timespec_get(&start_time, TIME_UTC);
>  	start_cycles = rte_get_timer_cycles();
> -	hz = rte_get_timer_hz();
> +
> +	hz_inv = rte_reciprocal_value_u64(rte_get_timer_hz());
> 
>  	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
>  		eth_dev = rte_eth_dev_attach_secondary(name);
> --
> 2.51.0

Apart from one minor optimization suggestion above,

Acked-by: Marat Khalili <marat.khalili@huawei.com>

Re: [PATCH 03/12] net/pcap: use bool for flags

[Stephen Hemminger]

On Wed, 7 Jan 2026 10:28:32 +0000
Marat Khalili <marat.khalili@huawei.com> wrote:

> > @@ -1180,31 +1181,29 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
> >  }
> > 
> >  static int
> > -select_phy_mac(const char *key __rte_unused, const char *value,
> > -		void *extra_args)
> > +process_bool_flag(const char *key, const char *value, void *extra_args)  
> 
> This function probably belongs in some common library. There is a similar code 
> in lib/argparse/rte_argparse.c and lib/cmdline/cmdline_parse_bool.c that might 
> benefit. Having some tests could also be useful.
> 
> I would also think of naming more, word "process" does not really convey much 
> meaning. How about "parse_bool"?

I just went off and tried that and it ends up not being that good.
The problem is that the place for common code in DPDK is currently EAL.

But if you put bool parsing in EAL it creates a circular dependency
since EAL depends on argparse and kvargs. So can't use any new string
parsing there. Cmdline does its own validation so common code won't help
there either.

Good idea, just won't work.
Going back to just 0/1 for now.

[PATCH v2 0/9] pcap: cleanup pcap PMD and add test

[Stephen Hemminger]

This is a set of enhancements and tests to the PCAP PMD.
It started out when looking at the handling of timestamps
then realized lots of other cleanups were needed here.

v2 - review feedback
   - consolidate patches

Stephen Hemminger (9):
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: support MTU set
  net/pcap: use bool for flags
  net/pcap: support Tx offloads
  net/pcap: support nanosecond timestamp precision
  net/pcap: remove global variables
  net/pcap: avoid use of volatile
  net/pcap: support MAC address set
  test: add test for pcap PMD

 app/test/meson.build                  |    2 +
 app/test/test_pmd_pcap.c              | 1846 +++++++++++++++++++++++++
 drivers/net/pcap/pcap_ethdev.c        |  353 +++--
 drivers/net/pcap/pcap_osdep.h         |    2 +
 drivers/net/pcap/pcap_osdep_freebsd.c |   60 +-
 drivers/net/pcap/pcap_osdep_linux.c   |   51 +-
 drivers/net/pcap/pcap_osdep_windows.c |    5 +
 7 files changed, 2184 insertions(+), 135 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v2 1/9] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_osdep_freebsd.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..32e4a2bee7 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -8,9 +8,6 @@
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +38,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
-- 
2.51.0

[PATCH v2 2/9] net/pcap: support MTU set

[Stephen Hemminger]

When used as single interface useful to support pass through
of MTU setting to enable larger frames.

Cleanup the transmit logic so that if packet sent exceeds MTU
is an error.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        | 94 +++++++++++++++------------
 drivers/net/pcap/pcap_osdep.h         |  1 +
 drivers/net/pcap/pcap_osdep_freebsd.c | 26 ++++++++
 drivers/net/pcap/pcap_osdep_linux.c   | 21 ++++++
 drivers/net/pcap/pcap_osdep_windows.c |  5 ++
 5 files changed, 104 insertions(+), 43 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..f4cb444395 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -22,7 +22,7 @@
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
+#define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
 #define RTE_ETH_PCAP_PROMISC 1
 #define RTE_ETH_PCAP_TIMEOUT -1
 
@@ -377,46 +377,46 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	uint16_t mtu;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	mtu = rte_eth_devices[dumper_q->port_id].data->mtu;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint8_t temp_data[RTE_ETH_PCAP_SNAPLEN];
+		struct pcap_pkthdr header;
+
+		if (unlikely(len > mtu))
+			continue;
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
-		header.caplen = caplen;
+		header.caplen = len;
+
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
 		 * a pointer to temp_data after copying into it.
 		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+		const uint8_t *data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		pcap_dump((u_char *)dumper, &header, data);
 
 		num_tx++;
-		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
+		tx_bytes += len;
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -444,15 +444,15 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(nb_pkts == 0))
 		return 0;
 
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -462,52 +462,45 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	uint16_t mtu;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	mtu = rte_eth_devices[tx_queue->port_id].data->mtu;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint8_t temp_data[RTE_ETH_PCAP_SNAPLEN];
+
+		if (unlikely(len > mtu))
 			continue;
-		}
 
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
 		 * a pointer to temp_data after copying into it.
 		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
+		const uint8_t *data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+
+		if (likely(pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
+		}
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
+	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -745,6 +738,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 
 	return 0;
 }
@@ -1002,6 +997,18 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+
+	if (internals->single_iface)
+		return osdep_iface_mtu_set(internals->if_index, mtu);
+
+	return 0;
+}
+
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1015,6 +1022,7 @@ static const struct eth_dev_ops ops = {
 	.rx_queue_stop = eth_rx_queue_stop,
 	.tx_queue_stop = eth_tx_queue_stop,
 	.link_update = eth_link_update,
+	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
 };
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..3c8b7ff27b 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -14,5 +14,6 @@ extern int eth_pcap_logtype;
 
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
+int osdep_iface_mtu_set(int index, uint16_t mtu);
 
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 32e4a2bee7..0279dbf00b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,9 +4,12 @@
  * All rights reserved.
  */
 
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
+#include <sys/ioctl.h>
+#include <sys/sockio.h>
 
 #include "pcap_osdep.h"
 
@@ -54,3 +57,26 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	char ifname[IFNAMSIZ];
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	int s = socket(AF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	struct ifreq ifr = { 0 };
+	if (s < 0)
+		return -EINVAL;
+
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_mtu = mtu;
+
+	int ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..d180e9b4b4 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -40,3 +40,24 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+int
+osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	char ifname[IFNAMSIZ];
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	int s = socket(PF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	struct ifreq ifr = { .ifr_mtu = mtu };
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	int ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..fde0db9961 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -116,3 +116,8 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int osdep_iface_mtu_set(int index __rte_unused, uint16_t mtu __rte_unused)
+{
+	return -ENOTSUP;
+}
-- 
2.51.0

[PATCH v2 3/9] net/pcap: use bool for flags

[Stephen Hemminger]

Save some space by using bool for flag values.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 67 +++++++++++++++-------------------
 1 file changed, 29 insertions(+), 38 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f4cb444395..5db44ab1ea 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -5,6 +5,7 @@
  */
 
 #include <stdlib.h>
+#include <stdbool.h>
 #include <time.h>
 
 #include <pcap.h>
@@ -91,9 +92,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -103,25 +104,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -858,7 +859,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1180,29 +1181,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1479,7 +1470,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1518,9 +1509,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
-- 
2.51.0

[PATCH v2 4/9] net/pcap: support Tx offloads

[Stephen Hemminger]

The driver already handles multi-segment mbufs but did not report
that in offload flags. Driver can easily insert vlan tag making
testing easier.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 5db44ab1ea..a27a132002 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -403,6 +403,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (unlikely(len > mtu))
 			continue;
 
+		if ((mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) && rte_vlan_insert(&mbuf))
+			continue;
+
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
@@ -485,6 +488,9 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (unlikely(len > mtu))
 			continue;
 
+		if ((mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) && rte_vlan_insert(&mbuf))
+			continue;
+
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
 		 * a pointer to temp_data after copying into it.
@@ -741,6 +747,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v2 5/9] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Consistently support nanosecond timestamps across all the
variations of pcap PMD receive.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 142 +++++++++++++++++++++++++--------
 1 file changed, 109 insertions(+), 33 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index a27a132002..25e78f1e3a 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -19,13 +19,13 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
+#include <rte_reciprocal.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
 #define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -44,6 +44,7 @@ static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
+static struct rte_reciprocal_u64 hz_inv;
 static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
@@ -68,6 +69,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -95,6 +97,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -325,10 +328,20 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * Although time stamp in struct pcap_pkthdr is defined as struct timeval,
+			 * it really is a timespec with nanosecond resolution.
+			 */
+			const struct timespec *ts = (struct timespec *)&header->ts;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(ts);
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -348,20 +361,21 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
  * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
  * because `ts` goes directly to nanosecond-precision dump.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
 	cycles = rte_get_timer_cycles() - start_cycles;
-	cur_time.tv_sec = cycles / hz;
-	cur_time.tv_nsec = (cycles % hz) * NSEC_PER_SEC / hz;
+	cur_time.tv_sec = rte_reciprocal_divide_u64(cycles, &hz_inv);
+	/* compute remainder */
+	cycles -= cur_time.tv_sec * hz;
+	cur_time.tv_nsec = rte_reciprocal_divide_u64(cycles * NS_PER_S, &hz_inv);
 
 	ts->tv_sec = start_time.tv_sec + cur_time.tv_sec;
 	ts->tv_usec = start_time.tv_nsec + cur_time.tv_nsec;
@@ -380,6 +394,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	unsigned int i;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct pcap_pkthdr header;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_dumper_t *dumper;
@@ -392,13 +407,14 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
 		size_t len = rte_pktmbuf_pkt_len(mbuf);
 		uint8_t temp_data[RTE_ETH_PCAP_SNAPLEN];
-		struct pcap_pkthdr header;
 
 		if (unlikely(len > mtu))
 			continue;
@@ -406,7 +422,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if ((mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) && rte_vlan_insert(&mbuf))
 			continue;
 
-		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
 
@@ -514,22 +529,57 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	int status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscious: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -576,7 +626,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -613,6 +664,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
 
+	if (internals->timestamp_offloading) {
+		int ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							     &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+	}
+
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
@@ -728,8 +788,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -749,6 +814,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -896,6 +962,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1017,6 +1084,16 @@ eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in UTC */
+static int
+eth_rx_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
 
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
@@ -1034,6 +1111,7 @@ static const struct eth_dev_ops ops = {
 	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.read_clock = eth_rx_clock,
 };
 
 static int
@@ -1434,15 +1512,13 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		hz = rte_get_timer_hz();
+		hz_inv = rte_reciprocal_value_u64(hz);
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v2 6/9] net/pcap: remove global variables

[Stephen Hemminger]

Localize variables where possible.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 25e78f1e3a..30734cc09d 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -40,12 +40,10 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
 static struct rte_reciprocal_u64 hz_inv;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -531,6 +529,8 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	pcap_t *pc = pcap_create(iface, errbuf);
 	if (pc == NULL) {
 		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
@@ -626,6 +626,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1327,6 +1329,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v2 7/9] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 30734cc09d..bf03f431dd 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -49,10 +49,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -826,11 +826,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v2 8/9] net/pcap: support MAC address set

[Stephen Hemminger]

Use rte_ether_addr structure to avoid memcpy and void *.

When using pcap on a single interface, it is possible for
driver to proxy the mac address set operation.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        | 19 ++++++++++++++---
 drivers/net/pcap/pcap_osdep.h         |  1 +
 drivers/net/pcap/pcap_osdep_freebsd.c | 23 ++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c   | 30 ++++++++++++++++++++++++++-
 4 files changed, 69 insertions(+), 4 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index bf03f431dd..824cdabab6 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1086,6 +1086,18 @@ eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 	return 0;
 }
 
+static int
+eth_dev_macaddr_set(struct rte_eth_dev *dev, struct rte_ether_addr *addr)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+
+	if (internals->single_iface)
+		return osdep_iface_mac_set(internals->if_index, addr);
+	else
+		return -ENOTSUP;
+}
+
+
 /* Timestamp values in receive packets from libpcap are in UTC */
 static int
 eth_rx_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
@@ -1110,6 +1122,7 @@ static const struct eth_dev_ops ops = {
 	.rx_queue_stop = eth_rx_queue_stop,
 	.tx_queue_stop = eth_tx_queue_stop,
 	.link_update = eth_link_update,
+	.mac_addr_set = eth_dev_macaddr_set,
 	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
@@ -1357,9 +1370,9 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 
 static int
 eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
-		const unsigned int numa_node)
+		    const unsigned int numa_node)
 {
-	void *mac_addrs;
+	struct rte_ether_addr *mac_addrs;
 	struct rte_ether_addr mac;
 
 	if (osdep_iface_mac_get(if_name, &mac) < 0)
@@ -1370,7 +1383,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	rte_ether_addr_copy(&mac, mac_addrs);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 3c8b7ff27b..00944e0843 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -14,6 +14,7 @@ extern int eth_pcap_logtype;
 
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
+int osdep_iface_mac_set(int ifindex, const struct rte_ether_addr *mac);
 int osdep_iface_mtu_set(int index, uint16_t mtu);
 
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0279dbf00b..39227da63a 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -58,6 +58,29 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	return 0;
 }
 
+int
+osdep_iface_mac_set(int ifindex, const struct rte_ether_addr *mac)
+{
+	char ifname[IFNAMSIZ];
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	int s = socket(AF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	struct ifreq ifr = { 0 };
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_addr.sa_family = AF_LINK;
+	memcpy(ifr.ifr_addr.sa_data, mac, sizeof(*mac));
+
+	int ret = ioctl(s, SIOCSIFLLADDR, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
+
 int osdep_iface_mtu_set(int ifindex, uint16_t mtu)
 {
 	char ifname[IFNAMSIZ];
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index d180e9b4b4..d5a3855a0a 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,13 +4,18 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <errno.h>
 #include <net/if.h>
+#include <net/if_arp.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
 #include <rte_memcpy.h>
 #include <rte_string_fns.h>
+#include <rte_ether.h>
 
 #include "pcap_osdep.h"
 
@@ -41,6 +46,29 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	return 0;
 }
 
+int
+osdep_iface_mac_set(int ifindex, const struct rte_ether_addr *mac)
+{
+	char ifname[IFNAMSIZ];
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	int s = socket(AF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	struct ifreq ifr = { 0 };
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
+	memcpy(ifr.ifr_hwaddr.sa_data, mac, sizeof(*mac));
+
+	int ret = ioctl(s, SIOCSIFHWADDR, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
+
 int
 osdep_iface_mtu_set(int ifindex, uint16_t mtu)
 {
-- 
2.51.0

[PATCH v2 9/9] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, and multiple queues.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build     |    2 +
 app/test/test_pmd_pcap.c | 1846 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 1848 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index efec42a6bf..237bc271a7 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev',  'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..ac02e30aa1
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,1846 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+/*
+ * Helper: Create a unique temporary file path
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		rte_memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+			   test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if network interface exists
+ */
+static int
+iface_exists(const char *name)
+{
+	struct ifreq ifr;
+	int sock, ret;
+
+	sock = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sock < 0)
+		return 0;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, name, IFNAMSIZ);
+	ret = ioctl(sock, SIOCGIFINDEX, &ifr);
+	close(sock);
+	return ret == 0;
+}
+
+/*
+ * Helper: Find a usable test interface
+ */
+static const char *
+find_test_iface(void)
+{
+	if (iface_exists("dummy0"))
+		return "dummy0";
+	if (iface_exists("lo"))
+		return "lo";
+	return NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	unlink(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	unlink(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: MTU configuration
+ */
+static int
+test_set_mtu(void)
+{
+	char devargs[256];
+	char mtu_tx_path[PATH_MAX];
+	uint16_t port_id;
+	static const uint16_t mtu_values[] = {1500, 9000, 1280};
+	int ret = 0;
+	size_t i;
+
+	printf("Testing MTU configuration\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_mtu_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(mtu_tx_path, sizeof(mtu_tx_path),
+				     "pcap_mtu_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, mtu_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_mtu", devargs, &port_id) == 0,
+		    "Failed to create MTU vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup MTU port");
+
+	for (i = 0; i < RTE_DIM(mtu_values); i++) {
+		uint16_t mtu;
+
+		ret = rte_eth_dev_set_mtu(port_id, mtu_values[i]);
+		if (ret != 0)
+			break;
+
+		TEST_ASSERT(rte_eth_dev_get_mtu(port_id, &mtu) == 0, "Failed to get MTU");
+		TEST_ASSERT_EQUAL(mtu, mtu_values[i], "MTU set mismatch for %u", mtu_values[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_mtu", port_id);
+	unlink(mtu_tx_path);
+
+	if (ret == 0) {
+		printf("MTU test completed\n");
+		return TEST_SUCCESS;
+	}
+
+	if (ret == -ENOTSUP) {
+		printf("MTU set not supported\n");
+		return TEST_SKIPPED;
+	}
+
+	printf("Failed to set MTU: %s", strerror(-ret));
+	return TEST_FAILED;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count, ret;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Set MTU to allow jumbo frames - PMD drops packets exceeding MTU */
+	ret = rte_eth_dev_set_mtu(port_id, PKT_SIZE_JUMBO);
+	if (ret != 0) {
+		printf("Failed to set MTU to %u: %s\n",
+		       PKT_SIZE_JUMBO, rte_strerror(-ret));
+		cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+		unlink(tx_path);
+		return TEST_SKIPPED;
+	}
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			unlink(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	unlink(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: MAC address with phy_mac option
+ */
+static int
+test_mac_address(void)
+{
+	struct rte_ether_addr orig_mac, new_mac, read_mac;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing MAC address configuration\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	if (strcmp(iface, "lo") == 0) {
+		printf("Need dummy interface to test setting mac address\n");
+		return TEST_SKIPPED;
+	}
+
+	snprintf(devargs, sizeof(devargs), "iface=%s,phy_mac=1", iface);
+	if (rte_vdev_init("net_pcap_mac", devargs) < 0) {
+		printf("Cannot create mac vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_mac", &port_id) == 0,
+		    "Failed to get mac port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup mac port");
+
+	ret = rte_eth_macaddr_get(port_id, &orig_mac);
+	TEST_ASSERT(ret == 0, "Failed to get original MAC");
+	printf("Original MAC: " RTE_ETHER_ADDR_PRT_FMT "\n",
+	       RTE_ETHER_ADDR_BYTES(&orig_mac));
+
+	/* Try to set a new MAC */
+	rte_eth_random_addr(new_mac.addr_bytes);
+
+	ret = rte_eth_dev_default_mac_addr_set(port_id, &new_mac);
+	if (ret == 0) {
+		rte_eth_macaddr_get(port_id, &read_mac);
+		printf("New MAC: " RTE_ETHER_ADDR_PRT_FMT "\n",
+		       RTE_ETHER_ADDR_BYTES(&read_mac));
+		/* Restore original */
+		rte_eth_dev_default_mac_addr_set(port_id, &orig_mac);
+		ret = TEST_SUCCESS;
+	} else if (ret == -ENOTSUP) {
+		printf("MAC change not supported\n");
+		ret = TEST_SKIPPED;
+	} else {
+		printf("MAC change failed: %s\n", rte_strerror(-ret));
+		ret = TEST_FAILED;
+	}
+
+	cleanup_pcap_vdev("net_pcap_mac", port_id);
+
+	printf("MAC address test completed\n");
+	return ret;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u", total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. min_mtu and max_mtu are set to reasonable values
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0, "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    min_mtu: %u\n", dev_info.min_mtu);
+	printf("    max_mtu: %u\n", dev_info.max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify MTU limits are reasonable */
+	TEST_ASSERT(dev_info.min_mtu > 0, "min_mtu should be > 0, got %u", dev_info.min_mtu);
+	TEST_ASSERT(dev_info.min_mtu <= RTE_ETHER_MIN_MTU,
+		    "min_mtu should be <= %u, got %u", RTE_ETHER_MIN_MTU, dev_info.min_mtu);
+	TEST_ASSERT(dev_info.max_mtu <= RTE_ETHER_MAX_JUMBO_FRAME_LEN,
+		    "max_mtu should be <= %u, got %u", RTE_ETHER_MAX_JUMBO_FRAME_LEN, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		unlink(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		unlink(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	if (tx_pcap_path[0] != '\0')
+		unlink(tx_pcap_path);
+	if (rx_pcap_path[0] != '\0')
+		unlink(rx_pcap_path);
+	if (infinite_pcap_path[0] != '\0')
+		unlink(infinite_pcap_path);
+	if (timestamp_pcap_path[0] != '\0')
+		unlink(timestamp_pcap_path);
+	if (varied_pcap_path[0] != '\0')
+		unlink(varied_pcap_path);
+	if (jumbo_pcap_path[0] != '\0')
+		unlink(jumbo_pcap_path);
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++) {
+		if (multi_tx_pcap_paths[i][0] != '\0')
+			unlink(multi_tx_pcap_paths[i]);
+	}
+	if (multi_rx_pcap_path[0] != '\0')
+		unlink(multi_rx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_set_mtu),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_mac_address),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, true, true, test_pmd_pcap);
-- 
2.51.0

Re: [PATCH v2 0/9] pcap: cleanup pcap PMD and add test

[Stephen Hemminger]

On Thu,  8 Jan 2026 17:16:17 -0800
Stephen Hemminger <stephen@networkplumber.org> wrote:

> This is a set of enhancements and tests to the PCAP PMD.
> It started out when looking at the handling of timestamps
> then realized lots of other cleanups were needed here.
> 
> v2 - review feedback
>    - consolidate patches
> 
> Stephen Hemminger (9):
>   net/pcap: avoid using rte_malloc and rte_memcpy
>   net/pcap: support MTU set
>   net/pcap: use bool for flags
>   net/pcap: support Tx offloads
>   net/pcap: support nanosecond timestamp precision
>   net/pcap: remove global variables
>   net/pcap: avoid use of volatile
>   net/pcap: support MAC address set
>   test: add test for pcap PMD
> 
>  app/test/meson.build                  |    2 +
>  app/test/test_pmd_pcap.c              | 1846 +++++++++++++++++++++++++
>  drivers/net/pcap/pcap_ethdev.c        |  353 +++--
>  drivers/net/pcap/pcap_osdep.h         |    2 +
>  drivers/net/pcap/pcap_osdep_freebsd.c |   60 +-
>  drivers/net/pcap/pcap_osdep_linux.c   |   51 +-
>  drivers/net/pcap/pcap_osdep_windows.c |    5 +
>  7 files changed, 2184 insertions(+), 135 deletions(-)
>  create mode 100644 app/test/test_pmd_pcap.c
> 

Results of AI review with AGENTS.md are:


I'll start by reading the AGENTS.md file to understand the review criteria, then examine the patch bundle.Let me view the middle sections of the patch bundle to see all patches:Now I have a comprehensive view of the patch series. Let me provide the review based on the AGENTS.md criteria:

---

## DPDK Patch Review: net/pcap Driver Changes (v2, 9 patches)

### Patch Series Overview

| # | Subject | Status |
|---|---------|--------|
| 1/9 | net/pcap: avoid using rte_malloc and rte_memcpy | ✅ Clean |
| 2/9 | net/pcap: support MTU set | ⚠️ Minor issues |
| 3/9 | net/pcap: use bool for flags | ✅ Clean |
| 4/9 | net/pcap: add VLAN insert offload | ✅ Clean |
| 5/9 | net/pcap: support nanosecond timestamp precision | ✅ Clean |
| 6/9 | net/pcap: localize variables | ✅ Clean |
| 7/9 | net/pcap: avoid use of volatile | ✅ Clean |
| 8/9 | net/pcap: support MAC address set | ⚠️ Minor issues |
| 9/9 | test: add test for pcap PMD | ⚠️ Warnings |

---

### Detailed Review

#### **Patch 1/9: net/pcap: avoid using rte_malloc and rte_memcpy**

**Commit Message**: ✅ Pass
- Subject line: 49 chars (≤60 ✓)
- Correct component prefix `net/pcap:`
- Imperative mood, lowercase, no trailing period
- Signed-off-by present

**Code Changes**: ✅ Pass
- Simple, correct replacement of `rte_malloc`/`rte_free` with standard `malloc`/`free`
- Removes unnecessary includes `<rte_malloc.h>` and `<rte_memcpy.h>`
- Appropriate for FreeBSD osdep code that doesn't need hugepage allocations

---

#### **Patch 2/9: net/pcap: support MTU set**

**Commit Message**: ✅ Pass

**Code Review**: ⚠️ Warnings

1. **FreeBSD duplicate check** (line 489-491):
   ```c
   int s = socket(AF_INET, SOCK_DGRAM, 0);
   if (s < 0)
       return -errno;

   struct ifreq ifr = { 0 };
   if (s < 0)     // <-- Dead code: already checked above
       return -EINVAL;
   ```
   This is dead code - `s < 0` was already handled above. Remove the second check.

2. **Double blank line** (lines 1009-1010): Style issue - extra blank line before `static const struct eth_dev_ops ops`.

3. **Warning (should fix)**: The FreeBSD `osdep_iface_mtu_set` function does not close the socket on all error paths before the duplicate check.

---

#### **Patch 3/9: net/pcap: use bool for flags**

**Commit Message**: ✅ Pass

**Code Changes**: ✅ Pass
- Good cleanup converting `unsigned int` and `int` flags to `bool`
- Adds `<stdbool.h>` header appropriately
- Consolidates `select_phy_mac` and `get_infinite_rx_arg` into unified `process_bool_flag`
- Using `bool` for flags follows DPDK guidelines

---

#### **Patch 4/9: net/pcap: add VLAN insert offload**

**Commit Message**: ✅ Pass

**Code Changes**: ✅ Pass
- Adds `<rte_vlan.h>` header
- Correctly adds VLAN insert capability to both TX paths
- Reports capability in `dev_info->tx_offload_capa`

---

#### **Patch 5/9: net/pcap: support nanosecond timestamp precision**

**Commit Message**: ✅ Pass

**Code Changes**: ✅ Pass
- Good use of `rte_reciprocal_u64` for efficient division
- Replaces `pcap_open_live` with `pcap_create`/`pcap_activate` pattern for more control
- Uses `pcap_open_offline_with_tstamp_precision` for nanosecond precision
- Adds `read_clock` op for timestamp synchronization
- Makes timestamp offloading configurable via `rxmode.offloads`

**Info**: Nice optimization using `rte_reciprocal_divide_u64` to avoid expensive division operations in the fast path.

---

#### **Patch 6/9: net/pcap: localize variables**

**Commit Message**: ✅ Pass
- Has `Acked-by:` from reviewer ✓

**Code Changes**: ✅ Pass
- Moves `errbuf` to function-local scope
- Makes `iface_idx` static within function scope
- Good practice to reduce global state

---

#### **Patch 7/9: net/pcap: avoid use of volatile**

**Commit Message**: ✅ Pass

**Code Changes**: ✅ Pass
- Removes `volatile` keyword from statistics structures
- Changes `unsigned long` to `uint64_t` for consistency
- Rationale is sound: only one thread operates on a queue at a time in DPDK

---

#### **Patch 8/9: net/pcap: support MAC address set**

**Commit Message**: ✅ Pass

**Code Review**: ⚠️ Warnings

1. **Double blank line** (lines 1709-1711): Extra blank line after `eth_dev_macaddr_set` function.

2. **Linux code changes** (line 1803-1809): The header reordering is correct:
   ```c
   #include <string.h>
   #include <stdint.h>
   #include <unistd.h>
   #include <errno.h>
   #include <net/if.h>
   #include <net/if_arp.h>
   ```
   This follows proper include ordering (system headers first).

---

#### **Patch 9/9: test: add test for pcap PMD**

**Commit Message**: ✅ Pass
- Subject `test:` prefix is correct for app/test

**Code Review**: ⚠️ Warnings

1. **SPDX/Copyright**: ✅ Correct format:
   ```c
   /* SPDX-License-Identifier: BSD-3-Clause
    * Copyright(c) 2026 Stephen Hemminger
    */
   ```

2. **Include order issue** (lines 1977-1997): The `"test.h"` and `"packet_burst_generator.h"` should come **after** system and DPDK includes, not before. The correct order per AGENTS.md is:
   - System/libc includes
   - DPDK EAL includes
   - DPDK misc library includes
   - Application-specific includes

   **Should be:**
   ```c
   #include <stdio.h>
   #include <stdlib.h>
   ...
   #include <rte_ethdev.h>
   ...
   #include "test.h"
   #include "packet_burst_generator.h"
   ```

3. **Meson.build style** (line 1955):
   ```python
   'test_pmd_pcap.c': ['net_pcap', 'ethdev',  'bus_vdev']  + packet_burst_generator_deps,
   ```
   Double space after `'ethdev',` - should be single space.

4. **Test registration** (line 3818): Uses `REGISTER_FAST_TEST` which is correct for the test framework.

5. **Line length**: All checked lines are within the 100-char limit ✓

---

### Summary

| Severity | Count | Issues |
|----------|-------|--------|
| **Error** | 0 | None |
| **Warning** | 4 | Dead code in FreeBSD MTU (2/9), double blank lines (2/9, 8/9), include order in test (9/9), meson spacing (9/9) |
| **Info** | 1 | Good use of reciprocal divide optimization (5/9) |

### Recommendations

1. **Patch 2/9**: Remove the dead code check `if (s < 0)` on line 490 of `pcap_osdep_freebsd.c`

2. **Patch 2/9, 8/9**: Remove extra blank lines to maintain single blank line between functions

3. **Patch 9/9**: Reorder includes in `test_pmd_pcap.c` to place `"test.h"` and `"packet_burst_generator.h"` after DPDK includes

4. **Patch 9/9**: Fix double space in `meson.build`

Overall, this is a well-structured patch series with good separation of concerns. The issues are minor style/cleanup items that don't affect functionality.

[PATCH v3 0/9] net/pcap: improvements and test coverage

[Stephen Hemminger]

This series brings several improvements to the PCAP PMD:

 - Update documentation to reflect actually supported features
 - Code cleanups: remove unnecessary rte_malloc/rte_memcpy usage,
   convert flags to bool, remove global variables, avoid volatile
 - Add MTU set support for single interface mode
 - Add Tx offload support
 - Support nanosecond timestamp precision
 - Add comprehensive test suite

This was done via mix of new code and AI feedback.

Stephen Hemminger (9):
  doc: update features for PCAP PMD
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: support MTU set
  net/pcap: use bool for flags
  net/pcap: support Tx offloads
  net/pcap: support nanosecond timestamp precision
  net/pcap: remove global variables
  net/pcap: avoid use of volatile
  test: add test for pcap PMD

 app/test/meson.build                  |    2 +
 app/test/test_pmd_pcap.c              | 1801 +++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini     |   10 +
 drivers/net/pcap/pcap_ethdev.c        |  336 +++--
 drivers/net/pcap/pcap_osdep.h         |    1 +
 drivers/net/pcap/pcap_osdep_freebsd.c |   37 +-
 drivers/net/pcap/pcap_osdep_linux.c   |   21 +
 drivers/net/pcap/pcap_osdep_windows.c |    6 +
 8 files changed, 2083 insertions(+), 131 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v3 1/9] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..060b2f4df5 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Rx Timestamp         = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v3 2/9] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_osdep_freebsd.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..32e4a2bee7 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -8,9 +8,6 @@
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +38,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
-- 
2.51.0

[PATCH v3 3/9] net/pcap: support MTU set

[Stephen Hemminger]

When used as single interface useful to support pass through
of MTU setting to enable larger frames.

Cleanup the transmit logic so that if packet sent exceeds MTU
it is counted as an error and packet is silently dropped.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini     |  1 +
 drivers/net/pcap/pcap_ethdev.c        | 93 ++++++++++++++-------------
 drivers/net/pcap/pcap_osdep.h         |  1 +
 drivers/net/pcap/pcap_osdep_freebsd.c | 26 ++++++++
 drivers/net/pcap/pcap_osdep_linux.c   | 21 ++++++
 drivers/net/pcap/pcap_osdep_windows.c |  6 ++
 6 files changed, 105 insertions(+), 43 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 060b2f4df5..e75bf03051 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -19,3 +19,4 @@ Power8               = Y
 x86-32               = Y
 x86-64               = Y
 Usage doc            = Y
+MTU update           = Y
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..564c40e26e 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -22,7 +22,7 @@
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
+#define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
 #define RTE_ETH_PCAP_PROMISC 1
 #define RTE_ETH_PCAP_TIMEOUT -1
 
@@ -377,46 +377,46 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	uint16_t mtu;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	mtu = rte_eth_devices[dumper_q->port_id].data->mtu;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint8_t temp_data[RTE_ETH_PCAP_SNAPLEN];
+		struct pcap_pkthdr header;
+
+		if (unlikely(len > mtu))
+			continue;
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
-		header.caplen = caplen;
+		header.caplen = len;
+
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
 		 * a pointer to temp_data after copying into it.
 		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+		const uint8_t *data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		pcap_dump((u_char *)dumper, &header, data);
 
 		num_tx++;
-		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
+		tx_bytes += len;
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -444,15 +444,15 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(nb_pkts == 0))
 		return 0;
 
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -462,52 +462,45 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	uint16_t mtu;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	mtu = rte_eth_devices[tx_queue->port_id].data->mtu;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint8_t temp_data[RTE_ETH_PCAP_SNAPLEN];
+
+		if (unlikely(len > mtu))
 			continue;
-		}
 
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
 		 * a pointer to temp_data after copying into it.
 		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
+		const uint8_t *data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+
+		if (likely(pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
+		}
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
+	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -745,6 +738,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 
 	return 0;
 }
@@ -1002,6 +997,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+
+	if (internals->single_iface)
+		return osdep_iface_mtu_set(internals->if_index, mtu);
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1015,6 +1021,7 @@ static const struct eth_dev_ops ops = {
 	.rx_queue_stop = eth_rx_queue_stop,
 	.tx_queue_stop = eth_tx_queue_stop,
 	.link_update = eth_link_update,
+	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
 };
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..3c8b7ff27b 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -14,5 +14,6 @@ extern int eth_pcap_logtype;
 
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
+int osdep_iface_mtu_set(int index, uint16_t mtu);
 
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 32e4a2bee7..697b7029dd 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,9 +4,12 @@
  * All rights reserved.
  */
 
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
+#include <sys/ioctl.h>
+#include <sys/sockio.h>
 
 #include "pcap_osdep.h"
 
@@ -54,3 +57,26 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	struct ifreq ifr = { 0 };
+	char ifname[IFNAMSIZ];
+	int s, ret;
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	s = socket(AF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_mtu = mtu;
+
+	ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..d180e9b4b4 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -40,3 +40,24 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+int
+osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	char ifname[IFNAMSIZ];
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	int s = socket(PF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	struct ifreq ifr = { .ifr_mtu = mtu };
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	int ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..00df67b8fc 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -116,3 +116,9 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_mtu_set(int index __rte_unused, uint16_t mtu __rte_unused)
+{
+	return -ENOTSUP;
+}
-- 
2.51.0

[PATCH v3 4/9] net/pcap: use bool for flags

[Stephen Hemminger]

Save some space by using bool for flag values.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 67 +++++++++++++++-------------------
 1 file changed, 29 insertions(+), 38 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 564c40e26e..7002f8034a 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -5,6 +5,7 @@
  */
 
 #include <stdlib.h>
+#include <stdbool.h>
 #include <time.h>
 
 #include <pcap.h>
@@ -91,9 +92,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -103,25 +104,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -858,7 +859,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1179,29 +1180,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1478,7 +1469,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1517,9 +1508,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
-- 
2.51.0

[PATCH v3 5/9] net/pcap: support Tx offloads

[Stephen Hemminger]

The driver already handles multi-segment mbufs but did not report
that in offload flags. Driver can easily insert vlan tag making
testing easier.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 1 +
 drivers/net/pcap/pcap_ethdev.c    | 8 ++++++++
 2 files changed, 9 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index e75bf03051..c4772031be 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Rx Timestamp         = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = P
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 7002f8034a..fde04bd1b2 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -403,6 +403,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (unlikely(len > mtu))
 			continue;
 
+		if ((mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) && rte_vlan_insert(&mbuf))
+			continue;
+
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
@@ -485,6 +488,9 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (unlikely(len > mtu))
 			continue;
 
+		if ((mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) && rte_vlan_insert(&mbuf))
+			continue;
+
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
 		 * a pointer to temp_data after copying into it.
@@ -741,6 +747,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v3 6/9] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Consistently support nanosecond timestamps across all the
variations of pcap PMD receive.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini |   1 +
 drivers/net/pcap/pcap_ethdev.c    | 146 +++++++++++++++++++++++-------
 2 files changed, 114 insertions(+), 33 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index c4772031be..ae38051dc6 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -11,6 +11,7 @@ Rx Timestamp         = Y
 Basic stats          = Y
 Stats per queue      = Y
 VLAN offload         = P
+Timestamp offload    = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fde04bd1b2..fbd0f475d7 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -19,13 +19,13 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
+#include <rte_reciprocal.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
 #define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -44,6 +44,7 @@ static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
+static struct rte_reciprocal_u64 hz_inv;
 static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
@@ -68,6 +69,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -95,6 +97,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -325,10 +328,20 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * Although time stamp in struct pcap_pkthdr is defined as struct timeval,
+			 * it really is a timespec with nanosecond resolution.
+			 */
+			const struct timespec *ts = (struct timespec *)&header->ts;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(ts);
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -348,20 +361,21 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
  * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
  * because `ts` goes directly to nanosecond-precision dump.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
 	cycles = rte_get_timer_cycles() - start_cycles;
-	cur_time.tv_sec = cycles / hz;
-	cur_time.tv_nsec = (cycles % hz) * NSEC_PER_SEC / hz;
+	cur_time.tv_sec = rte_reciprocal_divide_u64(cycles, &hz_inv);
+	/* compute remainder */
+	cycles -= cur_time.tv_sec * hz;
+	cur_time.tv_nsec = rte_reciprocal_divide_u64(cycles * NS_PER_S, &hz_inv);
 
 	ts->tv_sec = start_time.tv_sec + cur_time.tv_sec;
 	ts->tv_usec = start_time.tv_nsec + cur_time.tv_nsec;
@@ -380,6 +394,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	unsigned int i;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct pcap_pkthdr header;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_dumper_t *dumper;
@@ -392,13 +407,14 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
 		size_t len = rte_pktmbuf_pkt_len(mbuf);
 		uint8_t temp_data[RTE_ETH_PCAP_SNAPLEN];
-		struct pcap_pkthdr header;
 
 		if (unlikely(len > mtu))
 			continue;
@@ -406,7 +422,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if ((mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) && rte_vlan_insert(&mbuf))
 			continue;
 
-		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
 
@@ -514,22 +529,60 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
+
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscious: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -576,7 +629,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -613,6 +667,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
 
+	if (internals->timestamp_offloading) {
+		int ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							     &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+	}
+
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
@@ -728,8 +791,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -749,6 +817,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -896,6 +965,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1017,6 +1087,17 @@ eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in UTC */
+static int
+eth_rx_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1033,6 +1114,7 @@ static const struct eth_dev_ops ops = {
 	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.read_clock = eth_rx_clock,
 };
 
 static int
@@ -1433,15 +1515,13 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		hz = rte_get_timer_hz();
+		hz_inv = rte_reciprocal_value_u64(hz);
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v3 7/9] net/pcap: remove global variables

[Stephen Hemminger]

Localize variables where possible.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd0f475d7..6dbcd58465 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -40,12 +40,10 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
 static struct rte_reciprocal_u64 hz_inv;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -531,6 +529,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -629,6 +628,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1330,6 +1331,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v3 8/9] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 6dbcd58465..0c7eb00314 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -49,10 +49,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -828,11 +828,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v3 9/9] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, and multiple queues.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build     |    2 +
 app/test/test_pmd_pcap.c | 1801 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 1803 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index efec42a6bf..6c0bf7068d 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..59fedcce9d
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,1801 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * This test needs OS network interfaces and
+ * managing that would require more changes on Windows.
+ */
+static int
+test_pmd_pcap(void)
+{
+	printf("PCAP test not supported on Windows, skipping test\n");
+	return TEST_SKIPPED;
+}
+
+#else
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+/*
+ * Helper: Create a unique temporary file path
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		rte_memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+			   test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if network interface exists
+ */
+static int
+iface_exists(const char *name)
+{
+	struct ifreq ifr;
+	int sock, ret;
+
+	sock = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sock < 0)
+		return 0;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, name, IFNAMSIZ);
+	ret = ioctl(sock, SIOCGIFINDEX, &ifr);
+	close(sock);
+	return ret == 0;
+}
+
+/*
+ * Helper: Find a usable test interface
+ */
+static const char *
+find_test_iface(void)
+{
+	if (iface_exists("dummy0"))
+		return "dummy0";
+	if (iface_exists("lo"))
+		return "lo";
+	return NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	unlink(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	unlink(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: MTU configuration
+ */
+static int
+test_set_mtu(void)
+{
+	char devargs[256];
+	char mtu_tx_path[PATH_MAX];
+	uint16_t port_id;
+	static const uint16_t mtu_values[] = {1500, 9000, 1280};
+	int ret = 0;
+	size_t i;
+
+	printf("Testing MTU configuration\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_mtu_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(mtu_tx_path, sizeof(mtu_tx_path),
+				     "pcap_mtu_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, mtu_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_mtu", devargs, &port_id) == 0,
+		    "Failed to create MTU vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup MTU port");
+
+	for (i = 0; i < RTE_DIM(mtu_values); i++) {
+		uint16_t mtu;
+
+		ret = rte_eth_dev_set_mtu(port_id, mtu_values[i]);
+		if (ret != 0)
+			break;
+
+		TEST_ASSERT(rte_eth_dev_get_mtu(port_id, &mtu) == 0, "Failed to get MTU");
+		TEST_ASSERT_EQUAL(mtu, mtu_values[i], "MTU set mismatch for %u", mtu_values[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_mtu", port_id);
+	unlink(mtu_tx_path);
+
+	if (ret == 0) {
+		printf("MTU test completed\n");
+		return TEST_SUCCESS;
+	}
+
+	if (ret == -ENOTSUP) {
+		printf("MTU set not supported\n");
+		return TEST_SKIPPED;
+	}
+
+	printf("Failed to set MTU: %s", strerror(-ret));
+	return TEST_FAILED;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count, ret;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Set MTU to allow jumbo frames - PMD drops packets exceeding MTU */
+	ret = rte_eth_dev_set_mtu(port_id, PKT_SIZE_JUMBO);
+	if (ret != 0) {
+		printf("Failed to set MTU to %u: %s\n",
+		       PKT_SIZE_JUMBO, rte_strerror(-ret));
+		cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+		unlink(tx_path);
+		return TEST_SKIPPED;
+	}
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			unlink(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	unlink(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. min_mtu and max_mtu are set to reasonable values
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    min_mtu: %u\n", dev_info.min_mtu);
+	printf("    max_mtu: %u\n", dev_info.max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify MTU limits are reasonable */
+	TEST_ASSERT(dev_info.min_mtu > 0, "min_mtu should be > 0, got %u", dev_info.min_mtu);
+	TEST_ASSERT(dev_info.min_mtu <= RTE_ETHER_MIN_MTU,
+		    "min_mtu should be <= %u, got %u", RTE_ETHER_MIN_MTU, dev_info.min_mtu);
+	TEST_ASSERT(dev_info.max_mtu <= RTE_ETHER_MAX_JUMBO_FRAME_LEN,
+		    "max_mtu should be <= %u, got %u",
+		    RTE_ETHER_MAX_JUMBO_FRAME_LEN, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		unlink(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		unlink(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	if (tx_pcap_path[0] != '\0')
+		unlink(tx_pcap_path);
+	if (rx_pcap_path[0] != '\0')
+		unlink(rx_pcap_path);
+	if (infinite_pcap_path[0] != '\0')
+		unlink(infinite_pcap_path);
+	if (timestamp_pcap_path[0] != '\0')
+		unlink(timestamp_pcap_path);
+	if (varied_pcap_path[0] != '\0')
+		unlink(varied_pcap_path);
+	if (jumbo_pcap_path[0] != '\0')
+		unlink(jumbo_pcap_path);
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++) {
+		if (multi_tx_pcap_paths[i][0] != '\0')
+			unlink(multi_tx_pcap_paths[i]);
+	}
+	if (multi_rx_pcap_path[0] != '\0')
+		unlink(multi_rx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_set_mtu),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+#endif
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, true, true, test_pmd_pcap);
-- 
2.51.0

[PATCH v4 00/11] PCAP PMD improvements

[Stephen Hemminger]

This series improves the PCAP PMD with new features, better code quality,
and a comprehensive test suite.

Changes:
  - Update feature matrix to reflect actual capabilities
  - Replace unnecessary rte_malloc/rte_memcpy with standard libc
  - Fix multi-segment transmit handling (was using 9KB stack buffer)
  - Add MTU setting support for single interface mode
  - Convert integer flags to bool for type safety
  - Add VLAN strip (RX) and insert (TX) offload support
  - Support nanosecond timestamp precision
  - Localize global variables where possible
  - Remove unnecessary volatile from statistics
  - Add comprehensive unit test suite (18 test cases)
  - Add release notes

The VLAN and timestamp offloads follow the same patterns used by
virtio and af_packet PMDs.

The test suite covers basic TX/RX, varied packet sizes, jumbo frames,
infinite RX mode, statistics, MTU configuration, timestamps, multi-queue
operation, and VLAN offloads.

v4:
  - Rebase on current main
  - Add VLAN strip
  - Add release note
  - better multi-segment handling

Stephen Hemminger (11):
  doc: update features for PCAP PMD
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: cleanup transmit of multi segment
  net/pcap: support setting MTU
  net/pcap: use bool for flags
  net/pcap: support VLAN offloads
  net/pcap: support nanosecond timestamp precision
  net/pcap: remove global variables
  net/pcap: avoid use of volatile
  test: add test for pcap PMD
  net/pcap: add release note

 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2263 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |   10 +
 doc/guides/rel_notes/release_26_03.rst |    7 +
 drivers/net/pcap/pcap_ethdev.c         |  376 ++--
 drivers/net/pcap/pcap_osdep.h          |    1 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   37 +-
 drivers/net/pcap/pcap_osdep_linux.c    |   21 +
 drivers/net/pcap/pcap_osdep_windows.c  |    6 +
 9 files changed, 2586 insertions(+), 137 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v4 01/11] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..060b2f4df5 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Rx Timestamp         = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v4 02/11] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_osdep_freebsd.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..32e4a2bee7 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -8,9 +8,6 @@
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +38,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
-- 
2.51.0

[PATCH v4 03/11] net/pcap: cleanup transmit of multi segment

[Stephen Hemminger]

The driver was not reporting multi segment in offload
flags but it can handle it.

The logic for handling transmit would allocate a worst case
size buffer on the stack which could be up to 9K.
If packet was transmitted larger than that it would get
truncated and log would get flooded.

Instead, allocate a buffer on stack only if necessary
and gracefully handle errors by incrementing transmit error
counter.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 110 +++++++++++++++++----------------
 1 file changed, 58 insertions(+), 52 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..22c9cb5928 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -22,7 +22,7 @@
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
+#define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
 #define RTE_ETH_PCAP_PROMISC 1
 #define RTE_ETH_PCAP_TIMEOUT -1
 
@@ -370,6 +370,22 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+/* Like rte_pktmbuf_read() but allocate if needed */
+static inline const void *
+pcap_pktmbuf_read(const struct rte_mbuf *m,
+		  uint32_t off, uint32_t len, void **buf)
+{
+	if (likely(off + len <= rte_pktmbuf_data_len(m))) {
+		return rte_pktmbuf_mtod_offset(m, char *, off);
+	} else {
+		*buf = malloc(len);
+		if (likely(*buf != NULL))
+			return rte_pktmbuf_read(m, off, len, *buf);
+		else
+			return NULL;
+	}
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -377,46 +393,43 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	pcap_dumper_t *dumper;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
-		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+		header.caplen = len;
+
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (unlikely(data == NULL)) {
+			++dumper_q->tx_stat.err_pkts;
+			continue;
+		}
+
+		pcap_dump((u_char *)dumper, &header, data);
 
 		num_tx++;
-		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
+		tx_bytes += len;
+		free(temp);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -444,15 +457,15 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(nb_pkts == 0))
 		return 0;
 
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -462,15 +475,11 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
@@ -479,35 +488,31 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
+
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (unlikely(data == NULL)) {
+			++tx_queue->tx_stat.err_pkts;
 			continue;
 		}
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
+		if (likely(pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
+		} else {
+			++tx_queue->tx_stat.err_pkts;
+		}
+
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
+	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -745,6 +750,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v4 04/11] net/pcap: support setting MTU

[Stephen Hemminger]

If PCAP PMD is used in single interface mode, it can pass
the MTU setup to the device. Only implemented on
Linux and FreeBSD.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini     |  1 +
 drivers/net/pcap/pcap_ethdev.c        | 14 ++++++++++++++
 drivers/net/pcap/pcap_osdep.h         |  1 +
 drivers/net/pcap/pcap_osdep_freebsd.c | 26 ++++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c   | 21 +++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_windows.c |  6 ++++++
 6 files changed, 69 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 060b2f4df5..e75bf03051 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -19,3 +19,4 @@ Power8               = Y
 x86-32               = Y
 x86-64               = Y
 Usage doc            = Y
+MTU update           = Y
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 22c9cb5928..0c65a2dffc 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -750,6 +750,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
@@ -1008,6 +1010,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+
+	if (internals->single_iface)
+		return osdep_iface_mtu_set(internals->if_index, mtu);
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1021,6 +1034,7 @@ static const struct eth_dev_ops ops = {
 	.rx_queue_stop = eth_rx_queue_stop,
 	.tx_queue_stop = eth_tx_queue_stop,
 	.link_update = eth_link_update,
+	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
 };
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..3c8b7ff27b 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -14,5 +14,6 @@ extern int eth_pcap_logtype;
 
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
+int osdep_iface_mtu_set(int index, uint16_t mtu);
 
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 32e4a2bee7..697b7029dd 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,9 +4,12 @@
  * All rights reserved.
  */
 
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
+#include <sys/ioctl.h>
+#include <sys/sockio.h>
 
 #include "pcap_osdep.h"
 
@@ -54,3 +57,26 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	struct ifreq ifr = { 0 };
+	char ifname[IFNAMSIZ];
+	int s, ret;
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	s = socket(AF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_mtu = mtu;
+
+	ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..d180e9b4b4 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -40,3 +40,24 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+int
+osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	char ifname[IFNAMSIZ];
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	int s = socket(PF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	struct ifreq ifr = { .ifr_mtu = mtu };
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	int ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..00df67b8fc 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -116,3 +116,9 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_mtu_set(int index __rte_unused, uint16_t mtu __rte_unused)
+{
+	return -ENOTSUP;
+}
-- 
2.51.0

[PATCH v4 05/11] net/pcap: use bool for flags

[Stephen Hemminger]

Save some space by using bool for flag values.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 67 +++++++++++++++-------------------
 1 file changed, 29 insertions(+), 38 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 0c65a2dffc..62f073e214 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -5,6 +5,7 @@
  */
 
 #include <stdlib.h>
+#include <stdbool.h>
 #include <time.h>
 
 #include <pcap.h>
@@ -91,9 +92,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -103,25 +104,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -871,7 +872,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1192,29 +1193,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1491,7 +1482,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1530,9 +1521,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
-- 
2.51.0

[PATCH v4 06/11] net/pcap: support VLAN offloads

[Stephen Hemminger]

Driver can easily insert VLAN tag strip and insertion similar
to how it is handled in virtio and af_packet.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini |  1 +
 drivers/net/pcap/pcap_ethdev.c    | 33 ++++++++++++++++++++++++++++---
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index e75bf03051..7a1420a2eb 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Rx Timestamp         = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 62f073e214..19d4ed94e1 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -68,6 +68,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -95,6 +96,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -325,6 +327,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -414,6 +420,13 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		void *temp = NULL;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			if (unlikely(rte_vlan_insert(&mbuf) != 0)) {
+				++dumper_q->tx_stat.err_pkts;
+				continue;
+			}
+		}
+
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
@@ -494,6 +507,13 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		void *temp = NULL;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			if (unlikely(rte_vlan_insert(&mbuf) != 0)) {
+				++tx_queue->tx_stat.err_pkts;
+				continue;
+			}
+		}
+
 		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
 		if (unlikely(data == NULL)) {
 			++tx_queue->tx_stat.err_pkts;
@@ -506,7 +526,6 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		} else {
 			++tx_queue->tx_stat.err_pkts;
 		}
-
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
@@ -734,8 +753,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -753,7 +777,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -900,6 +926,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
-- 
2.51.0

[PATCH v4 07/11] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Consistently support nanosecond timestamps across all the
variations of pcap PMD receive.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini |   1 +
 drivers/net/pcap/pcap_ethdev.c    | 136 +++++++++++++++++++++++-------
 2 files changed, 107 insertions(+), 30 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7a1420a2eb..24161cb33f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -11,6 +11,7 @@ Rx Timestamp         = Y
 Basic stats          = Y
 Stats per queue      = Y
 VLAN offload         = Y
+Timestamp offload    = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 19d4ed94e1..7e2a69f137 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -19,13 +19,13 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
+#include <rte_reciprocal.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
 #define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -44,6 +44,7 @@ static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
+static struct rte_reciprocal_u64 hz_inv;
 static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
@@ -69,6 +70,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -97,6 +99,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -331,10 +334,19 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * Although time stamp in struct pcap_pkthdr is defined as struct timeval,
+			 * it really is a timespec with nanosecond resolution.
+			 */
+			const struct timespec *ts = (struct timespec *)&header->ts;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(ts);
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -354,20 +366,21 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
  * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
  * because `ts` goes directly to nanosecond-precision dump.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
 	cycles = rte_get_timer_cycles() - start_cycles;
-	cur_time.tv_sec = cycles / hz;
-	cur_time.tv_nsec = (cycles % hz) * NSEC_PER_SEC / hz;
+	cur_time.tv_sec = rte_reciprocal_divide_u64(cycles, &hz_inv);
+	/* compute remainder */
+	cycles -= cur_time.tv_sec * hz;
+	cur_time.tv_nsec = rte_reciprocal_divide_u64(cycles * NS_PER_S, &hz_inv);
 
 	ts->tv_sec = start_time.tv_sec + cur_time.tv_sec;
 	ts->tv_usec = start_time.tv_nsec + cur_time.tv_nsec;
@@ -413,6 +426,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
@@ -427,7 +443,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			}
 		}
 
-		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
 
@@ -539,22 +554,60 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
+
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -601,7 +654,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -638,6 +692,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
 
+	if (internals->timestamp_offloading) {
+		int ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							     &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+	}
+
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
@@ -760,6 +823,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -779,7 +843,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -928,6 +993,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1049,6 +1115,17 @@ eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in UTC */
+static int
+eth_rx_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1065,6 +1142,7 @@ static const struct eth_dev_ops ops = {
 	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.read_clock = eth_rx_clock,
 };
 
 static int
@@ -1465,15 +1543,13 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		hz = rte_get_timer_hz();
+		hz_inv = rte_reciprocal_value_u64(hz);
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v4 08/11] net/pcap: remove global variables

[Stephen Hemminger]

Localize variables where possible.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 7e2a69f137..9d4408a845 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -40,12 +40,10 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
 static struct rte_reciprocal_u64 hz_inv;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -556,6 +554,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -654,6 +653,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1358,6 +1359,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v4 09/11] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 9d4408a845..9da79378f5 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -49,10 +49,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -855,11 +855,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v4 10/11] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, vlan handling and multiple queues

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build     |    2 +
 app/test/test_pmd_pcap.c | 2263 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 2265 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index efec42a6bf..6c0bf7068d 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..4883d03354
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,2263 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * This test needs OS network interfaces and
+ * managing that would require more changes on Windows.
+ */
+static int
+test_pmd_pcap(void)
+{
+	printf("PCAP test not supported on Windows, skipping test\n");
+	return TEST_SKIPPED;
+}
+
+#else
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+/*
+ * Helper: Create a unique temporary file path
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u with VLAN strip: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		rte_memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+			   test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		rte_memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+			   test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if network interface exists
+ */
+static int
+iface_exists(const char *name)
+{
+	struct ifreq ifr;
+	int sock, ret;
+
+	sock = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sock < 0)
+		return 0;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, name, IFNAMSIZ);
+	ret = ioctl(sock, SIOCGIFINDEX, &ifr);
+	close(sock);
+	return ret == 0;
+}
+
+/*
+ * Helper: Find a usable test interface
+ */
+static const char *
+find_test_iface(void)
+{
+	if (iface_exists("dummy0"))
+		return "dummy0";
+	if (iface_exists("lo"))
+		return "lo";
+	return NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	unlink(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	unlink(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: MTU configuration
+ */
+static int
+test_set_mtu(void)
+{
+	char devargs[256];
+	char mtu_tx_path[PATH_MAX];
+	uint16_t port_id;
+	static const uint16_t mtu_values[] = {1500, 9000, 1280};
+	int ret = 0;
+	size_t i;
+
+	printf("Testing MTU configuration\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_mtu_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(mtu_tx_path, sizeof(mtu_tx_path),
+				     "pcap_mtu_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, mtu_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_mtu", devargs, &port_id) == 0,
+		    "Failed to create MTU vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup MTU port");
+
+	for (i = 0; i < RTE_DIM(mtu_values); i++) {
+		uint16_t mtu;
+
+		ret = rte_eth_dev_set_mtu(port_id, mtu_values[i]);
+		if (ret != 0)
+			break;
+
+		TEST_ASSERT(rte_eth_dev_get_mtu(port_id, &mtu) == 0, "Failed to get MTU");
+		TEST_ASSERT_EQUAL(mtu, mtu_values[i], "MTU set mismatch for %u", mtu_values[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_mtu", port_id);
+	unlink(mtu_tx_path);
+
+	if (ret == 0) {
+		printf("MTU test completed\n");
+		return TEST_SUCCESS;
+	}
+
+	if (ret == -ENOTSUP) {
+		printf("MTU set not supported\n");
+		return TEST_SKIPPED;
+	}
+
+	printf("Failed to set MTU: %s", strerror(-ret));
+	return TEST_FAILED;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count, ret;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Set MTU to allow jumbo frames - PMD drops packets exceeding MTU */
+	ret = rte_eth_dev_set_mtu(port_id, PKT_SIZE_JUMBO);
+	if (ret != 0) {
+		printf("Failed to set MTU to %u: %s\n",
+		       PKT_SIZE_JUMBO, rte_strerror(-ret));
+		cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+		unlink(tx_path);
+		return TEST_SKIPPED;
+	}
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			unlink(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	unlink(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. min_mtu and max_mtu are set to reasonable values
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    min_mtu: %u\n", dev_info.min_mtu);
+	printf("    max_mtu: %u\n", dev_info.max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify MTU limits are reasonable */
+	TEST_ASSERT(dev_info.min_mtu > 0, "min_mtu should be > 0, got %u", dev_info.min_mtu);
+	TEST_ASSERT(dev_info.min_mtu <= RTE_ETHER_MIN_MTU,
+		    "min_mtu should be <= %u, got %u", RTE_ETHER_MIN_MTU, dev_info.min_mtu);
+	TEST_ASSERT(dev_info.max_mtu <= RTE_ETHER_MAX_JUMBO_FRAME_LEN,
+		    "max_mtu should be <= %u, got %u",
+		    RTE_ETHER_MAX_JUMBO_FRAME_LEN, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		unlink(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		unlink(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	if (tx_pcap_path[0] != '\0')
+		unlink(tx_pcap_path);
+	if (rx_pcap_path[0] != '\0')
+		unlink(rx_pcap_path);
+	if (infinite_pcap_path[0] != '\0')
+		unlink(infinite_pcap_path);
+	if (timestamp_pcap_path[0] != '\0')
+		unlink(timestamp_pcap_path);
+	if (varied_pcap_path[0] != '\0')
+		unlink(varied_pcap_path);
+	if (jumbo_pcap_path[0] != '\0')
+		unlink(jumbo_pcap_path);
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++) {
+		if (multi_tx_pcap_paths[i][0] != '\0')
+			unlink(multi_tx_pcap_paths[i]);
+	}
+	if (multi_rx_pcap_path[0] != '\0')
+		unlink(multi_rx_pcap_path);
+	if (vlan_rx_pcap_path[0] != '\0')
+		unlink(vlan_rx_pcap_path);
+	if (vlan_tx_pcap_path[0] != '\0')
+		unlink(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_set_mtu),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+#endif
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
-- 
2.51.0

[PATCH v4 11/11] net/pcap: add release note

[Stephen Hemminger]

Add a release note describing the new feature
and offload changes.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 15dabee7a1..5550f17416 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -55,6 +55,13 @@ New Features
      Also, make sure to start the actual text at the margin.
      =======================================================
 
+* **Updated PCAP driver.**
+
+   * Added support for setting MTU in single interface mode.
+   * Made receive timestamp offload optional.
+   * Supports VLAN insertion and stripping.
+   * Added unit test suite.
+
 
 Removed Items
 -------------
-- 
2.51.0

[PATCH v5 00/11] PCAP PMD improvements

[Stephen Hemminger]

This series improves the PCAP PMD with new features, better code quality,
and a comprehensive test suite.

Changes:
  - Update feature matrix to reflect actual capabilities
  - Replace unnecessary rte_malloc/rte_memcpy with standard libc
  - Fix multi-segment transmit handling (was using 9KB stack buffer)
  - Add MTU setting support for single interface mode
  - Convert integer flags to bool for type safety
  - Add VLAN strip (RX) and insert (TX) offload support
  - Support nanosecond timestamp precision
  - Localize global variables where possible
  - Remove unnecessary volatile from statistics
  - Add comprehensive unit test suite (18 test cases)
  - Add release notes

The VLAN and timestamp offloads follow the same patterns used by
virtio and af_packet PMDs.

The test suite covers basic TX/RX, varied packet sizes, jumbo frames,
infinite RX mode, statistics, MTU configuration, timestamps, multi-queue
operation, and VLAN offloads.

v5 - fix typo in features table
   - resolve minor checkpatch complaint

Stephen Hemminger (11):
  doc: update features for PCAP PMD
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: cleanup transmit of multi segment
  net/pcap: support setting MTU
  net/pcap: use bool for flags
  net/pcap: support VLAN offloads
  net/pcap: support nanosecond timestamp precision
  net/pcap: remove global variables
  net/pcap: avoid use of volatile
  test: add test for pcap PMD
  net/pcap: add release note

 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2263 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    9 +
 doc/guides/rel_notes/release_26_03.rst |    7 +
 drivers/net/pcap/pcap_ethdev.c         |  375 ++--
 drivers/net/pcap/pcap_osdep.h          |    1 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   37 +-
 drivers/net/pcap/pcap_osdep_linux.c    |   21 +
 drivers/net/pcap/pcap_osdep_windows.c  |    6 +
 9 files changed, 2584 insertions(+), 137 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v5 01/11] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v5 02/11] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_osdep_freebsd.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..32e4a2bee7 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -8,9 +8,6 @@
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +38,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
-- 
2.51.0

[PATCH v5 03/11] net/pcap: cleanup transmit of multi segment

[Stephen Hemminger]

The driver was not reporting multi segment in offload
flags but it can handle it.

The logic for handling transmit would allocate a worst case
size buffer on the stack which could be up to 9K.
If packet was transmitted larger than that it would get
truncated and log would get flooded.

Instead, allocate a buffer on stack only if necessary
and gracefully handle errors by incrementing transmit error
counter.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 109 +++++++++++++++++----------------
 1 file changed, 57 insertions(+), 52 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..e86aaf8bbc 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -22,7 +22,7 @@
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
+#define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
 #define RTE_ETH_PCAP_PROMISC 1
 #define RTE_ETH_PCAP_TIMEOUT -1
 
@@ -370,6 +370,21 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+/* Like rte_pktmbuf_read() but allocate if needed */
+static inline const void *
+pcap_pktmbuf_read(const struct rte_mbuf *m,
+		  uint32_t off, uint32_t len, void **buf)
+{
+	if (likely(off + len <= rte_pktmbuf_data_len(m)))
+		return rte_pktmbuf_mtod_offset(m, char *, off);
+
+	*buf = malloc(len);
+	if (likely(*buf != NULL))
+		return rte_pktmbuf_read(m, off, len, *buf);
+	else
+		return NULL;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -377,46 +392,43 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	pcap_dumper_t *dumper;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
-		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+		header.caplen = len;
+
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (unlikely(data == NULL)) {
+			++dumper_q->tx_stat.err_pkts;
+			continue;
+		}
+
+		pcap_dump((u_char *)dumper, &header, data);
 
 		num_tx++;
-		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
+		tx_bytes += len;
+		free(temp);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -444,15 +456,15 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(nb_pkts == 0))
 		return 0;
 
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -462,15 +474,11 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
@@ -479,35 +487,31 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
+
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (unlikely(data == NULL)) {
+			++tx_queue->tx_stat.err_pkts;
 			continue;
 		}
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
+		if (likely(pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
+		} else {
+			++tx_queue->tx_stat.err_pkts;
+		}
+
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
+	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -745,6 +749,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v5 04/11] net/pcap: support setting MTU

[Stephen Hemminger]

If PCAP PMD is used in single interface mode, it can pass
the MTU setup to the device. Only implemented on
Linux and FreeBSD.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini     |  1 +
 drivers/net/pcap/pcap_ethdev.c        | 14 ++++++++++++++
 drivers/net/pcap/pcap_osdep.h         |  1 +
 drivers/net/pcap/pcap_osdep_freebsd.c | 26 ++++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c   | 21 +++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_windows.c |  6 ++++++
 6 files changed, 69 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..d2f5ee6039 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -19,3 +19,4 @@ Power8               = Y
 x86-32               = Y
 x86-64               = Y
 Usage doc            = Y
+MTU update           = Y
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index e86aaf8bbc..5683c44892 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -749,6 +749,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
@@ -1007,6 +1009,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+
+	if (internals->single_iface)
+		return osdep_iface_mtu_set(internals->if_index, mtu);
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1020,6 +1033,7 @@ static const struct eth_dev_ops ops = {
 	.rx_queue_stop = eth_rx_queue_stop,
 	.tx_queue_stop = eth_tx_queue_stop,
 	.link_update = eth_link_update,
+	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
 };
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..3c8b7ff27b 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -14,5 +14,6 @@ extern int eth_pcap_logtype;
 
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
+int osdep_iface_mtu_set(int index, uint16_t mtu);
 
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 32e4a2bee7..697b7029dd 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,9 +4,12 @@
  * All rights reserved.
  */
 
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
+#include <sys/ioctl.h>
+#include <sys/sockio.h>
 
 #include "pcap_osdep.h"
 
@@ -54,3 +57,26 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	struct ifreq ifr = { 0 };
+	char ifname[IFNAMSIZ];
+	int s, ret;
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	s = socket(AF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+	ifr.ifr_mtu = mtu;
+
+	ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..d180e9b4b4 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -40,3 +40,24 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+int
+osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	char ifname[IFNAMSIZ];
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	int s = socket(PF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	struct ifreq ifr = { .ifr_mtu = mtu };
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	int ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..00df67b8fc 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -116,3 +116,9 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_mtu_set(int index __rte_unused, uint16_t mtu __rte_unused)
+{
+	return -ENOTSUP;
+}
-- 
2.51.0

[PATCH v5 05/11] net/pcap: use bool for flags

[Stephen Hemminger]

Save some space by using bool for flag values.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 67 +++++++++++++++-------------------
 1 file changed, 29 insertions(+), 38 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 5683c44892..1b3a86cb50 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -5,6 +5,7 @@
  */
 
 #include <stdlib.h>
+#include <stdbool.h>
 #include <time.h>
 
 #include <pcap.h>
@@ -91,9 +92,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -103,25 +104,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -870,7 +871,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1191,29 +1192,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1490,7 +1481,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1529,9 +1520,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
-- 
2.51.0

[PATCH v5 06/11] net/pcap: support VLAN offloads

[Stephen Hemminger]

Driver can easily insert VLAN tag strip and insertion similar
to how it is handled in virtio and af_packet.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini |  1 +
 drivers/net/pcap/pcap_ethdev.c    | 33 ++++++++++++++++++++++++++++---
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index d2f5ee6039..7043213c5f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 1b3a86cb50..0018e03c06 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -68,6 +68,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -95,6 +96,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -325,6 +327,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -413,6 +419,13 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		void *temp = NULL;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			if (unlikely(rte_vlan_insert(&mbuf) != 0)) {
+				++dumper_q->tx_stat.err_pkts;
+				continue;
+			}
+		}
+
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
@@ -493,6 +506,13 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		void *temp = NULL;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			if (unlikely(rte_vlan_insert(&mbuf) != 0)) {
+				++tx_queue->tx_stat.err_pkts;
+				continue;
+			}
+		}
+
 		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
 		if (unlikely(data == NULL)) {
 			++tx_queue->tx_stat.err_pkts;
@@ -505,7 +525,6 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		} else {
 			++tx_queue->tx_stat.err_pkts;
 		}
-
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
@@ -733,8 +752,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -752,7 +776,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -899,6 +925,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
-- 
2.51.0

[PATCH v5 07/11] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Consistently support nanosecond timestamps across all the
variations of pcap PMD receive.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 136 +++++++++++++++++++++++++--------
 1 file changed, 106 insertions(+), 30 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 0018e03c06..76bb546673 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -19,13 +19,13 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
+#include <rte_reciprocal.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
 #define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -44,6 +44,7 @@ static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
+static struct rte_reciprocal_u64 hz_inv;
 static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
@@ -69,6 +70,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -97,6 +99,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -331,10 +334,19 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * Although time stamp in struct pcap_pkthdr is defined as struct timeval,
+			 * it really is a timespec with nanosecond resolution.
+			 */
+			const struct timespec *ts = (struct timespec *)&header->ts;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(ts);
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -354,20 +366,21 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
  * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
  * because `ts` goes directly to nanosecond-precision dump.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
 	cycles = rte_get_timer_cycles() - start_cycles;
-	cur_time.tv_sec = cycles / hz;
-	cur_time.tv_nsec = (cycles % hz) * NSEC_PER_SEC / hz;
+	cur_time.tv_sec = rte_reciprocal_divide_u64(cycles, &hz_inv);
+	/* compute remainder */
+	cycles -= cur_time.tv_sec * hz;
+	cur_time.tv_nsec = rte_reciprocal_divide_u64(cycles * NS_PER_S, &hz_inv);
 
 	ts->tv_sec = start_time.tv_sec + cur_time.tv_sec;
 	ts->tv_usec = start_time.tv_nsec + cur_time.tv_nsec;
@@ -412,6 +425,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
@@ -426,7 +442,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			}
 		}
 
-		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
 
@@ -538,22 +553,60 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
+
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -600,7 +653,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -637,6 +691,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
 
+	if (internals->timestamp_offloading) {
+		int ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							     &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+	}
+
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
@@ -759,6 +822,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -778,7 +842,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -927,6 +992,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1048,6 +1114,17 @@ eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in UTC */
+static int
+eth_rx_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1064,6 +1141,7 @@ static const struct eth_dev_ops ops = {
 	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.read_clock = eth_rx_clock,
 };
 
 static int
@@ -1464,15 +1542,13 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		hz = rte_get_timer_hz();
+		hz_inv = rte_reciprocal_value_u64(hz);
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v5 08/11] net/pcap: remove global variables

[Stephen Hemminger]

Localize variables where possible.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 76bb546673..bc31b526a4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -40,12 +40,10 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
 static struct rte_reciprocal_u64 hz_inv;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -555,6 +553,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -653,6 +652,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1357,6 +1358,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v5 09/11] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index bc31b526a4..2a06efd0e4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -49,10 +49,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -854,11 +854,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v5 10/11] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, vlan handling and multiple queues

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build     |    2 +
 app/test/test_pmd_pcap.c | 2263 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 2265 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index efec42a6bf..6c0bf7068d 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..4883d03354
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,2263 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * This test needs OS network interfaces and
+ * managing that would require more changes on Windows.
+ */
+static int
+test_pmd_pcap(void)
+{
+	printf("PCAP test not supported on Windows, skipping test\n");
+	return TEST_SKIPPED;
+}
+
+#else
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+/*
+ * Helper: Create a unique temporary file path
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u with VLAN strip: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		rte_memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+			   test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		rte_memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+			   test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if network interface exists
+ */
+static int
+iface_exists(const char *name)
+{
+	struct ifreq ifr;
+	int sock, ret;
+
+	sock = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sock < 0)
+		return 0;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, name, IFNAMSIZ);
+	ret = ioctl(sock, SIOCGIFINDEX, &ifr);
+	close(sock);
+	return ret == 0;
+}
+
+/*
+ * Helper: Find a usable test interface
+ */
+static const char *
+find_test_iface(void)
+{
+	if (iface_exists("dummy0"))
+		return "dummy0";
+	if (iface_exists("lo"))
+		return "lo";
+	return NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	unlink(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	unlink(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: MTU configuration
+ */
+static int
+test_set_mtu(void)
+{
+	char devargs[256];
+	char mtu_tx_path[PATH_MAX];
+	uint16_t port_id;
+	static const uint16_t mtu_values[] = {1500, 9000, 1280};
+	int ret = 0;
+	size_t i;
+
+	printf("Testing MTU configuration\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_mtu_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(mtu_tx_path, sizeof(mtu_tx_path),
+				     "pcap_mtu_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, mtu_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_mtu", devargs, &port_id) == 0,
+		    "Failed to create MTU vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup MTU port");
+
+	for (i = 0; i < RTE_DIM(mtu_values); i++) {
+		uint16_t mtu;
+
+		ret = rte_eth_dev_set_mtu(port_id, mtu_values[i]);
+		if (ret != 0)
+			break;
+
+		TEST_ASSERT(rte_eth_dev_get_mtu(port_id, &mtu) == 0, "Failed to get MTU");
+		TEST_ASSERT_EQUAL(mtu, mtu_values[i], "MTU set mismatch for %u", mtu_values[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_mtu", port_id);
+	unlink(mtu_tx_path);
+
+	if (ret == 0) {
+		printf("MTU test completed\n");
+		return TEST_SUCCESS;
+	}
+
+	if (ret == -ENOTSUP) {
+		printf("MTU set not supported\n");
+		return TEST_SKIPPED;
+	}
+
+	printf("Failed to set MTU: %s", strerror(-ret));
+	return TEST_FAILED;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count, ret;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Set MTU to allow jumbo frames - PMD drops packets exceeding MTU */
+	ret = rte_eth_dev_set_mtu(port_id, PKT_SIZE_JUMBO);
+	if (ret != 0) {
+		printf("Failed to set MTU to %u: %s\n",
+		       PKT_SIZE_JUMBO, rte_strerror(-ret));
+		cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+		unlink(tx_path);
+		return TEST_SKIPPED;
+	}
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			unlink(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	unlink(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. min_mtu and max_mtu are set to reasonable values
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    min_mtu: %u\n", dev_info.min_mtu);
+	printf("    max_mtu: %u\n", dev_info.max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify MTU limits are reasonable */
+	TEST_ASSERT(dev_info.min_mtu > 0, "min_mtu should be > 0, got %u", dev_info.min_mtu);
+	TEST_ASSERT(dev_info.min_mtu <= RTE_ETHER_MIN_MTU,
+		    "min_mtu should be <= %u, got %u", RTE_ETHER_MIN_MTU, dev_info.min_mtu);
+	TEST_ASSERT(dev_info.max_mtu <= RTE_ETHER_MAX_JUMBO_FRAME_LEN,
+		    "max_mtu should be <= %u, got %u",
+		    RTE_ETHER_MAX_JUMBO_FRAME_LEN, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		unlink(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		unlink(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	if (tx_pcap_path[0] != '\0')
+		unlink(tx_pcap_path);
+	if (rx_pcap_path[0] != '\0')
+		unlink(rx_pcap_path);
+	if (infinite_pcap_path[0] != '\0')
+		unlink(infinite_pcap_path);
+	if (timestamp_pcap_path[0] != '\0')
+		unlink(timestamp_pcap_path);
+	if (varied_pcap_path[0] != '\0')
+		unlink(varied_pcap_path);
+	if (jumbo_pcap_path[0] != '\0')
+		unlink(jumbo_pcap_path);
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++) {
+		if (multi_tx_pcap_paths[i][0] != '\0')
+			unlink(multi_tx_pcap_paths[i]);
+	}
+	if (multi_rx_pcap_path[0] != '\0')
+		unlink(multi_rx_pcap_path);
+	if (vlan_rx_pcap_path[0] != '\0')
+		unlink(vlan_rx_pcap_path);
+	if (vlan_tx_pcap_path[0] != '\0')
+		unlink(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_set_mtu),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+#endif
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
-- 
2.51.0

[PATCH v5 11/11] net/pcap: add release note

[Stephen Hemminger]

Add a release note describing the new feature
and offload changes.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 15dabee7a1..5550f17416 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -55,6 +55,13 @@ New Features
      Also, make sure to start the actual text at the margin.
      =======================================================
 
+* **Updated PCAP driver.**
+
+   * Added support for setting MTU in single interface mode.
+   * Made receive timestamp offload optional.
+   * Supports VLAN insertion and stripping.
+   * Added unit test suite.
+
 
 Removed Items
 -------------
-- 
2.51.0

RE: [PATCH v4 05/11] net/pcap: use bool for flags

[Marat Khalili]

> -----Original Message-----
> From: Stephen Hemminger <stephen@networkplumber.org>
> Sent: Saturday 17 January 2026 21:57
> To: dev@dpdk.org
> Cc: Stephen Hemminger <stephen@networkplumber.org>
> Subject: [PATCH v4 05/11] net/pcap: use bool for flags
> 
> Save some space by using bool for flag values.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
>  drivers/net/pcap/pcap_ethdev.c | 67 +++++++++++++++-------------------
>  1 file changed, 29 insertions(+), 38 deletions(-)
> 
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index 0c65a2dffc..62f073e214 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -5,6 +5,7 @@
>   */
> 
>  #include <stdlib.h>
> +#include <stdbool.h>
>  #include <time.h>
> 
>  #include <pcap.h>
> @@ -91,9 +92,9 @@ struct pmd_internals {
>  	char devargs[ETH_PCAP_ARG_MAXLEN];
>  	struct rte_ether_addr eth_addr;
>  	int if_index;
> -	int single_iface;
> -	int phy_mac;
> -	unsigned int infinite_rx;
> +	bool single_iface;
> +	bool phy_mac;
> +	bool infinite_rx;
>  };
> 
>  struct pmd_process_private {
> @@ -103,25 +104,25 @@ struct pmd_process_private {
>  };
> 
>  struct pmd_devargs {
> -	unsigned int num_of_queue;
> +	uint16_t num_of_queue;
> +	bool phy_mac;
>  	struct devargs_queue {
>  		pcap_dumper_t *dumper;
>  		pcap_t *pcap;
>  		const char *name;
>  		const char *type;
>  	} queue[RTE_PMD_PCAP_MAX_QUEUES];
> -	int phy_mac;
>  };
> 
>  struct pmd_devargs_all {
>  	struct pmd_devargs rx_queues;
>  	struct pmd_devargs tx_queues;
> -	int single_iface;
> -	unsigned int is_tx_pcap;
> -	unsigned int is_tx_iface;
> -	unsigned int is_rx_pcap;
> -	unsigned int is_rx_iface;
> -	unsigned int infinite_rx;
> +	bool single_iface;
> +	bool is_tx_pcap;
> +	bool is_tx_iface;
> +	bool is_rx_pcap;
> +	bool is_rx_iface;
> +	bool infinite_rx;
>  };
> 
>  static const char *valid_arguments[] = {
> @@ -871,7 +872,7 @@ eth_dev_close(struct rte_eth_dev *dev)
>  		}
>  	}
> 
> -	if (internals->phy_mac == 0)
> +	if (!internals->phy_mac)
>  		/* not dynamically allocated, must not be freed */
>  		dev->data->mac_addrs = NULL;
> 
> @@ -1192,29 +1193,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
>  }
> 
>  static int
> -select_phy_mac(const char *key __rte_unused, const char *value,
> -		void *extra_args)
> +process_bool_flag(const char *key, const char *value, void *extra_args)
>  {
> -	if (extra_args) {
> -		const int phy_mac = atoi(value);
> -		int *enable_phy_mac = extra_args;
> -
> -		if (phy_mac)
> -			*enable_phy_mac = 1;
> -	}
> -	return 0;
> -}
> -
> -static int
> -get_infinite_rx_arg(const char *key __rte_unused,
> -		const char *value, void *extra_args)
> -{
> -	if (extra_args) {
> -		const int infinite_rx = atoi(value);
> -		int *enable_infinite_rx = extra_args;
> -
> -		if (infinite_rx > 0)
> -			*enable_infinite_rx = 1;
> +	bool *flag = extra_args;
> +
> +	if (value == NULL || *value == '\0') {
> +		*flag = true; /* default with no additional argument */
> +	} else if (strcmp(value, "0") == 0) {
> +		*flag = false;
> +	} else if (strcmp(value, "1") == 0) {
> +		*flag = true;
> +	} else {
> +		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
> +		return -1;
>  	}
>  	return 0;
>  }
> @@ -1491,7 +1482,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
>  		dumpers.queue[0] = pcaps.queue[0];
> 
>  		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
> -				&select_phy_mac, &pcaps.phy_mac);
> +					 &process_bool_flag, &pcaps.phy_mac);

Nit: there seems to be one unnecessary space and unnecessary 
indentation change in the above and some other lines.

>  		if (ret < 0)
>  			goto free_kvlist;
> 
> @@ -1530,9 +1521,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
> 
>  		if (infinite_rx_arg_cnt == 1) {
>  			ret = rte_kvargs_process(kvlist,
> -					ETH_PCAP_INFINITE_RX_ARG,
> -					&get_infinite_rx_arg,
> -					&devargs_all.infinite_rx);
> +						 ETH_PCAP_INFINITE_RX_ARG,
> +						 &process_bool_flag,
> +						 &devargs_all.infinite_rx);
>  			if (ret < 0)
>  				goto free_kvlist;
>  			PMD_LOG(INFO, "infinite_rx has been %s for %s",
> --
> 2.51.0

Regardless of spacing issues,

Acked-by: Marat Khalili <marat.khalili@huawei.com>

[PATCH v6 00/13] net/pcap: improvements and new features

[Stephen Hemminger]

This series modernizes the PCAP PMD with bug fixes, code cleanup,
and new features.

**New features:**
- VLAN insert and strip offload support
- Nanosecond timestamp precision (using pcap_create/pcap_activate API)
- MTU configuration in single interface mode
- Advertise multi-segment TX capability

**Bug fixes:**
- Transmit now always consumes all packets, counting failures as errors
  rather than returning early (matches other PMD behavior)
- Remove silent truncation of oversized multi-segment packets
- Replace large stack buffers with dynamic allocation

**Code cleanup:**
- Add explicit header includes
- Remove unnecessary casts and rte_malloc/rte_memcpy usage
- Consolidate boolean flag parsing with input validation
- Reduce scope of file-level variables
- Replace volatile with proper atomics

**Other:**
- Update feature matrix documentation
- Add comprehensive unit test suite
- Take on maintainership

v6:
- Add maintainers patch
- Add patches for explicit header includes and removing unnecessary casts
- Fold release notes into individual patches
- Improve commit message subjects for clarity

---

Stephen Hemminger (13):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: improve multi-segment transmit handling
  net/pcap: support MTU configuration in single interface mode
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN insert and strip
  net/pcap: support nanosecond timestamp precision
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  test: add test for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2263 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    9 +
 doc/guides/rel_notes/release_26_03.rst |   10 +
 drivers/net/pcap/pcap_ethdev.c         |  383 ++--
 drivers/net/pcap/pcap_osdep.h          |    2 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   36 +-
 drivers/net/pcap/pcap_osdep_linux.c    |   28 +-
 drivers/net/pcap/pcap_osdep_windows.c  |    6 +
 10 files changed, 2591 insertions(+), 149 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v6 01/13] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 3e90cb8c28..62da2be759 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap_ring.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v6 02/13] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v6 03/13] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 8 ++++++++
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..d09ba5abe9 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,24 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v6 04/13] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index d09ba5abe9..0177cbc7df 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1221,9 +1221,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1591,10 +1590,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v6 05/13] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  2 +-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 0177cbc7df..2e41ad35ed 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1289,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v6 06/13] net/pcap: improve multi-segment transmit handling

[Stephen Hemminger]

Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability in device info. The
driver already handles multi-segment mbufs but was not reporting this.

Replace the fixed-size stack buffer (up to 9K) with dynamic allocation
only when the mbuf is non-contiguous. This avoids large stack usage and
removes the silent truncation that occurred when packets exceeded the
buffer size.

Change transmit functions to always consume and free all packets,
returning nb_pkts regardless of send success. The DPDK transmit API
interprets a return value less than requested as "queue full, retry
later." However, pcap_sendpacket() failures (bad parameters or socket
errors) are not transient and retrying would fail again. The correct
behavior is to free failed packets and increment the error counter
rather than leaving mbufs for the application to retry.

Also use rte_pktmbuf_free_bulk() for more efficient buffer freeing.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   5 ++
 drivers/net/pcap/pcap_ethdev.c         | 106 ++++++++++++-------------
 2 files changed, 56 insertions(+), 55 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 15dabee7a1..76d81ac524 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -55,6 +55,11 @@ New Features
      Also, make sure to start the actual text at the margin.
      =======================================================
 
+* **Updated PCAP ethernet driver.**
+
+  * Changed transmit burst to always return the number of packets requested.
+    Failed sends are counted as transmit errors.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2e41ad35ed..537d66ed30 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -30,7 +30,7 @@
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
+#define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
 #define RTE_ETH_PCAP_PROMISC 1
 #define RTE_ETH_PCAP_TIMEOUT -1
 
@@ -378,6 +378,21 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+/* Like rte_pktmbuf_read() but allocate if needed */
+static inline const void *
+pcap_pktmbuf_read(const struct rte_mbuf *m,
+		  uint32_t off, uint32_t len, void **buf)
+{
+	if (likely(off + len <= rte_pktmbuf_data_len(m)))
+		return rte_pktmbuf_mtod_offset(m, char *, off);
+
+	*buf = malloc(len);
+	if (likely(*buf != NULL))
+		return rte_pktmbuf_read(m, off, len, *buf);
+	else
+		return NULL;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -385,46 +400,40 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	pcap_dumper_t *dumper;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
-		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+		header.caplen = len;
 
-		num_tx++;
-		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (likely(data != NULL)) {
+			pcap_dump((u_char *)dumper, &header, data);
+
+			num_tx++;
+			tx_bytes += len;
+		}
+		free(temp);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -452,15 +461,15 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(nb_pkts == 0))
 		return 0;
 
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -470,15 +479,11 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
@@ -487,35 +492,25 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
-			continue;
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
+
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (likely(data != NULL &&
+		    pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
 		}
-
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
+	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -753,6 +748,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v6 07/13] net/pcap: support MTU configuration in single interface mode

[Stephen Hemminger]

Implement the mtu_set dev_op to allow MTU changes when the pcap PMD is
attached to a real network interface (single interface mode).
The MTU change is passed through to the underlying device via ioctl.

This is supported on Linux and FreeBSD. On Windows, the operation
returns -ENOTSUP (for now).

Also report min_mtu and max_mtu in device info.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 14 ++++++++++++++
 drivers/net/pcap/pcap_osdep.h          |  1 +
 drivers/net/pcap/pcap_osdep_freebsd.c  | 24 ++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 22 ++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  |  6 ++++++
 7 files changed, 69 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..d2f5ee6039 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -19,3 +19,4 @@ Power8               = Y
 x86-32               = Y
 x86-64               = Y
 Usage doc            = Y
+MTU update           = Y
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 76d81ac524..41f96ad1af 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -57,6 +57,7 @@ New Features
 
 * **Updated PCAP ethernet driver.**
 
+  * Added support for setting MTU in single interface mode.
   * Changed transmit burst to always return the number of packets requested.
     Failed sends are counted as transmit errors.
 
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 537d66ed30..54f71fa17f 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -748,6 +748,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
@@ -1006,6 +1008,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+
+	if (internals->single_iface)
+		return osdep_iface_mtu_set(internals->if_index, mtu);
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1019,6 +1032,7 @@ static const struct eth_dev_ops ops = {
 	.rx_queue_stop = eth_rx_queue_stop,
 	.tx_queue_stop = eth_tx_queue_stop,
 	.link_update = eth_link_update,
+	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
 };
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..7eacfce24f 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -15,5 +15,6 @@ extern int eth_pcap_logtype;
 
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
+int osdep_iface_mtu_set(int index, uint16_t mtu);
 
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..40244c51fb 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -8,6 +8,8 @@
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
+#include <sys/ioctl.h>
+#include <sys/sockio.h>
 
 #include "pcap_osdep.h"
 
@@ -55,3 +57,25 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	struct ifreq ifr = { .ifr_mtu = mtu };
+	char ifname[IFNAMSIZ];
+	int s, ret;
+
+	if (if_indextoname(ifindex, ifname) == NULL)
+		return -errno;
+
+	s = socket(PF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..567ab89bd6 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -40,3 +40,25 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+int
+osdep_iface_mtu_set(int ifindex, uint16_t mtu)
+{
+	struct ifreq ifr = { .ifr_mtu = mtu };
+	char if_name[IFNAMSIZ];
+	int s, ret;
+
+	if (if_indextoname(ifindex, if_name) == NULL)
+		return -errno;
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+
+	s = socket(PF_INET, SOCK_DGRAM, 0);
+	if (s < 0)
+		return -errno;
+
+	ret = ioctl(s, SIOCSIFMTU, &ifr);
+	close(s);
+
+	return (ret < 0) ? -errno : 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..00df67b8fc 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -116,3 +116,9 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_mtu_set(int index __rte_unused, uint16_t mtu __rte_unused)
+{
+	return -ENOTSUP;
+}
-- 
2.51.0

[PATCH v6 08/13] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 67 +++++++++++++++-------------------
 1 file changed, 29 insertions(+), 38 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 54f71fa17f..9ebb9c8633 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -99,9 +100,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -111,25 +112,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -869,7 +870,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1190,29 +1191,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1488,7 +1479,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1527,9 +1518,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
-- 
2.51.0

[PATCH v6 09/13] net/pcap: support VLAN insert and strip

[Stephen Hemminger]

Driver can easily insert VLAN tag strip and insertion similar
to how it is handled in virtio and af_packet.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 30 ++++++++++++++++++++++++--
 3 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index d2f5ee6039..7043213c5f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 41f96ad1af..4e31d85e50 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -58,6 +58,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for setting MTU in single interface mode.
+  * Added support for VLAN insertion and stripping.
   * Changed transmit burst to always return the number of packets requested.
     Failed sends are counted as transmit errors.
 
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 9ebb9c8633..85225fca2d 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -76,6 +76,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -103,6 +104,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -333,6 +335,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -421,6 +427,12 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		void *temp = NULL;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
@@ -498,6 +510,12 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		void *temp = NULL;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
 		if (likely(data != NULL &&
 		    pcap_sendpacket(pcap, data, len) == 0)) {
@@ -732,8 +750,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -751,7 +774,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN - RTE_ETHER_CRC_LEN;
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -898,6 +923,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
-- 
2.51.0

[PATCH v6 10/13] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Defer timestamp dynfield registration from probe to device start,
  and only when timestamp offloading is enabled
* Add read_clock dev_op returning current UTC time
  for timestamp correlation
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper
* Enable immediate mode and improve error reporting
  in live capture setup

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 129 +++++++++++++++++++------
 2 files changed, 102 insertions(+), 29 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 4e31d85e50..a1536033f7 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -59,6 +59,8 @@ New Features
 
   * Added support for setting MTU in single interface mode.
   * Added support for VLAN insertion and stripping.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
   * Changed transmit burst to always return the number of packets requested.
     Failed sends are counted as transmit errors.
 
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 85225fca2d..1c53a47bc6 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -27,13 +27,12 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
 #define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -77,6 +76,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -105,6 +105,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -339,10 +340,20 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * Although time stamp in struct pcap_pkthdr is defined as struct timeval,
+			 * it really is a timespec with nanosecond resolution.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -362,14 +373,13 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
  * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
  * because `ts` goes directly to nanosecond-precision dump.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -420,6 +430,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
@@ -433,7 +446,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 				continue;
 		}
 
-		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
 
@@ -536,22 +548,60 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
+	}
+
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -598,7 +648,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -635,6 +686,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
 
+	if (internals->timestamp_offloading) {
+		int ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							     &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+	}
+
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
@@ -757,6 +817,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -776,7 +837,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_mtu = RTE_ETH_PCAP_SNAPLEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -925,6 +987,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1046,6 +1109,17 @@ eth_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+ns_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1062,6 +1136,7 @@ static const struct eth_dev_ops ops = {
 	.mtu_set = eth_mtu_set,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.read_clock = ns_read_clock,
 };
 
 static int
@@ -1461,15 +1536,11 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
-
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
+		hz = rte_get_timer_hz();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v6 11/13] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 1c53a47bc6..c79b00332e 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -47,11 +47,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -550,6 +548,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -648,6 +647,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1351,6 +1352,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v6 12/13] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index c79b00332e..55cea14045 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -55,10 +55,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -849,11 +849,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v6 13/13] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, vlan handling and multiple queues

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2263 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 2266 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index f4d04a6e42..90e3afaecf 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..54ba4e178b
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,2263 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * This test needs OS network interfaces and
+ * managing that would require more changes on Windows.
+ */
+static int
+test_pmd_pcap(void)
+{
+	printf("PCAP test not supported on Windows, skipping test\n");
+	return TEST_SKIPPED;
+}
+
+#else
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+/*
+ * Helper: Create a unique temporary file path
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u with VLAN strip: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if network interface exists
+ */
+static int
+iface_exists(const char *name)
+{
+	struct ifreq ifr;
+	int sock, ret;
+
+	sock = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sock < 0)
+		return 0;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, name, IFNAMSIZ);
+	ret = ioctl(sock, SIOCGIFINDEX, &ifr);
+	close(sock);
+	return ret == 0;
+}
+
+/*
+ * Helper: Find a usable test interface
+ */
+static const char *
+find_test_iface(void)
+{
+	if (iface_exists("dummy0"))
+		return "dummy0";
+	if (iface_exists("lo"))
+		return "lo";
+	return NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	unlink(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	unlink(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: MTU configuration
+ */
+static int
+test_set_mtu(void)
+{
+	char devargs[256];
+	char mtu_tx_path[PATH_MAX];
+	uint16_t port_id;
+	static const uint16_t mtu_values[] = {1500, 9000, 1280};
+	int ret = 0;
+	size_t i;
+
+	printf("Testing MTU configuration\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_mtu_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(mtu_tx_path, sizeof(mtu_tx_path),
+				     "pcap_mtu_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, mtu_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_mtu", devargs, &port_id) == 0,
+		    "Failed to create MTU vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup MTU port");
+
+	for (i = 0; i < RTE_DIM(mtu_values); i++) {
+		uint16_t mtu;
+
+		ret = rte_eth_dev_set_mtu(port_id, mtu_values[i]);
+		if (ret != 0)
+			break;
+
+		TEST_ASSERT(rte_eth_dev_get_mtu(port_id, &mtu) == 0, "Failed to get MTU");
+		TEST_ASSERT_EQUAL(mtu, mtu_values[i], "MTU set mismatch for %u", mtu_values[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_mtu", port_id);
+	unlink(mtu_tx_path);
+
+	if (ret == 0) {
+		printf("MTU test completed\n");
+		return TEST_SUCCESS;
+	}
+
+	if (ret == -ENOTSUP) {
+		printf("MTU set not supported\n");
+		return TEST_SKIPPED;
+	}
+
+	printf("Failed to set MTU: %s", strerror(-ret));
+	return TEST_FAILED;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count, ret;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Set MTU to allow jumbo frames - PMD drops packets exceeding MTU */
+	ret = rte_eth_dev_set_mtu(port_id, PKT_SIZE_JUMBO);
+	if (ret != 0) {
+		printf("Failed to set MTU to %u: %s\n",
+		       PKT_SIZE_JUMBO, rte_strerror(-ret));
+		cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+		unlink(tx_path);
+		return TEST_SKIPPED;
+	}
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			unlink(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	unlink(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. min_mtu and max_mtu are set to reasonable values
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    min_mtu: %u\n", dev_info.min_mtu);
+	printf("    max_mtu: %u\n", dev_info.max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify MTU limits are reasonable */
+	TEST_ASSERT(dev_info.min_mtu > 0, "min_mtu should be > 0, got %u", dev_info.min_mtu);
+	TEST_ASSERT(dev_info.min_mtu <= RTE_ETHER_MIN_MTU,
+		    "min_mtu should be <= %u, got %u", RTE_ETHER_MIN_MTU, dev_info.min_mtu);
+	TEST_ASSERT(dev_info.max_mtu <= RTE_ETHER_MAX_JUMBO_FRAME_LEN,
+		    "max_mtu should be <= %u, got %u",
+		    RTE_ETHER_MAX_JUMBO_FRAME_LEN, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		unlink(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		unlink(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	if (tx_pcap_path[0] != '\0')
+		unlink(tx_pcap_path);
+	if (rx_pcap_path[0] != '\0')
+		unlink(rx_pcap_path);
+	if (infinite_pcap_path[0] != '\0')
+		unlink(infinite_pcap_path);
+	if (timestamp_pcap_path[0] != '\0')
+		unlink(timestamp_pcap_path);
+	if (varied_pcap_path[0] != '\0')
+		unlink(varied_pcap_path);
+	if (jumbo_pcap_path[0] != '\0')
+		unlink(jumbo_pcap_path);
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++) {
+		if (multi_tx_pcap_paths[i][0] != '\0')
+			unlink(multi_tx_pcap_paths[i]);
+	}
+	if (multi_rx_pcap_path[0] != '\0')
+		unlink(multi_rx_pcap_path);
+	if (vlan_rx_pcap_path[0] != '\0')
+		unlink(vlan_rx_pcap_path);
+	if (vlan_tx_pcap_path[0] != '\0')
+		unlink(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_set_mtu),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+#endif
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index a1536033f7..f8d9d81fd9 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -63,6 +63,7 @@ New Features
   * Receive timestamps support nanosecond precision.
   * Changed transmit burst to always return the number of packets requested.
     Failed sends are counted as transmit errors.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v7 00/13] net/pcap: improvements and test suite

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx and stripping on Rx
  - Nanosecond precision timestamps (when hardware/libpcap supports it)
  - Accurate link state, speed, and duplex reporting in interface mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability

Bug fixes:
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Change Tx burst to always consume all packets; failed sends
    increment error counter rather than leaving mbufs for retry
    (pcap_sendpacket failures are not transient)

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables

Testing:
  - Add comprehensive unit test suite covering basic operations,
    timestamps, jumbo frames, VLAN handling, multi-queue, and more

v7:
  - Drop MTU configuration patch; not necessary as underlying OS
    commands (ip link, ifconfig) can be used directly
  - Add patch to remove unnecessary volatile on queue statistics
  - Add test_link_status to unit test suite
  - Add Acked-by from Marat Khalili on patch 11

v6:
  - Rebase to latest main
  - Address review comments

Stephen Hemminger (13):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: improve multi-segment transmit handling
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN insert and strip
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  test: add test for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2334 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    8 +
 doc/guides/rel_notes/release_26_03.rst |    9 +
 drivers/net/pcap/pcap_ethdev.c         |  474 +++--
 drivers/net/pcap/pcap_osdep.h          |   23 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |  288 ++-
 drivers/net/pcap/pcap_osdep_linux.c    |  118 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   95 +-
 10 files changed, 3180 insertions(+), 172 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v7 01/13] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 3e90cb8c28..62da2be759 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap_ring.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v7 02/13] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v7 03/13] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 8 ++++++++
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..d09ba5abe9 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,24 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v7 04/13] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index d09ba5abe9..0177cbc7df 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1221,9 +1221,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1591,10 +1590,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v7 05/13] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  2 +-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 0177cbc7df..2e41ad35ed 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1289,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v7 06/13] net/pcap: improve multi-segment transmit handling

[Stephen Hemminger]

Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability in device info. The
driver already handles multi-segment mbufs but was not reporting this.

Replace the fixed-size stack buffer (up to 9K) with dynamic allocation
only when the mbuf is non-contiguous. This avoids large stack usage and
removes the silent truncation that occurred when packets exceeded the
buffer size.

Change transmit functions to always consume and free all packets,
returning nb_pkts regardless of send success. The DPDK transmit API
interprets a return value less than requested as "queue full, retry
later." However, pcap_sendpacket() failures (bad parameters or socket
errors) are not transient and retrying would fail again. The correct
behavior is to free failed packets and increment the error counter
rather than leaving mbufs for the application to retry.

Also use rte_pktmbuf_free_bulk() for more efficient buffer freeing.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   5 ++
 drivers/net/pcap/pcap_ethdev.c         | 106 ++++++++++++-------------
 2 files changed, 56 insertions(+), 55 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 15dabee7a1..76d81ac524 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -55,6 +55,11 @@ New Features
      Also, make sure to start the actual text at the margin.
      =======================================================
 
+* **Updated PCAP ethernet driver.**
+
+  * Changed transmit burst to always return the number of packets requested.
+    Failed sends are counted as transmit errors.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2e41ad35ed..537d66ed30 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -30,7 +30,7 @@
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
+#define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
 #define RTE_ETH_PCAP_PROMISC 1
 #define RTE_ETH_PCAP_TIMEOUT -1
 
@@ -378,6 +378,21 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+/* Like rte_pktmbuf_read() but allocate if needed */
+static inline const void *
+pcap_pktmbuf_read(const struct rte_mbuf *m,
+		  uint32_t off, uint32_t len, void **buf)
+{
+	if (likely(off + len <= rte_pktmbuf_data_len(m)))
+		return rte_pktmbuf_mtod_offset(m, char *, off);
+
+	*buf = malloc(len);
+	if (likely(*buf != NULL))
+		return rte_pktmbuf_read(m, off, len, *buf);
+	else
+		return NULL;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -385,46 +400,40 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	pcap_dumper_t *dumper;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
-		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+		header.caplen = len;
 
-		num_tx++;
-		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (likely(data != NULL)) {
+			pcap_dump((u_char *)dumper, &header, data);
+
+			num_tx++;
+			tx_bytes += len;
+		}
+		free(temp);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -452,15 +461,15 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(nb_pkts == 0))
 		return 0;
 
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -470,15 +479,11 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
@@ -487,35 +492,25 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
-			continue;
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
+
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (likely(data != NULL &&
+		    pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
 		}
-
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
+	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -753,6 +748,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v7 07/13] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 67 +++++++++++++++-------------------
 1 file changed, 29 insertions(+), 38 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 537d66ed30..641d345df4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -99,9 +100,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -111,25 +112,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -867,7 +868,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1176,29 +1177,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1474,7 +1465,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1513,9 +1504,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
-- 
2.51.0

[PATCH v7 08/13] net/pcap: support VLAN insert and strip

[Stephen Hemminger]

Driver can easily insert VLAN tag strip and insertion similar
to how it is handled in virtio and af_packet.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 30 ++++++++++++++++++++++++--
 3 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..814bc2119f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 76d81ac524..3d25626adb 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -59,6 +59,7 @@ New Features
 
   * Changed transmit burst to always return the number of packets requested.
     Failed sends are counted as transmit errors.
+  * Added support for VLAN insertion and stripping.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 641d345df4..810f9c6f82 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -76,6 +76,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -103,6 +104,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -333,6 +335,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -421,6 +427,12 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		void *temp = NULL;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
@@ -498,6 +510,12 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		void *temp = NULL;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
 		if (likely(data != NULL &&
 		    pcap_sendpacket(pcap, data, len) == 0)) {
@@ -732,8 +750,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -749,7 +772,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -896,6 +921,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
-- 
2.51.0

[PATCH v7 09/13] net/pcap: add link state and speed for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent functions to query the real link state, speed,
duplex, and autonegotiation settings from the underlying interface.
The eth_link_update() callback now returns accurate information
when operating in pass-through mode.

Linux uses ETHTOOL_GLINKSETTINGS which supports all speeds up to
800 Gbps. FreeBSD uses SIOCGIFMEDIA, and Windows uses
GetAdaptersAddresses().

For pcap file mode or separate rx/tx interface configurations,
default values continue to be used since there is no single
underlying interface to query.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        | 105 +++++++++-
 drivers/net/pcap/pcap_osdep.h         |  22 ++
 drivers/net/pcap/pcap_osdep_freebsd.c | 276 ++++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c   | 112 +++++++++++
 drivers/net/pcap/pcap_osdep_windows.c |  95 +++++++--
 5 files changed, 587 insertions(+), 23 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 810f9c6f82..0200e129d8 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -147,13 +147,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -900,11 +893,96 @@ eth_dev_close(struct rte_eth_dev *dev)
 	return 0;
 }
 
+/*
+ * Convert osdep speed (Mbps) to rte_eth_link speed constant.
+ */
+static uint32_t
+speed_mbps_to_rte(uint32_t speed_mbps)
+{
+	switch (speed_mbps) {
+	case 10:
+		return RTE_ETH_SPEED_NUM_10M;
+	case 100:
+		return RTE_ETH_SPEED_NUM_100M;
+	case 1000:
+		return RTE_ETH_SPEED_NUM_1G;
+	case 2500:
+		return RTE_ETH_SPEED_NUM_2_5G;
+	case 5000:
+		return RTE_ETH_SPEED_NUM_5G;
+	case 10000:
+		return RTE_ETH_SPEED_NUM_10G;
+	case 20000:
+		return RTE_ETH_SPEED_NUM_20G;
+	case 25000:
+		return RTE_ETH_SPEED_NUM_25G;
+	case 40000:
+		return RTE_ETH_SPEED_NUM_40G;
+	case 50000:
+		return RTE_ETH_SPEED_NUM_50G;
+	case 56000:
+		return RTE_ETH_SPEED_NUM_56G;
+	case 100000:
+		return RTE_ETH_SPEED_NUM_100G;
+	case 200000:
+		return RTE_ETH_SPEED_NUM_200G;
+	case 400000:
+		return RTE_ETH_SPEED_NUM_400G;
+	case 800000:
+		return RTE_ETH_SPEED_NUM_800G;
+	default:
+		/* For unknown speeds, return the raw value */
+		if (speed_mbps > 0)
+			return speed_mbps;
+		return RTE_ETH_SPEED_NUM_UNKNOWN;
+	}
+}
+
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link link;
+	struct osdep_iface_link osdep_link;
+	const char *iface_name;
+
+	memset(&link, 0, sizeof(link));
+
+	/*
+	 * For pass-through mode (single_iface), query the actual interface.
+	 * Otherwise, use the default static link values.
+	 */
+	if (internals->single_iface) {
+		iface_name = internals->rx_queue[0].name;
+
+		if (osdep_iface_link_get(iface_name, &osdep_link) == 0) {
+			link.link_speed = speed_mbps_to_rte(osdep_link.link_speed);
+			link.link_status = osdep_link.link_status ?
+				RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+			link.link_duplex = osdep_link.link_duplex ?
+				RTE_ETH_LINK_FULL_DUPLEX : RTE_ETH_LINK_HALF_DUPLEX;
+			link.link_autoneg = osdep_link.link_autoneg ?
+				RTE_ETH_LINK_AUTONEG : RTE_ETH_LINK_FIXED;
+		} else {
+			/* Query failed, use defaults */
+			link.link_speed = RTE_ETH_SPEED_NUM_10G;
+			link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+			link.link_status = RTE_ETH_LINK_DOWN;
+			link.link_autoneg = RTE_ETH_LINK_FIXED;
+		}
+	} else {
+		/*
+		 * Not in pass-through mode (using pcap files or separate
+		 * interfaces for rx/tx). Use default values.
+		 */
+		link.link_speed = RTE_ETH_SPEED_NUM_10G;
+		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_autoneg = RTE_ETH_LINK_FIXED;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1269,7 +1347,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..732813c028 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,7 +13,29 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+/**
+ * Link information returned by osdep_iface_link_get().
+ */
+struct osdep_iface_link {
+	uint32_t link_speed;    /**< Speed in Mbps, 0 if unknown */
+	uint8_t link_status;    /**< 1 = up, 0 = down */
+	uint8_t link_duplex;    /**< 1 = full, 0 = half */
+	uint8_t link_autoneg;   /**< 1 = autoneg enabled, 0 = fixed */
+};
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link state and speed for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @param link
+ *   Pointer to structure to fill with link information.
+ * @return
+ *   0 on success, -1 on failure.
+ */
+int osdep_iface_link_get(const char *name, struct osdep_iface_link *link);
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..404f3c7432 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,8 +5,12 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
@@ -55,3 +59,275 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+/*
+ * Map media subtype to speed in Mbps.
+ * This handles common Ethernet media types.
+ */
+static uint32_t
+media_subtype_to_speed(int subtype)
+{
+	switch (subtype) {
+	case IFM_10_T:
+	case IFM_10_2:
+	case IFM_10_5:
+	case IFM_10_STP:
+	case IFM_10_FL:
+		return 10;
+	case IFM_100_TX:
+	case IFM_100_FX:
+	case IFM_100_T4:
+	case IFM_100_VG:
+	case IFM_100_T2:
+		return 100;
+	case IFM_1000_SX:
+	case IFM_1000_LX:
+	case IFM_1000_CX:
+	case IFM_1000_T:
+#ifdef IFM_1000_KX
+	case IFM_1000_KX:
+#endif
+#ifdef IFM_1000_SGMII
+	case IFM_1000_SGMII:
+#endif
+		return 1000;
+#ifdef IFM_2500_T
+	case IFM_2500_T:
+#endif
+#ifdef IFM_2500_X
+	case IFM_2500_X:
+#endif
+#ifdef IFM_2500_KX
+	case IFM_2500_KX:
+#endif
+		return 2500;
+#ifdef IFM_5000_T
+	case IFM_5000_T:
+#endif
+#ifdef IFM_5000_KR
+	case IFM_5000_KR:
+#endif
+		return 5000;
+	case IFM_10G_LR:
+	case IFM_10G_SR:
+	case IFM_10G_CX4:
+	case IFM_10G_T:
+	case IFM_10G_TWINAX:
+	case IFM_10G_TWINAX_LONG:
+	case IFM_10G_LRM:
+	case IFM_10G_KX4:
+	case IFM_10G_KR:
+	case IFM_10G_CR1:
+	case IFM_10G_ER:
+	case IFM_10G_SFI:
+		return 10000;
+#ifdef IFM_20G_KR2
+	case IFM_20G_KR2:
+#endif
+		return 20000;
+	case IFM_25G_CR:
+	case IFM_25G_KR:
+	case IFM_25G_SR:
+	case IFM_25G_LR:
+#ifdef IFM_25G_ACC
+	case IFM_25G_ACC:
+#endif
+#ifdef IFM_25G_AOC
+	case IFM_25G_AOC:
+#endif
+#ifdef IFM_25G_ER
+	case IFM_25G_ER:
+#endif
+#ifdef IFM_25G_T
+	case IFM_25G_T:
+#endif
+		return 25000;
+	case IFM_40G_CR4:
+	case IFM_40G_SR4:
+	case IFM_40G_LR4:
+	case IFM_40G_KR4:
+#ifdef IFM_40G_ER4
+	case IFM_40G_ER4:
+#endif
+		return 40000;
+	case IFM_50G_CR2:
+	case IFM_50G_KR2:
+#ifdef IFM_50G_SR2
+	case IFM_50G_SR2:
+#endif
+#ifdef IFM_50G_LR2
+	case IFM_50G_LR2:
+#endif
+#ifdef IFM_50G_KR
+	case IFM_50G_KR:
+#endif
+#ifdef IFM_50G_SR
+	case IFM_50G_SR:
+#endif
+#ifdef IFM_50G_CR
+	case IFM_50G_CR:
+#endif
+#ifdef IFM_50G_LR
+	case IFM_50G_LR:
+#endif
+#ifdef IFM_50G_FR
+	case IFM_50G_FR:
+#endif
+		return 50000;
+	case IFM_100G_CR4:
+	case IFM_100G_SR4:
+	case IFM_100G_KR4:
+	case IFM_100G_LR4:
+#ifdef IFM_100G_CR2
+	case IFM_100G_CR2:
+#endif
+#ifdef IFM_100G_SR2
+	case IFM_100G_SR2:
+#endif
+#ifdef IFM_100G_KR2
+	case IFM_100G_KR2:
+#endif
+#ifdef IFM_100G_DR
+	case IFM_100G_DR:
+#endif
+#ifdef IFM_100G_FR
+	case IFM_100G_FR:
+#endif
+#ifdef IFM_100G_LR
+	case IFM_100G_LR:
+#endif
+		return 100000;
+#ifdef IFM_200G_CR4
+	case IFM_200G_CR4:
+#endif
+#ifdef IFM_200G_SR4
+	case IFM_200G_SR4:
+#endif
+#ifdef IFM_200G_KR4
+	case IFM_200G_KR4:
+#endif
+#ifdef IFM_200G_LR4
+	case IFM_200G_LR4:
+#endif
+#ifdef IFM_200G_FR4
+	case IFM_200G_FR4:
+#endif
+#ifdef IFM_200G_DR4
+	case IFM_200G_DR4:
+#endif
+		return 200000;
+#ifdef IFM_400G_CR8
+	case IFM_400G_CR8:
+#endif
+#ifdef IFM_400G_SR8
+	case IFM_400G_SR8:
+#endif
+#ifdef IFM_400G_KR8
+	case IFM_400G_KR8:
+#endif
+#ifdef IFM_400G_LR8
+	case IFM_400G_LR8:
+#endif
+#ifdef IFM_400G_FR8
+	case IFM_400G_FR8:
+#endif
+#ifdef IFM_400G_DR8
+	case IFM_400G_DR8:
+#endif
+#ifdef IFM_400G_CR4
+	case IFM_400G_CR4:
+#endif
+#ifdef IFM_400G_SR4
+	case IFM_400G_SR4:
+#endif
+#ifdef IFM_400G_DR4
+	case IFM_400G_DR4:
+#endif
+#ifdef IFM_400G_FR4
+	case IFM_400G_FR4:
+#endif
+#ifdef IFM_400G_LR4
+	case IFM_400G_LR4:
+#endif
+		return 400000;
+#ifdef IFM_800G_CR8
+	case IFM_800G_CR8:
+#endif
+#ifdef IFM_800G_SR8
+	case IFM_800G_SR8:
+#endif
+#ifdef IFM_800G_DR8
+	case IFM_800G_DR8:
+#endif
+#ifdef IFM_800G_FR8
+	case IFM_800G_FR8:
+#endif
+#ifdef IFM_800G_LR8
+	case IFM_800G_LR8:
+#endif
+		return 800000;
+	default:
+		return 0;
+	}
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifmediareq ifmr;
+	struct ifreq ifr;
+	int if_fd;
+	int subtype;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine administrative status */
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		if (ifr.ifr_flags & IFF_UP)
+			link->link_status = 1;
+	}
+
+	/* Get media status for speed, duplex, and link state */
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(if_fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* Check if link is actually active */
+		if (!(ifmr.ifm_status & IFM_ACTIVE))
+			link->link_status = 0;
+
+		/* Only parse media if we have a valid current media type */
+		if (ifmr.ifm_current != 0 && IFM_TYPE(ifmr.ifm_current) == IFM_ETHER) {
+			subtype = IFM_SUBTYPE(ifmr.ifm_current);
+			link->link_speed = media_subtype_to_speed(subtype);
+
+			/* Check duplex - FDX option means full duplex */
+			if (IFM_OPTIONS(ifmr.ifm_current) & IFM_FDX)
+				link->link_duplex = 1;
+			else
+				link->link_duplex = 0;
+		} else {
+			/* Default to full duplex if we can't determine */
+			link->link_duplex = 1;
+		}
+
+		/* Check autonegotiation status */
+		link->link_autoneg = (ifmr.ifm_current & IFM_AUTO) ? 1 : 0;
+	} else {
+		/*
+		 * SIOCGIFMEDIA failed - interface may not support it.
+		 * Default to reasonable values.
+		 */
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..c9cc1f5ebb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -9,6 +9,8 @@
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include <rte_string_fns.h>
 
@@ -40,3 +42,113 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+/*
+ * Get link speed, duplex, and autoneg using ETHTOOL_GLINKSETTINGS.
+ *
+ * ETHTOOL_GLINKSETTINGS was introduced in kernel 4.7 and supports
+ * speeds beyond 65535 Mbps (up to 800 Gbps and beyond).
+ * DPDK requires kernel 4.19 or later, so this interface is always available.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+get_link_settings(int fd, struct ifreq *ifr, struct osdep_iface_link *link)
+{
+	struct {
+		struct ethtool_link_settings req;
+		uint32_t link_mode_masks[3 * 127];  /* 3 masks * max words */
+	} ecmd;
+	int nwords;
+
+	memset(&ecmd, 0, sizeof(ecmd));
+	ecmd.req.cmd = ETHTOOL_GLINKSETTINGS;
+
+	ifr->ifr_data = (void *)&ecmd;
+
+	/* First call with nwords = 0 to get the required size */
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Kernel returns negative nwords on first call */
+	if (ecmd.req.link_mode_masks_nwords >= 0)
+		return -1;
+
+	nwords = -ecmd.req.link_mode_masks_nwords;
+
+	/* Sanity check */
+	if (nwords == 0 || nwords > 127)
+		return -1;
+
+	/* Second call with correct nwords */
+	memset(&ecmd, 0, sizeof(ecmd));
+	ecmd.req.cmd = ETHTOOL_GLINKSETTINGS;
+	ecmd.req.link_mode_masks_nwords = nwords;
+	ifr->ifr_data = (void *)&ecmd;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Speed is in Mbps, directly usable */
+	link->link_speed = ecmd.req.speed;
+
+	/* Handle special values */
+	if (link->link_speed == (uint32_t)SPEED_UNKNOWN ||
+	    link->link_speed == (uint32_t)-1)
+		link->link_speed = 0;
+
+	switch (ecmd.req.duplex) {
+	case DUPLEX_FULL:
+		link->link_duplex = 1;
+		break;
+	case DUPLEX_HALF:
+		link->link_duplex = 0;
+		break;
+	default:
+		link->link_duplex = 1;  /* Default to full duplex */
+		break;
+	}
+
+	link->link_autoneg = (ecmd.req.autoneg == AUTONEG_ENABLE) ? 1 : 0;
+
+	return 0;
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifreq ifr;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine link status */
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up
+		 * IFF_RUNNING means operationally up (carrier detected)
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			link->link_status = 1;
+	}
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (get_link_settings(if_fd, &ifr, link) < 0) {
+		/*
+		 * ethtool failed - interface may not support it
+		 * (e.g., virtual interfaces like veth, lo).
+		 * Use reasonable defaults.
+		 */
+		link->link_speed = 0;
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..1b76ae3185 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,56 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_get(const char *device_name, struct osdep_iface_link *link)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	memset(link, 0, sizeof(*link));
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			/* Check operational status */
+			if (cur->OperStatus == IfOperStatusUp)
+				link->link_status = 1;
+			else
+				link->link_status = 0;
+
+			/*
+			 * TransmitLinkSpeed and ReceiveLinkSpeed are in bits/sec.
+			 * Convert to Mbps. Use transmit speed as the link speed.
+			 * For asymmetric links, this is a reasonable approximation.
+			 */
+			if (cur->TransmitLinkSpeed != 0 &&
+			    cur->TransmitLinkSpeed != (ULONG64)-1) {
+				link->link_speed =
+					(uint32_t)(cur->TransmitLinkSpeed / 1000000ULL);
+			}
+
+			/*
+			 * Windows doesn't directly expose duplex/autoneg via
+			 * GetAdaptersAddresses(). Default to full duplex.
+			 * For more detailed info, WMI or OID queries would be needed.
+			 */
+			link->link_duplex = 1;  /* Assume full duplex */
+			link->link_autoneg = 0; /* Cannot determine */
+
+			ret = 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v7 10/13] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Defer timestamp dynfield registration from probe to device start,
  and only when timestamp offloading is enabled
* Add read_clock dev_op returning current UTC time
  for timestamp correlation
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper
* Enable immediate mode and improve error reporting
  in live capture setup

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 129 +++++++++++++++++++------
 2 files changed, 102 insertions(+), 29 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 3d25626adb..de1302ef06 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -60,6 +60,8 @@ New Features
   * Changed transmit burst to always return the number of packets requested.
     Failed sends are counted as transmit errors.
   * Added support for VLAN insertion and stripping.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 0200e129d8..35ab4e58d3 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -27,13 +27,12 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
 #define RTE_ETH_PCAP_SNAPLEN (RTE_ETHER_MAX_JUMBO_FRAME_LEN - RTE_ETHER_CRC_LEN)
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -77,6 +76,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -105,6 +105,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -332,10 +333,20 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * Although time stamp in struct pcap_pkthdr is defined as struct timeval,
+			 * it really is a timespec with nanosecond resolution.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -355,14 +366,13 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
  * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
  * because `ts` goes directly to nanosecond-precision dump.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -413,6 +423,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
@@ -426,7 +439,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 				continue;
 		}
 
-		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = len;
 
@@ -529,22 +541,60 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
+	}
+
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -591,7 +641,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -628,6 +679,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
 
+	if (internals->timestamp_offloading) {
+		int ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							     &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+	}
+
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
@@ -750,6 +810,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -767,7 +828,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -1001,6 +1063,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1111,12 +1174,24 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.rx_queue_start = eth_rx_queue_start,
@@ -1530,15 +1605,11 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
-
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
+		hz = rte_get_timer_hz();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v7 11/13] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 35ab4e58d3..1670cd56cf 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -47,11 +47,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -543,6 +541,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -641,6 +640,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1415,6 +1416,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v7 12/13] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 1670cd56cf..c960264db2 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -55,10 +55,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -840,11 +840,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v7 13/13] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, vlan handling and multiple queues

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2334 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 2337 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index f4d04a6e42..90e3afaecf 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..22039f94dc
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,2334 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * This test needs OS network interfaces and
+ * managing that would require more changes on Windows.
+ */
+static int
+test_pmd_pcap(void)
+{
+	printf("PCAP test not supported on Windows, skipping test\n");
+	return TEST_SKIPPED;
+}
+
+#else
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+/*
+ * Helper: Create a unique temporary file path
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u with VLAN strip: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if network interface exists
+ */
+static int
+iface_exists(const char *name)
+{
+	struct ifreq ifr;
+	int sock, ret;
+
+	sock = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sock < 0)
+		return 0;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, name, IFNAMSIZ);
+	ret = ioctl(sock, SIOCGIFINDEX, &ifr);
+	close(sock);
+	return ret == 0;
+}
+
+/*
+ * Helper: Find a usable test interface
+ */
+static const char *
+find_test_iface(void)
+{
+	if (iface_exists("dummy0"))
+		return "dummy0";
+	if (iface_exists("lo"))
+		return "lo";
+	return NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	unlink(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	unlink(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			unlink(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	unlink(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. min_mtu and max_mtu are set to reasonable values
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    min_mtu: %u\n", dev_info.min_mtu);
+	printf("    max_mtu: %u\n", dev_info.max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify MTU limits are reasonable */
+	TEST_ASSERT(dev_info.min_mtu > 0, "min_mtu should be > 0, got %u", dev_info.min_mtu);
+	TEST_ASSERT(dev_info.min_mtu <= RTE_ETHER_MIN_MTU,
+		    "min_mtu should be <= %u, got %u", RTE_ETHER_MIN_MTU, dev_info.min_mtu);
+	TEST_ASSERT(dev_info.max_mtu <= RTE_ETHER_MAX_JUMBO_FRAME_LEN,
+		    "max_mtu should be <= %u, got %u",
+		    RTE_ETHER_MAX_JUMBO_FRAME_LEN, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		unlink(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		unlink(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	if (tx_pcap_path[0] != '\0')
+		unlink(tx_pcap_path);
+	if (rx_pcap_path[0] != '\0')
+		unlink(rx_pcap_path);
+	if (infinite_pcap_path[0] != '\0')
+		unlink(infinite_pcap_path);
+	if (timestamp_pcap_path[0] != '\0')
+		unlink(timestamp_pcap_path);
+	if (varied_pcap_path[0] != '\0')
+		unlink(varied_pcap_path);
+	if (jumbo_pcap_path[0] != '\0')
+		unlink(jumbo_pcap_path);
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++) {
+		if (multi_tx_pcap_paths[i][0] != '\0')
+			unlink(multi_tx_pcap_paths[i]);
+	}
+	if (multi_rx_pcap_path[0] != '\0')
+		unlink(multi_rx_pcap_path);
+	if (vlan_rx_pcap_path[0] != '\0')
+		unlink(vlan_rx_pcap_path);
+	if (vlan_tx_pcap_path[0] != '\0')
+		unlink(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+#endif
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index de1302ef06..ddcb693166 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -62,6 +62,7 @@ New Features
   * Added support for VLAN insertion and stripping.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v8 00/14] net/pcap: improvements and test suite

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx and stripping on Rx
  - Nanosecond precision timestamps (when hardware/libpcap supports it)
  - Accurate link state, speed, and duplex reporting in interface mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability

Bug fixes:
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Change Tx burst to always consume all packets; failed sends
    increment error counter rather than leaving mbufs for retry
    (pcap_sendpacket failures are not transient)

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables

Testing:
  - Add comprehensive unit test suite covering basic operations,
    timestamps, jumbo frames, VLAN handling, multi-queue, and more

v8:
  - Fix pcap header length in VLAN transmit
  - Fix clang warnings from ethtool link_mode array

v7:
  - Drop MTU configuration patch; not necessary as underlying OS
    commands (ip link, ifconfig) can be used directly
  - Add patch to remove unnecessary volatile on queue statistics
  - Add test_link_status to unit test suite
  - Add Acked-by from Marat Khalili on patch 11

v6:
  - Rebase to latest main

Stephen Hemminger (14):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: improve multi-segment transmit handling
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN insert and strip
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  test: add test for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2337 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    8 +
 doc/guides/rel_notes/release_26_03.rst |    9 +
 drivers/net/pcap/pcap_ethdev.c         |  474 +++--
 drivers/net/pcap/pcap_osdep.h          |   23 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |  289 ++-
 drivers/net/pcap/pcap_osdep_linux.c    |  115 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   95 +-
 10 files changed, 3180 insertions(+), 173 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v8 01/14] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 3e90cb8c28..62da2be759 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap_ring.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v8 02/14] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v8 03/14] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 8 ++++++++
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..d09ba5abe9 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,24 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v8 04/14] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index d09ba5abe9..0177cbc7df 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1221,9 +1221,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1591,10 +1590,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v8 05/14] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  2 +-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 0177cbc7df..2e41ad35ed 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1289,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v8 06/14] net/pcap: improve multi-segment transmit handling

[Stephen Hemminger]

Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability in device info. The
driver already handles multi-segment mbufs but was not reporting this.

Replace the fixed-size stack buffer (up to 9K) with dynamic allocation
only when the mbuf is non-contiguous. This avoids large stack usage and
removes the silent truncation that occurred when packets exceeded the
buffer size.

Change transmit functions to always consume and free all packets,
returning nb_pkts regardless of send success. The DPDK transmit API
interprets a return value less than requested as "queue full, retry
later." However, pcap_sendpacket() failures (bad parameters or socket
errors) are not transient and retrying would fail again. The correct
behavior is to free failed packets and increment the error counter
rather than leaving mbufs for the application to retry.

Also use rte_pktmbuf_free_bulk() for more efficient buffer freeing.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   5 ++
 drivers/net/pcap/pcap_ethdev.c         | 105 ++++++++++++-------------
 2 files changed, 55 insertions(+), 55 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 15dabee7a1..76d81ac524 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -55,6 +55,11 @@ New Features
      Also, make sure to start the actual text at the margin.
      =======================================================
 
+* **Updated PCAP ethernet driver.**
+
+  * Changed transmit burst to always return the number of packets requested.
+    Failed sends are counted as transmit errors.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2e41ad35ed..93b3fe229d 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -30,7 +30,6 @@
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
 #define RTE_ETH_PCAP_PROMISC 1
 #define RTE_ETH_PCAP_TIMEOUT -1
 
@@ -378,6 +377,21 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+/* Like rte_pktmbuf_read() but allocate if needed */
+static inline const void *
+pcap_pktmbuf_read(const struct rte_mbuf *m,
+		  uint32_t off, uint32_t len, void **buf)
+{
+	if (likely(off + len <= rte_pktmbuf_data_len(m)))
+		return rte_pktmbuf_mtod_offset(m, char *, off);
+
+	*buf = malloc(len);
+	if (likely(*buf != NULL))
+		return rte_pktmbuf_read(m, off, len, *buf);
+	else
+		return NULL;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -385,46 +399,40 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	pcap_dumper_t *dumper;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
-		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+		header.caplen = len;
 
-		num_tx++;
-		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (likely(data != NULL)) {
+			pcap_dump((u_char *)dumper, &header, data);
+
+			num_tx++;
+			tx_bytes += len;
+		}
+		free(temp);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -452,15 +460,15 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(nb_pkts == 0))
 		return 0;
 
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -470,15 +478,11 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
@@ -487,35 +491,25 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
-			continue;
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
+
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (likely(data != NULL &&
+		    pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
 		}
-
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
+	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -753,6 +747,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v8 07/14] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 67 +++++++++++++++-------------------
 1 file changed, 29 insertions(+), 38 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 93b3fe229d..63a4f92c9c 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -98,9 +99,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -110,25 +111,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -866,7 +867,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1175,29 +1176,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1473,7 +1464,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1512,9 +1503,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
-- 
2.51.0

[PATCH v8 08/14] net/pcap: support VLAN insert and strip

[Stephen Hemminger]

Driver can easily insert VLAN tag strip and insertion similar
to how it is handled in virtio and af_packet.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 38 ++++++++++++++++++++++----
 3 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..814bc2119f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 76d81ac524..3d25626adb 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -59,6 +59,7 @@ New Features
 
   * Changed transmit burst to always return the number of packets requested.
     Failed sends are counted as transmit errors.
+  * Added support for VLAN insertion and stripping.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 63a4f92c9c..47211807a7 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -75,6 +75,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -102,6 +103,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -332,6 +334,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -416,15 +422,21 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
-		void *temp = NULL;
-		const uint8_t *data;
+
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
 
 		calculate_timestamp(&header.ts);
+
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		header.len = len;
 		header.caplen = len;
 
-		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		void *temp = NULL;
+		const uint8_t *data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
 		if (likely(data != NULL)) {
 			pcap_dump((u_char *)dumper, &header, data);
 
@@ -497,6 +509,12 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		void *temp = NULL;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
 		if (likely(data != NULL &&
 		    pcap_sendpacket(pcap, data, len) == 0)) {
@@ -731,8 +749,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -748,7 +771,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -895,6 +920,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
-- 
2.51.0

[PATCH v8 09/14] net/pcap: add link state and speed for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent functions to query the real link state, speed,
duplex, and autonegotiation settings from the underlying interface.
The eth_link_update() callback now returns accurate information
when operating in pass-through mode.

Linux uses ETHTOOL_GLINKSETTINGS which supports all speeds up to
800 Gbps. FreeBSD uses SIOCGIFMEDIA, and Windows uses
GetAdaptersAddresses().

For pcap file mode or separate rx/tx interface configurations,
default values continue to be used since there is no single
underlying interface to query.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        | 105 +++++++++-
 drivers/net/pcap/pcap_osdep.h         |  22 ++
 drivers/net/pcap/pcap_osdep_freebsd.c | 277 ++++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c   | 109 ++++++++++
 drivers/net/pcap/pcap_osdep_windows.c |  95 +++++++--
 5 files changed, 585 insertions(+), 23 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 47211807a7..f8ccc03d6f 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -146,13 +146,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -899,11 +892,96 @@ eth_dev_close(struct rte_eth_dev *dev)
 	return 0;
 }
 
+/*
+ * Convert osdep speed (Mbps) to rte_eth_link speed constant.
+ */
+static uint32_t
+speed_mbps_to_rte(uint32_t speed_mbps)
+{
+	switch (speed_mbps) {
+	case 10:
+		return RTE_ETH_SPEED_NUM_10M;
+	case 100:
+		return RTE_ETH_SPEED_NUM_100M;
+	case 1000:
+		return RTE_ETH_SPEED_NUM_1G;
+	case 2500:
+		return RTE_ETH_SPEED_NUM_2_5G;
+	case 5000:
+		return RTE_ETH_SPEED_NUM_5G;
+	case 10000:
+		return RTE_ETH_SPEED_NUM_10G;
+	case 20000:
+		return RTE_ETH_SPEED_NUM_20G;
+	case 25000:
+		return RTE_ETH_SPEED_NUM_25G;
+	case 40000:
+		return RTE_ETH_SPEED_NUM_40G;
+	case 50000:
+		return RTE_ETH_SPEED_NUM_50G;
+	case 56000:
+		return RTE_ETH_SPEED_NUM_56G;
+	case 100000:
+		return RTE_ETH_SPEED_NUM_100G;
+	case 200000:
+		return RTE_ETH_SPEED_NUM_200G;
+	case 400000:
+		return RTE_ETH_SPEED_NUM_400G;
+	case 800000:
+		return RTE_ETH_SPEED_NUM_800G;
+	default:
+		/* For unknown speeds, return the raw value */
+		if (speed_mbps > 0)
+			return speed_mbps;
+		return RTE_ETH_SPEED_NUM_UNKNOWN;
+	}
+}
+
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link link;
+	struct osdep_iface_link osdep_link;
+	const char *iface_name;
+
+	memset(&link, 0, sizeof(link));
+
+	/*
+	 * For pass-through mode (single_iface), query the actual interface.
+	 * Otherwise, use the default static link values.
+	 */
+	if (internals->single_iface) {
+		iface_name = internals->rx_queue[0].name;
+
+		if (osdep_iface_link_get(iface_name, &osdep_link) == 0) {
+			link.link_speed = speed_mbps_to_rte(osdep_link.link_speed);
+			link.link_status = osdep_link.link_status ?
+				RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+			link.link_duplex = osdep_link.link_duplex ?
+				RTE_ETH_LINK_FULL_DUPLEX : RTE_ETH_LINK_HALF_DUPLEX;
+			link.link_autoneg = osdep_link.link_autoneg ?
+				RTE_ETH_LINK_AUTONEG : RTE_ETH_LINK_FIXED;
+		} else {
+			/* Query failed, use defaults */
+			link.link_speed = RTE_ETH_SPEED_NUM_10G;
+			link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+			link.link_status = RTE_ETH_LINK_DOWN;
+			link.link_autoneg = RTE_ETH_LINK_FIXED;
+		}
+	} else {
+		/*
+		 * Not in pass-through mode (using pcap files or separate
+		 * interfaces for rx/tx). Use default values.
+		 */
+		link.link_speed = RTE_ETH_SPEED_NUM_10G;
+		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_autoneg = RTE_ETH_LINK_FIXED;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1268,7 +1346,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..732813c028 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,7 +13,29 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+/**
+ * Link information returned by osdep_iface_link_get().
+ */
+struct osdep_iface_link {
+	uint32_t link_speed;    /**< Speed in Mbps, 0 if unknown */
+	uint8_t link_status;    /**< 1 = up, 0 = down */
+	uint8_t link_duplex;    /**< 1 = full, 0 = half */
+	uint8_t link_autoneg;   /**< 1 = autoneg enabled, 0 = fixed */
+};
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link state and speed for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @param link
+ *   Pointer to structure to fill with link information.
+ * @return
+ *   0 on success, -1 on failure.
+ */
+int osdep_iface_link_get(const char *name, struct osdep_iface_link *link);
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..1405f1f85d 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,8 +5,13 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
@@ -55,3 +60,275 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+/*
+ * Map media subtype to speed in Mbps.
+ * This handles common Ethernet media types.
+ */
+static uint32_t
+media_subtype_to_speed(int subtype)
+{
+	switch (subtype) {
+	case IFM_10_T:
+	case IFM_10_2:
+	case IFM_10_5:
+	case IFM_10_STP:
+	case IFM_10_FL:
+		return 10;
+	case IFM_100_TX:
+	case IFM_100_FX:
+	case IFM_100_T4:
+	case IFM_100_VG:
+	case IFM_100_T2:
+		return 100;
+	case IFM_1000_SX:
+	case IFM_1000_LX:
+	case IFM_1000_CX:
+	case IFM_1000_T:
+#ifdef IFM_1000_KX
+	case IFM_1000_KX:
+#endif
+#ifdef IFM_1000_SGMII
+	case IFM_1000_SGMII:
+#endif
+		return 1000;
+#ifdef IFM_2500_T
+	case IFM_2500_T:
+#endif
+#ifdef IFM_2500_X
+	case IFM_2500_X:
+#endif
+#ifdef IFM_2500_KX
+	case IFM_2500_KX:
+#endif
+		return 2500;
+#ifdef IFM_5000_T
+	case IFM_5000_T:
+#endif
+#ifdef IFM_5000_KR
+	case IFM_5000_KR:
+#endif
+		return 5000;
+	case IFM_10G_LR:
+	case IFM_10G_SR:
+	case IFM_10G_CX4:
+	case IFM_10G_T:
+	case IFM_10G_TWINAX:
+	case IFM_10G_TWINAX_LONG:
+	case IFM_10G_LRM:
+	case IFM_10G_KX4:
+	case IFM_10G_KR:
+	case IFM_10G_CR1:
+	case IFM_10G_ER:
+	case IFM_10G_SFI:
+		return 10000;
+#ifdef IFM_20G_KR2
+	case IFM_20G_KR2:
+#endif
+		return 20000;
+	case IFM_25G_CR:
+	case IFM_25G_KR:
+	case IFM_25G_SR:
+	case IFM_25G_LR:
+#ifdef IFM_25G_ACC
+	case IFM_25G_ACC:
+#endif
+#ifdef IFM_25G_AOC
+	case IFM_25G_AOC:
+#endif
+#ifdef IFM_25G_ER
+	case IFM_25G_ER:
+#endif
+#ifdef IFM_25G_T
+	case IFM_25G_T:
+#endif
+		return 25000;
+	case IFM_40G_CR4:
+	case IFM_40G_SR4:
+	case IFM_40G_LR4:
+	case IFM_40G_KR4:
+#ifdef IFM_40G_ER4
+	case IFM_40G_ER4:
+#endif
+		return 40000;
+	case IFM_50G_CR2:
+	case IFM_50G_KR2:
+#ifdef IFM_50G_SR2
+	case IFM_50G_SR2:
+#endif
+#ifdef IFM_50G_LR2
+	case IFM_50G_LR2:
+#endif
+#ifdef IFM_50G_KR
+	case IFM_50G_KR:
+#endif
+#ifdef IFM_50G_SR
+	case IFM_50G_SR:
+#endif
+#ifdef IFM_50G_CR
+	case IFM_50G_CR:
+#endif
+#ifdef IFM_50G_LR
+	case IFM_50G_LR:
+#endif
+#ifdef IFM_50G_FR
+	case IFM_50G_FR:
+#endif
+		return 50000;
+	case IFM_100G_CR4:
+	case IFM_100G_SR4:
+	case IFM_100G_KR4:
+	case IFM_100G_LR4:
+#ifdef IFM_100G_CR2
+	case IFM_100G_CR2:
+#endif
+#ifdef IFM_100G_SR2
+	case IFM_100G_SR2:
+#endif
+#ifdef IFM_100G_KR2
+	case IFM_100G_KR2:
+#endif
+#ifdef IFM_100G_DR
+	case IFM_100G_DR:
+#endif
+#ifdef IFM_100G_FR
+	case IFM_100G_FR:
+#endif
+#ifdef IFM_100G_LR
+	case IFM_100G_LR:
+#endif
+		return 100000;
+#ifdef IFM_200G_CR4
+	case IFM_200G_CR4:
+#endif
+#ifdef IFM_200G_SR4
+	case IFM_200G_SR4:
+#endif
+#ifdef IFM_200G_KR4
+	case IFM_200G_KR4:
+#endif
+#ifdef IFM_200G_LR4
+	case IFM_200G_LR4:
+#endif
+#ifdef IFM_200G_FR4
+	case IFM_200G_FR4:
+#endif
+#ifdef IFM_200G_DR4
+	case IFM_200G_DR4:
+#endif
+		return 200000;
+#ifdef IFM_400G_CR8
+	case IFM_400G_CR8:
+#endif
+#ifdef IFM_400G_SR8
+	case IFM_400G_SR8:
+#endif
+#ifdef IFM_400G_KR8
+	case IFM_400G_KR8:
+#endif
+#ifdef IFM_400G_LR8
+	case IFM_400G_LR8:
+#endif
+#ifdef IFM_400G_FR8
+	case IFM_400G_FR8:
+#endif
+#ifdef IFM_400G_DR8
+	case IFM_400G_DR8:
+#endif
+#ifdef IFM_400G_CR4
+	case IFM_400G_CR4:
+#endif
+#ifdef IFM_400G_SR4
+	case IFM_400G_SR4:
+#endif
+#ifdef IFM_400G_DR4
+	case IFM_400G_DR4:
+#endif
+#ifdef IFM_400G_FR4
+	case IFM_400G_FR4:
+#endif
+#ifdef IFM_400G_LR4
+	case IFM_400G_LR4:
+#endif
+		return 400000;
+#ifdef IFM_800G_CR8
+	case IFM_800G_CR8:
+#endif
+#ifdef IFM_800G_SR8
+	case IFM_800G_SR8:
+#endif
+#ifdef IFM_800G_DR8
+	case IFM_800G_DR8:
+#endif
+#ifdef IFM_800G_FR8
+	case IFM_800G_FR8:
+#endif
+#ifdef IFM_800G_LR8
+	case IFM_800G_LR8:
+#endif
+		return 800000;
+	default:
+		return 0;
+	}
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifmediareq ifmr;
+	struct ifreq ifr;
+	int if_fd;
+	int subtype;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine administrative status */
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		if (ifr.ifr_flags & IFF_UP)
+			link->link_status = 1;
+	}
+
+	/* Get media status for speed, duplex, and link state */
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(if_fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* Check if link is actually active */
+		if (!(ifmr.ifm_status & IFM_ACTIVE))
+			link->link_status = 0;
+
+		/* Only parse media if we have a valid current media type */
+		if (ifmr.ifm_current != 0 && IFM_TYPE(ifmr.ifm_current) == IFM_ETHER) {
+			subtype = IFM_SUBTYPE(ifmr.ifm_current);
+			link->link_speed = media_subtype_to_speed(subtype);
+
+			/* Check duplex - FDX option means full duplex */
+			if (IFM_OPTIONS(ifmr.ifm_current) & IFM_FDX)
+				link->link_duplex = 1;
+			else
+				link->link_duplex = 0;
+		} else {
+			/* Default to full duplex if we can't determine */
+			link->link_duplex = 1;
+		}
+
+		/* Check autonegotiation status */
+		link->link_autoneg = (ifmr.ifm_current & IFM_AUTO) ? 1 : 0;
+	} else {
+		/*
+		 * SIOCGIFMEDIA failed - interface may not support it.
+		 * Default to reasonable values.
+		 */
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..036c685b50 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -9,6 +9,8 @@
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include <rte_string_fns.h>
 
@@ -40,3 +42,110 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+/*
+ * Get link speed, duplex, and autoneg using ETHTOOL_GLINKSETTINGS.
+ *
+ * ETHTOOL_GLINKSETTINGS was introduced in kernel 4.7 and supports
+ * speeds beyond 65535 Mbps (up to 800 Gbps and beyond).
+ * DPDK requires kernel 4.19 or later, so this interface is always available.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+get_link_settings(int fd, struct ifreq *ifr, struct osdep_iface_link *link)
+{
+	struct ethtool_link_settings *req;
+	int nwords;
+
+	/* First call with nwords = 0 to get the required size */
+	req = alloca(sizeof(*req));
+	memset(req, 0, sizeof(*req));
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Kernel returns negative nwords on first call */
+	if (req->link_mode_masks_nwords >= 0)
+		return -1;
+
+	nwords = -req->link_mode_masks_nwords;
+
+	/* Bounds check */
+	if (nwords == 0 || nwords > 127)
+		return -1;
+
+	/* Second call with correct nwords - need space for 3 link mode masks */
+	req = alloca(sizeof(*req) + 3 * nwords * sizeof(uint32_t));
+	memset(req, 0, sizeof(*req));
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	req->link_mode_masks_nwords = nwords;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Speed is in Mbps, directly usable */
+	link->link_speed = req->speed;
+
+	/* Handle special values */
+	if (link->link_speed == (uint32_t)SPEED_UNKNOWN ||
+	    link->link_speed == (uint32_t)-1)
+		link->link_speed = 0;
+
+	switch (req->duplex) {
+	case DUPLEX_FULL:
+		link->link_duplex = 1;
+		break;
+	case DUPLEX_HALF:
+		link->link_duplex = 0;
+		break;
+	default:
+		link->link_duplex = 1;  /* Default to full duplex */
+		break;
+	}
+
+	link->link_autoneg = (req->autoneg == AUTONEG_ENABLE) ? 1 : 0;
+	return 0;
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifreq ifr;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine link status */
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up
+		 * IFF_RUNNING means operationally up (carrier detected)
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			link->link_status = 1;
+	}
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (get_link_settings(if_fd, &ifr, link) < 0) {
+		/*
+		 * ethtool failed - interface may not support it
+		 * (e.g., virtual interfaces like veth, lo).
+		 * Use reasonable defaults.
+		 */
+		link->link_speed = 0;
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..1b76ae3185 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,56 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_get(const char *device_name, struct osdep_iface_link *link)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	memset(link, 0, sizeof(*link));
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			/* Check operational status */
+			if (cur->OperStatus == IfOperStatusUp)
+				link->link_status = 1;
+			else
+				link->link_status = 0;
+
+			/*
+			 * TransmitLinkSpeed and ReceiveLinkSpeed are in bits/sec.
+			 * Convert to Mbps. Use transmit speed as the link speed.
+			 * For asymmetric links, this is a reasonable approximation.
+			 */
+			if (cur->TransmitLinkSpeed != 0 &&
+			    cur->TransmitLinkSpeed != (ULONG64)-1) {
+				link->link_speed =
+					(uint32_t)(cur->TransmitLinkSpeed / 1000000ULL);
+			}
+
+			/*
+			 * Windows doesn't directly expose duplex/autoneg via
+			 * GetAdaptersAddresses(). Default to full duplex.
+			 * For more detailed info, WMI or OID queries would be needed.
+			 */
+			link->link_duplex = 1;  /* Assume full duplex */
+			link->link_autoneg = 0; /* Cannot determine */
+
+			ret = 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v8 10/14] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Defer timestamp dynfield registration from probe to device start,
  and only when timestamp offloading is enabled
* Add read_clock dev_op returning current UTC time
  for timestamp correlation
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper
* Enable immediate mode and improve error reporting
  in live capture setup

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 130 +++++++++++++++++++------
 2 files changed, 102 insertions(+), 30 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 3d25626adb..de1302ef06 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -60,6 +60,8 @@ New Features
   * Changed transmit burst to always return the number of packets requested.
     Failed sends are counted as transmit errors.
   * Added support for VLAN insertion and stripping.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f8ccc03d6f..2aec737088 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -27,12 +27,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -76,6 +75,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -104,6 +104,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -331,10 +332,20 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * Although time stamp in struct pcap_pkthdr is defined as struct timeval,
+			 * it really is a timespec with nanosecond resolution.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -354,14 +365,13 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
  * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
  * because `ts` goes directly to nanosecond-precision dump.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -412,6 +422,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
@@ -422,8 +435,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 				continue;
 		}
 
-		calculate_timestamp(&header.ts);
-
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		header.len = len;
 		header.caplen = len;
@@ -528,22 +539,60 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
+
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -590,7 +639,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -627,6 +677,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
 
+	if (internals->timestamp_offloading) {
+		int ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							     &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+	}
+
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
@@ -749,6 +808,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -766,7 +826,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -1000,6 +1061,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1110,12 +1172,24 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.rx_queue_start = eth_rx_queue_start,
@@ -1529,15 +1603,11 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
-
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
+		hz = rte_get_timer_hz();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v8 11/14] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2aec737088..8eb6356794 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -46,11 +46,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -541,6 +539,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -639,6 +638,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1413,6 +1414,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v8 12/14] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 8eb6356794..6380d76110 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -54,10 +54,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -838,11 +838,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v8 13/14] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 6380d76110..a8e8a3e241 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -821,7 +821,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-- 
2.51.0

[PATCH v8 14/14] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, vlan handling and multiple queues

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2337 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 2340 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index f4d04a6e42..90e3afaecf 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..8c5d5d76e4
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,2337 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * This test needs OS network interfaces and
+ * managing that would require more changes on Windows.
+ */
+static int
+test_pmd_pcap(void)
+{
+	printf("PCAP test not supported on Windows, skipping test\n");
+	return TEST_SKIPPED;
+}
+
+#else
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+/*
+ * Helper: Create a unique temporary file path
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u with VLAN strip: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if network interface exists
+ */
+static int
+iface_exists(const char *name)
+{
+	struct ifreq ifr;
+	int sock, ret;
+
+	sock = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sock < 0)
+		return 0;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, name, IFNAMSIZ);
+	ret = ioctl(sock, SIOCGIFINDEX, &ifr);
+	close(sock);
+	return ret == 0;
+}
+
+/*
+ * Helper: Find a usable test interface
+ *
+ * Prefers discard interfaces (dummy0 on Linux, edsc0 on FreeBSD)
+ * over loopback to avoid actual packet transmission.
+ */
+static const char *
+find_test_iface(void)
+{
+	/* Linux dummy interface */
+	if (iface_exists("dummy0"))
+		return "dummy0";
+	/* FreeBSD epair discard interface */
+	if (iface_exists("edsc0"))
+		return "edsc0";
+	/* Fallback to loopback */
+	if (iface_exists("lo"))
+		return "lo";
+	/* FreeBSD loopback */
+	if (iface_exists("lo0"))
+		return "lo0";
+	return NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	unlink(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	unlink(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			unlink(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	unlink(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. min_mtu and max_mtu are set to reasonable values
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    min_mtu: %u\n", dev_info.min_mtu);
+	printf("    max_mtu: %u\n", dev_info.max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		unlink(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		unlink(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	if (tx_pcap_path[0] != '\0')
+		unlink(tx_pcap_path);
+	if (rx_pcap_path[0] != '\0')
+		unlink(rx_pcap_path);
+	if (infinite_pcap_path[0] != '\0')
+		unlink(infinite_pcap_path);
+	if (timestamp_pcap_path[0] != '\0')
+		unlink(timestamp_pcap_path);
+	if (varied_pcap_path[0] != '\0')
+		unlink(varied_pcap_path);
+	if (jumbo_pcap_path[0] != '\0')
+		unlink(jumbo_pcap_path);
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++) {
+		if (multi_tx_pcap_paths[i][0] != '\0')
+			unlink(multi_tx_pcap_paths[i]);
+	}
+	if (multi_rx_pcap_path[0] != '\0')
+		unlink(multi_rx_pcap_path);
+	if (vlan_rx_pcap_path[0] != '\0')
+		unlink(vlan_rx_pcap_path);
+	if (vlan_tx_pcap_path[0] != '\0')
+		unlink(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+#endif
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index de1302ef06..ddcb693166 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -62,6 +62,7 @@ New Features
   * Added support for VLAN insertion and stripping.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v9 00/15] net/pcap: improvements and test suite

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx and stripping on Rx
  - Nanosecond precision timestamps (when hardware/libpcap supports it)
  - Accurate link state, speed, and duplex reporting in interface mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snapshot_len devarg

Bug fixes:
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Change Tx burst to always consume all packets; failed sends
    increment error counter rather than leaving mbufs for retry
    (pcap_sendpacket failures are not transient)

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables
  - Defer pcap handle opening until device start

Testing:
  - Add comprehensive unit test suite covering basic operations,
    timestamps, jumbo frames, VLAN handling, multi-queue, and more

v9:
  - Add configurable snapshot length parameter (snapshot_len devarg)
  - Defer opening of pcap files and interfaces until eth_dev_start()
    instead of during probe, passing configured snapshot length

v8:
  - Fix pcap header length in VLAN transmit
  - Fix clang warnings from ethtool link_mode array

v7:
  - Drop MTU configuration patch; not necessary as underlying OS
    commands (ip link, ifconfig) can be used directly
  - Add patch to remove unnecessary volatile on queue statistics
  - Add test_link_status to unit test suite
  - Add Acked-by from Marat Khalili on patch 11

Stephen Hemminger (15):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: improve multi-segment transmit handling
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN insert and strip
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  test: add test for pcap PMD
  net/pcap: add snapshot length devarg

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2525 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    8 +
 doc/guides/nics/pcap_ring.rst          |   17 +
 doc/guides/rel_notes/release_26_03.rst |   10 +
 drivers/net/pcap/pcap_ethdev.c         |  608 ++++--
 drivers/net/pcap/pcap_osdep.h          |   23 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |  289 ++-
 drivers/net/pcap/pcap_osdep_linux.c    |  115 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   95 +-
 11 files changed, 3468 insertions(+), 225 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v9 01/15] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 5683b87e4a..28a3269568 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap_ring.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v9 02/15] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v9 03/15] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 8 ++++++++
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..d09ba5abe9 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,24 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v9 04/15] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index d09ba5abe9..0177cbc7df 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1221,9 +1221,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1591,10 +1590,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v9 05/15] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  2 +-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 0177cbc7df..2e41ad35ed 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1289,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v9 06/15] net/pcap: improve multi-segment transmit handling

[Stephen Hemminger]

Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability in device info. The
driver already handles multi-segment mbufs but was not reporting this.

Replace the fixed-size stack buffer (up to 9K) with dynamic allocation
only when the mbuf is non-contiguous. This avoids large stack usage and
removes the silent truncation that occurred when packets exceeded the
buffer size.

Change transmit functions to always consume and free all packets,
returning nb_pkts regardless of send success. The DPDK transmit API
interprets a return value less than requested as "queue full, retry
later." However, pcap_sendpacket() failures (bad parameters or socket
errors) are not transient and retrying would fail again. The correct
behavior is to free failed packets and increment the error counter
rather than leaving mbufs for the application to retry.

Also use rte_pktmbuf_free_bulk() for more efficient buffer freeing.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   5 ++
 drivers/net/pcap/pcap_ethdev.c         | 105 ++++++++++++-------------
 2 files changed, 55 insertions(+), 55 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 15dabee7a1..76d81ac524 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -55,6 +55,11 @@ New Features
      Also, make sure to start the actual text at the margin.
      =======================================================
 
+* **Updated PCAP ethernet driver.**
+
+  * Changed transmit burst to always return the number of packets requested.
+    Failed sends are counted as transmit errors.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2e41ad35ed..93b3fe229d 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -30,7 +30,6 @@
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
 #define RTE_ETH_PCAP_PROMISC 1
 #define RTE_ETH_PCAP_TIMEOUT -1
 
@@ -378,6 +377,21 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+/* Like rte_pktmbuf_read() but allocate if needed */
+static inline const void *
+pcap_pktmbuf_read(const struct rte_mbuf *m,
+		  uint32_t off, uint32_t len, void **buf)
+{
+	if (likely(off + len <= rte_pktmbuf_data_len(m)))
+		return rte_pktmbuf_mtod_offset(m, char *, off);
+
+	*buf = malloc(len);
+	if (likely(*buf != NULL))
+		return rte_pktmbuf_read(m, off, len, *buf);
+	else
+		return NULL;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -385,46 +399,40 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	pcap_dumper_t *dumper;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
-		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+		header.caplen = len;
 
-		num_tx++;
-		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (likely(data != NULL)) {
+			pcap_dump((u_char *)dumper, &header, data);
+
+			num_tx++;
+			tx_bytes += len;
+		}
+		free(temp);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -452,15 +460,15 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(nb_pkts == 0))
 		return 0;
 
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -470,15 +478,11 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
@@ -487,35 +491,25 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
-			continue;
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		void *temp = NULL;
+		const uint8_t *data;
+
+		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		if (likely(data != NULL &&
+		    pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
 		}
-
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
+	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -753,6 +747,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v9 07/15] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 67 +++++++++++++++-------------------
 1 file changed, 29 insertions(+), 38 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 93b3fe229d..63a4f92c9c 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -98,9 +99,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -110,25 +111,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -866,7 +867,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1175,29 +1176,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1473,7 +1464,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1512,9 +1503,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
-- 
2.51.0

[PATCH v9 08/15] net/pcap: support VLAN insert and strip

[Stephen Hemminger]

Driver can easily insert VLAN tag strip and insertion similar
to how it is handled in virtio and af_packet.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 38 ++++++++++++++++++++++----
 3 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..814bc2119f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 76d81ac524..3d25626adb 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -59,6 +59,7 @@ New Features
 
   * Changed transmit burst to always return the number of packets requested.
     Failed sends are counted as transmit errors.
+  * Added support for VLAN insertion and stripping.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 63a4f92c9c..47211807a7 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -75,6 +75,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -102,6 +103,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -332,6 +334,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -416,15 +422,21 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
-		void *temp = NULL;
-		const uint8_t *data;
+
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
 
 		calculate_timestamp(&header.ts);
+
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		header.len = len;
 		header.caplen = len;
 
-		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		void *temp = NULL;
+		const uint8_t *data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
 		if (likely(data != NULL)) {
 			pcap_dump((u_char *)dumper, &header, data);
 
@@ -497,6 +509,12 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		void *temp = NULL;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
 		if (likely(data != NULL &&
 		    pcap_sendpacket(pcap, data, len) == 0)) {
@@ -731,8 +749,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -748,7 +771,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -895,6 +920,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
-- 
2.51.0

[PATCH v9 09/15] net/pcap: add link state and speed for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent functions to query the real link state, speed,
duplex, and autonegotiation settings from the underlying interface.
The eth_link_update() callback now returns accurate information
when operating in pass-through mode.

Linux uses ETHTOOL_GLINKSETTINGS which supports all speeds up to
800 Gbps. FreeBSD uses SIOCGIFMEDIA, and Windows uses
GetAdaptersAddresses().

For pcap file mode or separate rx/tx interface configurations,
default values continue to be used since there is no single
underlying interface to query.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        | 105 +++++++++-
 drivers/net/pcap/pcap_osdep.h         |  22 ++
 drivers/net/pcap/pcap_osdep_freebsd.c | 277 ++++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c   | 109 ++++++++++
 drivers/net/pcap/pcap_osdep_windows.c |  95 +++++++--
 5 files changed, 585 insertions(+), 23 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 47211807a7..f8ccc03d6f 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -146,13 +146,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -899,11 +892,96 @@ eth_dev_close(struct rte_eth_dev *dev)
 	return 0;
 }
 
+/*
+ * Convert osdep speed (Mbps) to rte_eth_link speed constant.
+ */
+static uint32_t
+speed_mbps_to_rte(uint32_t speed_mbps)
+{
+	switch (speed_mbps) {
+	case 10:
+		return RTE_ETH_SPEED_NUM_10M;
+	case 100:
+		return RTE_ETH_SPEED_NUM_100M;
+	case 1000:
+		return RTE_ETH_SPEED_NUM_1G;
+	case 2500:
+		return RTE_ETH_SPEED_NUM_2_5G;
+	case 5000:
+		return RTE_ETH_SPEED_NUM_5G;
+	case 10000:
+		return RTE_ETH_SPEED_NUM_10G;
+	case 20000:
+		return RTE_ETH_SPEED_NUM_20G;
+	case 25000:
+		return RTE_ETH_SPEED_NUM_25G;
+	case 40000:
+		return RTE_ETH_SPEED_NUM_40G;
+	case 50000:
+		return RTE_ETH_SPEED_NUM_50G;
+	case 56000:
+		return RTE_ETH_SPEED_NUM_56G;
+	case 100000:
+		return RTE_ETH_SPEED_NUM_100G;
+	case 200000:
+		return RTE_ETH_SPEED_NUM_200G;
+	case 400000:
+		return RTE_ETH_SPEED_NUM_400G;
+	case 800000:
+		return RTE_ETH_SPEED_NUM_800G;
+	default:
+		/* For unknown speeds, return the raw value */
+		if (speed_mbps > 0)
+			return speed_mbps;
+		return RTE_ETH_SPEED_NUM_UNKNOWN;
+	}
+}
+
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link link;
+	struct osdep_iface_link osdep_link;
+	const char *iface_name;
+
+	memset(&link, 0, sizeof(link));
+
+	/*
+	 * For pass-through mode (single_iface), query the actual interface.
+	 * Otherwise, use the default static link values.
+	 */
+	if (internals->single_iface) {
+		iface_name = internals->rx_queue[0].name;
+
+		if (osdep_iface_link_get(iface_name, &osdep_link) == 0) {
+			link.link_speed = speed_mbps_to_rte(osdep_link.link_speed);
+			link.link_status = osdep_link.link_status ?
+				RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+			link.link_duplex = osdep_link.link_duplex ?
+				RTE_ETH_LINK_FULL_DUPLEX : RTE_ETH_LINK_HALF_DUPLEX;
+			link.link_autoneg = osdep_link.link_autoneg ?
+				RTE_ETH_LINK_AUTONEG : RTE_ETH_LINK_FIXED;
+		} else {
+			/* Query failed, use defaults */
+			link.link_speed = RTE_ETH_SPEED_NUM_10G;
+			link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+			link.link_status = RTE_ETH_LINK_DOWN;
+			link.link_autoneg = RTE_ETH_LINK_FIXED;
+		}
+	} else {
+		/*
+		 * Not in pass-through mode (using pcap files or separate
+		 * interfaces for rx/tx). Use default values.
+		 */
+		link.link_speed = RTE_ETH_SPEED_NUM_10G;
+		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_autoneg = RTE_ETH_LINK_FIXED;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1268,7 +1346,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..732813c028 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,7 +13,29 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+/**
+ * Link information returned by osdep_iface_link_get().
+ */
+struct osdep_iface_link {
+	uint32_t link_speed;    /**< Speed in Mbps, 0 if unknown */
+	uint8_t link_status;    /**< 1 = up, 0 = down */
+	uint8_t link_duplex;    /**< 1 = full, 0 = half */
+	uint8_t link_autoneg;   /**< 1 = autoneg enabled, 0 = fixed */
+};
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link state and speed for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @param link
+ *   Pointer to structure to fill with link information.
+ * @return
+ *   0 on success, -1 on failure.
+ */
+int osdep_iface_link_get(const char *name, struct osdep_iface_link *link);
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..1405f1f85d 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,8 +5,13 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
@@ -55,3 +60,275 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+/*
+ * Map media subtype to speed in Mbps.
+ * This handles common Ethernet media types.
+ */
+static uint32_t
+media_subtype_to_speed(int subtype)
+{
+	switch (subtype) {
+	case IFM_10_T:
+	case IFM_10_2:
+	case IFM_10_5:
+	case IFM_10_STP:
+	case IFM_10_FL:
+		return 10;
+	case IFM_100_TX:
+	case IFM_100_FX:
+	case IFM_100_T4:
+	case IFM_100_VG:
+	case IFM_100_T2:
+		return 100;
+	case IFM_1000_SX:
+	case IFM_1000_LX:
+	case IFM_1000_CX:
+	case IFM_1000_T:
+#ifdef IFM_1000_KX
+	case IFM_1000_KX:
+#endif
+#ifdef IFM_1000_SGMII
+	case IFM_1000_SGMII:
+#endif
+		return 1000;
+#ifdef IFM_2500_T
+	case IFM_2500_T:
+#endif
+#ifdef IFM_2500_X
+	case IFM_2500_X:
+#endif
+#ifdef IFM_2500_KX
+	case IFM_2500_KX:
+#endif
+		return 2500;
+#ifdef IFM_5000_T
+	case IFM_5000_T:
+#endif
+#ifdef IFM_5000_KR
+	case IFM_5000_KR:
+#endif
+		return 5000;
+	case IFM_10G_LR:
+	case IFM_10G_SR:
+	case IFM_10G_CX4:
+	case IFM_10G_T:
+	case IFM_10G_TWINAX:
+	case IFM_10G_TWINAX_LONG:
+	case IFM_10G_LRM:
+	case IFM_10G_KX4:
+	case IFM_10G_KR:
+	case IFM_10G_CR1:
+	case IFM_10G_ER:
+	case IFM_10G_SFI:
+		return 10000;
+#ifdef IFM_20G_KR2
+	case IFM_20G_KR2:
+#endif
+		return 20000;
+	case IFM_25G_CR:
+	case IFM_25G_KR:
+	case IFM_25G_SR:
+	case IFM_25G_LR:
+#ifdef IFM_25G_ACC
+	case IFM_25G_ACC:
+#endif
+#ifdef IFM_25G_AOC
+	case IFM_25G_AOC:
+#endif
+#ifdef IFM_25G_ER
+	case IFM_25G_ER:
+#endif
+#ifdef IFM_25G_T
+	case IFM_25G_T:
+#endif
+		return 25000;
+	case IFM_40G_CR4:
+	case IFM_40G_SR4:
+	case IFM_40G_LR4:
+	case IFM_40G_KR4:
+#ifdef IFM_40G_ER4
+	case IFM_40G_ER4:
+#endif
+		return 40000;
+	case IFM_50G_CR2:
+	case IFM_50G_KR2:
+#ifdef IFM_50G_SR2
+	case IFM_50G_SR2:
+#endif
+#ifdef IFM_50G_LR2
+	case IFM_50G_LR2:
+#endif
+#ifdef IFM_50G_KR
+	case IFM_50G_KR:
+#endif
+#ifdef IFM_50G_SR
+	case IFM_50G_SR:
+#endif
+#ifdef IFM_50G_CR
+	case IFM_50G_CR:
+#endif
+#ifdef IFM_50G_LR
+	case IFM_50G_LR:
+#endif
+#ifdef IFM_50G_FR
+	case IFM_50G_FR:
+#endif
+		return 50000;
+	case IFM_100G_CR4:
+	case IFM_100G_SR4:
+	case IFM_100G_KR4:
+	case IFM_100G_LR4:
+#ifdef IFM_100G_CR2
+	case IFM_100G_CR2:
+#endif
+#ifdef IFM_100G_SR2
+	case IFM_100G_SR2:
+#endif
+#ifdef IFM_100G_KR2
+	case IFM_100G_KR2:
+#endif
+#ifdef IFM_100G_DR
+	case IFM_100G_DR:
+#endif
+#ifdef IFM_100G_FR
+	case IFM_100G_FR:
+#endif
+#ifdef IFM_100G_LR
+	case IFM_100G_LR:
+#endif
+		return 100000;
+#ifdef IFM_200G_CR4
+	case IFM_200G_CR4:
+#endif
+#ifdef IFM_200G_SR4
+	case IFM_200G_SR4:
+#endif
+#ifdef IFM_200G_KR4
+	case IFM_200G_KR4:
+#endif
+#ifdef IFM_200G_LR4
+	case IFM_200G_LR4:
+#endif
+#ifdef IFM_200G_FR4
+	case IFM_200G_FR4:
+#endif
+#ifdef IFM_200G_DR4
+	case IFM_200G_DR4:
+#endif
+		return 200000;
+#ifdef IFM_400G_CR8
+	case IFM_400G_CR8:
+#endif
+#ifdef IFM_400G_SR8
+	case IFM_400G_SR8:
+#endif
+#ifdef IFM_400G_KR8
+	case IFM_400G_KR8:
+#endif
+#ifdef IFM_400G_LR8
+	case IFM_400G_LR8:
+#endif
+#ifdef IFM_400G_FR8
+	case IFM_400G_FR8:
+#endif
+#ifdef IFM_400G_DR8
+	case IFM_400G_DR8:
+#endif
+#ifdef IFM_400G_CR4
+	case IFM_400G_CR4:
+#endif
+#ifdef IFM_400G_SR4
+	case IFM_400G_SR4:
+#endif
+#ifdef IFM_400G_DR4
+	case IFM_400G_DR4:
+#endif
+#ifdef IFM_400G_FR4
+	case IFM_400G_FR4:
+#endif
+#ifdef IFM_400G_LR4
+	case IFM_400G_LR4:
+#endif
+		return 400000;
+#ifdef IFM_800G_CR8
+	case IFM_800G_CR8:
+#endif
+#ifdef IFM_800G_SR8
+	case IFM_800G_SR8:
+#endif
+#ifdef IFM_800G_DR8
+	case IFM_800G_DR8:
+#endif
+#ifdef IFM_800G_FR8
+	case IFM_800G_FR8:
+#endif
+#ifdef IFM_800G_LR8
+	case IFM_800G_LR8:
+#endif
+		return 800000;
+	default:
+		return 0;
+	}
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifmediareq ifmr;
+	struct ifreq ifr;
+	int if_fd;
+	int subtype;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine administrative status */
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		if (ifr.ifr_flags & IFF_UP)
+			link->link_status = 1;
+	}
+
+	/* Get media status for speed, duplex, and link state */
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(if_fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* Check if link is actually active */
+		if (!(ifmr.ifm_status & IFM_ACTIVE))
+			link->link_status = 0;
+
+		/* Only parse media if we have a valid current media type */
+		if (ifmr.ifm_current != 0 && IFM_TYPE(ifmr.ifm_current) == IFM_ETHER) {
+			subtype = IFM_SUBTYPE(ifmr.ifm_current);
+			link->link_speed = media_subtype_to_speed(subtype);
+
+			/* Check duplex - FDX option means full duplex */
+			if (IFM_OPTIONS(ifmr.ifm_current) & IFM_FDX)
+				link->link_duplex = 1;
+			else
+				link->link_duplex = 0;
+		} else {
+			/* Default to full duplex if we can't determine */
+			link->link_duplex = 1;
+		}
+
+		/* Check autonegotiation status */
+		link->link_autoneg = (ifmr.ifm_current & IFM_AUTO) ? 1 : 0;
+	} else {
+		/*
+		 * SIOCGIFMEDIA failed - interface may not support it.
+		 * Default to reasonable values.
+		 */
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..036c685b50 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -9,6 +9,8 @@
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include <rte_string_fns.h>
 
@@ -40,3 +42,110 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+/*
+ * Get link speed, duplex, and autoneg using ETHTOOL_GLINKSETTINGS.
+ *
+ * ETHTOOL_GLINKSETTINGS was introduced in kernel 4.7 and supports
+ * speeds beyond 65535 Mbps (up to 800 Gbps and beyond).
+ * DPDK requires kernel 4.19 or later, so this interface is always available.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+get_link_settings(int fd, struct ifreq *ifr, struct osdep_iface_link *link)
+{
+	struct ethtool_link_settings *req;
+	int nwords;
+
+	/* First call with nwords = 0 to get the required size */
+	req = alloca(sizeof(*req));
+	memset(req, 0, sizeof(*req));
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Kernel returns negative nwords on first call */
+	if (req->link_mode_masks_nwords >= 0)
+		return -1;
+
+	nwords = -req->link_mode_masks_nwords;
+
+	/* Bounds check */
+	if (nwords == 0 || nwords > 127)
+		return -1;
+
+	/* Second call with correct nwords - need space for 3 link mode masks */
+	req = alloca(sizeof(*req) + 3 * nwords * sizeof(uint32_t));
+	memset(req, 0, sizeof(*req));
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	req->link_mode_masks_nwords = nwords;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Speed is in Mbps, directly usable */
+	link->link_speed = req->speed;
+
+	/* Handle special values */
+	if (link->link_speed == (uint32_t)SPEED_UNKNOWN ||
+	    link->link_speed == (uint32_t)-1)
+		link->link_speed = 0;
+
+	switch (req->duplex) {
+	case DUPLEX_FULL:
+		link->link_duplex = 1;
+		break;
+	case DUPLEX_HALF:
+		link->link_duplex = 0;
+		break;
+	default:
+		link->link_duplex = 1;  /* Default to full duplex */
+		break;
+	}
+
+	link->link_autoneg = (req->autoneg == AUTONEG_ENABLE) ? 1 : 0;
+	return 0;
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifreq ifr;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine link status */
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up
+		 * IFF_RUNNING means operationally up (carrier detected)
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			link->link_status = 1;
+	}
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (get_link_settings(if_fd, &ifr, link) < 0) {
+		/*
+		 * ethtool failed - interface may not support it
+		 * (e.g., virtual interfaces like veth, lo).
+		 * Use reasonable defaults.
+		 */
+		link->link_speed = 0;
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..1b76ae3185 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,56 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_get(const char *device_name, struct osdep_iface_link *link)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	memset(link, 0, sizeof(*link));
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			/* Check operational status */
+			if (cur->OperStatus == IfOperStatusUp)
+				link->link_status = 1;
+			else
+				link->link_status = 0;
+
+			/*
+			 * TransmitLinkSpeed and ReceiveLinkSpeed are in bits/sec.
+			 * Convert to Mbps. Use transmit speed as the link speed.
+			 * For asymmetric links, this is a reasonable approximation.
+			 */
+			if (cur->TransmitLinkSpeed != 0 &&
+			    cur->TransmitLinkSpeed != (ULONG64)-1) {
+				link->link_speed =
+					(uint32_t)(cur->TransmitLinkSpeed / 1000000ULL);
+			}
+
+			/*
+			 * Windows doesn't directly expose duplex/autoneg via
+			 * GetAdaptersAddresses(). Default to full duplex.
+			 * For more detailed info, WMI or OID queries would be needed.
+			 */
+			link->link_duplex = 1;  /* Assume full duplex */
+			link->link_autoneg = 0; /* Cannot determine */
+
+			ret = 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v9 10/15] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Defer timestamp dynfield registration from probe to device start,
  and only when timestamp offloading is enabled
* Add read_clock dev_op returning current UTC time
  for timestamp correlation
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper
* Enable immediate mode and improve error reporting
  in live capture setup

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 130 +++++++++++++++++++------
 2 files changed, 102 insertions(+), 30 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 3d25626adb..de1302ef06 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -60,6 +60,8 @@ New Features
   * Changed transmit burst to always return the number of packets requested.
     Failed sends are counted as transmit errors.
   * Added support for VLAN insertion and stripping.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f8ccc03d6f..2aec737088 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -27,12 +27,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -76,6 +75,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -104,6 +104,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -331,10 +332,20 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * Although time stamp in struct pcap_pkthdr is defined as struct timeval,
+			 * it really is a timespec with nanosecond resolution.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -354,14 +365,13 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
  * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
  * because `ts` goes directly to nanosecond-precision dump.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -412,6 +422,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (unlikely(dumper == NULL || nb_pkts == 0))
 		return 0;
 
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
@@ -422,8 +435,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 				continue;
 		}
 
-		calculate_timestamp(&header.ts);
-
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		header.len = len;
 		header.caplen = len;
@@ -528,22 +539,60 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
+
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -590,7 +639,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -627,6 +677,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
 
+	if (internals->timestamp_offloading) {
+		int ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							     &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+	}
+
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
@@ -749,6 +808,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -766,7 +826,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -1000,6 +1061,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1110,12 +1172,24 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.rx_queue_start = eth_rx_queue_start,
@@ -1529,15 +1603,11 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
-
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
+		hz = rte_get_timer_hz();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v9 11/15] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2aec737088..8eb6356794 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -46,11 +46,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -541,6 +539,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -639,6 +638,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1413,6 +1414,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v9 12/15] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 8eb6356794..6380d76110 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -54,10 +54,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -838,11 +838,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v9 13/15] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 6380d76110..cc72f7f657 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -821,10 +821,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v9 14/15] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, vlan handling and multiple queues

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2337 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 2340 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index f4d04a6e42..90e3afaecf 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..8c5d5d76e4
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,2337 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * This test needs OS network interfaces and
+ * managing that would require more changes on Windows.
+ */
+static int
+test_pmd_pcap(void)
+{
+	printf("PCAP test not supported on Windows, skipping test\n");
+	return TEST_SKIPPED;
+}
+
+#else
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+/*
+ * Helper: Create a unique temporary file path
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u with VLAN strip: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if network interface exists
+ */
+static int
+iface_exists(const char *name)
+{
+	struct ifreq ifr;
+	int sock, ret;
+
+	sock = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sock < 0)
+		return 0;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, name, IFNAMSIZ);
+	ret = ioctl(sock, SIOCGIFINDEX, &ifr);
+	close(sock);
+	return ret == 0;
+}
+
+/*
+ * Helper: Find a usable test interface
+ *
+ * Prefers discard interfaces (dummy0 on Linux, edsc0 on FreeBSD)
+ * over loopback to avoid actual packet transmission.
+ */
+static const char *
+find_test_iface(void)
+{
+	/* Linux dummy interface */
+	if (iface_exists("dummy0"))
+		return "dummy0";
+	/* FreeBSD epair discard interface */
+	if (iface_exists("edsc0"))
+		return "edsc0";
+	/* Fallback to loopback */
+	if (iface_exists("lo"))
+		return "lo";
+	/* FreeBSD loopback */
+	if (iface_exists("lo0"))
+		return "lo0";
+	return NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	unlink(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	unlink(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			unlink(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	unlink(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. min_mtu and max_mtu are set to reasonable values
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    min_mtu: %u\n", dev_info.min_mtu);
+	printf("    max_mtu: %u\n", dev_info.max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		unlink(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		unlink(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	if (tx_pcap_path[0] != '\0')
+		unlink(tx_pcap_path);
+	if (rx_pcap_path[0] != '\0')
+		unlink(rx_pcap_path);
+	if (infinite_pcap_path[0] != '\0')
+		unlink(infinite_pcap_path);
+	if (timestamp_pcap_path[0] != '\0')
+		unlink(timestamp_pcap_path);
+	if (varied_pcap_path[0] != '\0')
+		unlink(varied_pcap_path);
+	if (jumbo_pcap_path[0] != '\0')
+		unlink(jumbo_pcap_path);
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++) {
+		if (multi_tx_pcap_paths[i][0] != '\0')
+			unlink(multi_tx_pcap_paths[i]);
+	}
+	if (multi_rx_pcap_path[0] != '\0')
+		unlink(multi_rx_pcap_path);
+	if (vlan_rx_pcap_path[0] != '\0')
+		unlink(vlan_rx_pcap_path);
+	if (vlan_tx_pcap_path[0] != '\0')
+		unlink(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+#endif
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index de1302ef06..ddcb693166 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -62,6 +62,7 @@ New Features
   * Added support for VLAN insertion and stripping.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v9 15/15] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

Example usage:
  --vdev 'net_pcap0,iface=eth0,snaplen=1518'
  --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/test_pmd_pcap.c               | 194 ++++++++++++++++++++++++-
 doc/guides/nics/pcap_ring.rst          |  17 +++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 165 ++++++++++++---------
 4 files changed, 306 insertions(+), 71 deletions(-)

diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
index 8c5d5d76e4..86ec6165f3 100644
--- a/app/test/test_pmd_pcap.c
+++ b/app/test/test_pmd_pcap.c
@@ -447,6 +447,41 @@ get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
 	return count;
 }
 
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
 /*
  * Helper: Configure and start a pcap ethdev port
  */
@@ -1973,7 +2008,7 @@ test_multi_rx_queue_same_file(void)
  * This test verifies that rte_eth_dev_info_get() returns correct values:
  * 1. max_rx_queues matches the number of rx_pcap files passed
  * 2. max_tx_queues matches the number of tx_pcap files passed
- * 3. min_mtu and max_mtu are set to reasonable values
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
  */
 static int
 test_dev_info(void)
@@ -1985,6 +2020,9 @@ test_dev_info(void)
 	uint16_t port_id;
 	int ret;
 	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
 
 	printf("Testing device info reporting\n");
 
@@ -2023,8 +2061,8 @@ test_dev_info(void)
 	printf("    driver_name: %s\n", dev_info.driver_name);
 	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
 	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
-	printf("    min_mtu: %u\n", dev_info.min_mtu);
-	printf("    max_mtu: %u\n", dev_info.max_mtu);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
 
 	/* Verify queue counts match number of pcap files */
 	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
@@ -2032,6 +2070,16 @@ test_dev_info(void)
 	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
 			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
 
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
 	rte_vdev_uninit("net_pcap_devinfo");
 
 	/* Cleanup temp files */
@@ -2044,6 +2092,144 @@ test_dev_info(void)
 	return TEST_SUCCESS;
 }
 
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	unlink(rx_path);
+	unlink(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	unlink(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
 /*
  * Test: VLAN Strip on RX
  *
@@ -2322,6 +2508,8 @@ static struct unit_test_suite test_pmd_pcap_suite = {
 		TEST_CASE(test_vlan_strip_rx),
 		TEST_CASE(test_vlan_insert_tx),
 		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
 		TEST_CASES_END()
 	}
 };
diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index 6955e91130..f01107841d 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -94,6 +94,23 @@ The different stream types are:
 
         iface=eth0
 
+*   snaplen: Set snapshot length (maximum capture size)
+
+    The snapshot length limits the maximum size of captured packets. This can be
+    set with the ``snaplen`` devarg, for example::
+
+        snaplen=1518
+
+    This sets the snapshot length to 1518 bytes. The value affects the reported
+    ``max_rx_pktlen`` and ``max_mtu`` in device info. The default value is 65535
+    bytes, matching the default pcap snapshot length.
+
+    When capturing from interfaces, this limits the amount of data captured per
+    packet. For pcap file output, packets larger than the snapshot length are
+    truncated: only the first ``snaplen`` bytes are written, while the original
+    packet length is preserved in the pcap packet header.
+
+
 Runtime Config Options
 ^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index ddcb693166..edb39f2a37 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -60,6 +60,7 @@ New Features
   * Changed transmit burst to always return the number of packets requested.
     Failed sends are counted as transmit errors.
   * Added support for VLAN insertion and stripping.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
   * Added unit test suite.
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index cc72f7f657..82ead5f136 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -31,8 +31,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -41,6 +39,9 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -98,6 +99,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -125,6 +127,7 @@ struct pmd_devargs {
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -142,11 +145,16 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declaration */
+static inline int set_iface_direction(const char *iface, pcap_t *pcap,
+				      pcap_direction_t direction);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -406,25 +414,24 @@ pcap_pktmbuf_read(const struct rte_mbuf *m,
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
-	pcap_dumper_t *dumper;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	uint32_t snaplen = internals->snapshot_len;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-
-	if (unlikely(dumper == NULL || nb_pkts == 0))
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
 	calculate_timestamp(&header.ts);
 
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
-	for (i = 0; i < nb_pkts; i++) {
+	for (uint16_t i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
 
 		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
@@ -434,11 +441,12 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t caplen = RTE_MIN(len, snaplen);
 		header.len = len;
-		header.caplen = len;
+		header.caplen = caplen;
 
 		void *temp = NULL;
-		const uint8_t *data = pcap_pktmbuf_read(mbuf, 0, len, &temp);
+		const uint8_t *data = pcap_pktmbuf_read(mbuf, 0, caplen, &temp);
 		if (likely(data != NULL)) {
 			pcap_dump((u_char *)dumper, &header, data);
 
@@ -537,7 +545,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -564,7 +572,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -595,9 +603,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -606,7 +614,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -616,7 +625,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -677,6 +686,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	if (internals->timestamp_offloading) {
 		int ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
@@ -694,7 +704,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 		if (!pp->tx_pcap[0] &&
 			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -706,14 +716,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -728,9 +735,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -821,11 +833,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1242,41 +1254,32 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 }
 
 /*
- * Opens a pcap file for writing and stores a reference to it
- * for use it later on.
+ * Store TX pcap file configuration.
+ * The actual pcap dumper is opened in eth_dev_start().
  */
 static int
 open_tx_pcap(const char *key, const char *value, void *extra_args)
 {
 	const char *pcap_filename = value;
 	struct pmd_devargs *dumpers = extra_args;
-	pcap_dumper_t *dumper;
-
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
-		return -1;
 
-	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
-		pcap_dump_close(dumper);
+	if (add_queue(dumpers, pcap_filename, key, NULL, NULL) < 0)
 		return -1;
-	}
 
 	return 0;
 }
 
 /*
- * Opens an interface for reading and writing
+ * Store interface configuration for reading and writing.
+ * The actual pcap handle is opened in eth_dev_start().
  */
 static inline int
 open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *tx = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
-		return -1;
-
-	tx->queue[0].pcap = pcap;
+	tx->queue[0].pcap = NULL;
 	tx->queue[0].name = iface;
 	tx->queue[0].type = key;
 
@@ -1298,42 +1301,30 @@ set_iface_direction(const char *iface, pcap_t *pcap,
 	return 0;
 }
 
+/*
+ * Store interface configuration.
+ * The actual pcap handle is opened in eth_dev_start().
+ */
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *pmd = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
-		return -1;
-	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
-		pcap_close(pcap);
+	if (add_queue(pmd, iface, key, NULL, NULL) < 0)
 		return -1;
-	}
 
 	return 0;
 }
 
 /*
- * Opens a NIC for reading packets from it
+ * Store RX interface configuration.
+ * The actual pcap handle is opened and direction set in eth_dev_start().
  */
 static inline int
 open_rx_iface(const char *key, const char *value, void *extra_args)
 {
-	int ret = open_iface(key, value, extra_args);
-	if (ret < 0)
-		return ret;
-	if (strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
-		struct pmd_devargs *pmd = extra_args;
-		unsigned int qid = pmd->num_of_queue - 1;
-
-		set_iface_direction(pmd->queue[qid].name,
-				pmd->queue[qid].pcap,
-				PCAP_D_IN);
-	}
-
-	return 0;
+	return open_iface(key, value, extra_args);
 }
 
 static inline int
@@ -1373,6 +1364,29 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' || val == 0 || val > UINT32_MAX) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1537,6 +1551,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1597,6 +1613,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1632,6 +1649,17 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 			return -1;
 	}
 
+	/*
+	 * Process optional snapshot length argument.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
 	/*
 	 * If iface argument is passed we open the NICs and use them for
 	 * reading / writing
@@ -1837,5 +1865,6 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_PHY_MAC_ARG "=<int> "
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v10 00/19] net/pcap: improvements and test suite

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx and stripping on Rx
  - Nanosecond precision timestamps (when hardware/libpcap supports it)
  - Accurate link state, speed, and duplex reporting in interface mode
  - Support for Windows interface mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snapshot_len devarg

Bug fixes:
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Change Tx burst to always consume all packets; failed sends
    increment error counter rather than leaving mbufs for retry
    (pcap_sendpacket failures are not transient)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables
  - Defer pcap handle opening until device start
  - Use bulk free for better Tx performance

Testing:
  - Add comprehensive unit test suite covering basic operations,
    timestamps, jumbo frames, VLAN handling, multi-queue, and more
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows

v10:
  - Split transmit handling into separate patches for bulk free,
    bounce buffer allocation, and cleanup for easier review
  - Add patch to reject non-Ethernet interfaces (fixes loopback
    issues on FreeBSD/macOS where DLT_NULL is used)
  - Test uses pcap_findalldevs() for portable interface discovery
    instead of hardcoded interface names

v9:
  - Add configurable snapshot length parameter (snapshot_len devarg)
  - Defer opening of pcap files and interfaces until eth_dev_start()
    instead of during probe, passing configured snapshot length

v8:
  - Fix pcap header length in VLAN transmit
  - Fix clang warnings from ethtool link_mode array

v7:
  - Drop MTU configuration patch; not necessary as underlying OS
    commands (ip link, ifconfig) can be used directly
  - Add patch to remove unnecessary volatile on queue statistics
  - Add test_link_status to unit test suite
  - Add Acked-by from Marat Khalili on patch 11

Stephen Hemminger (19):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: use bulk free
  net/pcap: allocate Tx bounce buffer
  net/pcap: cleanup transmit buffer handling
  net/pcap: report multi-segment transmit capability
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN insert and strip
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  net/pcap: add snapshot length devarg
  test: add test for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2622 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    8 +
 doc/guides/nics/pcap_ring.rst          |   27 +
 doc/guides/rel_notes/release_26_03.rst |    9 +
 drivers/net/pcap/pcap_ethdev.c         |  655 ++++--
 drivers/net/pcap/pcap_osdep.h          |   23 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   79 +-
 drivers/net/pcap/pcap_osdep_linux.c    |  115 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   95 +-
 11 files changed, 3398 insertions(+), 238 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v10 01/19] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 5683b87e4a..28a3269568 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap_ring.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v10 02/19] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v10 03/19] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v10 04/19] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..fbd1021c39 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v10 05/19] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd1021c39..806451dc99 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v10 06/19] net/pcap: use bulk free

[Stephen Hemminger]

Using function rte_pktmbuf_free_bulk is marginally faster here.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 806451dc99..61ba50e356 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -423,8 +423,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 		num_tx++;
 		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -449,13 +449,10 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
@@ -494,7 +491,6 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			PMD_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
 				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
 			continue;
 		}
 
@@ -508,9 +504,10 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			break;
 		num_tx++;
 		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
 	}
 
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
+
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
 	tx_queue->tx_stat.err_pkts += i - num_tx;
-- 
2.51.0

[PATCH v10 07/19] net/pcap: allocate Tx bounce buffer

[Stephen Hemminger]

To handle possible multi segment mbufs, the driver would allocate
a worst case 64k buffer on the stack. Since each Tx queue is
single threaded, better to allocate the buffer from hugepage
with rte_malloc when queue is setup.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 41 +++++++++++++++++++++-------------
 1 file changed, 26 insertions(+), 15 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 61ba50e356..1a186142d3 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -12,6 +12,7 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <unistd.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -91,6 +92,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used to for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -392,11 +396,12 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
+	unsigned char *temp_data;
 	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -406,10 +411,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	for (i = 0; i < nb_pkts; i++) {
 		mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
@@ -419,7 +420,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		 * a pointer to temp_data after copying into it.
 		 */
 		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+			  rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
 		num_tx++;
 		tx_bytes += caplen;
@@ -474,11 +475,12 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
+	unsigned char *temp_data;
 	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
@@ -486,13 +488,6 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	for (i = 0; i < nb_pkts; i++) {
 		mbuf = bufs[i];
 		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			continue;
-		}
 
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
@@ -962,7 +957,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -970,11 +965,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1015,6 +1025,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
-- 
2.51.0

[PATCH v10 08/19] net/pcap: cleanup transmit buffer handling

[Stephen Hemminger]

The transmit loops should handle the possible failure
of rte_pktmbuf_read(). If a pcap_sendpacket fails, then
the packet with error should be freed.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 50 ++++++++++++++--------------------
 1 file changed, 21 insertions(+), 29 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 1a186142d3..394fd0b6b2 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -389,7 +389,6 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
@@ -397,7 +396,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
 	unsigned char *temp_data;
-	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
@@ -409,21 +407,22 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len, caplen;
+		const uint8_t *data;
+
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			  rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
-		num_tx++;
-		tx_bytes += caplen;
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+		if (likely(data != NULL)) {
+			pcap_dump((u_char *)dumper, &header, data);
+			num_tx++;
+			tx_bytes += caplen;
+		}
 	}
 	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
@@ -458,7 +457,7 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -468,15 +467,12 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
 	unsigned char *temp_data;
-	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
@@ -486,19 +482,15 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		const uint8_t *data;
+
+		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		if (likely(data != NULL && pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
+		}
 	}
 
 	rte_pktmbuf_free_bulk(bufs, nb_pkts);
@@ -507,7 +499,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.bytes += tx_bytes;
 	tx_queue->tx_stat.err_pkts += i - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
-- 
2.51.0

[PATCH v10 09/19] net/pcap: report multi-segment transmit capability

[Stephen Hemminger]

The driver has always handled multi-segment transmit
but the flag was never set in the offload capabilities.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 394fd0b6b2..bd33e72a02 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -737,6 +737,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v10 10/19] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index bd33e72a02..201eb97745 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -103,9 +104,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -115,25 +116,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -856,7 +857,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1181,29 +1182,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1479,7 +1470,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1518,9 +1509,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1670,5 +1661,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.51.0

[PATCH v10 11/19] net/pcap: support VLAN insert and strip

[Stephen Hemminger]

Driver can easily insert VLAN tag strip and insertion similar
to how it is handled in virtio and af_packet.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/nics/pcap_ring.rst          | 11 +++++++++
 doc/guides/rel_notes/release_26_03.rst |  4 ++++
 drivers/net/pcap/pcap_ethdev.c         | 31 ++++++++++++++++++++++++--
 4 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..814bc2119f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index 6955e91130..c005786ce3 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -213,6 +213,17 @@ Otherwise, the first 512 packets from the input pcap file will be discarded by t
    an error if interface is down, and the PMD itself won't change the status
    of the external network interface.
 
+Features and Limitations
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
+
 
 Rings-based PMD
 ~~~~~~~~~~~~~~~
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 15dabee7a1..7993ce2ee0 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -55,6 +55,10 @@ New Features
      Also, make sure to start the actual text at the margin.
      =======================================================
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 201eb97745..b19e837b97 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -77,6 +77,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -107,6 +108,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -337,6 +339,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -412,9 +418,16 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		uint32_t len, caplen;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -487,6 +500,12 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
 		if (likely(data != NULL && pcap_sendpacket(pcap, data, len) == 0)) {
 			num_tx++;
@@ -721,8 +740,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -738,7 +762,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -885,6 +911,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
-- 
2.51.0

[PATCH v10 12/19] net/pcap: add link state and speed for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent functions to query the real link state, speed,
duplex, and autonegotiation settings from the underlying interface.
The eth_link_update() callback now returns accurate information
when operating in pass-through mode.

Linux uses ETHTOOL_GLINKSETTINGS which supports all speeds up to
800 Gbps. FreeBSD uses SIOCGIFMEDIA, and Windows uses
GetAdaptersAddresses().

For pcap file mode or separate rx/tx interface configurations,
default values continue to be used since there is no single
underlying interface to query.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         |  93 ++++++++++++++++++---
 drivers/net/pcap/pcap_osdep.h          |  22 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  |  67 +++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 109 +++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  |  95 ++++++++++++++++++---
 6 files changed, 364 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 7993ce2ee0..0264968567 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -58,6 +58,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state and speed in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index b19e837b97..917a8eee36 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -151,13 +151,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -890,11 +883,84 @@ eth_dev_close(struct rte_eth_dev *dev)
 	return 0;
 }
 
+/*
+ * Convert osdep speed (Mbps) to rte_eth_link speed constant.
+ */
+static uint32_t
+speed_mbps_to_rte(uint32_t speed_mbps)
+{
+	switch (speed_mbps) {
+	case 10:
+		return RTE_ETH_SPEED_NUM_10M;
+	case 100:
+		return RTE_ETH_SPEED_NUM_100M;
+	case 1000:
+		return RTE_ETH_SPEED_NUM_1G;
+	case 2500:
+		return RTE_ETH_SPEED_NUM_2_5G;
+	case 5000:
+		return RTE_ETH_SPEED_NUM_5G;
+	case 10000:
+		return RTE_ETH_SPEED_NUM_10G;
+	case 20000:
+		return RTE_ETH_SPEED_NUM_20G;
+	case 25000:
+		return RTE_ETH_SPEED_NUM_25G;
+	case 40000:
+		return RTE_ETH_SPEED_NUM_40G;
+	case 50000:
+		return RTE_ETH_SPEED_NUM_50G;
+	case 56000:
+		return RTE_ETH_SPEED_NUM_56G;
+	case 100000:
+		return RTE_ETH_SPEED_NUM_100G;
+	case 200000:
+		return RTE_ETH_SPEED_NUM_200G;
+	case 400000:
+		return RTE_ETH_SPEED_NUM_400G;
+	case 800000:
+		return RTE_ETH_SPEED_NUM_800G;
+	default:
+		return RTE_ETH_SPEED_NUM_UNKNOWN;
+	}
+}
+
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	const char *iface_name = internals->rx_queue[0].name;
+	struct rte_eth_link link;
+	struct osdep_iface_link osdep_link;
+
+	memset(&link, 0, sizeof(link));
+
+	/*
+	 * For pass-through mode (single_iface), query the actual interface.
+	 * Otherwise, use the default static link values.
+	 */
+	if (internals->single_iface &&
+	    osdep_iface_link_get(iface_name, &osdep_link) == 0) {
+		link.link_speed = speed_mbps_to_rte(osdep_link.link_speed);
+		link.link_status = osdep_link.link_status ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_duplex = osdep_link.link_duplex ?
+			RTE_ETH_LINK_FULL_DUPLEX : RTE_ETH_LINK_HALF_DUPLEX;
+		link.link_autoneg = osdep_link.link_autoneg ?
+			RTE_ETH_LINK_AUTONEG : RTE_ETH_LINK_FIXED;
+	} else {
+		/*
+		 * Not in pass-through mode (using pcap files or separate
+		 * interfaces for rx/tx). Or query failed. Use default values.
+		 */
+		link.link_speed = RTE_ETH_SPEED_NUM_10G;
+		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_autoneg = RTE_ETH_LINK_FIXED;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1275,7 +1341,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..732813c028 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,7 +13,29 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+/**
+ * Link information returned by osdep_iface_link_get().
+ */
+struct osdep_iface_link {
+	uint32_t link_speed;    /**< Speed in Mbps, 0 if unknown */
+	uint8_t link_status;    /**< 1 = up, 0 = down */
+	uint8_t link_duplex;    /**< 1 = full, 0 = half */
+	uint8_t link_autoneg;   /**< 1 = autoneg enabled, 0 = fixed */
+};
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link state and speed for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @param link
+ *   Pointer to structure to fill with link information.
+ * @return
+ *   0 on success, -1 on failure.
+ */
+int osdep_iface_link_get(const char *name, struct osdep_iface_link *link);
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..8593bd8907 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,8 +5,13 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
@@ -55,3 +60,65 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifmediareq ifmr;
+	struct ifreq ifr;
+	uint64_t baudrate;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine administrative status */
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		if (ifr.ifr_flags & IFF_UP)
+			link->link_status = 1;
+	}
+
+	/* Get media status for speed, duplex, and link state */
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(if_fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* Check if link is actually active */
+		if (!(ifmr.ifm_status & IFM_ACTIVE))
+			link->link_status = 0;
+
+		/* Only parse media if we have a valid current media type */
+		if (ifmr.ifm_current != 0 && IFM_TYPE(ifmr.ifm_current) == IFM_ETHER) {
+			/* Use FreeBSD's ifmedia_baudrate() to get speed */
+			baudrate = ifmedia_baudrate(ifmr.ifm_current);
+			link->link_speed = baudrate / 1000000;
+
+			/* Check duplex - FDX option means full duplex */
+			if (IFM_OPTIONS(ifmr.ifm_current) & IFM_FDX)
+				link->link_duplex = 1;
+			else
+				link->link_duplex = 0;
+		} else {
+			/* Default to full duplex if we can't determine */
+			link->link_duplex = 1;
+		}
+
+		/* Check autonegotiation status */
+		link->link_autoneg = (ifmr.ifm_current & IFM_AUTO) ? 1 : 0;
+	} else {
+		/*
+		 * SIOCGIFMEDIA failed - interface may not support it.
+		 * Default to reasonable values.
+		 */
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..036c685b50 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -9,6 +9,8 @@
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include <rte_string_fns.h>
 
@@ -40,3 +42,110 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+/*
+ * Get link speed, duplex, and autoneg using ETHTOOL_GLINKSETTINGS.
+ *
+ * ETHTOOL_GLINKSETTINGS was introduced in kernel 4.7 and supports
+ * speeds beyond 65535 Mbps (up to 800 Gbps and beyond).
+ * DPDK requires kernel 4.19 or later, so this interface is always available.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+get_link_settings(int fd, struct ifreq *ifr, struct osdep_iface_link *link)
+{
+	struct ethtool_link_settings *req;
+	int nwords;
+
+	/* First call with nwords = 0 to get the required size */
+	req = alloca(sizeof(*req));
+	memset(req, 0, sizeof(*req));
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Kernel returns negative nwords on first call */
+	if (req->link_mode_masks_nwords >= 0)
+		return -1;
+
+	nwords = -req->link_mode_masks_nwords;
+
+	/* Bounds check */
+	if (nwords == 0 || nwords > 127)
+		return -1;
+
+	/* Second call with correct nwords - need space for 3 link mode masks */
+	req = alloca(sizeof(*req) + 3 * nwords * sizeof(uint32_t));
+	memset(req, 0, sizeof(*req));
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	req->link_mode_masks_nwords = nwords;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Speed is in Mbps, directly usable */
+	link->link_speed = req->speed;
+
+	/* Handle special values */
+	if (link->link_speed == (uint32_t)SPEED_UNKNOWN ||
+	    link->link_speed == (uint32_t)-1)
+		link->link_speed = 0;
+
+	switch (req->duplex) {
+	case DUPLEX_FULL:
+		link->link_duplex = 1;
+		break;
+	case DUPLEX_HALF:
+		link->link_duplex = 0;
+		break;
+	default:
+		link->link_duplex = 1;  /* Default to full duplex */
+		break;
+	}
+
+	link->link_autoneg = (req->autoneg == AUTONEG_ENABLE) ? 1 : 0;
+	return 0;
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifreq ifr;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine link status */
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up
+		 * IFF_RUNNING means operationally up (carrier detected)
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			link->link_status = 1;
+	}
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (get_link_settings(if_fd, &ifr, link) < 0) {
+		/*
+		 * ethtool failed - interface may not support it
+		 * (e.g., virtual interfaces like veth, lo).
+		 * Use reasonable defaults.
+		 */
+		link->link_speed = 0;
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..1b76ae3185 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,56 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_get(const char *device_name, struct osdep_iface_link *link)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	memset(link, 0, sizeof(*link));
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			/* Check operational status */
+			if (cur->OperStatus == IfOperStatusUp)
+				link->link_status = 1;
+			else
+				link->link_status = 0;
+
+			/*
+			 * TransmitLinkSpeed and ReceiveLinkSpeed are in bits/sec.
+			 * Convert to Mbps. Use transmit speed as the link speed.
+			 * For asymmetric links, this is a reasonable approximation.
+			 */
+			if (cur->TransmitLinkSpeed != 0 &&
+			    cur->TransmitLinkSpeed != (ULONG64)-1) {
+				link->link_speed =
+					(uint32_t)(cur->TransmitLinkSpeed / 1000000ULL);
+			}
+
+			/*
+			 * Windows doesn't directly expose duplex/autoneg via
+			 * GetAdaptersAddresses(). Default to full duplex.
+			 * For more detailed info, WMI or OID queries would be needed.
+			 */
+			link->link_duplex = 1;  /* Assume full duplex */
+			link->link_autoneg = 0; /* Cannot determine */
+
+			ret = 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v10 13/19] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Defer timestamp dynfield registration from probe to device start,
  and only when timestamp offloading is enabled
* Add read_clock dev_op returning current UTC time
  for timestamp correlation
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper
* Enable immediate mode and improve error reporting
  in live capture setup

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap_ring.rst          |   3 +
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 145 +++++++++++++++++++------
 3 files changed, 114 insertions(+), 36 deletions(-)

diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index c005786ce3..5b9ca71b18 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -224,6 +224,9 @@ Features and Limitations
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
 
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
+
 
 Rings-based PMD
 ~~~~~~~~~~~~~~~
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 0264968567..50ba8bf109 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -59,6 +59,8 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state and speed in ``iface`` mode.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 917a8eee36..90bedb6286 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -28,13 +28,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -78,6 +76,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -109,6 +108,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -336,10 +336,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -359,14 +370,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -404,8 +420,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
@@ -418,9 +436,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -519,22 +534,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
+
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
+	}
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -581,7 +636,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -740,6 +796,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -757,7 +814,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -979,6 +1037,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1104,12 +1163,24 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1524,15 +1595,17 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
-
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							 &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
+		hz = rte_get_timer_hz();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v10 14/19] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 90bedb6286..f1965449eb 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -578,6 +578,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.51.0

[PATCH v10 15/19] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f1965449eb..e7c4f3be5f 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -47,11 +47,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -536,6 +534,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -647,6 +646,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1416,6 +1417,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v10 16/19] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index e7c4f3be5f..5e72a985e4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -55,10 +55,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -837,11 +837,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v10 17/19] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 5e72a985e4..415de46e22 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -820,10 +820,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v10 18/19] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

Example usage:
  --vdev 'net_pcap0,iface=eth0,snaplen=1518'
  --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap_ring.rst          |  13 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 205 +++++++++++++++----------
 3 files changed, 137 insertions(+), 82 deletions(-)

diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index 5b9ca71b18..3a3946e4f1 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -132,6 +132,19 @@ Runtime Config Options
 
 In this case, one dummy rx queue is created for each tx queue argument passed
 
+- Set the snapshot length for packet capture
+
+ The snapshot length controls the maximum number of bytes captured per packet.
+ This affects both interface capture and pcap file output.
+ The default value is 65535 bytes, which captures complete packets up to the maximum Ethernet jumbo frame size.
+ Reducing this value can improve performance when only packet headers are needed.
+ This can be done with a ``devarg`` ``snaplen``, for example::
+
+   --vdev 'net_pcap0,iface=eth0,snaplen=1518'
+   --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'
+
+ The snapshot length also determines the reported ``max_rx_pktlen`` and ``max_mtu`` in device info.
+
 Examples of Usage
 ^^^^^^^^^^^^^^^^^
 
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 50ba8bf109..3ad3531800 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -61,6 +61,7 @@ New Features
   * Added support for reporting link state and speed in ``iface`` mode.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 415de46e22..937ed8c91b 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -32,8 +32,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -42,6 +40,9 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -102,6 +103,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -129,6 +131,7 @@ struct pmd_devargs {
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -146,11 +149,16 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declaration */
+static inline int set_iface_direction(const char *iface, pcap_t *pcap,
+				      pcap_direction_t direction);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -402,20 +410,19 @@ calculate_timestamp(struct timeval *ts)
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -433,7 +440,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 				continue;
 		}
 
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
+		len = rte_pktmbuf_pkt_len(mbuf);
+		caplen = RTE_MIN(len, snaplen);
 		header.len = len;
 		header.caplen = caplen;
 
@@ -486,25 +494,22 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
-		const uint8_t *data;
 
 		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
 			/* if vlan insert fails treat it as error */
@@ -512,10 +517,21 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 				continue;
 		}
 
-		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		/* Is bounce buffer needed and is it big enough. */
+		if (unlikely(mbuf->nb_segs > 1 && len > snaplen)) {
+			PMD_LOG(DEBUG, "multi-segment mbuf %u > packet size %u",
+				len, snaplen);
+			continue;
+		}
+
+		const uint8_t *data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
 		if (likely(data != NULL && pcap_sendpacket(pcap, data, len) == 0)) {
 			num_tx++;
 			tx_bytes += len;
+		} else if (data != NULL) {
+			PMD_LOG(DEBUG, "pcap_sendpacket failed: %s",
+				pcap_geterr(pcap));
 		}
 	}
 
@@ -532,7 +548,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -561,7 +577,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -575,6 +591,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -603,9 +622,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -614,7 +633,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -624,7 +644,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -633,9 +653,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -685,6 +705,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
@@ -693,7 +714,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 		if (!pp->tx_pcap[0] &&
 			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -705,14 +726,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -727,9 +745,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -820,11 +843,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1124,7 +1147,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1245,41 +1268,32 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 }
 
 /*
- * Opens a pcap file for writing and stores a reference to it
- * for use it later on.
+ * Store TX pcap file configuration.
+ * The actual pcap dumper is opened in eth_dev_start().
  */
 static int
 open_tx_pcap(const char *key, const char *value, void *extra_args)
 {
 	const char *pcap_filename = value;
 	struct pmd_devargs *dumpers = extra_args;
-	pcap_dumper_t *dumper;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	if (add_queue(dumpers, pcap_filename, key, NULL, NULL) < 0)
 		return -1;
 
-	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
-		pcap_dump_close(dumper);
-		return -1;
-	}
-
 	return 0;
 }
 
 /*
- * Opens an interface for reading and writing
+ * Store interface configuration for reading and writing.
+ * The actual pcap handle is opened in eth_dev_start().
  */
 static inline int
 open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *tx = extra_args;
-	pcap_t *pcap = NULL;
-
-	if (open_single_iface(iface, &pcap) < 0)
-		return -1;
 
-	tx->queue[0].pcap = pcap;
+	tx->queue[0].pcap = NULL;
 	tx->queue[0].name = iface;
 	tx->queue[0].type = key;
 
@@ -1301,42 +1315,30 @@ set_iface_direction(const char *iface, pcap_t *pcap,
 	return 0;
 }
 
+/*
+ * Store interface configuration.
+ * The actual pcap handle is opened in eth_dev_start().
+ */
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *pmd = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (add_queue(pmd, iface, key, NULL, NULL) < 0)
 		return -1;
-	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
-		pcap_close(pcap);
-		return -1;
-	}
 
 	return 0;
 }
 
 /*
- * Opens a NIC for reading packets from it
+ * Store RX interface configuration.
+ * The actual pcap handle is opened and direction set in eth_dev_start().
  */
 static inline int
 open_rx_iface(const char *key, const char *value, void *extra_args)
 {
-	int ret = open_iface(key, value, extra_args);
-	if (ret < 0)
-		return ret;
-	if (strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
-		struct pmd_devargs *pmd = extra_args;
-		unsigned int qid = pmd->num_of_queue - 1;
-
-		set_iface_direction(pmd->queue[qid].name,
-				pmd->queue[qid].pcap,
-				PCAP_D_IN);
-	}
-
-	return 0;
+	return open_iface(key, value, extra_args);
 }
 
 static inline int
@@ -1376,6 +1378,30 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN || val > UINT32_MAX) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1540,6 +1566,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1600,6 +1628,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1641,6 +1670,17 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 			return -1;
 	}
 
+	/*
+	 * Process optional snapshot length argument.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
 	/*
 	 * If iface argument is passed we open the NICs and use them for
 	 * reading / writing
@@ -1847,4 +1887,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v10 19/19] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, vlan handling and multiple queues

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2622 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 2625 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index f4d04a6e42..90e3afaecf 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..dbb7c3aa65
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,2622 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define access _access
+#define F_OK 0
+#else
+#include <unistd.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u with VLAN strip: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(infinite_pcap_path);
+	remove_temp_file(timestamp_pcap_path);
+	remove_temp_file(varied_pcap_path);
+	remove_temp_file(jumbo_pcap_path);
+
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++)
+		remove_temp_file(multi_tx_pcap_paths[i]);
+
+	remove_temp_file(multi_rx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+	remove_temp_file(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 3ad3531800..f242ba978c 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -62,6 +62,7 @@ New Features
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v11 00/19] net/pcap: improvements and test suite

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx and stripping on Rx
  - Nanosecond precision timestamps (when hardware/libpcap supports it)
  - Accurate link state, speed, and duplex reporting in interface mode
  - Support for Windows interface mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snapshot_len devarg

Bug fixes:
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Change Tx burst to always consume all packets; failed sends
    increment error counter rather than leaving mbufs for retry
    (pcap_sendpacket failures are not transient)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables
  - Defer pcap handle opening until device start
  - Use bulk free for better Tx performance

Testing:
  - Add comprehensive unit test suite covering basic operations,
    timestamps, jumbo frames, VLAN handling, multi-queue, and more
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows

v11:
  - Fix build on FreeBsd

v10:
  - Split transmit handling into separate patches for bulk free,
    bounce buffer allocation, and cleanup for easier review
  - Add patch to reject non-Ethernet interfaces (fixes loopback
    issues on FreeBSD/macOS where DLT_NULL is used)
  - Test uses pcap_findalldevs() for portable interface discovery
    instead of hardcoded interface names

v9:
  - Add configurable snapshot length parameter (snapshot_len devarg)
  - Defer opening of pcap files and interfaces until eth_dev_start()
    instead of during probe, passing configured snapshot length

Stephen Hemminger (19):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: use bulk free
  net/pcap: allocate Tx bounce buffer
  net/pcap: cleanup transmit buffer handling
  net/pcap: report multi-segment transmit capability
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN insert and strip
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  net/pcap: add snapshot length devarg
  test: add test for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2622 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    8 +
 doc/guides/nics/pcap_ring.rst          |   27 +
 doc/guides/rel_notes/release_26_03.rst |    9 +
 drivers/net/pcap/pcap_ethdev.c         |  655 ++++--
 drivers/net/pcap/pcap_osdep.h          |   23 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   98 +-
 drivers/net/pcap/pcap_osdep_linux.c    |  115 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   95 +-
 11 files changed, 3417 insertions(+), 238 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v11 01/19] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 5683b87e4a..28a3269568 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap_ring.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v11 02/19] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v11 03/19] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v11 04/19] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..fbd1021c39 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v11 05/19] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd1021c39..806451dc99 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v11 06/19] net/pcap: use bulk free

[Stephen Hemminger]

Using function rte_pktmbuf_free_bulk is marginally faster here.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 806451dc99..61ba50e356 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -423,8 +423,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 		num_tx++;
 		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -449,13 +449,10 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
@@ -494,7 +491,6 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			PMD_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
 				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
 			continue;
 		}
 
@@ -508,9 +504,10 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			break;
 		num_tx++;
 		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
 	}
 
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
+
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
 	tx_queue->tx_stat.err_pkts += i - num_tx;
-- 
2.51.0

[PATCH v11 07/19] net/pcap: allocate Tx bounce buffer

[Stephen Hemminger]

To handle possible multi segment mbufs, the driver would allocate
a worst case 64k buffer on the stack. Since each Tx queue is
single threaded, better to allocate the buffer from hugepage
with rte_malloc when queue is setup.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 41 +++++++++++++++++++++-------------
 1 file changed, 26 insertions(+), 15 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 61ba50e356..1a186142d3 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -12,6 +12,7 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <unistd.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -91,6 +92,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used to for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -392,11 +396,12 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
+	unsigned char *temp_data;
 	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -406,10 +411,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	for (i = 0; i < nb_pkts; i++) {
 		mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
@@ -419,7 +420,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		 * a pointer to temp_data after copying into it.
 		 */
 		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+			  rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
 		num_tx++;
 		tx_bytes += caplen;
@@ -474,11 +475,12 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
+	unsigned char *temp_data;
 	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
@@ -486,13 +488,6 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	for (i = 0; i < nb_pkts; i++) {
 		mbuf = bufs[i];
 		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			continue;
-		}
 
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
@@ -962,7 +957,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -970,11 +965,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1015,6 +1025,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
-- 
2.51.0

[PATCH v11 08/19] net/pcap: cleanup transmit buffer handling

[Stephen Hemminger]

The transmit loops should handle the possible failure
of rte_pktmbuf_read(). If a pcap_sendpacket fails, then
the packet with error should be freed.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 50 ++++++++++++++--------------------
 1 file changed, 21 insertions(+), 29 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 1a186142d3..394fd0b6b2 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -389,7 +389,6 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
@@ -397,7 +396,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
 	unsigned char *temp_data;
-	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
@@ -409,21 +407,22 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len, caplen;
+		const uint8_t *data;
+
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			  rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
-		num_tx++;
-		tx_bytes += caplen;
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+		if (likely(data != NULL)) {
+			pcap_dump((u_char *)dumper, &header, data);
+			num_tx++;
+			tx_bytes += caplen;
+		}
 	}
 	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
@@ -458,7 +457,7 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -468,15 +467,12 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
 	unsigned char *temp_data;
-	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
@@ -486,19 +482,15 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		const uint8_t *data;
+
+		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		if (likely(data != NULL && pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
+		}
 	}
 
 	rte_pktmbuf_free_bulk(bufs, nb_pkts);
@@ -507,7 +499,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.bytes += tx_bytes;
 	tx_queue->tx_stat.err_pkts += i - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
-- 
2.51.0

[PATCH v11 09/19] net/pcap: report multi-segment transmit capability

[Stephen Hemminger]

The driver has always handled multi-segment transmit
but the flag was never set in the offload capabilities.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 394fd0b6b2..bd33e72a02 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -737,6 +737,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v11 10/19] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index bd33e72a02..201eb97745 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -103,9 +104,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -115,25 +116,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -856,7 +857,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1181,29 +1182,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1479,7 +1470,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1518,9 +1509,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1670,5 +1661,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.51.0

[PATCH v11 11/19] net/pcap: support VLAN insert and strip

[Stephen Hemminger]

Driver can easily insert VLAN tag strip and insertion similar
to how it is handled in virtio and af_packet.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/nics/pcap_ring.rst          | 11 +++++++++
 doc/guides/rel_notes/release_26_03.rst |  4 ++++
 drivers/net/pcap/pcap_ethdev.c         | 31 ++++++++++++++++++++++++--
 4 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..814bc2119f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index 6955e91130..c005786ce3 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -213,6 +213,17 @@ Otherwise, the first 512 packets from the input pcap file will be discarded by t
    an error if interface is down, and the PMD itself won't change the status
    of the external network interface.
 
+Features and Limitations
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
+
 
 Rings-based PMD
 ~~~~~~~~~~~~~~~
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 15dabee7a1..7993ce2ee0 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -55,6 +55,10 @@ New Features
      Also, make sure to start the actual text at the margin.
      =======================================================
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 201eb97745..b19e837b97 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -77,6 +77,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -107,6 +108,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -337,6 +339,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -412,9 +418,16 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		uint32_t len, caplen;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -487,6 +500,12 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
 		if (likely(data != NULL && pcap_sendpacket(pcap, data, len) == 0)) {
 			num_tx++;
@@ -721,8 +740,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -738,7 +762,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -885,6 +911,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
-- 
2.51.0

[PATCH v11 12/19] net/pcap: add link state and speed for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent functions to query the real link state, speed,
duplex, and autonegotiation settings from the underlying interface.
The eth_link_update() callback now returns accurate information
when operating in pass-through mode.

Linux uses ETHTOOL_GLINKSETTINGS which supports all speeds up to
800 Gbps. FreeBSD uses SIOCGIFMEDIA, and Windows uses
GetAdaptersAddresses().

For pcap file mode or separate rx/tx interface configurations,
default values continue to be used since there is no single
underlying interface to query.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         |  93 ++++++++++++++++++---
 drivers/net/pcap/pcap_osdep.h          |  22 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  |  86 +++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 109 +++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  |  95 ++++++++++++++++++---
 6 files changed, 383 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 7993ce2ee0..0264968567 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -58,6 +58,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state and speed in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index b19e837b97..917a8eee36 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -151,13 +151,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -890,11 +883,84 @@ eth_dev_close(struct rte_eth_dev *dev)
 	return 0;
 }
 
+/*
+ * Convert osdep speed (Mbps) to rte_eth_link speed constant.
+ */
+static uint32_t
+speed_mbps_to_rte(uint32_t speed_mbps)
+{
+	switch (speed_mbps) {
+	case 10:
+		return RTE_ETH_SPEED_NUM_10M;
+	case 100:
+		return RTE_ETH_SPEED_NUM_100M;
+	case 1000:
+		return RTE_ETH_SPEED_NUM_1G;
+	case 2500:
+		return RTE_ETH_SPEED_NUM_2_5G;
+	case 5000:
+		return RTE_ETH_SPEED_NUM_5G;
+	case 10000:
+		return RTE_ETH_SPEED_NUM_10G;
+	case 20000:
+		return RTE_ETH_SPEED_NUM_20G;
+	case 25000:
+		return RTE_ETH_SPEED_NUM_25G;
+	case 40000:
+		return RTE_ETH_SPEED_NUM_40G;
+	case 50000:
+		return RTE_ETH_SPEED_NUM_50G;
+	case 56000:
+		return RTE_ETH_SPEED_NUM_56G;
+	case 100000:
+		return RTE_ETH_SPEED_NUM_100G;
+	case 200000:
+		return RTE_ETH_SPEED_NUM_200G;
+	case 400000:
+		return RTE_ETH_SPEED_NUM_400G;
+	case 800000:
+		return RTE_ETH_SPEED_NUM_800G;
+	default:
+		return RTE_ETH_SPEED_NUM_UNKNOWN;
+	}
+}
+
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	const char *iface_name = internals->rx_queue[0].name;
+	struct rte_eth_link link;
+	struct osdep_iface_link osdep_link;
+
+	memset(&link, 0, sizeof(link));
+
+	/*
+	 * For pass-through mode (single_iface), query the actual interface.
+	 * Otherwise, use the default static link values.
+	 */
+	if (internals->single_iface &&
+	    osdep_iface_link_get(iface_name, &osdep_link) == 0) {
+		link.link_speed = speed_mbps_to_rte(osdep_link.link_speed);
+		link.link_status = osdep_link.link_status ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_duplex = osdep_link.link_duplex ?
+			RTE_ETH_LINK_FULL_DUPLEX : RTE_ETH_LINK_HALF_DUPLEX;
+		link.link_autoneg = osdep_link.link_autoneg ?
+			RTE_ETH_LINK_AUTONEG : RTE_ETH_LINK_FIXED;
+	} else {
+		/*
+		 * Not in pass-through mode (using pcap files or separate
+		 * interfaces for rx/tx). Or query failed. Use default values.
+		 */
+		link.link_speed = RTE_ETH_SPEED_NUM_10G;
+		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_autoneg = RTE_ETH_LINK_FIXED;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1275,7 +1341,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..732813c028 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,7 +13,29 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+/**
+ * Link information returned by osdep_iface_link_get().
+ */
+struct osdep_iface_link {
+	uint32_t link_speed;    /**< Speed in Mbps, 0 if unknown */
+	uint8_t link_status;    /**< 1 = up, 0 = down */
+	uint8_t link_duplex;    /**< 1 = full, 0 = half */
+	uint8_t link_autoneg;   /**< 1 = autoneg enabled, 0 = fixed */
+};
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link state and speed for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @param link
+ *   Pointer to structure to fill with link information.
+ * @return
+ *   0 on success, -1 on failure.
+ */
+int osdep_iface_link_get(const char *name, struct osdep_iface_link *link);
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..5963b67087 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,12 +5,36 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
 
+/*
+ * Userspace implementation of ifmedia_baudrate().
+ * The kernel function is not exported to userspace, so we implement
+ * our own using the IFM_BAUDRATE_DESCRIPTIONS table from if_media.h.
+ */
+static uint64_t
+ifmedia_baudrate_user(int mword)
+{
+	static const struct ifmedia_baudrate descs[] =
+		IFM_BAUDRATE_DESCRIPTIONS;
+	const struct ifmedia_baudrate *desc;
+
+	for (desc = descs; desc->ifmb_word != 0; desc++) {
+		if (IFM_TYPE_MATCH(desc->ifmb_word, mword))
+			return desc->ifmb_baudrate;
+	}
+	return 0;
+}
+
 int
 osdep_iface_index_get(const char *name)
 {
@@ -55,3 +79,65 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifmediareq ifmr;
+	struct ifreq ifr;
+	uint64_t baudrate;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine administrative status */
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		if (ifr.ifr_flags & IFF_UP)
+			link->link_status = 1;
+	}
+
+	/* Get media status for speed, duplex, and link state */
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(if_fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* Check if link is actually active */
+		if (!(ifmr.ifm_status & IFM_ACTIVE))
+			link->link_status = 0;
+
+		/* Only parse media if we have a valid current media type */
+		if (ifmr.ifm_current != 0 && IFM_TYPE(ifmr.ifm_current) == IFM_ETHER) {
+			/* Use userspace baudrate lookup */
+			baudrate = ifmedia_baudrate_user(ifmr.ifm_current);
+			link->link_speed = baudrate / 1000000;
+
+			/* Check duplex - FDX option means full duplex */
+			if (IFM_OPTIONS(ifmr.ifm_current) & IFM_FDX)
+				link->link_duplex = 1;
+			else
+				link->link_duplex = 0;
+		} else {
+			/* Default to full duplex if we can't determine */
+			link->link_duplex = 1;
+		}
+
+		/* Check autonegotiation status */
+		link->link_autoneg = (ifmr.ifm_current & IFM_AUTO) ? 1 : 0;
+	} else {
+		/*
+		 * SIOCGIFMEDIA failed - interface may not support it.
+		 * Default to reasonable values.
+		 */
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..036c685b50 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -9,6 +9,8 @@
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include <rte_string_fns.h>
 
@@ -40,3 +42,110 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+/*
+ * Get link speed, duplex, and autoneg using ETHTOOL_GLINKSETTINGS.
+ *
+ * ETHTOOL_GLINKSETTINGS was introduced in kernel 4.7 and supports
+ * speeds beyond 65535 Mbps (up to 800 Gbps and beyond).
+ * DPDK requires kernel 4.19 or later, so this interface is always available.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+get_link_settings(int fd, struct ifreq *ifr, struct osdep_iface_link *link)
+{
+	struct ethtool_link_settings *req;
+	int nwords;
+
+	/* First call with nwords = 0 to get the required size */
+	req = alloca(sizeof(*req));
+	memset(req, 0, sizeof(*req));
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Kernel returns negative nwords on first call */
+	if (req->link_mode_masks_nwords >= 0)
+		return -1;
+
+	nwords = -req->link_mode_masks_nwords;
+
+	/* Bounds check */
+	if (nwords == 0 || nwords > 127)
+		return -1;
+
+	/* Second call with correct nwords - need space for 3 link mode masks */
+	req = alloca(sizeof(*req) + 3 * nwords * sizeof(uint32_t));
+	memset(req, 0, sizeof(*req));
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	req->link_mode_masks_nwords = nwords;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Speed is in Mbps, directly usable */
+	link->link_speed = req->speed;
+
+	/* Handle special values */
+	if (link->link_speed == (uint32_t)SPEED_UNKNOWN ||
+	    link->link_speed == (uint32_t)-1)
+		link->link_speed = 0;
+
+	switch (req->duplex) {
+	case DUPLEX_FULL:
+		link->link_duplex = 1;
+		break;
+	case DUPLEX_HALF:
+		link->link_duplex = 0;
+		break;
+	default:
+		link->link_duplex = 1;  /* Default to full duplex */
+		break;
+	}
+
+	link->link_autoneg = (req->autoneg == AUTONEG_ENABLE) ? 1 : 0;
+	return 0;
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifreq ifr;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine link status */
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up
+		 * IFF_RUNNING means operationally up (carrier detected)
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			link->link_status = 1;
+	}
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (get_link_settings(if_fd, &ifr, link) < 0) {
+		/*
+		 * ethtool failed - interface may not support it
+		 * (e.g., virtual interfaces like veth, lo).
+		 * Use reasonable defaults.
+		 */
+		link->link_speed = 0;
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..1b76ae3185 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,56 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_get(const char *device_name, struct osdep_iface_link *link)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	memset(link, 0, sizeof(*link));
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			/* Check operational status */
+			if (cur->OperStatus == IfOperStatusUp)
+				link->link_status = 1;
+			else
+				link->link_status = 0;
+
+			/*
+			 * TransmitLinkSpeed and ReceiveLinkSpeed are in bits/sec.
+			 * Convert to Mbps. Use transmit speed as the link speed.
+			 * For asymmetric links, this is a reasonable approximation.
+			 */
+			if (cur->TransmitLinkSpeed != 0 &&
+			    cur->TransmitLinkSpeed != (ULONG64)-1) {
+				link->link_speed =
+					(uint32_t)(cur->TransmitLinkSpeed / 1000000ULL);
+			}
+
+			/*
+			 * Windows doesn't directly expose duplex/autoneg via
+			 * GetAdaptersAddresses(). Default to full duplex.
+			 * For more detailed info, WMI or OID queries would be needed.
+			 */
+			link->link_duplex = 1;  /* Assume full duplex */
+			link->link_autoneg = 0; /* Cannot determine */
+
+			ret = 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v11 13/19] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Defer timestamp dynfield registration from probe to device start,
  and only when timestamp offloading is enabled
* Add read_clock dev_op returning current UTC time
  for timestamp correlation
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper
* Enable immediate mode and improve error reporting
  in live capture setup

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap_ring.rst          |   3 +
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 145 +++++++++++++++++++------
 3 files changed, 114 insertions(+), 36 deletions(-)

diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index c005786ce3..5b9ca71b18 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -224,6 +224,9 @@ Features and Limitations
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
 
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
+
 
 Rings-based PMD
 ~~~~~~~~~~~~~~~
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 0264968567..50ba8bf109 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -59,6 +59,8 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state and speed in ``iface`` mode.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 917a8eee36..90bedb6286 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -28,13 +28,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -78,6 +76,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -109,6 +108,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -336,10 +336,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -359,14 +370,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -404,8 +420,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
@@ -418,9 +436,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -519,22 +534,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
+
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
+	}
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -581,7 +636,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -740,6 +796,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -757,7 +814,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -979,6 +1037,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1104,12 +1163,24 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1524,15 +1595,17 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
-
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							 &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
+		hz = rte_get_timer_hz();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v11 14/19] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 90bedb6286..f1965449eb 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -578,6 +578,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.51.0

[PATCH v11 15/19] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f1965449eb..e7c4f3be5f 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -47,11 +47,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -536,6 +534,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -647,6 +646,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1416,6 +1417,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v11 16/19] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index e7c4f3be5f..5e72a985e4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -55,10 +55,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -837,11 +837,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v11 17/19] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 5e72a985e4..415de46e22 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -820,10 +820,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v11 18/19] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

Example usage:
  --vdev 'net_pcap0,iface=eth0,snaplen=1518'
  --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap_ring.rst          |  13 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 205 +++++++++++++++----------
 3 files changed, 137 insertions(+), 82 deletions(-)

diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index 5b9ca71b18..3a3946e4f1 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -132,6 +132,19 @@ Runtime Config Options
 
 In this case, one dummy rx queue is created for each tx queue argument passed
 
+- Set the snapshot length for packet capture
+
+ The snapshot length controls the maximum number of bytes captured per packet.
+ This affects both interface capture and pcap file output.
+ The default value is 65535 bytes, which captures complete packets up to the maximum Ethernet jumbo frame size.
+ Reducing this value can improve performance when only packet headers are needed.
+ This can be done with a ``devarg`` ``snaplen``, for example::
+
+   --vdev 'net_pcap0,iface=eth0,snaplen=1518'
+   --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'
+
+ The snapshot length also determines the reported ``max_rx_pktlen`` and ``max_mtu`` in device info.
+
 Examples of Usage
 ^^^^^^^^^^^^^^^^^
 
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 50ba8bf109..3ad3531800 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -61,6 +61,7 @@ New Features
   * Added support for reporting link state and speed in ``iface`` mode.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 415de46e22..937ed8c91b 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -32,8 +32,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -42,6 +40,9 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -102,6 +103,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -129,6 +131,7 @@ struct pmd_devargs {
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -146,11 +149,16 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declaration */
+static inline int set_iface_direction(const char *iface, pcap_t *pcap,
+				      pcap_direction_t direction);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -402,20 +410,19 @@ calculate_timestamp(struct timeval *ts)
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -433,7 +440,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 				continue;
 		}
 
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
+		len = rte_pktmbuf_pkt_len(mbuf);
+		caplen = RTE_MIN(len, snaplen);
 		header.len = len;
 		header.caplen = caplen;
 
@@ -486,25 +494,22 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
-		const uint8_t *data;
 
 		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
 			/* if vlan insert fails treat it as error */
@@ -512,10 +517,21 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 				continue;
 		}
 
-		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		/* Is bounce buffer needed and is it big enough. */
+		if (unlikely(mbuf->nb_segs > 1 && len > snaplen)) {
+			PMD_LOG(DEBUG, "multi-segment mbuf %u > packet size %u",
+				len, snaplen);
+			continue;
+		}
+
+		const uint8_t *data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
 		if (likely(data != NULL && pcap_sendpacket(pcap, data, len) == 0)) {
 			num_tx++;
 			tx_bytes += len;
+		} else if (data != NULL) {
+			PMD_LOG(DEBUG, "pcap_sendpacket failed: %s",
+				pcap_geterr(pcap));
 		}
 	}
 
@@ -532,7 +548,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -561,7 +577,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -575,6 +591,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -603,9 +622,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -614,7 +633,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -624,7 +644,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -633,9 +653,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -685,6 +705,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
@@ -693,7 +714,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 		if (!pp->tx_pcap[0] &&
 			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -705,14 +726,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -727,9 +745,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -820,11 +843,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1124,7 +1147,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1245,41 +1268,32 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 }
 
 /*
- * Opens a pcap file for writing and stores a reference to it
- * for use it later on.
+ * Store TX pcap file configuration.
+ * The actual pcap dumper is opened in eth_dev_start().
  */
 static int
 open_tx_pcap(const char *key, const char *value, void *extra_args)
 {
 	const char *pcap_filename = value;
 	struct pmd_devargs *dumpers = extra_args;
-	pcap_dumper_t *dumper;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	if (add_queue(dumpers, pcap_filename, key, NULL, NULL) < 0)
 		return -1;
 
-	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
-		pcap_dump_close(dumper);
-		return -1;
-	}
-
 	return 0;
 }
 
 /*
- * Opens an interface for reading and writing
+ * Store interface configuration for reading and writing.
+ * The actual pcap handle is opened in eth_dev_start().
  */
 static inline int
 open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *tx = extra_args;
-	pcap_t *pcap = NULL;
-
-	if (open_single_iface(iface, &pcap) < 0)
-		return -1;
 
-	tx->queue[0].pcap = pcap;
+	tx->queue[0].pcap = NULL;
 	tx->queue[0].name = iface;
 	tx->queue[0].type = key;
 
@@ -1301,42 +1315,30 @@ set_iface_direction(const char *iface, pcap_t *pcap,
 	return 0;
 }
 
+/*
+ * Store interface configuration.
+ * The actual pcap handle is opened in eth_dev_start().
+ */
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *pmd = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (add_queue(pmd, iface, key, NULL, NULL) < 0)
 		return -1;
-	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
-		pcap_close(pcap);
-		return -1;
-	}
 
 	return 0;
 }
 
 /*
- * Opens a NIC for reading packets from it
+ * Store RX interface configuration.
+ * The actual pcap handle is opened and direction set in eth_dev_start().
  */
 static inline int
 open_rx_iface(const char *key, const char *value, void *extra_args)
 {
-	int ret = open_iface(key, value, extra_args);
-	if (ret < 0)
-		return ret;
-	if (strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
-		struct pmd_devargs *pmd = extra_args;
-		unsigned int qid = pmd->num_of_queue - 1;
-
-		set_iface_direction(pmd->queue[qid].name,
-				pmd->queue[qid].pcap,
-				PCAP_D_IN);
-	}
-
-	return 0;
+	return open_iface(key, value, extra_args);
 }
 
 static inline int
@@ -1376,6 +1378,30 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN || val > UINT32_MAX) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1540,6 +1566,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1600,6 +1628,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1641,6 +1670,17 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 			return -1;
 	}
 
+	/*
+	 * Process optional snapshot length argument.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
 	/*
 	 * If iface argument is passed we open the NICs and use them for
 	 * reading / writing
@@ -1847,4 +1887,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v11 19/19] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, vlan handling and multiple queues

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2622 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 2625 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index f4d04a6e42..90e3afaecf 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..dbb7c3aa65
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,2622 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define access _access
+#define F_OK 0
+#else
+#include <unistd.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u with VLAN strip: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(infinite_pcap_path);
+	remove_temp_file(timestamp_pcap_path);
+	remove_temp_file(varied_pcap_path);
+	remove_temp_file(jumbo_pcap_path);
+
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++)
+		remove_temp_file(multi_tx_pcap_paths[i]);
+
+	remove_temp_file(multi_rx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+	remove_temp_file(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 3ad3531800..f242ba978c 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -62,6 +62,7 @@ New Features
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v12 00/19] net/pcap: improvements and test suite

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx and stripping on Rx
  - Runtime VLAN offload configuration via vlan_offload_set callback
  - Nanosecond precision timestamps (when hardware/libpcap supports it)
  - Accurate link state, speed, and duplex reporting in interface mode
  - Support for Windows interface mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snapshot_len devarg

Bug fixes:
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Change Tx burst to always consume all packets; failed sends
    increment error counter rather than leaving mbufs for retry
    (pcap_sendpacket failures are not transient)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback
  - Fix infinite_rx ring fill applying VLAN strip and timestamp
    offloads to template packets, preventing those offloads from
    working correctly during packet delivery

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables
  - Defer pcap handle opening until device start
  - Use bulk free for better Tx performance

Testing:
  - Add comprehensive unit test suite covering basic operations,
    timestamps, jumbo frames, VLAN handling, multi-queue, and more
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows
  - New tests for runtime VLAN offload toggle, VLAN strip with
    infinite_rx mode, and timestamp generation in infinite_rx mode

v12:
  - Add vlan_offload_set callback to support runtime VLAN strip
    configuration via rte_eth_dev_set_vlan_offload()
  - Fix bugs in vlan strip and infinite rx mode
  - Rebase to main

v11:
  - Fix build on FreeBsd

v10:
  - Split transmit handling into separate patches for bulk free,
    bounce buffer allocation, and cleanup for easier review
  - Add patch to reject non-Ethernet interfaces (fixes loopback
    issues on FreeBSD/macOS where DLT_NULL is used)
  - Test uses pcap_findalldevs() for portable interface discovery
    instead of hardcoded interface names

v9:
  - Add configurable snapshot length parameter (snapshot_len devarg)
  - Defer opening of pcap files and interfaces until eth_dev_start()
    instead of during probe, passing configured snapshot length

Stephen Hemminger (19):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: use bulk free
  net/pcap: allocate Tx bounce buffer
  net/pcap: cleanup transmit buffer handling
  net/pcap: report multi-segment transmit capability
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN insert and strip
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  net/pcap: add snapshot length devarg
  test: add test for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c              | 2962 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    8 +
 doc/guides/nics/pcap_ring.rst          |   27 +
 doc/guides/rel_notes/release_26_03.rst |    9 +
 drivers/net/pcap/pcap_ethdev.c         |  670 ++++--
 drivers/net/pcap/pcap_osdep.h          |   23 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   98 +-
 drivers/net/pcap/pcap_osdep_linux.c    |  115 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   95 +-
 11 files changed, 3772 insertions(+), 238 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

Stephen Hemminger (19):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: use bulk free
  net/pcap: allocate Tx bounce buffer
  net/pcap: cleanup transmit buffer handling
  net/pcap: report multi-segment transmit capability
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN insert and strip
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  net/pcap: add snapshot length devarg
  test: add test for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2962 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    8 +
 doc/guides/nics/pcap_ring.rst          |   27 +
 doc/guides/rel_notes/release_26_03.rst |    9 +
 drivers/net/pcap/pcap_ethdev.c         |  709 ++++--
 drivers/net/pcap/pcap_osdep.h          |   23 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   98 +-
 drivers/net/pcap/pcap_osdep_linux.c    |  124 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   95 +-
 11 files changed, 3819 insertions(+), 239 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v12 01/19] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 5683b87e4a..28a3269568 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap_ring.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v12 02/19] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v12 03/19] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v12 04/19] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..fbd1021c39 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v12 05/19] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd1021c39..806451dc99 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v12 06/19] net/pcap: use bulk free

[Stephen Hemminger]

Using function rte_pktmbuf_free_bulk is marginally faster here.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 806451dc99..61ba50e356 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -423,8 +423,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 		num_tx++;
 		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -449,13 +449,10 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
@@ -494,7 +491,6 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			PMD_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
 				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
 			continue;
 		}
 
@@ -508,9 +504,10 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			break;
 		num_tx++;
 		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
 	}
 
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
+
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
 	tx_queue->tx_stat.err_pkts += i - num_tx;
-- 
2.51.0

[PATCH v12 07/19] net/pcap: allocate Tx bounce buffer

[Stephen Hemminger]

To handle possible multi segment mbufs, the driver would allocate
a worst case 64k buffer on the stack. Since each Tx queue is
single threaded, better to allocate the buffer from hugepage
with rte_malloc when queue is setup.

The buffer needs to be come from huge pages because the primary
process may start the device but the bounce buffer could be used
in transmit path by secondary process.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 41 +++++++++++++++++++++-------------
 1 file changed, 26 insertions(+), 15 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 61ba50e356..a89379ea9c 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -12,6 +12,7 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <unistd.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -91,6 +92,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -392,11 +396,12 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
+	unsigned char *temp_data;
 	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -406,10 +411,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	for (i = 0; i < nb_pkts; i++) {
 		mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
@@ -419,7 +420,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		 * a pointer to temp_data after copying into it.
 		 */
 		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+			  rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
 		num_tx++;
 		tx_bytes += caplen;
@@ -474,11 +475,12 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
+	unsigned char *temp_data;
 	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
@@ -486,13 +488,6 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	for (i = 0; i < nb_pkts; i++) {
 		mbuf = bufs[i];
 		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			continue;
-		}
 
 		/* rte_pktmbuf_read() returns a pointer to the data directly
 		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
@@ -962,7 +957,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -970,11 +965,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1015,6 +1025,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
-- 
2.51.0

[PATCH v12 08/19] net/pcap: cleanup transmit buffer handling

[Stephen Hemminger]

The transmit loops should handle the possible failure
of rte_pktmbuf_read(). If a pcap_sendpacket fails, then
the packet with error should be freed.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 60 ++++++++++++++++++----------------
 1 file changed, 32 insertions(+), 28 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index a89379ea9c..0aa3d67e4d 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -389,7 +389,6 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
@@ -397,7 +396,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
 	unsigned char *temp_data;
-	size_t len, caplen;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
@@ -409,21 +407,22 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len, caplen;
+		const uint8_t *data;
+
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			  rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
-		num_tx++;
-		tx_bytes += caplen;
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+		if (likely(data != NULL)) {
+			pcap_dump((u_char *)dumper, &header, data);
+			num_tx++;
+			tx_bytes += caplen;
+		}
 	}
 	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
@@ -458,7 +457,7 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -468,15 +467,12 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
 	unsigned char *temp_data;
-	size_t len;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
@@ -486,19 +482,27 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		const uint8_t *data;
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+			static int warned;
+
+			if (!warned) {
+				PMD_LOG(ERR,
+					"Multi segment PCAP packet. Size (%u) > max size (%u).",
+					len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+				warned = 1;
+			}
+			continue;
+		}
+
+		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		if (likely(data != NULL && pcap_sendpacket(pcap, data, len) == 0)) {
+			num_tx++;
+			tx_bytes += len;
+		}
 	}
 
 	rte_pktmbuf_free_bulk(bufs, nb_pkts);
@@ -507,7 +511,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.bytes += tx_bytes;
 	tx_queue->tx_stat.err_pkts += i - num_tx;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
-- 
2.51.0

[PATCH v12 09/19] net/pcap: report multi-segment transmit capability

[Stephen Hemminger]

The driver has always handled multi-segment transmit
but the flag was never set in the offload capabilities.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 0aa3d67e4d..d983135a4a 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -749,6 +749,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v12 10/19] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index d983135a4a..dcfd636fa0 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -103,9 +104,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -115,25 +116,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -868,7 +869,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1193,29 +1194,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1491,7 +1482,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1530,9 +1521,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1682,5 +1673,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.51.0

[PATCH v12 11/19] net/pcap: support VLAN insert and strip

[Stephen Hemminger]

Driver can easily insert VLAN tag strip and insertion similar
to how it is handled in virtio and af_packet.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/nics/pcap_ring.rst          | 11 ++++
 doc/guides/rel_notes/release_26_03.rst |  4 ++
 drivers/net/pcap/pcap_ethdev.c         | 71 ++++++++++++++++++++++++--
 4 files changed, 84 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..814bc2119f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index 6955e91130..c005786ce3 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -213,6 +213,17 @@ Otherwise, the first 512 packets from the input pcap file will be discarded by t
    an error if interface is down, and the PMD itself won't change the status
    of the external network interface.
 
+Features and Limitations
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
+
 
 Rings-based PMD
 ~~~~~~~~~~~~~~~
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index a837bdb600..9d4bdfc985 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -59,6 +59,10 @@ New Features
 
   * Added support for V4000 Krackan2e.
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index dcfd636fa0..957da1e0ab 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -77,6 +77,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -107,6 +108,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -271,7 +273,11 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		bufs[i]->data_len = pcap_buf->data_len;
 		bufs[i]->pkt_len = pcap_buf->pkt_len;
 		bufs[i]->port = pcap_q->port_id;
-		rx_bytes += pcap_buf->data_len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(bufs[i]);
+
+		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
 		rte_ring_enqueue(pcap_q->pkts, pcap_buf);
@@ -337,6 +343,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -412,9 +422,16 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		uint32_t len, caplen;
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -487,6 +504,12 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
 
+		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
+			/* if vlan insert fails treat it as error */
+			if (unlikely(rte_vlan_insert(&mbuf) != 0))
+				continue;
+		}
+
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			static int warned;
 
@@ -733,8 +756,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -750,7 +778,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -897,6 +927,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
@@ -906,6 +937,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		uint64_t pcap_pkt_count = 0;
 		struct rte_mbuf *bufs[1];
 		pcap_t **pcap;
+		bool save_vlan_strip;
 
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
@@ -925,11 +957,20 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		if (!pcap_q->pkts)
 			return -ENOENT;
 
+		/*
+		 * Temporarily disable offloads while filling the ring
+		 * with raw packets. VLAN strip and timestamp will be
+		 * applied later in eth_pcap_rx_infinite() on each copy.
+		 */
+		save_vlan_strip = pcap_q->vlan_strip;
+		pcap_q->vlan_strip = false;
+
 		/* Fill ring with packets from PCAP file one by one. */
 		while (eth_pcap_rx(pcap_q, bufs, 1)) {
 			/* Check for multiseg mbufs. */
 			if (bufs[0]->nb_segs != 1) {
 				infinite_rx_ring_free(pcap_q->pkts);
+				pcap_q->vlan_strip = save_vlan_strip;
 				PMD_LOG(ERR,
 					"Multiseg mbufs are not supported in infinite_rx mode.");
 				return -EINVAL;
@@ -939,6 +980,9 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 					(void * const *)bufs, 1, NULL);
 		}
 
+		/* Restore offloads for use during packet delivery */
+		pcap_q->vlan_strip = save_vlan_strip;
+
 		if (rte_ring_count(pcap_q->pkts) < pcap_pkt_count) {
 			infinite_rx_ring_free(pcap_q->pkts);
 			PMD_LOG(ERR,
@@ -1023,6 +1067,26 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	unsigned int i;
+
+	if (mask & RTE_ETH_VLAN_STRIP_MASK) {
+		bool vlan_strip = !!(dev->data->dev_conf.rxmode.offloads &
+				     RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+
+		internals->vlan_strip = vlan_strip;
+
+		/* Update all RX queues */
+		for (i = 0; i < dev->data->nb_rx_queues; i++)
+			internals->rx_queue[i].vlan_strip = vlan_strip;
+	}
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1039,6 +1103,7 @@ static const struct eth_dev_ops ops = {
 	.link_update = eth_link_update,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.vlan_offload_set = eth_vlan_offload_set,
 };
 
 static int
-- 
2.51.0

[PATCH v12 12/19] net/pcap: add link state and speed for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent functions to query the real link state, speed,
duplex, and autonegotiation settings from the underlying interface.
The eth_link_update() callback now returns accurate information
when operating in pass-through mode.

Linux uses ETHTOOL_GLINKSETTINGS which supports all speeds up to
800 Gbps. FreeBSD uses SIOCGIFMEDIA, and Windows uses
GetAdaptersAddresses().

For pcap file mode or separate rx/tx interface configurations,
default values continue to be used since there is no single
underlying interface to query.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         |  93 ++++++++++++++++---
 drivers/net/pcap/pcap_osdep.h          |  22 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  |  86 ++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 118 +++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  |  95 +++++++++++++++++---
 6 files changed, 392 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 9d4bdfc985..3836870961 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -62,6 +62,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state and speed in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 957da1e0ab..21f8f1170a 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -151,13 +151,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -906,11 +899,84 @@ eth_dev_close(struct rte_eth_dev *dev)
 	return 0;
 }
 
+/*
+ * Convert osdep speed (Mbps) to rte_eth_link speed constant.
+ */
+static uint32_t
+speed_mbps_to_rte(uint32_t speed_mbps)
+{
+	switch (speed_mbps) {
+	case 10:
+		return RTE_ETH_SPEED_NUM_10M;
+	case 100:
+		return RTE_ETH_SPEED_NUM_100M;
+	case 1000:
+		return RTE_ETH_SPEED_NUM_1G;
+	case 2500:
+		return RTE_ETH_SPEED_NUM_2_5G;
+	case 5000:
+		return RTE_ETH_SPEED_NUM_5G;
+	case 10000:
+		return RTE_ETH_SPEED_NUM_10G;
+	case 20000:
+		return RTE_ETH_SPEED_NUM_20G;
+	case 25000:
+		return RTE_ETH_SPEED_NUM_25G;
+	case 40000:
+		return RTE_ETH_SPEED_NUM_40G;
+	case 50000:
+		return RTE_ETH_SPEED_NUM_50G;
+	case 56000:
+		return RTE_ETH_SPEED_NUM_56G;
+	case 100000:
+		return RTE_ETH_SPEED_NUM_100G;
+	case 200000:
+		return RTE_ETH_SPEED_NUM_200G;
+	case 400000:
+		return RTE_ETH_SPEED_NUM_400G;
+	case 800000:
+		return RTE_ETH_SPEED_NUM_800G;
+	default:
+		return RTE_ETH_SPEED_NUM_UNKNOWN;
+	}
+}
+
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	const char *iface_name = internals->rx_queue[0].name;
+	struct rte_eth_link link;
+	struct osdep_iface_link osdep_link;
+
+	memset(&link, 0, sizeof(link));
+
+	/*
+	 * For pass-through mode (single_iface), query the actual interface.
+	 * Otherwise, use the default static link values.
+	 */
+	if (internals->single_iface &&
+	    osdep_iface_link_get(iface_name, &osdep_link) == 0) {
+		link.link_speed = speed_mbps_to_rte(osdep_link.link_speed);
+		link.link_status = osdep_link.link_status ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_duplex = osdep_link.link_duplex ?
+			RTE_ETH_LINK_FULL_DUPLEX : RTE_ETH_LINK_HALF_DUPLEX;
+		link.link_autoneg = osdep_link.link_autoneg ?
+			RTE_ETH_LINK_AUTONEG : RTE_ETH_LINK_FIXED;
+	} else {
+		/*
+		 * Not in pass-through mode (using pcap files or separate
+		 * interfaces for rx/tx). Or query failed. Use default values.
+		 */
+		link.link_speed = RTE_ETH_SPEED_NUM_10G;
+		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_autoneg = RTE_ETH_LINK_FIXED;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1325,7 +1391,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..732813c028 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,7 +13,29 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+/**
+ * Link information returned by osdep_iface_link_get().
+ */
+struct osdep_iface_link {
+	uint32_t link_speed;    /**< Speed in Mbps, 0 if unknown */
+	uint8_t link_status;    /**< 1 = up, 0 = down */
+	uint8_t link_duplex;    /**< 1 = full, 0 = half */
+	uint8_t link_autoneg;   /**< 1 = autoneg enabled, 0 = fixed */
+};
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link state and speed for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @param link
+ *   Pointer to structure to fill with link information.
+ * @return
+ *   0 on success, -1 on failure.
+ */
+int osdep_iface_link_get(const char *name, struct osdep_iface_link *link);
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..5963b67087 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,12 +5,36 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
 
+/*
+ * Userspace implementation of ifmedia_baudrate().
+ * The kernel function is not exported to userspace, so we implement
+ * our own using the IFM_BAUDRATE_DESCRIPTIONS table from if_media.h.
+ */
+static uint64_t
+ifmedia_baudrate_user(int mword)
+{
+	static const struct ifmedia_baudrate descs[] =
+		IFM_BAUDRATE_DESCRIPTIONS;
+	const struct ifmedia_baudrate *desc;
+
+	for (desc = descs; desc->ifmb_word != 0; desc++) {
+		if (IFM_TYPE_MATCH(desc->ifmb_word, mword))
+			return desc->ifmb_baudrate;
+	}
+	return 0;
+}
+
 int
 osdep_iface_index_get(const char *name)
 {
@@ -55,3 +79,65 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifmediareq ifmr;
+	struct ifreq ifr;
+	uint64_t baudrate;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine administrative status */
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		if (ifr.ifr_flags & IFF_UP)
+			link->link_status = 1;
+	}
+
+	/* Get media status for speed, duplex, and link state */
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(if_fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* Check if link is actually active */
+		if (!(ifmr.ifm_status & IFM_ACTIVE))
+			link->link_status = 0;
+
+		/* Only parse media if we have a valid current media type */
+		if (ifmr.ifm_current != 0 && IFM_TYPE(ifmr.ifm_current) == IFM_ETHER) {
+			/* Use userspace baudrate lookup */
+			baudrate = ifmedia_baudrate_user(ifmr.ifm_current);
+			link->link_speed = baudrate / 1000000;
+
+			/* Check duplex - FDX option means full duplex */
+			if (IFM_OPTIONS(ifmr.ifm_current) & IFM_FDX)
+				link->link_duplex = 1;
+			else
+				link->link_duplex = 0;
+		} else {
+			/* Default to full duplex if we can't determine */
+			link->link_duplex = 1;
+		}
+
+		/* Check autonegotiation status */
+		link->link_autoneg = (ifmr.ifm_current & IFM_AUTO) ? 1 : 0;
+	} else {
+		/*
+		 * SIOCGIFMEDIA failed - interface may not support it.
+		 * Default to reasonable values.
+		 */
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..3b56a833a9 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,11 +4,14 @@
  * All rights reserved.
  */
 
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include <rte_string_fns.h>
 
@@ -40,3 +43,118 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+/*
+ * Get link speed, duplex, and autoneg using ETHTOOL_GLINKSETTINGS.
+ *
+ * ETHTOOL_GLINKSETTINGS was introduced in kernel 4.7 and supports
+ * speeds beyond 65535 Mbps (up to 800 Gbps and beyond).
+ * DPDK requires kernel 4.19 or later, so this interface is always available.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+get_link_settings(int fd, struct ifreq *ifr, struct osdep_iface_link *link)
+{
+	struct ethtool_link_settings probe = { };
+	struct ethtool_link_settings *req;
+	size_t req_size;
+	int nwords;
+	int ret = -1;
+
+	/* First call with nwords = 0 to get the required size */
+	probe.cmd = ETHTOOL_GLINKSETTINGS;
+	ifr->ifr_data = (void *)&probe;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Kernel returns negative nwords on first call */
+	if (probe.link_mode_masks_nwords >= 0)
+		return -1;
+
+	nwords = -probe.link_mode_masks_nwords;
+
+	/* Bounds check */
+	if (nwords == 0 || nwords > 127)
+		return -1;
+
+	/* Second call with correct nwords - need space for 3 link mode masks */
+	req_size = sizeof(*req) + 3 * nwords * sizeof(uint32_t);
+	req = malloc(req_size);
+	if (req == NULL)
+		return -1;
+
+	memset(req, 0, req_size);
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	req->link_mode_masks_nwords = nwords;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		goto out;
+
+	/* Speed is in Mbps, directly usable */
+	link->link_speed = req->speed;
+
+	/* Handle special values */
+	if (link->link_speed == (uint32_t)SPEED_UNKNOWN ||
+	    link->link_speed == (uint32_t)-1)
+		link->link_speed = 0;
+
+	switch (req->duplex) {
+	case DUPLEX_FULL:
+		link->link_duplex = 1;
+		break;
+	case DUPLEX_HALF:
+		link->link_duplex = 0;
+		break;
+	default:
+		link->link_duplex = 1;  /* Default to full duplex */
+		break;
+	}
+
+	link->link_autoneg = (req->autoneg == AUTONEG_ENABLE) ? 1 : 0;
+	ret = 0;
+out:
+	free(req);
+	return ret;
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifreq ifr;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine link status */
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up
+		 * IFF_RUNNING means operationally up (carrier detected)
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			link->link_status = 1;
+	}
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (get_link_settings(if_fd, &ifr, link) < 0) {
+		/*
+		 * ethtool failed - interface may not support it
+		 * (e.g., virtual interfaces like veth, lo).
+		 * Use reasonable defaults.
+		 */
+		link->link_speed = 0;
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..1b76ae3185 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,56 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_get(const char *device_name, struct osdep_iface_link *link)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	memset(link, 0, sizeof(*link));
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			/* Check operational status */
+			if (cur->OperStatus == IfOperStatusUp)
+				link->link_status = 1;
+			else
+				link->link_status = 0;
+
+			/*
+			 * TransmitLinkSpeed and ReceiveLinkSpeed are in bits/sec.
+			 * Convert to Mbps. Use transmit speed as the link speed.
+			 * For asymmetric links, this is a reasonable approximation.
+			 */
+			if (cur->TransmitLinkSpeed != 0 &&
+			    cur->TransmitLinkSpeed != (ULONG64)-1) {
+				link->link_speed =
+					(uint32_t)(cur->TransmitLinkSpeed / 1000000ULL);
+			}
+
+			/*
+			 * Windows doesn't directly expose duplex/autoneg via
+			 * GetAdaptersAddresses(). Default to full duplex.
+			 * For more detailed info, WMI or OID queries would be needed.
+			 */
+			link->link_duplex = 1;  /* Assume full duplex */
+			link->link_autoneg = 0; /* Cannot determine */
+
+			ret = 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v12 13/19] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Defer timestamp dynfield registration from probe to device start,
  and only when timestamp offloading is enabled
* Add read_clock dev_op returning current UTC time
  for timestamp correlation
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper
* Enable immediate mode and improve error reporting
  in live capture setup

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap_ring.rst          |   3 +
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 154 +++++++++++++++++++------
 3 files changed, 123 insertions(+), 36 deletions(-)

diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index c005786ce3..5b9ca71b18 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -224,6 +224,9 @@ Features and Limitations
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
 
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
+
 
 Rings-based PMD
 ~~~~~~~~~~~~~~~
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 3836870961..8590dc861b 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -63,6 +63,8 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state and speed in ``iface`` mode.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 21f8f1170a..a17c2a3986 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -28,13 +28,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -78,6 +76,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -109,6 +108,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -270,6 +270,15 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(bufs[i]);
 
+		if (pcap_q->timestamp_offloading) {
+			struct timespec ts;
+
+			timespec_get(&ts, TIME_UTC);
+			*RTE_MBUF_DYNFIELD(bufs[i], timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(&ts);
+			bufs[i]->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
@@ -340,10 +349,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -363,14 +383,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -408,8 +433,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
@@ -422,9 +449,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -535,22 +559,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
+
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
+	}
+
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -597,7 +661,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -756,6 +821,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -773,7 +839,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -995,6 +1062,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1133,6 +1201,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static int
 eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
 {
@@ -1159,6 +1238,7 @@ static const struct eth_dev_ops ops = {
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1574,15 +1654,17 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
-
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							 &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
+		hz = rte_get_timer_hz();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v12 14/19] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index a17c2a3986..fdec637988 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -603,6 +603,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.51.0

[PATCH v12 15/19] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fdec637988..b1dbf91acc 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -47,11 +47,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -561,6 +559,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -672,6 +671,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1475,6 +1476,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v12 16/19] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index b1dbf91acc..f3220cea92 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -55,10 +55,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -862,11 +862,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v12 17/19] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f3220cea92..35d4f28d50 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -845,10 +845,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v12 18/19] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

Example usage:
  --vdev 'net_pcap0,iface=eth0,snaplen=1518'
  --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap_ring.rst          |  13 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 202 +++++++++++++++----------
 3 files changed, 132 insertions(+), 84 deletions(-)

diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index 5b9ca71b18..7993fc5e09 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -132,6 +132,19 @@ Runtime Config Options
 
 In this case, one dummy rx queue is created for each tx queue argument passed
 
+- Set the snapshot length for packet capture
+
+ The snapshot length controls the maximum number of bytes captured per packet.
+ This affects both interface capture and pcap file output.  The default value is
+ 65535 bytes, which captures complete packets up to the maximum Ethernet jumbo frame size.
+ Reducing this value can improve performance when only packet headers are needed.
+ This can be done with a ``devarg`` ``snaplen``, for example::
+
+   --vdev 'net_pcap0,iface=eth0,snaplen=1518'
+   --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'
+
+ The snapshot length also determines the reported ``max_rx_pktlen`` and ``max_mtu`` in device info.
+
 Examples of Usage
 ^^^^^^^^^^^^^^^^^
 
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 8590dc861b..069bbed807 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -65,6 +65,7 @@ New Features
   * Added support for reporting link state and speed in ``iface`` mode.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 35d4f28d50..9cb8bee2cf 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -32,8 +32,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -42,6 +40,9 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -102,6 +103,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -129,6 +131,7 @@ struct pmd_devargs {
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -146,11 +149,16 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declaration */
+static inline int set_iface_direction(const char *iface, pcap_t *pcap,
+				      pcap_direction_t direction);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -415,20 +423,19 @@ calculate_timestamp(struct timeval *ts)
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -446,7 +453,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 				continue;
 		}
 
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
+		len = rte_pktmbuf_pkt_len(mbuf);
+		caplen = RTE_MIN(len, snaplen);
 		header.len = len;
 		header.caplen = caplen;
 
@@ -499,25 +507,22 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
-		const uint8_t *data;
 
 		if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) {
 			/* if vlan insert fails treat it as error */
@@ -525,22 +530,26 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 				continue;
 		}
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > snaplen)) {
 			static int warned;
 
 			if (!warned) {
 				PMD_LOG(ERR,
 					"Multi segment PCAP packet. Size (%u) > max size (%u).",
-					len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+					len, snaplen);
 				warned = 1;
 			}
 			continue;
 		}
 
-		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		const uint8_t *data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
 		if (likely(data != NULL && pcap_sendpacket(pcap, data, len) == 0)) {
 			num_tx++;
 			tx_bytes += len;
+		} else if (data != NULL) {
+			PMD_LOG(DEBUG, "pcap_sendpacket failed: %s",
+				pcap_geterr(pcap));
 		}
 	}
 
@@ -557,7 +566,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -586,7 +595,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -600,6 +609,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -628,9 +640,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -639,7 +651,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -649,7 +662,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -658,9 +671,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -710,6 +723,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
@@ -718,7 +732,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 		if (!pp->tx_pcap[0] &&
 			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -730,14 +744,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -752,9 +763,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -845,11 +861,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1162,7 +1178,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1304,41 +1320,32 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 }
 
 /*
- * Opens a pcap file for writing and stores a reference to it
- * for use it later on.
+ * Store TX pcap file configuration.
+ * The actual pcap dumper is opened in eth_dev_start().
  */
 static int
 open_tx_pcap(const char *key, const char *value, void *extra_args)
 {
 	const char *pcap_filename = value;
 	struct pmd_devargs *dumpers = extra_args;
-	pcap_dumper_t *dumper;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	if (add_queue(dumpers, pcap_filename, key, NULL, NULL) < 0)
 		return -1;
 
-	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
-		pcap_dump_close(dumper);
-		return -1;
-	}
-
 	return 0;
 }
 
 /*
- * Opens an interface for reading and writing
+ * Store interface configuration for reading and writing.
+ * The actual pcap handle is opened in eth_dev_start().
  */
 static inline int
 open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *tx = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
-		return -1;
-
-	tx->queue[0].pcap = pcap;
+	tx->queue[0].pcap = NULL;
 	tx->queue[0].name = iface;
 	tx->queue[0].type = key;
 
@@ -1360,42 +1367,30 @@ set_iface_direction(const char *iface, pcap_t *pcap,
 	return 0;
 }
 
+/*
+ * Store interface configuration.
+ * The actual pcap handle is opened in eth_dev_start().
+ */
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *pmd = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
-		return -1;
-	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
-		pcap_close(pcap);
+	if (add_queue(pmd, iface, key, NULL, NULL) < 0)
 		return -1;
-	}
 
 	return 0;
 }
 
 /*
- * Opens a NIC for reading packets from it
+ * Store RX interface configuration.
+ * The actual pcap handle is opened and direction set in eth_dev_start().
  */
 static inline int
 open_rx_iface(const char *key, const char *value, void *extra_args)
 {
-	int ret = open_iface(key, value, extra_args);
-	if (ret < 0)
-		return ret;
-	if (strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
-		struct pmd_devargs *pmd = extra_args;
-		unsigned int qid = pmd->num_of_queue - 1;
-
-		set_iface_direction(pmd->queue[qid].name,
-				pmd->queue[qid].pcap,
-				PCAP_D_IN);
-	}
-
-	return 0;
+	return open_iface(key, value, extra_args);
 }
 
 static inline int
@@ -1435,6 +1430,30 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN || val > UINT32_MAX) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1599,6 +1618,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1659,6 +1680,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1700,6 +1722,17 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 			return -1;
 	}
 
+	/*
+	 * Process optional snapshot length argument.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
 	/*
 	 * If iface argument is passed we open the NICs and use them for
 	 * reading / writing
@@ -1906,4 +1939,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v12 19/19] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, vlan handling and multiple queues

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 2962 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 2965 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index f4d04a6e42..90e3afaecf 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..c16320cdbd
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,2962 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define access _access
+#define F_OK 0
+#else
+#include <unistd.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u with VLAN strip: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Runtime VLAN offload configuration via rte_eth_dev_set_vlan_offload
+ *
+ * This test verifies that VLAN strip can be enabled/disabled at runtime
+ * using the standard ethdev API rather than only at configure time.
+ * Uses infinite_rx mode so the same packets can be read in each phase.
+ */
+static int
+test_vlan_offload_set(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char vlan_set_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf = { 0 };
+	unsigned int i;
+	uint16_t nb_rx;
+	int ret, current_offload;
+	size_t tagged_len, untagged_len;
+
+	printf("Testing runtime VLAN offload configuration\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_set_pcap_path, sizeof(vlan_set_pcap_path),
+				     "pcap_vlan_set") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_set_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	/* Use infinite_rx so packets are always available */
+	snprintf(devargs, sizeof(devargs),
+		 "rx_pcap=%s,infinite_rx=1", vlan_set_pcap_path);
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_set", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+
+	/* Configure WITHOUT VLAN strip initially */
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port_id, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	/* Expected lengths */
+	tagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		     sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+	untagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN strip is initially disabled */
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled initially");
+
+	/*
+	 * Phase 1: VLAN strip disabled - packets should have tags
+	 */
+	printf("  Phase 1: VLAN strip disabled\n");
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 1");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 1 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact\n", nb_rx);
+
+	/*
+	 * Phase 2: Enable VLAN strip at runtime - packets should be stripped
+	 */
+	printf("  Phase 2: Enabling VLAN strip via rte_eth_dev_set_vlan_offload\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, RTE_ETH_VLAN_STRIP_OFFLOAD);
+	TEST_ASSERT(ret == 0, "Failed to enable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD,
+		    "VLAN strip should be enabled after set_vlan_offload");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 2");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), untagged_len,
+				  "Phase 2 packet %u: expected untagged length %zu, got %u",
+				  i, untagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Phase 2 packet %u: VLAN_STRIPPED flag not set", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags stripped\n", nb_rx);
+
+	/*
+	 * Phase 3: Disable VLAN strip - packets should have tags again
+	 */
+	printf("  Phase 3: Disabling VLAN strip\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to disable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled after clearing");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 3");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 3 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact again\n", nb_rx);
+
+	cleanup_pcap_vdev("net_pcap_vlan_set", port_id);
+	remove_temp_file(vlan_set_pcap_path);
+
+	printf("Runtime VLAN offload PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip in infinite RX mode
+ *
+ * This test verifies that VLAN strip offload works correctly when combined
+ * with infinite_rx mode, which uses a different RX path (eth_pcap_rx_infinite).
+ */
+static int
+test_vlan_strip_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	char vlan_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int stripped_count = 0;
+	int iter, attempts, ret;
+	size_t expected_len;
+
+	printf("Testing VLAN strip with infinite RX mode\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_inf_pcap_path, sizeof(vlan_inf_pcap_path),
+				     "pcap_vlan_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_inf_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets for infinite RX\n", NUM_PACKETS);
+
+	/* Create vdev with infinite_rx enabled */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", vlan_inf_pcap_path);
+	ret = rte_vdev_init("net_pcap_vlan_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_vlan_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with VLAN strip enabled */
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port with VLAN strip: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	/* Expected length after VLAN strip */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Read packets - need more than file contains to verify infinite looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				/* Verify VLAN was stripped */
+				if (verify_no_vlan_tag(mbufs[i]) == 0 &&
+				    rte_pktmbuf_pkt_len(mbufs[i]) == expected_len &&
+				    (mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED))
+					stripped_count++;
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_vlan_inf");
+	remove_temp_file(vlan_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(stripped_count, total_rx,
+			  "VLAN strip failed: only %u/%u packets stripped correctly",
+			  stripped_count, total_rx);
+
+	printf("VLAN strip infinite RX PASSED: %u packets stripped (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Timestamps in infinite RX mode
+ *
+ * This test verifies that timestamp offload works correctly when combined
+ * with infinite_rx mode. Since infinite_rx generates packets on-the-fly,
+ * timestamps should reflect the current time rather than pcap file timestamps.
+ */
+static int
+test_timestamp_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	char ts_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int ts_count = 0;
+	int iter, attempts, ret;
+	rte_mbuf_timestamp_t first_ts = 0;
+	rte_mbuf_timestamp_t last_ts = 0;
+
+	printf("Testing timestamps with infinite RX mode\n");
+
+	/* Initialize timestamp dynamic field access */
+	if (timestamp_dynfield_offset < 0) {
+		ret = timestamp_init();
+		if (ret != 0) {
+			printf("Timestamp dynfield not available, skipping\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	/* Create simple pcap file */
+	TEST_ASSERT(create_temp_path(ts_inf_pcap_path, sizeof(ts_inf_pcap_path),
+				     "pcap_ts_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_test_pcap(ts_inf_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/* Create vdev with infinite_rx enabled */
+	snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", ts_inf_pcap_path);
+	ret = rte_vdev_init("net_pcap_ts_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_ts_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with timestamp offload enabled */
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port with timestamps: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	/* Read packets */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				if (mbuf_has_timestamp(mbufs[i])) {
+					rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+
+					if (ts_count == 0)
+						first_ts = ts;
+					last_ts = ts;
+					ts_count++;
+				}
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_ts_inf");
+	remove_temp_file(ts_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(ts_count, total_rx,
+			  "Timestamp missing: only %u/%u packets have timestamps",
+			  ts_count, total_rx);
+
+	/* Timestamps should be monotonically increasing (current time) */
+	TEST_ASSERT(last_ts >= first_ts,
+		    "Timestamps not monotonic: first=%" PRIu64 " last=%" PRIu64,
+		    first_ts, last_ts);
+
+	printf("Timestamp infinite RX PASSED: %u packets with valid timestamps\n", total_rx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(infinite_pcap_path);
+	remove_temp_file(timestamp_pcap_path);
+	remove_temp_file(varied_pcap_path);
+	remove_temp_file(jumbo_pcap_path);
+
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++)
+		remove_temp_file(multi_tx_pcap_paths[i]);
+
+	remove_temp_file(multi_rx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+	remove_temp_file(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_vlan_offload_set),
+		TEST_CASE(test_vlan_strip_infinite_rx),
+		TEST_CASE(test_timestamp_infinite_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 069bbed807..604f2c1f23 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -66,6 +66,7 @@ New Features
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v13 00/16] net/pcap: improvements and test suite

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx and stripping on Rx
  - Runtime VLAN offload configuration via vlan_offload_set callback
  - Nanosecond precision timestamps (when hardware/libpcap supports it)
  - Accurate link state, speed, and duplex reporting in interface mode
  - Support for Windows interface mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snapshot_len devarg

Bug fixes:
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Change Tx burst to always consume all packets; failed sends
    increment error counter rather than leaving mbufs for retry
    (pcap_sendpacket failures are not transient)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback
  - Fix infinite_rx ring fill applying VLAN strip and timestamp
    offloads to template packets, preventing those offloads from
    working correctly during packet delivery

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables
  - Defer pcap handle opening until device start
  - Use bulk free for better Tx performance

Testing:
  - Add comprehensive unit test suite covering basic operations,
    timestamps, jumbo frames, VLAN handling, multi-queue, and more
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows
  - New tests for runtime VLAN offload toggle, VLAN strip with
    infinite_rx mode, and timestamp generation in infinite_rx mode

v13:
  - Fix VLAN insert to pass mbuf by reference so caller sees
    updated pointer after indirect mbuf handling
  - Fix VLAN insert error path to not free mbuf (let bulk free
    handle it, avoiding double-free)
  - Fix handling of pcap_sendpacket() errors
  - Fix theoretical format string overflows in test suite

Stephen Hemminger (16):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: cleanup transmit burst logic
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN insert and strip
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  net/pcap: add snapshot length devarg
  test: add test for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3023 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    8 +
 doc/guides/nics/pcap_ring.rst          |   27 +
 doc/guides/rel_notes/release_26_03.rst |    9 +
 drivers/net/pcap/pcap_ethdev.c         |  794 +++++--
 drivers/net/pcap/pcap_osdep.h          |   39 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   98 +-
 drivers/net/pcap/pcap_osdep_linux.c    |  124 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   95 +-
 11 files changed, 3979 insertions(+), 241 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v13 01/16] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 5683b87e4a..28a3269568 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap_ring.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v13 02/16] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v13 03/16] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v13 04/16] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..fbd1021c39 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v13 05/16] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd1021c39..806451dc99 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v13 06/16] net/pcap: cleanup transmit burst logic

[Stephen Hemminger]

To handle possible multi segment mbufs, the driver would allocate
a worst case 64k buffer on the stack. Since each Tx queue is
single threaded, better to allocate the buffer from hugepage
with rte_malloc when queue is setup.

The buffer needs to be come from huge pages because the primary
process may start the device but the bounce buffer could be used
in transmit path by secondary process.

Using function rte_pktmbuf_free_bulk is marginally faster here.

Do proper handling of pcap_sendpacket() errors.
The function can return -1 in case of device queue being full.
This should not be counted as an error.

The driver has always handled multi-segment transmit
but the flag was never set in the offload capabilities.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 114 +++++++++++++++++++--------------
 drivers/net/pcap/pcap_osdep.h  |  14 ++++
 2 files changed, 81 insertions(+), 47 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 806451dc99..84da41542b 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -12,6 +12,7 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <unistd.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -91,6 +92,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -385,18 +389,17 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -404,27 +407,24 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len, caplen;
+		const uint8_t *data;
+
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
-		num_tx++;
-		tx_bytes += caplen;
-		rte_pktmbuf_free(mbuf);
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+		if (likely(data != NULL)) {
+			pcap_dump((u_char *)dumper, &header, data);
+			num_tx++;
+			tx_bytes += caplen;
+		}
 	}
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	/*
 	 * Since there's no place to hook a callback when the forwarding
@@ -449,71 +449,74 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
-	for (i = 0; i < nb_pkts; i++) {
+	for (i = 0; i < nb_pkts; i++)
 		tx_bytes += bufs[i]->pkt_len;
-		rte_pktmbuf_free(bufs[i]);
-	}
+
+	rte_pktmbuf_free_bulk(bufs, nb_pkts);
 
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
- * Callback to handle sending packets through a real NIC.
+ * Send a burst of packets to a pcap device.
+ *
+ * On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
+ * socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
+ * The send() call only blocks when the kernel socket send buffer is full,
+ * providing limited backpressure.
+ *
+ * On error, pcap_sendpacket() returns non-zero and the loop breaks,
+ * leaving remaining packets unsent.
+ *
+ * Bottom line: backpressure is not an error.
  */
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
-			rte_pktmbuf_free(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+			PMD_TX_LOG(ERR,
+				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
+				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+			tx_queue->tx_stat.err_pkts++;
 			continue;
 		}
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
+		if (pcap_sendpacket(pcap, rte_pktmbuf_read(mbuf, 0, len, temp_data), len) != 0) {
+			/* Unfortunately, libpcap collapses transient and hard errors. */
+			PMD_TX_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
 			break;
+		}
+
 		num_tx++;
 		tx_bytes += len;
-		rte_pktmbuf_free(mbuf);
 	}
 
+	rte_pktmbuf_free_bulk(bufs, i);
+
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
 
 	return i;
 }
@@ -753,6 +756,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
@@ -965,7 +969,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -973,11 +977,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1018,6 +1037,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..fe7399ff9f 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,6 +13,20 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+#ifdef RTE_ETHDEV_DEBUG_RX
+#define PMD_RX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() rx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_RX_LOG(...) do { } while (0)
+#endif
+
+#ifdef RTE_ETHDEV_DEBUG_TX
+#define PMD_TX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() tx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_TX_LOG(...) do { } while (0)
+#endif
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
-- 
2.51.0

[PATCH v13 07/16] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 84da41542b..b77fa85dd4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -103,9 +104,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -115,25 +116,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -875,7 +876,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1200,29 +1201,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1498,7 +1489,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1537,9 +1528,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1689,5 +1680,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.51.0

[PATCH v13 08/16] net/pcap: support VLAN insert and strip

[Stephen Hemminger]

Driver can easily insert VLAN tag strip and insertion similar
to how it is handled in virtio and af_packet.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |   1 +
 doc/guides/nics/pcap_ring.rst          |  11 +++
 doc/guides/rel_notes/release_26_03.rst |   4 +
 drivers/net/pcap/pcap_ethdev.c         | 117 ++++++++++++++++++++++++-
 4 files changed, 129 insertions(+), 4 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..814bc2119f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index 6955e91130..c005786ce3 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -213,6 +213,17 @@ Otherwise, the first 512 packets from the input pcap file will be discarded by t
    an error if interface is down, and the PMD itself won't change the status
    of the external network interface.
 
+Features and Limitations
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
+
 
 Rings-based PMD
 ~~~~~~~~~~~~~~~
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 031eaa657e..c97ab7c3ca 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -63,6 +63,10 @@ New Features
 
   * Added support for pre and post VF reset callbacks.
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index b77fa85dd4..7fb6d98d75 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -77,6 +77,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -107,6 +108,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -271,7 +273,11 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		bufs[i]->data_len = pcap_buf->data_len;
 		bufs[i]->pkt_len = pcap_buf->pkt_len;
 		bufs[i]->port = pcap_q->port_id;
-		rx_bytes += pcap_buf->data_len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(bufs[i]);
+
+		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
 		rte_ring_enqueue(pcap_q->pkts, pcap_buf);
@@ -337,6 +343,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -383,6 +393,56 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+
+/*
+ * If Vlan offload flag is present, insert the vlan.
+ * Returns the mbuf to send, or NULL on error.
+ */
+static inline int
+eth_pcap_tx_vlan(struct pcap_tx_queue *tx_queue, struct rte_mbuf **mbuf)
+{
+	struct rte_mbuf *mb = *mbuf;
+
+	if ((mb->ol_flags & RTE_MBUF_F_TX_VLAN) == 0)
+		return 0;
+
+	if (unlikely(mb->data_len < RTE_ETHER_HDR_LEN)) {
+		PMD_TX_LOG(ERR, "mbuf missing ether header");
+		goto error;
+	}
+
+	/* Need at another buffer to hold VLAN header? */
+	if (!RTE_MBUF_DIRECT(mb) || rte_mbuf_refcnt_read(mb) > 1) {
+		struct rte_mbuf *mh = rte_pktmbuf_alloc(mb->pool);
+		if (unlikely(mh == NULL)) {
+			PMD_TX_LOG(ERR, "mbuf pool exhausted on transmit vlan");
+			goto error;
+		}
+
+		/* Extract original ethernet header into new mbuf */
+		memcpy(rte_pktmbuf_mtod(mh, void *), rte_pktmbuf_mtod(mb, void *), RTE_ETHER_HDR_LEN);
+		mh->nb_segs = mb->nb_segs + 1;
+		mh->data_len = RTE_ETHER_HDR_LEN;
+		mh->pkt_len = mb->pkt_len;
+		mh->ol_flags = mb->ol_flags;
+
+		mb->data_len -= RTE_ETHER_HDR_LEN;
+		mh->next = mb;
+
+		*mbuf = mh;
+	}
+
+	int ret = rte_vlan_insert(mbuf);
+	if (unlikely(ret != 0)) {
+		PMD_TX_LOG(ERR, "Vlan insert failed: %s", strerror(-ret));
+		goto error;
+	}
+	return 0;
+error:
+	tx_queue->tx_stat.err_pkts++;
+	return -1;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -408,13 +468,17 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
 		const uint8_t *data;
 
+		if (eth_pcap_tx_vlan(dumper_q, &bufs[i]) < 0)
+			continue;
+
+		struct rte_mbuf *mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -493,6 +557,9 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
+		if (eth_pcap_tx_vlan(tx_queue, &bufs[i]) < 0)
+			continue;
+
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 
@@ -740,8 +807,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -757,7 +829,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -904,6 +978,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
@@ -913,6 +988,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		uint64_t pcap_pkt_count = 0;
 		struct rte_mbuf *bufs[1];
 		pcap_t **pcap;
+		bool save_vlan_strip;
 
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
@@ -932,11 +1008,20 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		if (!pcap_q->pkts)
 			return -ENOENT;
 
+		/*
+		 * Temporarily disable offloads while filling the ring
+		 * with raw packets. VLAN strip and timestamp will be
+		 * applied later in eth_pcap_rx_infinite() on each copy.
+		 */
+		save_vlan_strip = pcap_q->vlan_strip;
+		pcap_q->vlan_strip = false;
+
 		/* Fill ring with packets from PCAP file one by one. */
 		while (eth_pcap_rx(pcap_q, bufs, 1)) {
 			/* Check for multiseg mbufs. */
 			if (bufs[0]->nb_segs != 1) {
 				infinite_rx_ring_free(pcap_q->pkts);
+				pcap_q->vlan_strip = save_vlan_strip;
 				PMD_LOG(ERR,
 					"Multiseg mbufs are not supported in infinite_rx mode.");
 				return -EINVAL;
@@ -946,6 +1031,9 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 					(void * const *)bufs, 1, NULL);
 		}
 
+		/* Restore offloads for use during packet delivery */
+		pcap_q->vlan_strip = save_vlan_strip;
+
 		if (rte_ring_count(pcap_q->pkts) < pcap_pkt_count) {
 			infinite_rx_ring_free(pcap_q->pkts);
 			PMD_LOG(ERR,
@@ -1030,6 +1118,26 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	unsigned int i;
+
+	if (mask & RTE_ETH_VLAN_STRIP_MASK) {
+		bool vlan_strip = !!(dev->data->dev_conf.rxmode.offloads &
+				     RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+
+		internals->vlan_strip = vlan_strip;
+
+		/* Update all RX queues */
+		for (i = 0; i < dev->data->nb_rx_queues; i++)
+			internals->rx_queue[i].vlan_strip = vlan_strip;
+	}
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1046,6 +1154,7 @@ static const struct eth_dev_ops ops = {
 	.link_update = eth_link_update,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.vlan_offload_set = eth_vlan_offload_set,
 };
 
 static int
-- 
2.51.0

[PATCH v13 09/16] net/pcap: add link state and speed for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent functions to query the real link state, speed,
duplex, and autonegotiation settings from the underlying interface.
The eth_link_update() callback now returns accurate information
when operating in pass-through mode.

Linux uses ETHTOOL_GLINKSETTINGS which supports all speeds up to
800 Gbps. FreeBSD uses SIOCGIFMEDIA, and Windows uses
GetAdaptersAddresses().

For pcap file mode or separate rx/tx interface configurations,
default values continue to be used since there is no single
underlying interface to query.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         |  93 ++++++++++++++++---
 drivers/net/pcap/pcap_osdep.h          |  24 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  |  86 ++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 118 +++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  |  95 +++++++++++++++++---
 6 files changed, 394 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index c97ab7c3ca..1ccf17d1e7 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -66,6 +66,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state and speed in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 7fb6d98d75..90b23d6c2a 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -151,13 +151,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -957,11 +950,84 @@ eth_dev_close(struct rte_eth_dev *dev)
 	return 0;
 }
 
+/*
+ * Convert osdep speed (Mbps) to rte_eth_link speed constant.
+ */
+static uint32_t
+speed_mbps_to_rte(uint32_t speed_mbps)
+{
+	switch (speed_mbps) {
+	case 10:
+		return RTE_ETH_SPEED_NUM_10M;
+	case 100:
+		return RTE_ETH_SPEED_NUM_100M;
+	case 1000:
+		return RTE_ETH_SPEED_NUM_1G;
+	case 2500:
+		return RTE_ETH_SPEED_NUM_2_5G;
+	case 5000:
+		return RTE_ETH_SPEED_NUM_5G;
+	case 10000:
+		return RTE_ETH_SPEED_NUM_10G;
+	case 20000:
+		return RTE_ETH_SPEED_NUM_20G;
+	case 25000:
+		return RTE_ETH_SPEED_NUM_25G;
+	case 40000:
+		return RTE_ETH_SPEED_NUM_40G;
+	case 50000:
+		return RTE_ETH_SPEED_NUM_50G;
+	case 56000:
+		return RTE_ETH_SPEED_NUM_56G;
+	case 100000:
+		return RTE_ETH_SPEED_NUM_100G;
+	case 200000:
+		return RTE_ETH_SPEED_NUM_200G;
+	case 400000:
+		return RTE_ETH_SPEED_NUM_400G;
+	case 800000:
+		return RTE_ETH_SPEED_NUM_800G;
+	default:
+		return RTE_ETH_SPEED_NUM_UNKNOWN;
+	}
+}
+
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	const char *iface_name = internals->rx_queue[0].name;
+	struct rte_eth_link link;
+	struct osdep_iface_link osdep_link;
+
+	memset(&link, 0, sizeof(link));
+
+	/*
+	 * For pass-through mode (single_iface), query the actual interface.
+	 * Otherwise, use the default static link values.
+	 */
+	if (internals->single_iface &&
+	    osdep_iface_link_get(iface_name, &osdep_link) == 0) {
+		link.link_speed = speed_mbps_to_rte(osdep_link.link_speed);
+		link.link_status = osdep_link.link_status ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_duplex = osdep_link.link_duplex ?
+			RTE_ETH_LINK_FULL_DUPLEX : RTE_ETH_LINK_HALF_DUPLEX;
+		link.link_autoneg = osdep_link.link_autoneg ?
+			RTE_ETH_LINK_AUTONEG : RTE_ETH_LINK_FIXED;
+	} else {
+		/*
+		 * Not in pass-through mode (using pcap files or separate
+		 * interfaces for rx/tx). Or query failed. Use default values.
+		 */
+		link.link_speed = RTE_ETH_SPEED_NUM_10G;
+		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_autoneg = RTE_ETH_LINK_FIXED;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1376,7 +1442,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index fe7399ff9f..b72dd0d74c 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -10,6 +10,7 @@
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
+
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
@@ -27,7 +28,30 @@ extern int eth_pcap_logtype;
 #define PMD_TX_LOG(...) do { } while (0)
 #endif
 
+/**
+ * Link information returned by osdep_iface_link_get().
+ */
+struct osdep_iface_link {
+	uint32_t link_speed;    /**< Speed in Mbps, 0 if unknown */
+	uint8_t link_status;    /**< 1 = up, 0 = down */
+	uint8_t link_duplex;    /**< 1 = full, 0 = half */
+	uint8_t link_autoneg;   /**< 1 = autoneg enabled, 0 = fixed */
+};
+
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link state and speed for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @param link
+ *   Pointer to structure to fill with link information.
+ * @return
+ *   0 on success, -1 on failure.
+ */
+int osdep_iface_link_get(const char *name, struct osdep_iface_link *link);
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..5963b67087 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,12 +5,36 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
 
+/*
+ * Userspace implementation of ifmedia_baudrate().
+ * The kernel function is not exported to userspace, so we implement
+ * our own using the IFM_BAUDRATE_DESCRIPTIONS table from if_media.h.
+ */
+static uint64_t
+ifmedia_baudrate_user(int mword)
+{
+	static const struct ifmedia_baudrate descs[] =
+		IFM_BAUDRATE_DESCRIPTIONS;
+	const struct ifmedia_baudrate *desc;
+
+	for (desc = descs; desc->ifmb_word != 0; desc++) {
+		if (IFM_TYPE_MATCH(desc->ifmb_word, mword))
+			return desc->ifmb_baudrate;
+	}
+	return 0;
+}
+
 int
 osdep_iface_index_get(const char *name)
 {
@@ -55,3 +79,65 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifmediareq ifmr;
+	struct ifreq ifr;
+	uint64_t baudrate;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine administrative status */
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		if (ifr.ifr_flags & IFF_UP)
+			link->link_status = 1;
+	}
+
+	/* Get media status for speed, duplex, and link state */
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(if_fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* Check if link is actually active */
+		if (!(ifmr.ifm_status & IFM_ACTIVE))
+			link->link_status = 0;
+
+		/* Only parse media if we have a valid current media type */
+		if (ifmr.ifm_current != 0 && IFM_TYPE(ifmr.ifm_current) == IFM_ETHER) {
+			/* Use userspace baudrate lookup */
+			baudrate = ifmedia_baudrate_user(ifmr.ifm_current);
+			link->link_speed = baudrate / 1000000;
+
+			/* Check duplex - FDX option means full duplex */
+			if (IFM_OPTIONS(ifmr.ifm_current) & IFM_FDX)
+				link->link_duplex = 1;
+			else
+				link->link_duplex = 0;
+		} else {
+			/* Default to full duplex if we can't determine */
+			link->link_duplex = 1;
+		}
+
+		/* Check autonegotiation status */
+		link->link_autoneg = (ifmr.ifm_current & IFM_AUTO) ? 1 : 0;
+	} else {
+		/*
+		 * SIOCGIFMEDIA failed - interface may not support it.
+		 * Default to reasonable values.
+		 */
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..3b56a833a9 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,11 +4,14 @@
  * All rights reserved.
  */
 
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include <rte_string_fns.h>
 
@@ -40,3 +43,118 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+/*
+ * Get link speed, duplex, and autoneg using ETHTOOL_GLINKSETTINGS.
+ *
+ * ETHTOOL_GLINKSETTINGS was introduced in kernel 4.7 and supports
+ * speeds beyond 65535 Mbps (up to 800 Gbps and beyond).
+ * DPDK requires kernel 4.19 or later, so this interface is always available.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+get_link_settings(int fd, struct ifreq *ifr, struct osdep_iface_link *link)
+{
+	struct ethtool_link_settings probe = { };
+	struct ethtool_link_settings *req;
+	size_t req_size;
+	int nwords;
+	int ret = -1;
+
+	/* First call with nwords = 0 to get the required size */
+	probe.cmd = ETHTOOL_GLINKSETTINGS;
+	ifr->ifr_data = (void *)&probe;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Kernel returns negative nwords on first call */
+	if (probe.link_mode_masks_nwords >= 0)
+		return -1;
+
+	nwords = -probe.link_mode_masks_nwords;
+
+	/* Bounds check */
+	if (nwords == 0 || nwords > 127)
+		return -1;
+
+	/* Second call with correct nwords - need space for 3 link mode masks */
+	req_size = sizeof(*req) + 3 * nwords * sizeof(uint32_t);
+	req = malloc(req_size);
+	if (req == NULL)
+		return -1;
+
+	memset(req, 0, req_size);
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	req->link_mode_masks_nwords = nwords;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		goto out;
+
+	/* Speed is in Mbps, directly usable */
+	link->link_speed = req->speed;
+
+	/* Handle special values */
+	if (link->link_speed == (uint32_t)SPEED_UNKNOWN ||
+	    link->link_speed == (uint32_t)-1)
+		link->link_speed = 0;
+
+	switch (req->duplex) {
+	case DUPLEX_FULL:
+		link->link_duplex = 1;
+		break;
+	case DUPLEX_HALF:
+		link->link_duplex = 0;
+		break;
+	default:
+		link->link_duplex = 1;  /* Default to full duplex */
+		break;
+	}
+
+	link->link_autoneg = (req->autoneg == AUTONEG_ENABLE) ? 1 : 0;
+	ret = 0;
+out:
+	free(req);
+	return ret;
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifreq ifr;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine link status */
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up
+		 * IFF_RUNNING means operationally up (carrier detected)
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			link->link_status = 1;
+	}
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (get_link_settings(if_fd, &ifr, link) < 0) {
+		/*
+		 * ethtool failed - interface may not support it
+		 * (e.g., virtual interfaces like veth, lo).
+		 * Use reasonable defaults.
+		 */
+		link->link_speed = 0;
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..1b76ae3185 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,56 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_get(const char *device_name, struct osdep_iface_link *link)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	memset(link, 0, sizeof(*link));
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			/* Check operational status */
+			if (cur->OperStatus == IfOperStatusUp)
+				link->link_status = 1;
+			else
+				link->link_status = 0;
+
+			/*
+			 * TransmitLinkSpeed and ReceiveLinkSpeed are in bits/sec.
+			 * Convert to Mbps. Use transmit speed as the link speed.
+			 * For asymmetric links, this is a reasonable approximation.
+			 */
+			if (cur->TransmitLinkSpeed != 0 &&
+			    cur->TransmitLinkSpeed != (ULONG64)-1) {
+				link->link_speed =
+					(uint32_t)(cur->TransmitLinkSpeed / 1000000ULL);
+			}
+
+			/*
+			 * Windows doesn't directly expose duplex/autoneg via
+			 * GetAdaptersAddresses(). Default to full duplex.
+			 * For more detailed info, WMI or OID queries would be needed.
+			 */
+			link->link_duplex = 1;  /* Assume full duplex */
+			link->link_autoneg = 0; /* Cannot determine */
+
+			ret = 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v13 10/16] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Defer timestamp dynfield registration from probe to device start,
  and only when timestamp offloading is enabled
* Add read_clock dev_op returning current UTC time
  for timestamp correlation
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper
* Enable immediate mode and improve error reporting
  in live capture setup

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap_ring.rst          |   3 +
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 157 +++++++++++++++++++------
 3 files changed, 127 insertions(+), 35 deletions(-)

diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index c005786ce3..5b9ca71b18 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -224,6 +224,9 @@ Features and Limitations
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
 
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
+
 
 Rings-based PMD
 ~~~~~~~~~~~~~~~
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 1ccf17d1e7..04968a2c40 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -67,6 +67,8 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state and speed in ``iface`` mode.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 90b23d6c2a..29030544b8 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -28,13 +28,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -78,6 +76,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -109,6 +108,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -270,6 +270,15 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(bufs[i]);
 
+		if (pcap_q->timestamp_offloading) {
+			struct timespec ts;
+
+			timespec_get(&ts, TIME_UTC);
+			*RTE_MBUF_DYNFIELD(bufs[i], timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(&ts);
+			bufs[i]->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
@@ -340,10 +349,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -363,14 +383,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -458,8 +483,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		uint32_t len, caplen;
 		const uint8_t *data;
@@ -469,9 +496,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 		struct rte_mbuf *mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -586,22 +610,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
+	}
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
+	}
+
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -648,7 +712,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -807,6 +872,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -824,7 +890,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -1046,6 +1113,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1184,6 +1252,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static int
 eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
 {
@@ -1210,6 +1289,7 @@ static const struct eth_dev_ops ops = {
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1625,15 +1705,22 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		hz = rte_get_timer_hz();
+		if (hz == 0) {
+			PMD_LOG(ERR, "Reported hz is zero!");
+			return -1;
+		}
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							 &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v13 11/16] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 29030544b8..cde9744766 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -654,6 +654,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.51.0

[PATCH v13 12/16] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index cde9744766..fde1f9fef2 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -47,11 +47,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -612,6 +610,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -723,6 +722,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1526,6 +1527,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v13 13/16] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fde1f9fef2..acfee68711 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -55,10 +55,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -913,11 +913,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v13 14/16] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index acfee68711..2413e44377 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -896,10 +896,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v13 15/16] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

Example usage:
  --vdev 'net_pcap0,iface=eth0,snaplen=1518'
  --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap_ring.rst          |  13 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 231 ++++++++++++++++---------
 3 files changed, 159 insertions(+), 86 deletions(-)

diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst
index 5b9ca71b18..7993fc5e09 100644
--- a/doc/guides/nics/pcap_ring.rst
+++ b/doc/guides/nics/pcap_ring.rst
@@ -132,6 +132,19 @@ Runtime Config Options
 
 In this case, one dummy rx queue is created for each tx queue argument passed
 
+- Set the snapshot length for packet capture
+
+ The snapshot length controls the maximum number of bytes captured per packet.
+ This affects both interface capture and pcap file output.  The default value is
+ 65535 bytes, which captures complete packets up to the maximum Ethernet jumbo frame size.
+ Reducing this value can improve performance when only packet headers are needed.
+ This can be done with a ``devarg`` ``snaplen``, for example::
+
+   --vdev 'net_pcap0,iface=eth0,snaplen=1518'
+   --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'
+
+ The snapshot length also determines the reported ``max_rx_pktlen`` and ``max_mtu`` in device info.
+
 Examples of Usage
 ^^^^^^^^^^^^^^^^^
 
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 04968a2c40..1022a27486 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -69,6 +69,7 @@ New Features
   * Added support for reporting link state and speed in ``iface`` mode.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2413e44377..4e09c23023 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -14,6 +14,7 @@
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <net/if.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -32,8 +33,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -42,6 +41,9 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -102,6 +104,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -129,6 +132,7 @@ struct pmd_devargs {
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -146,11 +150,16 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declaration */
+static inline int set_iface_direction(const char *iface, pcap_t *pcap,
+				      pcap_direction_t direction);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -465,20 +474,19 @@ eth_pcap_tx_vlan(struct pcap_tx_queue *tx_queue, struct rte_mbuf **mbuf)
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -486,14 +494,15 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		uint32_t len, caplen;
 		const uint8_t *data;
 
 		if (eth_pcap_tx_vlan(dumper_q, &bufs[i]) < 0)
 			continue;
 
 		struct rte_mbuf *mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t caplen = RTE_MIN(len, snaplen);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -556,19 +565,18 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
@@ -578,10 +586,10 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > snaplen)) {
 			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
-				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+				len, snaplen);
 			tx_queue->tx_stat.err_pkts++;
 			continue;
 		}
@@ -608,7 +616,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -637,7 +645,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -651,6 +659,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -679,9 +690,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -690,7 +701,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -700,7 +712,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -709,9 +721,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -761,15 +773,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
 		rx = &internals->rx_queue[0];
 
-		if (!pp->tx_pcap[0] &&
-			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+		if (!pp->tx_pcap[0] && strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -781,14 +793,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -803,9 +812,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -896,11 +910,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1213,7 +1227,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1343,6 +1357,12 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *rx = extra_args;
 	pcap_t *pcap = NULL;
 
+	if (access(pcap_filename, R_OK) != 0) {
+		PMD_LOG(ERR, "Cannot read pcap file '%s': %s",
+			pcap_filename, strerror(errno));
+		return -1;
+	}
+
 	if (open_single_rx_pcap(pcap_filename, &pcap) < 0)
 		return -1;
 
@@ -1355,41 +1375,53 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 }
 
 /*
- * Opens a pcap file for writing and stores a reference to it
- * for use it later on.
+ * Store TX pcap file configuration.
+ * The actual pcap dumper is opened in eth_dev_start().
  */
 static int
 open_tx_pcap(const char *key, const char *value, void *extra_args)
 {
 	const char *pcap_filename = value;
 	struct pmd_devargs *dumpers = extra_args;
-	pcap_dumper_t *dumper;
+	FILE *f;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	/* Validate that pcap_filename can be created. */
+	if (strcmp(pcap_filename, "-") == 0) {
+		/* This isn't going to work very well in DPDK - so reject it */
+		PMD_LOG(ERR, "Sending pcap binary data to stdout is not supported");
 		return -1;
+	}
 
-	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
-		pcap_dump_close(dumper);
+	f = fopen(pcap_filename, "wb");
+	if (f == NULL) {
+		PMD_LOG(ERR, "Cannot open '%s' for writing: %s", pcap_filename, strerror(errno));
 		return -1;
 	}
+	fclose(f);
+
+	if (add_queue(dumpers, pcap_filename, key, NULL, NULL) < 0)
+		return -1;
 
 	return 0;
 }
 
 /*
- * Opens an interface for reading and writing
+ * Store interface configuration for reading and writing.
+ * The actual pcap handle is opened in eth_dev_start().
  */
 static inline int
 open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *tx = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (if_nametoindex(iface) == 0) {
+		PMD_LOG(ERR, "Interface '%s' not found: %s",
+			iface, strerror(errno));
 		return -1;
+	}
 
-	tx->queue[0].pcap = pcap;
+	tx->queue[0].pcap = NULL;
 	tx->queue[0].name = iface;
 	tx->queue[0].type = key;
 
@@ -1411,50 +1443,38 @@ set_iface_direction(const char *iface, pcap_t *pcap,
 	return 0;
 }
 
+/*
+ * Store interface configuration.
+ * The actual pcap handle is opened in eth_dev_start().
+ */
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *pmd = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
-		return -1;
-	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
-		pcap_close(pcap);
+	if (if_nametoindex(iface) == 0) {
+		PMD_LOG(ERR, "Interface '%s' not found: %s",
+			iface, strerror(errno));
 		return -1;
 	}
 
+	if (add_queue(pmd, iface, key, NULL, NULL) < 0)
+		return -1;
+
 	return 0;
 }
 
 /*
- * Opens a NIC for reading packets from it
+ * Store RX interface configuration.
+ * The actual pcap handle is opened and direction set in eth_dev_start().
  */
-static inline int
-open_rx_iface(const char *key, const char *value, void *extra_args)
-{
-	int ret = open_iface(key, value, extra_args);
-	if (ret < 0)
-		return ret;
-	if (strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
-		struct pmd_devargs *pmd = extra_args;
-		unsigned int qid = pmd->num_of_queue - 1;
-
-		set_iface_direction(pmd->queue[qid].name,
-				pmd->queue[qid].pcap,
-				PCAP_D_IN);
-	}
-
-	return 0;
-}
-
 static inline int
 rx_iface_args_process(const char *key, const char *value, void *extra_args)
 {
 	if (strcmp(key, ETH_PCAP_RX_IFACE_ARG) == 0 ||
-			strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
-		return open_rx_iface(key, value, extra_args);
+	    strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+		return open_iface(key, value, extra_args);
 
 	return 0;
 }
@@ -1486,6 +1506,30 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN || val > UINT32_MAX) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1650,6 +1694,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1710,6 +1756,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1757,7 +1804,18 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	}
 
 	/*
-	 * If iface argument is passed we open the NICs and use them for
+	 * Process optional snapshot length argument.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+	/*
+	 * If iface argument is passed we check that NIC can be used
 	 * reading / writing
 	 */
 	if (rte_kvargs_count(kvlist, ETH_PCAP_IFACE_ARG) == 1) {
@@ -1962,4 +2020,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v13 16/16] test: add test for pcap PMD

[Stephen Hemminger]

This test was generated by Claude AI with some prompting and
pointing at existing ring PMD test. It tests basic operations,
timestamps, jumbo frame, vlan handling and multiple queues

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3023 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 3026 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index 48874037eb..a83292cf49 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..6f3e5e0363
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,3023 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define access _access
+#define F_OK 0
+#else
+#include <unistd.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u with VLAN strip: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+	int ret;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+	int ret;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+	int ret;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+	int ret;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	int ret;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Runtime VLAN offload configuration via rte_eth_dev_set_vlan_offload
+ *
+ * This test verifies that VLAN strip can be enabled/disabled at runtime
+ * using the standard ethdev API rather than only at configure time.
+ * Uses infinite_rx mode so the same packets can be read in each phase.
+ */
+static int
+test_vlan_offload_set(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char vlan_set_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf = { 0 };
+	unsigned int i;
+	uint16_t nb_rx;
+	int ret, current_offload;
+	size_t tagged_len, untagged_len;
+
+	printf("Testing runtime VLAN offload configuration\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_set_pcap_path, sizeof(vlan_set_pcap_path),
+				     "pcap_vlan_set") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_set_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	/* Use infinite_rx so packets are always available */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", vlan_set_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_set", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+
+	/* Configure WITHOUT VLAN strip initially */
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port_id, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	/* Expected lengths */
+	tagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		     sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+	untagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN strip is initially disabled */
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled initially");
+
+	/*
+	 * Phase 1: VLAN strip disabled - packets should have tags
+	 */
+	printf("  Phase 1: VLAN strip disabled\n");
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 1");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 1 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact\n", nb_rx);
+
+	/*
+	 * Phase 2: Enable VLAN strip at runtime - packets should be stripped
+	 */
+	printf("  Phase 2: Enabling VLAN strip via rte_eth_dev_set_vlan_offload\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, RTE_ETH_VLAN_STRIP_OFFLOAD);
+	TEST_ASSERT(ret == 0, "Failed to enable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD,
+		    "VLAN strip should be enabled after set_vlan_offload");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 2");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), untagged_len,
+				  "Phase 2 packet %u: expected untagged length %zu, got %u",
+				  i, untagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Phase 2 packet %u: VLAN_STRIPPED flag not set", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags stripped\n", nb_rx);
+
+	/*
+	 * Phase 3: Disable VLAN strip - packets should have tags again
+	 */
+	printf("  Phase 3: Disabling VLAN strip\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to disable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled after clearing");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 3");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 3 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact again\n", nb_rx);
+
+	cleanup_pcap_vdev("net_pcap_vlan_set", port_id);
+	remove_temp_file(vlan_set_pcap_path);
+
+	printf("Runtime VLAN offload PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip in infinite RX mode
+ *
+ * This test verifies that VLAN strip offload works correctly when combined
+ * with infinite_rx mode, which uses a different RX path (eth_pcap_rx_infinite).
+ */
+static int
+test_vlan_strip_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	char vlan_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int stripped_count = 0;
+	int iter, attempts, ret;
+	size_t expected_len;
+
+	printf("Testing VLAN strip with infinite RX mode\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_inf_pcap_path, sizeof(vlan_inf_pcap_path),
+				     "pcap_vlan_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_inf_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets for infinite RX\n", NUM_PACKETS);
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", vlan_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_vlan_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_vlan_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with VLAN strip enabled */
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port with VLAN strip: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	/* Expected length after VLAN strip */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Read packets - need more than file contains to verify infinite looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				/* Verify VLAN was stripped */
+				if (verify_no_vlan_tag(mbufs[i]) == 0 &&
+				    rte_pktmbuf_pkt_len(mbufs[i]) == expected_len &&
+				    (mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED))
+					stripped_count++;
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_vlan_inf");
+	remove_temp_file(vlan_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(stripped_count, total_rx,
+			  "VLAN strip failed: only %u/%u packets stripped correctly",
+			  stripped_count, total_rx);
+
+	printf("VLAN strip infinite RX PASSED: %u packets stripped (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Timestamps in infinite RX mode
+ *
+ * This test verifies that timestamp offload works correctly when combined
+ * with infinite_rx mode. Since infinite_rx generates packets on-the-fly,
+ * timestamps should reflect the current time rather than pcap file timestamps.
+ */
+static int
+test_timestamp_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	char ts_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int ts_count = 0;
+	int iter, attempts, ret;
+	rte_mbuf_timestamp_t first_ts = 0;
+	rte_mbuf_timestamp_t last_ts = 0;
+
+	printf("Testing timestamps with infinite RX mode\n");
+
+	/* Initialize timestamp dynamic field access */
+	if (timestamp_dynfield_offset < 0) {
+		ret = timestamp_init();
+		if (ret != 0) {
+			printf("Timestamp dynfield not available, skipping\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	/* Create simple pcap file */
+	TEST_ASSERT(create_temp_path(ts_inf_pcap_path, sizeof(ts_inf_pcap_path),
+				     "pcap_ts_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_test_pcap(ts_inf_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", ts_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_ts_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_ts_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with timestamp offload enabled */
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port with timestamps: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	/* Read packets */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				if (mbuf_has_timestamp(mbufs[i])) {
+					rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+
+					if (ts_count == 0)
+						first_ts = ts;
+					last_ts = ts;
+					ts_count++;
+				}
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_ts_inf");
+	remove_temp_file(ts_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(ts_count, total_rx,
+			  "Timestamp missing: only %u/%u packets have timestamps",
+			  ts_count, total_rx);
+
+	/* Timestamps should be monotonically increasing (current time) */
+	TEST_ASSERT(last_ts >= first_ts,
+		    "Timestamps not monotonic: first=%" PRIu64 " last=%" PRIu64,
+		    first_ts, last_ts);
+
+	printf("Timestamp infinite RX PASSED: %u packets with valid timestamps\n", total_rx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(infinite_pcap_path);
+	remove_temp_file(timestamp_pcap_path);
+	remove_temp_file(varied_pcap_path);
+	remove_temp_file(jumbo_pcap_path);
+
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++)
+		remove_temp_file(multi_tx_pcap_paths[i]);
+
+	remove_temp_file(multi_rx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+	remove_temp_file(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_vlan_offload_set),
+		TEST_CASE(test_vlan_strip_infinite_rx),
+		TEST_CASE(test_timestamp_infinite_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 1022a27486..b68735a64b 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -70,6 +70,7 @@ New Features
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v14 00/18] net/pcap: improvements and test suite

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx and stripping on Rx
  - Runtime VLAN offload configuration via vlan_offload_set callback
  - Nanosecond precision timestamps (when hardware/libpcap supports it)
  - Accurate link state, speed, and duplex reporting in interface mode
  - Link status change (LSC) interrupt support in interface mode
  - EOF notification via link status change for rx_pcap mode
  - Support for Windows interface mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snapshot_len devarg

Bug fixes:
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Change Tx burst to always consume all packets; failed sends
    increment error counter rather than leaving mbufs for retry
    (pcap_sendpacket failures are not transient)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback
  - Fix infinite_rx ring fill applying VLAN strip and timestamp
    offloads to template packets, preventing those offloads from
    working correctly during packet delivery

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables
  - Defer pcap handle opening until device start
  - Use bulk free for better Tx performance

Testing:
  - Add comprehensive unit test suite covering basic operations,
    timestamps, jumbo frames, VLAN handling, multi-queue, and more
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows
  - New tests for runtime VLAN offload toggle, VLAN strip with
    infinite_rx mode, and timestamp generation in infinite_rx mode

v14:
  - Add LSC interrupt support for iface mode using alarm-based polling
  - Add EOF devarg for rx_pcap mode: signals end-of-file via link
    down and LSC event (mutually exclusive with infinite_rx)
  - Fix mbuf leak in eth_pcap_tx() when dropping oversized
    multi-segment packets (missing rte_pktmbuf_free before continue)
  - Fix rte_pktmbuf_read() NULL path falling through to success
    counters (num_tx/tx_bytes now inside else branch only)
  - Fix VLAN insert for indirect/shared mbufs: use rte_pktmbuf_adj()
    to advance data_off, preventing duplicated Ethernet header in
    the mbuf chain

v13:
  - Fix VLAN insert to pass mbuf by reference so caller sees
    updated pointer after indirect mbuf handling
  - Fix VLAN insert error path to not free mbuf (let bulk free
    handle it, avoiding double-free)
  - Fix handling of pcap_sendpacket() errors
  - Fix theoretical format string overflows in test suite

Stephen Hemminger (18):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: rework transmit burst handling
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN strip and insert offloads
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  net/pcap: add snapshot length devarg
  net/pcap: add link status change support for iface mode
  net/pcap: add EOF notification via link status change
  test: add comprehensive test suite for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3422 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    9 +
 doc/guides/nics/pcap.rst               |   41 +
 doc/guides/rel_notes/release_26_03.rst |   12 +
 drivers/net/pcap/pcap_ethdev.c         |  920 +++++--
 drivers/net/pcap/pcap_osdep.h          |   39 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   98 +-
 drivers/net/pcap/pcap_osdep_linux.c    |  124 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   95 +-
 11 files changed, 4524 insertions(+), 239 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v14 01/18] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 5683b87e4a..28a3269568 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap_ring.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v14 02/18] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v14 03/18] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v14 04/18] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..fbd1021c39 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v14 05/18] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd1021c39..806451dc99 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v14 06/18] net/pcap: rework transmit burst handling

[Stephen Hemminger]

Replace the 64K stack-allocated bounce buffer with a per-queue
buffer allocated from hugepages via rte_malloc at queue setup.
This is necessary because the buffer may be used in a secondary
process transmit path where the primary process allocated it.

Fix error accounting: backpressure from pcap_sendpacket() (kernel
socket buffer full) was incorrectly counted as errors. Malformed
multi-segment mbufs where pkt_len exceeds actual data were silently
accepted; they are now detected via rte_pktmbuf_read() failure
and counted as errors.

Add datapath debug logging macros (PMD_RX_LOG, PMD_TX_LOG) gated
on RTE_ETHDEV_DEBUG_RX/TX. Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS
in device capabilities since the driver has always supported
multi-segment transmit. Add tx_queue_release to free the bounce
buffer.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 122 +++++++++++++++++++++------------
 drivers/net/pcap/pcap_osdep.h  |  14 ++++
 2 files changed, 92 insertions(+), 44 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 806451dc99..4761741edd 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -12,6 +12,7 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <unistd.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -91,6 +92,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -385,18 +389,17 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -404,25 +407,28 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len, caplen;
+		const uint8_t *data;
+
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
-		num_tx++;
-		tx_bytes += caplen;
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+		if (unlikely(data == NULL)) {
+			/* This only happens if mbuf is bogus pkt_len > data_len */
+			PMD_TX_LOG(ERR, "rte_pktmbuf_read failed");
+			dumper_q->tx_stat.err_pkts++;
+		} else {
+			pcap_dump((u_char *)dumper, &header, data);
+
+			num_tx++;
+			tx_bytes += caplen;
+		}
+
 		rte_pktmbuf_free(mbuf);
 	}
 
@@ -449,9 +455,6 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
 	for (i = 0; i < nb_pkts; i++) {
 		tx_bytes += bufs[i]->pkt_len;
 		rte_pktmbuf_free(bufs[i]);
@@ -460,60 +463,74 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
- * Callback to handle sending packets through a real NIC.
+ * Send a burst of packets to a pcap device.
+ *
+ * On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
+ * socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
+ * The send() call only blocks when the kernel socket send buffer is full,
+ * providing limited backpressure.
+ *
+ * On error, pcap_sendpacket() returns non-zero and the loop breaks,
+ * leaving remaining packets unsent.
+ *
+ * Bottom line: backpressure is not an error.
  */
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		const uint8_t *data;
+
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+			PMD_TX_LOG(ERR,
+				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
+				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
+		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		if (unlikely(data == NULL)) {
+			/* This only happens if mbuf is bogus pkt_len > data_len */
+			PMD_TX_LOG(ERR, "rte_pktmbuf_read failed");
+			tx_queue->tx_stat.err_pkts++;
+		} else {
+			/* Unfortunately, libpcap collapses transient (-EBUSY) and hard errors. */
+			if (pcap_sendpacket(pcap, data, len) != 0) {
+				PMD_TX_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
+				break;
+			}
+			num_tx++;
+			tx_bytes += len;
+		}
+
 		rte_pktmbuf_free(mbuf);
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
 
 	return i;
 }
@@ -753,6 +770,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
@@ -965,7 +983,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -973,11 +991,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1018,6 +1051,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..fe7399ff9f 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,6 +13,20 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+#ifdef RTE_ETHDEV_DEBUG_RX
+#define PMD_RX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() rx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_RX_LOG(...) do { } while (0)
+#endif
+
+#ifdef RTE_ETHDEV_DEBUG_TX
+#define PMD_TX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() tx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_TX_LOG(...) do { } while (0)
+#endif
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
-- 
2.51.0

[PATCH v14 07/18] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4761741edd..f6adc23463 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -103,9 +104,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -115,25 +116,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -889,7 +890,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1214,29 +1215,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1512,7 +1503,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1551,9 +1542,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1703,5 +1694,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.51.0

[PATCH v14 08/18] net/pcap: support VLAN strip and insert offloads

[Stephen Hemminger]

Add VLAN tag handling to the pcap PMD, consistent with how virtio
and af_packet drivers implement it.

RX strip: when RTE_ETH_RX_OFFLOAD_VLAN_STRIP is enabled, the driver
calls rte_vlan_strip() on received packets in both normal and
infinite_rx modes. For infinite_rx, offloads are deferred to
packet delivery rather than applied during ring fill, so the
stored template packets remain unmodified.

TX insert: when RTE_MBUF_F_TX_VLAN is set on an mbuf, the driver
inserts the VLAN tag via rte_vlan_insert() before writing to pcap
or sending to the interface. Indirect or shared mbufs get a new
header mbuf to avoid modifying the original.

Runtime reconfiguration is supported through vlan_offload_set,
which propagates the strip setting to all active RX queues.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |   1 +
 doc/guides/nics/pcap.rst               |  11 +++
 doc/guides/rel_notes/release_26_03.rst |   4 +
 drivers/net/pcap/pcap_ethdev.c         | 118 ++++++++++++++++++++++++-
 4 files changed, 130 insertions(+), 4 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..814bc2119f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index fbfe854bb1..bed5006a42 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -247,3 +247,14 @@ will be discarded by the Rx flushing operation.
    The network interface provided to the PMD should be up.
    The PMD will return an error if the interface is down,
    and the PMD itself won't change the status of the external network interface.
+
+Features and Limitations
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 5c2a4bb32e..eb80c8a785 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -82,6 +82,10 @@ New Features
   * NEA5, NIA5, NCA5: AES 256 confidentiality, integrity and AEAD modes.
   * NEA6, NIA6, NCA6: ZUC 256 confidentiality, integrity and AEAD modes.
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f6adc23463..51f0fdbfd7 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -77,6 +77,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -107,6 +108,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -271,7 +273,11 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		bufs[i]->data_len = pcap_buf->data_len;
 		bufs[i]->pkt_len = pcap_buf->pkt_len;
 		bufs[i]->port = pcap_q->port_id;
-		rx_bytes += pcap_buf->data_len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(bufs[i]);
+
+		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
 		rte_ring_enqueue(pcap_q->pkts, pcap_buf);
@@ -337,6 +343,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -383,6 +393,57 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+
+/*
+ * If Vlan offload flag is present, insert the vlan.
+ */
+static inline int
+eth_pcap_tx_vlan(struct pcap_tx_queue *tx_queue, struct rte_mbuf **mbuf)
+{
+	struct rte_mbuf *mb = *mbuf;
+
+	if ((mb->ol_flags & RTE_MBUF_F_TX_VLAN) == 0)
+		return 0;
+
+	if (unlikely(mb->data_len < RTE_ETHER_HDR_LEN)) {
+		PMD_TX_LOG(ERR, "mbuf missing ether header");
+		goto error;
+	}
+
+	/* Need at another buffer to hold VLAN header? */
+	if (!RTE_MBUF_DIRECT(mb) || rte_mbuf_refcnt_read(mb) > 1) {
+		struct rte_mbuf *mh = rte_pktmbuf_alloc(mb->pool);
+		if (unlikely(mh == NULL)) {
+			PMD_TX_LOG(ERR, "mbuf pool exhausted on transmit vlan");
+			goto error;
+		}
+
+		/* Move original ethernet header into new mbuf */
+		memcpy(rte_pktmbuf_mtod(mh, void *),
+		       rte_pktmbuf_mtod(mb, void *), RTE_ETHER_HDR_LEN);
+
+		rte_pktmbuf_adj(mb, RTE_ETHER_HDR_LEN);
+		mh->nb_segs = mb->nb_segs + 1;
+		mh->data_len = RTE_ETHER_HDR_LEN;
+		mh->pkt_len = mb->pkt_len + RTE_ETHER_HDR_LEN;
+		mh->ol_flags = mb->ol_flags;
+		mh->next = mb;
+
+		*mbuf = mh;
+	}
+
+	int ret = rte_vlan_insert(mbuf);
+	if (unlikely(ret != 0)) {
+		PMD_TX_LOG(ERR, "Vlan insert failed: %s", strerror(-ret));
+		goto error;
+	}
+	return 0;
+error:
+	rte_pktmbuf_free(*mbuf);
+	tx_queue->tx_stat.err_pkts++;
+	return -1;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -408,13 +469,17 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
 		const uint8_t *data;
 
+		if (eth_pcap_tx_vlan(dumper_q, &bufs[i]) < 0)
+			continue;
+
+		struct rte_mbuf *mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -499,6 +564,9 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
+		if (eth_pcap_tx_vlan(tx_queue, &bufs[i]) < 0)
+			continue;
+
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
@@ -754,8 +822,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -771,7 +844,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -918,6 +993,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
@@ -927,6 +1003,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		uint64_t pcap_pkt_count = 0;
 		struct rte_mbuf *bufs[1];
 		pcap_t **pcap;
+		bool save_vlan_strip;
 
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
@@ -946,11 +1023,20 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		if (!pcap_q->pkts)
 			return -ENOENT;
 
+		/*
+		 * Temporarily disable offloads while filling the ring
+		 * with raw packets. VLAN strip and timestamp will be
+		 * applied later in eth_pcap_rx_infinite() on each copy.
+		 */
+		save_vlan_strip = pcap_q->vlan_strip;
+		pcap_q->vlan_strip = false;
+
 		/* Fill ring with packets from PCAP file one by one. */
 		while (eth_pcap_rx(pcap_q, bufs, 1)) {
 			/* Check for multiseg mbufs. */
 			if (bufs[0]->nb_segs != 1) {
 				infinite_rx_ring_free(pcap_q->pkts);
+				pcap_q->vlan_strip = save_vlan_strip;
 				PMD_LOG(ERR,
 					"Multiseg mbufs are not supported in infinite_rx mode.");
 				return -EINVAL;
@@ -960,6 +1046,9 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 					(void * const *)bufs, 1, NULL);
 		}
 
+		/* Restore offloads for use during packet delivery */
+		pcap_q->vlan_strip = save_vlan_strip;
+
 		if (rte_ring_count(pcap_q->pkts) < pcap_pkt_count) {
 			infinite_rx_ring_free(pcap_q->pkts);
 			PMD_LOG(ERR,
@@ -1044,6 +1133,26 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	unsigned int i;
+
+	if (mask & RTE_ETH_VLAN_STRIP_MASK) {
+		bool vlan_strip = !!(dev->data->dev_conf.rxmode.offloads &
+				     RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+
+		internals->vlan_strip = vlan_strip;
+
+		/* Update all RX queues */
+		for (i = 0; i < dev->data->nb_rx_queues; i++)
+			internals->rx_queue[i].vlan_strip = vlan_strip;
+	}
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1060,6 +1169,7 @@ static const struct eth_dev_ops ops = {
 	.link_update = eth_link_update,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.vlan_offload_set = eth_vlan_offload_set,
 };
 
 static int
-- 
2.51.0

[PATCH v14 09/18] net/pcap: add link state and speed for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent functions to query the real link state, speed,
duplex, and autonegotiation settings from the underlying interface.
The eth_link_update() callback now returns accurate information
when operating in pass-through mode.

Linux uses ETHTOOL_GLINKSETTINGS which supports all speeds up to
800 Gbps. FreeBSD uses SIOCGIFMEDIA, and Windows uses
GetAdaptersAddresses().

For pcap file mode or separate rx/tx interface configurations,
default values continue to be used since there is no single
underlying interface to query.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         |  93 ++++++++++++++++---
 drivers/net/pcap/pcap_osdep.h          |  24 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  |  86 ++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 118 +++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  |  95 +++++++++++++++++---
 6 files changed, 394 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index eb80c8a785..42ecba925e 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -85,6 +85,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state and speed in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 51f0fdbfd7..22d668163e 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -151,13 +151,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -972,11 +965,84 @@ eth_dev_close(struct rte_eth_dev *dev)
 	return 0;
 }
 
+/*
+ * Convert osdep speed (Mbps) to rte_eth_link speed constant.
+ */
+static uint32_t
+speed_mbps_to_rte(uint32_t speed_mbps)
+{
+	switch (speed_mbps) {
+	case 10:
+		return RTE_ETH_SPEED_NUM_10M;
+	case 100:
+		return RTE_ETH_SPEED_NUM_100M;
+	case 1000:
+		return RTE_ETH_SPEED_NUM_1G;
+	case 2500:
+		return RTE_ETH_SPEED_NUM_2_5G;
+	case 5000:
+		return RTE_ETH_SPEED_NUM_5G;
+	case 10000:
+		return RTE_ETH_SPEED_NUM_10G;
+	case 20000:
+		return RTE_ETH_SPEED_NUM_20G;
+	case 25000:
+		return RTE_ETH_SPEED_NUM_25G;
+	case 40000:
+		return RTE_ETH_SPEED_NUM_40G;
+	case 50000:
+		return RTE_ETH_SPEED_NUM_50G;
+	case 56000:
+		return RTE_ETH_SPEED_NUM_56G;
+	case 100000:
+		return RTE_ETH_SPEED_NUM_100G;
+	case 200000:
+		return RTE_ETH_SPEED_NUM_200G;
+	case 400000:
+		return RTE_ETH_SPEED_NUM_400G;
+	case 800000:
+		return RTE_ETH_SPEED_NUM_800G;
+	default:
+		return RTE_ETH_SPEED_NUM_UNKNOWN;
+	}
+}
+
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	const char *iface_name = internals->rx_queue[0].name;
+	struct rte_eth_link link;
+	struct osdep_iface_link osdep_link;
+
+	memset(&link, 0, sizeof(link));
+
+	/*
+	 * For pass-through mode (single_iface), query the actual interface.
+	 * Otherwise, use the default static link values.
+	 */
+	if (internals->single_iface &&
+	    osdep_iface_link_get(iface_name, &osdep_link) == 0) {
+		link.link_speed = speed_mbps_to_rte(osdep_link.link_speed);
+		link.link_status = osdep_link.link_status ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_duplex = osdep_link.link_duplex ?
+			RTE_ETH_LINK_FULL_DUPLEX : RTE_ETH_LINK_HALF_DUPLEX;
+		link.link_autoneg = osdep_link.link_autoneg ?
+			RTE_ETH_LINK_AUTONEG : RTE_ETH_LINK_FIXED;
+	} else {
+		/*
+		 * Not in pass-through mode (using pcap files or separate
+		 * interfaces for rx/tx). Or query failed. Use default values.
+		 */
+		link.link_speed = RTE_ETH_SPEED_NUM_10G;
+		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_autoneg = RTE_ETH_LINK_FIXED;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1391,7 +1457,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index fe7399ff9f..b72dd0d74c 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -10,6 +10,7 @@
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
+
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
@@ -27,7 +28,30 @@ extern int eth_pcap_logtype;
 #define PMD_TX_LOG(...) do { } while (0)
 #endif
 
+/**
+ * Link information returned by osdep_iface_link_get().
+ */
+struct osdep_iface_link {
+	uint32_t link_speed;    /**< Speed in Mbps, 0 if unknown */
+	uint8_t link_status;    /**< 1 = up, 0 = down */
+	uint8_t link_duplex;    /**< 1 = full, 0 = half */
+	uint8_t link_autoneg;   /**< 1 = autoneg enabled, 0 = fixed */
+};
+
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link state and speed for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @param link
+ *   Pointer to structure to fill with link information.
+ * @return
+ *   0 on success, -1 on failure.
+ */
+int osdep_iface_link_get(const char *name, struct osdep_iface_link *link);
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..5963b67087 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,12 +5,36 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
 
+/*
+ * Userspace implementation of ifmedia_baudrate().
+ * The kernel function is not exported to userspace, so we implement
+ * our own using the IFM_BAUDRATE_DESCRIPTIONS table from if_media.h.
+ */
+static uint64_t
+ifmedia_baudrate_user(int mword)
+{
+	static const struct ifmedia_baudrate descs[] =
+		IFM_BAUDRATE_DESCRIPTIONS;
+	const struct ifmedia_baudrate *desc;
+
+	for (desc = descs; desc->ifmb_word != 0; desc++) {
+		if (IFM_TYPE_MATCH(desc->ifmb_word, mword))
+			return desc->ifmb_baudrate;
+	}
+	return 0;
+}
+
 int
 osdep_iface_index_get(const char *name)
 {
@@ -55,3 +79,65 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifmediareq ifmr;
+	struct ifreq ifr;
+	uint64_t baudrate;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine administrative status */
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		if (ifr.ifr_flags & IFF_UP)
+			link->link_status = 1;
+	}
+
+	/* Get media status for speed, duplex, and link state */
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(if_fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* Check if link is actually active */
+		if (!(ifmr.ifm_status & IFM_ACTIVE))
+			link->link_status = 0;
+
+		/* Only parse media if we have a valid current media type */
+		if (ifmr.ifm_current != 0 && IFM_TYPE(ifmr.ifm_current) == IFM_ETHER) {
+			/* Use userspace baudrate lookup */
+			baudrate = ifmedia_baudrate_user(ifmr.ifm_current);
+			link->link_speed = baudrate / 1000000;
+
+			/* Check duplex - FDX option means full duplex */
+			if (IFM_OPTIONS(ifmr.ifm_current) & IFM_FDX)
+				link->link_duplex = 1;
+			else
+				link->link_duplex = 0;
+		} else {
+			/* Default to full duplex if we can't determine */
+			link->link_duplex = 1;
+		}
+
+		/* Check autonegotiation status */
+		link->link_autoneg = (ifmr.ifm_current & IFM_AUTO) ? 1 : 0;
+	} else {
+		/*
+		 * SIOCGIFMEDIA failed - interface may not support it.
+		 * Default to reasonable values.
+		 */
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..3b56a833a9 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,11 +4,14 @@
  * All rights reserved.
  */
 
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include <rte_string_fns.h>
 
@@ -40,3 +43,118 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+/*
+ * Get link speed, duplex, and autoneg using ETHTOOL_GLINKSETTINGS.
+ *
+ * ETHTOOL_GLINKSETTINGS was introduced in kernel 4.7 and supports
+ * speeds beyond 65535 Mbps (up to 800 Gbps and beyond).
+ * DPDK requires kernel 4.19 or later, so this interface is always available.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+get_link_settings(int fd, struct ifreq *ifr, struct osdep_iface_link *link)
+{
+	struct ethtool_link_settings probe = { };
+	struct ethtool_link_settings *req;
+	size_t req_size;
+	int nwords;
+	int ret = -1;
+
+	/* First call with nwords = 0 to get the required size */
+	probe.cmd = ETHTOOL_GLINKSETTINGS;
+	ifr->ifr_data = (void *)&probe;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Kernel returns negative nwords on first call */
+	if (probe.link_mode_masks_nwords >= 0)
+		return -1;
+
+	nwords = -probe.link_mode_masks_nwords;
+
+	/* Bounds check */
+	if (nwords == 0 || nwords > 127)
+		return -1;
+
+	/* Second call with correct nwords - need space for 3 link mode masks */
+	req_size = sizeof(*req) + 3 * nwords * sizeof(uint32_t);
+	req = malloc(req_size);
+	if (req == NULL)
+		return -1;
+
+	memset(req, 0, req_size);
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	req->link_mode_masks_nwords = nwords;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		goto out;
+
+	/* Speed is in Mbps, directly usable */
+	link->link_speed = req->speed;
+
+	/* Handle special values */
+	if (link->link_speed == (uint32_t)SPEED_UNKNOWN ||
+	    link->link_speed == (uint32_t)-1)
+		link->link_speed = 0;
+
+	switch (req->duplex) {
+	case DUPLEX_FULL:
+		link->link_duplex = 1;
+		break;
+	case DUPLEX_HALF:
+		link->link_duplex = 0;
+		break;
+	default:
+		link->link_duplex = 1;  /* Default to full duplex */
+		break;
+	}
+
+	link->link_autoneg = (req->autoneg == AUTONEG_ENABLE) ? 1 : 0;
+	ret = 0;
+out:
+	free(req);
+	return ret;
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifreq ifr;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine link status */
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up
+		 * IFF_RUNNING means operationally up (carrier detected)
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			link->link_status = 1;
+	}
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (get_link_settings(if_fd, &ifr, link) < 0) {
+		/*
+		 * ethtool failed - interface may not support it
+		 * (e.g., virtual interfaces like veth, lo).
+		 * Use reasonable defaults.
+		 */
+		link->link_speed = 0;
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..1b76ae3185 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,56 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_get(const char *device_name, struct osdep_iface_link *link)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	memset(link, 0, sizeof(*link));
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			/* Check operational status */
+			if (cur->OperStatus == IfOperStatusUp)
+				link->link_status = 1;
+			else
+				link->link_status = 0;
+
+			/*
+			 * TransmitLinkSpeed and ReceiveLinkSpeed are in bits/sec.
+			 * Convert to Mbps. Use transmit speed as the link speed.
+			 * For asymmetric links, this is a reasonable approximation.
+			 */
+			if (cur->TransmitLinkSpeed != 0 &&
+			    cur->TransmitLinkSpeed != (ULONG64)-1) {
+				link->link_speed =
+					(uint32_t)(cur->TransmitLinkSpeed / 1000000ULL);
+			}
+
+			/*
+			 * Windows doesn't directly expose duplex/autoneg via
+			 * GetAdaptersAddresses(). Default to full duplex.
+			 * For more detailed info, WMI or OID queries would be needed.
+			 */
+			link->link_duplex = 1;  /* Assume full duplex */
+			link->link_autoneg = 0; /* Cannot determine */
+
+			ret = 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v14 10/18] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Add read_clock dev_op returning current UTC time for timestamp
  correlation.
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper.
* Enable immediate mode and improve error reporting
  in live capture setup.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |   3 +
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 157 +++++++++++++++++++------
 3 files changed, 127 insertions(+), 35 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index bed5006a42..2709c6d017 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -258,3 +258,6 @@ Features and Limitations
 *  The PMD will transparently insert a VLAN tag to transmitted packets if
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
+
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 42ecba925e..5953995b77 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -86,6 +86,8 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state and speed in ``iface`` mode.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 22d668163e..8e12f7cd0e 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -28,13 +28,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -78,6 +76,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -109,6 +108,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -270,6 +270,15 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(bufs[i]);
 
+		if (pcap_q->timestamp_offloading) {
+			struct timespec ts;
+
+			timespec_get(&ts, TIME_UTC);
+			*RTE_MBUF_DYNFIELD(bufs[i], timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(&ts);
+			bufs[i]->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
@@ -340,10 +349,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -363,14 +383,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -459,8 +484,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		uint32_t len, caplen;
 		const uint8_t *data;
@@ -470,9 +497,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 		struct rte_mbuf *mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -601,22 +625,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
+	}
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
+	}
+
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -663,7 +727,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -822,6 +887,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -839,7 +905,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -1061,6 +1128,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1199,6 +1267,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static int
 eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
 {
@@ -1225,6 +1304,7 @@ static const struct eth_dev_ops ops = {
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1640,15 +1720,22 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		hz = rte_get_timer_hz();
+		if (hz == 0) {
+			PMD_LOG(ERR, "Reported hz is zero!");
+			return -1;
+		}
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							 &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v14 11/18] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 8e12f7cd0e..3522401b5e 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -669,6 +669,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.51.0

[PATCH v14 12/18] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 3522401b5e..89c1eac8d2 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -47,11 +47,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -627,6 +625,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -738,6 +737,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1541,6 +1542,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v14 13/18] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 89c1eac8d2..d4f8811572 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -55,10 +55,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -928,11 +928,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v14 14/18] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index d4f8811572..6562f0ecc5 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -911,10 +911,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v14 15/18] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

Example usage:
  --vdev 'net_pcap0,iface=eth0,snaplen=1518'
  --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |  15 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 235 ++++++++++++++++---------
 3 files changed, 165 insertions(+), 86 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2709c6d017..f241069ebb 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -162,6 +162,21 @@ Runtime Config Options
 
   In this case, one dummy Rx queue is created for each Tx queue argument passed.
 
+* Set the snapshot length for packet capture
+
+  The snapshot length controls the maximum number of bytes captured per packet.
+  This affects both interface capture and pcap file output.  The default value is
+  65535 bytes, which captures complete packets up to the maximum Ethernet jumbo
+  frame size.  Reducing this value can improve performance when only packet headers
+  are needed.  This can be done with the ``snaplen`` devarg, for example::
+
+     --vdev 'net_pcap0,iface=eth0,snaplen=1518'
+     --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'
+
+  The snapshot length also determines the reported ``max_rx_pktlen``
+  and ``max_mtu`` in device info.
+
+
 Examples of Usage
 ~~~~~~~~~~~~~~~~~
 
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 5953995b77..4d9303ca3a 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -88,6 +88,7 @@ New Features
   * Added support for reporting link state and speed in ``iface`` mode.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 6562f0ecc5..6863b78b49 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -14,6 +14,7 @@
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <net/if.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -32,8 +33,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -42,6 +41,12 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
+
+/* This is defined in libpcap but not exposed in headers */
+#define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -102,6 +107,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -129,6 +135,7 @@ struct pmd_devargs {
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -146,11 +153,16 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declaration */
+static inline int set_iface_direction(const char *iface, pcap_t *pcap,
+				      pcap_direction_t direction);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -466,20 +478,19 @@ eth_pcap_tx_vlan(struct pcap_tx_queue *tx_queue, struct rte_mbuf **mbuf)
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -487,14 +498,15 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		uint32_t len, caplen;
 		const uint8_t *data;
 
 		if (eth_pcap_tx_vlan(dumper_q, &bufs[i]) < 0)
 			continue;
 
 		struct rte_mbuf *mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t caplen = RTE_MIN(len, snaplen);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -563,19 +575,18 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
@@ -586,10 +597,10 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > snaplen)) {
 			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
-				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+				len, snaplen);
 			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
@@ -623,7 +634,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -652,7 +663,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -666,6 +677,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -694,9 +708,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -705,7 +719,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -715,7 +730,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -724,9 +739,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -776,15 +791,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
 		rx = &internals->rx_queue[0];
 
-		if (!pp->tx_pcap[0] &&
-			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+		if (!pp->tx_pcap[0] && strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -796,14 +811,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -818,9 +830,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -911,11 +928,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1228,7 +1245,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1358,6 +1375,12 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *rx = extra_args;
 	pcap_t *pcap = NULL;
 
+	if (access(pcap_filename, R_OK) != 0) {
+		PMD_LOG(ERR, "Cannot read pcap file '%s': %s",
+			pcap_filename, strerror(errno));
+		return -1;
+	}
+
 	if (open_single_rx_pcap(pcap_filename, &pcap) < 0)
 		return -1;
 
@@ -1370,41 +1393,53 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 }
 
 /*
- * Opens a pcap file for writing and stores a reference to it
- * for use it later on.
+ * Store TX pcap file configuration.
+ * The actual pcap dumper is opened in eth_dev_start().
  */
 static int
 open_tx_pcap(const char *key, const char *value, void *extra_args)
 {
 	const char *pcap_filename = value;
 	struct pmd_devargs *dumpers = extra_args;
-	pcap_dumper_t *dumper;
+	FILE *f;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	/* Validate that pcap_filename can be created. */
+	if (strcmp(pcap_filename, "-") == 0) {
+		/* This isn't going to work very well in DPDK - so reject it */
+		PMD_LOG(ERR, "Sending pcap binary data to stdout is not supported");
 		return -1;
+	}
 
-	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
-		pcap_dump_close(dumper);
+	f = fopen(pcap_filename, "wb");
+	if (f == NULL) {
+		PMD_LOG(ERR, "Cannot open '%s' for writing: %s", pcap_filename, strerror(errno));
 		return -1;
 	}
+	fclose(f);
+
+	if (add_queue(dumpers, pcap_filename, key, NULL, NULL) < 0)
+		return -1;
 
 	return 0;
 }
 
 /*
- * Opens an interface for reading and writing
+ * Store interface configuration for reading and writing.
+ * The actual pcap handle is opened in eth_dev_start().
  */
 static inline int
 open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *tx = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (if_nametoindex(iface) == 0) {
+		PMD_LOG(ERR, "Interface '%s' not found: %s",
+			iface, strerror(errno));
 		return -1;
+	}
 
-	tx->queue[0].pcap = pcap;
+	tx->queue[0].pcap = NULL;
 	tx->queue[0].name = iface;
 	tx->queue[0].type = key;
 
@@ -1426,50 +1461,38 @@ set_iface_direction(const char *iface, pcap_t *pcap,
 	return 0;
 }
 
+/*
+ * Store interface configuration.
+ * The actual pcap handle is opened in eth_dev_start().
+ */
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *pmd = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
-		return -1;
-	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
-		pcap_close(pcap);
+	if (if_nametoindex(iface) == 0) {
+		PMD_LOG(ERR, "Interface '%s' not found: %s",
+			iface, strerror(errno));
 		return -1;
 	}
 
+	if (add_queue(pmd, iface, key, NULL, NULL) < 0)
+		return -1;
+
 	return 0;
 }
 
 /*
- * Opens a NIC for reading packets from it
+ * Store RX interface configuration.
+ * The actual pcap handle is opened and direction set in eth_dev_start().
  */
-static inline int
-open_rx_iface(const char *key, const char *value, void *extra_args)
-{
-	int ret = open_iface(key, value, extra_args);
-	if (ret < 0)
-		return ret;
-	if (strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
-		struct pmd_devargs *pmd = extra_args;
-		unsigned int qid = pmd->num_of_queue - 1;
-
-		set_iface_direction(pmd->queue[qid].name,
-				pmd->queue[qid].pcap,
-				PCAP_D_IN);
-	}
-
-	return 0;
-}
-
 static inline int
 rx_iface_args_process(const char *key, const char *value, void *extra_args)
 {
 	if (strcmp(key, ETH_PCAP_RX_IFACE_ARG) == 0 ||
-			strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
-		return open_rx_iface(key, value, extra_args);
+	    strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+		return open_iface(key, value, extra_args);
 
 	return 0;
 }
@@ -1501,6 +1524,31 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN ||
+	    val > ETH_PCAP_MAXIMUM_SNAPLEN) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1665,6 +1713,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1725,6 +1775,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1772,7 +1823,18 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	}
 
 	/*
-	 * If iface argument is passed we open the NICs and use them for
+	 * Process optional snapshot length argument.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+	/*
+	 * If iface argument is passed we check that NIC can be used
 	 * reading / writing
 	 */
 	if (rte_kvargs_count(kvlist, ETH_PCAP_IFACE_ARG) == 1) {
@@ -1977,4 +2039,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v14 16/18] net/pcap: add link status change support for iface mode

[Stephen Hemminger]

Add LSC interrupt support for pass-through (iface=) mode so
applications can receive link state change notifications via
the standard ethdev callback mechanism.

Uses alarm-based polling to periodically check the underlying
interface state via osdep_iface_link_get(). The LSC flag is
advertised only for iface mode devices, and polling is gated
on the application enabling intr_conf.lsc in port configuration.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 44 +++++++++++++++++++++++++-
 3 files changed, 45 insertions(+), 1 deletion(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 814bc2119f..084fefbbbb 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -5,6 +5,7 @@
 ;
 [Features]
 Link status          = Y
+Link status event    = Y
 Queue start/stop     = Y
 Scattered Rx         = Y
 Timestamp offload    = Y
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 4d9303ca3a..e614d8a8ac 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -89,6 +89,7 @@ New Features
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added support for Link State interrupt in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 6863b78b49..afb68998e7 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -17,6 +17,7 @@
 #include <net/if.h>
 #include <pcap.h>
 
+#include <rte_alarm.h>
 #include <rte_cycles.h>
 #include <rte_ring.h>
 #include <rte_ethdev.h>
@@ -48,6 +49,8 @@
 /* This is defined in libpcap but not exposed in headers */
 #define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
+#define ETH_PCAP_LSC_POLL_INTERVAL_US (1000 * 1000) /* 1 second */
+
 #define ETH_PCAP_ARG_MAXLEN	64
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
@@ -113,6 +116,7 @@ struct pmd_internals {
 	bool infinite_rx;
 	bool vlan_strip;
 	bool timestamp_offloading;
+	bool lsc_active;
 };
 
 struct pmd_process_private {
@@ -159,9 +163,10 @@ static const char *valid_arguments[] = {
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
-/* Forward declaration */
+/* Forward declarations */
 static inline int set_iface_direction(const char *iface, pcap_t *pcap,
 				      pcap_direction_t direction);
+static int eth_link_update(struct rte_eth_dev *dev, int wait_to_complete);
 
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
@@ -783,6 +788,28 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+/*
+ * Perodic alarm to poll link state.
+ * Enabled when link state interrupt is enabled in single_iface mode.
+ */
+static void
+eth_pcap_lsc_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link old_link, new_link;
+
+	rte_eth_linkstatus_get(dev, &old_link);
+	eth_link_update(dev, 0);
+	rte_eth_linkstatus_get(dev, &new_link);
+
+	if (old_link.link_status != new_link.link_status)
+		rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+
+	if (internals->lsc_active)
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US, eth_pcap_lsc_alarm, dev);
+}
+
 static int
 eth_dev_start(struct rte_eth_dev *dev)
 {
@@ -850,6 +877,12 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
+	/* Start LSC polling for iface mode if application requested it */
+	if (internals->single_iface && dev->data->dev_conf.intr_conf.lsc) {
+		internals->lsc_active = true;
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US,eth_pcap_lsc_alarm, dev);
+	}
+
 	return 0;
 }
 
@@ -867,6 +900,12 @@ eth_dev_stop(struct rte_eth_dev *dev)
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
+		/* Cancel LSC polling before closing pcap handles */
+		if (internals->lsc_active) {
+			internals->lsc_active = false;
+			rte_eal_alarm_cancel(eth_pcap_lsc_alarm, dev);
+		}
+
 		queue_missed_stat_on_stop_update(dev, 0);
 		if (pp->tx_pcap[0] != NULL) {
 			pcap_close(pp->tx_pcap[0]);
@@ -1704,6 +1743,9 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		internals->if_index =
 			osdep_iface_index_get(rx_queues->queue[0].name);
 
+		/* Enable LSC interrupt support for iface mode */
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 		/* phy_mac arg is applied only if "iface" devarg is provided */
 		if (rx_queues->phy_mac) {
 			if (eth_pcap_update_mac(rx_queues->queue[0].name,
-- 
2.51.0

[PATCH v14 17/18] net/pcap: add EOF notification via link status change

[Stephen Hemminger]

Add an "eof" devarg for rx_pcap mode that signals end-of-file by
setting link down and generating an LSC event. This allows
applications to detect when a pcap file has been fully consumed
using the standard ethdev callback mechanism.

The eof and infinite_rx options are mutually exclusive. On device
restart, the EOF state is reset so the file can be replayed.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               | 12 +++++
 doc/guides/rel_notes/release_26_03.rst |  2 +
 drivers/net/pcap/pcap_ethdev.c         | 75 ++++++++++++++++++++++++--
 3 files changed, 86 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index f241069ebb..6f3a4fc887 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -144,6 +144,18 @@ Runtime Config Options
   so all queues on a device will either have this enabled or disabled.
   This option should only be provided once per device.
 
+* Signal end-of-file via link status change
+
+  In case ``rx_pcap=`` configuration is set, the user may want to be notified when
+  all packets in the pcap file have been read.  This can be done with the ``eof``
+  devarg, for example::
+
+     --vdev 'net_pcap0,rx_pcap=file_rx.pcap,eof=1'
+
+  When enabled, the driver sets link down and generates an LSC event at end of file.
+  If the device is stopped and restarted, the EOF state is reset.
+  This option cannot be combined with ``infinite_rx``.
+
 * Drop all packets on transmit
 
   To drop all packets on transmit for a device,
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index e614d8a8ac..acd6450a59 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -90,6 +90,8 @@ New Features
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
   * Added support for Link State interrupt in ``iface`` mode.
+  * Added ``eof`` devarg to use link state to signal end of receive
+    file input.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index afb68998e7..8b091af6ee 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -42,6 +42,7 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_EOF_ARG          "eof"
 #define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
 
 #define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
@@ -114,6 +115,8 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool eof;
+	bool eof_signaled;
 	bool vlan_strip;
 	bool timestamp_offloading;
 	bool lsc_active;
@@ -146,6 +149,7 @@ struct pmd_devargs_all {
 	bool is_rx_pcap;
 	bool is_rx_iface;
 	bool infinite_rx;
+	bool eof;
 };
 
 static const char *valid_arguments[] = {
@@ -157,6 +161,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_EOF_ARG,
 	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
@@ -306,15 +311,33 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	return i;
 }
 
+/*
+ * Deferred EOF alarm callback.
+ *
+ * Scheduled from the RX burst path when end-of-file is reached,
+ * so that rte_eth_dev_callback_process() runs outside the datapath.
+ * This avoids holding any locks that the application callback
+ * might also need, preventing potential deadlocks.
+ */
+static void
+eth_pcap_eof_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+
+	rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+}
+
 static uint16_t
 eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
+	struct pcap_rx_queue *pcap_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[pcap_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
 	unsigned int i;
 	struct pcap_pkthdr *header;
 	struct pmd_process_private *pp;
 	const u_char *packet;
 	struct rte_mbuf *mbuf;
-	struct pcap_rx_queue *pcap_q = queue;
 	uint16_t num_rx = 0;
 	uint32_t rx_bytes = 0;
 	pcap_t *pcap;
@@ -335,6 +358,19 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			if (ret == PCAP_ERROR)
 				pcap_q->rx_stat.err_pkts++;
 
+			/*
+			 * EOF: if eof mode is enabled, set link down and
+			 * defer notification via alarm to avoid calling
+			 * rte_eth_dev_callback_process() from the datapath.
+			 */
+			else if (ret == PCAP_ERROR_BREAK) {
+				if (internals->eof && !internals->eof_signaled) {
+					internals->eof_signaled = true;
+					dev->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
+					rte_eal_alarm_set(1, eth_pcap_eof_alarm, dev);
+				}
+			}
+
 			break;
 		}
 
@@ -875,6 +911,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++)
 		dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
 
+	internals->eof_signaled = false;
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
 	/* Start LSC polling for iface mode if application requested it */
@@ -936,6 +973,10 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	}
 
 status_down:
+	/* Cancel any pending EOF alarm */
+	if (internals->eof_signaled)
+		rte_eal_alarm_cancel(eth_pcap_eof_alarm, dev);
+
 	for (i = 0; i < dev->data->nb_rx_queues; i++)
 		dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
 
@@ -1173,9 +1214,13 @@ eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 		 */
 		link.link_speed = RTE_ETH_SPEED_NUM_10G;
 		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
-		link.link_status = dev->data->dev_started ?
-			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 		link.link_autoneg = RTE_ETH_LINK_FIXED;
+
+		if (internals->eof_signaled)
+			link.link_status = RTE_ETH_LINK_DOWN;
+		else
+			link.link_status = dev->data->dev_started ?
+				RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 	}
 
 	return rte_eth_linkstatus_set(dev, &link);
@@ -1755,8 +1800,13 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->eof = devargs_all->eof;
 	internals->snapshot_len = devargs_all->snapshot_len;
 
+	/* Enable LSC for eof mode (already set above for single_iface) */
+	if (internals->eof)
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1943,6 +1993,24 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 					"for %s", name);
 		}
 
+		/*
+		 * Check whether to signal EOF via link status change.
+		 */
+		if (rte_kvargs_count(kvlist, ETH_PCAP_EOF_ARG) == 1) {
+			ret = rte_kvargs_process(kvlist, ETH_PCAP_EOF_ARG,
+						 &process_bool_flag,
+						 &devargs_all.eof);
+			if (ret < 0)
+				goto free_kvlist;
+		}
+
+		if (devargs_all.infinite_rx && devargs_all.eof) {
+			PMD_LOG(ERR, "Cannot use both infinite_rx and eof for %s",
+				name);
+			ret = -EINVAL;
+			goto free_kvlist;
+		}
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
 				&open_rx_pcap, &pcaps);
 	} else if (devargs_all.is_rx_iface) {
@@ -2082,4 +2150,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_EOF_ARG "=<0|1> "
 	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v14 18/18] test: add comprehensive test suite for pcap PMD

[Stephen Hemminger]

Add unit tests for the pcap PMD covering file and interface modes.

Tests include:
  - basic TX to file and RX from file
  - varied packet sizes and jumbo frames
  - infinite RX mode
  - TX drop mode
  - statistics
  - interface (iface=) pass-through mode
  - link status reporting for file and iface modes
  - link status change (LSC) with interface toggle
  - EOF notification via LSC
  - RX timestamps and timestamp with infinite RX
  - multiple TX/RX queues
  - VLAN strip, insert, and runtime offload configuration
  - snapshot length (snaplen) and truncation

Cross-platform helpers handle temp file creation, interface
discovery, and VLAN packet generation.

The LSC link toggle test requires a pre-created dummy interface
(Linux: dummy0, FreeBSD: disc0) and is skipped if unavailable.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3422 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 3425 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index 48874037eb..a83292cf49 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..5f57184d5f
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,3422 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define access _access
+#define F_OK 0
+#else
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port with custom config
+ */
+static int
+setup_pcap_port_conf(uint16_t port, const struct rte_eth_conf *conf)
+{
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port (default: timestamp offload)
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+	int ret;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+	int ret;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+	int ret;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+	int ret;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	int ret;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link Status Change (LSC) interrupt support
+ *
+ * Verifies that:
+ * 1. LSC capability is NOT advertised for file mode
+ * 2. LSC capability IS advertised for iface mode
+ * 3. LSC callback fires when the underlying interface goes down/up
+ *
+ * Requires a toggleable Ethernet interface created before running:
+ *   Linux:   ip link add dummy0 type dummy && ip link set dummy0 up
+ *   FreeBSD: ifconfig disc0 create && ifconfig disc0 up
+ *
+ * Skipped if no suitable interface is found or on Windows.
+ */
+
+/* Callback counter for LSC test */
+static volatile int lsc_callback_count;
+
+static int
+test_lsc_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	lsc_callback_count++;
+	return 0;
+}
+
+#ifndef RTE_EXEC_ENV_WINDOWS
+/*
+ * Helper: Set interface link up or down via ioctl.
+ * Returns 0 on success, -errno on failure.
+ */
+static int
+set_iface_up_down(const char *ifname, int up)
+{
+	struct ifreq ifr;
+	int fd, ret;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd < 0)
+		return -errno;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	ret = ioctl(fd, SIOCGIFFLAGS, &ifr);
+	if (ret < 0) {
+		ret = -errno;
+		close(fd);
+		return ret;
+	}
+
+	if (up)
+		ifr.ifr_flags |= IFF_UP;
+	else
+		ifr.ifr_flags &= ~IFF_UP;
+
+	ret = ioctl(fd, SIOCSIFFLAGS, &ifr);
+	if (ret < 0)
+		ret = -errno;
+	else
+		ret = 0;
+
+	close(fd);
+	return ret;
+}
+
+/*
+ * Helper: Find a toggleable test interface for LSC testing.
+ *
+ * Looks for well-known interfaces that are safe to bring up/down:
+ *   Linux:   dummy0 (ip link add dummy0 type dummy)
+ *   FreeBSD: disc0 (ifconfig disc0 create)
+ *
+ * Returns interface name or NULL if none found.
+ */
+static const char *
+find_lsc_test_iface(void)
+{
+	static const char *candidates[] = { "dummy0", "disc0" };
+	unsigned int i;
+
+	for (i = 0; i < RTE_DIM(candidates); i++) {
+		if (iface_is_ethernet(candidates[i]))
+			return candidates[i];
+	}
+	return NULL;
+}
+#endif
+
+static int
+test_lsc_iface(void)
+{
+	struct rte_eth_dev_info dev_info;
+	struct rte_eth_link link;
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	char devargs[256];
+	uint16_t port_id;
+	int ret;
+
+	printf("Testing Link Status Change (LSC) support\n");
+
+	/*
+	 * Test 1: Verify LSC is NOT advertised for file mode
+	 */
+	printf("  Testing file mode does not advertise LSC\n");
+	{
+		char lsc_pcap_path[PATH_MAX];
+		uint16_t file_port_id;
+
+		TEST_ASSERT(create_temp_path(lsc_pcap_path, sizeof(lsc_pcap_path),
+					     "pcap_lsc") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(lsc_pcap_path, 1) == 0,
+			    "Failed to create test pcap");
+
+		ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", lsc_pcap_path);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		TEST_ASSERT(create_pcap_vdev("net_pcap_lsc_file", devargs,
+					     &file_port_id) == 0,
+			    "Failed to create file vdev");
+
+		ret = rte_eth_dev_info_get(file_port_id, &dev_info);
+		TEST_ASSERT(ret == 0, "Failed to get dev info");
+
+		TEST_ASSERT((*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC) == 0,
+			    "File mode should NOT advertise LSC capability");
+
+		rte_vdev_uninit("net_pcap_lsc_file");
+		remove_temp_file(lsc_pcap_path);
+		printf("  File mode LSC check PASSED\n");
+	}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+	printf("  Link toggle test not supported on Windows, skipping\n");
+	return TEST_SUCCESS;
+#else
+	/*
+	 * Test 2: Use a toggleable interface to test link change events.
+	 * Skip if not present.
+	 */
+	const char *lsc_iface = find_lsc_test_iface();
+	if (lsc_iface == NULL) {
+		printf("  No toggleable interface found, skipping link change test\n");
+		printf("  Linux:   ip link add dummy0 type dummy && ip link set dummy0 up\n");
+		printf("  FreeBSD: ifconfig disc0 create && ifconfig disc0 up\n");
+		return TEST_SUCCESS;
+	}
+
+	printf("  Testing iface mode LSC with: %s\n", lsc_iface);
+
+	/* Ensure interface is up before we start */
+	ret = set_iface_up_down(lsc_iface, 1);
+	if (ret != 0) {
+		printf("  Cannot set %s up (%s), skipping\n",
+		       lsc_iface, strerror(-ret));
+		return TEST_SUCCESS;
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", lsc_iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_lsc", devargs);
+	if (ret < 0) {
+		printf("  Cannot create iface vdev for %s, skipping\n", lsc_iface);
+		return TEST_SUCCESS;
+	}
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_lsc", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "Iface mode should advertise LSC capability");
+	printf("    LSC capability advertised: yes\n");
+
+	/* Register LSC callback */
+	lsc_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_lsc_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link status");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+	printf("    Link after start: UP\n");
+
+	/* Bring interface down - should trigger LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 0);
+	TEST_ASSERT(ret == 0, "Failed to set %s down: %s",
+		    lsc_iface, strerror(-ret));
+
+	/* Wait for at least one poll cycle (1 second interval) */
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after down");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after interface down");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired, count=%d",
+		    lsc_callback_count);
+	printf("    Interface down: link DOWN, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Bring it back up - should trigger another LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 1);
+	TEST_ASSERT(ret == 0, "Failed to set %s up: %s",
+		    lsc_iface, strerror(-ret));
+
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after up");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after interface up");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired on link restore, count=%d",
+		    lsc_callback_count);
+	printf("    Interface up: link UP, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Cleanup */
+	rte_eth_dev_stop(port_id);
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_lsc_callback, NULL);
+	rte_vdev_uninit("net_pcap_lsc");
+
+	printf("LSC test PASSED\n");
+	return TEST_SUCCESS;
+#endif /* !RTE_EXEC_ENV_WINDOWS */
+}
+
+/*
+ * Test: EOF notification via link status change
+ *
+ * Verifies that:
+ * 1. The eof devarg causes link down + LSC event at end of pcap file
+ * 2. link_get reports DOWN after EOF
+ * 3. Stop/start resets the EOF state and replays the file
+ * 4. The eof and infinite_rx options are mutually exclusive
+ */
+
+static volatile int eof_callback_count;
+
+static int
+test_eof_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	eof_callback_count++;
+	return 0;
+}
+
+static int
+test_eof_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	struct rte_eth_link link;
+	char eof_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx;
+	int ret;
+
+	printf("Testing EOF notification via link status change\n");
+
+	/* Create pcap file with known number of packets */
+	TEST_ASSERT(create_temp_path(eof_pcap_path, sizeof(eof_pcap_path),
+				     "pcap_eof") == 0,
+		    "Failed to create temp file path");
+	TEST_ASSERT(create_test_pcap(eof_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/*
+	 * Test 1: EOF triggers link down and LSC callback
+	 */
+	printf("  Testing EOF triggers link down and LSC event\n");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,eof=1",
+		       eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create eof vdev: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_eof", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	struct rte_eth_dev_info dev_info;
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "EOF mode should advertise LSC capability");
+
+	/* Register LSC callback */
+	eof_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_eof_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Drain all packets from the pcap file */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			/* Got all packets and rx returned 0 — EOF hit */
+			break;
+		}
+	}
+
+	printf("    Received %u packets (expected %d)\n", total_rx, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Should receive exactly %d packets", NUM_PACKETS);
+
+	/* Verify link went down */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after EOF");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after EOF");
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	/* Verify callback fired exactly once */
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "LSC callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    EOF signaled: link DOWN, callback fired\n");
+
+	/*
+	 * Test 2: Stop/start resets EOF and replays the file
+	 */
+	printf("  Testing restart replays pcap file\n");
+
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	eof_callback_count = 0;
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to restart port");
+
+	/* Verify link is up again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after restart");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after restart");
+
+	/* Read packets again */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			break;
+		}
+	}
+
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Restart: should receive %d packets, got %u",
+			  NUM_PACKETS, total_rx);
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "Restart: callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    Restart replay: %u packets, EOF signaled again\n", total_rx);
+
+	/* Cleanup */
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_eof_callback, NULL);
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_eof");
+
+	/*
+	 * Test 3: eof + infinite_rx is rejected
+	 */
+	printf("  Testing eof + infinite_rx mutual exclusion\n");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,eof=1,infinite_rx=1", eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof_bad", devargs);
+	TEST_ASSERT(ret != 0, "eof + infinite_rx should be rejected");
+	printf("    Mutual exclusion check PASSED\n");
+
+	remove_temp_file(eof_pcap_path);
+
+	printf("EOF test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Runtime VLAN offload configuration via rte_eth_dev_set_vlan_offload
+ *
+ * This test verifies that VLAN strip can be enabled/disabled at runtime
+ * using the standard ethdev API rather than only at configure time.
+ * Uses infinite_rx mode so the same packets can be read in each phase.
+ */
+static int
+test_vlan_offload_set(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char vlan_set_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf = { 0 };
+	unsigned int i;
+	uint16_t nb_rx;
+	int ret, current_offload;
+	size_t tagged_len, untagged_len;
+
+	printf("Testing runtime VLAN offload configuration\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_set_pcap_path, sizeof(vlan_set_pcap_path),
+				     "pcap_vlan_set") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_set_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	/* Use infinite_rx so packets are always available */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", vlan_set_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_set", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+
+	/* Configure WITHOUT VLAN strip initially and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port");
+
+	/* Expected lengths */
+	tagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		     sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+	untagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN strip is initially disabled */
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled initially");
+
+	/*
+	 * Phase 1: VLAN strip disabled - packets should have tags
+	 */
+	printf("  Phase 1: VLAN strip disabled\n");
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 1");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 1 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact\n", nb_rx);
+
+	/*
+	 * Phase 2: Enable VLAN strip at runtime - packets should be stripped
+	 */
+	printf("  Phase 2: Enabling VLAN strip via rte_eth_dev_set_vlan_offload\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, RTE_ETH_VLAN_STRIP_OFFLOAD);
+	TEST_ASSERT(ret == 0, "Failed to enable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD,
+		    "VLAN strip should be enabled after set_vlan_offload");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 2");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), untagged_len,
+				  "Phase 2 packet %u: expected untagged length %zu, got %u",
+				  i, untagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Phase 2 packet %u: VLAN_STRIPPED flag not set", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags stripped\n", nb_rx);
+
+	/*
+	 * Phase 3: Disable VLAN strip - packets should have tags again
+	 */
+	printf("  Phase 3: Disabling VLAN strip\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to disable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled after clearing");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 3");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 3 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact again\n", nb_rx);
+
+	cleanup_pcap_vdev("net_pcap_vlan_set", port_id);
+	remove_temp_file(vlan_set_pcap_path);
+
+	printf("Runtime VLAN offload PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip in infinite RX mode
+ *
+ * This test verifies that VLAN strip offload works correctly when combined
+ * with infinite_rx mode, which uses a different RX path (eth_pcap_rx_infinite).
+ */
+static int
+test_vlan_strip_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	char vlan_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int stripped_count = 0;
+	int iter, attempts, ret;
+	size_t expected_len;
+
+	printf("Testing VLAN strip with infinite RX mode\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_inf_pcap_path, sizeof(vlan_inf_pcap_path),
+				     "pcap_vlan_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_inf_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets for infinite RX\n", NUM_PACKETS);
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", vlan_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_vlan_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_vlan_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with VLAN strip enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Expected length after VLAN strip */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Read packets - need more than file contains to verify infinite looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				/* Verify VLAN was stripped */
+				if (verify_no_vlan_tag(mbufs[i]) == 0 &&
+				    rte_pktmbuf_pkt_len(mbufs[i]) == expected_len &&
+				    (mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED))
+					stripped_count++;
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_vlan_inf");
+	remove_temp_file(vlan_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(stripped_count, total_rx,
+			  "VLAN strip failed: only %u/%u packets stripped correctly",
+			  stripped_count, total_rx);
+
+	printf("VLAN strip infinite RX PASSED: %u packets stripped (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Timestamps in infinite RX mode
+ *
+ * This test verifies that timestamp offload works correctly when combined
+ * with infinite_rx mode. Since infinite_rx generates packets on-the-fly,
+ * timestamps should reflect the current time rather than pcap file timestamps.
+ */
+static int
+test_timestamp_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	char ts_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int ts_count = 0;
+	int iter, attempts, ret;
+	rte_mbuf_timestamp_t first_ts = 0;
+	rte_mbuf_timestamp_t last_ts = 0;
+
+	printf("Testing timestamps with infinite RX mode\n");
+
+	/* Initialize timestamp dynamic field access */
+	if (timestamp_dynfield_offset < 0) {
+		ret = timestamp_init();
+		if (ret != 0) {
+			printf("Timestamp dynfield not available, skipping\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	/* Create simple pcap file */
+	TEST_ASSERT(create_temp_path(ts_inf_pcap_path, sizeof(ts_inf_pcap_path),
+				     "pcap_ts_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_test_pcap(ts_inf_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", ts_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_ts_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_ts_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with timestamp offload enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with timestamps");
+
+	/* Read packets */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				if (mbuf_has_timestamp(mbufs[i])) {
+					rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+
+					if (ts_count == 0)
+						first_ts = ts;
+					last_ts = ts;
+					ts_count++;
+				}
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_ts_inf");
+	remove_temp_file(ts_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(ts_count, total_rx,
+			  "Timestamp missing: only %u/%u packets have timestamps",
+			  ts_count, total_rx);
+
+	/* Timestamps should be monotonically increasing (current time) */
+	TEST_ASSERT(last_ts >= first_ts,
+		    "Timestamps not monotonic: first=%" PRIu64 " last=%" PRIu64,
+		    first_ts, last_ts);
+
+	printf("Timestamp infinite RX PASSED: %u packets with valid timestamps\n", total_rx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(infinite_pcap_path);
+	remove_temp_file(timestamp_pcap_path);
+	remove_temp_file(varied_pcap_path);
+	remove_temp_file(jumbo_pcap_path);
+
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++)
+		remove_temp_file(multi_tx_pcap_paths[i]);
+
+	remove_temp_file(multi_rx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+	remove_temp_file(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_lsc_iface),
+		TEST_CASE(test_eof_rx),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_vlan_offload_set),
+		TEST_CASE(test_vlan_strip_infinite_rx),
+		TEST_CASE(test_timestamp_infinite_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index acd6450a59..c48af82868 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -92,6 +92,7 @@ New Features
   * Added support for Link State interrupt in ``iface`` mode.
   * Added ``eof`` devarg to use link state to signal end of receive
     file input.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v15 00/18] net/pcap: improvements and test suite

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx and stripping on Rx
  - Runtime VLAN offload configuration via vlan_offload_set callback
  - Nanosecond precision timestamps (when hardware/libpcap supports it)
  - Accurate link state, speed, and duplex reporting in interface mode
  - Link status change (LSC) interrupt support in interface mode
  - EOF notification via link status change for rx_pcap mode
  - Support for Windows interface mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snaplen devarg

Bug fixes:
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Change Tx burst to always consume all packets; failed sends
    increment error counter rather than leaving mbufs for retry
    (pcap_sendpacket failures are not transient)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback
  - Fix infinite_rx ring fill applying VLAN strip and timestamp
    offloads to template packets, preventing those offloads from
    working correctly during packet delivery

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables
  - Defer pcap handle opening until device start
  - Use bulk free for better Tx performance

Testing:
  - Add comprehensive unit test suite covering basic operations,
    timestamps, jumbo frames, VLAN handling, multi-queue, and more
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows
  - New tests for runtime VLAN offload toggle, VLAN strip with
    infinite_rx mode, and timestamp generation in infinite_rx mode

v15:
  - Fix "Perodic" typo in LSC alarm comment
  - Fix missing space after comma in rte_eal_alarm_set() call
  - Use eth_link_update() instead of direct dev_link.link_status
    write in EOF rx path for proper atomic link status update
  - Add detailed comment block to eth_pcap_tx() documenting
    PF_PACKET backpressure semantics and tx_burst return convention
  - Add PMD_TX_LOG/PMD_RX_LOG conditional debug logging macros
    gated by RTE_ETHDEV_DEBUG_TX/RTE_ETHDEV_DEBUG_RX

v14:
  - Add LSC interrupt support for iface mode using alarm-based polling
  - Add EOF devarg for rx_pcap mode: signals end-of-file via link
    down and LSC event (mutually exclusive with infinite_rx)
  - Fix mbuf leak in eth_pcap_tx() when dropping oversized
    multi-segment packets (missing rte_pktmbuf_free before continue)
  - Fix rte_pktmbuf_read() NULL path falling through to success
    counters (num_tx/tx_bytes now inside else branch only)
  - Fix VLAN insert for indirect/shared mbufs: use rte_pktmbuf_adj()
    to advance data_off, preventing duplicated Ethernet header in
    the mbuf chain

v13:
  - Fix VLAN insert to pass mbuf by reference so caller sees
    updated pointer after indirect mbuf handling
  - Fix VLAN insert error path to not free mbuf (let bulk free
    handle it, avoiding double-free)
  - Fix handling of pcap_sendpacket() errors
  - Fix theoretical format string overflows in test suite


Stephen Hemminger (18):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: rework transmit burst handling
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN strip and insert offloads
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  net/pcap: add snapshot length devarg
  net/pcap: add link status change support for iface mode
  net/pcap: add EOF notification via link status change
  test: add comprehensive test suite for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3422 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    9 +
 doc/guides/nics/pcap.rst               |   41 +
 doc/guides/rel_notes/release_26_03.rst |   12 +
 drivers/net/pcap/pcap_ethdev.c         |  921 +++++--
 drivers/net/pcap/pcap_osdep.h          |   39 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   98 +-
 drivers/net/pcap/pcap_osdep_linux.c    |  124 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   95 +-
 11 files changed, 4525 insertions(+), 239 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v15 01/18] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 25fb109ef4..9a9a7d85c7 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v15 02/18] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v15 03/18] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v15 04/18] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..fbd1021c39 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v15 05/18] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd1021c39..806451dc99 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v15 06/18] net/pcap: rework transmit burst handling

[Stephen Hemminger]

Replace the 64K stack-allocated bounce buffer with a per-queue
buffer allocated from hugepages via rte_malloc at queue setup.
This is necessary because the buffer may be used in a secondary
process transmit path where the primary process allocated it.

Fix error accounting: backpressure from pcap_sendpacket() (kernel
socket buffer full) was incorrectly counted as errors. Malformed
multi-segment mbufs where pkt_len exceeds actual data were silently
accepted; they are now detected via rte_pktmbuf_read() failure
and counted as errors.

Add datapath debug logging macros (PMD_RX_LOG, PMD_TX_LOG) gated
on RTE_ETHDEV_DEBUG_RX/TX. Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS
in device capabilities since the driver has always supported
multi-segment transmit. Add tx_queue_release to free the bounce
buffer.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 122 +++++++++++++++++++++------------
 drivers/net/pcap/pcap_osdep.h  |  14 ++++
 2 files changed, 92 insertions(+), 44 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 806451dc99..4761741edd 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -12,6 +12,7 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <unistd.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -91,6 +92,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -385,18 +389,17 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -404,25 +407,28 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len, caplen;
+		const uint8_t *data;
+
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
-		num_tx++;
-		tx_bytes += caplen;
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+		if (unlikely(data == NULL)) {
+			/* This only happens if mbuf is bogus pkt_len > data_len */
+			PMD_TX_LOG(ERR, "rte_pktmbuf_read failed");
+			dumper_q->tx_stat.err_pkts++;
+		} else {
+			pcap_dump((u_char *)dumper, &header, data);
+
+			num_tx++;
+			tx_bytes += caplen;
+		}
+
 		rte_pktmbuf_free(mbuf);
 	}
 
@@ -449,9 +455,6 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
 	for (i = 0; i < nb_pkts; i++) {
 		tx_bytes += bufs[i]->pkt_len;
 		rte_pktmbuf_free(bufs[i]);
@@ -460,60 +463,74 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
- * Callback to handle sending packets through a real NIC.
+ * Send a burst of packets to a pcap device.
+ *
+ * On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
+ * socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
+ * The send() call only blocks when the kernel socket send buffer is full,
+ * providing limited backpressure.
+ *
+ * On error, pcap_sendpacket() returns non-zero and the loop breaks,
+ * leaving remaining packets unsent.
+ *
+ * Bottom line: backpressure is not an error.
  */
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
+		struct rte_mbuf *mbuf = bufs[i];
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		const uint8_t *data;
+
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+			PMD_TX_LOG(ERR,
+				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
+				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
+		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		if (unlikely(data == NULL)) {
+			/* This only happens if mbuf is bogus pkt_len > data_len */
+			PMD_TX_LOG(ERR, "rte_pktmbuf_read failed");
+			tx_queue->tx_stat.err_pkts++;
+		} else {
+			/* Unfortunately, libpcap collapses transient (-EBUSY) and hard errors. */
+			if (pcap_sendpacket(pcap, data, len) != 0) {
+				PMD_TX_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
+				break;
+			}
+			num_tx++;
+			tx_bytes += len;
+		}
+
 		rte_pktmbuf_free(mbuf);
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
 
 	return i;
 }
@@ -753,6 +770,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
@@ -965,7 +983,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -973,11 +991,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1018,6 +1051,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..fe7399ff9f 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,6 +13,20 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+#ifdef RTE_ETHDEV_DEBUG_RX
+#define PMD_RX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() rx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_RX_LOG(...) do { } while (0)
+#endif
+
+#ifdef RTE_ETHDEV_DEBUG_TX
+#define PMD_TX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() tx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_TX_LOG(...) do { } while (0)
+#endif
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
-- 
2.51.0

[PATCH v15 07/18] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4761741edd..f6adc23463 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -103,9 +104,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -115,25 +116,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -889,7 +890,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1214,29 +1215,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1512,7 +1503,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1551,9 +1542,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1703,5 +1694,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.51.0

[PATCH v15 08/18] net/pcap: support VLAN strip and insert offloads

[Stephen Hemminger]

Add VLAN tag handling to the pcap PMD, consistent with how virtio
and af_packet drivers implement it.

RX strip: when RTE_ETH_RX_OFFLOAD_VLAN_STRIP is enabled, the driver
calls rte_vlan_strip() on received packets in both normal and
infinite_rx modes. For infinite_rx, offloads are deferred to
packet delivery rather than applied during ring fill, so the
stored template packets remain unmodified.

TX insert: when RTE_MBUF_F_TX_VLAN is set on an mbuf, the driver
inserts the VLAN tag via rte_vlan_insert() before writing to pcap
or sending to the interface. Indirect or shared mbufs get a new
header mbuf to avoid modifying the original.

Runtime reconfiguration is supported through vlan_offload_set,
which propagates the strip setting to all active RX queues.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |   1 +
 doc/guides/nics/pcap.rst               |  11 +++
 doc/guides/rel_notes/release_26_03.rst |   4 +
 drivers/net/pcap/pcap_ethdev.c         | 118 ++++++++++++++++++++++++-
 4 files changed, 130 insertions(+), 4 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..814bc2119f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index fbfe854bb1..bed5006a42 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -247,3 +247,14 @@ will be discarded by the Rx flushing operation.
    The network interface provided to the PMD should be up.
    The PMD will return an error if the interface is down,
    and the PMD itself won't change the status of the external network interface.
+
+Features and Limitations
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index afdf1af06c..fa998f1620 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -87,6 +87,10 @@ New Features
   * Added support for AES-XTS cipher algorithm.
   * Added support for SHAKE-128 and SHAKE-256 authentication algorithms.
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f6adc23463..421a72a0cb 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -77,6 +77,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -107,6 +108,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -271,7 +273,11 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		bufs[i]->data_len = pcap_buf->data_len;
 		bufs[i]->pkt_len = pcap_buf->pkt_len;
 		bufs[i]->port = pcap_q->port_id;
-		rx_bytes += pcap_buf->data_len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(bufs[i]);
+
+		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
 		rte_ring_enqueue(pcap_q->pkts, pcap_buf);
@@ -337,6 +343,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -383,6 +393,57 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+
+/*
+ * If Vlan offload flag is present, insert the vlan.
+ */
+static inline int
+eth_pcap_tx_vlan(struct pcap_tx_queue *tx_queue, struct rte_mbuf **mbuf)
+{
+	struct rte_mbuf *mb = *mbuf;
+
+	if ((mb->ol_flags & RTE_MBUF_F_TX_VLAN) == 0)
+		return 0;
+
+	if (unlikely(mb->data_len < RTE_ETHER_HDR_LEN)) {
+		PMD_TX_LOG(ERR, "mbuf missing ether header");
+		goto error;
+	}
+
+	/* If indirect or shared then need another buffer to hold VLAN header? */
+	if (!RTE_MBUF_DIRECT(mb) || rte_mbuf_refcnt_read(mb) > 1) {
+		struct rte_mbuf *mh = rte_pktmbuf_alloc(mb->pool);
+		if (unlikely(mh == NULL)) {
+			PMD_TX_LOG(ERR, "mbuf pool exhausted on transmit vlan");
+			goto error;
+		}
+
+		/* Move original ethernet header into new mbuf */
+		memcpy(rte_pktmbuf_mtod(mh, void *),
+		       rte_pktmbuf_mtod(mb, void *), RTE_ETHER_HDR_LEN);
+
+		rte_pktmbuf_adj(mb, RTE_ETHER_HDR_LEN);
+		mh->nb_segs = mb->nb_segs + 1;
+		mh->data_len = RTE_ETHER_HDR_LEN;
+		mh->pkt_len = mb->pkt_len + RTE_ETHER_HDR_LEN;
+		mh->ol_flags = mb->ol_flags;
+		mh->next = mb;
+
+		*mbuf = mh;
+	}
+
+	int ret = rte_vlan_insert(mbuf);
+	if (unlikely(ret != 0)) {
+		PMD_TX_LOG(ERR, "Vlan insert failed: %s", strerror(-ret));
+		goto error;
+	}
+	return 0;
+error:
+	rte_pktmbuf_free(*mbuf);
+	tx_queue->tx_stat.err_pkts++;
+	return -1;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -408,13 +469,17 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
 		const uint8_t *data;
 
+		if (eth_pcap_tx_vlan(dumper_q, &bufs[i]) < 0)
+			continue;
+
+		struct rte_mbuf *mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -499,6 +564,9 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
+		if (eth_pcap_tx_vlan(tx_queue, &bufs[i]) < 0)
+			continue;
+
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
@@ -754,8 +822,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -771,7 +844,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -918,6 +993,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
@@ -927,6 +1003,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		uint64_t pcap_pkt_count = 0;
 		struct rte_mbuf *bufs[1];
 		pcap_t **pcap;
+		bool save_vlan_strip;
 
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
@@ -946,11 +1023,20 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		if (!pcap_q->pkts)
 			return -ENOENT;
 
+		/*
+		 * Temporarily disable offloads while filling the ring
+		 * with raw packets. VLAN strip and timestamp will be
+		 * applied later in eth_pcap_rx_infinite() on each copy.
+		 */
+		save_vlan_strip = pcap_q->vlan_strip;
+		pcap_q->vlan_strip = false;
+
 		/* Fill ring with packets from PCAP file one by one. */
 		while (eth_pcap_rx(pcap_q, bufs, 1)) {
 			/* Check for multiseg mbufs. */
 			if (bufs[0]->nb_segs != 1) {
 				infinite_rx_ring_free(pcap_q->pkts);
+				pcap_q->vlan_strip = save_vlan_strip;
 				PMD_LOG(ERR,
 					"Multiseg mbufs are not supported in infinite_rx mode.");
 				return -EINVAL;
@@ -960,6 +1046,9 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 					(void * const *)bufs, 1, NULL);
 		}
 
+		/* Restore offloads for use during packet delivery */
+		pcap_q->vlan_strip = save_vlan_strip;
+
 		if (rte_ring_count(pcap_q->pkts) < pcap_pkt_count) {
 			infinite_rx_ring_free(pcap_q->pkts);
 			PMD_LOG(ERR,
@@ -1044,6 +1133,26 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	unsigned int i;
+
+	if (mask & RTE_ETH_VLAN_STRIP_MASK) {
+		bool vlan_strip = !!(dev->data->dev_conf.rxmode.offloads &
+				     RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+
+		internals->vlan_strip = vlan_strip;
+
+		/* Update all RX queues */
+		for (i = 0; i < dev->data->nb_rx_queues; i++)
+			internals->rx_queue[i].vlan_strip = vlan_strip;
+	}
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1060,6 +1169,7 @@ static const struct eth_dev_ops ops = {
 	.link_update = eth_link_update,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.vlan_offload_set = eth_vlan_offload_set,
 };
 
 static int
-- 
2.51.0

[PATCH v15 09/18] net/pcap: add link state and speed for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent functions to query the real link state, speed,
duplex, and autonegotiation settings from the underlying interface.
The eth_link_update() callback now returns accurate information
when operating in pass-through mode.

Linux uses ETHTOOL_GLINKSETTINGS which supports all speeds up to
800 Gbps. FreeBSD uses SIOCGIFMEDIA, and Windows uses
GetAdaptersAddresses().

For pcap file mode or separate rx/tx interface configurations,
default values continue to be used since there is no single
underlying interface to query.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         |  93 ++++++++++++++++---
 drivers/net/pcap/pcap_osdep.h          |  24 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  |  86 ++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 118 +++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  |  95 +++++++++++++++++---
 6 files changed, 394 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index fa998f1620..c1d8c3e10c 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -90,6 +90,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state and speed in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 421a72a0cb..2209b78ff3 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -151,13 +151,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -972,11 +965,84 @@ eth_dev_close(struct rte_eth_dev *dev)
 	return 0;
 }
 
+/*
+ * Convert osdep speed (Mbps) to rte_eth_link speed constant.
+ */
+static uint32_t
+speed_mbps_to_rte(uint32_t speed_mbps)
+{
+	switch (speed_mbps) {
+	case 10:
+		return RTE_ETH_SPEED_NUM_10M;
+	case 100:
+		return RTE_ETH_SPEED_NUM_100M;
+	case 1000:
+		return RTE_ETH_SPEED_NUM_1G;
+	case 2500:
+		return RTE_ETH_SPEED_NUM_2_5G;
+	case 5000:
+		return RTE_ETH_SPEED_NUM_5G;
+	case 10000:
+		return RTE_ETH_SPEED_NUM_10G;
+	case 20000:
+		return RTE_ETH_SPEED_NUM_20G;
+	case 25000:
+		return RTE_ETH_SPEED_NUM_25G;
+	case 40000:
+		return RTE_ETH_SPEED_NUM_40G;
+	case 50000:
+		return RTE_ETH_SPEED_NUM_50G;
+	case 56000:
+		return RTE_ETH_SPEED_NUM_56G;
+	case 100000:
+		return RTE_ETH_SPEED_NUM_100G;
+	case 200000:
+		return RTE_ETH_SPEED_NUM_200G;
+	case 400000:
+		return RTE_ETH_SPEED_NUM_400G;
+	case 800000:
+		return RTE_ETH_SPEED_NUM_800G;
+	default:
+		return RTE_ETH_SPEED_NUM_UNKNOWN;
+	}
+}
+
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	const char *iface_name = internals->rx_queue[0].name;
+	struct rte_eth_link link;
+	struct osdep_iface_link osdep_link;
+
+	memset(&link, 0, sizeof(link));
+
+	/*
+	 * For pass-through mode (single_iface), query the actual interface.
+	 * Otherwise, use the default static link values.
+	 */
+	if (internals->single_iface &&
+	    osdep_iface_link_get(iface_name, &osdep_link) == 0) {
+		link.link_speed = speed_mbps_to_rte(osdep_link.link_speed);
+		link.link_status = osdep_link.link_status ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_duplex = osdep_link.link_duplex ?
+			RTE_ETH_LINK_FULL_DUPLEX : RTE_ETH_LINK_HALF_DUPLEX;
+		link.link_autoneg = osdep_link.link_autoneg ?
+			RTE_ETH_LINK_AUTONEG : RTE_ETH_LINK_FIXED;
+	} else {
+		/*
+		 * Not in pass-through mode (using pcap files or separate
+		 * interfaces for rx/tx). Or query failed. Use default values.
+		 */
+		link.link_speed = RTE_ETH_SPEED_NUM_10G;
+		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_autoneg = RTE_ETH_LINK_FIXED;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1391,7 +1457,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index fe7399ff9f..b72dd0d74c 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -10,6 +10,7 @@
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
+
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
@@ -27,7 +28,30 @@ extern int eth_pcap_logtype;
 #define PMD_TX_LOG(...) do { } while (0)
 #endif
 
+/**
+ * Link information returned by osdep_iface_link_get().
+ */
+struct osdep_iface_link {
+	uint32_t link_speed;    /**< Speed in Mbps, 0 if unknown */
+	uint8_t link_status;    /**< 1 = up, 0 = down */
+	uint8_t link_duplex;    /**< 1 = full, 0 = half */
+	uint8_t link_autoneg;   /**< 1 = autoneg enabled, 0 = fixed */
+};
+
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link state and speed for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @param link
+ *   Pointer to structure to fill with link information.
+ * @return
+ *   0 on success, -1 on failure.
+ */
+int osdep_iface_link_get(const char *name, struct osdep_iface_link *link);
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..5963b67087 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,12 +5,36 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
 
+/*
+ * Userspace implementation of ifmedia_baudrate().
+ * The kernel function is not exported to userspace, so we implement
+ * our own using the IFM_BAUDRATE_DESCRIPTIONS table from if_media.h.
+ */
+static uint64_t
+ifmedia_baudrate_user(int mword)
+{
+	static const struct ifmedia_baudrate descs[] =
+		IFM_BAUDRATE_DESCRIPTIONS;
+	const struct ifmedia_baudrate *desc;
+
+	for (desc = descs; desc->ifmb_word != 0; desc++) {
+		if (IFM_TYPE_MATCH(desc->ifmb_word, mword))
+			return desc->ifmb_baudrate;
+	}
+	return 0;
+}
+
 int
 osdep_iface_index_get(const char *name)
 {
@@ -55,3 +79,65 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifmediareq ifmr;
+	struct ifreq ifr;
+	uint64_t baudrate;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine administrative status */
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		if (ifr.ifr_flags & IFF_UP)
+			link->link_status = 1;
+	}
+
+	/* Get media status for speed, duplex, and link state */
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(if_fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* Check if link is actually active */
+		if (!(ifmr.ifm_status & IFM_ACTIVE))
+			link->link_status = 0;
+
+		/* Only parse media if we have a valid current media type */
+		if (ifmr.ifm_current != 0 && IFM_TYPE(ifmr.ifm_current) == IFM_ETHER) {
+			/* Use userspace baudrate lookup */
+			baudrate = ifmedia_baudrate_user(ifmr.ifm_current);
+			link->link_speed = baudrate / 1000000;
+
+			/* Check duplex - FDX option means full duplex */
+			if (IFM_OPTIONS(ifmr.ifm_current) & IFM_FDX)
+				link->link_duplex = 1;
+			else
+				link->link_duplex = 0;
+		} else {
+			/* Default to full duplex if we can't determine */
+			link->link_duplex = 1;
+		}
+
+		/* Check autonegotiation status */
+		link->link_autoneg = (ifmr.ifm_current & IFM_AUTO) ? 1 : 0;
+	} else {
+		/*
+		 * SIOCGIFMEDIA failed - interface may not support it.
+		 * Default to reasonable values.
+		 */
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..3b56a833a9 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,11 +4,14 @@
  * All rights reserved.
  */
 
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include <rte_string_fns.h>
 
@@ -40,3 +43,118 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+/*
+ * Get link speed, duplex, and autoneg using ETHTOOL_GLINKSETTINGS.
+ *
+ * ETHTOOL_GLINKSETTINGS was introduced in kernel 4.7 and supports
+ * speeds beyond 65535 Mbps (up to 800 Gbps and beyond).
+ * DPDK requires kernel 4.19 or later, so this interface is always available.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+get_link_settings(int fd, struct ifreq *ifr, struct osdep_iface_link *link)
+{
+	struct ethtool_link_settings probe = { };
+	struct ethtool_link_settings *req;
+	size_t req_size;
+	int nwords;
+	int ret = -1;
+
+	/* First call with nwords = 0 to get the required size */
+	probe.cmd = ETHTOOL_GLINKSETTINGS;
+	ifr->ifr_data = (void *)&probe;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Kernel returns negative nwords on first call */
+	if (probe.link_mode_masks_nwords >= 0)
+		return -1;
+
+	nwords = -probe.link_mode_masks_nwords;
+
+	/* Bounds check */
+	if (nwords == 0 || nwords > 127)
+		return -1;
+
+	/* Second call with correct nwords - need space for 3 link mode masks */
+	req_size = sizeof(*req) + 3 * nwords * sizeof(uint32_t);
+	req = malloc(req_size);
+	if (req == NULL)
+		return -1;
+
+	memset(req, 0, req_size);
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	req->link_mode_masks_nwords = nwords;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		goto out;
+
+	/* Speed is in Mbps, directly usable */
+	link->link_speed = req->speed;
+
+	/* Handle special values */
+	if (link->link_speed == (uint32_t)SPEED_UNKNOWN ||
+	    link->link_speed == (uint32_t)-1)
+		link->link_speed = 0;
+
+	switch (req->duplex) {
+	case DUPLEX_FULL:
+		link->link_duplex = 1;
+		break;
+	case DUPLEX_HALF:
+		link->link_duplex = 0;
+		break;
+	default:
+		link->link_duplex = 1;  /* Default to full duplex */
+		break;
+	}
+
+	link->link_autoneg = (req->autoneg == AUTONEG_ENABLE) ? 1 : 0;
+	ret = 0;
+out:
+	free(req);
+	return ret;
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifreq ifr;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine link status */
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up
+		 * IFF_RUNNING means operationally up (carrier detected)
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			link->link_status = 1;
+	}
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (get_link_settings(if_fd, &ifr, link) < 0) {
+		/*
+		 * ethtool failed - interface may not support it
+		 * (e.g., virtual interfaces like veth, lo).
+		 * Use reasonable defaults.
+		 */
+		link->link_speed = 0;
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..1b76ae3185 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,56 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_get(const char *device_name, struct osdep_iface_link *link)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	memset(link, 0, sizeof(*link));
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			/* Check operational status */
+			if (cur->OperStatus == IfOperStatusUp)
+				link->link_status = 1;
+			else
+				link->link_status = 0;
+
+			/*
+			 * TransmitLinkSpeed and ReceiveLinkSpeed are in bits/sec.
+			 * Convert to Mbps. Use transmit speed as the link speed.
+			 * For asymmetric links, this is a reasonable approximation.
+			 */
+			if (cur->TransmitLinkSpeed != 0 &&
+			    cur->TransmitLinkSpeed != (ULONG64)-1) {
+				link->link_speed =
+					(uint32_t)(cur->TransmitLinkSpeed / 1000000ULL);
+			}
+
+			/*
+			 * Windows doesn't directly expose duplex/autoneg via
+			 * GetAdaptersAddresses(). Default to full duplex.
+			 * For more detailed info, WMI or OID queries would be needed.
+			 */
+			link->link_duplex = 1;  /* Assume full duplex */
+			link->link_autoneg = 0; /* Cannot determine */
+
+			ret = 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v15 10/18] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Add read_clock dev_op returning current UTC time for timestamp
  correlation.
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper.
* Enable immediate mode and improve error reporting
  in live capture setup.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |   3 +
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 157 +++++++++++++++++++------
 3 files changed, 127 insertions(+), 35 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index bed5006a42..2709c6d017 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -258,3 +258,6 @@ Features and Limitations
 *  The PMD will transparently insert a VLAN tag to transmitted packets if
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
+
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index c1d8c3e10c..e7782dee20 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -91,6 +91,8 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state and speed in ``iface`` mode.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2209b78ff3..b96bda0fc8 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -28,13 +28,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -78,6 +76,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -109,6 +108,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -270,6 +270,15 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(bufs[i]);
 
+		if (pcap_q->timestamp_offloading) {
+			struct timespec ts;
+
+			timespec_get(&ts, TIME_UTC);
+			*RTE_MBUF_DYNFIELD(bufs[i], timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(&ts);
+			bufs[i]->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
@@ -340,10 +349,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -363,14 +383,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -459,8 +484,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		uint32_t len, caplen;
 		const uint8_t *data;
@@ -470,9 +497,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 		struct rte_mbuf *mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -601,22 +625,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
+	}
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
+	}
+
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -663,7 +727,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -822,6 +887,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -839,7 +905,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -1061,6 +1128,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1199,6 +1267,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static int
 eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
 {
@@ -1225,6 +1304,7 @@ static const struct eth_dev_ops ops = {
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1640,15 +1720,22 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		hz = rte_get_timer_hz();
+		if (hz == 0) {
+			PMD_LOG(ERR, "Reported hz is zero!");
+			return -1;
+		}
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							 &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v15 11/18] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index b96bda0fc8..8f44baf2e1 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -669,6 +669,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.51.0

[PATCH v15 12/18] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 8f44baf2e1..16472ca068 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -47,11 +47,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -627,6 +625,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -738,6 +737,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1541,6 +1542,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v15 13/18] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 16472ca068..eeac0cffc8 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -55,10 +55,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -928,11 +928,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v15 14/18] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index eeac0cffc8..f2f05689ca 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -911,10 +911,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v15 15/18] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

Example usage:
  --vdev 'net_pcap0,iface=eth0,snaplen=1518'
  --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |  15 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 235 ++++++++++++++++---------
 3 files changed, 165 insertions(+), 86 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2709c6d017..f241069ebb 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -162,6 +162,21 @@ Runtime Config Options
 
   In this case, one dummy Rx queue is created for each Tx queue argument passed.
 
+* Set the snapshot length for packet capture
+
+  The snapshot length controls the maximum number of bytes captured per packet.
+  This affects both interface capture and pcap file output.  The default value is
+  65535 bytes, which captures complete packets up to the maximum Ethernet jumbo
+  frame size.  Reducing this value can improve performance when only packet headers
+  are needed.  This can be done with the ``snaplen`` devarg, for example::
+
+     --vdev 'net_pcap0,iface=eth0,snaplen=1518'
+     --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'
+
+  The snapshot length also determines the reported ``max_rx_pktlen``
+  and ``max_mtu`` in device info.
+
+
 Examples of Usage
 ~~~~~~~~~~~~~~~~~
 
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index e7782dee20..70179a454e 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -93,6 +93,7 @@ New Features
   * Added support for reporting link state and speed in ``iface`` mode.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f2f05689ca..e9200f9aac 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -14,6 +14,7 @@
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <net/if.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -32,8 +33,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -42,6 +41,12 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
+
+/* This is defined in libpcap but not exposed in headers */
+#define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -102,6 +107,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -129,6 +135,7 @@ struct pmd_devargs {
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -146,11 +153,16 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declaration */
+static inline int set_iface_direction(const char *iface, pcap_t *pcap,
+				      pcap_direction_t direction);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -466,20 +478,19 @@ eth_pcap_tx_vlan(struct pcap_tx_queue *tx_queue, struct rte_mbuf **mbuf)
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -487,14 +498,15 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		uint32_t len, caplen;
 		const uint8_t *data;
 
 		if (eth_pcap_tx_vlan(dumper_q, &bufs[i]) < 0)
 			continue;
 
 		struct rte_mbuf *mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t caplen = RTE_MIN(len, snaplen);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -563,19 +575,18 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
@@ -586,10 +597,10 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > snaplen)) {
 			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
-				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+				len, snaplen);
 			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
@@ -623,7 +634,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -652,7 +663,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -666,6 +677,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -694,9 +708,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -705,7 +719,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -715,7 +730,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -724,9 +739,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -776,15 +791,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
 		rx = &internals->rx_queue[0];
 
-		if (!pp->tx_pcap[0] &&
-			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+		if (!pp->tx_pcap[0] && strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -796,14 +811,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -818,9 +830,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -911,11 +928,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1228,7 +1245,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1358,6 +1375,12 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *rx = extra_args;
 	pcap_t *pcap = NULL;
 
+	if (access(pcap_filename, R_OK) != 0) {
+		PMD_LOG(ERR, "Cannot read pcap file '%s': %s",
+			pcap_filename, strerror(errno));
+		return -1;
+	}
+
 	if (open_single_rx_pcap(pcap_filename, &pcap) < 0)
 		return -1;
 
@@ -1370,41 +1393,53 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 }
 
 /*
- * Opens a pcap file for writing and stores a reference to it
- * for use it later on.
+ * Store TX pcap file configuration.
+ * The actual pcap dumper is opened in eth_dev_start().
  */
 static int
 open_tx_pcap(const char *key, const char *value, void *extra_args)
 {
 	const char *pcap_filename = value;
 	struct pmd_devargs *dumpers = extra_args;
-	pcap_dumper_t *dumper;
+	FILE *f;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	/* Validate that pcap_filename can be created. */
+	if (strcmp(pcap_filename, "-") == 0) {
+		/* This isn't going to work very well in DPDK - so reject it */
+		PMD_LOG(ERR, "Sending pcap binary data to stdout is not supported");
 		return -1;
+	}
 
-	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
-		pcap_dump_close(dumper);
+	f = fopen(pcap_filename, "wb");
+	if (f == NULL) {
+		PMD_LOG(ERR, "Cannot open '%s' for writing: %s", pcap_filename, strerror(errno));
 		return -1;
 	}
+	fclose(f);
+
+	if (add_queue(dumpers, pcap_filename, key, NULL, NULL) < 0)
+		return -1;
 
 	return 0;
 }
 
 /*
- * Opens an interface for reading and writing
+ * Store interface configuration for reading and writing.
+ * The actual pcap handle is opened in eth_dev_start().
  */
 static inline int
 open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *tx = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (if_nametoindex(iface) == 0) {
+		PMD_LOG(ERR, "Interface '%s' not found: %s",
+			iface, strerror(errno));
 		return -1;
+	}
 
-	tx->queue[0].pcap = pcap;
+	tx->queue[0].pcap = NULL;
 	tx->queue[0].name = iface;
 	tx->queue[0].type = key;
 
@@ -1426,50 +1461,38 @@ set_iface_direction(const char *iface, pcap_t *pcap,
 	return 0;
 }
 
+/*
+ * Store interface configuration.
+ * The actual pcap handle is opened in eth_dev_start().
+ */
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *pmd = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
-		return -1;
-	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
-		pcap_close(pcap);
+	if (if_nametoindex(iface) == 0) {
+		PMD_LOG(ERR, "Interface '%s' not found: %s",
+			iface, strerror(errno));
 		return -1;
 	}
 
+	if (add_queue(pmd, iface, key, NULL, NULL) < 0)
+		return -1;
+
 	return 0;
 }
 
 /*
- * Opens a NIC for reading packets from it
+ * Store RX interface configuration.
+ * The actual pcap handle is opened and direction set in eth_dev_start().
  */
-static inline int
-open_rx_iface(const char *key, const char *value, void *extra_args)
-{
-	int ret = open_iface(key, value, extra_args);
-	if (ret < 0)
-		return ret;
-	if (strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
-		struct pmd_devargs *pmd = extra_args;
-		unsigned int qid = pmd->num_of_queue - 1;
-
-		set_iface_direction(pmd->queue[qid].name,
-				pmd->queue[qid].pcap,
-				PCAP_D_IN);
-	}
-
-	return 0;
-}
-
 static inline int
 rx_iface_args_process(const char *key, const char *value, void *extra_args)
 {
 	if (strcmp(key, ETH_PCAP_RX_IFACE_ARG) == 0 ||
-			strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
-		return open_rx_iface(key, value, extra_args);
+	    strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+		return open_iface(key, value, extra_args);
 
 	return 0;
 }
@@ -1501,6 +1524,31 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN ||
+	    val > ETH_PCAP_MAXIMUM_SNAPLEN) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1665,6 +1713,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1725,6 +1775,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1772,7 +1823,18 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	}
 
 	/*
-	 * If iface argument is passed we open the NICs and use them for
+	 * Process optional snapshot length argument.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+	/*
+	 * If iface argument is passed we check that NIC can be used
 	 * reading / writing
 	 */
 	if (rte_kvargs_count(kvlist, ETH_PCAP_IFACE_ARG) == 1) {
@@ -1977,4 +2039,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v15 16/18] net/pcap: add link status change support for iface mode

[Stephen Hemminger]

Add LSC interrupt support for pass-through (iface=) mode so
applications can receive link state change notifications via
the standard ethdev callback mechanism.

Uses alarm-based polling to periodically check the underlying
interface state via osdep_iface_link_get(). The LSC flag is
advertised only for iface mode devices, and polling is gated
on the application enabling intr_conf.lsc in port configuration.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 45 +++++++++++++++++++++++++-
 3 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 814bc2119f..084fefbbbb 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -5,6 +5,7 @@
 ;
 [Features]
 Link status          = Y
+Link status event    = Y
 Queue start/stop     = Y
 Scattered Rx         = Y
 Timestamp offload    = Y
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 70179a454e..1db54a005a 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -94,6 +94,7 @@ New Features
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added support for Link State interrupt in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index e9200f9aac..00f6e4e33d 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -17,6 +17,7 @@
 #include <net/if.h>
 #include <pcap.h>
 
+#include <rte_alarm.h>
 #include <rte_cycles.h>
 #include <rte_ring.h>
 #include <rte_ethdev.h>
@@ -48,6 +49,8 @@
 /* This is defined in libpcap but not exposed in headers */
 #define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
+#define ETH_PCAP_LSC_POLL_INTERVAL_US (1000 * 1000) /* 1 second */
+
 #define ETH_PCAP_ARG_MAXLEN	64
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
@@ -113,6 +116,7 @@ struct pmd_internals {
 	bool infinite_rx;
 	bool vlan_strip;
 	bool timestamp_offloading;
+	bool lsc_active;
 };
 
 struct pmd_process_private {
@@ -159,9 +163,10 @@ static const char *valid_arguments[] = {
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
-/* Forward declaration */
+/* Forward declarations */
 static inline int set_iface_direction(const char *iface, pcap_t *pcap,
 				      pcap_direction_t direction);
+static int eth_link_update(struct rte_eth_dev *dev, int wait_to_complete);
 
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
@@ -783,6 +788,28 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+/*
+ * Periodic alarm to poll link state.
+ * Enabled when link state interrupt is enabled in single_iface mode.
+ */
+static void
+eth_pcap_lsc_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link old_link, new_link;
+
+	rte_eth_linkstatus_get(dev, &old_link);
+	eth_link_update(dev, 0);
+	rte_eth_linkstatus_get(dev, &new_link);
+
+	if (old_link.link_status != new_link.link_status)
+		rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+
+	if (internals->lsc_active)
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US, eth_pcap_lsc_alarm, dev);
+}
+
 static int
 eth_dev_start(struct rte_eth_dev *dev)
 {
@@ -850,6 +877,13 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
+	/* Start LSC polling for iface mode if application requested it */
+	if (internals->single_iface && dev->data->dev_conf.intr_conf.lsc) {
+		internals->lsc_active = true;
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US,
+				  eth_pcap_lsc_alarm, dev);
+	}
+
 	return 0;
 }
 
@@ -867,6 +901,12 @@ eth_dev_stop(struct rte_eth_dev *dev)
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
+		/* Cancel LSC polling before closing pcap handles */
+		if (internals->lsc_active) {
+			internals->lsc_active = false;
+			rte_eal_alarm_cancel(eth_pcap_lsc_alarm, dev);
+		}
+
 		queue_missed_stat_on_stop_update(dev, 0);
 		if (pp->tx_pcap[0] != NULL) {
 			pcap_close(pp->tx_pcap[0]);
@@ -1704,6 +1744,9 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		internals->if_index =
 			osdep_iface_index_get(rx_queues->queue[0].name);
 
+		/* Enable LSC interrupt support for iface mode */
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 		/* phy_mac arg is applied only if "iface" devarg is provided */
 		if (rx_queues->phy_mac) {
 			if (eth_pcap_update_mac(rx_queues->queue[0].name,
-- 
2.51.0

[PATCH v15 17/18] net/pcap: add EOF notification via link status change

[Stephen Hemminger]

Add an "eof" devarg for rx_pcap mode that signals end-of-file by
setting link down and generating an LSC event. This allows
applications to detect when a pcap file has been fully consumed
using the standard ethdev callback mechanism.

The eof and infinite_rx options are mutually exclusive. On device
restart, the EOF state is reset so the file can be replayed.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               | 12 +++++
 doc/guides/rel_notes/release_26_03.rst |  2 +
 drivers/net/pcap/pcap_ethdev.c         | 75 ++++++++++++++++++++++++--
 3 files changed, 86 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index f241069ebb..6f3a4fc887 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -144,6 +144,18 @@ Runtime Config Options
   so all queues on a device will either have this enabled or disabled.
   This option should only be provided once per device.
 
+* Signal end-of-file via link status change
+
+  In case ``rx_pcap=`` configuration is set, the user may want to be notified when
+  all packets in the pcap file have been read.  This can be done with the ``eof``
+  devarg, for example::
+
+     --vdev 'net_pcap0,rx_pcap=file_rx.pcap,eof=1'
+
+  When enabled, the driver sets link down and generates an LSC event at end of file.
+  If the device is stopped and restarted, the EOF state is reset.
+  This option cannot be combined with ``infinite_rx``.
+
 * Drop all packets on transmit
 
   To drop all packets on transmit for a device,
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 1db54a005a..7959b97c10 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -95,6 +95,8 @@ New Features
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
   * Added support for Link State interrupt in ``iface`` mode.
+  * Added ``eof`` devarg to use link state to signal end of receive
+    file input.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 00f6e4e33d..c995a3bf25 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -42,6 +42,7 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_EOF_ARG          "eof"
 #define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
 
 #define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
@@ -114,6 +115,8 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool eof;
+	bool eof_signaled;
 	bool vlan_strip;
 	bool timestamp_offloading;
 	bool lsc_active;
@@ -146,6 +149,7 @@ struct pmd_devargs_all {
 	bool is_rx_pcap;
 	bool is_rx_iface;
 	bool infinite_rx;
+	bool eof;
 };
 
 static const char *valid_arguments[] = {
@@ -157,6 +161,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_EOF_ARG,
 	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
@@ -306,15 +311,33 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	return i;
 }
 
+/*
+ * Deferred EOF alarm callback.
+ *
+ * Scheduled from the RX burst path when end-of-file is reached,
+ * so that rte_eth_dev_callback_process() runs outside the datapath.
+ * This avoids holding any locks that the application callback
+ * might also need, preventing potential deadlocks.
+ */
+static void
+eth_pcap_eof_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+
+	rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+}
+
 static uint16_t
 eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
+	struct pcap_rx_queue *pcap_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[pcap_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
 	unsigned int i;
 	struct pcap_pkthdr *header;
 	struct pmd_process_private *pp;
 	const u_char *packet;
 	struct rte_mbuf *mbuf;
-	struct pcap_rx_queue *pcap_q = queue;
 	uint16_t num_rx = 0;
 	uint32_t rx_bytes = 0;
 	pcap_t *pcap;
@@ -335,6 +358,19 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			if (ret == PCAP_ERROR)
 				pcap_q->rx_stat.err_pkts++;
 
+			/*
+			 * EOF: if eof mode is enabled, set link down and
+			 * defer notification via alarm to avoid calling
+			 * rte_eth_dev_callback_process() from the datapath.
+			 */
+			else if (ret == PCAP_ERROR_BREAK) {
+				if (internals->eof && !internals->eof_signaled) {
+					internals->eof_signaled = true;
+					eth_link_update(dev, 0);
+					rte_eal_alarm_set(1, eth_pcap_eof_alarm, dev);
+				}
+			}
+
 			break;
 		}
 
@@ -875,6 +911,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++)
 		dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
 
+	internals->eof_signaled = false;
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
 	/* Start LSC polling for iface mode if application requested it */
@@ -937,6 +974,10 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	}
 
 status_down:
+	/* Cancel any pending EOF alarm */
+	if (internals->eof_signaled)
+		rte_eal_alarm_cancel(eth_pcap_eof_alarm, dev);
+
 	for (i = 0; i < dev->data->nb_rx_queues; i++)
 		dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
 
@@ -1174,9 +1215,13 @@ eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 		 */
 		link.link_speed = RTE_ETH_SPEED_NUM_10G;
 		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
-		link.link_status = dev->data->dev_started ?
-			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 		link.link_autoneg = RTE_ETH_LINK_FIXED;
+
+		if (internals->eof_signaled)
+			link.link_status = RTE_ETH_LINK_DOWN;
+		else
+			link.link_status = dev->data->dev_started ?
+				RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 	}
 
 	return rte_eth_linkstatus_set(dev, &link);
@@ -1756,8 +1801,13 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->eof = devargs_all->eof;
 	internals->snapshot_len = devargs_all->snapshot_len;
 
+	/* Enable LSC for eof mode (already set above for single_iface) */
+	if (internals->eof)
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1944,6 +1994,24 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 					"for %s", name);
 		}
 
+		/*
+		 * Check whether to signal EOF via link status change.
+		 */
+		if (rte_kvargs_count(kvlist, ETH_PCAP_EOF_ARG) == 1) {
+			ret = rte_kvargs_process(kvlist, ETH_PCAP_EOF_ARG,
+						 &process_bool_flag,
+						 &devargs_all.eof);
+			if (ret < 0)
+				goto free_kvlist;
+		}
+
+		if (devargs_all.infinite_rx && devargs_all.eof) {
+			PMD_LOG(ERR, "Cannot use both infinite_rx and eof for %s",
+				name);
+			ret = -EINVAL;
+			goto free_kvlist;
+		}
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
 				&open_rx_pcap, &pcaps);
 	} else if (devargs_all.is_rx_iface) {
@@ -2083,4 +2151,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_EOF_ARG "=<0|1> "
 	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v15 18/18] test: add comprehensive test suite for pcap PMD

[Stephen Hemminger]

Add unit tests for the pcap PMD covering file and interface modes.

Tests include:
  - basic TX to file and RX from file
  - varied packet sizes and jumbo frames
  - infinite RX mode
  - TX drop mode
  - statistics
  - interface (iface=) pass-through mode
  - link status reporting for file and iface modes
  - link status change (LSC) with interface toggle
  - EOF notification via LSC
  - RX timestamps and timestamp with infinite RX
  - multiple TX/RX queues
  - VLAN strip, insert, and runtime offload configuration
  - snapshot length (snaplen) and truncation

Cross-platform helpers handle temp file creation, interface
discovery, and VLAN packet generation.

The LSC link toggle test requires a pre-created dummy interface
(Linux: dummy0, FreeBSD: disc0) and is skipped if unavailable.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3422 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 3425 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index 48874037eb..a83292cf49 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..5f57184d5f
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,3422 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define access _access
+#define F_OK 0
+#else
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port with custom config
+ */
+static int
+setup_pcap_port_conf(uint16_t port, const struct rte_eth_conf *conf)
+{
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port (default: timestamp offload)
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+	int ret;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+	int ret;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+	int ret;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+	int ret;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	int ret;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link Status Change (LSC) interrupt support
+ *
+ * Verifies that:
+ * 1. LSC capability is NOT advertised for file mode
+ * 2. LSC capability IS advertised for iface mode
+ * 3. LSC callback fires when the underlying interface goes down/up
+ *
+ * Requires a toggleable Ethernet interface created before running:
+ *   Linux:   ip link add dummy0 type dummy && ip link set dummy0 up
+ *   FreeBSD: ifconfig disc0 create && ifconfig disc0 up
+ *
+ * Skipped if no suitable interface is found or on Windows.
+ */
+
+/* Callback counter for LSC test */
+static volatile int lsc_callback_count;
+
+static int
+test_lsc_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	lsc_callback_count++;
+	return 0;
+}
+
+#ifndef RTE_EXEC_ENV_WINDOWS
+/*
+ * Helper: Set interface link up or down via ioctl.
+ * Returns 0 on success, -errno on failure.
+ */
+static int
+set_iface_up_down(const char *ifname, int up)
+{
+	struct ifreq ifr;
+	int fd, ret;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd < 0)
+		return -errno;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	ret = ioctl(fd, SIOCGIFFLAGS, &ifr);
+	if (ret < 0) {
+		ret = -errno;
+		close(fd);
+		return ret;
+	}
+
+	if (up)
+		ifr.ifr_flags |= IFF_UP;
+	else
+		ifr.ifr_flags &= ~IFF_UP;
+
+	ret = ioctl(fd, SIOCSIFFLAGS, &ifr);
+	if (ret < 0)
+		ret = -errno;
+	else
+		ret = 0;
+
+	close(fd);
+	return ret;
+}
+
+/*
+ * Helper: Find a toggleable test interface for LSC testing.
+ *
+ * Looks for well-known interfaces that are safe to bring up/down:
+ *   Linux:   dummy0 (ip link add dummy0 type dummy)
+ *   FreeBSD: disc0 (ifconfig disc0 create)
+ *
+ * Returns interface name or NULL if none found.
+ */
+static const char *
+find_lsc_test_iface(void)
+{
+	static const char *candidates[] = { "dummy0", "disc0" };
+	unsigned int i;
+
+	for (i = 0; i < RTE_DIM(candidates); i++) {
+		if (iface_is_ethernet(candidates[i]))
+			return candidates[i];
+	}
+	return NULL;
+}
+#endif
+
+static int
+test_lsc_iface(void)
+{
+	struct rte_eth_dev_info dev_info;
+	struct rte_eth_link link;
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	char devargs[256];
+	uint16_t port_id;
+	int ret;
+
+	printf("Testing Link Status Change (LSC) support\n");
+
+	/*
+	 * Test 1: Verify LSC is NOT advertised for file mode
+	 */
+	printf("  Testing file mode does not advertise LSC\n");
+	{
+		char lsc_pcap_path[PATH_MAX];
+		uint16_t file_port_id;
+
+		TEST_ASSERT(create_temp_path(lsc_pcap_path, sizeof(lsc_pcap_path),
+					     "pcap_lsc") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(lsc_pcap_path, 1) == 0,
+			    "Failed to create test pcap");
+
+		ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", lsc_pcap_path);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		TEST_ASSERT(create_pcap_vdev("net_pcap_lsc_file", devargs,
+					     &file_port_id) == 0,
+			    "Failed to create file vdev");
+
+		ret = rte_eth_dev_info_get(file_port_id, &dev_info);
+		TEST_ASSERT(ret == 0, "Failed to get dev info");
+
+		TEST_ASSERT((*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC) == 0,
+			    "File mode should NOT advertise LSC capability");
+
+		rte_vdev_uninit("net_pcap_lsc_file");
+		remove_temp_file(lsc_pcap_path);
+		printf("  File mode LSC check PASSED\n");
+	}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+	printf("  Link toggle test not supported on Windows, skipping\n");
+	return TEST_SUCCESS;
+#else
+	/*
+	 * Test 2: Use a toggleable interface to test link change events.
+	 * Skip if not present.
+	 */
+	const char *lsc_iface = find_lsc_test_iface();
+	if (lsc_iface == NULL) {
+		printf("  No toggleable interface found, skipping link change test\n");
+		printf("  Linux:   ip link add dummy0 type dummy && ip link set dummy0 up\n");
+		printf("  FreeBSD: ifconfig disc0 create && ifconfig disc0 up\n");
+		return TEST_SUCCESS;
+	}
+
+	printf("  Testing iface mode LSC with: %s\n", lsc_iface);
+
+	/* Ensure interface is up before we start */
+	ret = set_iface_up_down(lsc_iface, 1);
+	if (ret != 0) {
+		printf("  Cannot set %s up (%s), skipping\n",
+		       lsc_iface, strerror(-ret));
+		return TEST_SUCCESS;
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", lsc_iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_lsc", devargs);
+	if (ret < 0) {
+		printf("  Cannot create iface vdev for %s, skipping\n", lsc_iface);
+		return TEST_SUCCESS;
+	}
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_lsc", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "Iface mode should advertise LSC capability");
+	printf("    LSC capability advertised: yes\n");
+
+	/* Register LSC callback */
+	lsc_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_lsc_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link status");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+	printf("    Link after start: UP\n");
+
+	/* Bring interface down - should trigger LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 0);
+	TEST_ASSERT(ret == 0, "Failed to set %s down: %s",
+		    lsc_iface, strerror(-ret));
+
+	/* Wait for at least one poll cycle (1 second interval) */
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after down");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after interface down");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired, count=%d",
+		    lsc_callback_count);
+	printf("    Interface down: link DOWN, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Bring it back up - should trigger another LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 1);
+	TEST_ASSERT(ret == 0, "Failed to set %s up: %s",
+		    lsc_iface, strerror(-ret));
+
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after up");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after interface up");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired on link restore, count=%d",
+		    lsc_callback_count);
+	printf("    Interface up: link UP, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Cleanup */
+	rte_eth_dev_stop(port_id);
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_lsc_callback, NULL);
+	rte_vdev_uninit("net_pcap_lsc");
+
+	printf("LSC test PASSED\n");
+	return TEST_SUCCESS;
+#endif /* !RTE_EXEC_ENV_WINDOWS */
+}
+
+/*
+ * Test: EOF notification via link status change
+ *
+ * Verifies that:
+ * 1. The eof devarg causes link down + LSC event at end of pcap file
+ * 2. link_get reports DOWN after EOF
+ * 3. Stop/start resets the EOF state and replays the file
+ * 4. The eof and infinite_rx options are mutually exclusive
+ */
+
+static volatile int eof_callback_count;
+
+static int
+test_eof_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	eof_callback_count++;
+	return 0;
+}
+
+static int
+test_eof_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	struct rte_eth_link link;
+	char eof_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx;
+	int ret;
+
+	printf("Testing EOF notification via link status change\n");
+
+	/* Create pcap file with known number of packets */
+	TEST_ASSERT(create_temp_path(eof_pcap_path, sizeof(eof_pcap_path),
+				     "pcap_eof") == 0,
+		    "Failed to create temp file path");
+	TEST_ASSERT(create_test_pcap(eof_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/*
+	 * Test 1: EOF triggers link down and LSC callback
+	 */
+	printf("  Testing EOF triggers link down and LSC event\n");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,eof=1",
+		       eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create eof vdev: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_eof", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	struct rte_eth_dev_info dev_info;
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "EOF mode should advertise LSC capability");
+
+	/* Register LSC callback */
+	eof_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_eof_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Drain all packets from the pcap file */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			/* Got all packets and rx returned 0 — EOF hit */
+			break;
+		}
+	}
+
+	printf("    Received %u packets (expected %d)\n", total_rx, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Should receive exactly %d packets", NUM_PACKETS);
+
+	/* Verify link went down */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after EOF");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after EOF");
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	/* Verify callback fired exactly once */
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "LSC callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    EOF signaled: link DOWN, callback fired\n");
+
+	/*
+	 * Test 2: Stop/start resets EOF and replays the file
+	 */
+	printf("  Testing restart replays pcap file\n");
+
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	eof_callback_count = 0;
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to restart port");
+
+	/* Verify link is up again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after restart");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after restart");
+
+	/* Read packets again */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			break;
+		}
+	}
+
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Restart: should receive %d packets, got %u",
+			  NUM_PACKETS, total_rx);
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "Restart: callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    Restart replay: %u packets, EOF signaled again\n", total_rx);
+
+	/* Cleanup */
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_eof_callback, NULL);
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_eof");
+
+	/*
+	 * Test 3: eof + infinite_rx is rejected
+	 */
+	printf("  Testing eof + infinite_rx mutual exclusion\n");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,eof=1,infinite_rx=1", eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof_bad", devargs);
+	TEST_ASSERT(ret != 0, "eof + infinite_rx should be rejected");
+	printf("    Mutual exclusion check PASSED\n");
+
+	remove_temp_file(eof_pcap_path);
+
+	printf("EOF test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Runtime VLAN offload configuration via rte_eth_dev_set_vlan_offload
+ *
+ * This test verifies that VLAN strip can be enabled/disabled at runtime
+ * using the standard ethdev API rather than only at configure time.
+ * Uses infinite_rx mode so the same packets can be read in each phase.
+ */
+static int
+test_vlan_offload_set(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char vlan_set_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf = { 0 };
+	unsigned int i;
+	uint16_t nb_rx;
+	int ret, current_offload;
+	size_t tagged_len, untagged_len;
+
+	printf("Testing runtime VLAN offload configuration\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_set_pcap_path, sizeof(vlan_set_pcap_path),
+				     "pcap_vlan_set") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_set_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	/* Use infinite_rx so packets are always available */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", vlan_set_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_set", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+
+	/* Configure WITHOUT VLAN strip initially and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port");
+
+	/* Expected lengths */
+	tagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		     sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+	untagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN strip is initially disabled */
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled initially");
+
+	/*
+	 * Phase 1: VLAN strip disabled - packets should have tags
+	 */
+	printf("  Phase 1: VLAN strip disabled\n");
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 1");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 1 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact\n", nb_rx);
+
+	/*
+	 * Phase 2: Enable VLAN strip at runtime - packets should be stripped
+	 */
+	printf("  Phase 2: Enabling VLAN strip via rte_eth_dev_set_vlan_offload\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, RTE_ETH_VLAN_STRIP_OFFLOAD);
+	TEST_ASSERT(ret == 0, "Failed to enable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD,
+		    "VLAN strip should be enabled after set_vlan_offload");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 2");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), untagged_len,
+				  "Phase 2 packet %u: expected untagged length %zu, got %u",
+				  i, untagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Phase 2 packet %u: VLAN_STRIPPED flag not set", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags stripped\n", nb_rx);
+
+	/*
+	 * Phase 3: Disable VLAN strip - packets should have tags again
+	 */
+	printf("  Phase 3: Disabling VLAN strip\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to disable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled after clearing");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 3");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 3 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact again\n", nb_rx);
+
+	cleanup_pcap_vdev("net_pcap_vlan_set", port_id);
+	remove_temp_file(vlan_set_pcap_path);
+
+	printf("Runtime VLAN offload PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip in infinite RX mode
+ *
+ * This test verifies that VLAN strip offload works correctly when combined
+ * with infinite_rx mode, which uses a different RX path (eth_pcap_rx_infinite).
+ */
+static int
+test_vlan_strip_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	char vlan_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int stripped_count = 0;
+	int iter, attempts, ret;
+	size_t expected_len;
+
+	printf("Testing VLAN strip with infinite RX mode\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_inf_pcap_path, sizeof(vlan_inf_pcap_path),
+				     "pcap_vlan_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_inf_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets for infinite RX\n", NUM_PACKETS);
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", vlan_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_vlan_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_vlan_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with VLAN strip enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Expected length after VLAN strip */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Read packets - need more than file contains to verify infinite looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				/* Verify VLAN was stripped */
+				if (verify_no_vlan_tag(mbufs[i]) == 0 &&
+				    rte_pktmbuf_pkt_len(mbufs[i]) == expected_len &&
+				    (mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED))
+					stripped_count++;
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_vlan_inf");
+	remove_temp_file(vlan_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(stripped_count, total_rx,
+			  "VLAN strip failed: only %u/%u packets stripped correctly",
+			  stripped_count, total_rx);
+
+	printf("VLAN strip infinite RX PASSED: %u packets stripped (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Timestamps in infinite RX mode
+ *
+ * This test verifies that timestamp offload works correctly when combined
+ * with infinite_rx mode. Since infinite_rx generates packets on-the-fly,
+ * timestamps should reflect the current time rather than pcap file timestamps.
+ */
+static int
+test_timestamp_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	char ts_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int ts_count = 0;
+	int iter, attempts, ret;
+	rte_mbuf_timestamp_t first_ts = 0;
+	rte_mbuf_timestamp_t last_ts = 0;
+
+	printf("Testing timestamps with infinite RX mode\n");
+
+	/* Initialize timestamp dynamic field access */
+	if (timestamp_dynfield_offset < 0) {
+		ret = timestamp_init();
+		if (ret != 0) {
+			printf("Timestamp dynfield not available, skipping\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	/* Create simple pcap file */
+	TEST_ASSERT(create_temp_path(ts_inf_pcap_path, sizeof(ts_inf_pcap_path),
+				     "pcap_ts_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_test_pcap(ts_inf_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", ts_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_ts_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_ts_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with timestamp offload enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with timestamps");
+
+	/* Read packets */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				if (mbuf_has_timestamp(mbufs[i])) {
+					rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+
+					if (ts_count == 0)
+						first_ts = ts;
+					last_ts = ts;
+					ts_count++;
+				}
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_ts_inf");
+	remove_temp_file(ts_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(ts_count, total_rx,
+			  "Timestamp missing: only %u/%u packets have timestamps",
+			  ts_count, total_rx);
+
+	/* Timestamps should be monotonically increasing (current time) */
+	TEST_ASSERT(last_ts >= first_ts,
+		    "Timestamps not monotonic: first=%" PRIu64 " last=%" PRIu64,
+		    first_ts, last_ts);
+
+	printf("Timestamp infinite RX PASSED: %u packets with valid timestamps\n", total_rx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(infinite_pcap_path);
+	remove_temp_file(timestamp_pcap_path);
+	remove_temp_file(varied_pcap_path);
+	remove_temp_file(jumbo_pcap_path);
+
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++)
+		remove_temp_file(multi_tx_pcap_paths[i]);
+
+	remove_temp_file(multi_rx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+	remove_temp_file(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_lsc_iface),
+		TEST_CASE(test_eof_rx),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_vlan_offload_set),
+		TEST_CASE(test_vlan_strip_infinite_rx),
+		TEST_CASE(test_timestamp_infinite_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 7959b97c10..7d59463d54 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -97,6 +97,7 @@ New Features
   * Added support for Link State interrupt in ``iface`` mode.
   * Added ``eof`` devarg to use link state to signal end of receive
     file input.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

Re: [PATCH v15 06/18] net/pcap: rework transmit burst handling

[David Marchand]

On Fri, 13 Feb 2026 at 18:03, Stephen Hemminger
<stephen@networkplumber.org> wrote:
>
> Replace the 64K stack-allocated bounce buffer with a per-queue
> buffer allocated from hugepages via rte_malloc at queue setup.
> This is necessary because the buffer may be used in a secondary
> process transmit path where the primary process allocated it.
>
> Fix error accounting: backpressure from pcap_sendpacket() (kernel
> socket buffer full) was incorrectly counted as errors. Malformed
> multi-segment mbufs where pkt_len exceeds actual data were silently
> accepted; they are now detected via rte_pktmbuf_read() failure
> and counted as errors.
>
> Add datapath debug logging macros (PMD_RX_LOG, PMD_TX_LOG) gated
> on RTE_ETHDEV_DEBUG_RX/TX. Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS
> in device capabilities since the driver has always supported
> multi-segment transmit. Add tx_queue_release to free the bounce
> buffer.
>
> Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
> Cc: stable@dpdk.org
>
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>

It seems this commit does a lot more than fixing one issue.
Please split.



-- 
David Marchand

[PATCH v16 00/21] net/pcap: improvements and test suite

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx and stripping on Rx
  - Runtime VLAN offload configuration via vlan_offload_set callback
  - Nanosecond precision timestamps (when hardware/libpcap supports it)
  - Accurate link state, speed, and duplex reporting in interface mode
  - Link status change (LSC) interrupt support in interface mode
  - EOF notification via link status change for rx_pcap mode
  - Support for Windows interface mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snaplen devarg

Bug fixes:
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Change Tx burst to always consume all packets; failed sends
    increment error counter rather than leaving mbufs for retry
    (pcap_sendpacket failures are not transient)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback
  - Fix infinite_rx ring fill applying VLAN strip and timestamp
    offloads to template packets, preventing those offloads from
    working correctly during packet delivery

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables
  - Defer pcap handle opening until device start
  - Use bulk free for better Tx performance

Testing:
  - Add comprehensive unit test suite covering basic operations,
    timestamps, jumbo frames, VLAN handling, multi-queue, and more
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows
  - New tests for runtime VLAN offload toggle, VLAN strip with
    infinite_rx mode, and timestamp generation in infinite_rx mode

v16:
  - Split up the patches around transmit logic

Stephen Hemminger (21):
  maintainers: update for pcap driver
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: advertise Tx multi segment
  net/pcap: replace stack bounce buffer with per-queue allocation
  net/pcap: fix error accounting and backpressure on transmit
  net/pcap: add datapath debug logging
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN strip and insert offloads
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  net/pcap: add snapshot length devarg
  net/pcap: add link status change support for iface mode
  net/pcap: add EOF notification via link status change
  test: add comprehensive test suite for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3422 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    9 +
 doc/guides/nics/pcap.rst               |   41 +
 doc/guides/rel_notes/release_26_03.rst |   13 +
 drivers/net/pcap/pcap_ethdev.c         |  923 +++++--
 drivers/net/pcap/pcap_osdep.h          |   39 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   98 +-
 drivers/net/pcap/pcap_osdep_linux.c    |  124 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   95 +-
 11 files changed, 4529 insertions(+), 238 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v16 01/21] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 1b2f1ed2ba..93ac176573 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v16 02/21] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v16 03/21] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v16 04/21] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..fbd1021c39 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v16 05/21] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd1021c39..806451dc99 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v16 06/21] net/pcap: advertise Tx multi segment

[Stephen Hemminger]

The driver supports multi-segment transmit, but the did not set
the offload flag. Therefore applications would not know about
that capability.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 806451dc99..fedf461be4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -753,6 +753,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v16 07/21] net/pcap: replace stack bounce buffer with per-queue allocation

[Stephen Hemminger]

Replace the 64K stack-allocated bounce buffer with a per-queue
buffer allocated from hugepages via rte_malloc at queue setup.
This is necessary because the buffer may be used in a secondary
process transmit path where the primary process allocated it.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 57 +++++++++++++++++++++-------------
 1 file changed, 35 insertions(+), 22 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fedf461be4..4cf5319839 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -91,6 +91,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -385,18 +388,17 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -404,12 +406,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len, caplen;
+
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
@@ -449,9 +449,6 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
 	for (i = 0; i < nb_pkts; i++) {
 		tx_bytes += bufs[i]->pkt_len;
 		rte_pktmbuf_free(bufs[i]);
@@ -460,7 +457,7 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -470,30 +467,30 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		int ret;
+
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
+				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
+				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
@@ -966,7 +963,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -974,11 +971,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1019,6 +1031,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
-- 
2.51.0

[PATCH v16 08/21] net/pcap: fix error accounting and backpressure on transmit

[Stephen Hemminger]

Fix error accounting: backpressure from pcap_sendpacket() (kernel
socket buffer full) was incorrectly counted as errors. Malformed
multi-segment mbufs where pkt_len exceeds actual data were silently
accepted; they are now detected via rte_pktmbuf_read() failure
and counted as errors.

On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
The send() call only blocks when the kernel socket send buffer is full,
providing limited backpressure. Backpressure is not an error.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 71 +++++++++++++++++++++-------------
 1 file changed, 45 insertions(+), 26 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4cf5319839..42c5a37177 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -407,22 +407,27 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len, caplen;
+		uint32_t len, caplen;
+		const uint8_t *data;
 
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
-		num_tx++;
-		tx_bytes += caplen;
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+		if (unlikely(data == NULL)) {
+			/* This only happens if mbuf is bogus pkt_len > data_len */
+			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			dumper_q->tx_stat.err_pkts++;
+		} else {
+			pcap_dump((u_char *)dumper, &header, data);
+
+			num_tx++;
+			tx_bytes += caplen;
+		}
+
 		rte_pktmbuf_free(mbuf);
 	}
 
@@ -461,7 +466,17 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 }
 
 /*
- * Callback to handle sending packets through a real NIC.
+ * Send a burst of packets to a pcap device.
+ *
+ * On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
+ * socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
+ * The send() call only blocks when the kernel socket send buffer is full,
+ * providing limited backpressure.
+ *
+ * On error, pcap_sendpacket() returns non-zero and the loop breaks,
+ * leaving remaining packets unsent.
+ *
+ * Bottom line: backpressure is not an error.
  */
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
@@ -483,34 +498,38 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len = rte_pktmbuf_pkt_len(mbuf);
-		int ret;
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		const uint8_t *data;
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
+		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		if (unlikely(data == NULL)) {
+			/* This only happens if mbuf is bogus pkt_len > data_len */
+			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			tx_queue->tx_stat.err_pkts++;
+		} else {
+			/* Unfortunately, libpcap collapses transient (-EBUSY) and hard errors. */
+			if (pcap_sendpacket(pcap, data, len) != 0) {
+				PMD_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
+				break;
+			}
+			num_tx++;
+			tx_bytes += len;
+		}
+
 		rte_pktmbuf_free(mbuf);
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
 
 	return i;
 }
-- 
2.51.0

[PATCH v16 09/21] net/pcap: add datapath debug logging

[Stephen Hemminger]

Add datapath debug logging macros (PMD_RX_LOG, PMD_TX_LOG) gated
on RTE_ETHDEV_DEBUG_RX/TX. Use PMD_TX_LOG in transmit error paths
to aid debugging without impacting normal datapath performance.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c |  8 ++++----
 drivers/net/pcap/pcap_osdep.h  | 14 ++++++++++++++
 2 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 42c5a37177..8162e611e4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -419,7 +419,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
 		if (unlikely(data == NULL)) {
 			/* This only happens if mbuf is bogus pkt_len > data_len */
-			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			PMD_TX_LOG(ERR, "rte_pktmbuf_read failed");
 			dumper_q->tx_stat.err_pkts++;
 		} else {
 			pcap_dump((u_char *)dumper, &header, data);
@@ -502,7 +502,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		const uint8_t *data;
 
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
-			PMD_LOG(ERR,
+			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			tx_queue->tx_stat.err_pkts++;
@@ -513,12 +513,12 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
 		if (unlikely(data == NULL)) {
 			/* This only happens if mbuf is bogus pkt_len > data_len */
-			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			PMD_TX_LOG(ERR, "rte_pktmbuf_read failed");
 			tx_queue->tx_stat.err_pkts++;
 		} else {
 			/* Unfortunately, libpcap collapses transient (-EBUSY) and hard errors. */
 			if (pcap_sendpacket(pcap, data, len) != 0) {
-				PMD_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
+				PMD_TX_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
 				break;
 			}
 			num_tx++;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..fe7399ff9f 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,6 +13,20 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+#ifdef RTE_ETHDEV_DEBUG_RX
+#define PMD_RX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() rx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_RX_LOG(...) do { } while (0)
+#endif
+
+#ifdef RTE_ETHDEV_DEBUG_TX
+#define PMD_TX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() tx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_TX_LOG(...) do { } while (0)
+#endif
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
-- 
2.51.0

[PATCH v16 10/21] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 8162e611e4..2742e0ca80 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -102,9 +103,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -114,25 +115,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -888,7 +889,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1213,29 +1214,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1511,7 +1502,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1550,9 +1541,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1702,5 +1693,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.51.0

[PATCH v16 11/21] net/pcap: support VLAN strip and insert offloads

[Stephen Hemminger]

Add VLAN tag handling to the pcap PMD, consistent with how virtio
and af_packet drivers implement it.

RX strip: when RTE_ETH_RX_OFFLOAD_VLAN_STRIP is enabled, the driver
calls rte_vlan_strip() on received packets in both normal and
infinite_rx modes. For infinite_rx, offloads are deferred to
packet delivery rather than applied during ring fill, so the
stored template packets remain unmodified.

TX insert: when RTE_MBUF_F_TX_VLAN is set on an mbuf, the driver
inserts the VLAN tag via rte_vlan_insert() before writing to pcap
or sending to the interface. Indirect or shared mbufs get a new
header mbuf to avoid modifying the original.

Runtime reconfiguration is supported through vlan_offload_set,
which propagates the strip setting to all active RX queues.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |   1 +
 doc/guides/nics/pcap.rst               |  11 +++
 doc/guides/rel_notes/release_26_03.rst |   5 ++
 drivers/net/pcap/pcap_ethdev.c         | 118 ++++++++++++++++++++++++-
 4 files changed, 131 insertions(+), 4 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..814bc2119f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index fbfe854bb1..bed5006a42 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -247,3 +247,14 @@ will be discarded by the Rx flushing operation.
    The network interface provided to the PMD should be up.
    The PMD will return an error if the interface is down,
    and the PMD itself won't change the status of the external network interface.
+
+Features and Limitations
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index cb9fda07a8..2d0208ddac 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -92,6 +92,11 @@ New Features
   Added handling of the key combination Control+L
   to clear the screen before redisplaying the prompt.
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
+
 Removed Items
 -------------
 
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2742e0ca80..e794d2ab8d 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -76,6 +76,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -106,6 +107,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -270,7 +272,11 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		bufs[i]->data_len = pcap_buf->data_len;
 		bufs[i]->pkt_len = pcap_buf->pkt_len;
 		bufs[i]->port = pcap_q->port_id;
-		rx_bytes += pcap_buf->data_len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(bufs[i]);
+
+		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
 		rte_ring_enqueue(pcap_q->pkts, pcap_buf);
@@ -336,6 +342,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -382,6 +392,57 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+
+/*
+ * If Vlan offload flag is present, insert the vlan.
+ */
+static inline int
+eth_pcap_tx_vlan(struct pcap_tx_queue *tx_queue, struct rte_mbuf **mbuf)
+{
+	struct rte_mbuf *mb = *mbuf;
+
+	if ((mb->ol_flags & RTE_MBUF_F_TX_VLAN) == 0)
+		return 0;
+
+	if (unlikely(mb->data_len < RTE_ETHER_HDR_LEN)) {
+		PMD_TX_LOG(ERR, "mbuf missing ether header");
+		goto error;
+	}
+
+	/* If indirect or shared then need another buffer to hold VLAN header? */
+	if (!RTE_MBUF_DIRECT(mb) || rte_mbuf_refcnt_read(mb) > 1) {
+		struct rte_mbuf *mh = rte_pktmbuf_alloc(mb->pool);
+		if (unlikely(mh == NULL)) {
+			PMD_TX_LOG(ERR, "mbuf pool exhausted on transmit vlan");
+			goto error;
+		}
+
+		/* Move original ethernet header into new mbuf */
+		memcpy(rte_pktmbuf_mtod(mh, void *),
+		       rte_pktmbuf_mtod(mb, void *), RTE_ETHER_HDR_LEN);
+
+		rte_pktmbuf_adj(mb, RTE_ETHER_HDR_LEN);
+		mh->nb_segs = mb->nb_segs + 1;
+		mh->data_len = RTE_ETHER_HDR_LEN;
+		mh->pkt_len = mb->pkt_len + RTE_ETHER_HDR_LEN;
+		mh->ol_flags = mb->ol_flags;
+		mh->next = mb;
+
+		*mbuf = mh;
+	}
+
+	int ret = rte_vlan_insert(mbuf);
+	if (unlikely(ret != 0)) {
+		PMD_TX_LOG(ERR, "Vlan insert failed: %s", strerror(-ret));
+		goto error;
+	}
+	return 0;
+error:
+	rte_pktmbuf_free(*mbuf);
+	tx_queue->tx_stat.err_pkts++;
+	return -1;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -407,13 +468,17 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
 		const uint8_t *data;
 
+		if (eth_pcap_tx_vlan(dumper_q, &bufs[i]) < 0)
+			continue;
+
+		struct rte_mbuf *mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -498,6 +563,9 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
+		if (eth_pcap_tx_vlan(tx_queue, &bufs[i]) < 0)
+			continue;
+
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
@@ -753,8 +821,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -770,7 +843,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -917,6 +992,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
@@ -926,6 +1002,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		uint64_t pcap_pkt_count = 0;
 		struct rte_mbuf *bufs[1];
 		pcap_t **pcap;
+		bool save_vlan_strip;
 
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
@@ -945,11 +1022,20 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		if (!pcap_q->pkts)
 			return -ENOENT;
 
+		/*
+		 * Temporarily disable offloads while filling the ring
+		 * with raw packets. VLAN strip and timestamp will be
+		 * applied later in eth_pcap_rx_infinite() on each copy.
+		 */
+		save_vlan_strip = pcap_q->vlan_strip;
+		pcap_q->vlan_strip = false;
+
 		/* Fill ring with packets from PCAP file one by one. */
 		while (eth_pcap_rx(pcap_q, bufs, 1)) {
 			/* Check for multiseg mbufs. */
 			if (bufs[0]->nb_segs != 1) {
 				infinite_rx_ring_free(pcap_q->pkts);
+				pcap_q->vlan_strip = save_vlan_strip;
 				PMD_LOG(ERR,
 					"Multiseg mbufs are not supported in infinite_rx mode.");
 				return -EINVAL;
@@ -959,6 +1045,9 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 					(void * const *)bufs, 1, NULL);
 		}
 
+		/* Restore offloads for use during packet delivery */
+		pcap_q->vlan_strip = save_vlan_strip;
+
 		if (rte_ring_count(pcap_q->pkts) < pcap_pkt_count) {
 			infinite_rx_ring_free(pcap_q->pkts);
 			PMD_LOG(ERR,
@@ -1043,6 +1132,26 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	unsigned int i;
+
+	if (mask & RTE_ETH_VLAN_STRIP_MASK) {
+		bool vlan_strip = !!(dev->data->dev_conf.rxmode.offloads &
+				     RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+
+		internals->vlan_strip = vlan_strip;
+
+		/* Update all RX queues */
+		for (i = 0; i < dev->data->nb_rx_queues; i++)
+			internals->rx_queue[i].vlan_strip = vlan_strip;
+	}
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1059,6 +1168,7 @@ static const struct eth_dev_ops ops = {
 	.link_update = eth_link_update,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.vlan_offload_set = eth_vlan_offload_set,
 };
 
 static int
-- 
2.51.0

[PATCH v16 12/21] net/pcap: add link state and speed for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent functions to query the real link state, speed,
duplex, and autonegotiation settings from the underlying interface.
The eth_link_update() callback now returns accurate information
when operating in pass-through mode.

Linux uses ETHTOOL_GLINKSETTINGS which supports all speeds up to
800 Gbps. FreeBSD uses SIOCGIFMEDIA, and Windows uses
GetAdaptersAddresses().

For pcap file mode or separate rx/tx interface configurations,
default values continue to be used since there is no single
underlying interface to query.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         |  93 ++++++++++++++++---
 drivers/net/pcap/pcap_osdep.h          |  24 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  |  86 ++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 118 +++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  |  95 +++++++++++++++++---
 6 files changed, 394 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 2d0208ddac..6a09eb1048 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -95,6 +95,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state and speed in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index e794d2ab8d..f3069968c3 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -150,13 +150,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -971,11 +964,84 @@ eth_dev_close(struct rte_eth_dev *dev)
 	return 0;
 }
 
+/*
+ * Convert osdep speed (Mbps) to rte_eth_link speed constant.
+ */
+static uint32_t
+speed_mbps_to_rte(uint32_t speed_mbps)
+{
+	switch (speed_mbps) {
+	case 10:
+		return RTE_ETH_SPEED_NUM_10M;
+	case 100:
+		return RTE_ETH_SPEED_NUM_100M;
+	case 1000:
+		return RTE_ETH_SPEED_NUM_1G;
+	case 2500:
+		return RTE_ETH_SPEED_NUM_2_5G;
+	case 5000:
+		return RTE_ETH_SPEED_NUM_5G;
+	case 10000:
+		return RTE_ETH_SPEED_NUM_10G;
+	case 20000:
+		return RTE_ETH_SPEED_NUM_20G;
+	case 25000:
+		return RTE_ETH_SPEED_NUM_25G;
+	case 40000:
+		return RTE_ETH_SPEED_NUM_40G;
+	case 50000:
+		return RTE_ETH_SPEED_NUM_50G;
+	case 56000:
+		return RTE_ETH_SPEED_NUM_56G;
+	case 100000:
+		return RTE_ETH_SPEED_NUM_100G;
+	case 200000:
+		return RTE_ETH_SPEED_NUM_200G;
+	case 400000:
+		return RTE_ETH_SPEED_NUM_400G;
+	case 800000:
+		return RTE_ETH_SPEED_NUM_800G;
+	default:
+		return RTE_ETH_SPEED_NUM_UNKNOWN;
+	}
+}
+
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	const char *iface_name = internals->rx_queue[0].name;
+	struct rte_eth_link link;
+	struct osdep_iface_link osdep_link;
+
+	memset(&link, 0, sizeof(link));
+
+	/*
+	 * For pass-through mode (single_iface), query the actual interface.
+	 * Otherwise, use the default static link values.
+	 */
+	if (internals->single_iface &&
+	    osdep_iface_link_get(iface_name, &osdep_link) == 0) {
+		link.link_speed = speed_mbps_to_rte(osdep_link.link_speed);
+		link.link_status = osdep_link.link_status ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_duplex = osdep_link.link_duplex ?
+			RTE_ETH_LINK_FULL_DUPLEX : RTE_ETH_LINK_HALF_DUPLEX;
+		link.link_autoneg = osdep_link.link_autoneg ?
+			RTE_ETH_LINK_AUTONEG : RTE_ETH_LINK_FIXED;
+	} else {
+		/*
+		 * Not in pass-through mode (using pcap files or separate
+		 * interfaces for rx/tx). Or query failed. Use default values.
+		 */
+		link.link_speed = RTE_ETH_SPEED_NUM_10G;
+		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_autoneg = RTE_ETH_LINK_FIXED;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1390,7 +1456,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index fe7399ff9f..b72dd0d74c 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -10,6 +10,7 @@
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
+
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
@@ -27,7 +28,30 @@ extern int eth_pcap_logtype;
 #define PMD_TX_LOG(...) do { } while (0)
 #endif
 
+/**
+ * Link information returned by osdep_iface_link_get().
+ */
+struct osdep_iface_link {
+	uint32_t link_speed;    /**< Speed in Mbps, 0 if unknown */
+	uint8_t link_status;    /**< 1 = up, 0 = down */
+	uint8_t link_duplex;    /**< 1 = full, 0 = half */
+	uint8_t link_autoneg;   /**< 1 = autoneg enabled, 0 = fixed */
+};
+
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link state and speed for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @param link
+ *   Pointer to structure to fill with link information.
+ * @return
+ *   0 on success, -1 on failure.
+ */
+int osdep_iface_link_get(const char *name, struct osdep_iface_link *link);
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..5963b67087 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,12 +5,36 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
 
+/*
+ * Userspace implementation of ifmedia_baudrate().
+ * The kernel function is not exported to userspace, so we implement
+ * our own using the IFM_BAUDRATE_DESCRIPTIONS table from if_media.h.
+ */
+static uint64_t
+ifmedia_baudrate_user(int mword)
+{
+	static const struct ifmedia_baudrate descs[] =
+		IFM_BAUDRATE_DESCRIPTIONS;
+	const struct ifmedia_baudrate *desc;
+
+	for (desc = descs; desc->ifmb_word != 0; desc++) {
+		if (IFM_TYPE_MATCH(desc->ifmb_word, mword))
+			return desc->ifmb_baudrate;
+	}
+	return 0;
+}
+
 int
 osdep_iface_index_get(const char *name)
 {
@@ -55,3 +79,65 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifmediareq ifmr;
+	struct ifreq ifr;
+	uint64_t baudrate;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine administrative status */
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		if (ifr.ifr_flags & IFF_UP)
+			link->link_status = 1;
+	}
+
+	/* Get media status for speed, duplex, and link state */
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(if_fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* Check if link is actually active */
+		if (!(ifmr.ifm_status & IFM_ACTIVE))
+			link->link_status = 0;
+
+		/* Only parse media if we have a valid current media type */
+		if (ifmr.ifm_current != 0 && IFM_TYPE(ifmr.ifm_current) == IFM_ETHER) {
+			/* Use userspace baudrate lookup */
+			baudrate = ifmedia_baudrate_user(ifmr.ifm_current);
+			link->link_speed = baudrate / 1000000;
+
+			/* Check duplex - FDX option means full duplex */
+			if (IFM_OPTIONS(ifmr.ifm_current) & IFM_FDX)
+				link->link_duplex = 1;
+			else
+				link->link_duplex = 0;
+		} else {
+			/* Default to full duplex if we can't determine */
+			link->link_duplex = 1;
+		}
+
+		/* Check autonegotiation status */
+		link->link_autoneg = (ifmr.ifm_current & IFM_AUTO) ? 1 : 0;
+	} else {
+		/*
+		 * SIOCGIFMEDIA failed - interface may not support it.
+		 * Default to reasonable values.
+		 */
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..3b56a833a9 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,11 +4,14 @@
  * All rights reserved.
  */
 
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include <rte_string_fns.h>
 
@@ -40,3 +43,118 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+/*
+ * Get link speed, duplex, and autoneg using ETHTOOL_GLINKSETTINGS.
+ *
+ * ETHTOOL_GLINKSETTINGS was introduced in kernel 4.7 and supports
+ * speeds beyond 65535 Mbps (up to 800 Gbps and beyond).
+ * DPDK requires kernel 4.19 or later, so this interface is always available.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+get_link_settings(int fd, struct ifreq *ifr, struct osdep_iface_link *link)
+{
+	struct ethtool_link_settings probe = { };
+	struct ethtool_link_settings *req;
+	size_t req_size;
+	int nwords;
+	int ret = -1;
+
+	/* First call with nwords = 0 to get the required size */
+	probe.cmd = ETHTOOL_GLINKSETTINGS;
+	ifr->ifr_data = (void *)&probe;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Kernel returns negative nwords on first call */
+	if (probe.link_mode_masks_nwords >= 0)
+		return -1;
+
+	nwords = -probe.link_mode_masks_nwords;
+
+	/* Bounds check */
+	if (nwords == 0 || nwords > 127)
+		return -1;
+
+	/* Second call with correct nwords - need space for 3 link mode masks */
+	req_size = sizeof(*req) + 3 * nwords * sizeof(uint32_t);
+	req = malloc(req_size);
+	if (req == NULL)
+		return -1;
+
+	memset(req, 0, req_size);
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	req->link_mode_masks_nwords = nwords;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		goto out;
+
+	/* Speed is in Mbps, directly usable */
+	link->link_speed = req->speed;
+
+	/* Handle special values */
+	if (link->link_speed == (uint32_t)SPEED_UNKNOWN ||
+	    link->link_speed == (uint32_t)-1)
+		link->link_speed = 0;
+
+	switch (req->duplex) {
+	case DUPLEX_FULL:
+		link->link_duplex = 1;
+		break;
+	case DUPLEX_HALF:
+		link->link_duplex = 0;
+		break;
+	default:
+		link->link_duplex = 1;  /* Default to full duplex */
+		break;
+	}
+
+	link->link_autoneg = (req->autoneg == AUTONEG_ENABLE) ? 1 : 0;
+	ret = 0;
+out:
+	free(req);
+	return ret;
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifreq ifr;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine link status */
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up
+		 * IFF_RUNNING means operationally up (carrier detected)
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			link->link_status = 1;
+	}
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (get_link_settings(if_fd, &ifr, link) < 0) {
+		/*
+		 * ethtool failed - interface may not support it
+		 * (e.g., virtual interfaces like veth, lo).
+		 * Use reasonable defaults.
+		 */
+		link->link_speed = 0;
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..1b76ae3185 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,56 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_get(const char *device_name, struct osdep_iface_link *link)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	memset(link, 0, sizeof(*link));
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			/* Check operational status */
+			if (cur->OperStatus == IfOperStatusUp)
+				link->link_status = 1;
+			else
+				link->link_status = 0;
+
+			/*
+			 * TransmitLinkSpeed and ReceiveLinkSpeed are in bits/sec.
+			 * Convert to Mbps. Use transmit speed as the link speed.
+			 * For asymmetric links, this is a reasonable approximation.
+			 */
+			if (cur->TransmitLinkSpeed != 0 &&
+			    cur->TransmitLinkSpeed != (ULONG64)-1) {
+				link->link_speed =
+					(uint32_t)(cur->TransmitLinkSpeed / 1000000ULL);
+			}
+
+			/*
+			 * Windows doesn't directly expose duplex/autoneg via
+			 * GetAdaptersAddresses(). Default to full duplex.
+			 * For more detailed info, WMI or OID queries would be needed.
+			 */
+			link->link_duplex = 1;  /* Assume full duplex */
+			link->link_autoneg = 0; /* Cannot determine */
+
+			ret = 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v16 13/21] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Add read_clock dev_op returning current UTC time for timestamp
  correlation.
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper.
* Enable immediate mode and improve error reporting
  in live capture setup.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |   3 +
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 157 +++++++++++++++++++------
 3 files changed, 127 insertions(+), 35 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index bed5006a42..2709c6d017 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -258,3 +258,6 @@ Features and Limitations
 *  The PMD will transparently insert a VLAN tag to transmitted packets if
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
+
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 6a09eb1048..2cdc304539 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -96,6 +96,8 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state and speed in ``iface`` mode.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f3069968c3..79a8c63b72 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -27,13 +27,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -77,6 +75,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -108,6 +107,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -269,6 +269,15 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(bufs[i]);
 
+		if (pcap_q->timestamp_offloading) {
+			struct timespec ts;
+
+			timespec_get(&ts, TIME_UTC);
+			*RTE_MBUF_DYNFIELD(bufs[i], timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(&ts);
+			bufs[i]->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
@@ -339,10 +348,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -362,14 +382,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -458,8 +483,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		uint32_t len, caplen;
 		const uint8_t *data;
@@ -469,9 +496,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 		struct rte_mbuf *mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -600,22 +624,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
+	}
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
+	}
+
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -662,7 +726,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -821,6 +886,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -838,7 +904,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -1060,6 +1127,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1198,6 +1266,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static int
 eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
 {
@@ -1224,6 +1303,7 @@ static const struct eth_dev_ops ops = {
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1639,15 +1719,22 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		hz = rte_get_timer_hz();
+		if (hz == 0) {
+			PMD_LOG(ERR, "Reported hz is zero!");
+			return -1;
+		}
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							 &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v16 14/21] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 79a8c63b72..676b928484 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -668,6 +668,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.51.0

[PATCH v16 15/21] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 676b928484..be14d7690d 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -46,11 +46,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -626,6 +624,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -737,6 +736,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1540,6 +1541,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v16 16/21] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index be14d7690d..fc425109d5 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -54,10 +54,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -927,11 +927,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v16 17/21] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fc425109d5..9a5bab9932 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -910,10 +910,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v16 18/21] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

Example usage:
  --vdev 'net_pcap0,iface=eth0,snaplen=1518'
  --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |  15 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 240 ++++++++++++++++---------
 3 files changed, 170 insertions(+), 86 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2709c6d017..f241069ebb 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -162,6 +162,21 @@ Runtime Config Options
 
   In this case, one dummy Rx queue is created for each Tx queue argument passed.
 
+* Set the snapshot length for packet capture
+
+  The snapshot length controls the maximum number of bytes captured per packet.
+  This affects both interface capture and pcap file output.  The default value is
+  65535 bytes, which captures complete packets up to the maximum Ethernet jumbo
+  frame size.  Reducing this value can improve performance when only packet headers
+  are needed.  This can be done with the ``snaplen`` devarg, for example::
+
+     --vdev 'net_pcap0,iface=eth0,snaplen=1518'
+     --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'
+
+  The snapshot length also determines the reported ``max_rx_pktlen``
+  and ``max_mtu`` in device info.
+
+
 Examples of Usage
 ~~~~~~~~~~~~~~~~~
 
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 2cdc304539..3e82b51d3c 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -98,6 +98,7 @@ New Features
   * Added support for reporting link state and speed in ``iface`` mode.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 9a5bab9932..b0e2728990 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -13,6 +13,9 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <net/if.h>
+#include <unistd.h>
+
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -31,8 +34,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -41,6 +42,12 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
+
+/* This is defined in libpcap but not exposed in headers */
+#define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -101,6 +108,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -128,6 +136,7 @@ struct pmd_devargs {
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -145,11 +154,16 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declaration */
+static inline int set_iface_direction(const char *iface, pcap_t *pcap,
+				      pcap_direction_t direction);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -465,20 +479,19 @@ eth_pcap_tx_vlan(struct pcap_tx_queue *tx_queue, struct rte_mbuf **mbuf)
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -486,14 +499,15 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		uint32_t len, caplen;
 		const uint8_t *data;
 
 		if (eth_pcap_tx_vlan(dumper_q, &bufs[i]) < 0)
 			continue;
 
 		struct rte_mbuf *mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t caplen = RTE_MIN(len, snaplen);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -562,19 +576,18 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
@@ -585,10 +598,10 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > snaplen)) {
 			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
-				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+				len, snaplen);
 			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
@@ -622,7 +635,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -639,6 +652,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
 			iface, pcap_statustostr(status));
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	status = pcap_set_immediate_mode(pc, 1);
@@ -651,7 +667,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -665,6 +681,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -693,9 +712,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -704,7 +723,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -714,7 +734,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -723,9 +743,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -775,15 +795,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
 		rx = &internals->rx_queue[0];
 
-		if (!pp->tx_pcap[0] &&
-			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+		if (!pp->tx_pcap[0] && strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -795,14 +815,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -817,9 +834,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -910,11 +932,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1227,7 +1249,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1357,6 +1379,12 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *rx = extra_args;
 	pcap_t *pcap = NULL;
 
+	if (access(pcap_filename, R_OK) != 0) {
+		PMD_LOG(ERR, "Cannot read pcap file '%s': %s",
+			pcap_filename, strerror(errno));
+		return -1;
+	}
+
 	if (open_single_rx_pcap(pcap_filename, &pcap) < 0)
 		return -1;
 
@@ -1369,41 +1397,53 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 }
 
 /*
- * Opens a pcap file for writing and stores a reference to it
- * for use it later on.
+ * Store TX pcap file configuration.
+ * The actual pcap dumper is opened in eth_dev_start().
  */
 static int
 open_tx_pcap(const char *key, const char *value, void *extra_args)
 {
 	const char *pcap_filename = value;
 	struct pmd_devargs *dumpers = extra_args;
-	pcap_dumper_t *dumper;
+	FILE *f;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	/* Validate that pcap_filename can be created. */
+	if (strcmp(pcap_filename, "-") == 0) {
+		/* This isn't going to work very well in DPDK - so reject it */
+		PMD_LOG(ERR, "Sending pcap binary data to stdout is not supported");
 		return -1;
+	}
 
-	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
-		pcap_dump_close(dumper);
+	f = fopen(pcap_filename, "wb");
+	if (f == NULL) {
+		PMD_LOG(ERR, "Cannot open '%s' for writing: %s", pcap_filename, strerror(errno));
 		return -1;
 	}
+	fclose(f);
+
+	if (add_queue(dumpers, pcap_filename, key, NULL, NULL) < 0)
+		return -1;
 
 	return 0;
 }
 
 /*
- * Opens an interface for reading and writing
+ * Store interface configuration for reading and writing.
+ * The actual pcap handle is opened in eth_dev_start().
  */
 static inline int
 open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *tx = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (if_nametoindex(iface) == 0) {
+		PMD_LOG(ERR, "Interface '%s' not found: %s",
+			iface, strerror(errno));
 		return -1;
+	}
 
-	tx->queue[0].pcap = pcap;
+	tx->queue[0].pcap = NULL;
 	tx->queue[0].name = iface;
 	tx->queue[0].type = key;
 
@@ -1425,50 +1465,38 @@ set_iface_direction(const char *iface, pcap_t *pcap,
 	return 0;
 }
 
+/*
+ * Store interface configuration.
+ * The actual pcap handle is opened in eth_dev_start().
+ */
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *pmd = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
-		return -1;
-	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
-		pcap_close(pcap);
+	if (if_nametoindex(iface) == 0) {
+		PMD_LOG(ERR, "Interface '%s' not found: %s",
+			iface, strerror(errno));
 		return -1;
 	}
 
+	if (add_queue(pmd, iface, key, NULL, NULL) < 0)
+		return -1;
+
 	return 0;
 }
 
 /*
- * Opens a NIC for reading packets from it
+ * Store RX interface configuration.
+ * The actual pcap handle is opened and direction set in eth_dev_start().
  */
-static inline int
-open_rx_iface(const char *key, const char *value, void *extra_args)
-{
-	int ret = open_iface(key, value, extra_args);
-	if (ret < 0)
-		return ret;
-	if (strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
-		struct pmd_devargs *pmd = extra_args;
-		unsigned int qid = pmd->num_of_queue - 1;
-
-		set_iface_direction(pmd->queue[qid].name,
-				pmd->queue[qid].pcap,
-				PCAP_D_IN);
-	}
-
-	return 0;
-}
-
 static inline int
 rx_iface_args_process(const char *key, const char *value, void *extra_args)
 {
 	if (strcmp(key, ETH_PCAP_RX_IFACE_ARG) == 0 ||
-			strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
-		return open_rx_iface(key, value, extra_args);
+	    strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+		return open_iface(key, value, extra_args);
 
 	return 0;
 }
@@ -1500,6 +1528,31 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN ||
+	    val > ETH_PCAP_MAXIMUM_SNAPLEN) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1664,6 +1717,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1724,6 +1779,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1771,7 +1827,18 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	}
 
 	/*
-	 * If iface argument is passed we open the NICs and use them for
+	 * Process optional snapshot length argument.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+	/*
+	 * If iface argument is passed we check that NIC can be used
 	 * reading / writing
 	 */
 	if (rte_kvargs_count(kvlist, ETH_PCAP_IFACE_ARG) == 1) {
@@ -1976,4 +2043,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v16 19/21] net/pcap: add link status change support for iface mode

[Stephen Hemminger]

Add LSC interrupt support for pass-through (iface=) mode so
applications can receive link state change notifications via
the standard ethdev callback mechanism.

Uses alarm-based polling to periodically check the underlying
interface state via osdep_iface_link_get(). The LSC flag is
advertised only for iface mode devices, and polling is gated
on the application enabling intr_conf.lsc in port configuration.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 45 +++++++++++++++++++++++++-
 3 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 814bc2119f..084fefbbbb 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -5,6 +5,7 @@
 ;
 [Features]
 Link status          = Y
+Link status event    = Y
 Queue start/stop     = Y
 Scattered Rx         = Y
 Timestamp offload    = Y
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 3e82b51d3c..314f6d615b 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -99,6 +99,7 @@ New Features
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added support for Link State interrupt in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index b0e2728990..5fc534014e 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -18,6 +18,7 @@
 
 #include <pcap.h>
 
+#include <rte_alarm.h>
 #include <rte_cycles.h>
 #include <rte_ring.h>
 #include <rte_ethdev.h>
@@ -49,6 +50,8 @@
 /* This is defined in libpcap but not exposed in headers */
 #define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
+#define ETH_PCAP_LSC_POLL_INTERVAL_US (1000 * 1000) /* 1 second */
+
 #define ETH_PCAP_ARG_MAXLEN	64
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
@@ -114,6 +117,7 @@ struct pmd_internals {
 	bool infinite_rx;
 	bool vlan_strip;
 	bool timestamp_offloading;
+	bool lsc_active;
 };
 
 struct pmd_process_private {
@@ -160,9 +164,10 @@ static const char *valid_arguments[] = {
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
-/* Forward declaration */
+/* Forward declarations */
 static inline int set_iface_direction(const char *iface, pcap_t *pcap,
 				      pcap_direction_t direction);
+static int eth_link_update(struct rte_eth_dev *dev, int wait_to_complete);
 
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
@@ -787,6 +792,28 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+/*
+ * Periodic alarm to poll link state.
+ * Enabled when link state interrupt is enabled in single_iface mode.
+ */
+static void
+eth_pcap_lsc_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link old_link, new_link;
+
+	rte_eth_linkstatus_get(dev, &old_link);
+	eth_link_update(dev, 0);
+	rte_eth_linkstatus_get(dev, &new_link);
+
+	if (old_link.link_status != new_link.link_status)
+		rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+
+	if (internals->lsc_active)
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US, eth_pcap_lsc_alarm, dev);
+}
+
 static int
 eth_dev_start(struct rte_eth_dev *dev)
 {
@@ -854,6 +881,13 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
+	/* Start LSC polling for iface mode if application requested it */
+	if (internals->single_iface && dev->data->dev_conf.intr_conf.lsc) {
+		internals->lsc_active = true;
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US,
+				  eth_pcap_lsc_alarm, dev);
+	}
+
 	return 0;
 }
 
@@ -871,6 +905,12 @@ eth_dev_stop(struct rte_eth_dev *dev)
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
+		/* Cancel LSC polling before closing pcap handles */
+		if (internals->lsc_active) {
+			internals->lsc_active = false;
+			rte_eal_alarm_cancel(eth_pcap_lsc_alarm, dev);
+		}
+
 		queue_missed_stat_on_stop_update(dev, 0);
 		if (pp->tx_pcap[0] != NULL) {
 			pcap_close(pp->tx_pcap[0]);
@@ -1708,6 +1748,9 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		internals->if_index =
 			osdep_iface_index_get(rx_queues->queue[0].name);
 
+		/* Enable LSC interrupt support for iface mode */
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 		/* phy_mac arg is applied only if "iface" devarg is provided */
 		if (rx_queues->phy_mac) {
 			if (eth_pcap_update_mac(rx_queues->queue[0].name,
-- 
2.51.0

[PATCH v16 20/21] net/pcap: add EOF notification via link status change

[Stephen Hemminger]

Add an "eof" devarg for rx_pcap mode that signals end-of-file by
setting link down and generating an LSC event. This allows
applications to detect when a pcap file has been fully consumed
using the standard ethdev callback mechanism.

The eof and infinite_rx options are mutually exclusive. On device
restart, the EOF state is reset so the file can be replayed.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               | 12 +++++
 doc/guides/rel_notes/release_26_03.rst |  2 +
 drivers/net/pcap/pcap_ethdev.c         | 75 ++++++++++++++++++++++++--
 3 files changed, 86 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index f241069ebb..6f3a4fc887 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -144,6 +144,18 @@ Runtime Config Options
   so all queues on a device will either have this enabled or disabled.
   This option should only be provided once per device.
 
+* Signal end-of-file via link status change
+
+  In case ``rx_pcap=`` configuration is set, the user may want to be notified when
+  all packets in the pcap file have been read.  This can be done with the ``eof``
+  devarg, for example::
+
+     --vdev 'net_pcap0,rx_pcap=file_rx.pcap,eof=1'
+
+  When enabled, the driver sets link down and generates an LSC event at end of file.
+  If the device is stopped and restarted, the EOF state is reset.
+  This option cannot be combined with ``infinite_rx``.
+
 * Drop all packets on transmit
 
   To drop all packets on transmit for a device,
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 314f6d615b..1e30256f36 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -100,6 +100,8 @@ New Features
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
   * Added support for Link State interrupt in ``iface`` mode.
+  * Added ``eof`` devarg to use link state to signal end of receive
+    file input.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 5fc534014e..80c6f15cb4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -43,6 +43,7 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_EOF_ARG          "eof"
 #define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
 
 #define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
@@ -115,6 +116,8 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool eof;
+	bool eof_signaled;
 	bool vlan_strip;
 	bool timestamp_offloading;
 	bool lsc_active;
@@ -147,6 +150,7 @@ struct pmd_devargs_all {
 	bool is_rx_pcap;
 	bool is_rx_iface;
 	bool infinite_rx;
+	bool eof;
 };
 
 static const char *valid_arguments[] = {
@@ -158,6 +162,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_EOF_ARG,
 	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
@@ -307,15 +312,33 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	return i;
 }
 
+/*
+ * Deferred EOF alarm callback.
+ *
+ * Scheduled from the RX burst path when end-of-file is reached,
+ * so that rte_eth_dev_callback_process() runs outside the datapath.
+ * This avoids holding any locks that the application callback
+ * might also need, preventing potential deadlocks.
+ */
+static void
+eth_pcap_eof_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+
+	rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+}
+
 static uint16_t
 eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
+	struct pcap_rx_queue *pcap_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[pcap_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
 	unsigned int i;
 	struct pcap_pkthdr *header;
 	struct pmd_process_private *pp;
 	const u_char *packet;
 	struct rte_mbuf *mbuf;
-	struct pcap_rx_queue *pcap_q = queue;
 	uint16_t num_rx = 0;
 	uint32_t rx_bytes = 0;
 	pcap_t *pcap;
@@ -336,6 +359,19 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			if (ret == PCAP_ERROR)
 				pcap_q->rx_stat.err_pkts++;
 
+			/*
+			 * EOF: if eof mode is enabled, set link down and
+			 * defer notification via alarm to avoid calling
+			 * rte_eth_dev_callback_process() from the datapath.
+			 */
+			else if (ret == PCAP_ERROR_BREAK) {
+				if (internals->eof && !internals->eof_signaled) {
+					internals->eof_signaled = true;
+					eth_link_update(dev, 0);
+					rte_eal_alarm_set(1, eth_pcap_eof_alarm, dev);
+				}
+			}
+
 			break;
 		}
 
@@ -879,6 +915,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++)
 		dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
 
+	internals->eof_signaled = false;
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
 	/* Start LSC polling for iface mode if application requested it */
@@ -941,6 +978,10 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	}
 
 status_down:
+	/* Cancel any pending EOF alarm */
+	if (internals->eof_signaled)
+		rte_eal_alarm_cancel(eth_pcap_eof_alarm, dev);
+
 	for (i = 0; i < dev->data->nb_rx_queues; i++)
 		dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
 
@@ -1178,9 +1219,13 @@ eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 		 */
 		link.link_speed = RTE_ETH_SPEED_NUM_10G;
 		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
-		link.link_status = dev->data->dev_started ?
-			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 		link.link_autoneg = RTE_ETH_LINK_FIXED;
+
+		if (internals->eof_signaled)
+			link.link_status = RTE_ETH_LINK_DOWN;
+		else
+			link.link_status = dev->data->dev_started ?
+				RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 	}
 
 	return rte_eth_linkstatus_set(dev, &link);
@@ -1760,8 +1805,13 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->eof = devargs_all->eof;
 	internals->snapshot_len = devargs_all->snapshot_len;
 
+	/* Enable LSC for eof mode (already set above for single_iface) */
+	if (internals->eof)
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1948,6 +1998,24 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 					"for %s", name);
 		}
 
+		/*
+		 * Check whether to signal EOF via link status change.
+		 */
+		if (rte_kvargs_count(kvlist, ETH_PCAP_EOF_ARG) == 1) {
+			ret = rte_kvargs_process(kvlist, ETH_PCAP_EOF_ARG,
+						 &process_bool_flag,
+						 &devargs_all.eof);
+			if (ret < 0)
+				goto free_kvlist;
+		}
+
+		if (devargs_all.infinite_rx && devargs_all.eof) {
+			PMD_LOG(ERR, "Cannot use both infinite_rx and eof for %s",
+				name);
+			ret = -EINVAL;
+			goto free_kvlist;
+		}
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
 				&open_rx_pcap, &pcaps);
 	} else if (devargs_all.is_rx_iface) {
@@ -2087,4 +2155,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_EOF_ARG "=<0|1> "
 	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v16 21/21] test: add comprehensive test suite for pcap PMD

[Stephen Hemminger]

Add unit tests for the pcap PMD covering file and interface modes.

Tests include:
  - basic TX to file and RX from file
  - varied packet sizes and jumbo frames
  - infinite RX mode
  - TX drop mode
  - statistics
  - interface (iface=) pass-through mode
  - link status reporting for file and iface modes
  - link status change (LSC) with interface toggle
  - EOF notification via LSC
  - RX timestamps and timestamp with infinite RX
  - multiple TX/RX queues
  - VLAN strip, insert, and runtime offload configuration
  - snapshot length (snaplen) and truncation

Cross-platform helpers handle temp file creation, interface
discovery, and VLAN packet generation.

The LSC link toggle test requires a pre-created dummy interface
(Linux: dummy0, FreeBSD: disc0) and is skipped if unavailable.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3422 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 3425 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index 48874037eb..a83292cf49 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..5f57184d5f
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,3422 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define access _access
+#define F_OK 0
+#else
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths */
+static char tx_pcap_path[PATH_MAX];
+static char rx_pcap_path[PATH_MAX];
+static char infinite_pcap_path[PATH_MAX];
+static char timestamp_pcap_path[PATH_MAX];
+static char varied_pcap_path[PATH_MAX];
+static char jumbo_pcap_path[PATH_MAX];
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+static char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+static char multi_rx_pcap_path[PATH_MAX];
+static char vlan_rx_pcap_path[PATH_MAX];
+static char vlan_tx_pcap_path[PATH_MAX];
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port with custom config
+ */
+static int
+setup_pcap_port_conf(uint16_t port, const struct rte_eth_conf *conf)
+{
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port (default: timestamp offload)
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+	int ret;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+	int ret;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+	int ret;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+	int ret;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path),
+				     "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path),
+				     "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	int ret;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link Status Change (LSC) interrupt support
+ *
+ * Verifies that:
+ * 1. LSC capability is NOT advertised for file mode
+ * 2. LSC capability IS advertised for iface mode
+ * 3. LSC callback fires when the underlying interface goes down/up
+ *
+ * Requires a toggleable Ethernet interface created before running:
+ *   Linux:   ip link add dummy0 type dummy && ip link set dummy0 up
+ *   FreeBSD: ifconfig disc0 create && ifconfig disc0 up
+ *
+ * Skipped if no suitable interface is found or on Windows.
+ */
+
+/* Callback counter for LSC test */
+static volatile int lsc_callback_count;
+
+static int
+test_lsc_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	lsc_callback_count++;
+	return 0;
+}
+
+#ifndef RTE_EXEC_ENV_WINDOWS
+/*
+ * Helper: Set interface link up or down via ioctl.
+ * Returns 0 on success, -errno on failure.
+ */
+static int
+set_iface_up_down(const char *ifname, int up)
+{
+	struct ifreq ifr;
+	int fd, ret;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd < 0)
+		return -errno;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	ret = ioctl(fd, SIOCGIFFLAGS, &ifr);
+	if (ret < 0) {
+		ret = -errno;
+		close(fd);
+		return ret;
+	}
+
+	if (up)
+		ifr.ifr_flags |= IFF_UP;
+	else
+		ifr.ifr_flags &= ~IFF_UP;
+
+	ret = ioctl(fd, SIOCSIFFLAGS, &ifr);
+	if (ret < 0)
+		ret = -errno;
+	else
+		ret = 0;
+
+	close(fd);
+	return ret;
+}
+
+/*
+ * Helper: Find a toggleable test interface for LSC testing.
+ *
+ * Looks for well-known interfaces that are safe to bring up/down:
+ *   Linux:   dummy0 (ip link add dummy0 type dummy)
+ *   FreeBSD: disc0 (ifconfig disc0 create)
+ *
+ * Returns interface name or NULL if none found.
+ */
+static const char *
+find_lsc_test_iface(void)
+{
+	static const char *candidates[] = { "dummy0", "disc0" };
+	unsigned int i;
+
+	for (i = 0; i < RTE_DIM(candidates); i++) {
+		if (iface_is_ethernet(candidates[i]))
+			return candidates[i];
+	}
+	return NULL;
+}
+#endif
+
+static int
+test_lsc_iface(void)
+{
+	struct rte_eth_dev_info dev_info;
+	struct rte_eth_link link;
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	char devargs[256];
+	uint16_t port_id;
+	int ret;
+
+	printf("Testing Link Status Change (LSC) support\n");
+
+	/*
+	 * Test 1: Verify LSC is NOT advertised for file mode
+	 */
+	printf("  Testing file mode does not advertise LSC\n");
+	{
+		char lsc_pcap_path[PATH_MAX];
+		uint16_t file_port_id;
+
+		TEST_ASSERT(create_temp_path(lsc_pcap_path, sizeof(lsc_pcap_path),
+					     "pcap_lsc") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(lsc_pcap_path, 1) == 0,
+			    "Failed to create test pcap");
+
+		ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", lsc_pcap_path);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		TEST_ASSERT(create_pcap_vdev("net_pcap_lsc_file", devargs,
+					     &file_port_id) == 0,
+			    "Failed to create file vdev");
+
+		ret = rte_eth_dev_info_get(file_port_id, &dev_info);
+		TEST_ASSERT(ret == 0, "Failed to get dev info");
+
+		TEST_ASSERT((*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC) == 0,
+			    "File mode should NOT advertise LSC capability");
+
+		rte_vdev_uninit("net_pcap_lsc_file");
+		remove_temp_file(lsc_pcap_path);
+		printf("  File mode LSC check PASSED\n");
+	}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+	printf("  Link toggle test not supported on Windows, skipping\n");
+	return TEST_SUCCESS;
+#else
+	/*
+	 * Test 2: Use a toggleable interface to test link change events.
+	 * Skip if not present.
+	 */
+	const char *lsc_iface = find_lsc_test_iface();
+	if (lsc_iface == NULL) {
+		printf("  No toggleable interface found, skipping link change test\n");
+		printf("  Linux:   ip link add dummy0 type dummy && ip link set dummy0 up\n");
+		printf("  FreeBSD: ifconfig disc0 create && ifconfig disc0 up\n");
+		return TEST_SUCCESS;
+	}
+
+	printf("  Testing iface mode LSC with: %s\n", lsc_iface);
+
+	/* Ensure interface is up before we start */
+	ret = set_iface_up_down(lsc_iface, 1);
+	if (ret != 0) {
+		printf("  Cannot set %s up (%s), skipping\n",
+		       lsc_iface, strerror(-ret));
+		return TEST_SUCCESS;
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", lsc_iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_lsc", devargs);
+	if (ret < 0) {
+		printf("  Cannot create iface vdev for %s, skipping\n", lsc_iface);
+		return TEST_SUCCESS;
+	}
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_lsc", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "Iface mode should advertise LSC capability");
+	printf("    LSC capability advertised: yes\n");
+
+	/* Register LSC callback */
+	lsc_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_lsc_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link status");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+	printf("    Link after start: UP\n");
+
+	/* Bring interface down - should trigger LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 0);
+	TEST_ASSERT(ret == 0, "Failed to set %s down: %s",
+		    lsc_iface, strerror(-ret));
+
+	/* Wait for at least one poll cycle (1 second interval) */
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after down");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after interface down");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired, count=%d",
+		    lsc_callback_count);
+	printf("    Interface down: link DOWN, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Bring it back up - should trigger another LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 1);
+	TEST_ASSERT(ret == 0, "Failed to set %s up: %s",
+		    lsc_iface, strerror(-ret));
+
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after up");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after interface up");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired on link restore, count=%d",
+		    lsc_callback_count);
+	printf("    Interface up: link UP, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Cleanup */
+	rte_eth_dev_stop(port_id);
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_lsc_callback, NULL);
+	rte_vdev_uninit("net_pcap_lsc");
+
+	printf("LSC test PASSED\n");
+	return TEST_SUCCESS;
+#endif /* !RTE_EXEC_ENV_WINDOWS */
+}
+
+/*
+ * Test: EOF notification via link status change
+ *
+ * Verifies that:
+ * 1. The eof devarg causes link down + LSC event at end of pcap file
+ * 2. link_get reports DOWN after EOF
+ * 3. Stop/start resets the EOF state and replays the file
+ * 4. The eof and infinite_rx options are mutually exclusive
+ */
+
+static volatile int eof_callback_count;
+
+static int
+test_eof_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	eof_callback_count++;
+	return 0;
+}
+
+static int
+test_eof_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	struct rte_eth_link link;
+	char eof_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx;
+	int ret;
+
+	printf("Testing EOF notification via link status change\n");
+
+	/* Create pcap file with known number of packets */
+	TEST_ASSERT(create_temp_path(eof_pcap_path, sizeof(eof_pcap_path),
+				     "pcap_eof") == 0,
+		    "Failed to create temp file path");
+	TEST_ASSERT(create_test_pcap(eof_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/*
+	 * Test 1: EOF triggers link down and LSC callback
+	 */
+	printf("  Testing EOF triggers link down and LSC event\n");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,eof=1",
+		       eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create eof vdev: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_eof", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	struct rte_eth_dev_info dev_info;
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "EOF mode should advertise LSC capability");
+
+	/* Register LSC callback */
+	eof_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_eof_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Drain all packets from the pcap file */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			/* Got all packets and rx returned 0 — EOF hit */
+			break;
+		}
+	}
+
+	printf("    Received %u packets (expected %d)\n", total_rx, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Should receive exactly %d packets", NUM_PACKETS);
+
+	/* Verify link went down */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after EOF");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after EOF");
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	/* Verify callback fired exactly once */
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "LSC callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    EOF signaled: link DOWN, callback fired\n");
+
+	/*
+	 * Test 2: Stop/start resets EOF and replays the file
+	 */
+	printf("  Testing restart replays pcap file\n");
+
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	eof_callback_count = 0;
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to restart port");
+
+	/* Verify link is up again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after restart");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after restart");
+
+	/* Read packets again */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			break;
+		}
+	}
+
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Restart: should receive %d packets, got %u",
+			  NUM_PACKETS, total_rx);
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "Restart: callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    Restart replay: %u packets, EOF signaled again\n", total_rx);
+
+	/* Cleanup */
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_eof_callback, NULL);
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_eof");
+
+	/*
+	 * Test 3: eof + infinite_rx is rejected
+	 */
+	printf("  Testing eof + infinite_rx mutual exclusion\n");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,eof=1,infinite_rx=1", eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof_bad", devargs);
+	TEST_ASSERT(ret != 0, "eof + infinite_rx should be rejected");
+	printf("    Mutual exclusion check PASSED\n");
+
+	remove_temp_file(eof_pcap_path);
+
+	printf("EOF test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64" actual=%"PRIu64"\n",
+			       i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0, "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Runtime VLAN offload configuration via rte_eth_dev_set_vlan_offload
+ *
+ * This test verifies that VLAN strip can be enabled/disabled at runtime
+ * using the standard ethdev API rather than only at configure time.
+ * Uses infinite_rx mode so the same packets can be read in each phase.
+ */
+static int
+test_vlan_offload_set(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char vlan_set_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf = { 0 };
+	unsigned int i;
+	uint16_t nb_rx;
+	int ret, current_offload;
+	size_t tagged_len, untagged_len;
+
+	printf("Testing runtime VLAN offload configuration\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_set_pcap_path, sizeof(vlan_set_pcap_path),
+				     "pcap_vlan_set") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_set_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	/* Use infinite_rx so packets are always available */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", vlan_set_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_set", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+
+	/* Configure WITHOUT VLAN strip initially and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port");
+
+	/* Expected lengths */
+	tagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		     sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+	untagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN strip is initially disabled */
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled initially");
+
+	/*
+	 * Phase 1: VLAN strip disabled - packets should have tags
+	 */
+	printf("  Phase 1: VLAN strip disabled\n");
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 1");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 1 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact\n", nb_rx);
+
+	/*
+	 * Phase 2: Enable VLAN strip at runtime - packets should be stripped
+	 */
+	printf("  Phase 2: Enabling VLAN strip via rte_eth_dev_set_vlan_offload\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, RTE_ETH_VLAN_STRIP_OFFLOAD);
+	TEST_ASSERT(ret == 0, "Failed to enable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD,
+		    "VLAN strip should be enabled after set_vlan_offload");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 2");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), untagged_len,
+				  "Phase 2 packet %u: expected untagged length %zu, got %u",
+				  i, untagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Phase 2 packet %u: VLAN_STRIPPED flag not set", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags stripped\n", nb_rx);
+
+	/*
+	 * Phase 3: Disable VLAN strip - packets should have tags again
+	 */
+	printf("  Phase 3: Disabling VLAN strip\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to disable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled after clearing");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 3");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 3 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact again\n", nb_rx);
+
+	cleanup_pcap_vdev("net_pcap_vlan_set", port_id);
+	remove_temp_file(vlan_set_pcap_path);
+
+	printf("Runtime VLAN offload PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip in infinite RX mode
+ *
+ * This test verifies that VLAN strip offload works correctly when combined
+ * with infinite_rx mode, which uses a different RX path (eth_pcap_rx_infinite).
+ */
+static int
+test_vlan_strip_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	char vlan_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int stripped_count = 0;
+	int iter, attempts, ret;
+	size_t expected_len;
+
+	printf("Testing VLAN strip with infinite RX mode\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_inf_pcap_path, sizeof(vlan_inf_pcap_path),
+				     "pcap_vlan_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_inf_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets for infinite RX\n", NUM_PACKETS);
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", vlan_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_vlan_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_vlan_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with VLAN strip enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Expected length after VLAN strip */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Read packets - need more than file contains to verify infinite looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				/* Verify VLAN was stripped */
+				if (verify_no_vlan_tag(mbufs[i]) == 0 &&
+				    rte_pktmbuf_pkt_len(mbufs[i]) == expected_len &&
+				    (mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED))
+					stripped_count++;
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_vlan_inf");
+	remove_temp_file(vlan_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(stripped_count, total_rx,
+			  "VLAN strip failed: only %u/%u packets stripped correctly",
+			  stripped_count, total_rx);
+
+	printf("VLAN strip infinite RX PASSED: %u packets stripped (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Timestamps in infinite RX mode
+ *
+ * This test verifies that timestamp offload works correctly when combined
+ * with infinite_rx mode. Since infinite_rx generates packets on-the-fly,
+ * timestamps should reflect the current time rather than pcap file timestamps.
+ */
+static int
+test_timestamp_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	char ts_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int ts_count = 0;
+	int iter, attempts, ret;
+	rte_mbuf_timestamp_t first_ts = 0;
+	rte_mbuf_timestamp_t last_ts = 0;
+
+	printf("Testing timestamps with infinite RX mode\n");
+
+	/* Initialize timestamp dynamic field access */
+	if (timestamp_dynfield_offset < 0) {
+		ret = timestamp_init();
+		if (ret != 0) {
+			printf("Timestamp dynfield not available, skipping\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	/* Create simple pcap file */
+	TEST_ASSERT(create_temp_path(ts_inf_pcap_path, sizeof(ts_inf_pcap_path),
+				     "pcap_ts_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_test_pcap(ts_inf_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", ts_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_ts_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_ts_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with timestamp offload enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with timestamps");
+
+	/* Read packets */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				if (mbuf_has_timestamp(mbufs[i])) {
+					rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+
+					if (ts_count == 0)
+						first_ts = ts;
+					last_ts = ts;
+					ts_count++;
+				}
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_ts_inf");
+	remove_temp_file(ts_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(ts_count, total_rx,
+			  "Timestamp missing: only %u/%u packets have timestamps",
+			  ts_count, total_rx);
+
+	/* Timestamps should be monotonically increasing (current time) */
+	TEST_ASSERT(last_ts >= first_ts,
+		    "Timestamps not monotonic: first=%" PRIu64 " last=%" PRIu64,
+		    first_ts, last_ts);
+
+	printf("Timestamp infinite RX PASSED: %u packets with valid timestamps\n", total_rx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	unsigned int i;
+
+	/* Cleanup temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(infinite_pcap_path);
+	remove_temp_file(timestamp_pcap_path);
+	remove_temp_file(varied_pcap_path);
+	remove_temp_file(jumbo_pcap_path);
+
+	for (i = 0; i < RTE_DIM(multi_tx_pcap_paths); i++)
+		remove_temp_file(multi_tx_pcap_paths[i]);
+
+	remove_temp_file(multi_rx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+	remove_temp_file(vlan_tx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_lsc_iface),
+		TEST_CASE(test_eof_rx),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_vlan_offload_set),
+		TEST_CASE(test_vlan_strip_infinite_rx),
+		TEST_CASE(test_timestamp_infinite_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 1e30256f36..7fba410463 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -102,6 +102,7 @@ New Features
   * Added support for Link State interrupt in ``iface`` mode.
   * Added ``eof`` devarg to use link state to signal end of receive
     file input.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v17 00/23] net/pcap: fixes, test, and ehancements

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx and stripping on Rx
  - Runtime VLAN offload configuration via vlan_offload_set callback
  - Nanosecond precision timestamps (when hardware/libpcap supports it)
  - Accurate link state, speed, and duplex reporting in interface mode
  - Link status change (LSC) interrupt support in interface mode
  - EOF notification via link status change for rx_pcap mode
  - Support for Windows interface mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snaplen devarg

Bug fixes:
  - Fix build on Windows from RTE_LOG_LINE changes.
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Change Tx burst to always consume all packets; failed sends
    increment error counter rather than leaving mbufs for retry
    (pcap_sendpacket failures are not transient)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback
  - Fix infinite_rx ring fill applying VLAN strip and timestamp
    offloads to template packets, preventing those offloads from
    working correctly during packet delivery

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables
  - Defer pcap handle opening until device start
  - Use bulk free for better Tx performance

Testing:
  - Add comprehensive unit test suite covering basic operations,
    timestamps, jumbo frames, VLAN handling, multi-queue, and more
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows
  - New tests for runtime VLAN offload toggle, VLAN strip with
    infinite_rx mode, and timestamp generation in infinite_rx mode

v17:
  - Fix windows build
  - Fix feedback from AI review
  - Cleanup tests

Stephen Hemminger (23):
  maintainers: update for pcap driver
  net/pcap: fix build on Windows
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: advertise Tx multi segment
  net/pcap: replace stack bounce buffer
  net/pcap: fix error accounting and backpressure on transmit
  net/pcap: add datapath debug logging
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN strip and insert offloads
  net/pcap: add link state and speed for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  eal/windows: add wrapper for access function
  net/pcap: add snapshot length devarg
  net/pcap: add link status change support for iface mode
  net/pcap: add EOF notification via link status change
  test: add comprehensive test suite for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3424 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    9 +
 doc/guides/nics/pcap.rst               |   41 +
 doc/guides/rel_notes/release_26_03.rst |   13 +
 drivers/net/pcap/pcap_ethdev.c         |  935 +++++--
 drivers/net/pcap/pcap_osdep.h          |   39 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   98 +-
 drivers/net/pcap/pcap_osdep_linux.c    |  124 +-
 drivers/net/pcap/pcap_osdep_windows.c  |  103 +-
 lib/eal/windows/include/rte_os_shim.h  |    1 +
 lib/eal/windows/include/unistd.h       |    7 +
 13 files changed, 4553 insertions(+), 244 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v17 01/23] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 1b2f1ed2ba..93ac176573 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v17 02/23] net/pcap: fix build on Windows

[Stephen Hemminger]

The log messages in the pcap OS dependent code for Windows
was never converted during the last release.

It looks like the osdep part of pcap was not being built.
Building requires have libpcap for Windows built which is not
part of the CI infrastructure.

Fixes: 2b843cac232e ("drivers: use per line logging in helpers")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_osdep_windows.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..0965c2f5c9 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -53,7 +53,7 @@ osdep_iface_index_get(const char *device_name)
 
 	ret = GetAdapterIndex(adapter_name, &index);
 	if (ret != NO_ERROR) {
-		PMD_LOG(ERR, "GetAdapterIndex(%S) = %lu\n", adapter_name, ret);
+		PMD_LOG(ERR, "GetAdapterIndex(%S) = %lu", adapter_name, ret);
 		return -1;
 	}
 
@@ -75,20 +75,20 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
-		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
+		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
 		return -1;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
-		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
+		PMD_LOG(ERR, "Cannot allocate adapter address info");
 		return -1;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
-		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
+		PMD_LOG(ERR, "GetAdapterAddresses() = %lu", sys_ret);
 		free(info);
 		return -1;
 	}
-- 
2.51.0

[PATCH v17 03/23] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..b0dac3cca7 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Scattered Rx         = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v17 04/23] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v17 05/23] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..fbd1021c39 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v17 06/23] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd1021c39..806451dc99 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v17 07/23] net/pcap: advertise Tx multi segment

[Stephen Hemminger]

The driver supports multi-segment transmit, but the did not set
the offload flag. Therefore applications would not know about
that capability.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 806451dc99..fedf461be4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -753,6 +753,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v17 08/23] net/pcap: replace stack bounce buffer

[Stephen Hemminger]

Replace the 64K stack-allocated bounce buffer with a per-queue
buffer allocated from hugepages via rte_malloc at queue setup.
This is necessary because the buffer may be used in a secondary
process transmit path where the primary process allocated it.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 57 +++++++++++++++++++++-------------
 1 file changed, 35 insertions(+), 22 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fedf461be4..4cf5319839 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -91,6 +91,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -385,18 +388,17 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -404,12 +406,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len, caplen;
+
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
@@ -449,9 +449,6 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
 	for (i = 0; i < nb_pkts; i++) {
 		tx_bytes += bufs[i]->pkt_len;
 		rte_pktmbuf_free(bufs[i]);
@@ -460,7 +457,7 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -470,30 +467,30 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		int ret;
+
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
+				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
+				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
@@ -966,7 +963,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -974,11 +971,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1019,6 +1031,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
-- 
2.51.0

[PATCH v17 09/23] net/pcap: fix error accounting and backpressure on transmit

[Stephen Hemminger]

The error handling when pcap_sendpacket() was incorrect.
When underlying kernel socket buffer got full the send was counted as
an error. Malformed multi-segment mbufs where pkt_len exceeds actual
data were silently accepted.

Malformed mbufs are now detected via rte_pktmbuf_read() failure
and counted as errors.

On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
The send() call only blocks when the kernel socket send buffer is full,
providing limited backpressure. Backpressure is not an error.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 77 +++++++++++++++++++++-------------
 1 file changed, 49 insertions(+), 28 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4cf5319839..1ab5b1755c 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -407,22 +407,27 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len, caplen;
+		uint32_t len, caplen;
+		const uint8_t *data;
 
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
-		num_tx++;
-		tx_bytes += caplen;
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+		if (unlikely(data == NULL)) {
+			/* This only happens if mbuf is bogus pkt_len > data_len */
+			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			dumper_q->tx_stat.err_pkts++;
+		} else {
+			pcap_dump((u_char *)dumper, &header, data);
+
+			num_tx++;
+			tx_bytes += caplen;
+		}
+
 		rte_pktmbuf_free(mbuf);
 	}
 
@@ -434,9 +439,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	pcap_dump_flush(dumper);
 	dumper_q->tx_stat.pkts += num_tx;
 	dumper_q->tx_stat.bytes += tx_bytes;
-	dumper_q->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return nb_pkts;
+	return i;
 }
 
 /*
@@ -461,7 +465,17 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 }
 
 /*
- * Callback to handle sending packets through a real NIC.
+ * Send a burst of packets to a pcap device.
+ *
+ * On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
+ * socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
+ * The send() call only blocks when the kernel socket send buffer is full,
+ * providing limited backpressure.
+ *
+ * On error, pcap_sendpacket() returns non-zero and the loop breaks,
+ * leaving remaining packets unsent.
+ *
+ * Bottom line: backpressure is not an error.
  */
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
@@ -483,34 +497,41 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len = rte_pktmbuf_pkt_len(mbuf);
-		int ret;
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		const uint8_t *data;
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
+		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		if (unlikely(data == NULL)) {
+			/* This only happens if mbuf is bogus pkt_len > data_len */
+			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			tx_queue->tx_stat.err_pkts++;
+		} else {
+			/*
+			 * No good way to separate back pressure from failure here
+			 * Assume it is EBUSY, ENOMEM, or EINTR, something that can be retried.
+			 */
+			if (pcap_sendpacket(pcap, data, len) != 0) {
+				PMD_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
+				break;
+			}
+			num_tx++;
+			tx_bytes += len;
+		}
+
 		rte_pktmbuf_free(mbuf);
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
 
 	return i;
 }
-- 
2.51.0

[PATCH v17 10/23] net/pcap: add datapath debug logging

[Stephen Hemminger]

Add datapath debug logging macros (PMD_RX_LOG, PMD_TX_LOG) gated
on RTE_ETHDEV_DEBUG_RX/TX. Use PMD_TX_LOG in transmit error paths
to aid debugging without impacting normal datapath performance.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c |  8 ++++----
 drivers/net/pcap/pcap_osdep.h  | 14 ++++++++++++++
 2 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 1ab5b1755c..5b59e9d813 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -419,7 +419,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
 		if (unlikely(data == NULL)) {
 			/* This only happens if mbuf is bogus pkt_len > data_len */
-			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			PMD_TX_LOG(ERR, "rte_pktmbuf_read failed");
 			dumper_q->tx_stat.err_pkts++;
 		} else {
 			pcap_dump((u_char *)dumper, &header, data);
@@ -501,7 +501,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		const uint8_t *data;
 
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
-			PMD_LOG(ERR,
+			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			tx_queue->tx_stat.err_pkts++;
@@ -512,7 +512,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
 		if (unlikely(data == NULL)) {
 			/* This only happens if mbuf is bogus pkt_len > data_len */
-			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			PMD_TX_LOG(ERR, "rte_pktmbuf_read failed");
 			tx_queue->tx_stat.err_pkts++;
 		} else {
 			/*
@@ -520,7 +520,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			 * Assume it is EBUSY, ENOMEM, or EINTR, something that can be retried.
 			 */
 			if (pcap_sendpacket(pcap, data, len) != 0) {
-				PMD_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
+				PMD_TX_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
 				break;
 			}
 			num_tx++;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..fe7399ff9f 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,6 +13,20 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+#ifdef RTE_ETHDEV_DEBUG_RX
+#define PMD_RX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() rx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_RX_LOG(...) do { } while (0)
+#endif
+
+#ifdef RTE_ETHDEV_DEBUG_TX
+#define PMD_TX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() tx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_TX_LOG(...) do { } while (0)
+#endif
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
-- 
2.51.0

[PATCH v17 11/23] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 5b59e9d813..a2f0bf5687 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -102,9 +103,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -114,25 +115,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -890,7 +891,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1215,29 +1216,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1513,7 +1504,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1552,9 +1543,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1704,5 +1695,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.51.0

[PATCH v17 12/23] net/pcap: support VLAN strip and insert offloads

[Stephen Hemminger]

Add VLAN tag handling to the pcap PMD, consistent with how virtio
and af_packet drivers implement it.

RX strip: when RTE_ETH_RX_OFFLOAD_VLAN_STRIP is enabled, the driver
calls rte_vlan_strip() on received packets in both normal and
infinite_rx modes. For infinite_rx, offloads are deferred to
packet delivery rather than applied during ring fill, so the
stored template packets remain unmodified.

TX insert: when RTE_MBUF_F_TX_VLAN is set on an mbuf, the driver
inserts the VLAN tag via rte_vlan_insert() before writing to pcap
or sending to the interface. Indirect or shared mbufs get a new
header mbuf to avoid modifying the original.

Runtime reconfiguration is supported through vlan_offload_set,
which propagates the strip setting to all active RX queues.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |   1 +
 doc/guides/nics/pcap.rst               |  11 +++
 doc/guides/rel_notes/release_26_03.rst |   5 ++
 drivers/net/pcap/pcap_ethdev.c         | 119 ++++++++++++++++++++++++-
 4 files changed, 132 insertions(+), 4 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index b0dac3cca7..814bc2119f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -10,6 +10,7 @@ Scattered Rx         = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index fbfe854bb1..bed5006a42 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -247,3 +247,14 @@ will be discarded by the Rx flushing operation.
    The network interface provided to the PMD should be up.
    The PMD will return an error if the interface is down,
    and the PMD itself won't change the status of the external network interface.
+
+Features and Limitations
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index b4499ec066..63f554878d 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -106,6 +106,11 @@ New Features
   Added handling of the key combination Control+L
   to clear the screen before redisplaying the prompt.
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
+
 Removed Items
 -------------
 
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index a2f0bf5687..cc026a1a44 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -76,6 +76,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -106,6 +107,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -270,7 +272,11 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		bufs[i]->data_len = pcap_buf->data_len;
 		bufs[i]->pkt_len = pcap_buf->pkt_len;
 		bufs[i]->port = pcap_q->port_id;
-		rx_bytes += pcap_buf->data_len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(bufs[i]);
+
+		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
 		rte_ring_enqueue(pcap_q->pkts, pcap_buf);
@@ -336,6 +342,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -382,6 +392,58 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+
+/*
+ * If Vlan offload flag is present, insert the vlan.
+ */
+static inline int
+eth_pcap_tx_vlan(struct pcap_tx_queue *tx_queue, struct rte_mbuf **mbuf)
+{
+	struct rte_mbuf *mb = *mbuf;
+
+	if ((mb->ol_flags & RTE_MBUF_F_TX_VLAN) == 0)
+		return 0;
+
+	if (unlikely(mb->data_len < RTE_ETHER_HDR_LEN)) {
+		PMD_TX_LOG(ERR, "mbuf missing ether header");
+		goto error;
+	}
+
+	/* If indirect or shared then need another buffer to hold VLAN header? */
+	if (!RTE_MBUF_DIRECT(mb) || rte_mbuf_refcnt_read(mb) > 1) {
+		struct rte_mbuf *mh = rte_pktmbuf_alloc(mb->pool);
+		if (unlikely(mh == NULL)) {
+			PMD_TX_LOG(ERR, "mbuf pool exhausted on transmit vlan");
+			goto error;
+		}
+
+		/* Move original ethernet header into new mbuf */
+		memcpy(rte_pktmbuf_mtod(mh, void *),
+		       rte_pktmbuf_mtod(mb, void *), RTE_ETHER_HDR_LEN);
+
+		rte_pktmbuf_adj(mb, RTE_ETHER_HDR_LEN);
+		mh->nb_segs = mb->nb_segs + 1;
+		mh->data_len = RTE_ETHER_HDR_LEN;
+		mh->pkt_len = mb->pkt_len + RTE_ETHER_HDR_LEN;
+		mh->ol_flags = mb->ol_flags;
+		mh->vlan_tci = mb->vlan_tci;
+		mh->next = mb;
+
+		*mbuf = mh;
+	}
+
+	int ret = rte_vlan_insert(mbuf);
+	if (unlikely(ret != 0)) {
+		PMD_TX_LOG(ERR, "Vlan insert failed: %s", strerror(-ret));
+		goto error;
+	}
+	return 0;
+error:
+	rte_pktmbuf_free(*mbuf);
+	tx_queue->tx_stat.err_pkts++;
+	return -1;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -407,13 +469,17 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
 		const uint8_t *data;
 
+		if (eth_pcap_tx_vlan(dumper_q, &bufs[i]) < 0)
+			continue;
+
+		struct rte_mbuf *mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -497,6 +563,9 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
+		if (eth_pcap_tx_vlan(tx_queue, &bufs[i]) < 0)
+			continue;
+
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
@@ -755,8 +824,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -772,7 +846,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -919,6 +995,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
@@ -928,6 +1005,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		uint64_t pcap_pkt_count = 0;
 		struct rte_mbuf *bufs[1];
 		pcap_t **pcap;
+		bool save_vlan_strip;
 
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
@@ -947,11 +1025,20 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		if (!pcap_q->pkts)
 			return -ENOENT;
 
+		/*
+		 * Temporarily disable offloads while filling the ring
+		 * with raw packets. VLAN strip and timestamp will be
+		 * applied later in eth_pcap_rx_infinite() on each copy.
+		 */
+		save_vlan_strip = pcap_q->vlan_strip;
+		pcap_q->vlan_strip = false;
+
 		/* Fill ring with packets from PCAP file one by one. */
 		while (eth_pcap_rx(pcap_q, bufs, 1)) {
 			/* Check for multiseg mbufs. */
 			if (bufs[0]->nb_segs != 1) {
 				infinite_rx_ring_free(pcap_q->pkts);
+				pcap_q->vlan_strip = save_vlan_strip;
 				PMD_LOG(ERR,
 					"Multiseg mbufs are not supported in infinite_rx mode.");
 				return -EINVAL;
@@ -961,6 +1048,9 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 					(void * const *)bufs, 1, NULL);
 		}
 
+		/* Restore offloads for use during packet delivery */
+		pcap_q->vlan_strip = save_vlan_strip;
+
 		if (rte_ring_count(pcap_q->pkts) < pcap_pkt_count) {
 			infinite_rx_ring_free(pcap_q->pkts);
 			PMD_LOG(ERR,
@@ -1045,6 +1135,26 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	unsigned int i;
+
+	if (mask & RTE_ETH_VLAN_STRIP_MASK) {
+		bool vlan_strip = !!(dev->data->dev_conf.rxmode.offloads &
+				     RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+
+		internals->vlan_strip = vlan_strip;
+
+		/* Update all RX queues */
+		for (i = 0; i < dev->data->nb_rx_queues; i++)
+			internals->rx_queue[i].vlan_strip = vlan_strip;
+	}
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1061,6 +1171,7 @@ static const struct eth_dev_ops ops = {
 	.link_update = eth_link_update,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.vlan_offload_set = eth_vlan_offload_set,
 };
 
 static int
-- 
2.51.0

[PATCH v17 13/23] net/pcap: add link state and speed for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent functions to query the real link state, speed,
duplex, and autonegotiation settings from the underlying interface.
The eth_link_update() callback now returns accurate information
when operating in pass-through mode.

Linux uses ETHTOOL_GLINKSETTINGS which supports all speeds up to
800 Gbps. FreeBSD uses SIOCGIFMEDIA, and Windows uses
GetAdaptersAddresses().

For pcap file mode or separate rx/tx interface configurations,
default values continue to be used since there is no single
underlying interface to query.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         |  93 ++++++++++++++++---
 drivers/net/pcap/pcap_osdep.h          |  24 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  |  86 ++++++++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 118 +++++++++++++++++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  |  95 +++++++++++++++++---
 6 files changed, 394 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 63f554878d..d98b7ccf2c 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -109,6 +109,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state and speed in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index cc026a1a44..2dfe99dddb 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -150,13 +150,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -974,11 +967,84 @@ eth_dev_close(struct rte_eth_dev *dev)
 	return 0;
 }
 
+/*
+ * Convert osdep speed (Mbps) to rte_eth_link speed constant.
+ */
+static uint32_t
+speed_mbps_to_rte(uint32_t speed_mbps)
+{
+	switch (speed_mbps) {
+	case 10:
+		return RTE_ETH_SPEED_NUM_10M;
+	case 100:
+		return RTE_ETH_SPEED_NUM_100M;
+	case 1000:
+		return RTE_ETH_SPEED_NUM_1G;
+	case 2500:
+		return RTE_ETH_SPEED_NUM_2_5G;
+	case 5000:
+		return RTE_ETH_SPEED_NUM_5G;
+	case 10000:
+		return RTE_ETH_SPEED_NUM_10G;
+	case 20000:
+		return RTE_ETH_SPEED_NUM_20G;
+	case 25000:
+		return RTE_ETH_SPEED_NUM_25G;
+	case 40000:
+		return RTE_ETH_SPEED_NUM_40G;
+	case 50000:
+		return RTE_ETH_SPEED_NUM_50G;
+	case 56000:
+		return RTE_ETH_SPEED_NUM_56G;
+	case 100000:
+		return RTE_ETH_SPEED_NUM_100G;
+	case 200000:
+		return RTE_ETH_SPEED_NUM_200G;
+	case 400000:
+		return RTE_ETH_SPEED_NUM_400G;
+	case 800000:
+		return RTE_ETH_SPEED_NUM_800G;
+	default:
+		return RTE_ETH_SPEED_NUM_UNKNOWN;
+	}
+}
+
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	const char *iface_name = internals->rx_queue[0].name;
+	struct rte_eth_link link;
+	struct osdep_iface_link osdep_link;
+
+	memset(&link, 0, sizeof(link));
+
+	/*
+	 * For pass-through mode (single_iface), query the actual interface.
+	 * Otherwise, use the default static link values.
+	 */
+	if (internals->single_iface &&
+	    osdep_iface_link_get(iface_name, &osdep_link) == 0) {
+		link.link_speed = speed_mbps_to_rte(osdep_link.link_speed);
+		link.link_status = osdep_link.link_status ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_duplex = osdep_link.link_duplex ?
+			RTE_ETH_LINK_FULL_DUPLEX : RTE_ETH_LINK_HALF_DUPLEX;
+		link.link_autoneg = osdep_link.link_autoneg ?
+			RTE_ETH_LINK_AUTONEG : RTE_ETH_LINK_FIXED;
+	} else {
+		/*
+		 * Not in pass-through mode (using pcap files or separate
+		 * interfaces for rx/tx). Or query failed. Use default values.
+		 */
+		link.link_speed = RTE_ETH_SPEED_NUM_10G;
+		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_autoneg = RTE_ETH_LINK_FIXED;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1393,7 +1459,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index fe7399ff9f..b72dd0d74c 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -10,6 +10,7 @@
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
+
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
@@ -27,7 +28,30 @@ extern int eth_pcap_logtype;
 #define PMD_TX_LOG(...) do { } while (0)
 #endif
 
+/**
+ * Link information returned by osdep_iface_link_get().
+ */
+struct osdep_iface_link {
+	uint32_t link_speed;    /**< Speed in Mbps, 0 if unknown */
+	uint8_t link_status;    /**< 1 = up, 0 = down */
+	uint8_t link_duplex;    /**< 1 = full, 0 = half */
+	uint8_t link_autoneg;   /**< 1 = autoneg enabled, 0 = fixed */
+};
+
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link state and speed for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @param link
+ *   Pointer to structure to fill with link information.
+ * @return
+ *   0 on success, -1 on failure.
+ */
+int osdep_iface_link_get(const char *name, struct osdep_iface_link *link);
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..5963b67087 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,12 +5,36 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
 
+/*
+ * Userspace implementation of ifmedia_baudrate().
+ * The kernel function is not exported to userspace, so we implement
+ * our own using the IFM_BAUDRATE_DESCRIPTIONS table from if_media.h.
+ */
+static uint64_t
+ifmedia_baudrate_user(int mword)
+{
+	static const struct ifmedia_baudrate descs[] =
+		IFM_BAUDRATE_DESCRIPTIONS;
+	const struct ifmedia_baudrate *desc;
+
+	for (desc = descs; desc->ifmb_word != 0; desc++) {
+		if (IFM_TYPE_MATCH(desc->ifmb_word, mword))
+			return desc->ifmb_baudrate;
+	}
+	return 0;
+}
+
 int
 osdep_iface_index_get(const char *name)
 {
@@ -55,3 +79,65 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifmediareq ifmr;
+	struct ifreq ifr;
+	uint64_t baudrate;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine administrative status */
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		if (ifr.ifr_flags & IFF_UP)
+			link->link_status = 1;
+	}
+
+	/* Get media status for speed, duplex, and link state */
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(if_fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* Check if link is actually active */
+		if (!(ifmr.ifm_status & IFM_ACTIVE))
+			link->link_status = 0;
+
+		/* Only parse media if we have a valid current media type */
+		if (ifmr.ifm_current != 0 && IFM_TYPE(ifmr.ifm_current) == IFM_ETHER) {
+			/* Use userspace baudrate lookup */
+			baudrate = ifmedia_baudrate_user(ifmr.ifm_current);
+			link->link_speed = baudrate / 1000000;
+
+			/* Check duplex - FDX option means full duplex */
+			if (IFM_OPTIONS(ifmr.ifm_current) & IFM_FDX)
+				link->link_duplex = 1;
+			else
+				link->link_duplex = 0;
+		} else {
+			/* Default to full duplex if we can't determine */
+			link->link_duplex = 1;
+		}
+
+		/* Check autonegotiation status */
+		link->link_autoneg = (ifmr.ifm_current & IFM_AUTO) ? 1 : 0;
+	} else {
+		/*
+		 * SIOCGIFMEDIA failed - interface may not support it.
+		 * Default to reasonable values.
+		 */
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..3b56a833a9 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,11 +4,14 @@
  * All rights reserved.
  */
 
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include <rte_string_fns.h>
 
@@ -40,3 +43,118 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+/*
+ * Get link speed, duplex, and autoneg using ETHTOOL_GLINKSETTINGS.
+ *
+ * ETHTOOL_GLINKSETTINGS was introduced in kernel 4.7 and supports
+ * speeds beyond 65535 Mbps (up to 800 Gbps and beyond).
+ * DPDK requires kernel 4.19 or later, so this interface is always available.
+ *
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+get_link_settings(int fd, struct ifreq *ifr, struct osdep_iface_link *link)
+{
+	struct ethtool_link_settings probe = { };
+	struct ethtool_link_settings *req;
+	size_t req_size;
+	int nwords;
+	int ret = -1;
+
+	/* First call with nwords = 0 to get the required size */
+	probe.cmd = ETHTOOL_GLINKSETTINGS;
+	ifr->ifr_data = (void *)&probe;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		return -1;
+
+	/* Kernel returns negative nwords on first call */
+	if (probe.link_mode_masks_nwords >= 0)
+		return -1;
+
+	nwords = -probe.link_mode_masks_nwords;
+
+	/* Bounds check */
+	if (nwords == 0 || nwords > 127)
+		return -1;
+
+	/* Second call with correct nwords - need space for 3 link mode masks */
+	req_size = sizeof(*req) + 3 * nwords * sizeof(uint32_t);
+	req = malloc(req_size);
+	if (req == NULL)
+		return -1;
+
+	memset(req, 0, req_size);
+	req->cmd = ETHTOOL_GLINKSETTINGS;
+	req->link_mode_masks_nwords = nwords;
+	ifr->ifr_data = (void *)req;
+
+	if (ioctl(fd, SIOCETHTOOL, ifr) < 0)
+		goto out;
+
+	/* Speed is in Mbps, directly usable */
+	link->link_speed = req->speed;
+
+	/* Handle special values */
+	if (link->link_speed == (uint32_t)SPEED_UNKNOWN ||
+	    link->link_speed == (uint32_t)-1)
+		link->link_speed = 0;
+
+	switch (req->duplex) {
+	case DUPLEX_FULL:
+		link->link_duplex = 1;
+		break;
+	case DUPLEX_HALF:
+		link->link_duplex = 0;
+		break;
+	default:
+		link->link_duplex = 1;  /* Default to full duplex */
+		break;
+	}
+
+	link->link_autoneg = (req->autoneg == AUTONEG_ENABLE) ? 1 : 0;
+	ret = 0;
+out:
+	free(req);
+	return ret;
+}
+
+int
+osdep_iface_link_get(const char *if_name, struct osdep_iface_link *link)
+{
+	struct ifreq ifr;
+	int if_fd;
+
+	memset(link, 0, sizeof(*link));
+
+	if_fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (if_fd == -1)
+		return -1;
+
+	/* Get interface flags to determine link status */
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(if_fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up
+		 * IFF_RUNNING means operationally up (carrier detected)
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			link->link_status = 1;
+	}
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (get_link_settings(if_fd, &ifr, link) < 0) {
+		/*
+		 * ethtool failed - interface may not support it
+		 * (e.g., virtual interfaces like veth, lo).
+		 * Use reasonable defaults.
+		 */
+		link->link_speed = 0;
+		link->link_duplex = 1;  /* Assume full duplex */
+		link->link_autoneg = 0;
+	}
+
+	close(if_fd);
+	return 0;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 0965c2f5c9..e1dc1efbac 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,56 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_get(const char *device_name, struct osdep_iface_link *link)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	memset(link, 0, sizeof(*link));
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			/* Check operational status */
+			if (cur->OperStatus == IfOperStatusUp)
+				link->link_status = 1;
+			else
+				link->link_status = 0;
+
+			/*
+			 * TransmitLinkSpeed and ReceiveLinkSpeed are in bits/sec.
+			 * Convert to Mbps. Use transmit speed as the link speed.
+			 * For asymmetric links, this is a reasonable approximation.
+			 */
+			if (cur->TransmitLinkSpeed != 0 &&
+			    cur->TransmitLinkSpeed != (ULONG64)-1) {
+				link->link_speed =
+					(uint32_t)(cur->TransmitLinkSpeed / 1000000ULL);
+			}
+
+			/*
+			 * Windows doesn't directly expose duplex/autoneg via
+			 * GetAdaptersAddresses(). Default to full duplex.
+			 * For more detailed info, WMI or OID queries would be needed.
+			 */
+			link->link_duplex = 1;  /* Assume full duplex */
+			link->link_autoneg = 0; /* Cannot determine */
+
+			ret = 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v17 14/23] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Add read_clock dev_op returning current UTC time for timestamp
  correlation.
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper.
* Enable immediate mode and improve error reporting
  in live capture setup.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |   3 +
 doc/guides/rel_notes/release_26_03.rst |   2 +
 drivers/net/pcap/pcap_ethdev.c         | 157 +++++++++++++++++++------
 3 files changed, 127 insertions(+), 35 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index bed5006a42..2709c6d017 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -258,3 +258,6 @@ Features and Limitations
 *  The PMD will transparently insert a VLAN tag to transmitted packets if
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
+
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index d98b7ccf2c..9602e0b907 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -110,6 +110,8 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state and speed in ``iface`` mode.
+  * Receive timestamp offload is only done if offload flag set.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2dfe99dddb..f0c50093f5 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -27,13 +27,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -77,6 +75,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -108,6 +107,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -269,6 +269,15 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(bufs[i]);
 
+		if (pcap_q->timestamp_offloading) {
+			struct timespec ts;
+
+			timespec_get(&ts, TIME_UTC);
+			*RTE_MBUF_DYNFIELD(bufs[i], timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(&ts);
+			bufs[i]->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
@@ -339,10 +348,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -362,14 +382,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -459,8 +484,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		uint32_t len, caplen;
 		const uint8_t *data;
@@ -470,9 +497,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 		struct rte_mbuf *mbuf = bufs[i];
 		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -603,22 +627,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
+	}
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
+	}
+
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -665,7 +729,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -824,6 +889,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -841,7 +907,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -1063,6 +1130,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1201,6 +1269,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static int
 eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
 {
@@ -1227,6 +1306,7 @@ static const struct eth_dev_ops ops = {
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1642,15 +1722,22 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		hz = rte_get_timer_hz();
+		if (hz == 0) {
+			PMD_LOG(ERR, "Reported hz is zero!");
+			return -1;
+		}
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							 &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v17 15/23] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f0c50093f5..6fb21c96bb 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -671,6 +671,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.51.0

[PATCH v17 16/23] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 6fb21c96bb..508163c4c4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -46,11 +46,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -629,6 +627,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -740,6 +739,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1543,6 +1544,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v17 17/23] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 508163c4c4..74812c6842 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -54,10 +54,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -930,11 +930,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v17 18/23] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 74812c6842..27373ec8e8 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -913,10 +913,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v17 19/23] eal/windows: add wrapper for access function

[Stephen Hemminger]

Like other Posix functions in unistd.h add wrapper
using the Windows equivalent.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 lib/eal/windows/include/rte_os_shim.h | 1 +
 lib/eal/windows/include/unistd.h      | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/lib/eal/windows/include/rte_os_shim.h b/lib/eal/windows/include/rte_os_shim.h
index f16b2230c8..44664a5062 100644
--- a/lib/eal/windows/include/rte_os_shim.h
+++ b/lib/eal/windows/include/rte_os_shim.h
@@ -33,6 +33,7 @@
 #define unlink(path) _unlink(path)
 #define fileno(f) _fileno(f)
 #define isatty(fd) _isatty(fd)
+#define access(path, mode) _access(path, mode)
 
 #define IPVERSION	4
 
diff --git a/lib/eal/windows/include/unistd.h b/lib/eal/windows/include/unistd.h
index 78150c6480..f95888f4e1 100644
--- a/lib/eal/windows/include/unistd.h
+++ b/lib/eal/windows/include/unistd.h
@@ -23,4 +23,11 @@
 #define STDERR_FILENO _fileno(stderr)
 #endif
 
+/* Mode values for the _access() function.  */
+#ifndef F_OK
+#define	F_OK		0	/* test for existence of file */
+#define	W_OK		0x02	/* test for write permission */
+#define	R_OK		0x04	/* test for read permission */
+#endif
+
 #endif /* _UNISTD_H_ */
-- 
2.51.0

[PATCH v17 20/23] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

Example usage:
  --vdev 'net_pcap0,iface=eth0,snaplen=1518'
  --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |  15 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 237 ++++++++++++++++---------
 3 files changed, 167 insertions(+), 86 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2709c6d017..f241069ebb 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -162,6 +162,21 @@ Runtime Config Options
 
   In this case, one dummy Rx queue is created for each Tx queue argument passed.
 
+* Set the snapshot length for packet capture
+
+  The snapshot length controls the maximum number of bytes captured per packet.
+  This affects both interface capture and pcap file output.  The default value is
+  65535 bytes, which captures complete packets up to the maximum Ethernet jumbo
+  frame size.  Reducing this value can improve performance when only packet headers
+  are needed.  This can be done with the ``snaplen`` devarg, for example::
+
+     --vdev 'net_pcap0,iface=eth0,snaplen=1518'
+     --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000'
+
+  The snapshot length also determines the reported ``max_rx_pktlen``
+  and ``max_mtu`` in device info.
+
+
 Examples of Usage
 ~~~~~~~~~~~~~~~~~
 
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 9602e0b907..526e157dd4 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -112,6 +112,7 @@ New Features
   * Added support for reporting link state and speed in ``iface`` mode.
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 27373ec8e8..1ddd0c36d1 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -13,6 +13,8 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <unistd.h>
+
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -31,8 +33,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -41,6 +41,12 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
+
+/* This is defined in libpcap but not exposed in headers */
+#define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -101,6 +107,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -128,6 +135,7 @@ struct pmd_devargs {
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -145,11 +153,16 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declaration */
+static inline int set_iface_direction(const char *iface, pcap_t *pcap,
+				      pcap_direction_t direction);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -466,20 +479,19 @@ eth_pcap_tx_vlan(struct pcap_tx_queue *tx_queue, struct rte_mbuf **mbuf)
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -487,14 +499,15 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		uint32_t len, caplen;
 		const uint8_t *data;
 
 		if (eth_pcap_tx_vlan(dumper_q, &bufs[i]) < 0)
 			continue;
 
 		struct rte_mbuf *mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t caplen = RTE_MIN(len, snaplen);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -562,19 +575,18 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
@@ -585,10 +597,10 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > snaplen)) {
 			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
-				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+				len, snaplen);
 			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
@@ -625,7 +637,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -642,6 +654,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
 			iface, pcap_statustostr(status));
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	status = pcap_set_immediate_mode(pc, 1);
@@ -654,7 +669,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -668,6 +683,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -696,9 +714,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -707,7 +725,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -717,7 +736,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -726,9 +745,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -778,15 +797,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
 		rx = &internals->rx_queue[0];
 
-		if (!pp->tx_pcap[0] &&
-			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+		if (!pp->tx_pcap[0] && strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -798,14 +817,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -820,9 +836,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -913,11 +934,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1230,7 +1251,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1360,6 +1381,12 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *rx = extra_args;
 	pcap_t *pcap = NULL;
 
+	if (access(pcap_filename, R_OK) != 0) {
+		PMD_LOG(ERR, "Cannot read pcap file '%s': %s",
+			pcap_filename, strerror(errno));
+		return -1;
+	}
+
 	if (open_single_rx_pcap(pcap_filename, &pcap) < 0)
 		return -1;
 
@@ -1372,41 +1399,52 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 }
 
 /*
- * Opens a pcap file for writing and stores a reference to it
- * for use it later on.
+ * Store TX pcap file configuration.
+ * The actual pcap dumper is opened in eth_dev_start().
  */
 static int
 open_tx_pcap(const char *key, const char *value, void *extra_args)
 {
 	const char *pcap_filename = value;
 	struct pmd_devargs *dumpers = extra_args;
-	pcap_dumper_t *dumper;
+	FILE *f;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	/* Validate that pcap_filename can be created. */
+	if (strcmp(pcap_filename, "-") == 0) {
+		/* This isn't going to work very well in DPDK - so reject it */
+		PMD_LOG(ERR, "Sending pcap binary data to stdout is not supported");
 		return -1;
+	}
 
-	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
-		pcap_dump_close(dumper);
+	f = fopen(pcap_filename, "wb");
+	if (f == NULL) {
+		PMD_LOG(ERR, "Cannot open '%s' for writing: %s", pcap_filename, strerror(errno));
 		return -1;
 	}
+	fclose(f);
+
+	if (add_queue(dumpers, pcap_filename, key, NULL, NULL) < 0)
+		return -1;
 
 	return 0;
 }
 
 /*
- * Opens an interface for reading and writing
+ * Store interface configuration for reading and writing.
+ * The actual pcap handle is opened in eth_dev_start().
  */
 static inline int
 open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *tx = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (osdep_iface_index_get(iface) == 0) {
+		PMD_LOG(ERR, "Interface '%s' not found", iface);
 		return -1;
+	}
 
-	tx->queue[0].pcap = pcap;
+	tx->queue[0].pcap = NULL;
 	tx->queue[0].name = iface;
 	tx->queue[0].type = key;
 
@@ -1428,50 +1466,37 @@ set_iface_direction(const char *iface, pcap_t *pcap,
 	return 0;
 }
 
+/*
+ * Store interface configuration.
+ * The actual pcap handle is opened in eth_dev_start().
+ */
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
 	struct pmd_devargs *pmd = extra_args;
-	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
-		return -1;
-	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
-		pcap_close(pcap);
+	if (osdep_iface_index_get(iface) == 0) {
+		PMD_LOG(ERR, "Interface '%s' not found", iface);
 		return -1;
 	}
 
+	if (add_queue(pmd, iface, key, NULL, NULL) < 0)
+		return -1;
+
 	return 0;
 }
 
 /*
- * Opens a NIC for reading packets from it
+ * Store RX interface configuration.
+ * The actual pcap handle is opened and direction set in eth_dev_start().
  */
-static inline int
-open_rx_iface(const char *key, const char *value, void *extra_args)
-{
-	int ret = open_iface(key, value, extra_args);
-	if (ret < 0)
-		return ret;
-	if (strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
-		struct pmd_devargs *pmd = extra_args;
-		unsigned int qid = pmd->num_of_queue - 1;
-
-		set_iface_direction(pmd->queue[qid].name,
-				pmd->queue[qid].pcap,
-				PCAP_D_IN);
-	}
-
-	return 0;
-}
-
 static inline int
 rx_iface_args_process(const char *key, const char *value, void *extra_args)
 {
 	if (strcmp(key, ETH_PCAP_RX_IFACE_ARG) == 0 ||
-			strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
-		return open_rx_iface(key, value, extra_args);
+	    strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+		return open_iface(key, value, extra_args);
 
 	return 0;
 }
@@ -1503,6 +1528,31 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN ||
+	    val > ETH_PCAP_MAXIMUM_SNAPLEN) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1667,6 +1717,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1727,6 +1779,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1774,7 +1827,18 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	}
 
 	/*
-	 * If iface argument is passed we open the NICs and use them for
+	 * Process optional snapshot length argument.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+	/*
+	 * If iface argument is passed we check that NIC can be used
 	 * reading / writing
 	 */
 	if (rte_kvargs_count(kvlist, ETH_PCAP_IFACE_ARG) == 1) {
@@ -1979,4 +2043,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v17 21/23] net/pcap: add link status change support for iface mode

[Stephen Hemminger]

Add LSC interrupt support for pass-through (iface=) mode so
applications can receive link state change notifications via
the standard ethdev callback mechanism.

Uses alarm-based polling to periodically check the underlying
interface state via osdep_iface_link_get(). The LSC flag is
advertised only for iface mode devices, and polling is gated
on the application enabling intr_conf.lsc in port configuration.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 45 +++++++++++++++++++++++++-
 3 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 814bc2119f..084fefbbbb 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -5,6 +5,7 @@
 ;
 [Features]
 Link status          = Y
+Link status event    = Y
 Queue start/stop     = Y
 Scattered Rx         = Y
 Timestamp offload    = Y
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 526e157dd4..39ce14ffe7 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -113,6 +113,7 @@ New Features
   * Receive timestamp offload is only done if offload flag set.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added support for Link State interrupt in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 1ddd0c36d1..00659764dc 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -17,6 +17,7 @@
 
 #include <pcap.h>
 
+#include <rte_alarm.h>
 #include <rte_cycles.h>
 #include <rte_ring.h>
 #include <rte_ethdev.h>
@@ -48,6 +49,8 @@
 /* This is defined in libpcap but not exposed in headers */
 #define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
+#define ETH_PCAP_LSC_POLL_INTERVAL_US (1000 * 1000) /* 1 second */
+
 #define ETH_PCAP_ARG_MAXLEN	64
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
@@ -113,6 +116,7 @@ struct pmd_internals {
 	bool infinite_rx;
 	bool vlan_strip;
 	bool timestamp_offloading;
+	bool lsc_active;
 };
 
 struct pmd_process_private {
@@ -159,9 +163,10 @@ static const char *valid_arguments[] = {
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
-/* Forward declaration */
+/* Forward declarations */
 static inline int set_iface_direction(const char *iface, pcap_t *pcap,
 				      pcap_direction_t direction);
+static int eth_link_update(struct rte_eth_dev *dev, int wait_to_complete);
 
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
@@ -789,6 +794,28 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+/*
+ * Periodic alarm to poll link state.
+ * Enabled when link state interrupt is enabled in single_iface mode.
+ */
+static void
+eth_pcap_lsc_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link old_link, new_link;
+
+	rte_eth_linkstatus_get(dev, &old_link);
+	eth_link_update(dev, 0);
+	rte_eth_linkstatus_get(dev, &new_link);
+
+	if (old_link.link_status != new_link.link_status)
+		rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+
+	if (internals->lsc_active)
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US, eth_pcap_lsc_alarm, dev);
+}
+
 static int
 eth_dev_start(struct rte_eth_dev *dev)
 {
@@ -856,6 +883,13 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
+	/* Start LSC polling for iface mode if application requested it */
+	if (internals->single_iface && dev->data->dev_conf.intr_conf.lsc) {
+		internals->lsc_active = true;
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US,
+				  eth_pcap_lsc_alarm, dev);
+	}
+
 	return 0;
 }
 
@@ -873,6 +907,12 @@ eth_dev_stop(struct rte_eth_dev *dev)
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
+		/* Cancel LSC polling before closing pcap handles */
+		if (internals->lsc_active) {
+			internals->lsc_active = false;
+			rte_eal_alarm_cancel(eth_pcap_lsc_alarm, dev);
+		}
+
 		queue_missed_stat_on_stop_update(dev, 0);
 		if (pp->tx_pcap[0] != NULL) {
 			pcap_close(pp->tx_pcap[0]);
@@ -1708,6 +1748,9 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		internals->if_index =
 			osdep_iface_index_get(rx_queues->queue[0].name);
 
+		/* Enable LSC interrupt support for iface mode */
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 		/* phy_mac arg is applied only if "iface" devarg is provided */
 		if (rx_queues->phy_mac) {
 			if (eth_pcap_update_mac(rx_queues->queue[0].name,
-- 
2.51.0

[PATCH v17 22/23] net/pcap: add EOF notification via link status change

[Stephen Hemminger]

Add an "eof" devarg for rx_pcap mode that signals end-of-file by
setting link down and generating an LSC event. This allows
applications to detect when a pcap file has been fully consumed
using the standard ethdev callback mechanism.

The eof and infinite_rx options are mutually exclusive. On device
restart, the EOF state is reset so the file can be replayed.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               | 12 ++++
 doc/guides/rel_notes/release_26_03.rst |  2 +
 drivers/net/pcap/pcap_ethdev.c         | 83 +++++++++++++++++++++++++-
 3 files changed, 94 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index f241069ebb..6f3a4fc887 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -144,6 +144,18 @@ Runtime Config Options
   so all queues on a device will either have this enabled or disabled.
   This option should only be provided once per device.
 
+* Signal end-of-file via link status change
+
+  In case ``rx_pcap=`` configuration is set, the user may want to be notified when
+  all packets in the pcap file have been read.  This can be done with the ``eof``
+  devarg, for example::
+
+     --vdev 'net_pcap0,rx_pcap=file_rx.pcap,eof=1'
+
+  When enabled, the driver sets link down and generates an LSC event at end of file.
+  If the device is stopped and restarted, the EOF state is reset.
+  This option cannot be combined with ``infinite_rx``.
+
 * Drop all packets on transmit
 
   To drop all packets on transmit for a device,
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 39ce14ffe7..d8a8f2dfa5 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -114,6 +114,8 @@ New Features
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
   * Added support for Link State interrupt in ``iface`` mode.
+  * Added ``eof`` devarg to use link state to signal end of receive
+    file input.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 00659764dc..4fc617c7fc 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -42,6 +42,7 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_EOF_ARG          "eof"
 #define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
 
 #define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
@@ -114,6 +115,8 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool eof;
+	RTE_ATOMIC(bool) eof_signaled;
 	bool vlan_strip;
 	bool timestamp_offloading;
 	bool lsc_active;
@@ -146,6 +149,7 @@ struct pmd_devargs_all {
 	bool is_rx_pcap;
 	bool is_rx_iface;
 	bool infinite_rx;
+	bool eof;
 };
 
 static const char *valid_arguments[] = {
@@ -157,6 +161,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_EOF_ARG,
 	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
@@ -306,15 +311,33 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	return i;
 }
 
+/*
+ * Deferred EOF alarm callback.
+ *
+ * Scheduled from the RX burst path when end-of-file is reached,
+ * so that rte_eth_dev_callback_process() runs outside the datapath.
+ * This avoids holding any locks that the application callback
+ * might also need, preventing potential deadlocks.
+ */
+static void
+eth_pcap_eof_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+
+	rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+}
+
 static uint16_t
 eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
+	struct pcap_rx_queue *pcap_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[pcap_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
 	unsigned int i;
 	struct pcap_pkthdr *header;
 	struct pmd_process_private *pp;
 	const u_char *packet;
 	struct rte_mbuf *mbuf;
-	struct pcap_rx_queue *pcap_q = queue;
 	uint16_t num_rx = 0;
 	uint32_t rx_bytes = 0;
 	pcap_t *pcap;
@@ -335,6 +358,23 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			if (ret == PCAP_ERROR)
 				pcap_q->rx_stat.err_pkts++;
 
+			/*
+			 * EOF: if eof mode is enabled, set link down and
+			 * defer notification via alarm to avoid calling
+			 * rte_eth_dev_callback_process() from the datapath.
+			 */
+			else if (ret == PCAP_ERROR_BREAK) {
+				bool expected = false;
+
+				if (internals->eof &&
+				    rte_atomic_compare_exchange_strong_explicit(
+					    &internals->eof_signaled, &expected, true,
+					    rte_memory_order_relaxed, rte_memory_order_relaxed)) {
+					eth_link_update(dev, 0);
+					rte_eal_alarm_set(1, eth_pcap_eof_alarm, dev);
+				}
+			}
+
 			break;
 		}
 
@@ -881,6 +921,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++)
 		dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
 
+	rte_atomic_store_explicit(&internals->eof_signaled, false, rte_memory_order_relaxed);
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
 	/* Start LSC polling for iface mode if application requested it */
@@ -904,6 +945,7 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	unsigned int i;
 	struct pmd_internals *internals = dev->data->dev_private;
 	struct pmd_process_private *pp = dev->process_private;
+	bool expected;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
@@ -943,6 +985,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	}
 
 status_down:
+	/* Cancel any pending EOF alarm */
+	expected = true;
+	if (rte_atomic_compare_exchange_strong_explicit(
+		    &internals->eof_signaled, &expected, false,
+		    rte_memory_order_relaxed, rte_memory_order_relaxed))
+		rte_eal_alarm_cancel(eth_pcap_eof_alarm, dev);
+
 	for (i = 0; i < dev->data->nb_rx_queues; i++)
 		dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
 
@@ -1180,9 +1229,13 @@ eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 		 */
 		link.link_speed = RTE_ETH_SPEED_NUM_10G;
 		link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
-		link.link_status = dev->data->dev_started ?
-			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 		link.link_autoneg = RTE_ETH_LINK_FIXED;
+
+		if (rte_atomic_load_explicit(&internals->eof_signaled, rte_memory_order_relaxed))
+			link.link_status = RTE_ETH_LINK_DOWN;
+		else
+			link.link_status = dev->data->dev_started ?
+				RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 	}
 
 	return rte_eth_linkstatus_set(dev, &link);
@@ -1760,8 +1813,13 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->eof = devargs_all->eof;
 	internals->snapshot_len = devargs_all->snapshot_len;
 
+	/* Enable LSC for eof mode (already set above for single_iface) */
+	if (internals->eof)
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1948,6 +2006,24 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 					"for %s", name);
 		}
 
+		/*
+		 * Check whether to signal EOF via link status change.
+		 */
+		if (rte_kvargs_count(kvlist, ETH_PCAP_EOF_ARG) == 1) {
+			ret = rte_kvargs_process(kvlist, ETH_PCAP_EOF_ARG,
+						 &process_bool_flag,
+						 &devargs_all.eof);
+			if (ret < 0)
+				goto free_kvlist;
+		}
+
+		if (devargs_all.infinite_rx && devargs_all.eof) {
+			PMD_LOG(ERR, "Cannot use both infinite_rx and eof for %s",
+				name);
+			ret = -EINVAL;
+			goto free_kvlist;
+		}
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
 				&open_rx_pcap, &pcaps);
 	} else if (devargs_all.is_rx_iface) {
@@ -2087,4 +2163,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_EOF_ARG "=<0|1> "
 	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v17 23/23] test: add comprehensive test suite for pcap PMD

[Stephen Hemminger]

Add unit tests for the pcap PMD covering file and interface modes.

Tests include:
  - basic TX to file and RX from file
  - varied packet sizes and jumbo frames
  - infinite RX mode
  - TX drop mode
  - statistics
  - interface (iface=) pass-through mode
  - link status reporting for file and iface modes
  - link status change (LSC) with interface toggle
  - EOF notification via LSC
  - RX timestamps and timestamp with infinite RX
  - multiple TX/RX queues
  - VLAN strip, insert, and runtime offload configuration
  - snapshot length (snaplen) and truncation

Cross-platform helpers handle temp file creation, interface
discovery, and VLAN packet generation.

The LSC link toggle test requires a pre-created dummy interface
(Linux: dummy0, FreeBSD: disc0) and is skipped if unavailable.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3424 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 3427 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index 4fd8670e05..253d43d60f 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..0b4546ecae
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,3424 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define F_OK 0
+#define usleep(us) Sleep((us) / 1000 ? (us) / 1000 : 1)
+#else
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths shared between tests */
+static char tx_pcap_path[PATH_MAX];	/* test_tx_to_file -> test_rx_from_file */
+static char vlan_rx_pcap_path[PATH_MAX]; /* test_vlan_strip_rx -> test_vlan_no_strip_rx */
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port with custom config
+ */
+static int
+setup_pcap_port_conf(uint16_t port, const struct rte_eth_conf *conf)
+{
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port (default: timestamp offload)
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+	int ret;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char varied_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+	remove_temp_file(varied_pcap_path);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char infinite_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+	int ret;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+	remove_temp_file(infinite_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+	int ret;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+	remove_temp_file(rx_pcap_path);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+	int ret;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path), "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char jumbo_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path), "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+	remove_temp_file(jumbo_pcap_path);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	int ret;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+	remove_temp_file(rx_pcap_path);
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+static int
+test_lsc_iface(void)
+{
+	printf("  Link toggle test not supported on Windows, skipping\n");
+	return TEST_SKIPPED;
+}
+#else
+/*
+ * Test: Link Status Change (LSC) interrupt support
+ *
+ * Verifies that:
+ * 1. LSC capability is NOT advertised for file mode
+ * 2. LSC capability IS advertised for iface mode
+ * 3. LSC callback fires when the underlying interface goes down/up
+ *
+ * Requires a toggleable Ethernet interface created before running:
+ *   Linux:   ip link add dummy0 type dummy && ip link set dummy0 up
+ *   FreeBSD: ifconfig disc0 create && ifconfig disc0 up
+ *
+ * Skipped if no suitable interface is found or on Windows.
+ */
+
+/* Callback counter for LSC test */
+static volatile int lsc_callback_count;
+
+static int
+test_lsc_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	lsc_callback_count++;
+	return 0;
+}
+
+/*
+ * Helper: Set interface link up or down via ioctl.
+ * Returns 0 on success, -errno on failure.
+ */
+static int
+set_iface_up_down(const char *ifname, int up)
+{
+	struct ifreq ifr;
+	int fd, ret;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd < 0)
+		return -errno;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	ret = ioctl(fd, SIOCGIFFLAGS, &ifr);
+	if (ret < 0) {
+		ret = -errno;
+		close(fd);
+		return ret;
+	}
+
+	if (up)
+		ifr.ifr_flags |= IFF_UP;
+	else
+		ifr.ifr_flags &= ~IFF_UP;
+
+	ret = ioctl(fd, SIOCSIFFLAGS, &ifr);
+	if (ret < 0)
+		ret = -errno;
+	else
+		ret = 0;
+
+	close(fd);
+	return ret;
+}
+
+/*
+ * Helper: Find a toggleable test interface for LSC testing.
+ *
+ * Looks for well-known interfaces that are safe to bring up/down:
+ *   Linux:   dummy0 (ip link add dummy0 type dummy)
+ *   FreeBSD: disc0 (ifconfig disc0 create)
+ *
+ * Returns interface name or NULL if none found.
+ */
+static const char *
+find_lsc_test_iface(void)
+{
+	static const char *candidates[] = { "dummy0", "disc0" };
+	unsigned int i;
+
+	for (i = 0; i < RTE_DIM(candidates); i++) {
+		if (iface_is_ethernet(candidates[i]))
+			return candidates[i];
+	}
+	return NULL;
+}
+
+static int
+test_lsc_iface(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	int ret;
+
+	printf("Testing Link Status Change (LSC) support\n");
+
+	/*
+	 * Test 1: Verify LSC is NOT advertised for file mode
+	 */
+	printf("  Testing file mode does not advertise LSC\n");
+	{
+		char lsc_pcap_path[PATH_MAX];
+		uint16_t file_port_id;
+
+		TEST_ASSERT(create_temp_path(lsc_pcap_path, sizeof(lsc_pcap_path),
+					     "pcap_lsc") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(lsc_pcap_path, 1) == 0,
+			    "Failed to create test pcap");
+
+		ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", lsc_pcap_path);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		TEST_ASSERT(create_pcap_vdev("net_pcap_lsc_file", devargs,
+					     &file_port_id) == 0,
+			    "Failed to create file vdev");
+
+		ret = rte_eth_dev_info_get(file_port_id, &dev_info);
+		TEST_ASSERT(ret == 0, "Failed to get dev info");
+
+		TEST_ASSERT((*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC) == 0,
+			    "File mode should NOT advertise LSC capability");
+
+		rte_vdev_uninit("net_pcap_lsc_file");
+		remove_temp_file(lsc_pcap_path);
+		printf("  File mode LSC check PASSED\n");
+	}
+
+	struct rte_eth_link link;
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	uint16_t port_id;
+
+	/*
+	 * Test 2: Use a toggleable interface to test link change events.
+	 * Skip if not present.
+	 */
+	const char *lsc_iface = find_lsc_test_iface();
+	if (lsc_iface == NULL) {
+		printf("  No toggleable interface found, skipping link change test\n");
+		printf("  Linux:   ip link add dummy0 type dummy && ip link set dummy0 up\n");
+		printf("  FreeBSD: ifconfig disc0 create && ifconfig disc0 up\n");
+		return TEST_SUCCESS;
+	}
+
+	printf("  Testing iface mode LSC with: %s\n", lsc_iface);
+
+	/* Ensure interface is up before we start */
+	ret = set_iface_up_down(lsc_iface, 1);
+	if (ret != 0) {
+		printf("  Cannot set %s up (%s), skipping\n",
+		       lsc_iface, strerror(-ret));
+		return TEST_SUCCESS;
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", lsc_iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_lsc", devargs);
+	if (ret < 0) {
+		printf("  Cannot create iface vdev for %s, skipping\n", lsc_iface);
+		return TEST_SUCCESS;
+	}
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_lsc", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "Iface mode should advertise LSC capability");
+	printf("    LSC capability advertised: yes\n");
+
+	/* Register LSC callback */
+	lsc_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_lsc_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link status");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+	printf("    Link after start: UP\n");
+
+	/* Bring interface down - should trigger LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 0);
+	TEST_ASSERT(ret == 0, "Failed to set %s down: %s",
+		    lsc_iface, strerror(-ret));
+
+	/* Wait for at least one poll cycle (1 second interval) */
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after down");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after interface down");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired, count=%d",
+		    lsc_callback_count);
+	printf("    Interface down: link DOWN, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Bring it back up - should trigger another LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 1);
+	TEST_ASSERT(ret == 0, "Failed to set %s up: %s",
+		    lsc_iface, strerror(-ret));
+
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after up");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after interface up");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired on link restore, count=%d",
+		    lsc_callback_count);
+	printf("    Interface up: link UP, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Cleanup */
+	rte_eth_dev_stop(port_id);
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_lsc_callback, NULL);
+	rte_vdev_uninit("net_pcap_lsc");
+
+	printf("LSC test PASSED\n");
+	return TEST_SUCCESS;
+}
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Test: EOF notification via link status change
+ *
+ * Verifies that:
+ * 1. The eof devarg causes link down + LSC event at end of pcap file
+ * 2. link_get reports DOWN after EOF
+ * 3. Stop/start resets the EOF state and replays the file
+ * 4. The eof and infinite_rx options are mutually exclusive
+ */
+
+static volatile int eof_callback_count;
+
+static int
+test_eof_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	eof_callback_count++;
+	return 0;
+}
+
+static int
+test_eof_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	struct rte_eth_link link;
+	char eof_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx;
+	int ret;
+
+	printf("Testing EOF notification via link status change\n");
+
+	/* Create pcap file with known number of packets */
+	TEST_ASSERT(create_temp_path(eof_pcap_path, sizeof(eof_pcap_path),
+				     "pcap_eof") == 0,
+		    "Failed to create temp file path");
+	TEST_ASSERT(create_test_pcap(eof_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/*
+	 * Test 1: EOF triggers link down and LSC callback
+	 */
+	printf("  Testing EOF triggers link down and LSC event\n");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,eof=1",
+		       eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create eof vdev: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_eof", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	struct rte_eth_dev_info dev_info;
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "EOF mode should advertise LSC capability");
+
+	/* Register LSC callback */
+	eof_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_eof_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Drain all packets from the pcap file */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			/* Got all packets and rx returned 0 — EOF hit */
+			break;
+		}
+	}
+
+	printf("    Received %u packets (expected %d)\n", total_rx, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Should receive exactly %d packets", NUM_PACKETS);
+
+	/* Verify link went down */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after EOF");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after EOF");
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	/* Verify callback fired exactly once */
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "LSC callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    EOF signaled: link DOWN, callback fired\n");
+
+	/*
+	 * Test 2: Stop/start resets EOF and replays the file
+	 */
+	printf("  Testing restart replays pcap file\n");
+
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	eof_callback_count = 0;
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to restart port");
+
+	/* Verify link is up again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after restart");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after restart");
+
+	/* Read packets again */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			break;
+		}
+	}
+
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Restart: should receive %d packets, got %u",
+			  NUM_PACKETS, total_rx);
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "Restart: callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    Restart replay: %u packets, EOF signaled again\n", total_rx);
+
+	/* Cleanup */
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_eof_callback, NULL);
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_eof");
+
+	/*
+	 * Test 3: eof + infinite_rx is rejected
+	 */
+	printf("  Testing eof + infinite_rx mutual exclusion\n");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,eof=1,infinite_rx=1", eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof_bad", devargs);
+	TEST_ASSERT(ret != 0, "eof + infinite_rx should be rejected");
+	printf("    Mutual exclusion check PASSED\n");
+
+	remove_temp_file(eof_pcap_path);
+
+	printf("EOF test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char timestamp_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64
+			       " actual=%"PRIu64"\n", i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+	remove_temp_file(timestamp_pcap_path);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		remove_temp_file(multi_tx_pcap_paths[q]);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char multi_rx_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0,
+		    "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	remove_temp_file(multi_rx_pcap_path);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		       rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char vlan_tx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Transmit packets - driver should insert VLAN tags */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	remove_temp_file(vlan_tx_pcap_path);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Runtime VLAN offload configuration via rte_eth_dev_set_vlan_offload
+ *
+ * This test verifies that VLAN strip can be enabled/disabled at runtime
+ * using the standard ethdev API rather than only at configure time.
+ * Uses infinite_rx mode so the same packets can be read in each phase.
+ */
+static int
+test_vlan_offload_set(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char vlan_set_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf = { 0 };
+	unsigned int i;
+	uint16_t nb_rx;
+	int ret, current_offload;
+	size_t tagged_len, untagged_len;
+
+	printf("Testing runtime VLAN offload configuration\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_set_pcap_path, sizeof(vlan_set_pcap_path),
+				     "pcap_vlan_set") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_set_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	/* Use infinite_rx so packets are always available */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", vlan_set_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_set", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+
+	/* Configure WITHOUT VLAN strip initially and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port");
+
+	/* Expected lengths */
+	tagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		     sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+	untagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN strip is initially disabled */
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled initially");
+
+	/*
+	 * Phase 1: VLAN strip disabled - packets should have tags
+	 */
+	printf("  Phase 1: VLAN strip disabled\n");
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 1");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 1 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact\n", nb_rx);
+
+	/*
+	 * Phase 2: Enable VLAN strip at runtime - packets should be stripped
+	 */
+	printf("  Phase 2: Enabling VLAN strip via rte_eth_dev_set_vlan_offload\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, RTE_ETH_VLAN_STRIP_OFFLOAD);
+	TEST_ASSERT(ret == 0, "Failed to enable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD,
+		    "VLAN strip should be enabled after set_vlan_offload");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 2");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), untagged_len,
+				  "Phase 2 packet %u: expected untagged length %zu, got %u",
+				  i, untagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Phase 2 packet %u: VLAN_STRIPPED flag not set", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags stripped\n", nb_rx);
+
+	/*
+	 * Phase 3: Disable VLAN strip - packets should have tags again
+	 */
+	printf("  Phase 3: Disabling VLAN strip\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to disable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled after clearing");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 3");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 3 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact again\n", nb_rx);
+
+	cleanup_pcap_vdev("net_pcap_vlan_set", port_id);
+	remove_temp_file(vlan_set_pcap_path);
+
+	printf("Runtime VLAN offload PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip in infinite RX mode
+ *
+ * This test verifies that VLAN strip offload works correctly when combined
+ * with infinite_rx mode, which uses a different RX path (eth_pcap_rx_infinite).
+ */
+static int
+test_vlan_strip_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	char vlan_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int stripped_count = 0;
+	int iter, attempts, ret;
+	size_t expected_len;
+
+	printf("Testing VLAN strip with infinite RX mode\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_inf_pcap_path, sizeof(vlan_inf_pcap_path),
+				     "pcap_vlan_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_inf_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets for infinite RX\n", NUM_PACKETS);
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", vlan_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_vlan_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_vlan_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with VLAN strip enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Expected length after VLAN strip */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Read packets - need more than file contains to verify infinite looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				/* Verify VLAN was stripped */
+				if (verify_no_vlan_tag(mbufs[i]) == 0 &&
+				    rte_pktmbuf_pkt_len(mbufs[i]) == expected_len &&
+				    (mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED))
+					stripped_count++;
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_vlan_inf");
+	remove_temp_file(vlan_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(stripped_count, total_rx,
+			  "VLAN strip failed: only %u/%u packets stripped correctly",
+			  stripped_count, total_rx);
+
+	printf("VLAN strip infinite RX PASSED: %u packets stripped (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Timestamps in infinite RX mode
+ *
+ * This test verifies that timestamp offload works correctly when combined
+ * with infinite_rx mode. Since infinite_rx generates packets on-the-fly,
+ * timestamps should reflect the current time rather than pcap file timestamps.
+ */
+static int
+test_timestamp_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	char ts_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int ts_count = 0;
+	int iter, attempts, ret;
+	rte_mbuf_timestamp_t first_ts = 0;
+	rte_mbuf_timestamp_t last_ts = 0;
+
+	printf("Testing timestamps with infinite RX mode\n");
+
+	/* Initialize timestamp dynamic field access */
+	if (timestamp_dynfield_offset < 0) {
+		ret = timestamp_init();
+		if (ret != 0) {
+			printf("Timestamp dynfield not available, skipping\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	/* Create simple pcap file */
+	TEST_ASSERT(create_temp_path(ts_inf_pcap_path, sizeof(ts_inf_pcap_path),
+				     "pcap_ts_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_test_pcap(ts_inf_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", ts_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_ts_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_ts_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with timestamp offload enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with timestamps");
+
+	/* Read packets */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				if (mbuf_has_timestamp(mbufs[i])) {
+					rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+
+					if (ts_count == 0)
+						first_ts = ts;
+					last_ts = ts;
+					ts_count++;
+				}
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_ts_inf");
+	remove_temp_file(ts_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(ts_count, total_rx,
+			  "Timestamp missing: only %u/%u packets have timestamps",
+			  ts_count, total_rx);
+
+	/* Timestamps should be monotonically increasing (current time) */
+	TEST_ASSERT(last_ts >= first_ts,
+		    "Timestamps not monotonic: first=%" PRIu64 " last=%" PRIu64,
+		    first_ts, last_ts);
+
+	printf("Timestamp infinite RX PASSED: %u packets with valid timestamps\n", total_rx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	/* Cleanup shared temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_lsc_iface),
+		TEST_CASE(test_eof_rx),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_vlan_offload_set),
+		TEST_CASE(test_vlan_strip_infinite_rx),
+		TEST_CASE(test_timestamp_infinite_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index d8a8f2dfa5..e4817467d7 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -116,6 +116,7 @@ New Features
   * Added support for Link State interrupt in ``iface`` mode.
   * Added ``eof`` devarg to use link state to signal end of receive
     file input.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

Re: [PATCH v13 08/16] net/pcap: support VLAN insert and strip

[David Marchand]

On Tue, 10 Feb 2026 at 01:03, Stephen Hemminger
<stephen@networkplumber.org> wrote:
>
> Driver can easily insert VLAN tag strip and insertion similar
> to how it is handled in virtio and af_packet.
>
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>

[snip]

> @@ -383,6 +393,56 @@ calculate_timestamp(struct timeval *ts) {
>         }
>  }
>
> +

Unneeded empty line.

> +/*
> + * If Vlan offload flag is present, insert the vlan.
> + * Returns the mbuf to send, or NULL on error.
> + */
> +static inline int
> +eth_pcap_tx_vlan(struct pcap_tx_queue *tx_queue, struct rte_mbuf **mbuf)
> +{
> +       struct rte_mbuf *mb = *mbuf;
> +
> +       if ((mb->ol_flags & RTE_MBUF_F_TX_VLAN) == 0)
> +               return 0;
> +
> +       if (unlikely(mb->data_len < RTE_ETHER_HDR_LEN)) {
> +               PMD_TX_LOG(ERR, "mbuf missing ether header");
> +               goto error;
> +       }
> +
> +       /* Need at another buffer to hold VLAN header? */
> +       if (!RTE_MBUF_DIRECT(mb) || rte_mbuf_refcnt_read(mb) > 1) {
> +               struct rte_mbuf *mh = rte_pktmbuf_alloc(mb->pool);
> +               if (unlikely(mh == NULL)) {
> +                       PMD_TX_LOG(ERR, "mbuf pool exhausted on transmit vlan");
> +                       goto error;
> +               }
> +
> +               /* Extract original ethernet header into new mbuf */
> +               memcpy(rte_pktmbuf_mtod(mh, void *), rte_pktmbuf_mtod(mb, void *), RTE_ETHER_HDR_LEN);
> +               mh->nb_segs = mb->nb_segs + 1;
> +               mh->data_len = RTE_ETHER_HDR_LEN;
> +               mh->pkt_len = mb->pkt_len;
> +               mh->ol_flags = mb->ol_flags;
> +
> +               mb->data_len -= RTE_ETHER_HDR_LEN;
> +               mh->next = mb;
> +
> +               *mbuf = mh;
> +       }

Could this segment allocation+chaining be moved in rte_vlan_insert?

This would help solve this issue in other sw drivers that currently
just drop (indirect) mbufs.
We might need an additional input param for driver that don't want
multiseg / existing users... ?


-- 
David Marchand

[PATCH v18 00/23] net/pcap: fixes, test, and enhancements

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx (via tx_prepare) and stripping on Rx
  - Runtime VLAN offload configuration via vlan_offload_set callback
  - Nanosecond precision timestamps (when libpcap supports it)
  - Link state reporting in interface mode
  - Link status change (LSC) interrupt support in interface mode
  - EOF notification via link status change for rx_pcap mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snaplen devarg

Bug fixes:
  - Fix build on Windows from RTE_LOG_LINE changes.
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Fix Tx burst error handling: distinguish malformed mbufs (counted
    as errors) from pcap_sendpacket backpressure (break and retry)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback
  - Fix infinite_rx ring fill applying VLAN strip and timestamp
    offloads to template packets, preventing those offloads from
    working correctly during packet delivery

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables

Testing:
  - Add comprehensive unit test suite (26 test cases) covering basic
    file I/O, timestamps, jumbo frames, VLAN strip/insert, multi-queue,
    snaplen, EOF notification, and link status
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows
  - Tests use packet_burst_generator for standardized test packet
    creation

v18:
  - Move VLAN insert from tx burst path to tx_prepare callback,
    consistent with virtio and af_packet driver patterns
  - Simplify link status patch to just report UP/DOWN state;
    remove speed and duplex querying that had cross-platform
    portability issues (FreeBSD ifmedia_baudrate not available
    in userspace, Windows GetIfEntry2 linking issues)
  - Fix test_vlan_insert_tx to call rte_eth_tx_prepare() before
    rte_eth_tx_burst() to match the new tx_prepare VLAN insert
    implementation

Stephen Hemminger (23):
  maintainers: update for pcap driver
  net/pcap: fix build on Windows
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: advertise Tx multi segment
  net/pcap: replace stack bounce buffer
  net/pcap: fix error accounting and backpressure on transmit
  net/pcap: add datapath debug logging
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN strip and insert offloads
  net/pcap: add link status for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  eal/windows: add wrapper for access function
  net/pcap: add snapshot length devarg
  net/pcap: add link status change support for iface mode
  net/pcap: add EOF notification via link status change
  test: add comprehensive test suite for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3574 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    9 +
 doc/guides/nics/pcap.rst               |   48 +
 doc/guides/rel_notes/release_26_03.rst |   12 +
 drivers/net/pcap/pcap_ethdev.c         |  812 ++++--
 drivers/net/pcap/pcap_osdep.h          |   27 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   43 +-
 drivers/net/pcap/pcap_osdep_linux.c    |   33 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   76 +-
 lib/eal/windows/include/rte_os_shim.h  |    1 +
 lib/eal/windows/include/unistd.h       |    7 +
 13 files changed, 4423 insertions(+), 222 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v18 01/23] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 1b2f1ed2ba..93ac176573 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1118,6 +1118,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v18 02/23] net/pcap: fix build on Windows

[Stephen Hemminger]

The log messages in the pcap OS dependent code for Windows
was never converted during the last release.

It looks like the osdep part of pcap was not being built.
Building requires have libpcap for Windows built which is not
part of the CI infrastructure.

Fixes: 2b843cac232e ("drivers: use per line logging in helpers")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_osdep_windows.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..0965c2f5c9 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -53,7 +53,7 @@ osdep_iface_index_get(const char *device_name)
 
 	ret = GetAdapterIndex(adapter_name, &index);
 	if (ret != NO_ERROR) {
-		PMD_LOG(ERR, "GetAdapterIndex(%S) = %lu\n", adapter_name, ret);
+		PMD_LOG(ERR, "GetAdapterIndex(%S) = %lu", adapter_name, ret);
 		return -1;
 	}
 
@@ -75,20 +75,20 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
-		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
+		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
 		return -1;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
-		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
+		PMD_LOG(ERR, "Cannot allocate adapter address info");
 		return -1;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
-		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
+		PMD_LOG(ERR, "GetAdapterAddresses() = %lu", sys_ret);
 		free(info);
 		return -1;
 	}
-- 
2.51.0

[PATCH v18 03/23] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..c4f0360a06 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
+Windows              = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v18 04/23] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v18 05/23] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..fbd1021c39 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v18 06/23] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd1021c39..806451dc99 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v18 07/23] net/pcap: advertise Tx multi segment

[Stephen Hemminger]

The driver supports multi-segment transmit, but the did not set
the offload flag. Therefore applications would not know about
that capability.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 806451dc99..fedf461be4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -753,6 +753,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v18 08/23] net/pcap: replace stack bounce buffer

[Stephen Hemminger]

Replace the 64K stack-allocated bounce buffer with a per-queue
buffer allocated from hugepages via rte_malloc at queue setup.
This is necessary because the buffer may be used in a secondary
process transmit path where the primary process allocated it.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 60 +++++++++++++++++++++-------------
 1 file changed, 37 insertions(+), 23 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fedf461be4..72a297d423 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -91,6 +91,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -385,18 +388,17 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -404,12 +406,11 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len, caplen;
+
+		len = rte_pktmbuf_pkt_len(mbuf);
+		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
@@ -449,9 +450,6 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
 	for (i = 0; i < nb_pkts; i++) {
 		tx_bytes += bufs[i]->pkt_len;
 		rte_pktmbuf_free(bufs[i]);
@@ -460,7 +458,7 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -470,30 +468,30 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		int ret;
+
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
+				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
+				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
@@ -966,7 +964,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -974,11 +972,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1019,6 +1032,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
-- 
2.51.0

[PATCH v18 09/23] net/pcap: fix error accounting and backpressure on transmit

[Stephen Hemminger]

The error handling when pcap_sendpacket() was incorrect.
When underlying kernel socket buffer got full the send was counted as
an error. Malformed multi-segment mbufs where pkt_len exceeds actual
data were silently accepted.

Malformed mbufs are now detected via rte_pktmbuf_read() failure
and counted as errors.

On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
The send() call only blocks when the kernel socket send buffer is full,
providing limited backpressure. Backpressure is not an error.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 77 +++++++++++++++++++++-------------
 1 file changed, 49 insertions(+), 28 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 72a297d423..14014a9e4b 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -407,7 +407,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len, caplen;
+		uint32_t len, caplen;
+		const uint8_t *data;
 
 		len = rte_pktmbuf_pkt_len(mbuf);
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
@@ -415,15 +416,19 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
 
-		num_tx++;
-		tx_bytes += caplen;
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+		if (unlikely(data == NULL)) {
+			/* This only happens if mbuf is bogus pkt_len > data_len */
+			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			dumper_q->tx_stat.err_pkts++;
+		} else {
+			pcap_dump((u_char *)dumper, &header, data);
+
+			num_tx++;
+			tx_bytes += caplen;
+		}
+
 		rte_pktmbuf_free(mbuf);
 	}
 
@@ -435,9 +440,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	pcap_dump_flush(dumper);
 	dumper_q->tx_stat.pkts += num_tx;
 	dumper_q->tx_stat.bytes += tx_bytes;
-	dumper_q->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return nb_pkts;
+	return i;
 }
 
 /*
@@ -462,7 +466,17 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 }
 
 /*
- * Callback to handle sending packets through a real NIC.
+ * Send a burst of packets to a pcap device.
+ *
+ * On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
+ * socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
+ * The send() call only blocks when the kernel socket send buffer is full,
+ * providing limited backpressure.
+ *
+ * On error, pcap_sendpacket() returns non-zero and the loop breaks,
+ * leaving remaining packets unsent.
+ *
+ * Bottom line: backpressure is not an error.
  */
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
@@ -484,34 +498,41 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len = rte_pktmbuf_pkt_len(mbuf);
-		int ret;
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		const uint8_t *data;
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
-			break;
-		num_tx++;
-		tx_bytes += len;
+		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		if (unlikely(data == NULL)) {
+			/* This only happens if mbuf is bogus pkt_len > data_len */
+			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			tx_queue->tx_stat.err_pkts++;
+		} else {
+			/*
+			 * No good way to separate back pressure from failure here
+			 * Assume it is EBUSY, ENOMEM, or EINTR, something that can be retried.
+			 */
+			if (pcap_sendpacket(pcap, data, len) != 0) {
+				PMD_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
+				break;
+			}
+			num_tx++;
+			tx_bytes += len;
+		}
+
 		rte_pktmbuf_free(mbuf);
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
 
 	return i;
 }
-- 
2.51.0

[PATCH v18 10/23] net/pcap: add datapath debug logging

[Stephen Hemminger]

Add datapath debug logging macros (PMD_RX_LOG, PMD_TX_LOG) gated
on RTE_ETHDEV_DEBUG_RX/TX. Use PMD_TX_LOG in transmit error paths
to aid debugging without impacting normal datapath performance.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c |  8 ++++----
 drivers/net/pcap/pcap_osdep.h  | 14 ++++++++++++++
 2 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 14014a9e4b..4ae08d3b3c 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -420,7 +420,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
 		if (unlikely(data == NULL)) {
 			/* This only happens if mbuf is bogus pkt_len > data_len */
-			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			PMD_TX_LOG(ERR, "rte_pktmbuf_read failed");
 			dumper_q->tx_stat.err_pkts++;
 		} else {
 			pcap_dump((u_char *)dumper, &header, data);
@@ -502,7 +502,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		const uint8_t *data;
 
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
-			PMD_LOG(ERR,
+			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			tx_queue->tx_stat.err_pkts++;
@@ -513,7 +513,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
 		if (unlikely(data == NULL)) {
 			/* This only happens if mbuf is bogus pkt_len > data_len */
-			PMD_LOG(ERR, "rte_pktmbuf_read failed");
+			PMD_TX_LOG(ERR, "rte_pktmbuf_read failed");
 			tx_queue->tx_stat.err_pkts++;
 		} else {
 			/*
@@ -521,7 +521,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			 * Assume it is EBUSY, ENOMEM, or EINTR, something that can be retried.
 			 */
 			if (pcap_sendpacket(pcap, data, len) != 0) {
-				PMD_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
+				PMD_TX_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
 				break;
 			}
 			num_tx++;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..fe7399ff9f 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,6 +13,20 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+#ifdef RTE_ETHDEV_DEBUG_RX
+#define PMD_RX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() rx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_RX_LOG(...) do { } while (0)
+#endif
+
+#ifdef RTE_ETHDEV_DEBUG_TX
+#define PMD_TX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() tx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_TX_LOG(...) do { } while (0)
+#endif
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
-- 
2.51.0

[PATCH v18 11/23] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4ae08d3b3c..a369c029c3 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -102,9 +103,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -114,25 +115,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -891,7 +892,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1216,29 +1217,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1514,7 +1505,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1553,9 +1544,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1705,5 +1696,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.51.0

[PATCH v18 12/23] net/pcap: support VLAN strip and insert offloads

[Stephen Hemminger]

Add VLAN tag handling to the pcap PMD, consistent with how virtio
and af_packet drivers implement it. This also gets used for
capture of VLAN tagged packets when legacy pdump is used.

RX strip: when RTE_ETH_RX_OFFLOAD_VLAN_STRIP is enabled, the driver
calls rte_vlan_strip() on received packets in both normal and
infinite_rx modes. For infinite_rx, offloads are deferred to
packet delivery rather than applied during ring fill, so the
stored template packets remain unmodified.

TX insert: when RTE_MBUF_F_TX_VLAN is set on an mbuf, the driver
inserts the VLAN tag via rte_vlan_insert() before writing to pcap
or sending to the interface. Indirect or shared mbufs get a new
header mbuf to avoid modifying the original.

Runtime reconfiguration is supported through vlan_offload_set,
which propagates the strip setting to all active RX queues.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/nics/pcap.rst               | 11 +++
 doc/guides/rel_notes/release_26_03.rst |  5 ++
 drivers/net/pcap/pcap_ethdev.c         | 96 ++++++++++++++++++++++++--
 4 files changed, 109 insertions(+), 4 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index c4f0360a06..ec7c91c650 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -9,6 +9,7 @@ Queue start/stop     = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index fbfe854bb1..bed5006a42 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -247,3 +247,14 @@ will be discarded by the Rx flushing operation.
    The network interface provided to the PMD should be up.
    The PMD will return an error if the interface is down,
    and the PMD itself won't change the status of the external network interface.
+
+Features and Limitations
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index b4499ec066..63f554878d 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -106,6 +106,11 @@ New Features
   Added handling of the key combination Control+L
   to clear the screen before redisplaying the prompt.
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
+
 Removed Items
 -------------
 
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index a369c029c3..f1f148ce3a 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -76,6 +76,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -106,6 +107,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -270,7 +272,11 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		bufs[i]->data_len = pcap_buf->data_len;
 		bufs[i]->pkt_len = pcap_buf->pkt_len;
 		bufs[i]->port = pcap_q->port_id;
-		rx_bytes += pcap_buf->data_len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(bufs[i]);
+
+		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
 		rte_ring_enqueue(pcap_q->pkts, pcap_buf);
@@ -336,6 +342,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -382,6 +392,39 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+static uint16_t
+eth_pcap_tx_prepare(void *queue __rte_unused, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
+{
+	uint16_t nb_tx;
+	int error;
+
+	for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
+		struct rte_mbuf *m = tx_pkts[nb_tx];
+
+#ifdef RTE_LIBRTE_ETHDEV_DEBUG
+		error = rte_validate_tx_offload(m);
+		if (unlikely(error)) {
+			rte_errno = -error;
+			break;
+		}
+#endif
+		/* Do VLAN tag insertion */
+		if (unlikely(m->ol_flags & RTE_MBUF_F_TX_VLAN)) {
+			error = rte_vlan_insert(&m);
+
+			/* rte_vlan_insert() could change pointer (currently does not) */
+			tx_pkts[nb_tx] = m;
+
+			if (unlikely(error != 0)) {
+				PMD_TX_LOG(ERR, "rte_vlan_insert failed: %s", strerror(-error));
+				rte_errno = -error;
+				break;
+			}
+		}
+	}
+	return nb_tx;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -415,6 +458,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -499,9 +543,10 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t len;
 		const uint8_t *data;
 
+		len = rte_pktmbuf_pkt_len(mbuf);
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
@@ -756,8 +801,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -773,7 +823,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -920,6 +972,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
@@ -929,6 +982,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		uint64_t pcap_pkt_count = 0;
 		struct rte_mbuf *bufs[1];
 		pcap_t **pcap;
+		bool save_vlan_strip;
 
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
@@ -948,11 +1002,20 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		if (!pcap_q->pkts)
 			return -ENOENT;
 
+		/*
+		 * Temporarily disable offloads while filling the ring
+		 * with raw packets. VLAN strip and timestamp will be
+		 * applied later in eth_pcap_rx_infinite() on each copy.
+		 */
+		save_vlan_strip = pcap_q->vlan_strip;
+		pcap_q->vlan_strip = false;
+
 		/* Fill ring with packets from PCAP file one by one. */
 		while (eth_pcap_rx(pcap_q, bufs, 1)) {
 			/* Check for multiseg mbufs. */
 			if (bufs[0]->nb_segs != 1) {
 				infinite_rx_ring_free(pcap_q->pkts);
+				pcap_q->vlan_strip = save_vlan_strip;
 				PMD_LOG(ERR,
 					"Multiseg mbufs are not supported in infinite_rx mode.");
 				return -EINVAL;
@@ -962,6 +1025,9 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 					(void * const *)bufs, 1, NULL);
 		}
 
+		/* Restore offloads for use during packet delivery */
+		pcap_q->vlan_strip = save_vlan_strip;
+
 		if (rte_ring_count(pcap_q->pkts) < pcap_pkt_count) {
 			infinite_rx_ring_free(pcap_q->pkts);
 			PMD_LOG(ERR,
@@ -1046,6 +1112,26 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	unsigned int i;
+
+	if (mask & RTE_ETH_VLAN_STRIP_MASK) {
+		bool vlan_strip = !!(dev->data->dev_conf.rxmode.offloads &
+				     RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+
+		internals->vlan_strip = vlan_strip;
+
+		/* Update all RX queues */
+		for (i = 0; i < dev->data->nb_rx_queues; i++)
+			internals->rx_queue[i].vlan_strip = vlan_strip;
+	}
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1062,6 +1148,7 @@ static const struct eth_dev_ops ops = {
 	.link_update = eth_link_update,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.vlan_offload_set = eth_vlan_offload_set,
 };
 
 static int
@@ -1402,6 +1489,7 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		eth_dev->rx_pkt_burst = eth_null_rx;
 
 	/* Assign tx ops. */
+	eth_dev->tx_pkt_prepare = eth_pcap_tx_prepare;
 	if (devargs_all->is_tx_pcap)
 		eth_dev->tx_pkt_burst = eth_pcap_tx_dumper;
 	else if (devargs_all->is_tx_iface || single_iface)
-- 
2.51.0

[PATCH v18 13/23] net/pcap: add link status for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent function to query the real link state from
the underlying interface.

Linux and FreeBSD use SIOCGIFFLAGS to check IFF_UP and
IFF_RUNNING. Windows uses GetAdaptersAddresses() to check
OperStatus.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 38 +++++++++-----
 drivers/net/pcap/pcap_osdep.h          | 12 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  | 31 ++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 27 ++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  | 68 +++++++++++++++++++++-----
 6 files changed, 154 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 63f554878d..f117c4975e 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -109,6 +109,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f1f148ce3a..86e0380536 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -150,13 +150,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -952,10 +945,28 @@ eth_dev_close(struct rte_eth_dev *dev)
 }
 
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link link = {
+		.link_speed = RTE_ETH_SPEED_NUM_10G,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
+
+	/*
+	 * For pass-through mode (single_iface), query whether the
+	 * underlying interface is up. Otherwise use default values.
+	 */
+	if (internals->single_iface) {
+		link.link_status = (osdep_iface_link_status(internals->rx_queue[0].name) > 0) ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	} else {
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1370,7 +1381,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index fe7399ff9f..18e63c6f2b 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -10,6 +10,7 @@
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
+
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
@@ -30,4 +31,15 @@ extern int eth_pcap_logtype;
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link status for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @return
+ *   1 if link is up, 0 if link is down, -1 on error.
+ */
+int osdep_iface_link_status(const char *name);
+
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..9c4186aadc 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,8 +5,13 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
@@ -55,3 +60,29 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_status(const char *if_name)
+{
+	struct ifmediareq ifmr;
+	int fd, status = 0;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd == -1)
+		return -1;
+
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* IFM_AVALID means status is valid, IFM_ACTIVE means link up */
+		if ((ifmr.ifm_status & IFM_AVALID) &&
+		    (ifmr.ifm_status & IFM_ACTIVE))
+			status = 1;
+	} else {
+		status = -1;
+	}
+
+	close(fd);
+	return status;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..f61b7bd146 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -40,3 +40,30 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+int
+osdep_iface_link_status(const char *if_name)
+{
+	struct ifreq ifr;
+	int fd, status = 0;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd == -1)
+		return -1;
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up.
+		 * IFF_RUNNING means operationally up (carrier detected).
+		 * Both must be set for link to be considered up.
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			status = 1;
+	} else {
+		status = -1;
+	}
+
+	close(fd);
+	return status;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 0965c2f5c9..e7a49c47e0 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,29 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_status(const char *device_name)
+{
+	IP_ADAPTER_ADDRESSES *info, *cur;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			ret = (cur->OperStatus == IfOperStatusUp) ? 1 : 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v18 14/23] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Add read_clock dev_op returning current UTC time for timestamp
  correlation.
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper.
* Enable immediate mode and improve error reporting
  in live capture setup.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |   3 +
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 156 +++++++++++++++++++------
 3 files changed, 126 insertions(+), 34 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index bed5006a42..2709c6d017 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -258,3 +258,6 @@ Features and Limitations
 *  The PMD will transparently insert a VLAN tag to transmitted packets if
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
+
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index f117c4975e..494cd78f9f 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -110,6 +110,7 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state in ``iface`` mode.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 86e0380536..f14a7d93dd 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -27,13 +27,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -77,6 +75,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -108,6 +107,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -269,6 +269,15 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(bufs[i]);
 
+		if (pcap_q->timestamp_offloading) {
+			struct timespec ts;
+
+			timespec_get(&ts, TIME_UTC);
+			*RTE_MBUF_DYNFIELD(bufs[i], timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(&ts);
+			bufs[i]->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
@@ -339,10 +348,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -362,14 +382,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -440,8 +465,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
@@ -450,8 +477,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		len = rte_pktmbuf_pkt_len(mbuf);
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -580,22 +605,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
+
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
+	}
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -642,7 +707,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -801,6 +867,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -818,7 +885,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -985,6 +1053,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1123,6 +1192,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static int
 eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
 {
@@ -1149,6 +1229,7 @@ static const struct eth_dev_ops ops = {
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1565,15 +1646,22 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		hz = rte_get_timer_hz();
+		if (hz == 0) {
+			PMD_LOG(ERR, "Reported hz is zero!");
+			return -1;
+		}
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							 &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v18 15/23] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f14a7d93dd..1b927b3c35 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -649,6 +649,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.51.0

[PATCH v18 16/23] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 1b927b3c35..1a9db50990 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -46,11 +46,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -607,6 +605,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -718,6 +717,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1466,6 +1467,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v18 17/23] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 1a9db50990..14edafb581 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -54,10 +54,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -908,11 +908,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v18 18/23] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 14edafb581..f2c13530ee 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -891,10 +891,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v18 19/23] eal/windows: add wrapper for access function

[Stephen Hemminger]

Like other Posix functions in unistd.h add wrapper
using the Windows equivalent.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 lib/eal/windows/include/rte_os_shim.h | 1 +
 lib/eal/windows/include/unistd.h      | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/lib/eal/windows/include/rte_os_shim.h b/lib/eal/windows/include/rte_os_shim.h
index f16b2230c8..44664a5062 100644
--- a/lib/eal/windows/include/rte_os_shim.h
+++ b/lib/eal/windows/include/rte_os_shim.h
@@ -33,6 +33,7 @@
 #define unlink(path) _unlink(path)
 #define fileno(f) _fileno(f)
 #define isatty(fd) _isatty(fd)
+#define access(path, mode) _access(path, mode)
 
 #define IPVERSION	4
 
diff --git a/lib/eal/windows/include/unistd.h b/lib/eal/windows/include/unistd.h
index 78150c6480..f95888f4e1 100644
--- a/lib/eal/windows/include/unistd.h
+++ b/lib/eal/windows/include/unistd.h
@@ -23,4 +23,11 @@
 #define STDERR_FILENO _fileno(stderr)
 #endif
 
+/* Mode values for the _access() function.  */
+#ifndef F_OK
+#define	F_OK		0	/* test for existence of file */
+#define	W_OK		0x02	/* test for write permission */
+#define	R_OK		0x04	/* test for read permission */
+#endif
+
 #endif /* _UNISTD_H_ */
-- 
2.51.0

[PATCH v18 20/23] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

The snaplen argument is parsed before interface and file arguments
so that its value is available when pcap handles are opened during
device creation.

Example usage:
  --vdev 'net_pcap0,snaplen=1518,iface=eth0'
  --vdev 'net_pcap0,snaplen=9000,rx_pcap=in.pcap,tx_pcap=out.pcap'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |  17 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 235 ++++++++++++++++---------
 3 files changed, 167 insertions(+), 86 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2709c6d017..2754e205c7 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -15,6 +15,23 @@ For more information about the pcap library, see the
    The pcap-based PMD requires the libpcap development files to be installed.
    This applies to all supported operating systems: Linux, FreeBSD, and Windows.
 
+* Set the snapshot length for packet capture
+
+  The snapshot length controls the maximum number of bytes captured per packet.
+  This affects both interface capture and pcap file output.  The default value is
+  65535 bytes, which captures complete packets up to the maximum Ethernet jumbo
+  frame size.  Reducing this value can improve performance when only packet headers
+  are needed.
+
+  The ``snaplen`` argument is used when opening capture handles, so it should
+  be specified before the interface or file arguments.  Example::
+
+     --vdev 'net_pcap0,snaplen=1518,iface=eth0'
+     --vdev 'net_pcap0,snaplen=9000,rx_pcap=in.pcap,tx_pcap=out.pcap'
+
+  The snapshot length also determines the reported ``max_rx_pktlen``
+  and ``max_mtu`` in device info.
+
 
 Using the Driver from the EAL Command Line
 ------------------------------------------
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 494cd78f9f..49e2c0cf2b 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -111,6 +111,7 @@ New Features
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state in ``iface`` mode.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f2c13530ee..5b5cbb38a2 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -13,6 +13,8 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <unistd.h>
+
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -31,8 +33,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -41,6 +41,12 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
+
+/* This is defined in libpcap but not exposed in headers */
+#define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -101,6 +107,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -119,15 +126,18 @@ struct pmd_devargs {
 	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
+		/* pcap and name/type fields... */
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
+	uint32_t snapshot_len;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -145,6 +155,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
@@ -447,20 +458,19 @@ eth_pcap_tx_prepare(void *queue __rte_unused, struct rte_mbuf **tx_pkts, uint16_
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -473,7 +483,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		const uint8_t *data;
 
 		len = rte_pktmbuf_pkt_len(mbuf);
-		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+		caplen = RTE_MIN(len, snaplen);
 
 		header.len = len;
 		header.caplen = caplen;
@@ -542,55 +552,50 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_process_private *pp = dev->process_private;
+	struct pmd_internals *internals = dev->data->dev_private;
+	uint32_t snaplen = internals->snapshot_len;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		uint32_t len;
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
 
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		/*
+		 * multi-segment transmit that has to go through bounce buffer.
+		 * Make sure it fits; don't want to truncate the packet.
+		 */
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > snaplen)) {
 			PMD_TX_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
-				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
-			tx_queue->tx_stat.err_pkts++;
+				   "Multi segment len (%u) > snaplen (%u)",
+				   len, snaplen);
 			rte_pktmbuf_free(mbuf);
+			tx_queue->tx_stat.err_pkts++;
 			continue;
 		}
 
 		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
-		if (unlikely(data == NULL)) {
-			/* This only happens if mbuf is bogus pkt_len > data_len */
-			PMD_TX_LOG(ERR, "rte_pktmbuf_read failed");
-			tx_queue->tx_stat.err_pkts++;
-		} else {
-			/*
-			 * No good way to separate back pressure from failure here
-			 * Assume it is EBUSY, ENOMEM, or EINTR, something that can be retried.
-			 */
-			if (pcap_sendpacket(pcap, data, len) != 0) {
-				PMD_TX_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
-				break;
-			}
-			num_tx++;
-			tx_bytes += len;
+		/*
+		 * No good way to separate back pressure from failure here
+		 * Assume it is EBUSY, ENOMEM, or EINTR, something that can be retried.
+		 */
+		if (pcap_sendpacket(pcap, data, len) != 0) {
+			PMD_TX_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
+			break;
 		}
-
 		rte_pktmbuf_free(mbuf);
+		num_tx++;
+		tx_bytes += len;
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
@@ -603,7 +608,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -620,6 +625,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
 			iface, pcap_statustostr(status));
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	status = pcap_set_immediate_mode(pc, 1);
@@ -632,7 +640,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -646,6 +654,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -674,9 +685,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -685,7 +696,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -695,7 +707,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -704,9 +716,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -748,6 +760,21 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+static int
+set_iface_direction(const char *iface, pcap_t *pcap,
+		pcap_direction_t direction)
+{
+	const char *direction_str = (direction == PCAP_D_IN) ? "IN" : "OUT";
+	if (pcap_setdirection(pcap, direction) < 0) {
+		PMD_LOG(ERR, "Setting %s pcap direction %s failed - %s",
+				iface, direction_str, pcap_geterr(pcap));
+		return -1;
+	}
+	PMD_LOG(INFO, "Setting %s pcap direction %s",
+			iface, direction_str);
+	return 0;
+}
+
 static int
 eth_dev_start(struct rte_eth_dev *dev)
 {
@@ -756,15 +783,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
 		rx = &internals->rx_queue[0];
 
-		if (!pp->tx_pcap[0] &&
-			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+		if (!pp->tx_pcap[0] && strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -776,14 +803,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -798,9 +822,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -891,11 +920,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1153,7 +1182,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1305,7 +1334,8 @@ open_tx_pcap(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *dumpers = extra_args;
 	pcap_dumper_t *dumper;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	if (open_single_tx_pcap(pcap_filename, &dumper,
+				dumpers->snapshot_len) < 0)
 		return -1;
 
 	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
@@ -1326,7 +1356,7 @@ open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *tx = extra_args;
 	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (open_single_iface(iface, &pcap, tx->snapshot_len) < 0)
 		return -1;
 
 	tx->queue[0].pcap = pcap;
@@ -1336,21 +1366,6 @@ open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
-static inline int
-set_iface_direction(const char *iface, pcap_t *pcap,
-		pcap_direction_t direction)
-{
-	const char *direction_str = (direction == PCAP_D_IN) ? "IN" : "OUT";
-	if (pcap_setdirection(pcap, direction) < 0) {
-		PMD_LOG(ERR, "Setting %s pcap direction %s failed - %s",
-				iface, direction_str, pcap_geterr(pcap));
-		return -1;
-	}
-	PMD_LOG(INFO, "Setting %s pcap direction %s",
-			iface, direction_str);
-	return 0;
-}
-
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
@@ -1358,7 +1373,7 @@ open_iface(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *pmd = extra_args;
 	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (open_single_iface(iface, &pcap, pmd->snapshot_len) < 0)
 		return -1;
 	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
 		pcap_close(pcap);
@@ -1426,6 +1441,31 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN ||
+	    val > ETH_PCAP_MAXIMUM_SNAPLEN) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1590,6 +1630,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1651,6 +1693,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1697,6 +1740,25 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 			return -1;
 	}
 
+	/*
+	 * Process optional snapshot length argument first, so the value
+	 * is available when opening pcap handles for files and interfaces.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+	/*
+	 * Propagate snapshot length to per-queue devargs so that
+	 * the open callbacks can access it.
+	 */
+	devargs_all.rx_queues.snapshot_len = devargs_all.snapshot_len;
+	devargs_all.tx_queues.snapshot_len = devargs_all.snapshot_len;
+
 	/*
 	 * If iface argument is passed we open the NICs and use them for
 	 * reading / writing
@@ -1903,4 +1965,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v18 21/23] net/pcap: add link status change support for iface mode

[Stephen Hemminger]

Add LSC interrupt support for pass-through (iface=) mode so
applications can receive link state change notifications via
the standard ethdev callback mechanism.

Uses alarm-based polling to periodically check the underlying
interface state via osdep_iface_link_get(). The LSC flag is
advertised only for iface mode devices, and polling is gated
on the application enabling intr_conf.lsc in port configuration.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/nics/pcap.rst               |  5 +++
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 45 ++++++++++++++++++++++++++
 4 files changed, 52 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index ec7c91c650..b409ecd597 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -5,6 +5,7 @@
 ;
 [Features]
 Link status          = Y
+Link status event    = Y
 Queue start/stop     = Y
 Timestamp offload    = Y
 Basic stats          = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2754e205c7..72f2250790 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -278,3 +278,8 @@ Features and Limitations
 
 *  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
    UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
+
+*  In ``iface`` mode, the PMD supports link status change (LSC) notifications.
+   When the application enables ``intr_conf.lsc`` in the port configuration,
+   the driver polls the underlying network interface once per second and generates an
+   ``RTE_ETH_EVENT_INTR_LSC`` callback when the link state changes.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 49e2c0cf2b..c1bb808195 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -112,6 +112,7 @@ New Features
   * Added support for reporting link state in ``iface`` mode.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added support for Link State interrupt in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 5b5cbb38a2..de28eb1dec 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -17,6 +17,7 @@
 
 #include <pcap.h>
 
+#include <rte_alarm.h>
 #include <rte_cycles.h>
 #include <rte_ring.h>
 #include <rte_ethdev.h>
@@ -48,6 +49,8 @@
 /* This is defined in libpcap but not exposed in headers */
 #define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
+#define ETH_PCAP_LSC_POLL_INTERVAL_US (1000 * 1000) /* 1 second */
+
 #define ETH_PCAP_ARG_MAXLEN	64
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
@@ -113,6 +116,7 @@ struct pmd_internals {
 	bool infinite_rx;
 	bool vlan_strip;
 	bool timestamp_offloading;
+	bool lsc_active;
 };
 
 struct pmd_process_private {
@@ -161,6 +165,9 @@ static const char *valid_arguments[] = {
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declarations */
+static int eth_link_update(struct rte_eth_dev *dev, int wait_to_complete);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -760,6 +767,28 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+/*
+ * Periodic alarm to poll link state.
+ * Enabled when link state interrupt is enabled in single_iface mode.
+ */
+static void
+eth_pcap_lsc_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link old_link, new_link;
+
+	rte_eth_linkstatus_get(dev, &old_link);
+	eth_link_update(dev, 0);
+	rte_eth_linkstatus_get(dev, &new_link);
+
+	if (old_link.link_status != new_link.link_status)
+		rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+
+	if (internals->lsc_active)
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US, eth_pcap_lsc_alarm, dev);
+}
+
 static int
 set_iface_direction(const char *iface, pcap_t *pcap,
 		pcap_direction_t direction)
@@ -842,6 +871,13 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
+	/* Start LSC polling for iface mode if application requested it */
+	if (internals->single_iface && dev->data->dev_conf.intr_conf.lsc) {
+		internals->lsc_active = true;
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US,
+				  eth_pcap_lsc_alarm, dev);
+	}
+
 	return 0;
 }
 
@@ -859,6 +895,12 @@ eth_dev_stop(struct rte_eth_dev *dev)
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
+		/* Cancel LSC polling before closing pcap handles */
+		if (internals->lsc_active) {
+			internals->lsc_active = false;
+			rte_eal_alarm_cancel(eth_pcap_lsc_alarm, dev);
+		}
+
 		queue_missed_stat_on_stop_update(dev, 0);
 		if (pp->tx_pcap[0] != NULL) {
 			pcap_close(pp->tx_pcap[0]);
@@ -1621,6 +1663,9 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		internals->if_index =
 			osdep_iface_index_get(rx_queues->queue[0].name);
 
+		/* Enable LSC interrupt support for iface mode */
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 		/* phy_mac arg is applied only if "iface" devarg is provided */
 		if (rx_queues->phy_mac) {
 			if (eth_pcap_update_mac(rx_queues->queue[0].name,
-- 
2.51.0

[PATCH v18 22/23] net/pcap: add EOF notification via link status change

[Stephen Hemminger]

Add an "eof" devarg for rx_pcap mode that signals end-of-file by
setting link down and generating an LSC event. This allows
applications to detect when a pcap file has been fully consumed
using the standard ethdev callback mechanism.

The eof and infinite_rx options are mutually exclusive. On device
restart, the EOF state is reset so the file can be replayed.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               | 12 ++++
 doc/guides/rel_notes/release_26_03.rst |  2 +
 drivers/net/pcap/pcap_ethdev.c         | 80 +++++++++++++++++++++++++-
 3 files changed, 91 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 72f2250790..18a9a04652 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -161,6 +161,18 @@ Runtime Config Options
   so all queues on a device will either have this enabled or disabled.
   This option should only be provided once per device.
 
+* Signal end-of-file via link status change
+
+  In case ``rx_pcap=`` configuration is set, the user may want to be notified when
+  all packets in the pcap file have been read.  This can be done with the ``eof``
+  devarg, for example::
+
+     --vdev 'net_pcap0,rx_pcap=file_rx.pcap,eof=1'
+
+  When enabled, the driver sets link down and generates an LSC event at end of file.
+  If the device is stopped and restarted, the EOF state is reset.
+  This option cannot be combined with ``infinite_rx``.
+
 * Drop all packets on transmit
 
   To drop all packets on transmit for a device,
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index c1bb808195..aa95b5885c 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -113,6 +113,8 @@ New Features
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
   * Added support for Link State interrupt in ``iface`` mode.
+  * Added ``eof`` devarg to use link state to signal end of receive
+    file input.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index de28eb1dec..70e0604db4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -42,6 +42,7 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_EOF_ARG          "eof"
 #define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
 
 #define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
@@ -114,6 +115,8 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool eof;
+	RTE_ATOMIC(bool) eof_signaled;
 	bool vlan_strip;
 	bool timestamp_offloading;
 	bool lsc_active;
@@ -148,6 +151,7 @@ struct pmd_devargs_all {
 	bool is_rx_pcap;
 	bool is_rx_iface;
 	bool infinite_rx;
+	bool eof;
 };
 
 static const char *valid_arguments[] = {
@@ -159,6 +163,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_EOF_ARG,
 	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
@@ -306,15 +311,33 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	return i;
 }
 
+/*
+ * Deferred EOF alarm callback.
+ *
+ * Scheduled from the RX burst path when end-of-file is reached,
+ * so that rte_eth_dev_callback_process() runs outside the datapath.
+ * This avoids holding any locks that the application callback
+ * might also need, preventing potential deadlocks.
+ */
+static void
+eth_pcap_eof_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+
+	rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+}
+
 static uint16_t
 eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
+	struct pcap_rx_queue *pcap_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[pcap_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
 	unsigned int i;
 	struct pcap_pkthdr *header;
 	struct pmd_process_private *pp;
 	const u_char *packet;
 	struct rte_mbuf *mbuf;
-	struct pcap_rx_queue *pcap_q = queue;
 	uint16_t num_rx = 0;
 	uint32_t rx_bytes = 0;
 	pcap_t *pcap;
@@ -335,6 +358,23 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			if (ret == PCAP_ERROR)
 				pcap_q->rx_stat.err_pkts++;
 
+			/*
+			 * EOF: if eof mode is enabled, set link down and
+			 * defer notification via alarm to avoid calling
+			 * rte_eth_dev_callback_process() from the datapath.
+			 */
+			else if (ret == PCAP_ERROR_BREAK) {
+				bool expected = false;
+
+				if (internals->eof &&
+				    rte_atomic_compare_exchange_strong_explicit(
+					    &internals->eof_signaled, &expected, true,
+					    rte_memory_order_relaxed, rte_memory_order_relaxed)) {
+					eth_link_update(dev, 0);
+					rte_eal_alarm_set(1, eth_pcap_eof_alarm, dev);
+				}
+			}
+
 			break;
 		}
 
@@ -869,6 +909,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++)
 		dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
 
+	rte_atomic_store_explicit(&internals->eof_signaled, false, rte_memory_order_relaxed);
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
 	/* Start LSC polling for iface mode if application requested it */
@@ -892,6 +933,7 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	unsigned int i;
 	struct pmd_internals *internals = dev->data->dev_private;
 	struct pmd_process_private *pp = dev->process_private;
+	bool expected;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
@@ -931,6 +973,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	}
 
 status_down:
+	/* Cancel any pending EOF alarm */
+	expected = true;
+	if (rte_atomic_compare_exchange_strong_explicit(
+		    &internals->eof_signaled, &expected, false,
+		    rte_memory_order_relaxed, rte_memory_order_relaxed))
+		rte_eal_alarm_cancel(eth_pcap_eof_alarm, dev);
+
 	for (i = 0; i < dev->data->nb_rx_queues; i++)
 		dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
 
@@ -1113,9 +1162,10 @@ eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 	if (internals->single_iface) {
 		link.link_status = (osdep_iface_link_status(internals->rx_queue[0].name) > 0) ?
 			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	} else if (rte_atomic_load_explicit(&internals->eof_signaled, rte_memory_order_relaxed)) {
+		link.link_status = RTE_ETH_LINK_DOWN;
 	} else {
-		link.link_status = dev->data->dev_started ?
-			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_status = dev->data->dev_started ? RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 	}
 
 	return rte_eth_linkstatus_set(dev, &link);
@@ -1675,8 +1725,13 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->eof = devargs_all->eof;
 	internals->snapshot_len = devargs_all->snapshot_len;
 
+	/* Enable LSC for eof mode (already set above for single_iface) */
+	if (internals->eof)
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1872,6 +1927,24 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 					"for %s", name);
 		}
 
+		/*
+		 * Check whether to signal EOF via link status change.
+		 */
+		if (rte_kvargs_count(kvlist, ETH_PCAP_EOF_ARG) == 1) {
+			ret = rte_kvargs_process(kvlist, ETH_PCAP_EOF_ARG,
+						 &process_bool_flag,
+						 &devargs_all.eof);
+			if (ret < 0)
+				goto free_kvlist;
+		}
+
+		if (devargs_all.infinite_rx && devargs_all.eof) {
+			PMD_LOG(ERR, "Cannot use both infinite_rx and eof for %s",
+				name);
+			ret = -EINVAL;
+			goto free_kvlist;
+		}
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
 				&open_rx_pcap, &pcaps);
 	} else if (devargs_all.is_rx_iface) {
@@ -2011,4 +2084,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_EOF_ARG "=<0|1> "
 	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v18 23/23] test: add comprehensive test suite for pcap PMD

[Stephen Hemminger]

Add unit tests for the pcap PMD covering file and interface modes.

Tests include:
  - basic TX to file and RX from file
  - varied packet sizes and jumbo frames
  - infinite RX mode
  - TX drop mode
  - statistics
  - interface (iface=) pass-through mode
  - link status reporting for file and iface modes
  - link status change (LSC) with interface toggle
  - EOF notification via LSC
  - RX timestamps and timestamp with infinite RX
  - multiple TX/RX queues
  - VLAN strip, insert, and runtime offload configuration
  - snapshot length (snaplen) and truncation

Cross-platform helpers handle temp file creation, interface
discovery, and VLAN packet generation.

The LSC link toggle test requires a pre-created dummy interface
(Linux: dummy0, FreeBSD: disc0) and is skipped if unavailable.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3574 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 3577 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index 4fd8670e05..253d43d60f 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 def_lib = get_option('default_library')
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..c4a9436ad5
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,3574 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define F_OK 0
+#define usleep(us) Sleep((us) / 1000 ? (us) / 1000 : 1)
+#else
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths shared between tests */
+static char tx_pcap_path[PATH_MAX];	/* test_tx_to_file -> test_rx_from_file */
+static char vlan_rx_pcap_path[PATH_MAX]; /* test_vlan_strip_rx -> test_vlan_no_strip_rx */
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port with custom config
+ */
+static int
+setup_pcap_port_conf(uint16_t port, const struct rte_eth_conf *conf)
+{
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port (default: timestamp offload)
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf with controlled segment size.
+ *
+ * Unlike alloc_jumbo_mbuf which fills segments to tailroom capacity,
+ * this limits each segment to seg_size bytes, guaranteeing that the
+ * resulting mbuf chain has multiple segments even for moderate pkt_len.
+ */
+static struct rte_mbuf *
+alloc_multiseg_mbuf(uint32_t pkt_len, uint16_t seg_size, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t this_len;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		this_len = RTE_MIN(remaining, seg_size);
+		this_len = RTE_MIN(this_len, rte_pktmbuf_tailroom(seg));
+		seg->data_len = this_len;
+
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, this_len);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= this_len;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+	int ret;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char varied_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+	remove_temp_file(varied_pcap_path);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char infinite_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+	int ret;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+	remove_temp_file(infinite_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+	int ret;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+	remove_temp_file(rx_pcap_path);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+	int ret;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path), "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char jumbo_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path), "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+	remove_temp_file(jumbo_pcap_path);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	int ret;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+	remove_temp_file(rx_pcap_path);
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+static int
+test_lsc_iface(void)
+{
+	printf("  Link toggle test not supported on Windows, skipping\n");
+	return TEST_SKIPPED;
+}
+#else
+/*
+ * Test: Link Status Change (LSC) interrupt support
+ *
+ * Verifies that:
+ * 1. LSC capability is NOT advertised for file mode
+ * 2. LSC capability IS advertised for iface mode
+ * 3. LSC callback fires when the underlying interface goes down/up
+ *
+ * Requires a toggleable Ethernet interface created before running:
+ *   Linux:   ip link add dummy0 type dummy && ip link set dummy0 up
+ *   FreeBSD: ifconfig disc0 create && ifconfig disc0 up
+ *
+ * Skipped if no suitable interface is found or on Windows.
+ */
+
+/* Callback counter for LSC test */
+static volatile int lsc_callback_count;
+
+static int
+test_lsc_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	lsc_callback_count++;
+	return 0;
+}
+
+/*
+ * Helper: Set interface link up or down via ioctl.
+ * Returns 0 on success, -errno on failure.
+ */
+static int
+set_iface_up_down(const char *ifname, int up)
+{
+	struct ifreq ifr;
+	int fd, ret;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd < 0)
+		return -errno;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	ret = ioctl(fd, SIOCGIFFLAGS, &ifr);
+	if (ret < 0) {
+		ret = -errno;
+		close(fd);
+		return ret;
+	}
+
+	if (up)
+		ifr.ifr_flags |= IFF_UP;
+	else
+		ifr.ifr_flags &= ~IFF_UP;
+
+	ret = ioctl(fd, SIOCSIFFLAGS, &ifr);
+	if (ret < 0)
+		ret = -errno;
+	else
+		ret = 0;
+
+	close(fd);
+	return ret;
+}
+
+/*
+ * Helper: Find a toggleable test interface for LSC testing.
+ *
+ * Looks for well-known interfaces that are safe to bring up/down:
+ *   Linux:   dummy0 (ip link add dummy0 type dummy)
+ *   FreeBSD: disc0 (ifconfig disc0 create)
+ *
+ * Returns interface name or NULL if none found.
+ */
+static const char *
+find_lsc_test_iface(void)
+{
+	static const char *candidates[] = { "dummy0", "disc0" };
+	unsigned int i;
+
+	for (i = 0; i < RTE_DIM(candidates); i++) {
+		if (iface_is_ethernet(candidates[i]))
+			return candidates[i];
+	}
+	return NULL;
+}
+
+static int
+test_lsc_iface(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	int ret;
+
+	printf("Testing Link Status Change (LSC) support\n");
+
+	/*
+	 * Test 1: Verify LSC is NOT advertised for file mode
+	 */
+	printf("  Testing file mode does not advertise LSC\n");
+	{
+		char lsc_pcap_path[PATH_MAX];
+		uint16_t file_port_id;
+
+		TEST_ASSERT(create_temp_path(lsc_pcap_path, sizeof(lsc_pcap_path),
+					     "pcap_lsc") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(lsc_pcap_path, 1) == 0,
+			    "Failed to create test pcap");
+
+		ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", lsc_pcap_path);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		TEST_ASSERT(create_pcap_vdev("net_pcap_lsc_file", devargs,
+					     &file_port_id) == 0,
+			    "Failed to create file vdev");
+
+		ret = rte_eth_dev_info_get(file_port_id, &dev_info);
+		TEST_ASSERT(ret == 0, "Failed to get dev info");
+
+		TEST_ASSERT((*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC) == 0,
+			    "File mode should NOT advertise LSC capability");
+
+		rte_vdev_uninit("net_pcap_lsc_file");
+		remove_temp_file(lsc_pcap_path);
+		printf("  File mode LSC check PASSED\n");
+	}
+
+	struct rte_eth_link link;
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	uint16_t port_id;
+
+	/*
+	 * Test 2: Use a toggleable interface to test link change events.
+	 * Skip if not present.
+	 */
+	const char *lsc_iface = find_lsc_test_iface();
+	if (lsc_iface == NULL) {
+		printf("  No toggleable interface found, skipping link change test\n");
+		printf("  Linux:   ip link add dummy0 type dummy && ip link set dummy0 up\n");
+		printf("  FreeBSD: ifconfig disc0 create && ifconfig disc0 up\n");
+		return TEST_SUCCESS;
+	}
+
+	printf("  Testing iface mode LSC with: %s\n", lsc_iface);
+
+	/* Ensure interface is up before we start */
+	ret = set_iface_up_down(lsc_iface, 1);
+	if (ret != 0) {
+		printf("  Cannot set %s up (%s), skipping\n",
+		       lsc_iface, strerror(-ret));
+		return TEST_SUCCESS;
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", lsc_iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_lsc", devargs);
+	if (ret < 0) {
+		printf("  Cannot create iface vdev for %s, skipping\n", lsc_iface);
+		return TEST_SUCCESS;
+	}
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_lsc", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "Iface mode should advertise LSC capability");
+	printf("    LSC capability advertised: yes\n");
+
+	/* Register LSC callback */
+	lsc_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_lsc_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link status");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+	printf("    Link after start: UP\n");
+
+	/* Bring interface down - should trigger LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 0);
+	TEST_ASSERT(ret == 0, "Failed to set %s down: %s",
+		    lsc_iface, strerror(-ret));
+
+	/* Wait for at least one poll cycle (1 second interval) */
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after down");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after interface down");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired, count=%d",
+		    lsc_callback_count);
+	printf("    Interface down: link DOWN, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Bring it back up - should trigger another LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 1);
+	TEST_ASSERT(ret == 0, "Failed to set %s up: %s",
+		    lsc_iface, strerror(-ret));
+
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after up");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after interface up");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired on link restore, count=%d",
+		    lsc_callback_count);
+	printf("    Interface up: link UP, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Cleanup */
+	rte_eth_dev_stop(port_id);
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_lsc_callback, NULL);
+	rte_vdev_uninit("net_pcap_lsc");
+
+	printf("LSC test PASSED\n");
+	return TEST_SUCCESS;
+}
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Test: EOF notification via link status change
+ *
+ * Verifies that:
+ * 1. The eof devarg causes link down + LSC event at end of pcap file
+ * 2. link_get reports DOWN after EOF
+ * 3. Stop/start resets the EOF state and replays the file
+ * 4. The eof and infinite_rx options are mutually exclusive
+ */
+
+static volatile int eof_callback_count;
+
+static int
+test_eof_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	eof_callback_count++;
+	return 0;
+}
+
+static int
+test_eof_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	struct rte_eth_link link;
+	char eof_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx;
+	int ret;
+
+	printf("Testing EOF notification via link status change\n");
+
+	/* Create pcap file with known number of packets */
+	TEST_ASSERT(create_temp_path(eof_pcap_path, sizeof(eof_pcap_path),
+				     "pcap_eof") == 0,
+		    "Failed to create temp file path");
+	TEST_ASSERT(create_test_pcap(eof_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/*
+	 * Test 1: EOF triggers link down and LSC callback
+	 */
+	printf("  Testing EOF triggers link down and LSC event\n");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,eof=1",
+		       eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create eof vdev: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_eof", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	struct rte_eth_dev_info dev_info;
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "EOF mode should advertise LSC capability");
+
+	/* Register LSC callback */
+	eof_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_eof_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Drain all packets from the pcap file */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			/* Got all packets and rx returned 0 — EOF hit */
+			break;
+		}
+	}
+
+	printf("    Received %u packets (expected %d)\n", total_rx, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Should receive exactly %d packets", NUM_PACKETS);
+
+	/* Verify link went down */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after EOF");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after EOF");
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	/* Verify callback fired exactly once */
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "LSC callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    EOF signaled: link DOWN, callback fired\n");
+
+	/*
+	 * Test 2: Stop/start resets EOF and replays the file
+	 */
+	printf("  Testing restart replays pcap file\n");
+
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	eof_callback_count = 0;
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to restart port");
+
+	/* Verify link is up again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after restart");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after restart");
+
+	/* Read packets again */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			break;
+		}
+	}
+
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Restart: should receive %d packets, got %u",
+			  NUM_PACKETS, total_rx);
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "Restart: callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    Restart replay: %u packets, EOF signaled again\n", total_rx);
+
+	/* Cleanup */
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_eof_callback, NULL);
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_eof");
+
+	/*
+	 * Test 3: eof + infinite_rx is rejected
+	 */
+	printf("  Testing eof + infinite_rx mutual exclusion\n");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,eof=1,infinite_rx=1", eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof_bad", devargs);
+	TEST_ASSERT(ret != 0, "eof + infinite_rx should be rejected");
+	printf("    Mutual exclusion check PASSED\n");
+
+	remove_temp_file(eof_pcap_path);
+
+	printf("EOF test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char timestamp_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64
+			       " actual=%"PRIu64"\n", i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+	remove_temp_file(timestamp_pcap_path);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		remove_temp_file(multi_tx_pcap_paths[q]);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char multi_rx_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0,
+		    "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	remove_temp_file(multi_rx_pcap_path);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		       rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation with multi-segment mbufs
+ *
+ * This test verifies that the dumper path correctly truncates
+ * non-contiguous (multi-segment) mbufs when the total packet length
+ * exceeds the configured snaplen.  It exercises the RTE_MIN(len, snaplen)
+ * cap in the TX dumper by ensuring:
+ *
+ * 1. caplen in the pcap header equals snaplen (not pkt_len)
+ * 2. len in the pcap header preserves the original packet length
+ * 3. Truncation works when the snaplen boundary falls mid-chain
+ */
+static int
+test_snaplen_truncation_multiseg(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx;
+	unsigned int i, pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint32_t pkt_size = 300;
+	const uint16_t seg_size = 64;
+	const unsigned int num_pkts = 8;
+
+	printf("Testing snaplen truncation with multi-segment mbufs\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_trunc_ms") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		       tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	TEST_ASSERT(create_pcap_vdev("net_pcap_trunc_ms", devargs,
+				     &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/*
+	 * Allocate multi-segment mbufs.  With seg_size=64 and pkt_size=300,
+	 * each mbuf will have 5 segments (4×64 + 1×44).  The snaplen of 100
+	 * falls partway through the second segment, forcing the dumper to
+	 * stop writing in the middle of the chain.
+	 */
+	for (i = 0; i < num_pkts; i++) {
+		mbufs[i] = alloc_multiseg_mbuf(pkt_size, seg_size,
+					       (uint8_t)(0xA0 + i));
+		if (mbufs[i] == NULL) {
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_trunc_ms", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+	}
+
+	printf("  Sending %u packets: pkt_len=%u, seg_size=%u (%u segs), snaplen=%u\n",
+	       num_pkts, pkt_size, seg_size, mbufs[0]->nb_segs, test_snaplen);
+
+	/* Verify mbufs are actually multi-segment */
+	TEST_ASSERT(mbufs[0]->nb_segs > 1,
+		    "Expected multi-segment mbufs, got %u segment(s)",
+		    mbufs[0]->nb_segs);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_pkts);
+
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_pkts; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_pkts,
+			  "TX burst failed: sent %d/%u", nb_tx, num_pkts);
+
+	cleanup_pcap_vdev("net_pcap_trunc_ms", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size,
+				     &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, num_pkts,
+			  "Packet count mismatch: got %u, expected %u",
+			  pkt_count, num_pkts);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation multi-segment test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char vlan_tx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t nb_prep;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* tx_prepare handles VLAN tag insertion */
+	nb_prep = rte_eth_tx_prepare(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_prep, NUM_PACKETS,
+			  "tx_prepare failed: prepared %u/%d", nb_prep, NUM_PACKETS);
+
+	/* Transmit the prepared packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_prep);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	remove_temp_file(vlan_tx_pcap_path);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Runtime VLAN offload configuration via rte_eth_dev_set_vlan_offload
+ *
+ * This test verifies that VLAN strip can be enabled/disabled at runtime
+ * using the standard ethdev API rather than only at configure time.
+ * Uses infinite_rx mode so the same packets can be read in each phase.
+ */
+static int
+test_vlan_offload_set(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char vlan_set_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf = { 0 };
+	unsigned int i;
+	uint16_t nb_rx;
+	int ret, current_offload;
+	size_t tagged_len, untagged_len;
+
+	printf("Testing runtime VLAN offload configuration\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_set_pcap_path, sizeof(vlan_set_pcap_path),
+				     "pcap_vlan_set") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_set_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	/* Use infinite_rx so packets are always available */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", vlan_set_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_set", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+
+	/* Configure WITHOUT VLAN strip initially and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port");
+
+	/* Expected lengths */
+	tagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		     sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+	untagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN strip is initially disabled */
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled initially");
+
+	/*
+	 * Phase 1: VLAN strip disabled - packets should have tags
+	 */
+	printf("  Phase 1: VLAN strip disabled\n");
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 1");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 1 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact\n", nb_rx);
+
+	/*
+	 * Phase 2: Enable VLAN strip at runtime - packets should be stripped
+	 */
+	printf("  Phase 2: Enabling VLAN strip via rte_eth_dev_set_vlan_offload\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, RTE_ETH_VLAN_STRIP_OFFLOAD);
+	TEST_ASSERT(ret == 0, "Failed to enable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD,
+		    "VLAN strip should be enabled after set_vlan_offload");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 2");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), untagged_len,
+				  "Phase 2 packet %u: expected untagged length %zu, got %u",
+				  i, untagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Phase 2 packet %u: VLAN_STRIPPED flag not set", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags stripped\n", nb_rx);
+
+	/*
+	 * Phase 3: Disable VLAN strip - packets should have tags again
+	 */
+	printf("  Phase 3: Disabling VLAN strip\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to disable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled after clearing");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 3");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 3 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact again\n", nb_rx);
+
+	cleanup_pcap_vdev("net_pcap_vlan_set", port_id);
+	remove_temp_file(vlan_set_pcap_path);
+
+	printf("Runtime VLAN offload PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip in infinite RX mode
+ *
+ * This test verifies that VLAN strip offload works correctly when combined
+ * with infinite_rx mode, which uses a different RX path (eth_pcap_rx_infinite).
+ */
+static int
+test_vlan_strip_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	char vlan_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int stripped_count = 0;
+	int iter, attempts, ret;
+	size_t expected_len;
+
+	printf("Testing VLAN strip with infinite RX mode\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_inf_pcap_path, sizeof(vlan_inf_pcap_path),
+				     "pcap_vlan_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_inf_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets for infinite RX\n", NUM_PACKETS);
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", vlan_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_vlan_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_vlan_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with VLAN strip enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Expected length after VLAN strip */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Read packets - need more than file contains to verify infinite looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				/* Verify VLAN was stripped */
+				if (verify_no_vlan_tag(mbufs[i]) == 0 &&
+				    rte_pktmbuf_pkt_len(mbufs[i]) == expected_len &&
+				    (mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED))
+					stripped_count++;
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_vlan_inf");
+	remove_temp_file(vlan_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(stripped_count, total_rx,
+			  "VLAN strip failed: only %u/%u packets stripped correctly",
+			  stripped_count, total_rx);
+
+	printf("VLAN strip infinite RX PASSED: %u packets stripped (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Timestamps in infinite RX mode
+ *
+ * This test verifies that timestamp offload works correctly when combined
+ * with infinite_rx mode. Since infinite_rx generates packets on-the-fly,
+ * timestamps should reflect the current time rather than pcap file timestamps.
+ */
+static int
+test_timestamp_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	char ts_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int ts_count = 0;
+	int iter, attempts, ret;
+	rte_mbuf_timestamp_t first_ts = 0;
+	rte_mbuf_timestamp_t last_ts = 0;
+
+	printf("Testing timestamps with infinite RX mode\n");
+
+	/* Initialize timestamp dynamic field access */
+	if (timestamp_dynfield_offset < 0) {
+		ret = timestamp_init();
+		if (ret != 0) {
+			printf("Timestamp dynfield not available, skipping\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	/* Create simple pcap file */
+	TEST_ASSERT(create_temp_path(ts_inf_pcap_path, sizeof(ts_inf_pcap_path),
+				     "pcap_ts_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_test_pcap(ts_inf_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", ts_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_ts_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_ts_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with timestamp offload enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with timestamps");
+
+	/* Read packets */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				if (mbuf_has_timestamp(mbufs[i])) {
+					rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+
+					if (ts_count == 0)
+						first_ts = ts;
+					last_ts = ts;
+					ts_count++;
+				}
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_ts_inf");
+	remove_temp_file(ts_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(ts_count, total_rx,
+			  "Timestamp missing: only %u/%u packets have timestamps",
+			  ts_count, total_rx);
+
+	/* Timestamps should be monotonically increasing (current time) */
+	TEST_ASSERT(last_ts >= first_ts,
+		    "Timestamps not monotonic: first=%" PRIu64 " last=%" PRIu64,
+		    first_ts, last_ts);
+
+	printf("Timestamp infinite RX PASSED: %u packets with valid timestamps\n", total_rx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	/* Cleanup shared temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_lsc_iface),
+		TEST_CASE(test_eof_rx),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_vlan_offload_set),
+		TEST_CASE(test_vlan_strip_infinite_rx),
+		TEST_CASE(test_timestamp_infinite_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASE(test_snaplen_truncation_multiseg),
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index aa95b5885c..3b59adfdb2 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -115,6 +115,7 @@ New Features
   * Added support for Link State interrupt in ``iface`` mode.
   * Added ``eof`` devarg to use link state to signal end of receive
     file input.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

Re: [PATCH v18 02/23] net/pcap: fix build on Windows

[fengchengwen]

Acked-by: Chengwen Feng <fengchengwen@huawei.com>

On 3/1/2026 10:05 AM, Stephen Hemminger wrote:
> The log messages in the pcap OS dependent code for Windows
> was never converted during the last release.
> 
> It looks like the osdep part of pcap was not being built.
> Building requires have libpcap for Windows built which is not
> part of the CI infrastructure.
> 
> Fixes: 2b843cac232e ("drivers: use per line logging in helpers")
> Cc: stable@dpdk.org
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>

Re: [PATCH v18 02/23] net/pcap: fix build on Windows

[David Marchand]

On Sun, 1 Mar 2026 at 03:07, Stephen Hemminger
<stephen@networkplumber.org> wrote:
>
> The log messages in the pcap OS dependent code for Windows
> was never converted during the last release.
>
> It looks like the osdep part of pcap was not being built.
> Building requires have libpcap for Windows built which is not
> part of the CI infrastructure.
>
> Fixes: 2b843cac232e ("drivers: use per line logging in helpers")
> Cc: stable@dpdk.org
>
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>

Acked-by: David Marchand <david.marchand@redhat.com>


-- 
David Marchand

[PATCH v19 00/24] net/pcap: fixes, test, and enhancements

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx (via tx_prepare) and stripping on Rx
  - Runtime VLAN offload configuration via vlan_offload_set callback
  - Nanosecond precision timestamps (when libpcap supports it)
  - Link state reporting in interface mode
  - Link status change (LSC) interrupt support in interface mode
  - EOF notification via link status change for rx_pcap mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snaplen devarg
  - Rx scatter offload support with mbuf pool validation

Bug fixes:
  - Fix build on Windows from RTE_LOG_LINE changes.
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Fix Tx burst error handling: distinguish malformed mbufs (counted
    as errors) from pcap_sendpacket backpressure (break and retry)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback
  - Fix infinite_rx ring fill applying VLAN strip and timestamp
    offloads to template packets, preventing those offloads from
    working correctly during packet delivery

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables

Testing:
  - Add comprehensive unit test suite covering basic file I/O,
    timestamps, jumbo frames, VLAN strip/insert, multi-queue,
    scatter receive, snaplen, EOF notification, and link status
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows
  - Tests use packet_burst_generator for standardized test packet
    creation

v19:
  - Restore Rx scatter offload patch
  - minor fix to tx_burst

v18:
  - Move VLAN insert from tx burst path to tx_prepare callback,
    consistent with virtio and af_packet driver patterns
  - Simplify link status patch to just report UP/DOWN state;
    remove speed and duplex querying that had cross-platform
    portability issues (FreeBSD ifmedia_baudrate not available
    in userspace, Windows GetIfEntry2 linking issues)
  - Fix test_vlan_insert_tx to call rte_eth_tx_prepare() before
    rte_eth_tx_burst() to match the new tx_prepare VLAN insert
    implementation

Stephen Hemminger (24):
  maintainers: update for pcap driver
  net/pcap: fix build on Windows
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: advertise Tx multi segment
  net/pcap: replace stack bounce buffer
  net/pcap: fix error accounting and backpressure on transmit
  net/pcap: add datapath debug logging
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN strip and insert offloads
  net/pcap: add link status for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  eal/windows: add wrapper for access function
  net/pcap: add snapshot length devarg
  net/pcap: add Rx scatter offload
  net/pcap: add link status change support for iface mode
  net/pcap: add EOF notification via link status change
  test: add comprehensive test suite for pcap PMD


Stephen Hemminger (25):
  maintainers: update for pcap driver
  net/pcap: fix build on Windows
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: advertise Tx multi segment
  net/pcap: replace stack bounce buffer
  net/pcap: fix error accounting and backpressure on transmit
  net/pcap: add datapath debug logging
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN strip and insert offloads
  net/pcap: add link status for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  eal/windows: add wrapper for access function
  net/pcap: add snapshot length devarg
  net/pcap: add Rx scatter offload
  net/pcap: add link status change support for iface mode
  net/pcap: add EOF notification via link status change
  test: add comprehensive test suite for pcap PMD
  check patch warn in test

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3755 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    9 +
 doc/guides/nics/pcap.rst               |   48 +
 doc/guides/rel_notes/release_26_03.rst |   12 +
 drivers/net/pcap/pcap_ethdev.c         |  850 ++++--
 drivers/net/pcap/pcap_osdep.h          |   27 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   43 +-
 drivers/net/pcap/pcap_osdep_linux.c    |   33 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   76 +-
 lib/eal/windows/include/rte_os_shim.h  |    1 +
 lib/eal/windows/include/unistd.h       |    7 +
 13 files changed, 4643 insertions(+), 221 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v19 01/25] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 5eb8e9dc22..a8e375ddab 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1116,6 +1116,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v19 02/25] net/pcap: fix build on Windows

[Stephen Hemminger]

The log messages in the pcap OS dependent code for Windows
was never converted during the last release.

It looks like the osdep part of pcap was not being built.
Building requires have libpcap for Windows built which is not
part of the CI infrastructure.

Fixes: 2b843cac232e ("drivers: use per line logging in helpers")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Chengwen Feng <fengchengwen@huawei.com>
Acked-by: David Marchand <david.marchand@redhat.com>
---
 drivers/net/pcap/pcap_osdep_windows.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..0965c2f5c9 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -53,7 +53,7 @@ osdep_iface_index_get(const char *device_name)
 
 	ret = GetAdapterIndex(adapter_name, &index);
 	if (ret != NO_ERROR) {
-		PMD_LOG(ERR, "GetAdapterIndex(%S) = %lu\n", adapter_name, ret);
+		PMD_LOG(ERR, "GetAdapterIndex(%S) = %lu", adapter_name, ret);
 		return -1;
 	}
 
@@ -75,20 +75,20 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
-		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
+		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
 		return -1;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
-		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
+		PMD_LOG(ERR, "Cannot allocate adapter address info");
 		return -1;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
-		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
+		PMD_LOG(ERR, "GetAdapterAddresses() = %lu", sys_ret);
 		free(info);
 		return -1;
 	}
-- 
2.51.0

[PATCH v19 03/25] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..c4f0360a06 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
+Windows              = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v19 04/25] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v19 05/25] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..fbd1021c39 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v19 06/25] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd1021c39..806451dc99 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v19 07/25] net/pcap: advertise Tx multi segment

[Stephen Hemminger]

The driver supports multi-segment transmit, but the did not set
the offload flag. Therefore applications would not know about
that capability.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 806451dc99..fedf461be4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -753,6 +753,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v19 08/25] net/pcap: replace stack bounce buffer

[Stephen Hemminger]

Replace the 64K stack-allocated bounce buffer with a per-queue
buffer allocated from hugepages via rte_malloc at queue setup.
This is necessary because the buffer may be used in a secondary
process transmit path where the primary process allocated it.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 60 +++++++++++++++++++++-------------
 1 file changed, 37 insertions(+), 23 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fedf461be4..72a297d423 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -91,6 +91,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -385,18 +388,17 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -404,12 +406,11 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len, caplen;
+
+		len = rte_pktmbuf_pkt_len(mbuf);
+		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
@@ -449,9 +450,6 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
 	for (i = 0; i < nb_pkts; i++) {
 		tx_bytes += bufs[i]->pkt_len;
 		rte_pktmbuf_free(bufs[i]);
@@ -460,7 +458,7 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -470,30 +468,30 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		int ret;
+
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
+				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
+				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
@@ -966,7 +964,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -974,11 +972,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1019,6 +1032,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
-- 
2.51.0

[PATCH v19 09/25] net/pcap: fix error accounting and backpressure on transmit

[Stephen Hemminger]

The error handling when pcap_sendpacket() was incorrect.
When underlying kernel socket buffer got full the send was counted as
an error. Malformed multi-segment mbufs where pkt_len exceeds actual
data were silently accepted.

On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
The send() call only blocks when the kernel socket send buffer is full,
providing limited backpressure. Backpressure is not an error.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 58 +++++++++++++++++++++-------------
 1 file changed, 36 insertions(+), 22 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 72a297d423..47a050df11 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -407,7 +407,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len, caplen;
+		uint32_t len, caplen;
+		const uint8_t *data;
 
 		len = rte_pktmbuf_pkt_len(mbuf);
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
@@ -415,15 +416,16 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+
+		/* This could only happen if mbuf is bogus pkt_len > data_len */
+		RTE_ASSERT(data != NULL);
+		pcap_dump((u_char *)dumper, &header, data);
 
 		num_tx++;
 		tx_bytes += caplen;
+
 		rte_pktmbuf_free(mbuf);
 	}
 
@@ -435,9 +437,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	pcap_dump_flush(dumper);
 	dumper_q->tx_stat.pkts += num_tx;
 	dumper_q->tx_stat.bytes += tx_bytes;
-	dumper_q->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return nb_pkts;
+	return i;
 }
 
 /*
@@ -462,7 +463,17 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 }
 
 /*
- * Callback to handle sending packets through a real NIC.
+ * Send a burst of packets to a pcap device.
+ *
+ * On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
+ * socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
+ * The send() call only blocks when the kernel socket send buffer is full,
+ * providing limited backpressure.
+ *
+ * On error, pcap_sendpacket() returns non-zero and the loop breaks,
+ * leaving remaining packets unsent.
+ *
+ * Bottom line: backpressure is not an error.
  */
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
@@ -484,34 +495,37 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len = rte_pktmbuf_pkt_len(mbuf);
-		int ret;
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		const uint8_t *data;
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
+		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		RTE_ASSERT(data != NULL);
+
+		/*
+		 * No good way to separate back pressure from failure here
+		 * Assume it is EBUSY, ENOMEM, or EINTR, something that can be retried.
 		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
+		if (pcap_sendpacket(pcap, data, len) != 0) {
+			PMD_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
 			break;
+		}
 		num_tx++;
 		tx_bytes += len;
+
 		rte_pktmbuf_free(mbuf);
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
 
 	return i;
 }
-- 
2.51.0

[PATCH v19 10/25] net/pcap: add datapath debug logging

[Stephen Hemminger]

Add datapath debug logging macros (PMD_RX_LOG, PMD_TX_LOG) gated
on RTE_ETHDEV_DEBUG_RX/TX. Use PMD_TX_LOG in transmit error paths
to aid debugging without impacting normal datapath performance.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c |  2 +-
 drivers/net/pcap/pcap_osdep.h  | 14 ++++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 47a050df11..258cffb813 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -499,7 +499,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		const uint8_t *data;
 
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
-			PMD_LOG(ERR,
+			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			tx_queue->tx_stat.err_pkts++;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..fe7399ff9f 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,6 +13,20 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+#ifdef RTE_ETHDEV_DEBUG_RX
+#define PMD_RX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() rx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_RX_LOG(...) do { } while (0)
+#endif
+
+#ifdef RTE_ETHDEV_DEBUG_TX
+#define PMD_TX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() tx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_TX_LOG(...) do { } while (0)
+#endif
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
-- 
2.51.0

[PATCH v19 11/25] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 258cffb813..c3270a676c 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -102,9 +103,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -114,25 +115,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -884,7 +885,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1209,29 +1210,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1507,7 +1498,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1546,9 +1537,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1698,5 +1689,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.51.0

[PATCH v19 12/25] net/pcap: support VLAN strip and insert offloads

[Stephen Hemminger]

Add VLAN tag handling to the pcap PMD, consistent with how virtio
and af_packet drivers implement it. This also gets used for
capture of VLAN tagged packets when legacy pdump is used.

RX strip: when RTE_ETH_RX_OFFLOAD_VLAN_STRIP is enabled, the driver
calls rte_vlan_strip() on received packets in both normal and
infinite_rx modes. For infinite_rx, offloads are deferred to
packet delivery rather than applied during ring fill, so the
stored template packets remain unmodified.

TX insert: when RTE_MBUF_F_TX_VLAN is set on an mbuf, the driver
inserts the VLAN tag via rte_vlan_insert() before writing to pcap
or sending to the interface. Indirect or shared mbufs get a new
header mbuf to avoid modifying the original.

Runtime reconfiguration is supported through vlan_offload_set,
which propagates the strip setting to all active RX queues.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/nics/pcap.rst               | 11 +++
 doc/guides/rel_notes/release_26_03.rst |  5 ++
 drivers/net/pcap/pcap_ethdev.c         | 96 ++++++++++++++++++++++++--
 4 files changed, 109 insertions(+), 4 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index c4f0360a06..ec7c91c650 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -9,6 +9,7 @@ Queue start/stop     = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index fbfe854bb1..bed5006a42 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -247,3 +247,14 @@ will be discarded by the Rx flushing operation.
    The network interface provided to the PMD should be up.
    The PMD will return an error if the interface is down,
    and the PMD itself won't change the status of the external network interface.
+
+Features and Limitations
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index b4499ec066..63f554878d 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -106,6 +106,11 @@ New Features
   Added handling of the key combination Control+L
   to clear the screen before redisplaying the prompt.
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
+
 Removed Items
 -------------
 
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index c3270a676c..c49ca7fa2b 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -76,6 +76,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -106,6 +107,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -270,7 +272,11 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		bufs[i]->data_len = pcap_buf->data_len;
 		bufs[i]->pkt_len = pcap_buf->pkt_len;
 		bufs[i]->port = pcap_q->port_id;
-		rx_bytes += pcap_buf->data_len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(bufs[i]);
+
+		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
 		rte_ring_enqueue(pcap_q->pkts, pcap_buf);
@@ -336,6 +342,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -382,6 +392,39 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+static uint16_t
+eth_pcap_tx_prepare(void *queue __rte_unused, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
+{
+	uint16_t nb_tx;
+	int error;
+
+	for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
+		struct rte_mbuf *m = tx_pkts[nb_tx];
+
+#ifdef RTE_LIBRTE_ETHDEV_DEBUG
+		error = rte_validate_tx_offload(m);
+		if (unlikely(error)) {
+			rte_errno = -error;
+			break;
+		}
+#endif
+		/* Do VLAN tag insertion */
+		if (unlikely(m->ol_flags & RTE_MBUF_F_TX_VLAN)) {
+			error = rte_vlan_insert(&m);
+
+			/* rte_vlan_insert() could change pointer (currently does not) */
+			tx_pkts[nb_tx] = m;
+
+			if (unlikely(error != 0)) {
+				PMD_TX_LOG(ERR, "rte_vlan_insert failed: %s", strerror(-error));
+				rte_errno = -error;
+				break;
+			}
+		}
+	}
+	return nb_tx;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -415,6 +458,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -496,9 +540,10 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t len;
 		const uint8_t *data;
 
+		len = rte_pktmbuf_pkt_len(mbuf);
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
@@ -749,8 +794,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -766,7 +816,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -913,6 +965,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
@@ -922,6 +975,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		uint64_t pcap_pkt_count = 0;
 		struct rte_mbuf *bufs[1];
 		pcap_t **pcap;
+		bool save_vlan_strip;
 
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
@@ -941,11 +995,20 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		if (!pcap_q->pkts)
 			return -ENOENT;
 
+		/*
+		 * Temporarily disable offloads while filling the ring
+		 * with raw packets. VLAN strip and timestamp will be
+		 * applied later in eth_pcap_rx_infinite() on each copy.
+		 */
+		save_vlan_strip = pcap_q->vlan_strip;
+		pcap_q->vlan_strip = false;
+
 		/* Fill ring with packets from PCAP file one by one. */
 		while (eth_pcap_rx(pcap_q, bufs, 1)) {
 			/* Check for multiseg mbufs. */
 			if (bufs[0]->nb_segs != 1) {
 				infinite_rx_ring_free(pcap_q->pkts);
+				pcap_q->vlan_strip = save_vlan_strip;
 				PMD_LOG(ERR,
 					"Multiseg mbufs are not supported in infinite_rx mode.");
 				return -EINVAL;
@@ -955,6 +1018,9 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 					(void * const *)bufs, 1, NULL);
 		}
 
+		/* Restore offloads for use during packet delivery */
+		pcap_q->vlan_strip = save_vlan_strip;
+
 		if (rte_ring_count(pcap_q->pkts) < pcap_pkt_count) {
 			infinite_rx_ring_free(pcap_q->pkts);
 			PMD_LOG(ERR,
@@ -1039,6 +1105,26 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	unsigned int i;
+
+	if (mask & RTE_ETH_VLAN_STRIP_MASK) {
+		bool vlan_strip = !!(dev->data->dev_conf.rxmode.offloads &
+				     RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+
+		internals->vlan_strip = vlan_strip;
+
+		/* Update all RX queues */
+		for (i = 0; i < dev->data->nb_rx_queues; i++)
+			internals->rx_queue[i].vlan_strip = vlan_strip;
+	}
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1055,6 +1141,7 @@ static const struct eth_dev_ops ops = {
 	.link_update = eth_link_update,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.vlan_offload_set = eth_vlan_offload_set,
 };
 
 static int
@@ -1395,6 +1482,7 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		eth_dev->rx_pkt_burst = eth_null_rx;
 
 	/* Assign tx ops. */
+	eth_dev->tx_pkt_prepare = eth_pcap_tx_prepare;
 	if (devargs_all->is_tx_pcap)
 		eth_dev->tx_pkt_burst = eth_pcap_tx_dumper;
 	else if (devargs_all->is_tx_iface || single_iface)
-- 
2.51.0

[PATCH v19 13/25] net/pcap: add link status for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent function to query the real link state from
the underlying interface.

Linux and FreeBSD use SIOCGIFFLAGS to check IFF_UP and
IFF_RUNNING. Windows uses GetAdaptersAddresses() to check
OperStatus.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 38 +++++++++-----
 drivers/net/pcap/pcap_osdep.h          | 12 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  | 31 ++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 27 ++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  | 68 +++++++++++++++++++++-----
 6 files changed, 154 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 63f554878d..f117c4975e 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -109,6 +109,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index c49ca7fa2b..232b8fa4b1 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -150,13 +150,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -945,10 +938,28 @@ eth_dev_close(struct rte_eth_dev *dev)
 }
 
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link link = {
+		.link_speed = RTE_ETH_SPEED_NUM_10G,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
+
+	/*
+	 * For pass-through mode (single_iface), query whether the
+	 * underlying interface is up. Otherwise use default values.
+	 */
+	if (internals->single_iface) {
+		link.link_status = (osdep_iface_link_status(internals->rx_queue[0].name) > 0) ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	} else {
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1363,7 +1374,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index fe7399ff9f..18e63c6f2b 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -10,6 +10,7 @@
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
+
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
@@ -30,4 +31,15 @@ extern int eth_pcap_logtype;
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link status for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @return
+ *   1 if link is up, 0 if link is down, -1 on error.
+ */
+int osdep_iface_link_status(const char *name);
+
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..9c4186aadc 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,8 +5,13 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
@@ -55,3 +60,29 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_status(const char *if_name)
+{
+	struct ifmediareq ifmr;
+	int fd, status = 0;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd == -1)
+		return -1;
+
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* IFM_AVALID means status is valid, IFM_ACTIVE means link up */
+		if ((ifmr.ifm_status & IFM_AVALID) &&
+		    (ifmr.ifm_status & IFM_ACTIVE))
+			status = 1;
+	} else {
+		status = -1;
+	}
+
+	close(fd);
+	return status;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..f61b7bd146 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -40,3 +40,30 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+int
+osdep_iface_link_status(const char *if_name)
+{
+	struct ifreq ifr;
+	int fd, status = 0;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd == -1)
+		return -1;
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up.
+		 * IFF_RUNNING means operationally up (carrier detected).
+		 * Both must be set for link to be considered up.
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			status = 1;
+	} else {
+		status = -1;
+	}
+
+	close(fd);
+	return status;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 0965c2f5c9..e7a49c47e0 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,29 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_status(const char *device_name)
+{
+	IP_ADAPTER_ADDRESSES *info, *cur;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			ret = (cur->OperStatus == IfOperStatusUp) ? 1 : 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v19 14/25] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Add read_clock dev_op returning current UTC time for timestamp
  correlation.
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper.
* Enable immediate mode and improve error reporting
  in live capture setup.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |   3 +
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 156 +++++++++++++++++++------
 3 files changed, 126 insertions(+), 34 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index bed5006a42..2709c6d017 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -258,3 +258,6 @@ Features and Limitations
 *  The PMD will transparently insert a VLAN tag to transmitted packets if
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
+
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index f117c4975e..494cd78f9f 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -110,6 +110,7 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state in ``iface`` mode.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 232b8fa4b1..6b728c6009 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -27,13 +27,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -77,6 +75,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -108,6 +107,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -269,6 +269,15 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(bufs[i]);
 
+		if (pcap_q->timestamp_offloading) {
+			struct timespec ts;
+
+			timespec_get(&ts, TIME_UTC);
+			*RTE_MBUF_DYNFIELD(bufs[i], timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(&ts);
+			bufs[i]->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
@@ -339,10 +348,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -362,14 +382,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -440,8 +465,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
@@ -450,8 +477,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		len = rte_pktmbuf_pkt_len(mbuf);
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -573,22 +598,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
+
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
+	}
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -635,7 +700,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -794,6 +860,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -811,7 +878,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -978,6 +1046,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1116,6 +1185,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static int
 eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
 {
@@ -1142,6 +1222,7 @@ static const struct eth_dev_ops ops = {
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1558,15 +1639,22 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		hz = rte_get_timer_hz();
+		if (hz == 0) {
+			PMD_LOG(ERR, "Reported hz is zero!");
+			return -1;
+		}
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							 &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v19 15/25] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 6b728c6009..b9e828f5a4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -642,6 +642,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.51.0

[PATCH v19 16/25] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index b9e828f5a4..8be3a59690 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -46,11 +46,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -600,6 +598,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -711,6 +710,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1459,6 +1460,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v19 17/25] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 8be3a59690..20e4b8e6aa 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -54,10 +54,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -901,11 +901,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v19 18/25] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 20e4b8e6aa..2ffbce2448 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -884,10 +884,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v19 19/25] eal/windows: add wrapper for access function

[Stephen Hemminger]

Like other Posix functions in unistd.h add wrapper
using the Windows equivalent.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 lib/eal/windows/include/rte_os_shim.h | 1 +
 lib/eal/windows/include/unistd.h      | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/lib/eal/windows/include/rte_os_shim.h b/lib/eal/windows/include/rte_os_shim.h
index f16b2230c8..44664a5062 100644
--- a/lib/eal/windows/include/rte_os_shim.h
+++ b/lib/eal/windows/include/rte_os_shim.h
@@ -33,6 +33,7 @@
 #define unlink(path) _unlink(path)
 #define fileno(f) _fileno(f)
 #define isatty(fd) _isatty(fd)
+#define access(path, mode) _access(path, mode)
 
 #define IPVERSION	4
 
diff --git a/lib/eal/windows/include/unistd.h b/lib/eal/windows/include/unistd.h
index 78150c6480..f95888f4e1 100644
--- a/lib/eal/windows/include/unistd.h
+++ b/lib/eal/windows/include/unistd.h
@@ -23,4 +23,11 @@
 #define STDERR_FILENO _fileno(stderr)
 #endif
 
+/* Mode values for the _access() function.  */
+#ifndef F_OK
+#define	F_OK		0	/* test for existence of file */
+#define	W_OK		0x02	/* test for write permission */
+#define	R_OK		0x04	/* test for read permission */
+#endif
+
 #endif /* _UNISTD_H_ */
-- 
2.51.0

[PATCH v19 20/25] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

The snaplen argument is parsed before interface and file arguments
so that its value is available when pcap handles are opened during
device creation.

Example usage:
  --vdev 'net_pcap0,snaplen=1518,iface=eth0'
  --vdev 'net_pcap0,snaplen=9000,rx_pcap=in.pcap,tx_pcap=out.pcap'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |  17 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 211 ++++++++++++++++---------
 3 files changed, 158 insertions(+), 71 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2709c6d017..2754e205c7 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -15,6 +15,23 @@ For more information about the pcap library, see the
    The pcap-based PMD requires the libpcap development files to be installed.
    This applies to all supported operating systems: Linux, FreeBSD, and Windows.
 
+* Set the snapshot length for packet capture
+
+  The snapshot length controls the maximum number of bytes captured per packet.
+  This affects both interface capture and pcap file output.  The default value is
+  65535 bytes, which captures complete packets up to the maximum Ethernet jumbo
+  frame size.  Reducing this value can improve performance when only packet headers
+  are needed.
+
+  The ``snaplen`` argument is used when opening capture handles, so it should
+  be specified before the interface or file arguments.  Example::
+
+     --vdev 'net_pcap0,snaplen=1518,iface=eth0'
+     --vdev 'net_pcap0,snaplen=9000,rx_pcap=in.pcap,tx_pcap=out.pcap'
+
+  The snapshot length also determines the reported ``max_rx_pktlen``
+  and ``max_mtu`` in device info.
+
 
 Using the Driver from the EAL Command Line
 ------------------------------------------
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 494cd78f9f..49e2c0cf2b 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -111,6 +111,7 @@ New Features
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state in ``iface`` mode.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2ffbce2448..8a2b5c1b4b 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -13,6 +13,8 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <unistd.h>
+
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -31,8 +33,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -41,6 +41,12 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
+
+/* This is defined in libpcap but not exposed in headers */
+#define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -101,6 +107,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -119,15 +126,18 @@ struct pmd_devargs {
 	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
+		/* pcap and name/type fields... */
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
+	uint32_t snapshot_len;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -145,6 +155,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
@@ -447,20 +458,19 @@ eth_pcap_tx_prepare(void *queue __rte_unused, struct rte_mbuf **tx_pkts, uint16_
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -473,7 +483,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		const uint8_t *data;
 
 		len = rte_pktmbuf_pkt_len(mbuf);
-		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+		caplen = RTE_MIN(len, snaplen);
 
 		header.len = len;
 		header.caplen = caplen;
@@ -539,33 +549,35 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_process_private *pp = dev->process_private;
+	struct pmd_internals *internals = dev->data->dev_private;
+	uint32_t snaplen = internals->snapshot_len;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		uint32_t len;
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
 
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		/*
+		 * multi-segment transmit that has to go through bounce buffer.
+		 * Make sure it fits; don't want to truncate the packet.
+		 */
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > snaplen)) {
 			PMD_TX_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
-				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
-			tx_queue->tx_stat.err_pkts++;
+				   "Multi segment len (%u) > snaplen (%u)",
+				   len, snaplen);
 			rte_pktmbuf_free(mbuf);
+			tx_queue->tx_stat.err_pkts++;
 			continue;
 		}
 
@@ -582,7 +594,6 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 		num_tx++;
 		tx_bytes += len;
-
 		rte_pktmbuf_free(mbuf);
 	}
 
@@ -596,7 +607,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -613,6 +624,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
 			iface, pcap_statustostr(status));
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	status = pcap_set_immediate_mode(pc, 1);
@@ -625,7 +639,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -639,6 +653,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -667,9 +684,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -678,7 +695,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -688,7 +706,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -697,9 +715,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -741,6 +759,21 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+static int
+set_iface_direction(const char *iface, pcap_t *pcap,
+		pcap_direction_t direction)
+{
+	const char *direction_str = (direction == PCAP_D_IN) ? "IN" : "OUT";
+	if (pcap_setdirection(pcap, direction) < 0) {
+		PMD_LOG(ERR, "Setting %s pcap direction %s failed - %s",
+				iface, direction_str, pcap_geterr(pcap));
+		return -1;
+	}
+	PMD_LOG(INFO, "Setting %s pcap direction %s",
+			iface, direction_str);
+	return 0;
+}
+
 static int
 eth_dev_start(struct rte_eth_dev *dev)
 {
@@ -749,15 +782,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
 		rx = &internals->rx_queue[0];
 
-		if (!pp->tx_pcap[0] &&
-			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+		if (!pp->tx_pcap[0] && strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -769,14 +802,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -791,9 +821,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -884,11 +919,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1146,7 +1181,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1298,7 +1333,8 @@ open_tx_pcap(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *dumpers = extra_args;
 	pcap_dumper_t *dumper;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	if (open_single_tx_pcap(pcap_filename, &dumper,
+				dumpers->snapshot_len) < 0)
 		return -1;
 
 	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
@@ -1319,7 +1355,7 @@ open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *tx = extra_args;
 	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (open_single_iface(iface, &pcap, tx->snapshot_len) < 0)
 		return -1;
 
 	tx->queue[0].pcap = pcap;
@@ -1329,21 +1365,6 @@ open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
-static inline int
-set_iface_direction(const char *iface, pcap_t *pcap,
-		pcap_direction_t direction)
-{
-	const char *direction_str = (direction == PCAP_D_IN) ? "IN" : "OUT";
-	if (pcap_setdirection(pcap, direction) < 0) {
-		PMD_LOG(ERR, "Setting %s pcap direction %s failed - %s",
-				iface, direction_str, pcap_geterr(pcap));
-		return -1;
-	}
-	PMD_LOG(INFO, "Setting %s pcap direction %s",
-			iface, direction_str);
-	return 0;
-}
-
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
@@ -1351,7 +1372,7 @@ open_iface(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *pmd = extra_args;
 	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (open_single_iface(iface, &pcap, pmd->snapshot_len) < 0)
 		return -1;
 	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
 		pcap_close(pcap);
@@ -1419,6 +1440,31 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN ||
+	    val > ETH_PCAP_MAXIMUM_SNAPLEN) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1583,6 +1629,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1644,6 +1692,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1690,6 +1739,25 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 			return -1;
 	}
 
+	/*
+	 * Process optional snapshot length argument first, so the value
+	 * is available when opening pcap handles for files and interfaces.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+	/*
+	 * Propagate snapshot length to per-queue devargs so that
+	 * the open callbacks can access it.
+	 */
+	devargs_all.rx_queues.snapshot_len = devargs_all.snapshot_len;
+	devargs_all.tx_queues.snapshot_len = devargs_all.snapshot_len;
+
 	/*
 	 * If iface argument is passed we open the NICs and use them for
 	 * reading / writing
@@ -1896,4 +1964,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v19 21/25] net/pcap: add Rx scatter offload

[Stephen Hemminger]

Add RTE_ETH_RX_OFFLOAD_SCATTER to the advertised receive offload
capabilities. Validate in rx_queue_setup that the mbuf pool data
room is large enough when scatter is not enabled, following the
same pattern as the virtio driver.

Gate the multi-segment receive path on the scatter offload flag
and drop oversized packets when scatter is disabled.
Reject scatter with infinite_rx mode since the ring-based replay
path does not support multi-segment mbufs.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 47 +++++++++++++++++++++++++++++++---
 1 file changed, 44 insertions(+), 3 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 8a2b5c1b4b..d8a924b0cd 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -79,6 +79,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool rx_scatter;
 	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
@@ -112,6 +113,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool rx_scatter;
 	bool timestamp_offloading;
 };
 
@@ -342,14 +344,19 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			/* pcap packet will fit in the mbuf, can copy it */
 			rte_memcpy(rte_pktmbuf_mtod(mbuf, void *), packet, len);
 			mbuf->data_len = len;
-		} else {
-			/* Try read jumbo frame into multi mbufs. */
+		} else if (pcap_q->rx_scatter) {
+			/* Scatter into multi-segment mbufs. */
 			if (unlikely(eth_pcap_rx_jumbo(pcap_q->mb_pool,
 						       mbuf, packet, len) == -1)) {
 				pcap_q->rx_stat.err_pkts++;
 				rte_pktmbuf_free(mbuf);
 				break;
 			}
+		} else {
+			/* Packet too large and scatter not enabled, drop it. */
+			pcap_q->rx_stat.err_pkts++;
+			rte_pktmbuf_free(mbuf);
+			continue;
 		}
 
 		mbuf->pkt_len = len;
@@ -907,6 +914,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->rx_scatter = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_SCATTER);
 	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
@@ -927,7 +935,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP |
+		RTE_ETH_RX_OFFLOAD_SCATTER;
 
 	return 0;
 }
@@ -1088,11 +1097,37 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 {
 	struct pmd_internals *internals = dev->data->dev_private;
 	struct pcap_rx_queue *pcap_q = &internals->rx_queue[rx_queue_id];
+	uint16_t buf_size;
+	bool rx_scatter;
+
+	buf_size = rte_pktmbuf_data_room_size(mb_pool) - RTE_PKTMBUF_HEADROOM;
+	rx_scatter = !!(dev->data->dev_conf.rxmode.offloads &
+			RTE_ETH_RX_OFFLOAD_SCATTER);
+
+	/*
+	 * If Rx scatter is not enabled, verify that the mbuf data room
+	 * can hold the largest received packet in a single segment.
+	 * Use the MTU-derived frame size as the expected maximum, not
+	 * snapshot_len which is a capture truncation limit rather than
+	 * an expected packet size.
+	 */
+	if (!rx_scatter) {
+		uint32_t max_rx_pktlen = dev->data->mtu + RTE_ETHER_HDR_LEN;
+
+		if (max_rx_pktlen > buf_size) {
+			PMD_LOG(ERR,
+				"Rx scatter is disabled and RxQ mbuf pool object size is too small "
+				"(buf_size=%u, max_rx_pkt_len=%u)",
+				buf_size, max_rx_pktlen);
+			return -EINVAL;
+		}
+	}
 
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
+	pcap_q->rx_scatter = rx_scatter;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
@@ -1105,6 +1140,12 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		pcap_t **pcap;
 		bool save_vlan_strip;
 
+		if (rx_scatter) {
+			PMD_LOG(ERR,
+				"Rx scatter is not supported with infinite_rx mode");
+			return -EINVAL;
+		}
+
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
 
-- 
2.51.0

[PATCH v19 22/25] net/pcap: add link status change support for iface mode

[Stephen Hemminger]

Add LSC interrupt support for pass-through (iface=) mode so
applications can receive link state change notifications via
the standard ethdev callback mechanism.

Uses alarm-based polling to periodically check the underlying
interface state via osdep_iface_link_get(). The LSC flag is
advertised only for iface mode devices, and polling is gated
on the application enabling intr_conf.lsc in port configuration.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/nics/pcap.rst               |  5 +++
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 45 ++++++++++++++++++++++++++
 4 files changed, 52 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index ec7c91c650..b409ecd597 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -5,6 +5,7 @@
 ;
 [Features]
 Link status          = Y
+Link status event    = Y
 Queue start/stop     = Y
 Timestamp offload    = Y
 Basic stats          = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2754e205c7..72f2250790 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -278,3 +278,8 @@ Features and Limitations
 
 *  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
    UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
+
+*  In ``iface`` mode, the PMD supports link status change (LSC) notifications.
+   When the application enables ``intr_conf.lsc`` in the port configuration,
+   the driver polls the underlying network interface once per second and generates an
+   ``RTE_ETH_EVENT_INTR_LSC`` callback when the link state changes.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 49e2c0cf2b..c1bb808195 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -112,6 +112,7 @@ New Features
   * Added support for reporting link state in ``iface`` mode.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added support for Link State interrupt in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index d8a924b0cd..2d64032474 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -17,6 +17,7 @@
 
 #include <pcap.h>
 
+#include <rte_alarm.h>
 #include <rte_cycles.h>
 #include <rte_ring.h>
 #include <rte_ethdev.h>
@@ -48,6 +49,8 @@
 /* This is defined in libpcap but not exposed in headers */
 #define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
+#define ETH_PCAP_LSC_POLL_INTERVAL_US (1000 * 1000) /* 1 second */
+
 #define ETH_PCAP_ARG_MAXLEN	64
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
@@ -115,6 +118,7 @@ struct pmd_internals {
 	bool vlan_strip;
 	bool rx_scatter;
 	bool timestamp_offloading;
+	bool lsc_active;
 };
 
 struct pmd_process_private {
@@ -163,6 +167,9 @@ static const char *valid_arguments[] = {
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declarations */
+static int eth_link_update(struct rte_eth_dev *dev, int wait_to_complete);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -766,6 +773,28 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+/*
+ * Periodic alarm to poll link state.
+ * Enabled when link state interrupt is enabled in single_iface mode.
+ */
+static void
+eth_pcap_lsc_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link old_link, new_link;
+
+	rte_eth_linkstatus_get(dev, &old_link);
+	eth_link_update(dev, 0);
+	rte_eth_linkstatus_get(dev, &new_link);
+
+	if (old_link.link_status != new_link.link_status)
+		rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+
+	if (internals->lsc_active)
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US, eth_pcap_lsc_alarm, dev);
+}
+
 static int
 set_iface_direction(const char *iface, pcap_t *pcap,
 		pcap_direction_t direction)
@@ -848,6 +877,13 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
+	/* Start LSC polling for iface mode if application requested it */
+	if (internals->single_iface && dev->data->dev_conf.intr_conf.lsc) {
+		internals->lsc_active = true;
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US,
+				  eth_pcap_lsc_alarm, dev);
+	}
+
 	return 0;
 }
 
@@ -865,6 +901,12 @@ eth_dev_stop(struct rte_eth_dev *dev)
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
+		/* Cancel LSC polling before closing pcap handles */
+		if (internals->lsc_active) {
+			internals->lsc_active = false;
+			rte_eal_alarm_cancel(eth_pcap_lsc_alarm, dev);
+		}
+
 		queue_missed_stat_on_stop_update(dev, 0);
 		if (pp->tx_pcap[0] != NULL) {
 			pcap_close(pp->tx_pcap[0]);
@@ -1661,6 +1703,9 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		internals->if_index =
 			osdep_iface_index_get(rx_queues->queue[0].name);
 
+		/* Enable LSC interrupt support for iface mode */
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 		/* phy_mac arg is applied only if "iface" devarg is provided */
 		if (rx_queues->phy_mac) {
 			if (eth_pcap_update_mac(rx_queues->queue[0].name,
-- 
2.51.0

[PATCH v19 23/25] net/pcap: add EOF notification via link status change

[Stephen Hemminger]

Add an "eof" devarg for rx_pcap mode that signals end-of-file by
setting link down and generating an LSC event. This allows
applications to detect when a pcap file has been fully consumed
using the standard ethdev callback mechanism.

The eof and infinite_rx options are mutually exclusive. On device
restart, the EOF state is reset so the file can be replayed.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               | 12 ++++
 doc/guides/rel_notes/release_26_03.rst |  2 +
 drivers/net/pcap/pcap_ethdev.c         | 80 +++++++++++++++++++++++++-
 3 files changed, 91 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 72f2250790..18a9a04652 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -161,6 +161,18 @@ Runtime Config Options
   so all queues on a device will either have this enabled or disabled.
   This option should only be provided once per device.
 
+* Signal end-of-file via link status change
+
+  In case ``rx_pcap=`` configuration is set, the user may want to be notified when
+  all packets in the pcap file have been read.  This can be done with the ``eof``
+  devarg, for example::
+
+     --vdev 'net_pcap0,rx_pcap=file_rx.pcap,eof=1'
+
+  When enabled, the driver sets link down and generates an LSC event at end of file.
+  If the device is stopped and restarted, the EOF state is reset.
+  This option cannot be combined with ``infinite_rx``.
+
 * Drop all packets on transmit
 
   To drop all packets on transmit for a device,
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index c1bb808195..aa95b5885c 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -113,6 +113,8 @@ New Features
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
   * Added support for Link State interrupt in ``iface`` mode.
+  * Added ``eof`` devarg to use link state to signal end of receive
+    file input.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2d64032474..feefcf922d 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -42,6 +42,7 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_EOF_ARG          "eof"
 #define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
 
 #define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
@@ -115,6 +116,8 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool eof;
+	RTE_ATOMIC(bool) eof_signaled;
 	bool vlan_strip;
 	bool rx_scatter;
 	bool timestamp_offloading;
@@ -150,6 +153,7 @@ struct pmd_devargs_all {
 	bool is_rx_pcap;
 	bool is_rx_iface;
 	bool infinite_rx;
+	bool eof;
 };
 
 static const char *valid_arguments[] = {
@@ -161,6 +165,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_EOF_ARG,
 	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
@@ -308,15 +313,33 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	return i;
 }
 
+/*
+ * Deferred EOF alarm callback.
+ *
+ * Scheduled from the RX burst path when end-of-file is reached,
+ * so that rte_eth_dev_callback_process() runs outside the datapath.
+ * This avoids holding any locks that the application callback
+ * might also need, preventing potential deadlocks.
+ */
+static void
+eth_pcap_eof_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+
+	rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+}
+
 static uint16_t
 eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
+	struct pcap_rx_queue *pcap_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[pcap_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
 	unsigned int i;
 	struct pcap_pkthdr *header;
 	struct pmd_process_private *pp;
 	const u_char *packet;
 	struct rte_mbuf *mbuf;
-	struct pcap_rx_queue *pcap_q = queue;
 	uint16_t num_rx = 0;
 	uint32_t rx_bytes = 0;
 	pcap_t *pcap;
@@ -337,6 +360,23 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			if (ret == PCAP_ERROR)
 				pcap_q->rx_stat.err_pkts++;
 
+			/*
+			 * EOF: if eof mode is enabled, set link down and
+			 * defer notification via alarm to avoid calling
+			 * rte_eth_dev_callback_process() from the datapath.
+			 */
+			else if (ret == PCAP_ERROR_BREAK) {
+				bool expected = false;
+
+				if (internals->eof &&
+				    rte_atomic_compare_exchange_strong_explicit(
+					    &internals->eof_signaled, &expected, true,
+					    rte_memory_order_relaxed, rte_memory_order_relaxed)) {
+					eth_link_update(dev, 0);
+					rte_eal_alarm_set(1, eth_pcap_eof_alarm, dev);
+				}
+			}
+
 			break;
 		}
 
@@ -875,6 +915,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++)
 		dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
 
+	rte_atomic_store_explicit(&internals->eof_signaled, false, rte_memory_order_relaxed);
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
 	/* Start LSC polling for iface mode if application requested it */
@@ -898,6 +939,7 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	unsigned int i;
 	struct pmd_internals *internals = dev->data->dev_private;
 	struct pmd_process_private *pp = dev->process_private;
+	bool expected;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
@@ -937,6 +979,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	}
 
 status_down:
+	/* Cancel any pending EOF alarm */
+	expected = true;
+	if (rte_atomic_compare_exchange_strong_explicit(
+		    &internals->eof_signaled, &expected, false,
+		    rte_memory_order_relaxed, rte_memory_order_relaxed))
+		rte_eal_alarm_cancel(eth_pcap_eof_alarm, dev);
+
 	for (i = 0; i < dev->data->nb_rx_queues; i++)
 		dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
 
@@ -1121,9 +1170,10 @@ eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 	if (internals->single_iface) {
 		link.link_status = (osdep_iface_link_status(internals->rx_queue[0].name) > 0) ?
 			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	} else if (rte_atomic_load_explicit(&internals->eof_signaled, rte_memory_order_relaxed)) {
+		link.link_status = RTE_ETH_LINK_DOWN;
 	} else {
-		link.link_status = dev->data->dev_started ?
-			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_status = dev->data->dev_started ? RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 	}
 
 	return rte_eth_linkstatus_set(dev, &link);
@@ -1715,8 +1765,13 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->eof = devargs_all->eof;
 	internals->snapshot_len = devargs_all->snapshot_len;
 
+	/* Enable LSC for eof mode (already set above for single_iface) */
+	if (internals->eof)
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1912,6 +1967,24 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 					"for %s", name);
 		}
 
+		/*
+		 * Check whether to signal EOF via link status change.
+		 */
+		if (rte_kvargs_count(kvlist, ETH_PCAP_EOF_ARG) == 1) {
+			ret = rte_kvargs_process(kvlist, ETH_PCAP_EOF_ARG,
+						 &process_bool_flag,
+						 &devargs_all.eof);
+			if (ret < 0)
+				goto free_kvlist;
+		}
+
+		if (devargs_all.infinite_rx && devargs_all.eof) {
+			PMD_LOG(ERR, "Cannot use both infinite_rx and eof for %s",
+				name);
+			ret = -EINVAL;
+			goto free_kvlist;
+		}
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
 				&open_rx_pcap, &pcaps);
 	} else if (devargs_all.is_rx_iface) {
@@ -2051,4 +2124,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_EOF_ARG "=<0|1> "
 	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v19 24/25] test: add comprehensive test suite for pcap PMD

[Stephen Hemminger]

Add unit tests for the pcap PMD covering file and interface modes.

Tests include:
  - basic TX to file and RX from file
  - varied packet sizes and jumbo frames
  - infinite RX mode
  - TX drop mode
  - statistics
  - interface (iface=) pass-through mode
  - link status reporting for file and iface modes
  - link status change (LSC) with interface toggle
  - EOF notification via LSC
  - RX timestamps and timestamp with infinite RX
  - multiple TX/RX queues
  - VLAN strip, insert, and runtime offload configuration
  - snapshot length (snaplen) and truncation

Cross-platform helpers handle temp file creation, interface
discovery, and VLAN packet generation.

The LSC link toggle test requires a pre-created dummy interface
(Linux: dummy0, FreeBSD: disc0) and is skipped if unavailable.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3755 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 3758 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index 5dde50b181..6ffcfc0ab3 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 # the NULL ethdev is used by a number of tests, in some cases as an optional dependency.
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..3b0a7e1348
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,3755 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define F_OK 0
+#define usleep(us) Sleep((us) / 1000 ? (us) / 1000 : 1)
+#else
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths shared between tests */
+static char tx_pcap_path[PATH_MAX];	/* test_tx_to_file -> test_rx_from_file */
+static char vlan_rx_pcap_path[PATH_MAX]; /* test_vlan_strip_rx -> test_vlan_no_strip_rx */
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port with custom config
+ */
+static int
+setup_pcap_port_conf(uint16_t port, const struct rte_eth_conf *conf)
+{
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port (default: timestamp offload)
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf with controlled segment size.
+ *
+ * Unlike alloc_jumbo_mbuf which fills segments to tailroom capacity,
+ * this limits each segment to seg_size bytes, guaranteeing that the
+ * resulting mbuf chain has multiple segments even for moderate pkt_len.
+ */
+static struct rte_mbuf *
+alloc_multiseg_mbuf(uint32_t pkt_len, uint16_t seg_size, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t this_len;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		this_len = RTE_MIN(remaining, seg_size);
+		this_len = RTE_MIN(this_len, rte_pktmbuf_tailroom(seg));
+		seg->data_len = this_len;
+
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, this_len);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= this_len;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+	int ret;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char varied_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+	remove_temp_file(varied_pcap_path);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char infinite_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+	int ret;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+	remove_temp_file(infinite_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+	int ret;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+	remove_temp_file(rx_pcap_path);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+	int ret;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path), "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char jumbo_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path), "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+
+	/* Jumbo frames require scatter to receive into multi-segment mbufs */
+	struct rte_eth_conf jumbo_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_SCATTER |
+				   RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &jumbo_conf) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+	remove_temp_file(jumbo_pcap_path);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	int ret;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+	remove_temp_file(rx_pcap_path);
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+static int
+test_lsc_iface(void)
+{
+	printf("  Link toggle test not supported on Windows, skipping\n");
+	return TEST_SKIPPED;
+}
+#else
+/*
+ * Test: Link Status Change (LSC) interrupt support
+ *
+ * Verifies that:
+ * 1. LSC capability is NOT advertised for file mode
+ * 2. LSC capability IS advertised for iface mode
+ * 3. LSC callback fires when the underlying interface goes down/up
+ *
+ * Requires a toggleable Ethernet interface created before running:
+ *   Linux:   ip link add dummy0 type dummy && ip link set dummy0 up
+ *   FreeBSD: ifconfig disc0 create && ifconfig disc0 up
+ *
+ * Skipped if no suitable interface is found or on Windows.
+ */
+
+/* Callback counter for LSC test */
+static volatile int lsc_callback_count;
+
+static int
+test_lsc_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	lsc_callback_count++;
+	return 0;
+}
+
+/*
+ * Helper: Set interface link up or down via ioctl.
+ * Returns 0 on success, -errno on failure.
+ */
+static int
+set_iface_up_down(const char *ifname, int up)
+{
+	struct ifreq ifr;
+	int fd, ret;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd < 0)
+		return -errno;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	ret = ioctl(fd, SIOCGIFFLAGS, &ifr);
+	if (ret < 0) {
+		ret = -errno;
+		close(fd);
+		return ret;
+	}
+
+	if (up)
+		ifr.ifr_flags |= IFF_UP;
+	else
+		ifr.ifr_flags &= ~IFF_UP;
+
+	ret = ioctl(fd, SIOCSIFFLAGS, &ifr);
+	if (ret < 0)
+		ret = -errno;
+	else
+		ret = 0;
+
+	close(fd);
+	return ret;
+}
+
+/*
+ * Helper: Find a toggleable test interface for LSC testing.
+ *
+ * Looks for well-known interfaces that are safe to bring up/down:
+ *   Linux:   dummy0 (ip link add dummy0 type dummy)
+ *   FreeBSD: disc0 (ifconfig disc0 create)
+ *
+ * Returns interface name or NULL if none found.
+ */
+static const char *
+find_lsc_test_iface(void)
+{
+	static const char *candidates[] = { "dummy0", "disc0" };
+	unsigned int i;
+
+	for (i = 0; i < RTE_DIM(candidates); i++) {
+		if (iface_is_ethernet(candidates[i]))
+			return candidates[i];
+	}
+	return NULL;
+}
+
+static int
+test_lsc_iface(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	int ret;
+
+	printf("Testing Link Status Change (LSC) support\n");
+
+	/*
+	 * Test 1: Verify LSC is NOT advertised for file mode
+	 */
+	printf("  Testing file mode does not advertise LSC\n");
+	{
+		char lsc_pcap_path[PATH_MAX];
+		uint16_t file_port_id;
+
+		TEST_ASSERT(create_temp_path(lsc_pcap_path, sizeof(lsc_pcap_path),
+					     "pcap_lsc") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(lsc_pcap_path, 1) == 0,
+			    "Failed to create test pcap");
+
+		ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", lsc_pcap_path);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		TEST_ASSERT(create_pcap_vdev("net_pcap_lsc_file", devargs,
+					     &file_port_id) == 0,
+			    "Failed to create file vdev");
+
+		ret = rte_eth_dev_info_get(file_port_id, &dev_info);
+		TEST_ASSERT(ret == 0, "Failed to get dev info");
+
+		TEST_ASSERT((*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC) == 0,
+			    "File mode should NOT advertise LSC capability");
+
+		rte_vdev_uninit("net_pcap_lsc_file");
+		remove_temp_file(lsc_pcap_path);
+		printf("  File mode LSC check PASSED\n");
+	}
+
+	struct rte_eth_link link;
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	uint16_t port_id;
+
+	/*
+	 * Test 2: Use a toggleable interface to test link change events.
+	 * Skip if not present.
+	 */
+	const char *lsc_iface = find_lsc_test_iface();
+	if (lsc_iface == NULL) {
+		printf("  No toggleable interface found, skipping link change test\n");
+		printf("  Linux:   ip link add dummy0 type dummy && ip link set dummy0 up\n");
+		printf("  FreeBSD: ifconfig disc0 create && ifconfig disc0 up\n");
+		return TEST_SUCCESS;
+	}
+
+	printf("  Testing iface mode LSC with: %s\n", lsc_iface);
+
+	/* Ensure interface is up before we start */
+	ret = set_iface_up_down(lsc_iface, 1);
+	if (ret != 0) {
+		printf("  Cannot set %s up (%s), skipping\n",
+		       lsc_iface, strerror(-ret));
+		return TEST_SUCCESS;
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", lsc_iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_lsc", devargs);
+	if (ret < 0) {
+		printf("  Cannot create iface vdev for %s, skipping\n", lsc_iface);
+		return TEST_SUCCESS;
+	}
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_lsc", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "Iface mode should advertise LSC capability");
+	printf("    LSC capability advertised: yes\n");
+
+	/* Register LSC callback */
+	lsc_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_lsc_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link status");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+	printf("    Link after start: UP\n");
+
+	/* Bring interface down - should trigger LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 0);
+	TEST_ASSERT(ret == 0, "Failed to set %s down: %s",
+		    lsc_iface, strerror(-ret));
+
+	/* Wait for at least one poll cycle (1 second interval) */
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after down");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after interface down");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired, count=%d",
+		    lsc_callback_count);
+	printf("    Interface down: link DOWN, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Bring it back up - should trigger another LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 1);
+	TEST_ASSERT(ret == 0, "Failed to set %s up: %s",
+		    lsc_iface, strerror(-ret));
+
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after up");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after interface up");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired on link restore, count=%d",
+		    lsc_callback_count);
+	printf("    Interface up: link UP, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Cleanup */
+	rte_eth_dev_stop(port_id);
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_lsc_callback, NULL);
+	rte_vdev_uninit("net_pcap_lsc");
+
+	printf("LSC test PASSED\n");
+	return TEST_SUCCESS;
+}
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Test: EOF notification via link status change
+ *
+ * Verifies that:
+ * 1. The eof devarg causes link down + LSC event at end of pcap file
+ * 2. link_get reports DOWN after EOF
+ * 3. Stop/start resets the EOF state and replays the file
+ * 4. The eof and infinite_rx options are mutually exclusive
+ */
+
+static volatile int eof_callback_count;
+
+static int
+test_eof_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	eof_callback_count++;
+	return 0;
+}
+
+static int
+test_eof_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	struct rte_eth_link link;
+	char eof_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx;
+	int ret;
+
+	printf("Testing EOF notification via link status change\n");
+
+	/* Create pcap file with known number of packets */
+	TEST_ASSERT(create_temp_path(eof_pcap_path, sizeof(eof_pcap_path),
+				     "pcap_eof") == 0,
+		    "Failed to create temp file path");
+	TEST_ASSERT(create_test_pcap(eof_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/*
+	 * Test 1: EOF triggers link down and LSC callback
+	 */
+	printf("  Testing EOF triggers link down and LSC event\n");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,eof=1",
+		       eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create eof vdev: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_eof", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	struct rte_eth_dev_info dev_info;
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "EOF mode should advertise LSC capability");
+
+	/* Register LSC callback */
+	eof_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_eof_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Drain all packets from the pcap file */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			/* Got all packets and rx returned 0 — EOF hit */
+			break;
+		}
+	}
+
+	printf("    Received %u packets (expected %d)\n", total_rx, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Should receive exactly %d packets", NUM_PACKETS);
+
+	/* Verify link went down */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after EOF");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after EOF");
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	/* Verify callback fired exactly once */
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "LSC callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    EOF signaled: link DOWN, callback fired\n");
+
+	/*
+	 * Test 2: Stop/start resets EOF and replays the file
+	 */
+	printf("  Testing restart replays pcap file\n");
+
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	eof_callback_count = 0;
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to restart port");
+
+	/* Verify link is up again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after restart");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after restart");
+
+	/* Read packets again */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			break;
+		}
+	}
+
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Restart: should receive %d packets, got %u",
+			  NUM_PACKETS, total_rx);
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "Restart: callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    Restart replay: %u packets, EOF signaled again\n", total_rx);
+
+	/* Cleanup */
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_eof_callback, NULL);
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_eof");
+
+	/*
+	 * Test 3: eof + infinite_rx is rejected
+	 */
+	printf("  Testing eof + infinite_rx mutual exclusion\n");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,eof=1,infinite_rx=1", eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof_bad", devargs);
+	TEST_ASSERT(ret != 0, "eof + infinite_rx should be rejected");
+	printf("    Mutual exclusion check PASSED\n");
+
+	remove_temp_file(eof_pcap_path);
+
+	printf("EOF test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char timestamp_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64
+			       " actual=%"PRIu64"\n", i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+	remove_temp_file(timestamp_pcap_path);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		remove_temp_file(multi_tx_pcap_paths[q]);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char multi_rx_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0,
+		    "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	remove_temp_file(multi_rx_pcap_path);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		       rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation with multi-segment mbufs
+ *
+ * This test verifies that the dumper path correctly truncates
+ * non-contiguous (multi-segment) mbufs when the total packet length
+ * exceeds the configured snaplen.  It exercises the RTE_MIN(len, snaplen)
+ * cap in the TX dumper by ensuring:
+ *
+ * 1. caplen in the pcap header equals snaplen (not pkt_len)
+ * 2. len in the pcap header preserves the original packet length
+ * 3. Truncation works when the snaplen boundary falls mid-chain
+ */
+static int
+test_snaplen_truncation_multiseg(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx;
+	unsigned int i, pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint32_t pkt_size = 300;
+	const uint16_t seg_size = 64;
+	const unsigned int num_pkts = 8;
+
+	printf("Testing snaplen truncation with multi-segment mbufs\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_trunc_ms") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		       tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	TEST_ASSERT(create_pcap_vdev("net_pcap_trunc_ms", devargs,
+				     &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/*
+	 * Allocate multi-segment mbufs.  With seg_size=64 and pkt_size=300,
+	 * each mbuf will have 5 segments (4×64 + 1×44).  The snaplen of 100
+	 * falls partway through the second segment, forcing the dumper to
+	 * stop writing in the middle of the chain.
+	 */
+	for (i = 0; i < num_pkts; i++) {
+		mbufs[i] = alloc_multiseg_mbuf(pkt_size, seg_size,
+					       (uint8_t)(0xA0 + i));
+		if (mbufs[i] == NULL) {
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_trunc_ms", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+	}
+
+	printf("  Sending %u packets: pkt_len=%u, seg_size=%u (%u segs), snaplen=%u\n",
+	       num_pkts, pkt_size, seg_size, mbufs[0]->nb_segs, test_snaplen);
+
+	/* Verify mbufs are actually multi-segment */
+	TEST_ASSERT(mbufs[0]->nb_segs > 1,
+		    "Expected multi-segment mbufs, got %u segment(s)",
+		    mbufs[0]->nb_segs);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_pkts);
+
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_pkts; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_pkts,
+			  "TX burst failed: sent %d/%u", nb_tx, num_pkts);
+
+	cleanup_pcap_vdev("net_pcap_trunc_ms", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size,
+				     &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, num_pkts,
+			  "Packet count mismatch: got %u, expected %u",
+			  pkt_count, num_pkts);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation multi-segment test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char vlan_tx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t nb_prep;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* tx_prepare handles VLAN tag insertion */
+	nb_prep = rte_eth_tx_prepare(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_prep, NUM_PACKETS,
+			  "tx_prepare failed: prepared %u/%d", nb_prep, NUM_PACKETS);
+
+	/* Transmit the prepared packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_prep);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	remove_temp_file(vlan_tx_pcap_path);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Runtime VLAN offload configuration via rte_eth_dev_set_vlan_offload
+ *
+ * This test verifies that VLAN strip can be enabled/disabled at runtime
+ * using the standard ethdev API rather than only at configure time.
+ * Uses infinite_rx mode so the same packets can be read in each phase.
+ */
+static int
+test_vlan_offload_set(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char vlan_set_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf = { 0 };
+	unsigned int i;
+	uint16_t nb_rx;
+	int ret, current_offload;
+	size_t tagged_len, untagged_len;
+
+	printf("Testing runtime VLAN offload configuration\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_set_pcap_path, sizeof(vlan_set_pcap_path),
+				     "pcap_vlan_set") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_set_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	/* Use infinite_rx so packets are always available */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", vlan_set_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_set", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+
+	/* Configure WITHOUT VLAN strip initially and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port");
+
+	/* Expected lengths */
+	tagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		     sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+	untagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN strip is initially disabled */
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled initially");
+
+	/*
+	 * Phase 1: VLAN strip disabled - packets should have tags
+	 */
+	printf("  Phase 1: VLAN strip disabled\n");
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 1");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 1 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact\n", nb_rx);
+
+	/*
+	 * Phase 2: Enable VLAN strip at runtime - packets should be stripped
+	 */
+	printf("  Phase 2: Enabling VLAN strip via rte_eth_dev_set_vlan_offload\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, RTE_ETH_VLAN_STRIP_OFFLOAD);
+	TEST_ASSERT(ret == 0, "Failed to enable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD,
+		    "VLAN strip should be enabled after set_vlan_offload");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 2");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), untagged_len,
+				  "Phase 2 packet %u: expected untagged length %zu, got %u",
+				  i, untagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Phase 2 packet %u: VLAN_STRIPPED flag not set", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags stripped\n", nb_rx);
+
+	/*
+	 * Phase 3: Disable VLAN strip - packets should have tags again
+	 */
+	printf("  Phase 3: Disabling VLAN strip\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to disable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled after clearing");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 3");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 3 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact again\n", nb_rx);
+
+	cleanup_pcap_vdev("net_pcap_vlan_set", port_id);
+	remove_temp_file(vlan_set_pcap_path);
+
+	printf("Runtime VLAN offload PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip in infinite RX mode
+ *
+ * This test verifies that VLAN strip offload works correctly when combined
+ * with infinite_rx mode, which uses a different RX path (eth_pcap_rx_infinite).
+ */
+static int
+test_vlan_strip_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	char vlan_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int stripped_count = 0;
+	int iter, attempts, ret;
+	size_t expected_len;
+
+	printf("Testing VLAN strip with infinite RX mode\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_inf_pcap_path, sizeof(vlan_inf_pcap_path),
+				     "pcap_vlan_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_inf_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets for infinite RX\n", NUM_PACKETS);
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", vlan_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_vlan_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_vlan_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with VLAN strip enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Expected length after VLAN strip */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Read packets - need more than file contains to verify infinite looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				/* Verify VLAN was stripped */
+				if (verify_no_vlan_tag(mbufs[i]) == 0 &&
+				    rte_pktmbuf_pkt_len(mbufs[i]) == expected_len &&
+				    (mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED))
+					stripped_count++;
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_vlan_inf");
+	remove_temp_file(vlan_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(stripped_count, total_rx,
+			  "VLAN strip failed: only %u/%u packets stripped correctly",
+			  stripped_count, total_rx);
+
+	printf("VLAN strip infinite RX PASSED: %u packets stripped (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Timestamps in infinite RX mode
+ *
+ * This test verifies that timestamp offload works correctly when combined
+ * with infinite_rx mode. Since infinite_rx generates packets on-the-fly,
+ * timestamps should reflect the current time rather than pcap file timestamps.
+ */
+static int
+test_timestamp_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	char ts_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int ts_count = 0;
+	int iter, attempts, ret;
+	rte_mbuf_timestamp_t first_ts = 0;
+	rte_mbuf_timestamp_t last_ts = 0;
+
+	printf("Testing timestamps with infinite RX mode\n");
+
+	/* Initialize timestamp dynamic field access */
+	if (timestamp_dynfield_offset < 0) {
+		ret = timestamp_init();
+		if (ret != 0) {
+			printf("Timestamp dynfield not available, skipping\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	/* Create simple pcap file */
+	TEST_ASSERT(create_temp_path(ts_inf_pcap_path, sizeof(ts_inf_pcap_path),
+				     "pcap_ts_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_test_pcap(ts_inf_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", ts_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_ts_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_ts_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with timestamp offload enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with timestamps");
+
+	/* Read packets */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				if (mbuf_has_timestamp(mbufs[i])) {
+					rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+
+					if (ts_count == 0)
+						first_ts = ts;
+					last_ts = ts;
+					ts_count++;
+				}
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_ts_inf");
+	remove_temp_file(ts_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(ts_count, total_rx,
+			  "Timestamp missing: only %u/%u packets have timestamps",
+			  ts_count, total_rx);
+
+	/* Timestamps should be monotonically increasing (current time) */
+	TEST_ASSERT(last_ts >= first_ts,
+		    "Timestamps not monotonic: first=%" PRIu64 " last=%" PRIu64,
+		    first_ts, last_ts);
+
+	printf("Timestamp infinite RX PASSED: %u packets with valid timestamps\n", total_rx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+
+/*
+ * Test: Oversized packets are dropped when scatter is disabled
+ *
+ * Use the default mempool (buf_size ~2048) without scatter enabled.
+ * Read a pcap file containing packets larger than the mbuf data room.
+ * Verify that oversized packets are dropped and counted as errors.
+ */
+static int
+test_scatter_drop_oversized(void)
+{
+	struct rte_eth_conf port_conf;
+	struct rte_eth_stats stats;
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received;
+	int ret;
+	const unsigned int num_pkts = 16;
+
+	printf("Testing scatter: oversized packets dropped without scatter\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_scat_drop") == 0,
+		    "Failed to create temp file path");
+
+	/*
+	 * Create pcap with jumbo packets (9000 bytes) that exceed the
+	 * default mbuf data room (~2048 bytes). Without scatter enabled,
+	 * these should be dropped at receive time.
+	 */
+	TEST_ASSERT(create_sized_pcap(rx_pcap_path, num_pkts,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap file");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_scat_drop", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_scat_drop", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure without scatter - MTU check passes (1514 < 2048) */
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port: %s", rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "rx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "tx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	ret = rte_eth_stats_reset(port_id);
+	TEST_ASSERT(ret == 0, "Failed to reset stats");
+
+	/*
+	 * Read all packets. The pcap file has 9000-byte packets but
+	 * scatter is not enabled. They should all be dropped.
+	 */
+	receive_packets(port_id, mbufs, num_pkts, &received);
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	ret = rte_eth_stats_get(port_id, &stats);
+	TEST_ASSERT(ret == 0, "Failed to get stats");
+
+	printf("  Received %u packets, errors=%" PRIu64 "\n",
+	       received, stats.ierrors);
+
+	TEST_ASSERT_EQUAL(received, 0U,
+			  "Expected 0 received packets without scatter, got %u",
+			  received);
+	TEST_ASSERT_EQUAL(stats.ierrors, (uint64_t)num_pkts,
+			  "Expected %u errors for oversized packets, got %" PRIu64,
+			  num_pkts, stats.ierrors);
+
+	cleanup_pcap_vdev("net_pcap_scat_drop", port_id);
+	remove_temp_file(rx_pcap_path);
+
+	printf("Scatter drop oversized PASSED: %" PRIu64 " packets dropped\n",
+	       stats.ierrors);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo packets are scattered when scatter is enabled
+ *
+ * With scatter enabled and a normal mempool, read jumbo-sized packets
+ * from a pcap file. Verify they arrive as multi-segment mbufs with
+ * correct total length.
+ */
+static int
+test_scatter_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_conf port_conf;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	unsigned int multiseg_count = 0;
+	int ret;
+	const unsigned int num_pkts = 16;
+
+	printf("Testing scatter: jumbo RX with scatter enabled\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_scat_jumbo") == 0,
+		    "Failed to create temp file path");
+	TEST_ASSERT(create_sized_pcap(rx_pcap_path, num_pkts,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap file");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_scat_jumbo", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_scat_jumbo", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure WITH scatter enabled */
+	memset(&port_conf, 0, sizeof(port_conf));
+	port_conf.rxmode.offloads = RTE_ETH_RX_OFFLOAD_SCATTER;
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port: %s", rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "rx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "tx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	receive_packets(port_id, mbufs, num_pkts, &received);
+	TEST_ASSERT_EQUAL(received, num_pkts,
+			  "Received %u packets, expected %u", received, num_pkts);
+
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		if (nb_segs > 1)
+			multiseg_count++;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_scat_jumbo", port_id);
+	remove_temp_file(rx_pcap_path);
+
+	/* Jumbo packets should require multiple segments */
+	TEST_ASSERT(multiseg_count > 0,
+		    "Expected multi-segment mbufs for jumbo packets");
+
+	printf("Scatter jumbo RX PASSED: %u/%u packets were multi-segment\n",
+	       multiseg_count, received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	/* Cleanup shared temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_lsc_iface),
+		TEST_CASE(test_eof_rx),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_vlan_offload_set),
+		TEST_CASE(test_vlan_strip_infinite_rx),
+		TEST_CASE(test_timestamp_infinite_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASE(test_snaplen_truncation_multiseg),
+		TEST_CASE(test_scatter_drop_oversized),
+		TEST_CASE(test_scatter_jumbo_rx),
+
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index aa95b5885c..3b59adfdb2 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -115,6 +115,7 @@ New Features
   * Added support for Link State interrupt in ``iface`` mode.
   * Added ``eof`` devarg to use link state to signal end of receive
     file input.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v19 25/25] check patch warn in test

[Stephen Hemminger]

---
 app/test/test_pmd_pcap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
index 3b0a7e1348..4662e6675d 100644
--- a/app/test/test_pmd_pcap.c
+++ b/app/test/test_pmd_pcap.c
@@ -1912,7 +1912,7 @@ set_iface_up_down(const char *ifname, int up)
 static const char *
 find_lsc_test_iface(void)
 {
-	static const char *candidates[] = { "dummy0", "disc0" };
+	static const char * const candidates[] = { "dummy0", "disc0" };
 	unsigned int i;
 
 	for (i = 0; i < RTE_DIM(candidates); i++) {
-- 
2.51.0

[PATCH v20 00/25] net/pcap: fixes, test, and enhancements

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx (via tx_prepare) and stripping on Rx
  - Runtime VLAN offload configuration via vlan_offload_set callback
  - Nanosecond precision timestamps (when libpcap supports it)
  - Link state reporting in interface mode
  - Link status change (LSC) interrupt support in interface mode
  - EOF notification via link status change for rx_pcap mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snaplen devarg
  - Rx scatter offload support with mbuf pool validation

Bug fixes:
  - Fix build on Windows from RTE_LOG_LINE changes.
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Fix Tx burst error handling: distinguish malformed mbufs (counted
    as errors) from pcap_sendpacket backpressure (break and retry)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback
  - Fix infinite_rx ring fill applying VLAN strip and timestamp
    offloads to template packets, preventing those offloads from
    working correctly during packet delivery
  - Preserve VLAN tags in dpdk-pdump captures by converting
    stripped VLAN metadata to Tx insert requests and calling
    rte_eth_tx_prepare() on the pcap vdev

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Remove unnecessary volatile qualifier on statistics
  - Reduce scope of file-level variables

Testing:
  - Add comprehensive unit test suite covering basic file I/O,
    timestamps, jumbo frames, VLAN strip/insert, multi-queue,
    scatter receive, snaplen, EOF notification, and link status
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows
  - Tests use packet_burst_generator for standardized test packet
    creation

v20:
  - Add dpdk-pdump VLAN tag preservation patch

v19:
  - Restore Rx scatter offload patch that was inadvertently
    dropped in v18

Stephen Hemminger (25):
  maintainers: update for pcap driver
  net/pcap: fix build on Windows
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: advertise Tx multi segment
  net/pcap: replace stack bounce buffer
  net/pcap: fix error accounting and backpressure on transmit
  net/pcap: add datapath debug logging
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN strip and insert offloads
  net/pcap: add link status for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: avoid use of volatile
  net/pcap: clarify maximum received packet
  eal/windows: add wrapper for access function
  net/pcap: add snapshot length devarg
  net/pcap: add Rx scatter offload
  net/pcap: add link status change support for iface mode
  net/pcap: add EOF notification via link status change
  test: add comprehensive test suite for pcap PMD
  app/pdump: preserve VLAN tags in captured packets

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3755 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    9 +
 doc/guides/nics/pcap.rst               |   48 +
 doc/guides/rel_notes/release_26_03.rst |   12 +
 drivers/net/pcap/pcap_ethdev.c         |  850 ++++--
 drivers/net/pcap/pcap_osdep.h          |   27 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   43 +-
 drivers/net/pcap/pcap_osdep_linux.c    |   33 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   76 +-
 lib/eal/windows/include/rte_os_shim.h  |    1 +
 lib/eal/windows/include/unistd.h       |    7 +
 lib/pdump/rte_pdump.c                  |   32 +-
 14 files changed, 4674 insertions(+), 222 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.51.0

[PATCH v20 01/25] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 5eb8e9dc22..a8e375ddab 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1116,6 +1116,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.51.0

[PATCH v20 02/25] net/pcap: fix build on Windows

[Stephen Hemminger]

The log messages in the pcap OS dependent code for Windows
was never converted during the last release.

It looks like the osdep part of pcap was not being built.
Building requires have libpcap for Windows built which is not
part of the CI infrastructure.

Fixes: 2b843cac232e ("drivers: use per line logging in helpers")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Chengwen Feng <fengchengwen@huawei.com>
Acked-by: David Marchand <david.marchand@redhat.com>
---
 drivers/net/pcap/pcap_osdep_windows.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..0965c2f5c9 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -53,7 +53,7 @@ osdep_iface_index_get(const char *device_name)
 
 	ret = GetAdapterIndex(adapter_name, &index);
 	if (ret != NO_ERROR) {
-		PMD_LOG(ERR, "GetAdapterIndex(%S) = %lu\n", adapter_name, ret);
+		PMD_LOG(ERR, "GetAdapterIndex(%S) = %lu", adapter_name, ret);
 		return -1;
 	}
 
@@ -75,20 +75,20 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
-		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
+		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
 		return -1;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
-		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
+		PMD_LOG(ERR, "Cannot allocate adapter address info");
 		return -1;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
-		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
+		PMD_LOG(ERR, "GetAdapterAddresses() = %lu", sys_ret);
 		free(info);
 		return -1;
 	}
-- 
2.51.0

[PATCH v20 03/25] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..c4f0360a06 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Timestamp offload    = Y
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
+Windows              = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.51.0

[PATCH v20 04/25] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.51.0

[PATCH v20 05/25] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.

Correct the indentation in that code. Not really worth backporting.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..fbd1021c39 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
+	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 
 	if (pp == NULL) {
 		PMD_LOG(ERR,
@@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
+		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
+				 RTE_CACHE_LINE_SIZE);
 
 		if (pp == NULL) {
 			PMD_LOG(ERR,
-- 
2.51.0

[PATCH v20 06/25] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fbd1021c39..806451dc99 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.51.0

[PATCH v20 07/25] net/pcap: advertise Tx multi segment

[Stephen Hemminger]

The driver supports multi-segment transmit, but the did not set
the offload flag. Therefore applications would not know about
that capability.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 806451dc99..fedf461be4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -753,6 +753,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.51.0

[PATCH v20 08/25] net/pcap: replace stack bounce buffer

[Stephen Hemminger]

Replace the 64K stack-allocated bounce buffer with a per-queue
buffer allocated from hugepages via rte_malloc at queue setup.
This is necessary because the buffer may be used in a secondary
process transmit path where the primary process allocated it.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 60 +++++++++++++++++++++-------------
 1 file changed, 37 insertions(+), 23 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index fedf461be4..72a297d423 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -91,6 +91,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -385,18 +388,17 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -404,12 +406,11 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len, caplen;
+
+		len = rte_pktmbuf_pkt_len(mbuf);
+		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
@@ -449,9 +450,6 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
 	for (i = 0; i < nb_pkts; i++) {
 		tx_bytes += bufs[i]->pkt_len;
 		rte_pktmbuf_free(bufs[i]);
@@ -460,7 +458,7 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -470,30 +468,30 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		int ret;
+
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
+				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
+				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
@@ -966,7 +964,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -974,11 +972,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1019,6 +1032,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
-- 
2.51.0

[PATCH v20 09/25] net/pcap: fix error accounting and backpressure on transmit

[Stephen Hemminger]

The error handling when pcap_sendpacket() was incorrect.
When underlying kernel socket buffer got full the send was counted as
an error. Malformed multi-segment mbufs where pkt_len exceeds actual
data were silently accepted.

On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
The send() call only blocks when the kernel socket send buffer is full,
providing limited backpressure. Backpressure is not an error.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 58 +++++++++++++++++++++-------------
 1 file changed, 36 insertions(+), 22 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 72a297d423..47a050df11 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -407,7 +407,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len, caplen;
+		uint32_t len, caplen;
+		const uint8_t *data;
 
 		len = rte_pktmbuf_pkt_len(mbuf);
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
@@ -415,15 +416,16 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+
+		/* This could only happen if mbuf is bogus pkt_len > data_len */
+		RTE_ASSERT(data != NULL);
+		pcap_dump((u_char *)dumper, &header, data);
 
 		num_tx++;
 		tx_bytes += caplen;
+
 		rte_pktmbuf_free(mbuf);
 	}
 
@@ -435,9 +437,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	pcap_dump_flush(dumper);
 	dumper_q->tx_stat.pkts += num_tx;
 	dumper_q->tx_stat.bytes += tx_bytes;
-	dumper_q->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return nb_pkts;
+	return i;
 }
 
 /*
@@ -462,7 +463,17 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 }
 
 /*
- * Callback to handle sending packets through a real NIC.
+ * Send a burst of packets to a pcap device.
+ *
+ * On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
+ * socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
+ * The send() call only blocks when the kernel socket send buffer is full,
+ * providing limited backpressure.
+ *
+ * On error, pcap_sendpacket() returns non-zero and the loop breaks,
+ * leaving remaining packets unsent.
+ *
+ * Bottom line: backpressure is not an error.
  */
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
@@ -484,34 +495,37 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len = rte_pktmbuf_pkt_len(mbuf);
-		int ret;
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		const uint8_t *data;
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
+		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		RTE_ASSERT(data != NULL);
+
+		/*
+		 * No good way to separate back pressure from failure here
+		 * Assume it is EBUSY, ENOMEM, or EINTR, something that can be retried.
 		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
+		if (pcap_sendpacket(pcap, data, len) != 0) {
+			PMD_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
 			break;
+		}
 		num_tx++;
 		tx_bytes += len;
+
 		rte_pktmbuf_free(mbuf);
 	}
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
 
 	return i;
 }
-- 
2.51.0

[PATCH v20 10/25] net/pcap: add datapath debug logging

[Stephen Hemminger]

Add datapath debug logging macros (PMD_RX_LOG, PMD_TX_LOG) gated
on RTE_ETHDEV_DEBUG_RX/TX. Use PMD_TX_LOG in transmit error paths
to aid debugging without impacting normal datapath performance.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c |  2 +-
 drivers/net/pcap/pcap_osdep.h  | 14 ++++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 47a050df11..258cffb813 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -499,7 +499,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		const uint8_t *data;
 
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
-			PMD_LOG(ERR,
+			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			tx_queue->tx_stat.err_pkts++;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..fe7399ff9f 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,6 +13,20 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+#ifdef RTE_ETHDEV_DEBUG_RX
+#define PMD_RX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() rx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_RX_LOG(...) do { } while (0)
+#endif
+
+#ifdef RTE_ETHDEV_DEBUG_TX
+#define PMD_TX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() tx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_TX_LOG(...) do { } while (0)
+#endif
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
-- 
2.51.0

[PATCH v20 11/25] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
 1 file changed, 30 insertions(+), 39 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 258cffb813..c3270a676c 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -102,9 +103,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -114,25 +115,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -884,7 +885,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1209,29 +1210,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1507,7 +1498,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1546,9 +1537,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
-					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+						 ETH_PCAP_INFINITE_RX_ARG,
+						 &process_bool_flag,
+						 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1698,5 +1689,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.51.0

[PATCH v20 12/25] net/pcap: support VLAN strip and insert offloads

[Stephen Hemminger]

Add VLAN tag handling to the pcap PMD, consistent with how virtio
and af_packet drivers implement it. This also gets used for
capture of VLAN tagged packets when legacy pdump is used.

RX strip: when RTE_ETH_RX_OFFLOAD_VLAN_STRIP is enabled, the driver
calls rte_vlan_strip() on received packets in both normal and
infinite_rx modes. For infinite_rx, offloads are deferred to
packet delivery rather than applied during ring fill, so the
stored template packets remain unmodified.

TX insert: when RTE_MBUF_F_TX_VLAN is set on an mbuf, the driver
inserts the VLAN tag via rte_vlan_insert() before writing to pcap
or sending to the interface. Indirect or shared mbufs get a new
header mbuf to avoid modifying the original.

Runtime reconfiguration is supported through vlan_offload_set,
which propagates the strip setting to all active RX queues.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/nics/pcap.rst               | 11 +++
 doc/guides/rel_notes/release_26_03.rst |  5 ++
 drivers/net/pcap/pcap_ethdev.c         | 96 ++++++++++++++++++++++++--
 4 files changed, 109 insertions(+), 4 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index c4f0360a06..ec7c91c650 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -9,6 +9,7 @@ Queue start/stop     = Y
 Timestamp offload    = Y
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index fbfe854bb1..bed5006a42 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -247,3 +247,14 @@ will be discarded by the Rx flushing operation.
    The network interface provided to the PMD should be up.
    The PMD will return an error if the interface is down,
    and the PMD itself won't change the status of the external network interface.
+
+Features and Limitations
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index d121951f5c..6aef623bf8 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -118,6 +118,11 @@ New Features
   Added handling of the key combination Control+L
   to clear the screen before redisplaying the prompt.
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
+
 Removed Items
 -------------
 
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index c3270a676c..c49ca7fa2b 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -76,6 +76,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -106,6 +107,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -270,7 +272,11 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		bufs[i]->data_len = pcap_buf->data_len;
 		bufs[i]->pkt_len = pcap_buf->pkt_len;
 		bufs[i]->port = pcap_q->port_id;
-		rx_bytes += pcap_buf->data_len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(bufs[i]);
+
+		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
 		rte_ring_enqueue(pcap_q->pkts, pcap_buf);
@@ -336,6 +342,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -382,6 +392,39 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+static uint16_t
+eth_pcap_tx_prepare(void *queue __rte_unused, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
+{
+	uint16_t nb_tx;
+	int error;
+
+	for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
+		struct rte_mbuf *m = tx_pkts[nb_tx];
+
+#ifdef RTE_LIBRTE_ETHDEV_DEBUG
+		error = rte_validate_tx_offload(m);
+		if (unlikely(error)) {
+			rte_errno = -error;
+			break;
+		}
+#endif
+		/* Do VLAN tag insertion */
+		if (unlikely(m->ol_flags & RTE_MBUF_F_TX_VLAN)) {
+			error = rte_vlan_insert(&m);
+
+			/* rte_vlan_insert() could change pointer (currently does not) */
+			tx_pkts[nb_tx] = m;
+
+			if (unlikely(error != 0)) {
+				PMD_TX_LOG(ERR, "rte_vlan_insert failed: %s", strerror(-error));
+				rte_errno = -error;
+				break;
+			}
+		}
+	}
+	return nb_tx;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -415,6 +458,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -496,9 +540,10 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		uint32_t len;
 		const uint8_t *data;
 
+		len = rte_pktmbuf_pkt_len(mbuf);
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
@@ -749,8 +794,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -766,7 +816,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -913,6 +965,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
@@ -922,6 +975,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		uint64_t pcap_pkt_count = 0;
 		struct rte_mbuf *bufs[1];
 		pcap_t **pcap;
+		bool save_vlan_strip;
 
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
@@ -941,11 +995,20 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		if (!pcap_q->pkts)
 			return -ENOENT;
 
+		/*
+		 * Temporarily disable offloads while filling the ring
+		 * with raw packets. VLAN strip and timestamp will be
+		 * applied later in eth_pcap_rx_infinite() on each copy.
+		 */
+		save_vlan_strip = pcap_q->vlan_strip;
+		pcap_q->vlan_strip = false;
+
 		/* Fill ring with packets from PCAP file one by one. */
 		while (eth_pcap_rx(pcap_q, bufs, 1)) {
 			/* Check for multiseg mbufs. */
 			if (bufs[0]->nb_segs != 1) {
 				infinite_rx_ring_free(pcap_q->pkts);
+				pcap_q->vlan_strip = save_vlan_strip;
 				PMD_LOG(ERR,
 					"Multiseg mbufs are not supported in infinite_rx mode.");
 				return -EINVAL;
@@ -955,6 +1018,9 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 					(void * const *)bufs, 1, NULL);
 		}
 
+		/* Restore offloads for use during packet delivery */
+		pcap_q->vlan_strip = save_vlan_strip;
+
 		if (rte_ring_count(pcap_q->pkts) < pcap_pkt_count) {
 			infinite_rx_ring_free(pcap_q->pkts);
 			PMD_LOG(ERR,
@@ -1039,6 +1105,26 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	unsigned int i;
+
+	if (mask & RTE_ETH_VLAN_STRIP_MASK) {
+		bool vlan_strip = !!(dev->data->dev_conf.rxmode.offloads &
+				     RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+
+		internals->vlan_strip = vlan_strip;
+
+		/* Update all RX queues */
+		for (i = 0; i < dev->data->nb_rx_queues; i++)
+			internals->rx_queue[i].vlan_strip = vlan_strip;
+	}
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1055,6 +1141,7 @@ static const struct eth_dev_ops ops = {
 	.link_update = eth_link_update,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.vlan_offload_set = eth_vlan_offload_set,
 };
 
 static int
@@ -1395,6 +1482,7 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		eth_dev->rx_pkt_burst = eth_null_rx;
 
 	/* Assign tx ops. */
+	eth_dev->tx_pkt_prepare = eth_pcap_tx_prepare;
 	if (devargs_all->is_tx_pcap)
 		eth_dev->tx_pkt_burst = eth_pcap_tx_dumper;
 	else if (devargs_all->is_tx_iface || single_iface)
-- 
2.51.0

[PATCH v20 13/25] net/pcap: add link status for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent function to query the real link state from
the underlying interface.

Linux and FreeBSD use SIOCGIFFLAGS to check IFF_UP and
IFF_RUNNING. Windows uses GetAdaptersAddresses() to check
OperStatus.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 38 +++++++++-----
 drivers/net/pcap/pcap_osdep.h          | 12 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  | 31 ++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 27 ++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  | 68 +++++++++++++++++++++-----
 6 files changed, 154 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 6aef623bf8..35a191b45f 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -121,6 +121,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index c49ca7fa2b..232b8fa4b1 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -150,13 +150,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -945,10 +938,28 @@ eth_dev_close(struct rte_eth_dev *dev)
 }
 
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link link = {
+		.link_speed = RTE_ETH_SPEED_NUM_10G,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
+
+	/*
+	 * For pass-through mode (single_iface), query whether the
+	 * underlying interface is up. Otherwise use default values.
+	 */
+	if (internals->single_iface) {
+		link.link_status = (osdep_iface_link_status(internals->rx_queue[0].name) > 0) ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	} else {
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1363,7 +1374,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index fe7399ff9f..18e63c6f2b 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -10,6 +10,7 @@
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
+
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
@@ -30,4 +31,15 @@ extern int eth_pcap_logtype;
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link status for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @return
+ *   1 if link is up, 0 if link is down, -1 on error.
+ */
+int osdep_iface_link_status(const char *name);
+
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..9c4186aadc 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,8 +5,13 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
@@ -55,3 +60,29 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_status(const char *if_name)
+{
+	struct ifmediareq ifmr;
+	int fd, status = 0;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd == -1)
+		return -1;
+
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* IFM_AVALID means status is valid, IFM_ACTIVE means link up */
+		if ((ifmr.ifm_status & IFM_AVALID) &&
+		    (ifmr.ifm_status & IFM_ACTIVE))
+			status = 1;
+	} else {
+		status = -1;
+	}
+
+	close(fd);
+	return status;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..f61b7bd146 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -40,3 +40,30 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+int
+osdep_iface_link_status(const char *if_name)
+{
+	struct ifreq ifr;
+	int fd, status = 0;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd == -1)
+		return -1;
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up.
+		 * IFF_RUNNING means operationally up (carrier detected).
+		 * Both must be set for link to be considered up.
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			status = 1;
+	} else {
+		status = -1;
+	}
+
+	close(fd);
+	return status;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 0965c2f5c9..e7a49c47e0 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,29 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_status(const char *device_name)
+{
+	IP_ADAPTER_ADDRESSES *info, *cur;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			ret = (cur->OperStatus == IfOperStatusUp) ? 1 : 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.51.0

[PATCH v20 14/25] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Add read_clock dev_op returning current UTC time for timestamp
  correlation.
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper.
* Enable immediate mode and improve error reporting
  in live capture setup.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |   3 +
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 156 +++++++++++++++++++------
 3 files changed, 126 insertions(+), 34 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index bed5006a42..2709c6d017 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -258,3 +258,6 @@ Features and Limitations
 *  The PMD will transparently insert a VLAN tag to transmitted packets if
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
+
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 35a191b45f..b06e1e72ee 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -122,6 +122,7 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state in ``iface`` mode.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 232b8fa4b1..6b728c6009 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -27,13 +27,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -77,6 +75,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -108,6 +107,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -269,6 +269,15 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(bufs[i]);
 
+		if (pcap_q->timestamp_offloading) {
+			struct timespec ts;
+
+			timespec_get(&ts, TIME_UTC);
+			*RTE_MBUF_DYNFIELD(bufs[i], timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(&ts);
+			bufs[i]->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
@@ -339,10 +348,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -362,14 +382,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -440,8 +465,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
@@ -450,8 +477,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		len = rte_pktmbuf_pkt_len(mbuf);
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -573,22 +598,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
+	}
+
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
+	}
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -635,7 +700,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -794,6 +860,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
 
@@ -811,7 +878,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -978,6 +1046,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1116,6 +1185,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static int
 eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
 {
@@ -1142,6 +1222,7 @@ static const struct eth_dev_ops ops = {
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1558,15 +1639,22 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		hz = rte_get_timer_hz();
+		if (hz == 0) {
+			PMD_LOG(ERR, "Reported hz is zero!");
+			return -1;
+		}
 
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							 &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.51.0

[PATCH v20 15/25] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 6b728c6009..b9e828f5a4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -642,6 +642,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.51.0

[PATCH v20 16/25] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index b9e828f5a4..8be3a59690 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -46,11 +46,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -600,6 +598,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -711,6 +710,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1459,6 +1460,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.51.0

[PATCH v20 17/25] net/pcap: avoid use of volatile

[Stephen Hemminger]

Using volatile for statistics is not necessary since only one
thread is allowed to operate on a queue at a time.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 8be3a59690..20e4b8e6aa 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -54,10 +54,10 @@ static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
 
 struct queue_stat {
-	volatile unsigned long pkts;
-	volatile unsigned long bytes;
-	volatile unsigned long err_pkts;
-	volatile unsigned long rx_nombuf;
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t err_pkts;
+	uint64_t rx_nombuf;
 };
 
 struct queue_missed_stat {
@@ -901,11 +901,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
 	      struct eth_queue_stats *qstats)
 {
 	unsigned int i;
-	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
-	unsigned long rx_missed_total = 0;
-	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
-	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
-	unsigned long tx_packets_err_total = 0;
+	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
+	uint64_t rx_missed_total = 0;
+	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
+	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
+	uint64_t tx_packets_err_total = 0;
 	const struct pmd_internals *internal = dev->data->dev_private;
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
-- 
2.51.0

[PATCH v20 18/25] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 20e4b8e6aa..2ffbce2448 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -884,10 +884,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.51.0

[PATCH v20 19/25] eal/windows: add wrapper for access function

[Stephen Hemminger]

Like other Posix functions in unistd.h add wrapper
using the Windows equivalent.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 lib/eal/windows/include/rte_os_shim.h | 1 +
 lib/eal/windows/include/unistd.h      | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/lib/eal/windows/include/rte_os_shim.h b/lib/eal/windows/include/rte_os_shim.h
index f16b2230c8..44664a5062 100644
--- a/lib/eal/windows/include/rte_os_shim.h
+++ b/lib/eal/windows/include/rte_os_shim.h
@@ -33,6 +33,7 @@
 #define unlink(path) _unlink(path)
 #define fileno(f) _fileno(f)
 #define isatty(fd) _isatty(fd)
+#define access(path, mode) _access(path, mode)
 
 #define IPVERSION	4
 
diff --git a/lib/eal/windows/include/unistd.h b/lib/eal/windows/include/unistd.h
index 78150c6480..f95888f4e1 100644
--- a/lib/eal/windows/include/unistd.h
+++ b/lib/eal/windows/include/unistd.h
@@ -23,4 +23,11 @@
 #define STDERR_FILENO _fileno(stderr)
 #endif
 
+/* Mode values for the _access() function.  */
+#ifndef F_OK
+#define	F_OK		0	/* test for existence of file */
+#define	W_OK		0x02	/* test for write permission */
+#define	R_OK		0x04	/* test for read permission */
+#endif
+
 #endif /* _UNISTD_H_ */
-- 
2.51.0

[PATCH v20 20/25] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

The snaplen argument is parsed before interface and file arguments
so that its value is available when pcap handles are opened during
device creation.

Example usage:
  --vdev 'net_pcap0,snaplen=1518,iface=eth0'
  --vdev 'net_pcap0,snaplen=9000,rx_pcap=in.pcap,tx_pcap=out.pcap'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |  17 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 211 ++++++++++++++++---------
 3 files changed, 158 insertions(+), 71 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2709c6d017..2754e205c7 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -15,6 +15,23 @@ For more information about the pcap library, see the
    The pcap-based PMD requires the libpcap development files to be installed.
    This applies to all supported operating systems: Linux, FreeBSD, and Windows.
 
+* Set the snapshot length for packet capture
+
+  The snapshot length controls the maximum number of bytes captured per packet.
+  This affects both interface capture and pcap file output.  The default value is
+  65535 bytes, which captures complete packets up to the maximum Ethernet jumbo
+  frame size.  Reducing this value can improve performance when only packet headers
+  are needed.
+
+  The ``snaplen`` argument is used when opening capture handles, so it should
+  be specified before the interface or file arguments.  Example::
+
+     --vdev 'net_pcap0,snaplen=1518,iface=eth0'
+     --vdev 'net_pcap0,snaplen=9000,rx_pcap=in.pcap,tx_pcap=out.pcap'
+
+  The snapshot length also determines the reported ``max_rx_pktlen``
+  and ``max_mtu`` in device info.
+
 
 Using the Driver from the EAL Command Line
 ------------------------------------------
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index b06e1e72ee..dc3a0fa81f 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -123,6 +123,7 @@ New Features
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state in ``iface`` mode.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2ffbce2448..8a2b5c1b4b 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -13,6 +13,8 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <unistd.h>
+
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -31,8 +33,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -41,6 +41,12 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
+
+/* This is defined in libpcap but not exposed in headers */
+#define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -101,6 +107,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -119,15 +126,18 @@ struct pmd_devargs {
 	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
+		/* pcap and name/type fields... */
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
+	uint32_t snapshot_len;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -145,6 +155,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
@@ -447,20 +458,19 @@ eth_pcap_tx_prepare(void *queue __rte_unused, struct rte_mbuf **tx_pkts, uint16_
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -473,7 +483,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		const uint8_t *data;
 
 		len = rte_pktmbuf_pkt_len(mbuf);
-		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+		caplen = RTE_MIN(len, snaplen);
 
 		header.len = len;
 		header.caplen = caplen;
@@ -539,33 +549,35 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_process_private *pp = dev->process_private;
+	struct pmd_internals *internals = dev->data->dev_private;
+	uint32_t snaplen = internals->snapshot_len;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		uint32_t len;
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
 
-		len = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		/*
+		 * multi-segment transmit that has to go through bounce buffer.
+		 * Make sure it fits; don't want to truncate the packet.
+		 */
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > snaplen)) {
 			PMD_TX_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
-				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
-			tx_queue->tx_stat.err_pkts++;
+				   "Multi segment len (%u) > snaplen (%u)",
+				   len, snaplen);
 			rte_pktmbuf_free(mbuf);
+			tx_queue->tx_stat.err_pkts++;
 			continue;
 		}
 
@@ -582,7 +594,6 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 		num_tx++;
 		tx_bytes += len;
-
 		rte_pktmbuf_free(mbuf);
 	}
 
@@ -596,7 +607,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -613,6 +624,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
 			iface, pcap_statustostr(status));
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	status = pcap_set_immediate_mode(pc, 1);
@@ -625,7 +639,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -639,6 +653,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -667,9 +684,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -678,7 +695,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -688,7 +706,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -697,9 +715,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -741,6 +759,21 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+static int
+set_iface_direction(const char *iface, pcap_t *pcap,
+		pcap_direction_t direction)
+{
+	const char *direction_str = (direction == PCAP_D_IN) ? "IN" : "OUT";
+	if (pcap_setdirection(pcap, direction) < 0) {
+		PMD_LOG(ERR, "Setting %s pcap direction %s failed - %s",
+				iface, direction_str, pcap_geterr(pcap));
+		return -1;
+	}
+	PMD_LOG(INFO, "Setting %s pcap direction %s",
+			iface, direction_str);
+	return 0;
+}
+
 static int
 eth_dev_start(struct rte_eth_dev *dev)
 {
@@ -749,15 +782,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
 		rx = &internals->rx_queue[0];
 
-		if (!pp->tx_pcap[0] &&
-			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+		if (!pp->tx_pcap[0] && strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -769,14 +802,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -791,9 +821,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -884,11 +919,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1146,7 +1181,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1298,7 +1333,8 @@ open_tx_pcap(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *dumpers = extra_args;
 	pcap_dumper_t *dumper;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	if (open_single_tx_pcap(pcap_filename, &dumper,
+				dumpers->snapshot_len) < 0)
 		return -1;
 
 	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
@@ -1319,7 +1355,7 @@ open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *tx = extra_args;
 	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (open_single_iface(iface, &pcap, tx->snapshot_len) < 0)
 		return -1;
 
 	tx->queue[0].pcap = pcap;
@@ -1329,21 +1365,6 @@ open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
-static inline int
-set_iface_direction(const char *iface, pcap_t *pcap,
-		pcap_direction_t direction)
-{
-	const char *direction_str = (direction == PCAP_D_IN) ? "IN" : "OUT";
-	if (pcap_setdirection(pcap, direction) < 0) {
-		PMD_LOG(ERR, "Setting %s pcap direction %s failed - %s",
-				iface, direction_str, pcap_geterr(pcap));
-		return -1;
-	}
-	PMD_LOG(INFO, "Setting %s pcap direction %s",
-			iface, direction_str);
-	return 0;
-}
-
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
@@ -1351,7 +1372,7 @@ open_iface(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *pmd = extra_args;
 	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (open_single_iface(iface, &pcap, pmd->snapshot_len) < 0)
 		return -1;
 	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
 		pcap_close(pcap);
@@ -1419,6 +1440,31 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN ||
+	    val > ETH_PCAP_MAXIMUM_SNAPLEN) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1583,6 +1629,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1644,6 +1692,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1690,6 +1739,25 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 			return -1;
 	}
 
+	/*
+	 * Process optional snapshot length argument first, so the value
+	 * is available when opening pcap handles for files and interfaces.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+	/*
+	 * Propagate snapshot length to per-queue devargs so that
+	 * the open callbacks can access it.
+	 */
+	devargs_all.rx_queues.snapshot_len = devargs_all.snapshot_len;
+	devargs_all.tx_queues.snapshot_len = devargs_all.snapshot_len;
+
 	/*
 	 * If iface argument is passed we open the NICs and use them for
 	 * reading / writing
@@ -1896,4 +1964,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v20 21/25] net/pcap: add Rx scatter offload

[Stephen Hemminger]

Add RTE_ETH_RX_OFFLOAD_SCATTER to the advertised receive offload
capabilities. Validate in rx_queue_setup that the mbuf pool data
room is large enough when scatter is not enabled, following the
same pattern as the virtio driver.

Gate the multi-segment receive path on the scatter offload flag
and drop oversized packets when scatter is disabled.
Reject scatter with infinite_rx mode since the ring-based replay
path does not support multi-segment mbufs.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 47 +++++++++++++++++++++++++++++++---
 1 file changed, 44 insertions(+), 3 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 8a2b5c1b4b..d8a924b0cd 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -79,6 +79,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool rx_scatter;
 	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
@@ -112,6 +113,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool rx_scatter;
 	bool timestamp_offloading;
 };
 
@@ -342,14 +344,19 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			/* pcap packet will fit in the mbuf, can copy it */
 			rte_memcpy(rte_pktmbuf_mtod(mbuf, void *), packet, len);
 			mbuf->data_len = len;
-		} else {
-			/* Try read jumbo frame into multi mbufs. */
+		} else if (pcap_q->rx_scatter) {
+			/* Scatter into multi-segment mbufs. */
 			if (unlikely(eth_pcap_rx_jumbo(pcap_q->mb_pool,
 						       mbuf, packet, len) == -1)) {
 				pcap_q->rx_stat.err_pkts++;
 				rte_pktmbuf_free(mbuf);
 				break;
 			}
+		} else {
+			/* Packet too large and scatter not enabled, drop it. */
+			pcap_q->rx_stat.err_pkts++;
+			rte_pktmbuf_free(mbuf);
+			continue;
 		}
 
 		mbuf->pkt_len = len;
@@ -907,6 +914,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->rx_scatter = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_SCATTER);
 	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 	return 0;
 }
@@ -927,7 +935,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP |
+		RTE_ETH_RX_OFFLOAD_SCATTER;
 
 	return 0;
 }
@@ -1088,11 +1097,37 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 {
 	struct pmd_internals *internals = dev->data->dev_private;
 	struct pcap_rx_queue *pcap_q = &internals->rx_queue[rx_queue_id];
+	uint16_t buf_size;
+	bool rx_scatter;
+
+	buf_size = rte_pktmbuf_data_room_size(mb_pool) - RTE_PKTMBUF_HEADROOM;
+	rx_scatter = !!(dev->data->dev_conf.rxmode.offloads &
+			RTE_ETH_RX_OFFLOAD_SCATTER);
+
+	/*
+	 * If Rx scatter is not enabled, verify that the mbuf data room
+	 * can hold the largest received packet in a single segment.
+	 * Use the MTU-derived frame size as the expected maximum, not
+	 * snapshot_len which is a capture truncation limit rather than
+	 * an expected packet size.
+	 */
+	if (!rx_scatter) {
+		uint32_t max_rx_pktlen = dev->data->mtu + RTE_ETHER_HDR_LEN;
+
+		if (max_rx_pktlen > buf_size) {
+			PMD_LOG(ERR,
+				"Rx scatter is disabled and RxQ mbuf pool object size is too small "
+				"(buf_size=%u, max_rx_pkt_len=%u)",
+				buf_size, max_rx_pktlen);
+			return -EINVAL;
+		}
+	}
 
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
+	pcap_q->rx_scatter = rx_scatter;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
@@ -1105,6 +1140,12 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		pcap_t **pcap;
 		bool save_vlan_strip;
 
+		if (rx_scatter) {
+			PMD_LOG(ERR,
+				"Rx scatter is not supported with infinite_rx mode");
+			return -EINVAL;
+		}
+
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
 
-- 
2.51.0

[PATCH v20 22/25] net/pcap: add link status change support for iface mode

[Stephen Hemminger]

Add LSC interrupt support for pass-through (iface=) mode so
applications can receive link state change notifications via
the standard ethdev callback mechanism.

Uses alarm-based polling to periodically check the underlying
interface state via osdep_iface_link_get(). The LSC flag is
advertised only for iface mode devices, and polling is gated
on the application enabling intr_conf.lsc in port configuration.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/nics/pcap.rst               |  5 +++
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 45 ++++++++++++++++++++++++++
 4 files changed, 52 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index ec7c91c650..b409ecd597 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -5,6 +5,7 @@
 ;
 [Features]
 Link status          = Y
+Link status event    = Y
 Queue start/stop     = Y
 Timestamp offload    = Y
 Basic stats          = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2754e205c7..72f2250790 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -278,3 +278,8 @@ Features and Limitations
 
 *  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
    UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
+
+*  In ``iface`` mode, the PMD supports link status change (LSC) notifications.
+   When the application enables ``intr_conf.lsc`` in the port configuration,
+   the driver polls the underlying network interface once per second and generates an
+   ``RTE_ETH_EVENT_INTR_LSC`` callback when the link state changes.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index dc3a0fa81f..d1bc6ba493 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -124,6 +124,7 @@ New Features
   * Added support for reporting link state in ``iface`` mode.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added support for Link State interrupt in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index d8a924b0cd..2d64032474 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -17,6 +17,7 @@
 
 #include <pcap.h>
 
+#include <rte_alarm.h>
 #include <rte_cycles.h>
 #include <rte_ring.h>
 #include <rte_ethdev.h>
@@ -48,6 +49,8 @@
 /* This is defined in libpcap but not exposed in headers */
 #define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
+#define ETH_PCAP_LSC_POLL_INTERVAL_US (1000 * 1000) /* 1 second */
+
 #define ETH_PCAP_ARG_MAXLEN	64
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
@@ -115,6 +118,7 @@ struct pmd_internals {
 	bool vlan_strip;
 	bool rx_scatter;
 	bool timestamp_offloading;
+	bool lsc_active;
 };
 
 struct pmd_process_private {
@@ -163,6 +167,9 @@ static const char *valid_arguments[] = {
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declarations */
+static int eth_link_update(struct rte_eth_dev *dev, int wait_to_complete);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -766,6 +773,28 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+/*
+ * Periodic alarm to poll link state.
+ * Enabled when link state interrupt is enabled in single_iface mode.
+ */
+static void
+eth_pcap_lsc_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link old_link, new_link;
+
+	rte_eth_linkstatus_get(dev, &old_link);
+	eth_link_update(dev, 0);
+	rte_eth_linkstatus_get(dev, &new_link);
+
+	if (old_link.link_status != new_link.link_status)
+		rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+
+	if (internals->lsc_active)
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US, eth_pcap_lsc_alarm, dev);
+}
+
 static int
 set_iface_direction(const char *iface, pcap_t *pcap,
 		pcap_direction_t direction)
@@ -848,6 +877,13 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
+	/* Start LSC polling for iface mode if application requested it */
+	if (internals->single_iface && dev->data->dev_conf.intr_conf.lsc) {
+		internals->lsc_active = true;
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US,
+				  eth_pcap_lsc_alarm, dev);
+	}
+
 	return 0;
 }
 
@@ -865,6 +901,12 @@ eth_dev_stop(struct rte_eth_dev *dev)
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
+		/* Cancel LSC polling before closing pcap handles */
+		if (internals->lsc_active) {
+			internals->lsc_active = false;
+			rte_eal_alarm_cancel(eth_pcap_lsc_alarm, dev);
+		}
+
 		queue_missed_stat_on_stop_update(dev, 0);
 		if (pp->tx_pcap[0] != NULL) {
 			pcap_close(pp->tx_pcap[0]);
@@ -1661,6 +1703,9 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		internals->if_index =
 			osdep_iface_index_get(rx_queues->queue[0].name);
 
+		/* Enable LSC interrupt support for iface mode */
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 		/* phy_mac arg is applied only if "iface" devarg is provided */
 		if (rx_queues->phy_mac) {
 			if (eth_pcap_update_mac(rx_queues->queue[0].name,
-- 
2.51.0

[PATCH v20 23/25] net/pcap: add EOF notification via link status change

[Stephen Hemminger]

Add an "eof" devarg for rx_pcap mode that signals end-of-file by
setting link down and generating an LSC event. This allows
applications to detect when a pcap file has been fully consumed
using the standard ethdev callback mechanism.

The eof and infinite_rx options are mutually exclusive. On device
restart, the EOF state is reset so the file can be replayed.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               | 12 ++++
 doc/guides/rel_notes/release_26_03.rst |  2 +
 drivers/net/pcap/pcap_ethdev.c         | 80 +++++++++++++++++++++++++-
 3 files changed, 91 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 72f2250790..18a9a04652 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -161,6 +161,18 @@ Runtime Config Options
   so all queues on a device will either have this enabled or disabled.
   This option should only be provided once per device.
 
+* Signal end-of-file via link status change
+
+  In case ``rx_pcap=`` configuration is set, the user may want to be notified when
+  all packets in the pcap file have been read.  This can be done with the ``eof``
+  devarg, for example::
+
+     --vdev 'net_pcap0,rx_pcap=file_rx.pcap,eof=1'
+
+  When enabled, the driver sets link down and generates an LSC event at end of file.
+  If the device is stopped and restarted, the EOF state is reset.
+  This option cannot be combined with ``infinite_rx``.
+
 * Drop all packets on transmit
 
   To drop all packets on transmit for a device,
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index d1bc6ba493..ed8d96f7b6 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -125,6 +125,8 @@ New Features
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
   * Added support for Link State interrupt in ``iface`` mode.
+  * Added ``eof`` devarg to use link state to signal end of receive
+    file input.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2d64032474..feefcf922d 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -42,6 +42,7 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_EOF_ARG          "eof"
 #define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
 
 #define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
@@ -115,6 +116,8 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool eof;
+	RTE_ATOMIC(bool) eof_signaled;
 	bool vlan_strip;
 	bool rx_scatter;
 	bool timestamp_offloading;
@@ -150,6 +153,7 @@ struct pmd_devargs_all {
 	bool is_rx_pcap;
 	bool is_rx_iface;
 	bool infinite_rx;
+	bool eof;
 };
 
 static const char *valid_arguments[] = {
@@ -161,6 +165,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_EOF_ARG,
 	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
@@ -308,15 +313,33 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	return i;
 }
 
+/*
+ * Deferred EOF alarm callback.
+ *
+ * Scheduled from the RX burst path when end-of-file is reached,
+ * so that rte_eth_dev_callback_process() runs outside the datapath.
+ * This avoids holding any locks that the application callback
+ * might also need, preventing potential deadlocks.
+ */
+static void
+eth_pcap_eof_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+
+	rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+}
+
 static uint16_t
 eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
+	struct pcap_rx_queue *pcap_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[pcap_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
 	unsigned int i;
 	struct pcap_pkthdr *header;
 	struct pmd_process_private *pp;
 	const u_char *packet;
 	struct rte_mbuf *mbuf;
-	struct pcap_rx_queue *pcap_q = queue;
 	uint16_t num_rx = 0;
 	uint32_t rx_bytes = 0;
 	pcap_t *pcap;
@@ -337,6 +360,23 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			if (ret == PCAP_ERROR)
 				pcap_q->rx_stat.err_pkts++;
 
+			/*
+			 * EOF: if eof mode is enabled, set link down and
+			 * defer notification via alarm to avoid calling
+			 * rte_eth_dev_callback_process() from the datapath.
+			 */
+			else if (ret == PCAP_ERROR_BREAK) {
+				bool expected = false;
+
+				if (internals->eof &&
+				    rte_atomic_compare_exchange_strong_explicit(
+					    &internals->eof_signaled, &expected, true,
+					    rte_memory_order_relaxed, rte_memory_order_relaxed)) {
+					eth_link_update(dev, 0);
+					rte_eal_alarm_set(1, eth_pcap_eof_alarm, dev);
+				}
+			}
+
 			break;
 		}
 
@@ -875,6 +915,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++)
 		dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
 
+	rte_atomic_store_explicit(&internals->eof_signaled, false, rte_memory_order_relaxed);
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
 	/* Start LSC polling for iface mode if application requested it */
@@ -898,6 +939,7 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	unsigned int i;
 	struct pmd_internals *internals = dev->data->dev_private;
 	struct pmd_process_private *pp = dev->process_private;
+	bool expected;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
@@ -937,6 +979,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	}
 
 status_down:
+	/* Cancel any pending EOF alarm */
+	expected = true;
+	if (rte_atomic_compare_exchange_strong_explicit(
+		    &internals->eof_signaled, &expected, false,
+		    rte_memory_order_relaxed, rte_memory_order_relaxed))
+		rte_eal_alarm_cancel(eth_pcap_eof_alarm, dev);
+
 	for (i = 0; i < dev->data->nb_rx_queues; i++)
 		dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
 
@@ -1121,9 +1170,10 @@ eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 	if (internals->single_iface) {
 		link.link_status = (osdep_iface_link_status(internals->rx_queue[0].name) > 0) ?
 			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	} else if (rte_atomic_load_explicit(&internals->eof_signaled, rte_memory_order_relaxed)) {
+		link.link_status = RTE_ETH_LINK_DOWN;
 	} else {
-		link.link_status = dev->data->dev_started ?
-			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_status = dev->data->dev_started ? RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 	}
 
 	return rte_eth_linkstatus_set(dev, &link);
@@ -1715,8 +1765,13 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->eof = devargs_all->eof;
 	internals->snapshot_len = devargs_all->snapshot_len;
 
+	/* Enable LSC for eof mode (already set above for single_iface) */
+	if (internals->eof)
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1912,6 +1967,24 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 					"for %s", name);
 		}
 
+		/*
+		 * Check whether to signal EOF via link status change.
+		 */
+		if (rte_kvargs_count(kvlist, ETH_PCAP_EOF_ARG) == 1) {
+			ret = rte_kvargs_process(kvlist, ETH_PCAP_EOF_ARG,
+						 &process_bool_flag,
+						 &devargs_all.eof);
+			if (ret < 0)
+				goto free_kvlist;
+		}
+
+		if (devargs_all.infinite_rx && devargs_all.eof) {
+			PMD_LOG(ERR, "Cannot use both infinite_rx and eof for %s",
+				name);
+			ret = -EINVAL;
+			goto free_kvlist;
+		}
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
 				&open_rx_pcap, &pcaps);
 	} else if (devargs_all.is_rx_iface) {
@@ -2051,4 +2124,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_EOF_ARG "=<0|1> "
 	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.51.0

[PATCH v20 24/25] test: add comprehensive test suite for pcap PMD

[Stephen Hemminger]

Add unit tests for the pcap PMD covering file and interface modes.

Tests include:
  - basic TX to file and RX from file
  - varied packet sizes and jumbo frames
  - infinite RX mode
  - TX drop mode
  - statistics
  - interface (iface=) pass-through mode
  - link status reporting for file and iface modes
  - link status change (LSC) with interface toggle
  - EOF notification via LSC
  - RX timestamps and timestamp with infinite RX
  - multiple TX/RX queues
  - VLAN strip, insert, and runtime offload configuration
  - snapshot length (snaplen) and truncation

Cross-platform helpers handle temp file creation, interface
discovery, and VLAN packet generation.

The LSC link toggle test requires a pre-created dummy interface
(Linux: dummy0, FreeBSD: disc0) and is skipped if unavailable.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 3755 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 3758 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index 5dde50b181..6ffcfc0ab3 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -216,6 +217,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 # the NULL ethdev is used by a number of tests, in some cases as an optional dependency.
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..4662e6675d
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,3755 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define F_OK 0
+#define usleep(us) Sleep((us) / 1000 ? (us) / 1000 : 1)
+#else
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths shared between tests */
+static char tx_pcap_path[PATH_MAX];	/* test_tx_to_file -> test_rx_from_file */
+static char vlan_rx_pcap_path[PATH_MAX]; /* test_vlan_strip_rx -> test_vlan_no_strip_rx */
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port with custom config
+ */
+static int
+setup_pcap_port_conf(uint16_t port, const struct rte_eth_conf *conf)
+{
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port (default: timestamp offload)
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint8_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf with controlled segment size.
+ *
+ * Unlike alloc_jumbo_mbuf which fills segments to tailroom capacity,
+ * this limits each segment to seg_size bytes, guaranteeing that the
+ * resulting mbuf chain has multiple segments even for moderate pkt_len.
+ */
+static struct rte_mbuf *
+alloc_multiseg_mbuf(uint32_t pkt_len, uint16_t seg_size, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t this_len;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		this_len = RTE_MIN(remaining, seg_size);
+		this_len = RTE_MIN(this_len, rte_pktmbuf_tailroom(seg));
+		seg->data_len = this_len;
+
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, this_len);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= this_len;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint8_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PACKET_BURST_GEN_PKT_LEN_128
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+	int ret;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char varied_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+	remove_temp_file(varied_pcap_path);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char infinite_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+	int ret;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+	remove_temp_file(infinite_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+	int ret;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+	remove_temp_file(rx_pcap_path);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+	int ret;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path), "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char jumbo_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path), "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+
+	/* Jumbo frames require scatter to receive into multi-segment mbufs */
+	struct rte_eth_conf jumbo_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_SCATTER |
+				   RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &jumbo_conf) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+	remove_temp_file(jumbo_pcap_path);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	int ret;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+	remove_temp_file(rx_pcap_path);
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+static int
+test_lsc_iface(void)
+{
+	printf("  Link toggle test not supported on Windows, skipping\n");
+	return TEST_SKIPPED;
+}
+#else
+/*
+ * Test: Link Status Change (LSC) interrupt support
+ *
+ * Verifies that:
+ * 1. LSC capability is NOT advertised for file mode
+ * 2. LSC capability IS advertised for iface mode
+ * 3. LSC callback fires when the underlying interface goes down/up
+ *
+ * Requires a toggleable Ethernet interface created before running:
+ *   Linux:   ip link add dummy0 type dummy && ip link set dummy0 up
+ *   FreeBSD: ifconfig disc0 create && ifconfig disc0 up
+ *
+ * Skipped if no suitable interface is found or on Windows.
+ */
+
+/* Callback counter for LSC test */
+static volatile int lsc_callback_count;
+
+static int
+test_lsc_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	lsc_callback_count++;
+	return 0;
+}
+
+/*
+ * Helper: Set interface link up or down via ioctl.
+ * Returns 0 on success, -errno on failure.
+ */
+static int
+set_iface_up_down(const char *ifname, int up)
+{
+	struct ifreq ifr;
+	int fd, ret;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd < 0)
+		return -errno;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	ret = ioctl(fd, SIOCGIFFLAGS, &ifr);
+	if (ret < 0) {
+		ret = -errno;
+		close(fd);
+		return ret;
+	}
+
+	if (up)
+		ifr.ifr_flags |= IFF_UP;
+	else
+		ifr.ifr_flags &= ~IFF_UP;
+
+	ret = ioctl(fd, SIOCSIFFLAGS, &ifr);
+	if (ret < 0)
+		ret = -errno;
+	else
+		ret = 0;
+
+	close(fd);
+	return ret;
+}
+
+/*
+ * Helper: Find a toggleable test interface for LSC testing.
+ *
+ * Looks for well-known interfaces that are safe to bring up/down:
+ *   Linux:   dummy0 (ip link add dummy0 type dummy)
+ *   FreeBSD: disc0 (ifconfig disc0 create)
+ *
+ * Returns interface name or NULL if none found.
+ */
+static const char *
+find_lsc_test_iface(void)
+{
+	static const char * const candidates[] = { "dummy0", "disc0" };
+	unsigned int i;
+
+	for (i = 0; i < RTE_DIM(candidates); i++) {
+		if (iface_is_ethernet(candidates[i]))
+			return candidates[i];
+	}
+	return NULL;
+}
+
+static int
+test_lsc_iface(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	int ret;
+
+	printf("Testing Link Status Change (LSC) support\n");
+
+	/*
+	 * Test 1: Verify LSC is NOT advertised for file mode
+	 */
+	printf("  Testing file mode does not advertise LSC\n");
+	{
+		char lsc_pcap_path[PATH_MAX];
+		uint16_t file_port_id;
+
+		TEST_ASSERT(create_temp_path(lsc_pcap_path, sizeof(lsc_pcap_path),
+					     "pcap_lsc") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(lsc_pcap_path, 1) == 0,
+			    "Failed to create test pcap");
+
+		ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", lsc_pcap_path);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		TEST_ASSERT(create_pcap_vdev("net_pcap_lsc_file", devargs,
+					     &file_port_id) == 0,
+			    "Failed to create file vdev");
+
+		ret = rte_eth_dev_info_get(file_port_id, &dev_info);
+		TEST_ASSERT(ret == 0, "Failed to get dev info");
+
+		TEST_ASSERT((*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC) == 0,
+			    "File mode should NOT advertise LSC capability");
+
+		rte_vdev_uninit("net_pcap_lsc_file");
+		remove_temp_file(lsc_pcap_path);
+		printf("  File mode LSC check PASSED\n");
+	}
+
+	struct rte_eth_link link;
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	uint16_t port_id;
+
+	/*
+	 * Test 2: Use a toggleable interface to test link change events.
+	 * Skip if not present.
+	 */
+	const char *lsc_iface = find_lsc_test_iface();
+	if (lsc_iface == NULL) {
+		printf("  No toggleable interface found, skipping link change test\n");
+		printf("  Linux:   ip link add dummy0 type dummy && ip link set dummy0 up\n");
+		printf("  FreeBSD: ifconfig disc0 create && ifconfig disc0 up\n");
+		return TEST_SUCCESS;
+	}
+
+	printf("  Testing iface mode LSC with: %s\n", lsc_iface);
+
+	/* Ensure interface is up before we start */
+	ret = set_iface_up_down(lsc_iface, 1);
+	if (ret != 0) {
+		printf("  Cannot set %s up (%s), skipping\n",
+		       lsc_iface, strerror(-ret));
+		return TEST_SUCCESS;
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", lsc_iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_lsc", devargs);
+	if (ret < 0) {
+		printf("  Cannot create iface vdev for %s, skipping\n", lsc_iface);
+		return TEST_SUCCESS;
+	}
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_lsc", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "Iface mode should advertise LSC capability");
+	printf("    LSC capability advertised: yes\n");
+
+	/* Register LSC callback */
+	lsc_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_lsc_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link status");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+	printf("    Link after start: UP\n");
+
+	/* Bring interface down - should trigger LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 0);
+	TEST_ASSERT(ret == 0, "Failed to set %s down: %s",
+		    lsc_iface, strerror(-ret));
+
+	/* Wait for at least one poll cycle (1 second interval) */
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after down");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after interface down");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired, count=%d",
+		    lsc_callback_count);
+	printf("    Interface down: link DOWN, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Bring it back up - should trigger another LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 1);
+	TEST_ASSERT(ret == 0, "Failed to set %s up: %s",
+		    lsc_iface, strerror(-ret));
+
+	usleep(1500 * 1000);
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after up");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after interface up");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired on link restore, count=%d",
+		    lsc_callback_count);
+	printf("    Interface up: link UP, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Cleanup */
+	rte_eth_dev_stop(port_id);
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_lsc_callback, NULL);
+	rte_vdev_uninit("net_pcap_lsc");
+
+	printf("LSC test PASSED\n");
+	return TEST_SUCCESS;
+}
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Test: EOF notification via link status change
+ *
+ * Verifies that:
+ * 1. The eof devarg causes link down + LSC event at end of pcap file
+ * 2. link_get reports DOWN after EOF
+ * 3. Stop/start resets the EOF state and replays the file
+ * 4. The eof and infinite_rx options are mutually exclusive
+ */
+
+static volatile int eof_callback_count;
+
+static int
+test_eof_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	eof_callback_count++;
+	return 0;
+}
+
+static int
+test_eof_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	struct rte_eth_link link;
+	char eof_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx;
+	int ret;
+
+	printf("Testing EOF notification via link status change\n");
+
+	/* Create pcap file with known number of packets */
+	TEST_ASSERT(create_temp_path(eof_pcap_path, sizeof(eof_pcap_path),
+				     "pcap_eof") == 0,
+		    "Failed to create temp file path");
+	TEST_ASSERT(create_test_pcap(eof_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/*
+	 * Test 1: EOF triggers link down and LSC callback
+	 */
+	printf("  Testing EOF triggers link down and LSC event\n");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,eof=1",
+		       eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create eof vdev: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_eof", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	struct rte_eth_dev_info dev_info;
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "EOF mode should advertise LSC capability");
+
+	/* Register LSC callback */
+	eof_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_eof_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Drain all packets from the pcap file */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			/* Got all packets and rx returned 0 — EOF hit */
+			break;
+		}
+	}
+
+	printf("    Received %u packets (expected %d)\n", total_rx, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Should receive exactly %d packets", NUM_PACKETS);
+
+	/* Verify link went down */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after EOF");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after EOF");
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	/* Verify callback fired exactly once */
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "LSC callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    EOF signaled: link DOWN, callback fired\n");
+
+	/*
+	 * Test 2: Stop/start resets EOF and replays the file
+	 */
+	printf("  Testing restart replays pcap file\n");
+
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	eof_callback_count = 0;
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to restart port");
+
+	/* Verify link is up again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after restart");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after restart");
+
+	/* Read packets again */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			break;
+		}
+	}
+
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Restart: should receive %d packets, got %u",
+			  NUM_PACKETS, total_rx);
+
+	/* Allow deferred EOF alarm to fire on the interrupt thread */
+	usleep(100 * 1000);
+
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "Restart: callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    Restart replay: %u packets, EOF signaled again\n", total_rx);
+
+	/* Cleanup */
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_eof_callback, NULL);
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_eof");
+
+	/*
+	 * Test 3: eof + infinite_rx is rejected
+	 */
+	printf("  Testing eof + infinite_rx mutual exclusion\n");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,eof=1,infinite_rx=1", eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof_bad", devargs);
+	TEST_ASSERT(ret != 0, "eof + infinite_rx should be rejected");
+	printf("    Mutual exclusion check PASSED\n");
+
+	remove_temp_file(eof_pcap_path);
+
+	printf("EOF test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char timestamp_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SUCCESS;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		if (ts != expected)
+			printf("Packet %u: timestamp mismatch, expected=%"PRIu64
+			       " actual=%"PRIu64"\n", i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+	remove_temp_file(timestamp_pcap_path);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		remove_temp_file(multi_tx_pcap_paths[q]);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char multi_rx_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0,
+		    "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	remove_temp_file(multi_rx_pcap_path);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		       rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation with multi-segment mbufs
+ *
+ * This test verifies that the dumper path correctly truncates
+ * non-contiguous (multi-segment) mbufs when the total packet length
+ * exceeds the configured snaplen.  It exercises the RTE_MIN(len, snaplen)
+ * cap in the TX dumper by ensuring:
+ *
+ * 1. caplen in the pcap header equals snaplen (not pkt_len)
+ * 2. len in the pcap header preserves the original packet length
+ * 3. Truncation works when the snaplen boundary falls mid-chain
+ */
+static int
+test_snaplen_truncation_multiseg(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx;
+	unsigned int i, pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint32_t pkt_size = 300;
+	const uint16_t seg_size = 64;
+	const unsigned int num_pkts = 8;
+
+	printf("Testing snaplen truncation with multi-segment mbufs\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_trunc_ms") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		       tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	TEST_ASSERT(create_pcap_vdev("net_pcap_trunc_ms", devargs,
+				     &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/*
+	 * Allocate multi-segment mbufs.  With seg_size=64 and pkt_size=300,
+	 * each mbuf will have 5 segments (4×64 + 1×44).  The snaplen of 100
+	 * falls partway through the second segment, forcing the dumper to
+	 * stop writing in the middle of the chain.
+	 */
+	for (i = 0; i < num_pkts; i++) {
+		mbufs[i] = alloc_multiseg_mbuf(pkt_size, seg_size,
+					       (uint8_t)(0xA0 + i));
+		if (mbufs[i] == NULL) {
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_trunc_ms", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+	}
+
+	printf("  Sending %u packets: pkt_len=%u, seg_size=%u (%u segs), snaplen=%u\n",
+	       num_pkts, pkt_size, seg_size, mbufs[0]->nb_segs, test_snaplen);
+
+	/* Verify mbufs are actually multi-segment */
+	TEST_ASSERT(mbufs[0]->nb_segs > 1,
+		    "Expected multi-segment mbufs, got %u segment(s)",
+		    mbufs[0]->nb_segs);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_pkts);
+
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_pkts; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_pkts,
+			  "TX burst failed: sent %d/%u", nb_tx, num_pkts);
+
+	cleanup_pcap_vdev("net_pcap_trunc_ms", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size,
+				     &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, num_pkts,
+			  "Packet count mismatch: got %u, expected %u",
+			  pkt_count, num_pkts);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation multi-segment test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char vlan_tx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t nb_prep;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* tx_prepare handles VLAN tag insertion */
+	nb_prep = rte_eth_tx_prepare(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_prep, NUM_PACKETS,
+			  "tx_prepare failed: prepared %u/%d", nb_prep, NUM_PACKETS);
+
+	/* Transmit the prepared packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_prep);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	remove_temp_file(vlan_tx_pcap_path);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Runtime VLAN offload configuration via rte_eth_dev_set_vlan_offload
+ *
+ * This test verifies that VLAN strip can be enabled/disabled at runtime
+ * using the standard ethdev API rather than only at configure time.
+ * Uses infinite_rx mode so the same packets can be read in each phase.
+ */
+static int
+test_vlan_offload_set(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char vlan_set_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf = { 0 };
+	unsigned int i;
+	uint16_t nb_rx;
+	int ret, current_offload;
+	size_t tagged_len, untagged_len;
+
+	printf("Testing runtime VLAN offload configuration\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_set_pcap_path, sizeof(vlan_set_pcap_path),
+				     "pcap_vlan_set") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_set_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	/* Use infinite_rx so packets are always available */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", vlan_set_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_set", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+
+	/* Configure WITHOUT VLAN strip initially and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port");
+
+	/* Expected lengths */
+	tagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		     sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+	untagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN strip is initially disabled */
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled initially");
+
+	/*
+	 * Phase 1: VLAN strip disabled - packets should have tags
+	 */
+	printf("  Phase 1: VLAN strip disabled\n");
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 1");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 1 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact\n", nb_rx);
+
+	/*
+	 * Phase 2: Enable VLAN strip at runtime - packets should be stripped
+	 */
+	printf("  Phase 2: Enabling VLAN strip via rte_eth_dev_set_vlan_offload\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, RTE_ETH_VLAN_STRIP_OFFLOAD);
+	TEST_ASSERT(ret == 0, "Failed to enable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD,
+		    "VLAN strip should be enabled after set_vlan_offload");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 2");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), untagged_len,
+				  "Phase 2 packet %u: expected untagged length %zu, got %u",
+				  i, untagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Phase 2 packet %u: VLAN_STRIPPED flag not set", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags stripped\n", nb_rx);
+
+	/*
+	 * Phase 3: Disable VLAN strip - packets should have tags again
+	 */
+	printf("  Phase 3: Disabling VLAN strip\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to disable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled after clearing");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 3");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 3 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact again\n", nb_rx);
+
+	cleanup_pcap_vdev("net_pcap_vlan_set", port_id);
+	remove_temp_file(vlan_set_pcap_path);
+
+	printf("Runtime VLAN offload PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip in infinite RX mode
+ *
+ * This test verifies that VLAN strip offload works correctly when combined
+ * with infinite_rx mode, which uses a different RX path (eth_pcap_rx_infinite).
+ */
+static int
+test_vlan_strip_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	char vlan_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int stripped_count = 0;
+	int iter, attempts, ret;
+	size_t expected_len;
+
+	printf("Testing VLAN strip with infinite RX mode\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_inf_pcap_path, sizeof(vlan_inf_pcap_path),
+				     "pcap_vlan_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_inf_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets for infinite RX\n", NUM_PACKETS);
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", vlan_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_vlan_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_vlan_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with VLAN strip enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Expected length after VLAN strip */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Read packets - need more than file contains to verify infinite looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				/* Verify VLAN was stripped */
+				if (verify_no_vlan_tag(mbufs[i]) == 0 &&
+				    rte_pktmbuf_pkt_len(mbufs[i]) == expected_len &&
+				    (mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED))
+					stripped_count++;
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_vlan_inf");
+	remove_temp_file(vlan_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(stripped_count, total_rx,
+			  "VLAN strip failed: only %u/%u packets stripped correctly",
+			  stripped_count, total_rx);
+
+	printf("VLAN strip infinite RX PASSED: %u packets stripped (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Timestamps in infinite RX mode
+ *
+ * This test verifies that timestamp offload works correctly when combined
+ * with infinite_rx mode. Since infinite_rx generates packets on-the-fly,
+ * timestamps should reflect the current time rather than pcap file timestamps.
+ */
+static int
+test_timestamp_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	char ts_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int ts_count = 0;
+	int iter, attempts, ret;
+	rte_mbuf_timestamp_t first_ts = 0;
+	rte_mbuf_timestamp_t last_ts = 0;
+
+	printf("Testing timestamps with infinite RX mode\n");
+
+	/* Initialize timestamp dynamic field access */
+	if (timestamp_dynfield_offset < 0) {
+		ret = timestamp_init();
+		if (ret != 0) {
+			printf("Timestamp dynfield not available, skipping\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	/* Create simple pcap file */
+	TEST_ASSERT(create_temp_path(ts_inf_pcap_path, sizeof(ts_inf_pcap_path),
+				     "pcap_ts_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_test_pcap(ts_inf_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", ts_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_ts_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_ts_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with timestamp offload enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with timestamps");
+
+	/* Read packets */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				if (mbuf_has_timestamp(mbufs[i])) {
+					rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+
+					if (ts_count == 0)
+						first_ts = ts;
+					last_ts = ts;
+					ts_count++;
+				}
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_ts_inf");
+	remove_temp_file(ts_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(ts_count, total_rx,
+			  "Timestamp missing: only %u/%u packets have timestamps",
+			  ts_count, total_rx);
+
+	/* Timestamps should be monotonically increasing (current time) */
+	TEST_ASSERT(last_ts >= first_ts,
+		    "Timestamps not monotonic: first=%" PRIu64 " last=%" PRIu64,
+		    first_ts, last_ts);
+
+	printf("Timestamp infinite RX PASSED: %u packets with valid timestamps\n", total_rx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+
+/*
+ * Test: Oversized packets are dropped when scatter is disabled
+ *
+ * Use the default mempool (buf_size ~2048) without scatter enabled.
+ * Read a pcap file containing packets larger than the mbuf data room.
+ * Verify that oversized packets are dropped and counted as errors.
+ */
+static int
+test_scatter_drop_oversized(void)
+{
+	struct rte_eth_conf port_conf;
+	struct rte_eth_stats stats;
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received;
+	int ret;
+	const unsigned int num_pkts = 16;
+
+	printf("Testing scatter: oversized packets dropped without scatter\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_scat_drop") == 0,
+		    "Failed to create temp file path");
+
+	/*
+	 * Create pcap with jumbo packets (9000 bytes) that exceed the
+	 * default mbuf data room (~2048 bytes). Without scatter enabled,
+	 * these should be dropped at receive time.
+	 */
+	TEST_ASSERT(create_sized_pcap(rx_pcap_path, num_pkts,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap file");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_scat_drop", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_scat_drop", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure without scatter - MTU check passes (1514 < 2048) */
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port: %s", rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "rx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "tx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	ret = rte_eth_stats_reset(port_id);
+	TEST_ASSERT(ret == 0, "Failed to reset stats");
+
+	/*
+	 * Read all packets. The pcap file has 9000-byte packets but
+	 * scatter is not enabled. They should all be dropped.
+	 */
+	receive_packets(port_id, mbufs, num_pkts, &received);
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	ret = rte_eth_stats_get(port_id, &stats);
+	TEST_ASSERT(ret == 0, "Failed to get stats");
+
+	printf("  Received %u packets, errors=%" PRIu64 "\n",
+	       received, stats.ierrors);
+
+	TEST_ASSERT_EQUAL(received, 0U,
+			  "Expected 0 received packets without scatter, got %u",
+			  received);
+	TEST_ASSERT_EQUAL(stats.ierrors, (uint64_t)num_pkts,
+			  "Expected %u errors for oversized packets, got %" PRIu64,
+			  num_pkts, stats.ierrors);
+
+	cleanup_pcap_vdev("net_pcap_scat_drop", port_id);
+	remove_temp_file(rx_pcap_path);
+
+	printf("Scatter drop oversized PASSED: %" PRIu64 " packets dropped\n",
+	       stats.ierrors);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo packets are scattered when scatter is enabled
+ *
+ * With scatter enabled and a normal mempool, read jumbo-sized packets
+ * from a pcap file. Verify they arrive as multi-segment mbufs with
+ * correct total length.
+ */
+static int
+test_scatter_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_conf port_conf;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	unsigned int multiseg_count = 0;
+	int ret;
+	const unsigned int num_pkts = 16;
+
+	printf("Testing scatter: jumbo RX with scatter enabled\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_scat_jumbo") == 0,
+		    "Failed to create temp file path");
+	TEST_ASSERT(create_sized_pcap(rx_pcap_path, num_pkts,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap file");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_scat_jumbo", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_scat_jumbo", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure WITH scatter enabled */
+	memset(&port_conf, 0, sizeof(port_conf));
+	port_conf.rxmode.offloads = RTE_ETH_RX_OFFLOAD_SCATTER;
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port: %s", rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "rx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "tx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	receive_packets(port_id, mbufs, num_pkts, &received);
+	TEST_ASSERT_EQUAL(received, num_pkts,
+			  "Received %u packets, expected %u", received, num_pkts);
+
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		if (nb_segs > 1)
+			multiseg_count++;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_scat_jumbo", port_id);
+	remove_temp_file(rx_pcap_path);
+
+	/* Jumbo packets should require multiple segments */
+	TEST_ASSERT(multiseg_count > 0,
+		    "Expected multi-segment mbufs for jumbo packets");
+
+	printf("Scatter jumbo RX PASSED: %u/%u packets were multi-segment\n",
+	       multiseg_count, received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	/* Cleanup shared temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_lsc_iface),
+		TEST_CASE(test_eof_rx),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_vlan_offload_set),
+		TEST_CASE(test_vlan_strip_infinite_rx),
+		TEST_CASE(test_timestamp_infinite_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASE(test_snaplen_truncation_multiseg),
+		TEST_CASE(test_scatter_drop_oversized),
+		TEST_CASE(test_scatter_jumbo_rx),
+
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index ed8d96f7b6..62abc9cc1d 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -127,6 +127,7 @@ New Features
   * Added support for Link State interrupt in ``iface`` mode.
   * Added ``eof`` devarg to use link state to signal end of receive
     file input.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.51.0

[PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Stephen Hemminger]

When the source port has VLAN strip enabled, captured packets have
the VLAN tag in mbuf metadata (vlan_tci) but not in the packet data.
Similarly, TX captures with pending VLAN insert have the tag only
in metadata. The resulting pcap files contain untagged packets.

Convert RX_VLAN_STRIPPED metadata to TX_VLAN offload requests on
dequeued mbufs and call rte_eth_tx_prepare() before rte_eth_tx_burst()
so the pcap vdev inserts the tag into the packet data.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 lib/pdump/rte_pdump.c | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/lib/pdump/rte_pdump.c b/lib/pdump/rte_pdump.c
index ac94efe7ff..6ffe72e284 100644
--- a/lib/pdump/rte_pdump.c
+++ b/lib/pdump/rte_pdump.c
@@ -9,6 +9,7 @@
 #include <rte_mbuf.h>
 #include <rte_ethdev.h>
 #include <rte_lcore.h>
+#include <rte_ether.h>
 #include <rte_log.h>
 #include <rte_memzone.h>
 #include <rte_errno.h>
@@ -135,6 +136,29 @@ pdump_cb_release(struct pdump_rxtx_cbs *cbs)
 	rte_atomic_store_explicit(&cbs->use_count, count, rte_memory_order_release);
 }
 
+/*
+ * Reconstruct VLAN tag in packet data if it was offloaded to metadata.
+ *
+ * When VLAN strip is active on RX, or VLAN insert is pending on TX,
+ * the VLAN tag exists only in mbuf metadata (vlan_tci / ol_flags)
+ * and not in the packet data.  For packet capture we need the
+ * complete wire-format packet, so insert the tag back into the
+ * cloned mbuf.
+ */
+static inline void
+pdump_vlan_restore(struct rte_mbuf *m)
+{
+	if (m->ol_flags & (RTE_MBUF_F_RX_VLAN_STRIPPED | RTE_MBUF_F_TX_VLAN)) {
+		if (rte_vlan_insert(&m) != 0)
+			return;
+		/*
+		 * Clear offload flags so the pcap writer sees the packet
+		 * as a plain tagged frame rather than acting on these again.
+		 */
+		m->ol_flags &= ~(RTE_MBUF_F_RX_VLAN_STRIPPED | RTE_MBUF_F_TX_VLAN);
+	}
+}
+
 /* Create a clone of mbuf to be placed into ring. */
 static void
 pdump_copy_burst(uint16_t port_id, uint16_t queue_id,
@@ -182,8 +206,14 @@ pdump_copy_burst(uint16_t port_id, uint16_t queue_id,
 
 		if (unlikely(p == NULL))
 			rte_atomic_fetch_add_explicit(&stats->nombuf, 1, rte_memory_order_relaxed);
-		else
+		else {
+			/*
+			 * Restore any VLAN tag that was offloaded to metadata
+			 * so the captured packet has the complete wire format.
+			 */
+			pdump_vlan_restore(p);
 			dup_bufs[d_pkts++] = p;
+		}
 	}
 
 	if (d_pkts == 0)
-- 
2.51.0

Re: [PATCH v20 01/25] maintainers: update for pcap driver

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:39AM -0700, Stephen Hemminger wrote:
> Nominate myself to take care of this since already doing pcapng
> and pdump code.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>

Thanks for agreeing to step up here, Stephen.

Acked-by: Bruce Richardson <bruce.richardson@intel.com>

> ---
>  MAINTAINERS | 1 +
>  1 file changed, 1 insertion(+)
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 5eb8e9dc22..a8e375ddab 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -1116,6 +1116,7 @@ F: doc/guides/nics/zxdh.rst
>  F: doc/guides/nics/features/zxdh.ini
>  
>  PCAP PMD
> +M: Stephen Hemminger <stephen@networkplumber.org>
>  F: drivers/net/pcap/
>  F: doc/guides/nics/pcap.rst
>  F: doc/guides/nics/features/pcap.ini
> -- 
> 2.51.0
> 

Re: [PATCH v20 03/25] doc: update features for PCAP PMD

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:41AM -0700, Stephen Hemminger wrote:
> The PCAP PMD supports more features that were not flagged
> in the feature matrix.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---

With one item below fixed:

Acked-by: Bruce Richardson <bruce.richardson@intel.com>


>  doc/guides/nics/features/pcap.ini | 7 +++++++
>  1 file changed, 7 insertions(+)
> 
> diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
> index 7fd22b190e..c4f0360a06 100644
> --- a/doc/guides/nics/features/pcap.ini
> +++ b/doc/guides/nics/features/pcap.ini
> @@ -4,8 +4,15 @@
>  ; Refer to default.ini for the full list of available PMD features.
>  ;
>  [Features]
> +Link status          = Y
> +Queue start/stop     = Y
> +Timestamp offload    = Y

I'd omit this or put it as partial. There is no support for Timestamps on
Tx, so you can't use this for PTP, for example, as you can't get the exact
time a packet was transmitted.

>  Basic stats          = Y
> +Stats per queue      = Y
>  Multiprocess aware   = Y
> +FreeBSD              = Y
> +Linux                = Y
> +Windows              = Y
>  ARMv7                = Y
>  ARMv8                = Y
>  Power8               = Y
> -- 
> 2.51.0
> 

Re: [PATCH v20 04/25] net/pcap: include used headers

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:42AM -0700, Stephen Hemminger wrote:
> Include the used headers instead of relying on getting
> the headers indirectly through other headers.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Re: [PATCH v20 05/25] net/pcap: remove unnecessary casts

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:43AM -0700, Stephen Hemminger wrote:
> The function rte_zmalloc returns void * so cast is unnecessary.
> 
> Correct the indentation in that code. Not really worth backporting.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---

Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Though one comment (and mini-rant, sorry!) inline below. Ok with this
change as-is if you aren't respinning the set.


>  drivers/net/pcap/pcap_ethdev.c | 11 ++++-------
>  1 file changed, 4 insertions(+), 7 deletions(-)
> 
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index 4513d46d61..fbd1021c39 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -1220,9 +1220,8 @@ pmd_init_internals(struct rte_vdev_device *vdev,
>  	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
>  		numa_node);
>  
> -	pp = (struct pmd_process_private *)
> -		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
> -				RTE_CACHE_LINE_SIZE);
> +	pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
> +			 RTE_CACHE_LINE_SIZE);
>  

Not a major issue, but scanning through the existing file it uses more
double-tab indent than aligning with braces. Personally for a refactor like
this I'd just avoid unnecessarily changing the second line. [This is one
reason why I hate this aligning with brackets, if you change the first
line, you have to change the following ones too! Makes refactoring or
renaming have either broken indentation or far larger diffs. Given the
capabilities of AI, I would very much tend towards making our code more
"refactor safe", as changes are less likely to made manually.]

>  	if (pp == NULL) {
>  		PMD_LOG(ERR,
> @@ -1590,10 +1589,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
>  		unsigned int i;
>  
>  		internal = eth_dev->data->dev_private;
> -			pp = (struct pmd_process_private *)
> -				rte_zmalloc(NULL,
> -					sizeof(struct pmd_process_private),
> -					RTE_CACHE_LINE_SIZE);
> +		pp = rte_zmalloc(NULL, sizeof(struct pmd_process_private),
> +				 RTE_CACHE_LINE_SIZE);
>  
>  		if (pp == NULL) {
>  			PMD_LOG(ERR,
> -- 
> 2.51.0
> 

Re: [PATCH v20 06/25] net/pcap: avoid using rte_malloc and rte_memcpy

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:44AM -0700, Stephen Hemminger wrote:
> No need to use rte_malloc or rte_memcpy in the short
> code to get MAC address.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---

Acked-by: Bruce Richardson <bruce.richardson@intel.com>

>  drivers/net/pcap/pcap_ethdev.c        |  3 ++-
>  drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
>  drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
>  3 files changed, 10 insertions(+), 11 deletions(-)
> 
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index fbd1021c39..806451dc99 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -6,6 +6,7 @@
>  
>  #include <stdio.h>
>  #include <stdlib.h>
> +#include <string.h>
>  #include <time.h>
>  #include <inttypes.h>
>  #include <errno.h>
> @@ -1288,7 +1289,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
>  		return -1;
>  
>  	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
> -	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
> +	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
>  	eth_dev->data->mac_addrs = mac_addrs;
>  	return 0;
>  }
> diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
> index 20556b3e92..0185665f0b 100644
> --- a/drivers/net/pcap/pcap_osdep_freebsd.c
> +++ b/drivers/net/pcap/pcap_osdep_freebsd.c
> @@ -4,13 +4,11 @@
>   * All rights reserved.
>   */
>  
> +#include <string.h>
>  #include <net/if.h>
>  #include <net/if_dl.h>
>  #include <sys/sysctl.h>
>  
> -#include <rte_malloc.h>
> -#include <rte_memcpy.h>
> -
>  #include "pcap_osdep.h"
>  
>  int
> @@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
>  	if (len == 0)
>  		return -1;
>  
> -	buf = rte_malloc(NULL, len, 0);
> +	buf = malloc(len);
>  	if (!buf)
>  		return -1;
>  

It's a pity there is no defined max length here that we can use a static
buffer, but since there isn't using malloc rather than rte_malloc is best.

>  	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
> -		rte_free(buf);
> +		free(buf);
>  		return -1;
>  	}
>  	ifm = (struct if_msghdr *)buf;
>  	sdl = (struct sockaddr_dl *)(ifm + 1);
>  
> -	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
> +	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
>  
> -	rte_free(buf);
> +	free(buf);
>  	return 0;
>  }
> diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
> index 97033f57c5..df976417cb 100644
> --- a/drivers/net/pcap/pcap_osdep_linux.c
> +++ b/drivers/net/pcap/pcap_osdep_linux.c
> @@ -4,12 +4,12 @@
>   * All rights reserved.
>   */
>  
> +#include <string.h>
> +#include <unistd.h>
>  #include <net/if.h>
>  #include <sys/ioctl.h>
>  #include <sys/socket.h>
> -#include <unistd.h>
>  
> -#include <rte_memcpy.h>
>  #include <rte_string_fns.h>
>  
>  #include "pcap_osdep.h"
> @@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
>  		return -1;
>  	}
>  
> -	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
> +	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
>  
>  	close(if_fd);
>  	return 0;
> -- 
> 2.51.0
> 

Re: [PATCH v20 07/25] net/pcap: advertise Tx multi segment

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:45AM -0700, Stephen Hemminger wrote:
> The driver supports multi-segment transmit, but the did not set
> the offload flag. Therefore applications would not know about
> that capability.
> 
> Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
> Cc: stable@dpdk.org
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Re: [PATCH v20 08/25] net/pcap: replace stack bounce buffer

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:46AM -0700, Stephen Hemminger wrote:
> Replace the 64K stack-allocated bounce buffer with a per-queue
> buffer allocated from hugepages via rte_malloc at queue setup.
> This is necessary because the buffer may be used in a secondary
> process transmit path where the primary process allocated it.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Re: [PATCH v20 09/25] net/pcap: fix error accounting and backpressure on transmit

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:47AM -0700, Stephen Hemminger wrote:
> The error handling when pcap_sendpacket() was incorrect.
> When underlying kernel socket buffer got full the send was counted as
> an error. Malformed multi-segment mbufs where pkt_len exceeds actual
> data were silently accepted.
> 
> On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
> socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
> The send() call only blocks when the kernel socket send buffer is full,
> providing limited backpressure. Backpressure is not an error.
> 

I think we need a clearer explanation of what this patch does, this didn't
make sense to me on reading it. See also comments inline below - I think we
can get a better patch with a clearer explanation by just focusing on the
changes to eth_pcap_tx. If you want to update the tx_dumper function put it
in a different patch with a different explanation.

> Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
> Cc: stable@dpdk.org
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>

With commit log clarified, I'm ok with this, but would prefer a smaller
patch.

Acked-by: Bruce Richardson <bruce.richardson@intel.com>


> ---
>  drivers/net/pcap/pcap_ethdev.c | 58 +++++++++++++++++++++-------------
>  1 file changed, 36 insertions(+), 22 deletions(-)
> 
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index 72a297d423..47a050df11 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -407,7 +407,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  	 * dumper */
>  	for (i = 0; i < nb_pkts; i++) {
>  		struct rte_mbuf *mbuf = bufs[i];
> -		size_t len, caplen;
> +		uint32_t len, caplen;
> +		const uint8_t *data;
>  
>  		len = rte_pktmbuf_pkt_len(mbuf);
>  		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
> @@ -415,15 +416,16 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  		calculate_timestamp(&header.ts);
>  		header.len = len;
>  		header.caplen = caplen;
> -		/* rte_pktmbuf_read() returns a pointer to the data directly
> -		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
> -		 * a pointer to temp_data after copying into it.
> -		 */
> -		pcap_dump((u_char *)dumper, &header,
> -			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
> +
> +		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
> +
> +		/* This could only happen if mbuf is bogus pkt_len > data_len */
> +		RTE_ASSERT(data != NULL);
> +		pcap_dump((u_char *)dumper, &header, data);
>  
>  		num_tx++;
>  		tx_bytes += caplen;
> +
>  		rte_pktmbuf_free(mbuf);
>  	}
>  
> @@ -435,9 +437,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  	pcap_dump_flush(dumper);
>  	dumper_q->tx_stat.pkts += num_tx;
>  	dumper_q->tx_stat.bytes += tx_bytes;
> -	dumper_q->tx_stat.err_pkts += nb_pkts - num_tx;
>  
> -	return nb_pkts;
> +	return i;
>  }

While not wrong or problematic, the changes here are unnecessary IMHO,
since there is no error that I can see in this function. The changes I see
are:
* change datatype from size_t to uint32_t - ok but the original code wasn't
  really wrong for this.
* having an RTE_ASSERT for the data being NULL - I suppose this is useful
  for certain debug builds, but only if the user knows to define
  RTE_ENABLE_ASSERT.
* extra whitespace line - unnecessary
* drop status increment - the num_tx value would always equal nb_pkts, so
  this was an increment of zero. Removing it is good, as it saves a store.
* change return value from nb_pkts to i - this is equivalent since the loop
  always completes so that i == nb_pkts, so change is not needed.

The change I would keep is the unnecessary error increment since it was
always zero - however, it doesn't go far enough, as num_tx can be removed
in the function completely. By function end, i == num_tx == nb_pkts, so
let's just use nb_pkts directly, and we can also make "i" a loop-local
variable.

>  
>  /*
> @@ -462,7 +463,17 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  }
>  
>  /*
> - * Callback to handle sending packets through a real NIC.
> + * Send a burst of packets to a pcap device.
> + *
> + * On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
> + * socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
> + * The send() call only blocks when the kernel socket send buffer is full,
> + * providing limited backpressure.
> + *
> + * On error, pcap_sendpacket() returns non-zero and the loop breaks,
> + * leaving remaining packets unsent.
> + *
> + * Bottom line: backpressure is not an error.
>   */
>  static uint16_t
>  eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
> @@ -484,34 +495,37 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  
>  	for (i = 0; i < nb_pkts; i++) {
>  		struct rte_mbuf *mbuf = bufs[i];
> -		size_t len = rte_pktmbuf_pkt_len(mbuf);
> -		int ret;
> +		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
> +		const uint8_t *data;
>  
> -		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
> -				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
> +		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
>  			PMD_LOG(ERR,
> -				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
> +				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
>  				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
> +			tx_queue->tx_stat.err_pkts++;
>  			rte_pktmbuf_free(mbuf);
>  			continue;
>  		}
>  
> -		/* rte_pktmbuf_read() returns a pointer to the data directly
> -		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
> -		 * a pointer to temp_data after copying into it.
> +		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
> +		RTE_ASSERT(data != NULL);
> +
> +		/*
> +		 * No good way to separate back pressure from failure here
> +		 * Assume it is EBUSY, ENOMEM, or EINTR, something that can be retried.
>  		 */
> -		ret = pcap_sendpacket(pcap,
> -			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
> -		if (unlikely(ret != 0))
> +		if (pcap_sendpacket(pcap, data, len) != 0) {
> +			PMD_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
>  			break;
> +		}
>  		num_tx++;
>  		tx_bytes += len;
> +
>  		rte_pktmbuf_free(mbuf);
>  	}
>  
>  	tx_queue->tx_stat.pkts += num_tx;
>  	tx_queue->tx_stat.bytes += tx_bytes;
> -	tx_queue->tx_stat.err_pkts += i - num_tx;
>  
>  	return i;
>  }
> -- 
> 2.51.0
> 

Re: [PATCH v20 10/25] net/pcap: add datapath debug logging

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:48AM -0700, Stephen Hemminger wrote:
> Add datapath debug logging macros (PMD_RX_LOG, PMD_TX_LOG) gated
> on RTE_ETHDEV_DEBUG_RX/TX. Use PMD_TX_LOG in transmit error paths
> to aid debugging without impacting normal datapath performance.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Re: [PATCH v20 11/25] net/pcap: consolidate boolean flag handling

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:49AM -0700, Stephen Hemminger wrote:
> Convert internal flag fields from int/unsigned int to bool for clarity
> and reduced structure size.
> 
> Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
> into a single process_bool_flag() handler. The new function also adds
> proper validation, rejecting values other than "0", "1", or empty (which
> defaults to true).
> 
> Also change num_of_queue from unsigned int to uint16_t since it cannot
> exceed RTE_PMD_PCAP_MAX_QUEUES.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>

Acked-by: Bruce Richardson <bruce.richardson@intel.com>

One minor comment inline below.

> ---
>  drivers/net/pcap/pcap_ethdev.c | 69 +++++++++++++++-------------------
>  1 file changed, 30 insertions(+), 39 deletions(-)
> 
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index 258cffb813..c3270a676c 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -7,6 +7,7 @@
>  #include <stdio.h>
>  #include <stdlib.h>
>  #include <string.h>
> +#include <stdbool.h>
>  #include <time.h>
>  #include <inttypes.h>
>  #include <errno.h>
> @@ -102,9 +103,9 @@ struct pmd_internals {
>  	char devargs[ETH_PCAP_ARG_MAXLEN];
>  	struct rte_ether_addr eth_addr;
>  	int if_index;
> -	int single_iface;
> -	int phy_mac;
> -	unsigned int infinite_rx;
> +	bool single_iface;
> +	bool phy_mac;
> +	bool infinite_rx;
>  };
>  
>  struct pmd_process_private {
> @@ -114,25 +115,25 @@ struct pmd_process_private {
>  };
>  
>  struct pmd_devargs {
> -	unsigned int num_of_queue;
> +	uint16_t num_of_queue;
> +	bool phy_mac;
>  	struct devargs_queue {
>  		pcap_dumper_t *dumper;
>  		pcap_t *pcap;
>  		const char *name;
>  		const char *type;
>  	} queue[RTE_PMD_PCAP_MAX_QUEUES];
> -	int phy_mac;
>  };
>  
>  struct pmd_devargs_all {
>  	struct pmd_devargs rx_queues;
>  	struct pmd_devargs tx_queues;
> -	int single_iface;
> -	unsigned int is_tx_pcap;
> -	unsigned int is_tx_iface;
> -	unsigned int is_rx_pcap;
> -	unsigned int is_rx_iface;
> -	unsigned int infinite_rx;
> +	bool single_iface;
> +	bool is_tx_pcap;
> +	bool is_tx_iface;
> +	bool is_rx_pcap;
> +	bool is_rx_iface;
> +	bool infinite_rx;
>  };
>  
>  static const char *valid_arguments[] = {
> @@ -884,7 +885,7 @@ eth_dev_close(struct rte_eth_dev *dev)
>  		}
>  	}
>  
> -	if (internals->phy_mac == 0)
> +	if (!internals->phy_mac)
>  		/* not dynamically allocated, must not be freed */
>  		dev->data->mac_addrs = NULL;
>  
> @@ -1209,29 +1210,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
>  }
>  
>  static int
> -select_phy_mac(const char *key __rte_unused, const char *value,
> -		void *extra_args)
> +process_bool_flag(const char *key, const char *value, void *extra_args)
>  {
> -	if (extra_args) {
> -		const int phy_mac = atoi(value);
> -		int *enable_phy_mac = extra_args;
> -
> -		if (phy_mac)
> -			*enable_phy_mac = 1;
> -	}
> -	return 0;
> -}
> -
> -static int
> -get_infinite_rx_arg(const char *key __rte_unused,
> -		const char *value, void *extra_args)
> -{
> -	if (extra_args) {
> -		const int infinite_rx = atoi(value);
> -		int *enable_infinite_rx = extra_args;
> -
> -		if (infinite_rx > 0)
> -			*enable_infinite_rx = 1;
> +	bool *flag = extra_args;
> +
> +	if (value == NULL || *value == '\0') {
> +		*flag = true; /* default with no additional argument */
> +	} else if (strcmp(value, "0") == 0) {
> +		*flag = false;
> +	} else if (strcmp(value, "1") == 0) {
> +		*flag = true;
> +	} else {
> +		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
> +		return -1;
>  	}
>  	return 0;
>  }
> @@ -1507,7 +1498,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
>  		dumpers.queue[0] = pcaps.queue[0];
>  
>  		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
> -				&select_phy_mac, &pcaps.phy_mac);
> +					 &process_bool_flag, &pcaps.phy_mac);
>  		if (ret < 0)
>  			goto free_kvlist;
>  
> @@ -1546,9 +1537,9 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
>  
>  		if (infinite_rx_arg_cnt == 1) {
>  			ret = rte_kvargs_process(kvlist,
> -					ETH_PCAP_INFINITE_RX_ARG,
> -					&get_infinite_rx_arg,
> -					&devargs_all.infinite_rx);
> +						 ETH_PCAP_INFINITE_RX_ARG,
> +						 &process_bool_flag,
> +						 &devargs_all.infinite_rx);

You can shrink the diff by leaving the indentation alone, there is nothing
wrong with it! :-)

>  			if (ret < 0)
>  				goto free_kvlist;
>  			PMD_LOG(INFO, "infinite_rx has been %s for %s",
> @@ -1698,5 +1689,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
>  	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
>  	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
>  	ETH_PCAP_IFACE_ARG "=<ifc> "
> -	ETH_PCAP_PHY_MAC_ARG "=<int>"
> +	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
>  	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
> -- 
> 2.51.0
> 

Re: [PATCH v20 12/25] net/pcap: support VLAN strip and insert offloads

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:50AM -0700, Stephen Hemminger wrote:
> Add VLAN tag handling to the pcap PMD, consistent with how virtio
> and af_packet drivers implement it. This also gets used for
> capture of VLAN tagged packets when legacy pdump is used.
> 
> RX strip: when RTE_ETH_RX_OFFLOAD_VLAN_STRIP is enabled, the driver
> calls rte_vlan_strip() on received packets in both normal and
> infinite_rx modes. For infinite_rx, offloads are deferred to
> packet delivery rather than applied during ring fill, so the
> stored template packets remain unmodified.
> 
> TX insert: when RTE_MBUF_F_TX_VLAN is set on an mbuf, the driver
> inserts the VLAN tag via rte_vlan_insert() before writing to pcap
> or sending to the interface. Indirect or shared mbufs get a new
> header mbuf to avoid modifying the original.
> 
> Runtime reconfiguration is supported through vlan_offload_set,
> which propagates the strip setting to all active RX queues.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
>  doc/guides/nics/features/pcap.ini      |  1 +
>  doc/guides/nics/pcap.rst               | 11 +++
>  doc/guides/rel_notes/release_26_03.rst |  5 ++
>  drivers/net/pcap/pcap_ethdev.c         | 96 ++++++++++++++++++++++++--
>  4 files changed, 109 insertions(+), 4 deletions(-)
> 
> diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
> index c4f0360a06..ec7c91c650 100644
> --- a/doc/guides/nics/features/pcap.ini
> +++ b/doc/guides/nics/features/pcap.ini
> @@ -9,6 +9,7 @@ Queue start/stop     = Y
>  Timestamp offload    = Y
>  Basic stats          = Y
>  Stats per queue      = Y
> +VLAN offload         = Y
>  Multiprocess aware   = Y
>  FreeBSD              = Y
>  Linux                = Y
> diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
> index fbfe854bb1..bed5006a42 100644
> --- a/doc/guides/nics/pcap.rst
> +++ b/doc/guides/nics/pcap.rst
> @@ -247,3 +247,14 @@ will be discarded by the Rx flushing operation.
>     The network interface provided to the PMD should be up.
>     The PMD will return an error if the interface is down,
>     and the PMD itself won't change the status of the external network interface.
> +
> +Features and Limitations
> +~~~~~~~~~~~~~~~~~~~~~~~~
> +
> +*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
> +   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
> +   application.
> +
> +*  The PMD will transparently insert a VLAN tag to transmitted packets if
> +   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
> +   set.
> diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
> index d121951f5c..6aef623bf8 100644
> --- a/doc/guides/rel_notes/release_26_03.rst
> +++ b/doc/guides/rel_notes/release_26_03.rst
> @@ -118,6 +118,11 @@ New Features
>    Added handling of the key combination Control+L
>    to clear the screen before redisplaying the prompt.
>  
> +* **Updated PCAP ethernet driver.**
> +
> +  * Added support for VLAN insertion and stripping.
> +
> +
>  Removed Items
>  -------------
>  
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index c3270a676c..c49ca7fa2b 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -76,6 +76,7 @@ struct queue_missed_stat {
>  struct pcap_rx_queue {
>  	uint16_t port_id;
>  	uint16_t queue_id;
> +	bool vlan_strip;
>  	struct rte_mempool *mb_pool;
>  	struct queue_stat rx_stat;
>  	struct queue_missed_stat missed_stat;
> @@ -106,6 +107,7 @@ struct pmd_internals {
>  	bool single_iface;
>  	bool phy_mac;
>  	bool infinite_rx;
> +	bool vlan_strip;
>  };
>  
>  struct pmd_process_private {
> @@ -270,7 +272,11 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  		bufs[i]->data_len = pcap_buf->data_len;
>  		bufs[i]->pkt_len = pcap_buf->pkt_len;
>  		bufs[i]->port = pcap_q->port_id;
> -		rx_bytes += pcap_buf->data_len;
> +
> +		if (pcap_q->vlan_strip)
> +			rte_vlan_strip(bufs[i]);
> +
> +		rx_bytes += bufs[i]->data_len;
>  
>  		/* Enqueue packet back on ring to allow infinite rx. */
>  		rte_ring_enqueue(pcap_q->pkts, pcap_buf);
> @@ -336,6 +342,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  		}
>  
>  		mbuf->pkt_len = len;
> +
> +		if (pcap_q->vlan_strip)
> +			rte_vlan_strip(mbuf);
> +
>  		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
>  
>  		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
> @@ -382,6 +392,39 @@ calculate_timestamp(struct timeval *ts) {
>  	}
>  }
>  
> +static uint16_t
> +eth_pcap_tx_prepare(void *queue __rte_unused, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
> +{
> +	uint16_t nb_tx;
> +	int error;
> +
> +	for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
> +		struct rte_mbuf *m = tx_pkts[nb_tx];
> +
> +#ifdef RTE_LIBRTE_ETHDEV_DEBUG
> +		error = rte_validate_tx_offload(m);
> +		if (unlikely(error)) {
> +			rte_errno = -error;
> +			break;
> +		}
> +#endif
> +		/* Do VLAN tag insertion */
> +		if (unlikely(m->ol_flags & RTE_MBUF_F_TX_VLAN)) {
> +			error = rte_vlan_insert(&m);
> +
> +			/* rte_vlan_insert() could change pointer (currently does not) */
> +			tx_pkts[nb_tx] = m;
> +
> +			if (unlikely(error != 0)) {
> +				PMD_TX_LOG(ERR, "rte_vlan_insert failed: %s", strerror(-error));
> +				rte_errno = -error;
> +				break;
> +			}
> +		}
> +	}
> +	return nb_tx;
> +}
> +

Are we sure this is the correct way to do this? To behave like a normal NIC
the Tx VLAN tag should be inserted in the Tx function, rather than tx
prepare should it not? There is no guarantee apps will call tx_prepare
before Tx.

/Bruce

Re: [PATCH v20 13/25] net/pcap: add link status for interface mode

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:51AM -0700, Stephen Hemminger wrote:
> When the PCAP PMD is used in pass-through mode with a physical
> interface (iface=X), the link status was always reported with
> hardcoded values regardless of the actual interface state.
> 
> Add OS-dependent function to query the real link state from
> the underlying interface.
> 
> Linux and FreeBSD use SIOCGIFFLAGS to check IFF_UP and
> IFF_RUNNING. Windows uses GetAdaptersAddresses() to check
> OperStatus.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---

Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Any reason we can't in future similarly query the link speed of the
interface in use, and the other link parameters?

Re: [PATCH v20 14/25] net/pcap: support nanosecond timestamp precision

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:52AM -0700, Stephen Hemminger wrote:
> Enable nanosecond-precision timestamps for both live capture and pcap
> file reading.
> 
> Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
> which allows setting PCAP_TSTAMP_PRECISION_NANO before
> activation. Similarly, use pcap_open_offline_with_tstamp_precision()
> for reading pcap files. The pcap_pkthdr timestamp field, despite being
> declared as struct timeval, actually contains nanoseconds (not
> microseconds) when nanosecond precision is requested.
> 
> Make receive timestamp offloading conditional: timestamps are now only
> written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
> enabled. Previously, timestamps were unconditionally added to every
> received packet.
> 
> Other related changes:
> * Add read_clock dev_op returning current UTC time for timestamp
>   correlation.
> * Move per-burst timestamp calculation outside the packet loop in
>   tx_dumper.
> * Enable immediate mode and improve error reporting
>   in live capture setup.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
>  doc/guides/nics/pcap.rst               |   3 +
>  doc/guides/rel_notes/release_26_03.rst |   1 +
>  drivers/net/pcap/pcap_ethdev.c         | 156 +++++++++++++++++++------
>  3 files changed, 126 insertions(+), 34 deletions(-)
> 
> diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
> index bed5006a42..2709c6d017 100644
> --- a/doc/guides/nics/pcap.rst
> +++ b/doc/guides/nics/pcap.rst
> @@ -258,3 +258,6 @@ Features and Limitations
>  *  The PMD will transparently insert a VLAN tag to transmitted packets if
>     ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
>     set.
> +
> +*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
> +   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
> diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
> index 35a191b45f..b06e1e72ee 100644
> --- a/doc/guides/rel_notes/release_26_03.rst
> +++ b/doc/guides/rel_notes/release_26_03.rst
> @@ -122,6 +122,7 @@ New Features
>  
>    * Added support for VLAN insertion and stripping.
>    * Added support for reporting link state in ``iface`` mode.
> +  * Receive timestamps support nanosecond precision.
>  
>  
>  Removed Items
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index 232b8fa4b1..6b728c6009 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -27,13 +27,11 @@
>  #include <rte_mbuf_dyn.h>
>  #include <bus_vdev_driver.h>
>  #include <rte_os_shim.h>
> +#include <rte_time.h>
>  
>  #include "pcap_osdep.h"
>  
>  #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
> -#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
> -#define RTE_ETH_PCAP_PROMISC 1
> -#define RTE_ETH_PCAP_TIMEOUT -1
>  
>  #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
>  #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
> @@ -77,6 +75,7 @@ struct pcap_rx_queue {
>  	uint16_t port_id;
>  	uint16_t queue_id;
>  	bool vlan_strip;
> +	bool timestamp_offloading;
>  	struct rte_mempool *mb_pool;
>  	struct queue_stat rx_stat;
>  	struct queue_missed_stat missed_stat;
> @@ -108,6 +107,7 @@ struct pmd_internals {
>  	bool phy_mac;
>  	bool infinite_rx;
>  	bool vlan_strip;
> +	bool timestamp_offloading;
>  };
>  
>  struct pmd_process_private {
> @@ -269,6 +269,15 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  		if (pcap_q->vlan_strip)
>  			rte_vlan_strip(bufs[i]);
>  
> +		if (pcap_q->timestamp_offloading) {
> +			struct timespec ts;
> +
> +			timespec_get(&ts, TIME_UTC);
> +			*RTE_MBUF_DYNFIELD(bufs[i], timestamp_dynfield_offset,
> +					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(&ts);
> +			bufs[i]->ol_flags |= timestamp_rx_dynflag;
> +		}
> +
>  		rx_bytes += bufs[i]->data_len;
>  
>  		/* Enqueue packet back on ring to allow infinite rx. */
> @@ -339,10 +348,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  		if (pcap_q->vlan_strip)
>  			rte_vlan_strip(mbuf);
>  
> -		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
> +		if (pcap_q->timestamp_offloading) {
> +			/*
> +			 * The use of tv_usec as nanoseconds is not a bug here.
> +			 * Interface is always created with nanosecond precision, and
> +			 * that is how pcap API bodged in nanoseconds support.
> +			 */
> +			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
> +				+  header->ts.tv_usec;
> +
> +			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
> +					   rte_mbuf_timestamp_t *) = ns;
> +
> +			mbuf->ol_flags |= timestamp_rx_dynflag;
> +		}
>  
> -		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
> -		mbuf->ol_flags |= timestamp_rx_dynflag;
>  		mbuf->port = pcap_q->port_id;
>  		bufs[num_rx] = mbuf;
>  		num_rx++;
> @@ -362,14 +382,19 @@ eth_null_rx(void *queue __rte_unused,
>  	return 0;
>  }
>  
> -#define NSEC_PER_SEC	1000000000L
> -
>  /*
> - * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
> - * because `ts` goes directly to nanosecond-precision dump.
> + * Calculate current timestamp in nanoseconds by computing
> + * offset from starting time value.
> + *
> + * Note: it is not a bug that this code is putting nanosecond
> + * value into microsecond timeval field. The pcap API is old
> + * and nanoseconds were bodged on as an after thought.
> + * As long as the pcap stream is set to nanosecond precision
> + * it expects nanoseconds here.
>   */
>  static inline void
> -calculate_timestamp(struct timeval *ts) {
> +calculate_timestamp(struct timeval *ts)
> +{
>  	uint64_t cycles;
>  	struct timespec cur_time;
>  
> @@ -440,8 +465,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  	if (dumper == NULL || nb_pkts == 0)
>  		return 0;
>  
> -	/* writes the nb_pkts packets to the previously opened pcap file
> -	 * dumper */
> +	/* all packets in burst have same timestamp */
> +	calculate_timestamp(&header.ts);
> +
> +	/* writes the nb_pkts packets to the previously opened pcap file dumper */
>  	for (i = 0; i < nb_pkts; i++) {
>  		struct rte_mbuf *mbuf = bufs[i];
>  		uint32_t len, caplen;
> @@ -450,8 +477,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  		len = rte_pktmbuf_pkt_len(mbuf);
>  		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
>  
> -		calculate_timestamp(&header.ts);
> -
>  		header.len = len;
>  		header.caplen = caplen;
>  
> @@ -573,22 +598,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>   * pcap_open_live wrapper function
>   */
>  static inline int
> -open_iface_live(const char *iface, pcap_t **pcap) {
> -	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
> -			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
> +open_iface_live(const char *iface, pcap_t **pcap)
> +{
> +	pcap_t *pc;
> +	int status;
>  
> -	if (*pcap == NULL) {
> -		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
> -		return -1;
> +	pc = pcap_create(iface, errbuf);
> +	if (pc == NULL) {
> +		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
> +		goto error;
> +	}
> +
> +	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
> +	if (status != 0) {
> +		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
> +			iface, pcap_statustostr(status));
> +		goto error;
> +	}
> +
> +	status = pcap_set_immediate_mode(pc, 1);
> +	if (status != 0)
> +		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
> +			iface, pcap_statustostr(status));
> +
> +	status = pcap_set_promisc(pc, 1);
> +	if (status != 0)
> +		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
> +			iface, pcap_statustostr(status));
> +
> +	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
> +	if (status != 0)
> +		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
> +			iface, pcap_statustostr(status));
> +
> +	status = pcap_activate(pc);
> +	if (status < 0) {
> +		char *cp = pcap_geterr(pc);
> +
> +		if (status == PCAP_ERROR)
> +			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
> +		else
> +			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
> +		goto error;
>  	}
>  
> -	if (pcap_setnonblock(*pcap, 1, errbuf)) {
> +	if (pcap_setnonblock(pc, 1, errbuf)) {
>  		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
> -		pcap_close(*pcap);
> -		return -1;
> +		goto error;
>  	}
>  
> +	*pcap = pc;
>  	return 0;
> +
> +error:
> +	if (pc != NULL)
> +		pcap_close(pc);
> +	return -1;
>  }
>  
>  static int
> @@ -635,7 +700,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
>  static int
>  open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
>  {
> -	*pcap = pcap_open_offline(pcap_filename, errbuf);
> +	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
> +							PCAP_TSTAMP_PRECISION_NANO, errbuf);
>  	if (*pcap == NULL) {
>  		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
>  			errbuf);
> @@ -794,6 +860,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
>  	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
>  
>  	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
> +	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
>  	return 0;
>  }
>  
> @@ -811,7 +878,8 @@ eth_dev_info(struct rte_eth_dev *dev,
>  	dev_info->min_rx_bufsize = 0;
>  	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
>  		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
> -	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
> +	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
> +		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
>  
>  	return 0;
>  }
> @@ -978,6 +1046,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
>  	pcap_q->queue_id = rx_queue_id;
>  	pcap_q->vlan_strip = internals->vlan_strip;
>  	dev->data->rx_queues[rx_queue_id] = pcap_q;
> +	pcap_q->timestamp_offloading = internals->timestamp_offloading;
>  
>  	if (internals->infinite_rx) {
>  		struct pmd_process_private *pp;
> @@ -1116,6 +1185,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
>  	return 0;
>  }
>  
> +/* Timestamp values in receive packets from libpcap are in nanoseconds */
> +static int
> +eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
> +{
> +	struct timespec cur_time;
> +
> +	timespec_get(&cur_time, TIME_UTC);
> +	*timestamp = rte_timespec_to_ns(&cur_time);
> +	return 0;
> +}
> +
>  static int
>  eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
>  {
> @@ -1142,6 +1222,7 @@ static const struct eth_dev_ops ops = {
>  	.dev_close = eth_dev_close,
>  	.dev_configure = eth_dev_configure,
>  	.dev_infos_get = eth_dev_info,
> +	.read_clock = eth_dev_read_clock,
>  	.rx_queue_setup = eth_rx_queue_setup,
>  	.tx_queue_setup = eth_tx_queue_setup,
>  	.tx_queue_release = eth_tx_queue_release,
> @@ -1558,15 +1639,22 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
>  	name = rte_vdev_device_name(dev);
>  	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
>  
> -	timespec_get(&start_time, TIME_UTC);
> -	start_cycles = rte_get_timer_cycles();
> -	hz = rte_get_timer_hz();
> +	/* Record info for timestamps on first probe */
> +	if (hz == 0) {
> +		hz = rte_get_timer_hz();
> +		if (hz == 0) {
> +			PMD_LOG(ERR, "Reported hz is zero!");
> +			return -1;
> +		}
>  
> -	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
> -			&timestamp_rx_dynflag);
> -	if (ret != 0) {
> -		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
> -		return -1;
> +		ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
> +							 &timestamp_rx_dynflag);

Should we not check if timestamps are requested before registering the
dynamic field?

> +		if (ret != 0) {
> +			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
> +			return ret;
> +		}
> +		timespec_get(&start_time, TIME_UTC);
> +		start_cycles = rte_get_timer_cycles();
>  	}
>  
>  	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
> -- 
> 2.51.0
> 

Re: [PATCH v20 16/25] net/pcap: reduce scope of file-level variables

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:54AM -0700, Stephen Hemminger wrote:
> Move errbuf from file scope to local variables in the two functions that
> use it (open_iface_live and open_single_rx_pcap). This avoids potential
> issues if these functions were called concurrently, since each call now
> has its own error buffer.  Move iface_idx to a static local variable
> within pmd_init_internals(), the only function that uses it. The
> variable remains static to preserve the MAC address uniqueness counter
> across calls.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> Acked-by: Marat Khalili <marat.khalili@huawei.com>
> ---
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Re: [PATCH v20 17/25] net/pcap: avoid use of volatile

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:55AM -0700, Stephen Hemminger wrote:
> Using volatile for statistics is not necessary since only one
> thread is allowed to operate on a queue at a time.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---

Well only one queue is allowed to change them, but other threads could read
them, so using volatile is correct in that it tells the compiler not to
cache the values in registers or on the stack. Technically the compiler
could have the stats stored locally somewhere between updates, but in
practice I don't think that situation could ever arise for stats. Therefore
I'm ok with stats being either volatile or not, I doubt the resulting code
will be any different.

Acked-by: Bruce Richardson <bruce.richardson@intel.com>


>  drivers/net/pcap/pcap_ethdev.c | 18 +++++++++---------
>  1 file changed, 9 insertions(+), 9 deletions(-)
> 
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index 8be3a59690..20e4b8e6aa 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -54,10 +54,10 @@ static uint64_t timestamp_rx_dynflag;
>  static int timestamp_dynfield_offset = -1;
>  
>  struct queue_stat {
> -	volatile unsigned long pkts;
> -	volatile unsigned long bytes;
> -	volatile unsigned long err_pkts;
> -	volatile unsigned long rx_nombuf;
> +	uint64_t pkts;
> +	uint64_t bytes;
> +	uint64_t err_pkts;
> +	uint64_t rx_nombuf;
>  };
>  
>  struct queue_missed_stat {
> @@ -901,11 +901,11 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats,
>  	      struct eth_queue_stats *qstats)
>  {
>  	unsigned int i;
> -	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
> -	unsigned long rx_missed_total = 0;
> -	unsigned long rx_nombuf_total = 0, rx_err_total = 0;
> -	unsigned long tx_packets_total = 0, tx_bytes_total = 0;
> -	unsigned long tx_packets_err_total = 0;
> +	uint64_t rx_packets_total = 0, rx_bytes_total = 0;
> +	uint64_t rx_missed_total = 0;
> +	uint64_t rx_nombuf_total = 0, rx_err_total = 0;
> +	uint64_t tx_packets_total = 0, tx_bytes_total = 0;
> +	uint64_t tx_packets_err_total = 0;
>  	const struct pmd_internals *internal = dev->data->dev_private;
>  
>  	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
> -- 
> 2.51.0
> 

Re: [PATCH v20 18/25] net/pcap: clarify maximum received packet

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:56AM -0700, Stephen Hemminger wrote:
> The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
> to the largest value the pcap library will return, so that should
> also be the largest receive buffer.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

>  drivers/net/pcap/pcap_ethdev.c | 3 ++-
>  1 file changed, 2 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index 20e4b8e6aa..2ffbce2448 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -884,10 +884,11 @@ eth_dev_info(struct rte_eth_dev *dev,
>  
>  	dev_info->if_index = internals->if_index;
>  	dev_info->max_mac_addrs = 1;
> -	dev_info->max_rx_pktlen = (uint32_t) -1;
> +	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
>  	dev_info->max_rx_queues = dev->data->nb_rx_queues;
>  	dev_info->max_tx_queues = dev->data->nb_tx_queues;
>  	dev_info->min_rx_bufsize = 0;
> +	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
>  	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
>  		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
>  	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
> -- 
> 2.51.0
> 

Re: [PATCH v20 19/25] eal/windows: add wrapper for access function

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:57AM -0700, Stephen Hemminger wrote:
> Like other Posix functions in unistd.h add wrapper
> using the Windows equivalent.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
>  lib/eal/windows/include/rte_os_shim.h | 1 +
>  lib/eal/windows/include/unistd.h      | 7 +++++++
>  2 files changed, 8 insertions(+)
> 
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Re: [PATCH v20 20/25] net/pcap: add snapshot length devarg

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:58AM -0700, Stephen Hemminger wrote:
> Add a new devarg 'snaplen' to configure the pcap snapshot length,
> which controls the maximum packet size for capture and output.
> 
> The snapshot length affects:
> - The pcap_set_snaplen() call when capturing from interfaces
> - The pcap_open_dead() snapshot parameter for output files
> - The reported max_rx_pktlen in device info
> - The reported max_mtu in device info (snaplen - ethernet header)
> 
> The default value is 65535 bytes, preserving backward compatibility
> with previous driver behavior.
> 
> The snaplen argument is parsed before interface and file arguments
> so that its value is available when pcap handles are opened during
> device creation.
> 
> Example usage:
>   --vdev 'net_pcap0,snaplen=1518,iface=eth0'
>   --vdev 'net_pcap0,snaplen=9000,rx_pcap=in.pcap,tx_pcap=out.pcap'
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Re: [PATCH v20 21/25] net/pcap: add Rx scatter offload

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:09:59AM -0700, Stephen Hemminger wrote:
> Add RTE_ETH_RX_OFFLOAD_SCATTER to the advertised receive offload
> capabilities. Validate in rx_queue_setup that the mbuf pool data
> room is large enough when scatter is not enabled, following the
> same pattern as the virtio driver.
> 
> Gate the multi-segment receive path on the scatter offload flag
> and drop oversized packets when scatter is disabled.
> Reject scatter with infinite_rx mode since the ring-based replay
> path does not support multi-segment mbufs.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
>  drivers/net/pcap/pcap_ethdev.c | 47 +++++++++++++++++++++++++++++++---
>  1 file changed, 44 insertions(+), 3 deletions(-)
> 
> diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
> index 8a2b5c1b4b..d8a924b0cd 100644
> --- a/drivers/net/pcap/pcap_ethdev.c
> +++ b/drivers/net/pcap/pcap_ethdev.c
> @@ -79,6 +79,7 @@ struct pcap_rx_queue {
>  	uint16_t port_id;
>  	uint16_t queue_id;
>  	bool vlan_strip;
> +	bool rx_scatter;
>  	bool timestamp_offloading;
>  	struct rte_mempool *mb_pool;
>  	struct queue_stat rx_stat;
> @@ -112,6 +113,7 @@ struct pmd_internals {
>  	bool phy_mac;
>  	bool infinite_rx;
>  	bool vlan_strip;
> +	bool rx_scatter;
>  	bool timestamp_offloading;
>  };
>  
> @@ -342,14 +344,19 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  			/* pcap packet will fit in the mbuf, can copy it */
>  			rte_memcpy(rte_pktmbuf_mtod(mbuf, void *), packet, len);
>  			mbuf->data_len = len;
> -		} else {
> -			/* Try read jumbo frame into multi mbufs. */
> +		} else if (pcap_q->rx_scatter) {
> +			/* Scatter into multi-segment mbufs. */
>  			if (unlikely(eth_pcap_rx_jumbo(pcap_q->mb_pool,
>  						       mbuf, packet, len) == -1)) {
>  				pcap_q->rx_stat.err_pkts++;
>  				rte_pktmbuf_free(mbuf);
>  				break;
>  			}
> +		} else {
> +			/* Packet too large and scatter not enabled, drop it. */
> +			pcap_q->rx_stat.err_pkts++;
> +			rte_pktmbuf_free(mbuf);
> +			continue;
>  		}
>  
>  		mbuf->pkt_len = len;
> @@ -907,6 +914,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
>  	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
>  
>  	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
> +	internals->rx_scatter = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_SCATTER);
>  	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
>  	return 0;
>  }
> @@ -927,7 +935,8 @@ eth_dev_info(struct rte_eth_dev *dev,
>  	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
>  		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
>  	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
> -		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
> +		RTE_ETH_RX_OFFLOAD_TIMESTAMP |
> +		RTE_ETH_RX_OFFLOAD_SCATTER;
>  

You should check for the infinite_rx mode here and only add the capability
if it's not set.

With that fixed:
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Re: [PATCH v20 22/25] net/pcap: add link status change support for iface mode

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:10:00AM -0700, Stephen Hemminger wrote:
> Add LSC interrupt support for pass-through (iface=) mode so
> applications can receive link state change notifications via
> the standard ethdev callback mechanism.
> 
> Uses alarm-based polling to periodically check the underlying
> interface state via osdep_iface_link_get(). The LSC flag is
> advertised only for iface mode devices, and polling is gated
> on the application enabling intr_conf.lsc in port configuration.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Re: [PATCH v20 23/25] net/pcap: add EOF notification via link status change

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:10:01AM -0700, Stephen Hemminger wrote:
> Add an "eof" devarg for rx_pcap mode that signals end-of-file by
> setting link down and generating an LSC event. This allows
> applications to detect when a pcap file has been fully consumed
> using the standard ethdev callback mechanism.
> 
> The eof and infinite_rx options are mutually exclusive. On device
> restart, the EOF state is reset so the file can be replayed.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Re: [PATCH v20 17/25] net/pcap: avoid use of volatile

[Stephen Hemminger]

On Mon, 16 Mar 2026 14:31:43 +0000
Bruce Richardson <bruce.richardson@intel.com> wrote:

> On Tue, Mar 10, 2026 at 09:09:55AM -0700, Stephen Hemminger wrote:
> > Using volatile for statistics is not necessary since only one
> > thread is allowed to operate on a queue at a time.
> > 
> > Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> > ---  
> 
> Well only one queue is allowed to change them, but other threads could read
> them, so using volatile is correct in that it tells the compiler not to
> cache the values in registers or on the stack. Technically the compiler
> could have the stats stored locally somewhere between updates, but in
> practice I don't think that situation could ever arise for stats. Therefore
> I'm ok with stats being either volatile or not, I doubt the resulting code
> will be any different.
> 
> Acked-by: Bruce Richardson <bruce.richardson@intel.com>


I went back and forth on this. The compiler unless statically linked
with LTO has no chance or seeing across calls.

The other option would be relaxed atomics would also solve
the torn 32 bit counter roll over problem on 32 bit CPU's.

Re: [PATCH v20 24/25] test: add comprehensive test suite for pcap PMD

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:10:02AM -0700, Stephen Hemminger wrote:
> Add unit tests for the pcap PMD covering file and interface modes.
> 
> Tests include:
>   - basic TX to file and RX from file
>   - varied packet sizes and jumbo frames
>   - infinite RX mode
>   - TX drop mode
>   - statistics
>   - interface (iface=) pass-through mode
>   - link status reporting for file and iface modes
>   - link status change (LSC) with interface toggle
>   - EOF notification via LSC
>   - RX timestamps and timestamp with infinite RX
>   - multiple TX/RX queues
>   - VLAN strip, insert, and runtime offload configuration
>   - snapshot length (snaplen) and truncation
> 
> Cross-platform helpers handle temp file creation, interface
> discovery, and VLAN packet generation.
> 
> The LSC link toggle test requires a pre-created dummy interface
> (Linux: dummy0, FreeBSD: disc0) and is skipped if unavailable.
> 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
>  app/test/meson.build                   |    2 +
>  app/test/test_pmd_pcap.c               | 3755 ++++++++++++++++++++++++
>  doc/guides/rel_notes/release_26_03.rst |    1 +
>  3 files changed, 3758 insertions(+)
>  create mode 100644 app/test/test_pmd_pcap.c
> 
Ran this patch through AI for a code review. Below is the output. In
general seems a good addition.

/Bruce

Code Review: test: add comprehensive test suite for pcap PMD
The patch adds a 3755-line test file. The breadth of coverage is commendable — it exercises most of the pcap PMD's devargs. However, there are several concrete problems:

Bugs / Incorrect Logic
1. Duplicate values in test_tx_varied_sizes test array (test_pmd_pcap.c:1203-1205)

PKT_SIZE_SMALL (128) == PACKET_BURST_GEN_PKT_LEN_128 (128), so only two distinct sizes are tested. Furthermore, PKT_SIZE_MIN(60) == PACKET_BURST_GEN_PKT_LEN (60) — the whole point of mixing these constants obscures the fact. The array should use distinct, intentional sizes like PKT_SIZE_MIN, PKT_SIZE_MEDIUM, PKT_SIZE_LARGE.

2. Timestamp exact-match check is non-asserting (test_pmd_pcap.c:2322-2325)

A timestamp accuracy mismatch only prints a warning; the test still passes. This should be a TEST_ASSERT_EQUAL(ts, expected, ...). This is the entire point of having controllable timestamps via create_timestamped_pcap().

Test Quality / Weak Assertions
3. test_tx_varied_sizes doesn't verify file content (test_pmd_pcap.c:1240-1244)
It only checks nb_tx > 0 — it never reads the pcap file back to confirm the sizes were written correctly. Compare with test_jumbo_tx which does read back via get_pcap_packet_sizes(). Both tests should do the same.

4. Statistics test doesn't verify ibytes/obytes values (test_pmd_pcap.c:1462-1474)
test_stats validates ipackets/opackets but despite checking ibytes == 0 && obytes == 0 at init, it never asserts the actual byte totals after traffic. The driver tracks bytes; the test should verify ibytes == received * sizeof(test_packet).

5. test_lsc_iface skips with TEST_SUCCESS instead of TEST_SKIPPED (test_pmd_pcap.c:1981-2000)
Three early-exit paths when no interface is available return TEST_SUCCESS:

Compare with test_iface() at test_pmd_pcap.c:1644 which correctly returns TEST_SKIPPED. This makes CI results misleading — a skipped test looks like a passing one.

6. Similarly in test_rx_timestamp (test_pmd_pcap.c:2308)
When the timestamp dynamic field isn't available, return TEST_SUCCESS is used instead of TEST_SKIPPED.

Racy / Fragile Tests
7. LSC callback detection relies entirely on usleep(1500ms) (test_pmd_pcap.c:2050, test_pmd_pcap.c:2074)
The test sleeps 1.5 seconds twice waiting for the pcap LSC polling thread to detect the interface state change. With no retry/poll loop, this is fragile under load and adds 3 seconds to every run. A small polling loop (for (i = 0; i < 20; i++) { if (lsc_callback_count >= 1) break; usleep(100000); }) would be more robust.

8. EOF callback timing (test_pmd_pcap.c:2229)
usleep(100 * 1000) (100 ms) is used to wait for the EOF alarm to fire, then immediately asserts eof_callback_count == 1. The driver uses rte_eal_alarm_set(1, ...) (1 µs delay), but alarm delivery is not instantaneous under load. The same polling loop pattern would be safer.

Missing Coverage
9. No tests for rx_iface=/tx_iface=/rx_iface_in= devargs
The test covers iface= (symmetric single-interface mode) but completely misses rx_iface=, tx_iface=, and rx_iface_in= (asymmetric / separate RX and TX interface modes). These are distinct code paths in the driver including PCAP_D_IN direction filtering for rx_iface_in.

10. No test for per-queue start/stop
The driver implements rx_queue_start, tx_queue_start, rx_queue_stop, tx_queue_stop. None of these are exercised.

11. imissed stat not tested
The driver has queue_missed_stat_update() using pcap_stats() to track kernel-level drops. This code path (iface mode under load, or mocked via the pcap stat interface) is never exercised.

Minor Issues
12. Shared state between tests (test_pmd_pcap.c:60-61)
tx_pcap_path and vlan_rx_pcap_path are global state shared between test pairs (test_tx_to_file→test_rx_from_file, test_vlan_strip_rx→test_vlan_no_strip_rx). Both have fallback access() checks, but this creates implicit ordering dependencies. The comment documents this, but it's an unusual pattern for a test suite that should have independent cases.

13. Missing rte_cycles.h include for NS_PER_S (test_pmd_pcap.c:2319)
NS_PER_S is used in test_rx_timestamp() but <rte_cycles.h> (where it's defined) is not explicitly included. It compiles today because another included header transitively pulls it in, but the dependency is fragile. A direct #include <rte_cycles.h> should be added.

Re: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Bruce Richardson]

On Tue, Mar 10, 2026 at 09:10:03AM -0700, Stephen Hemminger wrote:
> When the source port has VLAN strip enabled, captured packets have
> the VLAN tag in mbuf metadata (vlan_tci) but not in the packet data.
> Similarly, TX captures with pending VLAN insert have the tag only
> in metadata. The resulting pcap files contain untagged packets.
> 
> Convert RX_VLAN_STRIPPED metadata to TX_VLAN offload requests on
> dequeued mbufs and call rte_eth_tx_prepare() before rte_eth_tx_burst()
> so the pcap vdev inserts the tag into the packet data.
>

This is an example of something I previously flagged. Like with real
hardware, I think the PMD should be inserting the VLAN tag into the packet
as part of the Tx function, not the prepare function.
 
> Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
> ---
>  lib/pdump/rte_pdump.c | 32 +++++++++++++++++++++++++++++++-
>  1 file changed, 31 insertions(+), 1 deletion(-)
> 

RE: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Morten Brørup]

> From: Bruce Richardson [mailto:bruce.richardson@intel.com]
> Sent: Monday, 16 March 2026 16.34
> 
> On Tue, Mar 10, 2026 at 09:10:03AM -0700, Stephen Hemminger wrote:
> > When the source port has VLAN strip enabled, captured packets have
> > the VLAN tag in mbuf metadata (vlan_tci) but not in the packet data.
> > Similarly, TX captures with pending VLAN insert have the tag only
> > in metadata. The resulting pcap files contain untagged packets.
> >
> > Convert RX_VLAN_STRIPPED metadata to TX_VLAN offload requests on
> > dequeued mbufs and call rte_eth_tx_prepare() before
> rte_eth_tx_burst()
> > so the pcap vdev inserts the tag into the packet data.
> >
> 
> This is an example of something I previously flagged. Like with real
> hardware, I think the PMD should be inserting the VLAN tag into the
> packet
> as part of the Tx function, not the prepare function.

Agree with Bruce on this.
For simple stuff like VLAN offload, applications should not be required to call tx_prep first.

However, the Tx function is supposed to not modify the packets; relevant when refcnt > 1.

Instead of modifying the packet data to insert/strip the VLAN tag,
perhaps the driver can split the write/read operation into multiple write/read operations:
1. the Ethernet header
2. the VLAN tag
3. the remaining packet data

I haven't really followed the pcap driver, so maybe my suggestion doesn't make sense.


Let's say an application adds 1 to the mbufs' refcnt before each Tx, so the mbufs still exist after Tx.
Then, the application captures/mirrors the packets consumed by the driver, and logs/drops the packets the driver was unable to consume.
If the capture/mirror is filtering by VLAN ID, modifying the packets in the driver's Tx function is bad.

-Morten

Re: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Bruce Richardson]

On Mon, Mar 16, 2026 at 04:55:29PM +0100, Morten Brørup wrote:
> > From: Bruce Richardson [mailto:bruce.richardson@intel.com]
> > Sent: Monday, 16 March 2026 16.34
> > 
> > On Tue, Mar 10, 2026 at 09:10:03AM -0700, Stephen Hemminger wrote:
> > > When the source port has VLAN strip enabled, captured packets have
> > > the VLAN tag in mbuf metadata (vlan_tci) but not in the packet data.
> > > Similarly, TX captures with pending VLAN insert have the tag only
> > > in metadata. The resulting pcap files contain untagged packets.
> > >
> > > Convert RX_VLAN_STRIPPED metadata to TX_VLAN offload requests on
> > > dequeued mbufs and call rte_eth_tx_prepare() before
> > rte_eth_tx_burst()
> > > so the pcap vdev inserts the tag into the packet data.
> > >
> > 
> > This is an example of something I previously flagged. Like with real
> > hardware, I think the PMD should be inserting the VLAN tag into the
> > packet
> > as part of the Tx function, not the prepare function.
> 
> Agree with Bruce on this.
> For simple stuff like VLAN offload, applications should not be required to call tx_prep first.
> 
> However, the Tx function is supposed to not modify the packets; relevant when refcnt > 1.
> 

Reading the doc on tx_burst it can modify the packets (obviously enough) if
refcnt is one, so only the edge case of refcnt > 1 needs to be worried
about. The other thing worth noting is that there is already an exception
for bonding driver - if we need to, I suppose we can look to make a more
general exception for a set of virtual drivers under specific
circumstances. I'd be ok with documenting that "the following drivers modify
packets for VLAN insertion..." or something like that.

> Instead of modifying the packet data to insert/strip the VLAN tag,
> perhaps the driver can split the write/read operation into multiple write/read operations:
> 1. the Ethernet header
> 2. the VLAN tag
> 3. the remaining packet data
> 
> I haven't really followed the pcap driver, so maybe my suggestion doesn't make sense.
> 
> 
> Let's say an application adds 1 to the mbufs' refcnt before each Tx, so the mbufs still exist after Tx.
> Then, the application captures/mirrors the packets consumed by the driver, and logs/drops the packets the driver was unable to consume.
> If the capture/mirror is filtering by VLAN ID, modifying the packets in the driver's Tx function is bad.
>
Worth investigating. We already have copies for scattered packets, I think,
so doing some copying for VLAN insertion if refcnt > 1 wouldn't be the end
of the world.

/Bruce 

RE: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Morten Brørup]

> From: Bruce Richardson [mailto:bruce.richardson@intel.com]
> Sent: Monday, 16 March 2026 17.06
> 
> On Mon, Mar 16, 2026 at 04:55:29PM +0100, Morten Brørup wrote:
> > > From: Bruce Richardson [mailto:bruce.richardson@intel.com]
> > > Sent: Monday, 16 March 2026 16.34
> > >
> > > On Tue, Mar 10, 2026 at 09:10:03AM -0700, Stephen Hemminger wrote:
> > > > When the source port has VLAN strip enabled, captured packets
> have
> > > > the VLAN tag in mbuf metadata (vlan_tci) but not in the packet
> data.
> > > > Similarly, TX captures with pending VLAN insert have the tag only
> > > > in metadata. The resulting pcap files contain untagged packets.
> > > >
> > > > Convert RX_VLAN_STRIPPED metadata to TX_VLAN offload requests on
> > > > dequeued mbufs and call rte_eth_tx_prepare() before
> > > rte_eth_tx_burst()
> > > > so the pcap vdev inserts the tag into the packet data.
> > > >
> > >
> > > This is an example of something I previously flagged. Like with
> real
> > > hardware, I think the PMD should be inserting the VLAN tag into the
> > > packet
> > > as part of the Tx function, not the prepare function.
> >
> > Agree with Bruce on this.
> > For simple stuff like VLAN offload, applications should not be
> required to call tx_prep first.
> >
> > However, the Tx function is supposed to not modify the packets;
> relevant when refcnt > 1.
> >
> 
> Reading the doc on tx_burst it can modify the packets (obviously
> enough) if
> refcnt is one, so only the edge case of refcnt > 1 needs to be worried
> about. The other thing worth noting is that there is already an
> exception
> for bonding driver - if we need to, I suppose we can look to make a
> more
> general exception for a set of virtual drivers under specific
> circumstances. I'd be ok with documenting that "the following drivers
> modify
> packets for VLAN insertion..." or something like that.

I'm opposed to API contract exceptions for virtual drivers.
They should be just as well behaved as physical device drivers.
Otherwise, applications need to behave differently, depending on which driver they are using.

I cannot remember the reason for the exception in the bonding driver, but optimally it should be treated as a bug and fixed.

> 
> > Instead of modifying the packet data to insert/strip the VLAN tag,
> > perhaps the driver can split the write/read operation into multiple
> write/read operations:
> > 1. the Ethernet header
> > 2. the VLAN tag
> > 3. the remaining packet data
> >
> > I haven't really followed the pcap driver, so maybe my suggestion
> doesn't make sense.
> >
> >
> > Let's say an application adds 1 to the mbufs' refcnt before each Tx,
> so the mbufs still exist after Tx.
> > Then, the application captures/mirrors the packets consumed by the
> driver, and logs/drops the packets the driver was unable to consume.
> > If the capture/mirror is filtering by VLAN ID, modifying the packets
> in the driver's Tx function is bad.
> >
> Worth investigating. We already have copies for scattered packets, I
> think,
> so doing some copying for VLAN insertion if refcnt > 1 wouldn't be the
> end
> of the world.

+1

> 
> /Bruce

Re: [PATCH v20 12/25] net/pcap: support VLAN strip and insert offloads

[Stephen Hemminger]

On Mon, 16 Mar 2026 14:04:59 +0000
Bruce Richardson <bruce.richardson@intel.com> wrote:

> Are we sure this is the correct way to do this? To behave like a normal NIC
> the Tx VLAN tag should be inserted in the Tx function, rather than tx
> prepare should it not? There is no guarantee apps will call tx_prepare
> before Tx.
> 
> /Bruce

I wasn't sure, but copied what virtio PMD was doing.
If application is using VLAN's on virtio it would need to call prepare.

uint16_t
virtio_xmit_pkts_prepare(void *tx_queue __rte_unused, struct rte_mbuf **tx_pkts,
			uint16_t nb_pkts)
{
	uint16_t nb_tx;
	int error;

	for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
		struct rte_mbuf *m = tx_pkts[nb_tx];

...
		/* Do VLAN tag insertion */
		if (unlikely(m->ol_flags & RTE_MBUF_F_TX_VLAN)) {
			error = rte_vlan_insert(&m);
			/* rte_vlan_insert() may change pointer
			 * even in the case of failure
			 */
			tx_pkts[nb_tx] = m;

			if (unlikely(error)) {
				rte_errno = -error;
				break;
			}
		}

Re: [PATCH v20 13/25] net/pcap: add link status for interface mode

[Stephen Hemminger]

On Mon, 16 Mar 2026 14:11:47 +0000
Bruce Richardson <bruce.richardson@intel.com> wrote:

> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
> 
> Any reason we can't in future similarly query the link speed of the
> interface in use, and the other link parameters?

I did that in earlier version but it adds more complexity.
Each OS has its own way, and doesn't work for most common case
of read/write to file.

Re: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Stephen Hemminger]

On Mon, 16 Mar 2026 16:55:29 +0100
Morten Brørup <mb@smartsharesystems.com> wrote:

> > 
> > This is an example of something I previously flagged. Like with real
> > hardware, I think the PMD should be inserting the VLAN tag into the
> > packet
> > as part of the Tx function, not the prepare function.  
> 
> Agree with Bruce on this.
> For simple stuff like VLAN offload, applications should not be required to call tx_prep first.
> 
> However, the Tx function is supposed to not modify the packets; relevant when refcnt > 1.
> 
> Instead of modifying the packet data to insert/strip the VLAN tag,
> perhaps the driver can split the write/read operation into multiple write/read operations:
> 1. the Ethernet header
> 2. the VLAN tag
> 3. the remaining packet data
> 
> I haven't really followed the pcap driver, so maybe my suggestion doesn't make sense.

The prepare code and VLAN was copied from virtio.
I assume virtio is widely used already.

[PATCH v21 00/25] net/pcap: fixes, test, and enhancements

[Stephen Hemminger]

This series contains improvements to the PCAP PMD including new
features, bug fixes, code cleanup, and a comprehensive test suite.

New features:
  - VLAN tag insertion on Tx (via tx_prepare) and stripping on Rx
  - Runtime VLAN offload configuration via vlan_offload_set callback
  - Nanosecond precision timestamps (when libpcap supports it)
  - Link state reporting in interface mode
  - Link status change (LSC) interrupt support in interface mode
  - EOF notification via link status change for rx_pcap mode
  - Advertise RTE_ETH_TX_OFFLOAD_MULTI_SEGS capability
  - Configurable snapshot length via snaplen devarg
  - Rx scatter offload support with mbuf pool validation

Bug fixes:
  - Fix build on Windows from RTE_LOG_LINE changes.
  - Fix multi-segment transmit to dynamically allocate instead of
    silently truncating packets larger than 9K stack buffer
  - Fix Tx burst error handling: distinguish malformed mbufs (counted
    as errors) from pcap_sendpacket backpressure (break and retry)
  - Reject non-Ethernet interfaces to prevent malformed packets
    and kernel warnings on FreeBSD/macOS loopback
  - Fix infinite_rx ring fill applying VLAN strip and timestamp
    offloads to template packets, preventing those offloads from
    working correctly during packet delivery
  - Preserve VLAN tags in dpdk-pdump captures by converting
    stripped VLAN metadata to Tx insert requests and calling
    rte_eth_tx_prepare() on the pcap vdev

Code cleanup:
  - Convert internal flags from int to bool
  - Remove unnecessary casts of void* from rte_zmalloc
  - Replace rte_malloc/rte_memcpy with libc equivalents in osdep code
  - Include headers explicitly rather than relying on indirect includes
  - Reduce scope of file-level variables

Testing:
  - Add comprehensive unit test suite covering basic file I/O,
    timestamps, jumbo frames, VLAN strip/insert, multi-queue,
    scatter receive, snaplen, EOF notification, and link status
  - Test discovers network interfaces using pcap_findalldevs API
    for portable interface enumeration across Linux, FreeBSD, macOS,
    and Windows
  - Tests use packet_burst_generator for standardized test packet
    creation

v21:
  - Drop volatile patch, existing code is acceptable (Bruce)
  - Split Tx burst cleanup into two patches: error accounting
    fix and dumper return value cleanup (Bruce)
  - Add more tests

v20:
  - Add dpdk-pdump VLAN tag preservation patch

v19:
  - Restore Rx scatter offload patch that was inadvertently
    dropped in v18

Stephen Hemminger (25):
  maintainers: update for pcap driver
  net/pcap: fix build on Windows
  doc: update features for PCAP PMD
  net/pcap: include used headers
  net/pcap: remove unnecessary casts
  net/pcap: avoid using rte_malloc and rte_memcpy
  net/pcap: advertise Tx multi segment
  net/pcap: replace stack bounce buffer
  net/pcap: fix error accounting and backpressure on transmit
  net/pcap: clean up TX dumper return value and types
  net/pcap: add datapath debug logging
  net/pcap: consolidate boolean flag handling
  net/pcap: support VLAN strip and insert offloads
  app/pdump: preserve VLAN tags in captured packets
  net/pcap: add link status for interface mode
  net/pcap: support nanosecond timestamp precision
  net/pcap: reject non-Ethernet interfaces
  net/pcap: reduce scope of file-level variables
  net/pcap: clarify maximum received packet
  eal/windows: add wrapper for access function
  net/pcap: add snapshot length devarg
  net/pcap: add Rx scatter offload
  net/pcap: add link status change support for iface mode
  net/pcap: add EOF notification via link status change
  test: add comprehensive test suite for pcap PMD

 MAINTAINERS                            |    1 +
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 4122 ++++++++++++++++++++++++
 doc/guides/nics/features/pcap.ini      |    9 +
 doc/guides/nics/pcap.rst               |   48 +
 doc/guides/rel_notes/release_26_03.rst |   11 +
 drivers/net/pcap/pcap_ethdev.c         |  842 +++--
 drivers/net/pcap/pcap_osdep.h          |   27 +
 drivers/net/pcap/pcap_osdep_freebsd.c  |   43 +-
 drivers/net/pcap/pcap_osdep_linux.c    |   33 +-
 drivers/net/pcap/pcap_osdep_windows.c  |   76 +-
 lib/eal/windows/include/rte_os_shim.h  |    1 +
 lib/eal/windows/include/unistd.h       |    7 +
 lib/pdump/rte_pdump.c                  |   32 +-
 14 files changed, 5036 insertions(+), 218 deletions(-)
 create mode 100644 app/test/test_pmd_pcap.c

-- 
2.53.0

[PATCH v21 01/25] maintainers: update for pcap driver

[Stephen Hemminger]

Nominate myself to take care of this since already doing pcapng
and pdump code.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 0f5539f851..580113a658 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1116,6 +1116,7 @@ F: doc/guides/nics/zxdh.rst
 F: doc/guides/nics/features/zxdh.ini
 
 PCAP PMD
+M: Stephen Hemminger <stephen@networkplumber.org>
 F: drivers/net/pcap/
 F: doc/guides/nics/pcap.rst
 F: doc/guides/nics/features/pcap.ini
-- 
2.53.0

[PATCH v21 02/25] net/pcap: fix build on Windows

[Stephen Hemminger]

The log messages in the pcap OS dependent code for Windows
was never converted during the last release.

It looks like the osdep part of pcap was not being built.
Building requires have libpcap for Windows built which is not
part of the CI infrastructure.

Fixes: 2b843cac232e ("drivers: use per line logging in helpers")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Chengwen Feng <fengchengwen@huawei.com>
Acked-by: David Marchand <david.marchand@redhat.com>
---
 drivers/net/pcap/pcap_osdep_windows.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 1d398dc7ed..0965c2f5c9 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -53,7 +53,7 @@ osdep_iface_index_get(const char *device_name)
 
 	ret = GetAdapterIndex(adapter_name, &index);
 	if (ret != NO_ERROR) {
-		PMD_LOG(ERR, "GetAdapterIndex(%S) = %lu\n", adapter_name, ret);
+		PMD_LOG(ERR, "GetAdapterIndex(%S) = %lu", adapter_name, ret);
 		return -1;
 	}
 
@@ -75,20 +75,20 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
-		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu\n",
+		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
 		return -1;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
-		PMD_LOG(ERR, "Cannot allocate adapter address info\n");
+		PMD_LOG(ERR, "Cannot allocate adapter address info");
 		return -1;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
-		PMD_LOG(ERR, "GetAdapterAddresses() = %lu\n", sys_ret);
+		PMD_LOG(ERR, "GetAdapterAddresses() = %lu", sys_ret);
 		free(info);
 		return -1;
 	}
-- 
2.53.0

[PATCH v21 03/25] doc: update features for PCAP PMD

[Stephen Hemminger]

The PCAP PMD supports more features that were not flagged
in the feature matrix.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
 doc/guides/nics/features/pcap.ini | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 7fd22b190e..99ba3b8e1f 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -4,8 +4,15 @@
 ; Refer to default.ini for the full list of available PMD features.
 ;
 [Features]
+Link status          = Y
+Queue start/stop     = Y
+Timestamp offload    = P
 Basic stats          = Y
+Stats per queue      = Y
 Multiprocess aware   = Y
+FreeBSD              = Y
+Linux                = Y
+Windows              = Y
 ARMv7                = Y
 ARMv8                = Y
 Power8               = Y
-- 
2.53.0

[PATCH v21 04/25] net/pcap: include used headers

[Stephen Hemminger]

Include the used headers instead of relying on getting
the headers indirectly through other headers.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
 drivers/net/pcap/pcap_ethdev.c | 9 ++++++++-
 drivers/net/pcap/pcap_osdep.h  | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index f323c0b0df..4513d46d61 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -4,16 +4,23 @@
  * All rights reserved.
  */
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
 #include <pcap.h>
 
 #include <rte_cycles.h>
+#include <rte_ring.h>
+#include <rte_ethdev.h>
 #include <ethdev_driver.h>
 #include <ethdev_vdev.h>
 #include <rte_kvargs.h>
 #include <rte_malloc.h>
+#include <rte_memcpy.h>
 #include <rte_mbuf.h>
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index 2aa13f3629..a0e2b5ace9 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -6,6 +6,7 @@
 #define _RTE_PCAP_OSDEP_
 
 #include <rte_ether.h>
+#include <rte_log.h>
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
-- 
2.53.0

[PATCH v21 05/25] net/pcap: remove unnecessary casts

[Stephen Hemminger]

The function rte_zmalloc returns void * so cast is unnecessary.
Use numa aware allocation and add tag for tracing.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4513d46d61..d6fe062b92 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -1217,13 +1217,11 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	struct pmd_process_private *pp;
 	unsigned int numa_node = vdev->device.numa_node;
 
-	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
+	PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %u",
 		numa_node);
 
-	pp = (struct pmd_process_private *)
-		rte_zmalloc(NULL, sizeof(struct pmd_process_private),
-				RTE_CACHE_LINE_SIZE);
-
+	pp = rte_zmalloc_socket("pcap_private", sizeof(struct pmd_process_private),
+		RTE_CACHE_LINE_SIZE, numa_node);
 	if (pp == NULL) {
 		PMD_LOG(ERR,
 			"Failed to allocate memory for process private");
@@ -1284,7 +1282,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 	if (osdep_iface_mac_get(if_name, &mac) < 0)
 		return -1;
 
-	mac_addrs = rte_zmalloc_socket(NULL, RTE_ETHER_ADDR_LEN, 0, numa_node);
+	mac_addrs = rte_zmalloc_socket("pcap_mac", RTE_ETHER_ADDR_LEN, 0, numa_node);
 	if (mac_addrs == NULL)
 		return -1;
 
@@ -1590,11 +1588,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		unsigned int i;
 
 		internal = eth_dev->data->dev_private;
-			pp = (struct pmd_process_private *)
-				rte_zmalloc(NULL,
-					sizeof(struct pmd_process_private),
-					RTE_CACHE_LINE_SIZE);
-
+		pp = rte_zmalloc("pcap_private", sizeof(struct pmd_process_private),
+			 RTE_CACHE_LINE_SIZE);
 		if (pp == NULL) {
 			PMD_LOG(ERR,
 				"Failed to allocate memory for process private");
-- 
2.53.0

[PATCH v21 06/25] net/pcap: avoid using rte_malloc and rte_memcpy

[Stephen Hemminger]

No need to use rte_malloc or rte_memcpy in the short
code to get MAC address.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c        |  3 ++-
 drivers/net/pcap/pcap_osdep_freebsd.c | 12 +++++-------
 drivers/net/pcap/pcap_osdep_linux.c   |  6 +++---
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index d6fe062b92..724b7a9038 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -6,6 +6,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -1287,7 +1288,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
 		return -1;
 
 	PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
-	rte_memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
+	memcpy(mac_addrs, mac.addr_bytes, RTE_ETHER_ADDR_LEN);
 	eth_dev->data->mac_addrs = mac_addrs;
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 20556b3e92..0185665f0b 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -4,13 +4,11 @@
  * All rights reserved.
  */
 
+#include <string.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <sys/sysctl.h>
 
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-
 #include "pcap_osdep.h"
 
 int
@@ -41,19 +39,19 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	if (len == 0)
 		return -1;
 
-	buf = rte_malloc(NULL, len, 0);
+	buf = malloc(len);
 	if (!buf)
 		return -1;
 
 	if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-		rte_free(buf);
+		free(buf);
 		return -1;
 	}
 	ifm = (struct if_msghdr *)buf;
 	sdl = (struct sockaddr_dl *)(ifm + 1);
 
-	rte_memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, LLADDR(sdl), RTE_ETHER_ADDR_LEN);
 
-	rte_free(buf);
+	free(buf);
 	return 0;
 }
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index 97033f57c5..df976417cb 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -4,12 +4,12 @@
  * All rights reserved.
  */
 
+#include <string.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
-#include <rte_memcpy.h>
 #include <rte_string_fns.h>
 
 #include "pcap_osdep.h"
@@ -35,7 +35,7 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 		return -1;
 	}
 
-	rte_memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
+	memcpy(mac->addr_bytes, ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
 
 	close(if_fd);
 	return 0;
-- 
2.53.0

[PATCH v21 07/25] net/pcap: advertise Tx multi segment

[Stephen Hemminger]

The driver supports multi-segment transmit, but the did not set
the offload flag. Therefore applications would not know about
that capability.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
 drivers/net/pcap/pcap_ethdev.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 724b7a9038..ebc96fafe5 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -753,6 +753,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
 
 	return 0;
 }
-- 
2.53.0

[PATCH v21 08/25] net/pcap: replace stack bounce buffer

[Stephen Hemminger]

Replace the 64K stack-allocated bounce buffer with a per-queue
buffer allocated from hugepages via rte_malloc at queue setup.
This is necessary because the buffer may be used in a secondary
process transmit path where the primary process allocated it.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
 drivers/net/pcap/pcap_ethdev.c | 60 +++++++++++++++++++++-------------
 1 file changed, 37 insertions(+), 23 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index ebc96fafe5..02d5cb591f 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -91,6 +91,9 @@ struct pcap_tx_queue {
 	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
+
+	/* Temp buffer used for non-linear packets */
+	uint8_t *bounce_buf;
 };
 
 struct pmd_internals {
@@ -385,18 +388,17 @@ static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
 	pcap_dumper_t *dumper;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len, caplen;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[dumper_q->port_id].process_private;
 	dumper = pp->tx_dumper[dumper_q->queue_id];
+	temp_data = dumper_q->bounce_buf;
 
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
@@ -404,12 +406,11 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	/* writes the nb_pkts packets to the previously opened pcap file
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = caplen = rte_pktmbuf_pkt_len(mbuf);
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
-			caplen = sizeof(temp_data);
-		}
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len, caplen;
+
+		len = rte_pktmbuf_pkt_len(mbuf);
+		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
 		calculate_timestamp(&header.ts);
 		header.len = len;
@@ -449,9 +450,6 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	uint32_t tx_bytes = 0;
 	struct pcap_tx_queue *tx_queue = queue;
 
-	if (unlikely(nb_pkts == 0))
-		return 0;
-
 	for (i = 0; i < nb_pkts; i++) {
 		tx_bytes += bufs[i]->pkt_len;
 		rte_pktmbuf_free(bufs[i]);
@@ -460,7 +458,7 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	tx_queue->tx_stat.pkts += nb_pkts;
 	tx_queue->tx_stat.bytes += tx_bytes;
 
-	return i;
+	return nb_pkts;
 }
 
 /*
@@ -470,30 +468,30 @@ static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned int i;
-	int ret;
-	struct rte_mbuf *mbuf;
 	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	pcap_t *pcap;
-	unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
-	size_t len;
+	unsigned char *temp_data;
 
 	pp = rte_eth_devices[tx_queue->port_id].process_private;
 	pcap = pp->tx_pcap[tx_queue->queue_id];
+	temp_data = tx_queue->bounce_buf;
 
 	if (unlikely(nb_pkts == 0 || pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
-		mbuf = bufs[i];
-		len = rte_pktmbuf_pkt_len(mbuf);
+		struct rte_mbuf *mbuf = bufs[i];
+		size_t len = rte_pktmbuf_pkt_len(mbuf);
+		int ret;
+
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > sizeof(temp_data))) {
+				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
-				len, sizeof(temp_data));
+				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
@@ -966,7 +964,7 @@ static int
 eth_tx_queue_setup(struct rte_eth_dev *dev,
 		uint16_t tx_queue_id,
 		uint16_t nb_tx_desc __rte_unused,
-		unsigned int socket_id __rte_unused,
+		unsigned int socket_id,
 		const struct rte_eth_txconf *tx_conf __rte_unused)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
@@ -974,11 +972,26 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+					       RTE_CACHE_LINE_SIZE, socket_id);
+	if (pcap_q->bounce_buf == NULL)
+		return -ENOMEM;
+
 	dev->data->tx_queues[tx_queue_id] = pcap_q;
 
 	return 0;
 }
 
+static void
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t tx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
+
+	rte_free(pcap_q->bounce_buf);
+	pcap_q->bounce_buf = NULL;
+}
+
 static int
 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 {
@@ -1019,6 +1032,7 @@ static const struct eth_dev_ops ops = {
 	.dev_infos_get = eth_dev_info,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
+	.tx_queue_release = eth_tx_queue_release,
 	.rx_queue_start = eth_rx_queue_start,
 	.tx_queue_start = eth_tx_queue_start,
 	.rx_queue_stop = eth_rx_queue_stop,
-- 
2.53.0

[PATCH v21 09/25] net/pcap: fix error accounting and backpressure on transmit

[Stephen Hemminger]

Fix two problems in eth_pcap_tx():

Oversized multi-segment packets that exceed the bounce buffer are
dropped but were not counted as errors. Add err_pkts accounting
for these drops.

When pcap_sendpacket() fails due to kernel socket backpressure,
the remaining unsent packets were counted as TX errors. Since
backpressure is transient (EAGAIN/EBUSY/EINTR), break the loop
and return the number of packets attempted so the caller retains
ownership of the unsent mbufs per tx_burst semantics.

Fixes: fbbbf553f268 ("net/pcap: fix concurrent multiseg Tx")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 34 ++++++++++++++++++++++------------
 1 file changed, 22 insertions(+), 12 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 02d5cb591f..ca08b8e342 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -462,7 +462,17 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 }
 
 /*
- * Callback to handle sending packets through a real NIC.
+ * Send a burst of packets to a pcap device.
+ *
+ * On Linux, pcap_sendpacket() calls send() on a blocking PF_PACKET
+ * socket with default kernel buffer sizes and no TX ring (PACKET_TX_RING).
+ * The send() call only blocks when the kernel socket send buffer is full,
+ * providing limited backpressure.
+ *
+ * On error, pcap_sendpacket() returns non-zero and the loop breaks,
+ * leaving remaining packets unsent.
+ *
+ * Bottom line: backpressure is not an error.
  */
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
@@ -484,26 +494,27 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len = rte_pktmbuf_pkt_len(mbuf);
-		int ret;
+		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
+		const uint8_t *data;
 
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
 				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
 			PMD_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%zd) > max size (%u).",
+				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+			tx_queue->tx_stat.err_pkts++;
 			rte_pktmbuf_free(mbuf);
 			continue;
 		}
 
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		ret = pcap_sendpacket(pcap,
-			rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
-		if (unlikely(ret != 0))
+		data = rte_pktmbuf_read(mbuf, 0, len, temp_data);
+		RTE_ASSERT(data != NULL);
+
+		if (unlikely(pcap_sendpacket(pcap, data, len) != 0)) {
+			/* Assume failure is backpressure */
+			PMD_LOG(ERR, "pcap_sendpacket() failed: %s", pcap_geterr(pcap));
 			break;
+		}
 		num_tx++;
 		tx_bytes += len;
 		rte_pktmbuf_free(mbuf);
@@ -511,7 +522,6 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
-	tx_queue->tx_stat.err_pkts += i - num_tx;
 
 	return i;
 }
-- 
2.53.0

[PATCH v21 10/25] net/pcap: clean up TX dumper return value and types

[Stephen Hemminger]

Use uint32_t for packet lengths to match rte_pktmbuf_pkt_len()
return type. Split rte_pktmbuf_read() out of the pcap_dump() call
and add RTE_ASSERT for bogus mbuf detection. Remove incorrect
err_pkts accounting since the dumper loop cannot partially fail,
and return the loop index for consistency with eth_pcap_tx.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index ca08b8e342..8df66ebb96 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -407,7 +407,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	 * dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
-		size_t len, caplen;
+		uint32_t len, caplen;
+		const uint8_t *data;
 
 		len = rte_pktmbuf_pkt_len(mbuf);
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
@@ -415,15 +416,16 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		calculate_timestamp(&header.ts);
 		header.len = len;
 		header.caplen = caplen;
-		/* rte_pktmbuf_read() returns a pointer to the data directly
-		 * in the mbuf (when the mbuf is contiguous) or, otherwise,
-		 * a pointer to temp_data after copying into it.
-		 */
-		pcap_dump((u_char *)dumper, &header,
-			rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
+
+		data = rte_pktmbuf_read(mbuf, 0, caplen, temp_data);
+
+		/* This could only happen if mbuf is bogus pkt_len > data_len */
+		RTE_ASSERT(data != NULL);
+		pcap_dump((u_char *)dumper, &header, data);
 
 		num_tx++;
 		tx_bytes += caplen;
+
 		rte_pktmbuf_free(mbuf);
 	}
 
@@ -435,9 +437,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	pcap_dump_flush(dumper);
 	dumper_q->tx_stat.pkts += num_tx;
 	dumper_q->tx_stat.bytes += tx_bytes;
-	dumper_q->tx_stat.err_pkts += nb_pkts - num_tx;
 
-	return nb_pkts;
+	return i;
 }
 
 /*
-- 
2.53.0

[PATCH v21 11/25] net/pcap: add datapath debug logging

[Stephen Hemminger]

Add datapath debug logging macros (PMD_RX_LOG, PMD_TX_LOG) gated
on RTE_ETHDEV_DEBUG_RX/TX. Use PMD_TX_LOG in transmit error paths
to aid debugging without impacting normal datapath performance.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c |  2 +-
 drivers/net/pcap/pcap_osdep.h  | 14 ++++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 8df66ebb96..cfdbf3eace 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -500,7 +500,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 
 		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
 				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
-			PMD_LOG(ERR,
+			PMD_TX_LOG(ERR,
 				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
 				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 			tx_queue->tx_stat.err_pkts++;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index a0e2b5ace9..fe7399ff9f 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -13,6 +13,20 @@
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
+#ifdef RTE_ETHDEV_DEBUG_RX
+#define PMD_RX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() rx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_RX_LOG(...) do { } while (0)
+#endif
+
+#ifdef RTE_ETHDEV_DEBUG_TX
+#define PMD_TX_LOG(level, ...) \
+	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s() tx: ", __func__, __VA_ARGS__)
+#else
+#define PMD_TX_LOG(...) do { } while (0)
+#endif
+
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
-- 
2.53.0

[PATCH v21 12/25] net/pcap: consolidate boolean flag handling

[Stephen Hemminger]

Convert internal flag fields from int/unsigned int to bool for clarity
and reduced structure size.

Merge the separate select_phy_mac() and get_infinite_rx_arg() functions
into a single process_bool_flag() handler. The new function also adds
proper validation, rejecting values other than "0", "1", or empty (which
defaults to true).

Also change num_of_queue from unsigned int to uint16_t since it cannot
exceed RTE_PMD_PCAP_MAX_QUEUES.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
 drivers/net/pcap/pcap_ethdev.c | 67 +++++++++++++++-------------------
 1 file changed, 29 insertions(+), 38 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index cfdbf3eace..955eaf17e2 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <time.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -102,9 +103,9 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
-	int single_iface;
-	int phy_mac;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool phy_mac;
+	bool infinite_rx;
 };
 
 struct pmd_process_private {
@@ -114,25 +115,25 @@ struct pmd_process_private {
 };
 
 struct pmd_devargs {
-	unsigned int num_of_queue;
+	uint16_t num_of_queue;
+	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
-	int phy_mac;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
-	int single_iface;
-	unsigned int is_tx_pcap;
-	unsigned int is_tx_iface;
-	unsigned int is_rx_pcap;
-	unsigned int is_rx_iface;
-	unsigned int infinite_rx;
+	bool single_iface;
+	bool is_tx_pcap;
+	bool is_tx_iface;
+	bool is_rx_pcap;
+	bool is_rx_iface;
+	bool infinite_rx;
 };
 
 static const char *valid_arguments[] = {
@@ -881,7 +882,7 @@ eth_dev_close(struct rte_eth_dev *dev)
 		}
 	}
 
-	if (internals->phy_mac == 0)
+	if (!internals->phy_mac)
 		/* not dynamically allocated, must not be freed */
 		dev->data->mac_addrs = NULL;
 
@@ -1206,29 +1207,19 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-select_phy_mac(const char *key __rte_unused, const char *value,
-		void *extra_args)
+process_bool_flag(const char *key, const char *value, void *extra_args)
 {
-	if (extra_args) {
-		const int phy_mac = atoi(value);
-		int *enable_phy_mac = extra_args;
-
-		if (phy_mac)
-			*enable_phy_mac = 1;
-	}
-	return 0;
-}
-
-static int
-get_infinite_rx_arg(const char *key __rte_unused,
-		const char *value, void *extra_args)
-{
-	if (extra_args) {
-		const int infinite_rx = atoi(value);
-		int *enable_infinite_rx = extra_args;
-
-		if (infinite_rx > 0)
-			*enable_infinite_rx = 1;
+	bool *flag = extra_args;
+
+	if (value == NULL || *value == '\0') {
+		*flag = true; /* default with no additional argument */
+	} else if (strcmp(value, "0") == 0) {
+		*flag = false;
+	} else if (strcmp(value, "1") == 0) {
+		*flag = true;
+	} else {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
 	}
 	return 0;
 }
@@ -1503,7 +1494,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		dumpers.queue[0] = pcaps.queue[0];
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
-				&select_phy_mac, &pcaps.phy_mac);
+					 &process_bool_flag, &pcaps.phy_mac);
 		if (ret < 0)
 			goto free_kvlist;
 
@@ -1543,8 +1534,8 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 		if (infinite_rx_arg_cnt == 1) {
 			ret = rte_kvargs_process(kvlist,
 					ETH_PCAP_INFINITE_RX_ARG,
-					&get_infinite_rx_arg,
-					&devargs_all.infinite_rx);
+					 &process_bool_flag,
+					 &devargs_all.infinite_rx);
 			if (ret < 0)
 				goto free_kvlist;
 			PMD_LOG(INFO, "infinite_rx has been %s for %s",
@@ -1693,5 +1684,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
-	ETH_PCAP_PHY_MAC_ARG "=<int>"
+	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
-- 
2.53.0

[PATCH v21 13/25] net/pcap: support VLAN strip and insert offloads

[Stephen Hemminger]

Add VLAN tag handling to the pcap PMD, consistent with how virtio
and af_packet drivers implement it. This also gets used for
capture of VLAN tagged packets when legacy pdump is used.

RX strip: when RTE_ETH_RX_OFFLOAD_VLAN_STRIP is enabled, the driver
calls rte_vlan_strip() on received packets in both normal and
infinite_rx modes. For infinite_rx, offloads are deferred to
packet delivery rather than applied during ring fill, so the
stored template packets remain unmodified.

TX insert: when RTE_MBUF_F_TX_VLAN is set on an mbuf, the driver
inserts the VLAN tag via rte_vlan_insert() before writing to pcap
or sending to the interface. Indirect or shared mbufs get a new
header mbuf to avoid modifying the original.

Runtime reconfiguration is supported through vlan_offload_set,
which propagates the strip setting to all active RX queues.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/nics/pcap.rst               | 11 +++
 doc/guides/rel_notes/release_26_03.rst |  4 ++
 drivers/net/pcap/pcap_ethdev.c         | 93 +++++++++++++++++++++++++-
 4 files changed, 106 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 99ba3b8e1f..9f234aa7b9 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -9,6 +9,7 @@ Queue start/stop     = Y
 Timestamp offload    = P
 Basic stats          = Y
 Stats per queue      = Y
+VLAN offload         = Y
 Multiprocess aware   = Y
 FreeBSD              = Y
 Linux                = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index fbfe854bb1..bed5006a42 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -247,3 +247,14 @@ will be discarded by the Rx flushing operation.
    The network interface provided to the PMD should be up.
    The PMD will return an error if the interface is down,
    and the PMD itself won't change the status of the external network interface.
+
+Features and Limitations
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+*  The PMD will re-insert the VLAN tag transparently to the packet if the kernel
+   strips it, as long as the ``RTE_ETH_RX_OFFLOAD_VLAN_STRIP`` is not enabled by the
+   application.
+
+*  The PMD will transparently insert a VLAN tag to transmitted packets if
+   ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
+   set.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 3d2ed19eb8..7a74f732d3 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -136,6 +136,10 @@ New Features
   Added handling of the key combination Control+L
   to clear the screen before redisplaying the prompt.
 
+* **Updated PCAP ethernet driver.**
+
+  * Added support for VLAN insertion and stripping.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 955eaf17e2..c16bff9198 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -76,6 +76,7 @@ struct queue_missed_stat {
 struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
+	bool vlan_strip;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -106,6 +107,7 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool vlan_strip;
 };
 
 struct pmd_process_private {
@@ -270,7 +272,11 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		bufs[i]->data_len = pcap_buf->data_len;
 		bufs[i]->pkt_len = pcap_buf->pkt_len;
 		bufs[i]->port = pcap_q->port_id;
-		rx_bytes += pcap_buf->data_len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(bufs[i]);
+
+		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
 		rte_ring_enqueue(pcap_q->pkts, pcap_buf);
@@ -336,6 +342,10 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		}
 
 		mbuf->pkt_len = len;
+
+		if (pcap_q->vlan_strip)
+			rte_vlan_strip(mbuf);
+
 		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
 
 		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
@@ -382,6 +392,39 @@ calculate_timestamp(struct timeval *ts) {
 	}
 }
 
+static uint16_t
+eth_pcap_tx_prepare(void *queue __rte_unused, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
+{
+	uint16_t nb_tx;
+	int error;
+
+	for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
+		struct rte_mbuf *m = tx_pkts[nb_tx];
+
+#ifdef RTE_LIBRTE_ETHDEV_DEBUG
+		error = rte_validate_tx_offload(m);
+		if (unlikely(error)) {
+			rte_errno = -error;
+			break;
+		}
+#endif
+		/* Do VLAN tag insertion */
+		if (unlikely(m->ol_flags & RTE_MBUF_F_TX_VLAN)) {
+			error = rte_vlan_insert(&m);
+
+			/* rte_vlan_insert() could change pointer (currently does not) */
+			tx_pkts[nb_tx] = m;
+
+			if (unlikely(error != 0)) {
+				PMD_TX_LOG(ERR, "rte_vlan_insert failed: %s", strerror(-error));
+				rte_errno = -error;
+				break;
+			}
+		}
+	}
+	return nb_tx;
+}
+
 /*
  * Callback to handle writing packets to a pcap file.
  */
@@ -415,6 +458,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
 		calculate_timestamp(&header.ts);
+
 		header.len = len;
 		header.caplen = caplen;
 
@@ -746,8 +790,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 }
 
 static int
-eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+eth_dev_configure(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
+	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
+
+	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
 	return 0;
 }
 
@@ -763,7 +812,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
-	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
+		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
 
 	return 0;
 }
@@ -910,6 +961,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
+	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 
 	if (internals->infinite_rx) {
@@ -919,6 +971,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		uint64_t pcap_pkt_count = 0;
 		struct rte_mbuf *bufs[1];
 		pcap_t **pcap;
+		bool save_vlan_strip;
 
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
@@ -938,11 +991,20 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		if (!pcap_q->pkts)
 			return -ENOENT;
 
+		/*
+		 * Temporarily disable offloads while filling the ring
+		 * with raw packets. VLAN strip and timestamp will be
+		 * applied later in eth_pcap_rx_infinite() on each copy.
+		 */
+		save_vlan_strip = pcap_q->vlan_strip;
+		pcap_q->vlan_strip = false;
+
 		/* Fill ring with packets from PCAP file one by one. */
 		while (eth_pcap_rx(pcap_q, bufs, 1)) {
 			/* Check for multiseg mbufs. */
 			if (bufs[0]->nb_segs != 1) {
 				infinite_rx_ring_free(pcap_q->pkts);
+				pcap_q->vlan_strip = save_vlan_strip;
 				PMD_LOG(ERR,
 					"Multiseg mbufs are not supported in infinite_rx mode.");
 				return -EINVAL;
@@ -952,6 +1014,9 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 					(void * const *)bufs, 1, NULL);
 		}
 
+		/* Restore offloads for use during packet delivery */
+		pcap_q->vlan_strip = save_vlan_strip;
+
 		if (rte_ring_count(pcap_q->pkts) < pcap_pkt_count) {
 			infinite_rx_ring_free(pcap_q->pkts);
 			PMD_LOG(ERR,
@@ -1036,6 +1101,26 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+static int
+eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	unsigned int i;
+
+	if (mask & RTE_ETH_VLAN_STRIP_MASK) {
+		bool vlan_strip = !!(dev->data->dev_conf.rxmode.offloads &
+				     RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+
+		internals->vlan_strip = vlan_strip;
+
+		/* Update all RX queues */
+		for (i = 0; i < dev->data->nb_rx_queues; i++)
+			internals->rx_queue[i].vlan_strip = vlan_strip;
+	}
+
+	return 0;
+}
+
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
 	.dev_stop = eth_dev_stop,
@@ -1052,6 +1137,7 @@ static const struct eth_dev_ops ops = {
 	.link_update = eth_link_update,
 	.stats_get = eth_stats_get,
 	.stats_reset = eth_stats_reset,
+	.vlan_offload_set = eth_vlan_offload_set,
 };
 
 static int
@@ -1391,6 +1477,7 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		eth_dev->rx_pkt_burst = eth_null_rx;
 
 	/* Assign tx ops. */
+	eth_dev->tx_pkt_prepare = eth_pcap_tx_prepare;
 	if (devargs_all->is_tx_pcap)
 		eth_dev->tx_pkt_burst = eth_pcap_tx_dumper;
 	else if (devargs_all->is_tx_iface || single_iface)
-- 
2.53.0

[PATCH v21 14/25] app/pdump: preserve VLAN tags in captured packets

[Stephen Hemminger]

When the source port has VLAN strip enabled, captured packets have
the VLAN tag in mbuf metadata (vlan_tci) but not in the packet data.
Similarly, TX captures with pending VLAN insert have the tag only
in metadata. The resulting pcap files contain untagged packets.

Convert RX_VLAN_STRIPPED metadata to TX_VLAN offload requests on
dequeued mbufs and call rte_eth_tx_prepare() before rte_eth_tx_burst()
so the pcap vdev inserts the tag into the packet data.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 lib/pdump/rte_pdump.c | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/lib/pdump/rte_pdump.c b/lib/pdump/rte_pdump.c
index ac94efe7ff..6ffe72e284 100644
--- a/lib/pdump/rte_pdump.c
+++ b/lib/pdump/rte_pdump.c
@@ -9,6 +9,7 @@
 #include <rte_mbuf.h>
 #include <rte_ethdev.h>
 #include <rte_lcore.h>
+#include <rte_ether.h>
 #include <rte_log.h>
 #include <rte_memzone.h>
 #include <rte_errno.h>
@@ -135,6 +136,29 @@ pdump_cb_release(struct pdump_rxtx_cbs *cbs)
 	rte_atomic_store_explicit(&cbs->use_count, count, rte_memory_order_release);
 }
 
+/*
+ * Reconstruct VLAN tag in packet data if it was offloaded to metadata.
+ *
+ * When VLAN strip is active on RX, or VLAN insert is pending on TX,
+ * the VLAN tag exists only in mbuf metadata (vlan_tci / ol_flags)
+ * and not in the packet data.  For packet capture we need the
+ * complete wire-format packet, so insert the tag back into the
+ * cloned mbuf.
+ */
+static inline void
+pdump_vlan_restore(struct rte_mbuf *m)
+{
+	if (m->ol_flags & (RTE_MBUF_F_RX_VLAN_STRIPPED | RTE_MBUF_F_TX_VLAN)) {
+		if (rte_vlan_insert(&m) != 0)
+			return;
+		/*
+		 * Clear offload flags so the pcap writer sees the packet
+		 * as a plain tagged frame rather than acting on these again.
+		 */
+		m->ol_flags &= ~(RTE_MBUF_F_RX_VLAN_STRIPPED | RTE_MBUF_F_TX_VLAN);
+	}
+}
+
 /* Create a clone of mbuf to be placed into ring. */
 static void
 pdump_copy_burst(uint16_t port_id, uint16_t queue_id,
@@ -182,8 +206,14 @@ pdump_copy_burst(uint16_t port_id, uint16_t queue_id,
 
 		if (unlikely(p == NULL))
 			rte_atomic_fetch_add_explicit(&stats->nombuf, 1, rte_memory_order_relaxed);
-		else
+		else {
+			/*
+			 * Restore any VLAN tag that was offloaded to metadata
+			 * so the captured packet has the complete wire format.
+			 */
+			pdump_vlan_restore(p);
 			dup_bufs[d_pkts++] = p;
+		}
 	}
 
 	if (d_pkts == 0)
-- 
2.53.0

[PATCH v21 15/25] net/pcap: add link status for interface mode

[Stephen Hemminger]

When the PCAP PMD is used in pass-through mode with a physical
interface (iface=X), the link status was always reported with
hardcoded values regardless of the actual interface state.

Add OS-dependent function to query the real link state from
the underlying interface.

Linux and FreeBSD use SIOCGIFFLAGS to check IFF_UP and
IFF_RUNNING. Windows uses GetAdaptersAddresses() to check
OperStatus.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 38 +++++++++-----
 drivers/net/pcap/pcap_osdep.h          | 12 +++++
 drivers/net/pcap/pcap_osdep_freebsd.c  | 31 ++++++++++++
 drivers/net/pcap/pcap_osdep_linux.c    | 27 ++++++++++
 drivers/net/pcap/pcap_osdep_windows.c  | 68 +++++++++++++++++++++-----
 6 files changed, 154 insertions(+), 23 deletions(-)

diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 7a74f732d3..a9ddd872cf 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -139,6 +139,7 @@ New Features
 * **Updated PCAP ethernet driver.**
 
   * Added support for VLAN insertion and stripping.
+  * Added support for reporting link state in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index c16bff9198..4894e04e8a 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -150,13 +150,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct rte_eth_link pmd_link = {
-		.link_speed = RTE_ETH_SPEED_NUM_10G,
-		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
-		.link_status = RTE_ETH_LINK_DOWN,
-		.link_autoneg = RTE_ETH_LINK_FIXED,
-};
-
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
 static struct queue_missed_stat*
@@ -941,10 +934,28 @@ eth_dev_close(struct rte_eth_dev *dev)
 }
 
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused)
+eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 {
-	return 0;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link link = {
+		.link_speed = RTE_ETH_SPEED_NUM_10G,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
+
+	/*
+	 * For pass-through mode (single_iface), query whether the
+	 * underlying interface is up. Otherwise use default values.
+	 */
+	if (internals->single_iface) {
+		link.link_status = (osdep_iface_link_status(internals->rx_queue[0].name) > 0) ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	} else {
+		link.link_status = dev->data->dev_started ?
+			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
 }
 
 static int
@@ -1358,7 +1369,12 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	data = (*eth_dev)->data;
 	data->nb_rx_queues = (uint16_t)nb_rx_queues;
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
-	data->dev_link = pmd_link;
+	data->dev_link = (struct rte_eth_link) {
+		.link_speed = RTE_ETH_SPEED_NUM_NONE,
+		.link_duplex = RTE_ETH_LINK_FULL_DUPLEX,
+		.link_status = RTE_ETH_LINK_DOWN,
+		.link_autoneg = RTE_ETH_LINK_FIXED,
+	};
 	data->mac_addrs = &(*internals)->eth_addr;
 	data->promiscuous = 1;
 	data->all_multicast = 1;
diff --git a/drivers/net/pcap/pcap_osdep.h b/drivers/net/pcap/pcap_osdep.h
index fe7399ff9f..18e63c6f2b 100644
--- a/drivers/net/pcap/pcap_osdep.h
+++ b/drivers/net/pcap/pcap_osdep.h
@@ -10,6 +10,7 @@
 
 #define PMD_LOG(level, ...) \
 	RTE_LOG_LINE_PREFIX(level, ETH_PCAP, "%s(): ", __func__, __VA_ARGS__)
+
 extern int eth_pcap_logtype;
 #define RTE_LOGTYPE_ETH_PCAP eth_pcap_logtype
 
@@ -30,4 +31,15 @@ extern int eth_pcap_logtype;
 int osdep_iface_index_get(const char *name);
 int osdep_iface_mac_get(const char *name, struct rte_ether_addr *mac);
 
+/**
+ * Get link status for a network interface.
+ *
+ * @param name
+ *   Interface name (e.g., "eth0" on Linux, "{GUID}" on Windows).
+ * @return
+ *   1 if link is up, 0 if link is down, -1 on error.
+ */
+int osdep_iface_link_status(const char *name);
+
+
 #endif
diff --git a/drivers/net/pcap/pcap_osdep_freebsd.c b/drivers/net/pcap/pcap_osdep_freebsd.c
index 0185665f0b..9c4186aadc 100644
--- a/drivers/net/pcap/pcap_osdep_freebsd.c
+++ b/drivers/net/pcap/pcap_osdep_freebsd.c
@@ -5,8 +5,13 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <net/if.h>
 #include <net/if_dl.h>
+#include <net/if_media.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 
 #include "pcap_osdep.h"
@@ -55,3 +60,29 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	free(buf);
 	return 0;
 }
+
+int
+osdep_iface_link_status(const char *if_name)
+{
+	struct ifmediareq ifmr;
+	int fd, status = 0;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd == -1)
+		return -1;
+
+	memset(&ifmr, 0, sizeof(ifmr));
+	strlcpy(ifmr.ifm_name, if_name, sizeof(ifmr.ifm_name));
+
+	if (ioctl(fd, SIOCGIFMEDIA, &ifmr) == 0) {
+		/* IFM_AVALID means status is valid, IFM_ACTIVE means link up */
+		if ((ifmr.ifm_status & IFM_AVALID) &&
+		    (ifmr.ifm_status & IFM_ACTIVE))
+			status = 1;
+	} else {
+		status = -1;
+	}
+
+	close(fd);
+	return status;
+}
diff --git a/drivers/net/pcap/pcap_osdep_linux.c b/drivers/net/pcap/pcap_osdep_linux.c
index df976417cb..f61b7bd146 100644
--- a/drivers/net/pcap/pcap_osdep_linux.c
+++ b/drivers/net/pcap/pcap_osdep_linux.c
@@ -40,3 +40,30 @@ osdep_iface_mac_get(const char *if_name, struct rte_ether_addr *mac)
 	close(if_fd);
 	return 0;
 }
+
+int
+osdep_iface_link_status(const char *if_name)
+{
+	struct ifreq ifr;
+	int fd, status = 0;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd == -1)
+		return -1;
+
+	rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
+	if (ioctl(fd, SIOCGIFFLAGS, &ifr) == 0) {
+		/*
+		 * IFF_UP means administratively up.
+		 * IFF_RUNNING means operationally up (carrier detected).
+		 * Both must be set for link to be considered up.
+		 */
+		if ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))
+			status = 1;
+	} else {
+		status = -1;
+	}
+
+	close(fd);
+	return status;
+}
diff --git a/drivers/net/pcap/pcap_osdep_windows.c b/drivers/net/pcap/pcap_osdep_windows.c
index 0965c2f5c9..e7a49c47e0 100644
--- a/drivers/net/pcap/pcap_osdep_windows.c
+++ b/drivers/net/pcap/pcap_osdep_windows.c
@@ -61,38 +61,56 @@ osdep_iface_index_get(const char *device_name)
 }
 
 /*
- * libpcap takes device names like "\Device\NPF_{GUID}",
- * GetAdaptersAddresses() returns names in "{GUID}" form.
- * Try to extract GUID from device name, fall back to original device name.
+ * Helper function to get adapter information by name.
+ * Returns adapter info on success, NULL on failure.
+ * Caller must free the returned buffer.
  */
-int
-osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+static IP_ADAPTER_ADDRESSES *
+get_adapter_addresses(void)
 {
-	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
-	ULONG size, sys_ret;
-	const char *adapter_name;
-	int ret = -1;
+	IP_ADAPTER_ADDRESSES *info = NULL;
+	ULONG size;
+	DWORD sys_ret;
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
 	if (sys_ret != ERROR_BUFFER_OVERFLOW) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu, expected %lu",
 			sys_ret, ERROR_BUFFER_OVERFLOW);
-		return -1;
+		return NULL;
 	}
 
 	info = (IP_ADAPTER_ADDRESSES *)malloc(size);
 	if (info == NULL) {
 		PMD_LOG(ERR, "Cannot allocate adapter address info");
-		return -1;
+		return NULL;
 	}
 
 	sys_ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, info, &size);
 	if (sys_ret != ERROR_SUCCESS) {
 		PMD_LOG(ERR, "GetAdapterAddresses() = %lu", sys_ret);
 		free(info);
-		return -1;
+		return NULL;
 	}
 
+	return info;
+}
+
+/*
+ * libpcap takes device names like "\Device\NPF_{GUID}",
+ * GetAdaptersAddresses() returns names in "{GUID}" form.
+ * Try to extract GUID from device name, fall back to original device name.
+ */
+int
+osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
+{
+	IP_ADAPTER_ADDRESSES *info = NULL, *cur = NULL;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
 	adapter_name = iface_guid(device_name);
 	if (adapter_name == NULL)
 		adapter_name = device_name;
@@ -116,3 +134,29 @@ osdep_iface_mac_get(const char *device_name, struct rte_ether_addr *mac)
 	free(info);
 	return ret;
 }
+
+int
+osdep_iface_link_status(const char *device_name)
+{
+	IP_ADAPTER_ADDRESSES *info, *cur;
+	const char *adapter_name;
+	int ret = -1;
+
+	info = get_adapter_addresses();
+	if (info == NULL)
+		return -1;
+
+	adapter_name = iface_guid(device_name);
+	if (adapter_name == NULL)
+		adapter_name = device_name;
+
+	for (cur = info; cur != NULL; cur = cur->Next) {
+		if (strcmp(cur->AdapterName, adapter_name) == 0) {
+			ret = (cur->OperStatus == IfOperStatusUp) ? 1 : 0;
+			break;
+		}
+	}
+
+	free(info);
+	return ret;
+}
-- 
2.53.0

[PATCH v21 16/25] net/pcap: support nanosecond timestamp precision

[Stephen Hemminger]

Enable nanosecond-precision timestamps for both live capture and pcap
file reading.

Replace pcap_open_live() with the pcap_create()/pcap_activate() API,
which allows setting PCAP_TSTAMP_PRECISION_NANO before
activation. Similarly, use pcap_open_offline_with_tstamp_precision()
for reading pcap files. The pcap_pkthdr timestamp field, despite being
declared as struct timeval, actually contains nanoseconds (not
microseconds) when nanosecond precision is requested.

Make receive timestamp offloading conditional: timestamps are now only
written to the mbuf dynamic field when RTE_ETH_RX_OFFLOAD_TIMESTAMP is
enabled. Previously, timestamps were unconditionally added to every
received packet.

Other related changes:
* Add read_clock dev_op returning current UTC time for timestamp
  correlation.
* Move per-burst timestamp calculation outside the packet loop in
  tx_dumper.
* Enable immediate mode and improve error reporting
  in live capture setup.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               |   3 +
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 161 +++++++++++++++++++------
 3 files changed, 130 insertions(+), 35 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index bed5006a42..2709c6d017 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -258,3 +258,6 @@ Features and Limitations
 *  The PMD will transparently insert a VLAN tag to transmitted packets if
    ``RTE_ETH_TX_OFFLOAD_VLAN_INSERT`` is enabled and the mbuf has ``RTE_MBUF_F_TX_VLAN``
    set.
+
+*  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
+   UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index a9ddd872cf..b46402064f 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -140,6 +140,7 @@ New Features
 
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state in ``iface`` mode.
+  * Receive timestamps support nanosecond precision.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 4894e04e8a..86a7d22cc6 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -27,13 +27,11 @@
 #include <rte_mbuf_dyn.h>
 #include <bus_vdev_driver.h>
 #include <rte_os_shim.h>
+#include <rte_time.h>
 
 #include "pcap_osdep.h"
 
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
-#define RTE_ETH_PCAP_PROMISC 1
-#define RTE_ETH_PCAP_TIMEOUT -1
 
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
@@ -77,6 +75,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
 	struct queue_missed_stat missed_stat;
@@ -108,6 +107,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool timestamp_offloading;
 };
 
 struct pmd_process_private {
@@ -269,6 +269,15 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(bufs[i]);
 
+		if (pcap_q->timestamp_offloading) {
+			struct timespec ts;
+
+			timespec_get(&ts, TIME_UTC);
+			*RTE_MBUF_DYNFIELD(bufs[i], timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = rte_timespec_to_ns(&ts);
+			bufs[i]->ol_flags |= timestamp_rx_dynflag;
+		}
+
 		rx_bytes += bufs[i]->data_len;
 
 		/* Enqueue packet back on ring to allow infinite rx. */
@@ -339,10 +348,21 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		if (pcap_q->vlan_strip)
 			rte_vlan_strip(mbuf);
 
-		uint64_t us = (uint64_t)header->ts.tv_sec * US_PER_S + header->ts.tv_usec;
+		if (pcap_q->timestamp_offloading) {
+			/*
+			 * The use of tv_usec as nanoseconds is not a bug here.
+			 * Interface is always created with nanosecond precision, and
+			 * that is how pcap API bodged in nanoseconds support.
+			 */
+			uint64_t ns = (uint64_t)header->ts.tv_sec * NSEC_PER_SEC
+				+  header->ts.tv_usec;
+
+			*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset,
+					   rte_mbuf_timestamp_t *) = ns;
+
+			mbuf->ol_flags |= timestamp_rx_dynflag;
+		}
 
-		*RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *) = us;
-		mbuf->ol_flags |= timestamp_rx_dynflag;
 		mbuf->port = pcap_q->port_id;
 		bufs[num_rx] = mbuf;
 		num_rx++;
@@ -362,14 +382,19 @@ eth_null_rx(void *queue __rte_unused,
 	return 0;
 }
 
-#define NSEC_PER_SEC	1000000000L
-
 /*
- * This function stores nanoseconds in `tv_usec` field of `struct timeval`,
- * because `ts` goes directly to nanosecond-precision dump.
+ * Calculate current timestamp in nanoseconds by computing
+ * offset from starting time value.
+ *
+ * Note: it is not a bug that this code is putting nanosecond
+ * value into microsecond timeval field. The pcap API is old
+ * and nanoseconds were bodged on as an after thought.
+ * As long as the pcap stream is set to nanosecond precision
+ * it expects nanoseconds here.
  */
 static inline void
-calculate_timestamp(struct timeval *ts) {
+calculate_timestamp(struct timeval *ts)
+{
 	uint64_t cycles;
 	struct timespec cur_time;
 
@@ -440,8 +465,10 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	if (dumper == NULL || nb_pkts == 0)
 		return 0;
 
-	/* writes the nb_pkts packets to the previously opened pcap file
-	 * dumper */
+	/* all packets in burst have same timestamp */
+	calculate_timestamp(&header.ts);
+
+	/* writes the nb_pkts packets to the previously opened pcap file dumper */
 	for (i = 0; i < nb_pkts; i++) {
 		struct rte_mbuf *mbuf = bufs[i];
 		uint32_t len, caplen;
@@ -450,8 +477,6 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		len = rte_pktmbuf_pkt_len(mbuf);
 		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
 
-		calculate_timestamp(&header.ts);
-
 		header.len = len;
 		header.caplen = caplen;
 
@@ -569,22 +594,62 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+open_iface_live(const char *iface, pcap_t **pcap)
+{
+	pcap_t *pc;
+	int status;
 
-	if (*pcap == NULL) {
-		PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
-		return -1;
+	pc = pcap_create(iface, errbuf);
+	if (pc == NULL) {
+		PMD_LOG(ERR, "Couldn't create %s: %s", iface, errbuf);
+		goto error;
 	}
 
-	if (pcap_setnonblock(*pcap, 1, errbuf)) {
+	status = pcap_set_tstamp_precision(pc, PCAP_TSTAMP_PRECISION_NANO);
+	if (status != 0) {
+		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
+			iface, pcap_statustostr(status));
+		goto error;
+	}
+
+	status = pcap_set_immediate_mode(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to immediate mode: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_promisc(pc, 1);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	if (status != 0)
+		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
+			iface, pcap_statustostr(status));
+
+	status = pcap_activate(pc);
+	if (status < 0) {
+		char *cp = pcap_geterr(pc);
+
+		if (status == PCAP_ERROR)
+			PMD_LOG(ERR, "%s: could not activate: %s", iface, cp);
+		else
+			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
+		goto error;
+	}
+
+	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
-		pcap_close(*pcap);
-		return -1;
+		goto error;
 	}
 
+	*pcap = pc;
 	return 0;
+
+error:
+	if (pc != NULL)
+		pcap_close(pc);
+	return -1;
 }
 
 static int
@@ -631,7 +696,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
-	*pcap = pcap_open_offline(pcap_filename, errbuf);
+	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
+							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
 			errbuf);
@@ -790,6 +856,17 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
+
+	if (internals->timestamp_offloading && timestamp_rx_dynflag == 0) {
+		int ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
+							     &timestamp_rx_dynflag);
+		if (ret != 0) {
+			PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
+			return ret;
+		}
+	}
+
 	return 0;
 }
 
@@ -807,7 +884,8 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->min_rx_bufsize = 0;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
-	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
+		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
 	return 0;
 }
@@ -974,6 +1052,7 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
+	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
 	if (internals->infinite_rx) {
 		struct pmd_process_private *pp;
@@ -1112,6 +1191,17 @@ eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 	return 0;
 }
 
+/* Timestamp values in receive packets from libpcap are in nanoseconds */
+static int
+eth_dev_read_clock(struct rte_eth_dev *dev __rte_unused, uint64_t *timestamp)
+{
+	struct timespec cur_time;
+
+	timespec_get(&cur_time, TIME_UTC);
+	*timestamp = rte_timespec_to_ns(&cur_time);
+	return 0;
+}
+
 static int
 eth_vlan_offload_set(struct rte_eth_dev *dev, int mask)
 {
@@ -1138,6 +1228,7 @@ static const struct eth_dev_ops ops = {
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
+	.read_clock = eth_dev_read_clock,
 	.rx_queue_setup = eth_rx_queue_setup,
 	.tx_queue_setup = eth_tx_queue_setup,
 	.tx_queue_release = eth_tx_queue_release,
@@ -1553,15 +1644,15 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	name = rte_vdev_device_name(dev);
 	PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
 
-	timespec_get(&start_time, TIME_UTC);
-	start_cycles = rte_get_timer_cycles();
-	hz = rte_get_timer_hz();
-
-	ret = rte_mbuf_dyn_rx_timestamp_register(&timestamp_dynfield_offset,
-			&timestamp_rx_dynflag);
-	if (ret != 0) {
-		PMD_LOG(ERR, "Failed to register Rx timestamp field/flag");
-		return -1;
+	/* Record info for timestamps on first probe */
+	if (hz == 0) {
+		hz = rte_get_timer_hz();
+		if (hz == 0) {
+			PMD_LOG(ERR, "Reported hz is zero!");
+			return -1;
+		}
+		timespec_get(&start_time, TIME_UTC);
+		start_cycles = rte_get_timer_cycles();
 	}
 
 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
-- 
2.53.0

[PATCH v21 17/25] net/pcap: reject non-Ethernet interfaces

[Stephen Hemminger]

The pcap PMD sends and receives raw Ethernet frames. If used with
an interface that has a different link type, packets will be malformed.

On FreeBSD and macOS, the loopback interface uses DLT_NULL which expects
a 4-byte address family header instead of an Ethernet header. Sending
Ethernet frames to such interfaces causes kernel warnings like:
  looutput: af=-1 unexpected

Add a check after pcap_activate() to verify the interface uses
DLT_EN10MB (Ethernet) link type and reject others with a clear error.

Fixes: 4c173302c307 ("pcap: add new driver")
Cc: stable@dpdk.org

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 drivers/net/pcap/pcap_ethdev.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 86a7d22cc6..dd640a82c4 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -638,6 +638,17 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		goto error;
 	}
 
+	/*
+	 * Verify interface supports Ethernet link type.
+	 * Loopback on FreeBSD/macOS uses DLT_NULL which expects a 4-byte
+	 * address family header instead of Ethernet, causing kernel warnings.
+	 */
+	if (pcap_datalink(pc) != DLT_EN10MB) {
+		PMD_LOG(ERR, "%s: not Ethernet (link type %d)",
+			iface, pcap_datalink(pc));
+		goto error;
+	}
+
 	if (pcap_setnonblock(pc, 1, errbuf)) {
 		PMD_LOG(ERR, "Couldn't set non-blocking on %s: %s", iface, errbuf);
 		goto error;
-- 
2.53.0

[PATCH v21 18/25] net/pcap: reduce scope of file-level variables

[Stephen Hemminger]

Move errbuf from file scope to local variables in the two functions that
use it (open_iface_live and open_single_rx_pcap). This avoids potential
issues if these functions were called concurrently, since each call now
has its own error buffer.  Move iface_idx to a static local variable
within pmd_init_internals(), the only function that uses it. The
variable remains static to preserve the MAC address uniqueness counter
across calls.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Marat Khalili <marat.khalili@huawei.com>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
 drivers/net/pcap/pcap_ethdev.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index dd640a82c4..0ac8b90ce3 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -46,11 +46,9 @@
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
 
-static char errbuf[PCAP_ERRBUF_SIZE];
 static struct timespec start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
-static uint8_t iface_idx;
 
 static uint64_t timestamp_rx_dynflag;
 static int timestamp_dynfield_offset = -1;
@@ -596,6 +594,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static inline int
 open_iface_live(const char *iface, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
 	int status;
 
@@ -707,6 +706,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 static int
 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
 {
+	char errbuf[PCAP_ERRBUF_SIZE];
+
 	*pcap = pcap_open_offline_with_tstamp_precision(pcap_filename,
 							PCAP_TSTAMP_PRECISION_NANO, errbuf);
 	if (*pcap == NULL) {
@@ -1464,6 +1465,7 @@ pmd_init_internals(struct rte_vdev_device *vdev,
 	 * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
 	 * where the middle 4 characters are converted to hex.
 	 */
+	static uint8_t iface_idx;
 	(*internals)->eth_addr = (struct rte_ether_addr) {
 		.addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
 	};
-- 
2.53.0

[PATCH v21 19/25] net/pcap: clarify maximum received packet

[Stephen Hemminger]

The driver has constant RTE_ETH_PCAP_SNAPSHOT_LEN with is set
to the largest value the pcap library will return, so that should
also be the largest receive buffer.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
 drivers/net/pcap/pcap_ethdev.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 0ac8b90ce3..0da3062d2f 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -890,10 +890,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = (uint32_t) -1;
+	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
 	dev_info->min_rx_bufsize = 0;
+	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
-- 
2.53.0

[PATCH v21 20/25] eal/windows: add wrapper for access function

[Stephen Hemminger]

Like other Posix functions in unistd.h add wrapper
using the Windows equivalent.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
 lib/eal/windows/include/rte_os_shim.h | 1 +
 lib/eal/windows/include/unistd.h      | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/lib/eal/windows/include/rte_os_shim.h b/lib/eal/windows/include/rte_os_shim.h
index f16b2230c8..44664a5062 100644
--- a/lib/eal/windows/include/rte_os_shim.h
+++ b/lib/eal/windows/include/rte_os_shim.h
@@ -33,6 +33,7 @@
 #define unlink(path) _unlink(path)
 #define fileno(f) _fileno(f)
 #define isatty(fd) _isatty(fd)
+#define access(path, mode) _access(path, mode)
 
 #define IPVERSION	4
 
diff --git a/lib/eal/windows/include/unistd.h b/lib/eal/windows/include/unistd.h
index 78150c6480..f95888f4e1 100644
--- a/lib/eal/windows/include/unistd.h
+++ b/lib/eal/windows/include/unistd.h
@@ -23,4 +23,11 @@
 #define STDERR_FILENO _fileno(stderr)
 #endif
 
+/* Mode values for the _access() function.  */
+#ifndef F_OK
+#define	F_OK		0	/* test for existence of file */
+#define	W_OK		0x02	/* test for write permission */
+#define	R_OK		0x04	/* test for read permission */
+#endif
+
 #endif /* _UNISTD_H_ */
-- 
2.53.0

[PATCH v21 21/25] net/pcap: add snapshot length devarg

[Stephen Hemminger]

Add a new devarg 'snaplen' to configure the pcap snapshot length,
which controls the maximum packet size for capture and output.

The snapshot length affects:
- The pcap_set_snaplen() call when capturing from interfaces
- The pcap_open_dead() snapshot parameter for output files
- The reported max_rx_pktlen in device info
- The reported max_mtu in device info (snaplen - ethernet header)

The default value is 65535 bytes, preserving backward compatibility
with previous driver behavior.

The snaplen argument is parsed before interface and file arguments
so that its value is available when pcap handles are opened during
device creation.

Example usage:
  --vdev 'net_pcap0,snaplen=1518,iface=eth0'
  --vdev 'net_pcap0,snaplen=9000,rx_pcap=in.pcap,tx_pcap=out.pcap'

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
 doc/guides/nics/pcap.rst               |  17 ++
 doc/guides/rel_notes/release_26_03.rst |   1 +
 drivers/net/pcap/pcap_ethdev.c         | 208 +++++++++++++++++--------
 3 files changed, 157 insertions(+), 69 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2709c6d017..2754e205c7 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -15,6 +15,23 @@ For more information about the pcap library, see the
    The pcap-based PMD requires the libpcap development files to be installed.
    This applies to all supported operating systems: Linux, FreeBSD, and Windows.
 
+* Set the snapshot length for packet capture
+
+  The snapshot length controls the maximum number of bytes captured per packet.
+  This affects both interface capture and pcap file output.  The default value is
+  65535 bytes, which captures complete packets up to the maximum Ethernet jumbo
+  frame size.  Reducing this value can improve performance when only packet headers
+  are needed.
+
+  The ``snaplen`` argument is used when opening capture handles, so it should
+  be specified before the interface or file arguments.  Example::
+
+     --vdev 'net_pcap0,snaplen=1518,iface=eth0'
+     --vdev 'net_pcap0,snaplen=9000,rx_pcap=in.pcap,tx_pcap=out.pcap'
+
+  The snapshot length also determines the reported ``max_rx_pktlen``
+  and ``max_mtu`` in device info.
+
 
 Using the Driver from the EAL Command Line
 ------------------------------------------
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index b46402064f..869084d4cd 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -141,6 +141,7 @@ New Features
   * Added support for VLAN insertion and stripping.
   * Added support for reporting link state in ``iface`` mode.
   * Receive timestamps support nanosecond precision.
+  * Added ``snaplen`` devarg to configure packet capture snapshot length.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 0da3062d2f..2de9c85124 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -13,6 +13,8 @@
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#include <unistd.h>
+
 #include <pcap.h>
 
 #include <rte_cycles.h>
@@ -31,8 +33,6 @@
 
 #include "pcap_osdep.h"
 
-#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
-
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -41,6 +41,12 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
+
+#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
+
+/* This is defined in libpcap but not exposed in headers */
+#define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
 #define ETH_PCAP_ARG_MAXLEN	64
 
@@ -101,6 +107,7 @@ struct pmd_internals {
 	char devargs[ETH_PCAP_ARG_MAXLEN];
 	struct rte_ether_addr eth_addr;
 	int if_index;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
@@ -119,15 +126,18 @@ struct pmd_devargs {
 	bool phy_mac;
 	struct devargs_queue {
 		pcap_dumper_t *dumper;
+		/* pcap and name/type fields... */
 		pcap_t *pcap;
 		const char *name;
 		const char *type;
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
+	uint32_t snapshot_len;
 };
 
 struct pmd_devargs_all {
 	struct pmd_devargs rx_queues;
 	struct pmd_devargs tx_queues;
+	uint32_t snapshot_len;
 	bool single_iface;
 	bool is_tx_pcap;
 	bool is_tx_iface;
@@ -145,6 +155,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
 
@@ -447,20 +458,19 @@ eth_pcap_tx_prepare(void *queue __rte_unused, struct rte_mbuf **tx_pkts, uint16_
 static uint16_t
 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *dumper_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct pmd_process_private *pp = dev->process_private;
+	pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id];
+	unsigned char *temp_data = dumper_q->bounce_buf;
+	uint32_t snaplen = internals->snapshot_len;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
 	struct pcap_pkthdr header;
-	pcap_dumper_t *dumper;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[dumper_q->port_id].process_private;
-	dumper = pp->tx_dumper[dumper_q->queue_id];
-	temp_data = dumper_q->bounce_buf;
+	unsigned int i;
 
-	if (dumper == NULL || nb_pkts == 0)
+	if (unlikely(dumper == NULL))
 		return 0;
 
 	/* all packets in burst have same timestamp */
@@ -473,7 +483,7 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		const uint8_t *data;
 
 		len = rte_pktmbuf_pkt_len(mbuf);
-		caplen = RTE_MIN(len, RTE_ETH_PCAP_SNAPSHOT_LEN);
+		caplen = RTE_MIN(len, snaplen);
 
 		header.len = len;
 		header.caplen = caplen;
@@ -539,19 +549,18 @@ eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 static uint16_t
 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
-	unsigned int i;
-	struct pmd_process_private *pp;
 	struct pcap_tx_queue *tx_queue = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[tx_queue->port_id];
+	struct pmd_process_private *pp = dev->process_private;
+	struct pmd_internals *internals = dev->data->dev_private;
+	uint32_t snaplen = internals->snapshot_len;
+	pcap_t *pcap = pp->tx_pcap[tx_queue->queue_id];
+	unsigned char *temp_data = tx_queue->bounce_buf;
 	uint16_t num_tx = 0;
 	uint32_t tx_bytes = 0;
-	pcap_t *pcap;
-	unsigned char *temp_data;
-
-	pp = rte_eth_devices[tx_queue->port_id].process_private;
-	pcap = pp->tx_pcap[tx_queue->queue_id];
-	temp_data = tx_queue->bounce_buf;
+	unsigned int i;
 
-	if (unlikely(nb_pkts == 0 || pcap == NULL))
+	if (unlikely(pcap == NULL))
 		return 0;
 
 	for (i = 0; i < nb_pkts; i++) {
@@ -559,13 +568,16 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 		uint32_t len = rte_pktmbuf_pkt_len(mbuf);
 		const uint8_t *data;
 
-		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
-				len > RTE_ETH_PCAP_SNAPSHOT_LEN)) {
+		/*
+		 * multi-segment transmit that has to go through bounce buffer.
+		 * Make sure it fits; don't want to truncate the packet.
+		 */
+		if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && len > snaplen)) {
 			PMD_TX_LOG(ERR,
-				"Dropping multi segment PCAP packet. Size (%u) > max size (%u).",
-				len, RTE_ETH_PCAP_SNAPSHOT_LEN);
-			tx_queue->tx_stat.err_pkts++;
+				   "Multi segment len (%u) > snaplen (%u)",
+				   len, snaplen);
 			rte_pktmbuf_free(mbuf);
+			tx_queue->tx_stat.err_pkts++;
 			continue;
 		}
 
@@ -592,7 +604,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
  * pcap_open_live wrapper function
  */
 static inline int
-open_iface_live(const char *iface, pcap_t **pcap)
+open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
 	char errbuf[PCAP_ERRBUF_SIZE];
 	pcap_t *pc;
@@ -609,6 +621,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(ERR, "%s: Could not set to ns precision: %s",
 			iface, pcap_statustostr(status));
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	status = pcap_set_immediate_mode(pc, 1);
@@ -621,7 +636,7 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s",
 			iface, pcap_statustostr(status));
 
-	status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN);
+	status = pcap_set_snaplen(pc, snaplen);
 	if (status != 0)
 		PMD_LOG(WARNING, "%s: Could not set snapshot length: %s",
 			iface, pcap_statustostr(status));
@@ -635,6 +650,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 		else
 			PMD_LOG(ERR, "%s: %s (%s)", iface, pcap_statustostr(status), cp);
 		goto error;
+	} else if (status > 0) {
+		/* Warning condition - log but continue */
+		PMD_LOG(WARNING, "%s: %s", iface, pcap_statustostr(status));
 	}
 
 	/*
@@ -663,9 +681,9 @@ open_iface_live(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
+open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen)
 {
-	if (open_iface_live(iface, pcap) < 0) {
+	if (open_iface_live(iface, pcap, snaplen) < 0) {
 		PMD_LOG(ERR, "Couldn't open interface %s", iface);
 		return -1;
 	}
@@ -674,7 +692,8 @@ open_single_iface(const char *iface, pcap_t **pcap)
 }
 
 static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper,
+		    uint32_t snaplen)
 {
 	pcap_t *tx_pcap;
 
@@ -684,7 +703,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	 * pcap holder.
 	 */
 	tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
-			RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
+			snaplen, PCAP_TSTAMP_PRECISION_NANO);
 	if (tx_pcap == NULL) {
 		PMD_LOG(ERR, "Couldn't create dead pcap");
 		return -1;
@@ -693,9 +712,9 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
 	/* The dumper is created using the previous pcap_t reference */
 	*dumper = pcap_dump_open(tx_pcap, pcap_filename);
 	if (*dumper == NULL) {
+		PMD_LOG(ERR, "Couldn't open %s for writing: %s",
+			pcap_filename, pcap_geterr(tx_pcap));
 		pcap_close(tx_pcap);
-		PMD_LOG(ERR, "Couldn't open %s for writing.",
-			pcap_filename);
 		return -1;
 	}
 
@@ -737,6 +756,21 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+static int
+set_iface_direction(const char *iface, pcap_t *pcap,
+		pcap_direction_t direction)
+{
+	const char *direction_str = (direction == PCAP_D_IN) ? "IN" : "OUT";
+	if (pcap_setdirection(pcap, direction) < 0) {
+		PMD_LOG(ERR, "Setting %s pcap direction %s failed - %s",
+				iface, direction_str, pcap_geterr(pcap));
+		return -1;
+	}
+	PMD_LOG(INFO, "Setting %s pcap direction %s",
+			iface, direction_str);
+	return 0;
+}
+
 static int
 eth_dev_start(struct rte_eth_dev *dev)
 {
@@ -745,15 +779,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 	struct pmd_process_private *pp = dev->process_private;
 	struct pcap_tx_queue *tx;
 	struct pcap_rx_queue *rx;
+	uint32_t snaplen = internals->snapshot_len;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
 		tx = &internals->tx_queue[0];
 		rx = &internals->rx_queue[0];
 
-		if (!pp->tx_pcap[0] &&
-			strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
+		if (!pp->tx_pcap[0] && strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0)
 				return -1;
 			pp->rx_pcap[0] = pp->tx_pcap[0];
 		}
@@ -765,14 +799,11 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		tx = &internals->tx_queue[i];
 
-		if (!pp->tx_dumper[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
-			if (open_single_tx_pcap(tx->name,
-				&pp->tx_dumper[i]) < 0)
+		if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
+			if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0)
 				return -1;
-		} else if (!pp->tx_pcap[i] &&
-				strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
-			if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
+		} else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+			if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0)
 				return -1;
 		}
 	}
@@ -787,9 +818,14 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
 				return -1;
-		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
-			if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 ||
+			   strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
+			if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0)
 				return -1;
+			/* Set direction for rx_iface_in */
+			if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
+				set_iface_direction(rx->name, pp->rx_pcap[i],
+						    PCAP_D_IN);
 		}
 	}
 
@@ -890,11 +926,11 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
-	dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN;
+	dev_info->max_rx_pktlen = internals->snapshot_len;
 	dev_info->max_rx_queues = dev->data->nb_rx_queues;
 	dev_info->max_tx_queues = dev->data->nb_tx_queues;
-	dev_info->min_rx_bufsize = 0;
-	dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN;
+	dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN;
+	dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN;
 	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
 		RTE_ETH_TX_OFFLOAD_VLAN_INSERT;
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
@@ -1152,7 +1188,7 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = tx_queue_id;
-	pcap_q->bounce_buf = rte_malloc_socket(NULL, RTE_ETH_PCAP_SNAPSHOT_LEN,
+	pcap_q->bounce_buf = rte_malloc_socket(NULL, internals->snapshot_len,
 					       RTE_CACHE_LINE_SIZE, socket_id);
 	if (pcap_q->bounce_buf == NULL)
 		return -ENOMEM;
@@ -1304,7 +1340,8 @@ open_tx_pcap(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *dumpers = extra_args;
 	pcap_dumper_t *dumper;
 
-	if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+	if (open_single_tx_pcap(pcap_filename, &dumper,
+				dumpers->snapshot_len) < 0)
 		return -1;
 
 	if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
@@ -1325,7 +1362,7 @@ open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *tx = extra_args;
 	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (open_single_iface(iface, &pcap, tx->snapshot_len) < 0)
 		return -1;
 
 	tx->queue[0].pcap = pcap;
@@ -1335,21 +1372,6 @@ open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
-static inline int
-set_iface_direction(const char *iface, pcap_t *pcap,
-		pcap_direction_t direction)
-{
-	const char *direction_str = (direction == PCAP_D_IN) ? "IN" : "OUT";
-	if (pcap_setdirection(pcap, direction) < 0) {
-		PMD_LOG(ERR, "Setting %s pcap direction %s failed - %s",
-				iface, direction_str, pcap_geterr(pcap));
-		return -1;
-	}
-	PMD_LOG(INFO, "Setting %s pcap direction %s",
-			iface, direction_str);
-	return 0;
-}
-
 static inline int
 open_iface(const char *key, const char *value, void *extra_args)
 {
@@ -1357,7 +1379,7 @@ open_iface(const char *key, const char *value, void *extra_args)
 	struct pmd_devargs *pmd = extra_args;
 	pcap_t *pcap = NULL;
 
-	if (open_single_iface(iface, &pcap) < 0)
+	if (open_single_iface(iface, &pcap, pmd->snapshot_len) < 0)
 		return -1;
 	if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
 		pcap_close(pcap);
@@ -1425,6 +1447,31 @@ process_bool_flag(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
+static int
+process_snapshot_len(const char *key, const char *value, void *extra_args)
+{
+	uint32_t *snaplen = extra_args;
+	unsigned long val;
+	char *endptr;
+
+	if (value == NULL || *value == '\0') {
+		PMD_LOG(ERR, "Argument '%s' requires a value", key);
+		return -1;
+	}
+
+	errno = 0;
+	val = strtoul(value, &endptr, 10);
+	if (errno != 0 || *endptr != '\0' ||
+	    val < RTE_ETHER_HDR_LEN ||
+	    val > ETH_PCAP_MAXIMUM_SNAPLEN) {
+		PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value);
+		return -1;
+	}
+
+	*snaplen = (uint32_t)val;
+	return 0;
+}
+
 static int
 pmd_init_internals(struct rte_vdev_device *vdev,
 		const unsigned int nb_rx_queues,
@@ -1588,6 +1635,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->snapshot_len = devargs_all->snapshot_len;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1649,6 +1698,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 	int ret = 0;
 
 	struct pmd_devargs_all devargs_all = {
+		.snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT,
 		.single_iface = 0,
 		.is_tx_pcap = 0,
 		.is_tx_iface = 0,
@@ -1688,6 +1738,25 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 			return -1;
 	}
 
+	/*
+	 * Process optional snapshot length argument first, so the value
+	 * is available when opening pcap handles for files and interfaces.
+	 */
+	if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) {
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG,
+					 &process_snapshot_len,
+					 &devargs_all.snapshot_len);
+		if (ret < 0)
+			goto free_kvlist;
+	}
+
+	/*
+	 * Propagate snapshot length to per-queue devargs so that
+	 * the open callbacks can access it.
+	 */
+	devargs_all.rx_queues.snapshot_len = devargs_all.snapshot_len;
+	devargs_all.tx_queues.snapshot_len = devargs_all.snapshot_len;
+
 	/*
 	 * If iface argument is passed we open the NICs and use them for
 	 * reading / writing
@@ -1893,4 +1962,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_TX_IFACE_ARG "=<ifc> "
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
-	ETH_PCAP_INFINITE_RX_ARG "=<0|1>");
+	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.53.0

[PATCH v21 22/25] net/pcap: add Rx scatter offload

[Stephen Hemminger]

Add RTE_ETH_RX_OFFLOAD_SCATTER to the advertised receive offload
capabilities if not using infinite_rx mode.

Validate in rx_queue_setup that the mbuf pool data room is
large enough when scatter is not enabled, following the
same pattern as the virtio driver.

Gate the multi-segment receive path on the scatter offload flag
and drop oversized packets when scatter is disabled.
Reject scatter with infinite_rx mode since the ring-based replay
path does not support multi-segment mbufs.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
---
 drivers/net/pcap/pcap_ethdev.c | 47 ++++++++++++++++++++++++++++++++--
 1 file changed, 45 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 2de9c85124..9b1fbdba3d 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -79,6 +79,7 @@ struct pcap_rx_queue {
 	uint16_t port_id;
 	uint16_t queue_id;
 	bool vlan_strip;
+	bool rx_scatter;
 	bool timestamp_offloading;
 	struct rte_mempool *mb_pool;
 	struct queue_stat rx_stat;
@@ -112,6 +113,7 @@ struct pmd_internals {
 	bool phy_mac;
 	bool infinite_rx;
 	bool vlan_strip;
+	bool rx_scatter;
 	bool timestamp_offloading;
 };
 
@@ -342,14 +344,19 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			/* pcap packet will fit in the mbuf, can copy it */
 			rte_memcpy(rte_pktmbuf_mtod(mbuf, void *), packet, len);
 			mbuf->data_len = len;
-		} else {
-			/* Try read jumbo frame into multi mbufs. */
+		} else if (pcap_q->rx_scatter) {
+			/* Scatter into multi-segment mbufs. */
 			if (unlikely(eth_pcap_rx_jumbo(pcap_q->mb_pool,
 						       mbuf, packet, len) == -1)) {
 				pcap_q->rx_stat.err_pkts++;
 				rte_pktmbuf_free(mbuf);
 				break;
 			}
+		} else {
+			/* Packet too large and scatter not enabled, drop it. */
+			pcap_q->rx_stat.err_pkts++;
+			rte_pktmbuf_free(mbuf);
+			continue;
 		}
 
 		mbuf->pkt_len = len;
@@ -904,6 +911,7 @@ eth_dev_configure(struct rte_eth_dev *dev)
 	const struct rte_eth_rxmode *rxmode = &dev_conf->rxmode;
 
 	internals->vlan_strip = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP);
+	internals->rx_scatter = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_SCATTER);
 	internals->timestamp_offloading = !!(rxmode->offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP);
 
 	if (internals->timestamp_offloading && timestamp_rx_dynflag == 0) {
@@ -936,6 +944,9 @@ eth_dev_info(struct rte_eth_dev *dev,
 	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
 		RTE_ETH_RX_OFFLOAD_TIMESTAMP;
 
+	if (!internals->infinite_rx)
+		dev_info->rx_offload_capa |= RTE_ETH_RX_OFFLOAD_SCATTER;
+
 	return 0;
 }
 
@@ -1095,11 +1106,37 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 {
 	struct pmd_internals *internals = dev->data->dev_private;
 	struct pcap_rx_queue *pcap_q = &internals->rx_queue[rx_queue_id];
+	uint16_t buf_size;
+	bool rx_scatter;
+
+	buf_size = rte_pktmbuf_data_room_size(mb_pool) - RTE_PKTMBUF_HEADROOM;
+	rx_scatter = !!(dev->data->dev_conf.rxmode.offloads &
+			RTE_ETH_RX_OFFLOAD_SCATTER);
+
+	/*
+	 * If Rx scatter is not enabled, verify that the mbuf data room
+	 * can hold the largest received packet in a single segment.
+	 * Use the MTU-derived frame size as the expected maximum, not
+	 * snapshot_len which is a capture truncation limit rather than
+	 * an expected packet size.
+	 */
+	if (!rx_scatter) {
+		uint32_t max_rx_pktlen = dev->data->mtu + RTE_ETHER_HDR_LEN;
+
+		if (max_rx_pktlen > buf_size) {
+			PMD_LOG(ERR,
+				"Rx scatter is disabled and RxQ mbuf pool object size is too small "
+				"(buf_size=%u, max_rx_pkt_len=%u)",
+				buf_size, max_rx_pktlen);
+			return -EINVAL;
+		}
+	}
 
 	pcap_q->mb_pool = mb_pool;
 	pcap_q->port_id = dev->data->port_id;
 	pcap_q->queue_id = rx_queue_id;
 	pcap_q->vlan_strip = internals->vlan_strip;
+	pcap_q->rx_scatter = rx_scatter;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 	pcap_q->timestamp_offloading = internals->timestamp_offloading;
 
@@ -1112,6 +1149,12 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 		pcap_t **pcap;
 		bool save_vlan_strip;
 
+		if (rx_scatter) {
+			PMD_LOG(ERR,
+				"Rx scatter is not supported with infinite_rx mode");
+			return -EINVAL;
+		}
+
 		pp = rte_eth_devices[pcap_q->port_id].process_private;
 		pcap = &pp->rx_pcap[pcap_q->queue_id];
 
-- 
2.53.0

[PATCH v21 23/25] net/pcap: add link status change support for iface mode

[Stephen Hemminger]

Add LSC interrupt support for pass-through (iface=) mode so
applications can receive link state change notifications via
the standard ethdev callback mechanism.

Uses alarm-based polling to periodically check the underlying
interface state via osdep_iface_link_get(). The LSC flag is
advertised only for iface mode devices, and polling is gated
on the application enabling intr_conf.lsc in port configuration.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/features/pcap.ini      |  1 +
 doc/guides/nics/pcap.rst               |  5 +++
 doc/guides/rel_notes/release_26_03.rst |  1 +
 drivers/net/pcap/pcap_ethdev.c         | 45 ++++++++++++++++++++++++++
 4 files changed, 52 insertions(+)

diff --git a/doc/guides/nics/features/pcap.ini b/doc/guides/nics/features/pcap.ini
index 9f234aa7b9..38dd298603 100644
--- a/doc/guides/nics/features/pcap.ini
+++ b/doc/guides/nics/features/pcap.ini
@@ -5,6 +5,7 @@
 ;
 [Features]
 Link status          = Y
+Link status event    = Y
 Queue start/stop     = Y
 Timestamp offload    = P
 Basic stats          = Y
diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 2754e205c7..72f2250790 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -278,3 +278,8 @@ Features and Limitations
 
 *  The PMD will insert the pcap header packet timestamp with nanoseconds resolution and
    UNIX origin, i.e. time since 1-JAN-1970 UTC, if ``RTE_ETH_RX_OFFLOAD_TIMESTAMP`` is enabled.
+
+*  In ``iface`` mode, the PMD supports link status change (LSC) notifications.
+   When the application enables ``intr_conf.lsc`` in the port configuration,
+   the driver polls the underlying network interface once per second and generates an
+   ``RTE_ETH_EVENT_INTR_LSC`` callback when the link state changes.
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 869084d4cd..feb080aa3f 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -142,6 +142,7 @@ New Features
   * Added support for reporting link state in ``iface`` mode.
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
+  * Added support for Link State interrupt in ``iface`` mode.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index 9b1fbdba3d..aca9ff189c 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -17,6 +17,7 @@
 
 #include <pcap.h>
 
+#include <rte_alarm.h>
 #include <rte_cycles.h>
 #include <rte_ring.h>
 #include <rte_ethdev.h>
@@ -48,6 +49,8 @@
 /* This is defined in libpcap but not exposed in headers */
 #define ETH_PCAP_MAXIMUM_SNAPLEN      262144
 
+#define ETH_PCAP_LSC_POLL_INTERVAL_US (1000 * 1000) /* 1 second */
+
 #define ETH_PCAP_ARG_MAXLEN	64
 
 #define RTE_PMD_PCAP_MAX_QUEUES 16
@@ -115,6 +118,7 @@ struct pmd_internals {
 	bool vlan_strip;
 	bool rx_scatter;
 	bool timestamp_offloading;
+	bool lsc_active;
 };
 
 struct pmd_process_private {
@@ -163,6 +167,9 @@ static const char *valid_arguments[] = {
 
 RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE);
 
+/* Forward declarations */
+static int eth_link_update(struct rte_eth_dev *dev, int wait_to_complete);
+
 static struct queue_missed_stat*
 queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid)
 {
@@ -763,6 +770,28 @@ count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
 	return pcap_pkt_count;
 }
 
+/*
+ * Periodic alarm to poll link state.
+ * Enabled when link state interrupt is enabled in single_iface mode.
+ */
+static void
+eth_pcap_lsc_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link old_link, new_link;
+
+	rte_eth_linkstatus_get(dev, &old_link);
+	eth_link_update(dev, 0);
+	rte_eth_linkstatus_get(dev, &new_link);
+
+	if (old_link.link_status != new_link.link_status)
+		rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+
+	if (internals->lsc_active)
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US, eth_pcap_lsc_alarm, dev);
+}
+
 static int
 set_iface_direction(const char *iface, pcap_t *pcap,
 		pcap_direction_t direction)
@@ -845,6 +874,13 @@ eth_dev_start(struct rte_eth_dev *dev)
 
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
+	/* Start LSC polling for iface mode if application requested it */
+	if (internals->single_iface && dev->data->dev_conf.intr_conf.lsc) {
+		internals->lsc_active = true;
+		rte_eal_alarm_set(ETH_PCAP_LSC_POLL_INTERVAL_US,
+				  eth_pcap_lsc_alarm, dev);
+	}
+
 	return 0;
 }
 
@@ -862,6 +898,12 @@ eth_dev_stop(struct rte_eth_dev *dev)
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
+		/* Cancel LSC polling before closing pcap handles */
+		if (internals->lsc_active) {
+			internals->lsc_active = false;
+			rte_eal_alarm_cancel(eth_pcap_lsc_alarm, dev);
+		}
+
 		queue_missed_stat_on_stop_update(dev, 0);
 		if (pp->tx_pcap[0] != NULL) {
 			pcap_close(pp->tx_pcap[0]);
@@ -1669,6 +1711,9 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 		internals->if_index =
 			osdep_iface_index_get(rx_queues->queue[0].name);
 
+		/* Enable LSC interrupt support for iface mode */
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 		/* phy_mac arg is applied only if "iface" devarg is provided */
 		if (rx_queues->phy_mac) {
 			if (eth_pcap_update_mac(rx_queues->queue[0].name,
-- 
2.53.0

[PATCH v21 24/25] net/pcap: add EOF notification via link status change

[Stephen Hemminger]

Add an "eof" devarg for rx_pcap mode that signals end-of-file by
setting link down and generating an LSC event. This allows
applications to detect when a pcap file has been fully consumed
using the standard ethdev callback mechanism.

The eof and infinite_rx options are mutually exclusive. On device
restart, the EOF state is reset so the file can be replayed.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 doc/guides/nics/pcap.rst               | 12 ++++
 doc/guides/rel_notes/release_26_03.rst |  2 +
 drivers/net/pcap/pcap_ethdev.c         | 80 +++++++++++++++++++++++++-
 3 files changed, 91 insertions(+), 3 deletions(-)

diff --git a/doc/guides/nics/pcap.rst b/doc/guides/nics/pcap.rst
index 72f2250790..18a9a04652 100644
--- a/doc/guides/nics/pcap.rst
+++ b/doc/guides/nics/pcap.rst
@@ -161,6 +161,18 @@ Runtime Config Options
   so all queues on a device will either have this enabled or disabled.
   This option should only be provided once per device.
 
+* Signal end-of-file via link status change
+
+  In case ``rx_pcap=`` configuration is set, the user may want to be notified when
+  all packets in the pcap file have been read.  This can be done with the ``eof``
+  devarg, for example::
+
+     --vdev 'net_pcap0,rx_pcap=file_rx.pcap,eof=1'
+
+  When enabled, the driver sets link down and generates an LSC event at end of file.
+  If the device is stopped and restarted, the EOF state is reset.
+  This option cannot be combined with ``infinite_rx``.
+
 * Drop all packets on transmit
 
   To drop all packets on transmit for a device,
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index feb080aa3f..6752cf599a 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -143,6 +143,8 @@ New Features
   * Receive timestamps support nanosecond precision.
   * Added ``snaplen`` devarg to configure packet capture snapshot length.
   * Added support for Link State interrupt in ``iface`` mode.
+  * Added ``eof`` devarg to use link state to signal end of receive
+    file input.
 
 
 Removed Items
diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c
index aca9ff189c..a9b0ed2f60 100644
--- a/drivers/net/pcap/pcap_ethdev.c
+++ b/drivers/net/pcap/pcap_ethdev.c
@@ -42,6 +42,7 @@
 #define ETH_PCAP_IFACE_ARG    "iface"
 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
+#define ETH_PCAP_EOF_ARG          "eof"
 #define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen"
 
 #define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535
@@ -115,6 +116,8 @@ struct pmd_internals {
 	bool single_iface;
 	bool phy_mac;
 	bool infinite_rx;
+	bool eof;
+	RTE_ATOMIC(bool) eof_signaled;
 	bool vlan_strip;
 	bool rx_scatter;
 	bool timestamp_offloading;
@@ -150,6 +153,7 @@ struct pmd_devargs_all {
 	bool is_rx_pcap;
 	bool is_rx_iface;
 	bool infinite_rx;
+	bool eof;
 };
 
 static const char *valid_arguments[] = {
@@ -161,6 +165,7 @@ static const char *valid_arguments[] = {
 	ETH_PCAP_IFACE_ARG,
 	ETH_PCAP_PHY_MAC_ARG,
 	ETH_PCAP_INFINITE_RX_ARG,
+	ETH_PCAP_EOF_ARG,
 	ETH_PCAP_SNAPSHOT_LEN_ARG,
 	NULL
 };
@@ -308,15 +313,33 @@ eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 	return i;
 }
 
+/*
+ * Deferred EOF alarm callback.
+ *
+ * Scheduled from the RX burst path when end-of-file is reached,
+ * so that rte_eth_dev_callback_process() runs outside the datapath.
+ * This avoids holding any locks that the application callback
+ * might also need, preventing potential deadlocks.
+ */
+static void
+eth_pcap_eof_alarm(void *arg)
+{
+	struct rte_eth_dev *dev = arg;
+
+	rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
+}
+
 static uint16_t
 eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
+	struct pcap_rx_queue *pcap_q = queue;
+	struct rte_eth_dev *dev = &rte_eth_devices[pcap_q->port_id];
+	struct pmd_internals *internals = dev->data->dev_private;
 	unsigned int i;
 	struct pcap_pkthdr *header;
 	struct pmd_process_private *pp;
 	const u_char *packet;
 	struct rte_mbuf *mbuf;
-	struct pcap_rx_queue *pcap_q = queue;
 	uint16_t num_rx = 0;
 	uint32_t rx_bytes = 0;
 	pcap_t *pcap;
@@ -337,6 +360,23 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 			if (ret == PCAP_ERROR)
 				pcap_q->rx_stat.err_pkts++;
 
+			/*
+			 * EOF: if eof mode is enabled, set link down and
+			 * defer notification via alarm to avoid calling
+			 * rte_eth_dev_callback_process() from the datapath.
+			 */
+			else if (ret == PCAP_ERROR_BREAK) {
+				bool expected = false;
+
+				if (internals->eof &&
+				    rte_atomic_compare_exchange_strong_explicit(
+					    &internals->eof_signaled, &expected, true,
+					    rte_memory_order_relaxed, rte_memory_order_relaxed)) {
+					eth_link_update(dev, 0);
+					rte_eal_alarm_set(1, eth_pcap_eof_alarm, dev);
+				}
+			}
+
 			break;
 		}
 
@@ -872,6 +912,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 	for (i = 0; i < dev->data->nb_tx_queues; i++)
 		dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
 
+	rte_atomic_store_explicit(&internals->eof_signaled, false, rte_memory_order_relaxed);
 	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
 	/* Start LSC polling for iface mode if application requested it */
@@ -895,6 +936,7 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	unsigned int i;
 	struct pmd_internals *internals = dev->data->dev_private;
 	struct pmd_process_private *pp = dev->process_private;
+	bool expected;
 
 	/* Special iface case. Single pcap is open and shared between tx/rx. */
 	if (internals->single_iface) {
@@ -934,6 +976,13 @@ eth_dev_stop(struct rte_eth_dev *dev)
 	}
 
 status_down:
+	/* Cancel any pending EOF alarm */
+	expected = true;
+	if (rte_atomic_compare_exchange_strong_explicit(
+		    &internals->eof_signaled, &expected, false,
+		    rte_memory_order_relaxed, rte_memory_order_relaxed))
+		rte_eal_alarm_cancel(eth_pcap_eof_alarm, dev);
+
 	for (i = 0; i < dev->data->nb_rx_queues; i++)
 		dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
 
@@ -1130,9 +1179,10 @@ eth_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 	if (internals->single_iface) {
 		link.link_status = (osdep_iface_link_status(internals->rx_queue[0].name) > 0) ?
 			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+	} else if (rte_atomic_load_explicit(&internals->eof_signaled, rte_memory_order_relaxed)) {
+		link.link_status = RTE_ETH_LINK_DOWN;
 	} else {
-		link.link_status = dev->data->dev_started ?
-			RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
+		link.link_status = dev->data->dev_started ? RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
 	}
 
 	return rte_eth_linkstatus_set(dev, &link);
@@ -1723,8 +1773,13 @@ eth_from_pcaps(struct rte_vdev_device *vdev,
 	}
 
 	internals->infinite_rx = infinite_rx;
+	internals->eof = devargs_all->eof;
 	internals->snapshot_len = devargs_all->snapshot_len;
 
+	/* Enable LSC for eof mode (already set above for single_iface) */
+	if (internals->eof)
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
+
 	/* Assign rx ops. */
 	if (infinite_rx)
 		eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
@@ -1913,6 +1968,24 @@ pmd_pcap_probe(struct rte_vdev_device *dev)
 					"for %s", name);
 		}
 
+		/*
+		 * Check whether to signal EOF via link status change.
+		 */
+		if (rte_kvargs_count(kvlist, ETH_PCAP_EOF_ARG) == 1) {
+			ret = rte_kvargs_process(kvlist, ETH_PCAP_EOF_ARG,
+						 &process_bool_flag,
+						 &devargs_all.eof);
+			if (ret < 0)
+				goto free_kvlist;
+		}
+
+		if (devargs_all.infinite_rx && devargs_all.eof) {
+			PMD_LOG(ERR, "Cannot use both infinite_rx and eof for %s",
+				name);
+			ret = -EINVAL;
+			goto free_kvlist;
+		}
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
 				&open_rx_pcap, &pcaps);
 	} else if (devargs_all.is_rx_iface) {
@@ -2051,4 +2124,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
 	ETH_PCAP_IFACE_ARG "=<ifc> "
 	ETH_PCAP_PHY_MAC_ARG "=<0|1> "
 	ETH_PCAP_INFINITE_RX_ARG "=<0|1> "
+	ETH_PCAP_EOF_ARG "=<0|1> "
 	ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>");
-- 
2.53.0

[PATCH v21 25/25] test: add comprehensive test suite for pcap PMD

[Stephen Hemminger]

Add unit tests for the pcap PMD covering file and interface modes.

Tests include:
  - basic TX to file and RX from file
  - varied packet sizes and jumbo frames
  - infinite RX mode
  - TX drop mode
  - statistics (ipackets, opackets, ibytes, obytes)
  - interface (iface=) pass-through mode
  - asymmetric rx_iface/tx_iface mode
  - rx_iface_in direction filtering
  - link status reporting for file and iface modes
  - link status change (LSC) with interface toggle
  - EOF notification via LSC
  - RX timestamps and timestamp with infinite RX
  - multiple TX/RX queues
  - VLAN strip, insert, and runtime offload configuration
  - snapshot length (snaplen) and truncation
  - scatter RX and oversized packet drop
  - per-queue start/stop
  - imissed statistic (pcap_stats kernel drops)

Cross-platform helpers handle temp file creation, interface
discovery, and VLAN packet generation.

The LSC link toggle test requires a pre-created dummy interface
(Linux: dummy0, FreeBSD: disc0) and is skipped if unavailable.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
 app/test/meson.build                   |    2 +
 app/test/test_pmd_pcap.c               | 4122 ++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_03.rst |    1 +
 3 files changed, 4125 insertions(+)
 create mode 100644 app/test/test_pmd_pcap.c

diff --git a/app/test/meson.build b/app/test/meson.build
index 7d458f9c07..7a4daeb0c7 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ source_file_deps = {
     'test_per_lcore.c': [],
     'test_pflock.c': [],
     'test_pie.c': ['sched'],
+    'test_pmd_pcap.c': ['net_pcap', 'ethdev', 'bus_vdev']  + packet_burst_generator_deps,
     'test_pmd_perf.c': ['ethdev', 'net'] + packet_burst_generator_deps,
     'test_pmd_ring.c': ['net_ring', 'ethdev', 'bus_vdev'],
     'test_pmd_ring_perf.c': ['ethdev', 'net_ring', 'bus_vdev'],
@@ -217,6 +218,7 @@ source_file_deps = {
 source_file_ext_deps = {
     'test_compressdev.c': ['zlib'],
     'test_pcapng.c': ['pcap'],
+    'test_pmd_pcap.c': ['pcap'],
 }
 
 # the NULL ethdev is used by a number of tests, in some cases as an optional dependency.
diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c
new file mode 100644
index 0000000000..1a19ad70c3
--- /dev/null
+++ b/app/test/test_pmd_pcap.c
@@ -0,0 +1,4122 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include "test.h"
+
+#include "packet_burst_generator.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+#include <io.h>
+#include <windows.h>
+#define F_OK 0
+#define usleep(us) Sleep((us) / 1000 ? (us) / 1000 : 1)
+#else
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#endif
+
+#include <pcap/pcap.h>
+
+#include <rte_ethdev.h>
+#include <rte_bus_vdev.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_mempool.h>
+#include <rte_ether.h>
+#include <rte_string_fns.h>
+#include <rte_cycles.h>
+#include <rte_ip.h>
+#include <rte_udp.h>
+
+#define SOCKET0 0
+#define RING_SIZE 256
+#define NB_MBUF 1024
+#define NUM_PACKETS 64
+#define MAX_PKT_BURST 32
+#define PCAP_SNAPLEN 65535
+
+/* Packet sizes to test */
+#define PKT_SIZE_MIN 60
+#define PKT_SIZE_SMALL 128
+#define PKT_SIZE_MEDIUM 512
+#define PKT_SIZE_LARGE 1024
+#define PKT_SIZE_MTU 1500
+#define PKT_SIZE_JUMBO 9000
+
+static struct rte_mempool *mp;
+
+/* Timestamp dynamic field access */
+static int timestamp_dynfield_offset = -1;
+static uint64_t timestamp_rx_dynflag;
+
+/* Temporary file paths shared between tests */
+static char tx_pcap_path[PATH_MAX];	/* test_tx_to_file -> test_rx_from_file */
+static char vlan_rx_pcap_path[PATH_MAX]; /* test_vlan_strip_rx -> test_vlan_no_strip_rx */
+
+/* Constants for multi-queue tests */
+#define MULTI_QUEUE_NUM_QUEUES   4U
+#define MULTI_QUEUE_NUM_PACKETS  100U
+#define MULTI_QUEUE_BURST_SIZE   32U
+
+/* Test VLAN parameters */
+#define TEST_VLAN_ID  100
+#define TEST_VLAN_PCP 3
+
+/* MAC addresses for packet generation */
+static struct rte_ether_addr src_mac;
+static struct rte_ether_addr dst_mac = {
+	.addr_bytes = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
+};
+
+/* Sample Ethernet/IPv4/UDP packet for testing */
+static const uint8_t test_packet[] = {
+	/* Ethernet header */
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* dst MAC (broadcast) */
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55,  /* src MAC */
+	0x08, 0x00,                          /* EtherType: IPv4 */
+	/* IPv4 header */
+	0x45, 0x00, 0x00, 0x2e,              /* ver, ihl, tos, len */
+	0x00, 0x01, 0x00, 0x00,              /* id, flags, frag */
+	0x40, 0x11, 0x00, 0x00,              /* ttl, proto(UDP), csum */
+	0x0a, 0x00, 0x00, 0x01,              /* src: 10.0.0.1 */
+	0x0a, 0x00, 0x00, 0x02,              /* dst: 10.0.0.2 */
+	/* UDP header */
+	0x04, 0xd2, 0x04, 0xd2,              /* sport, dport (1234) */
+	0x00, 0x1a, 0x00, 0x00,              /* len, csum */
+	/* Payload: "Test packet!" */
+	0x54, 0x65, 0x73, 0x74, 0x20, 0x70,
+	0x61, 0x63, 0x6b, 0x65, 0x74, 0x21
+};
+
+/* Helper: Get timestamp from mbuf using dynamic field */
+static inline rte_mbuf_timestamp_t
+mbuf_timestamp_get(const struct rte_mbuf *mbuf)
+{
+	return *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, rte_mbuf_timestamp_t *);
+}
+
+/* Helper: Check if mbuf has valid timestamp */
+static inline int
+mbuf_has_timestamp(const struct rte_mbuf *mbuf)
+{
+	return (mbuf->ol_flags & timestamp_rx_dynflag) != 0;
+}
+
+/* Helper: Initialize timestamp dynamic field access */
+static int
+timestamp_init(void)
+{
+	int offset;
+
+	offset = rte_mbuf_dynfield_lookup(RTE_MBUF_DYNFIELD_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynfield not registered\n");
+		return -1;
+	}
+	timestamp_dynfield_offset = offset;
+
+	offset = rte_mbuf_dynflag_lookup(RTE_MBUF_DYNFLAG_RX_TIMESTAMP_NAME, NULL);
+	if (offset < 0) {
+		printf("Timestamp dynflag not registered\n");
+		return -1;
+	}
+	timestamp_rx_dynflag = RTE_BIT64(offset);
+	return 0;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+
+/*
+ * Helper: Create a unique temporary file path (Windows version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	char temp_dir[MAX_PATH];
+	char temp_file[MAX_PATH];
+	DWORD ret;
+
+	ret = GetTempPathA(sizeof(temp_dir), temp_dir);
+	if (ret == 0 || ret > sizeof(temp_dir))
+		return -1;
+
+	if (GetTempFileNameA(temp_dir, prefix, 0, temp_file) == 0)
+		return -1;
+
+	ret = snprintf(buf, buflen, "%s.pcap", temp_file);
+	if (ret >= buflen) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	if (MoveFileA(temp_file, buf) == 0) {
+		DeleteFileA(temp_file);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (Windows version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		DeleteFileA(path);
+}
+
+#else /* POSIX */
+
+/*
+ * Helper: Create a unique temporary file path (POSIX version)
+ */
+static int
+create_temp_path(char *buf, size_t buflen, const char *prefix)
+{
+	int fd;
+
+	snprintf(buf, buflen, "/tmp/%s_XXXXXX.pcap", prefix);
+	fd = mkstemps(buf, 5);  /* 5 = strlen(".pcap") */
+	if (fd < 0)
+		return -1;
+	close(fd);
+	return 0;
+}
+
+/*
+ * Helper: Remove temporary file (POSIX version)
+ */
+static inline void
+remove_temp_file(const char *path)
+{
+	if (path[0] != '\0')
+		unlink(path);
+}
+
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Helper: Create a pcap file with test packets using libpcap
+ */
+static int
+create_test_pcap(const char *path, unsigned int num_pkts)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		printf("pcap_open_dead failed\n");
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		printf("pcap_dump_open failed: %s\n", pcap_geterr(pd));
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with packets of specified size
+ */
+static int
+create_sized_pcap(const char *path, unsigned int num_pkts, uint16_t pkt_size)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	/* Minimum valid ethernet frame */
+	if (pkt_size < 60)
+		pkt_size = 60;
+
+	pkt_data = calloc(1, pkt_size);
+	if (pkt_data == NULL)
+		return -1;
+
+	/* Build ethernet header */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	/* Build IP header */
+	struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+	uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	/* Build UDP header */
+	struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+	udp_hdr->dgram_cksum = 0;
+
+	/* Fill payload with pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	uint16_t payload_len = udp_len - sizeof(struct rte_udp_hdr);
+	for (uint16_t j = 0; j < payload_len; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_size;
+	hdr.len = pkt_size;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with varied packet sizes
+ */
+static int
+create_varied_pcap(const char *path, unsigned int num_pkts)
+{
+	static const uint16_t sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t *pkt_data;
+	unsigned int i;
+
+	pkt_data = calloc(1, PKT_SIZE_MTU);
+	if (pkt_data == NULL)
+		return -1;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL) {
+		free(pkt_data);
+		return -1;
+	}
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		free(pkt_data);
+		return -1;
+	}
+
+	for (i = 0; i < num_pkts; i++) {
+		uint16_t pkt_size = sizes[i % RTE_DIM(sizes)];
+
+		memset(pkt_data, 0, pkt_size);
+
+		/* Build ethernet header */
+		struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+		rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+		rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+		eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+		/* Build IP header */
+		struct rte_ipv4_hdr *ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
+		uint16_t ip_len = pkt_size - sizeof(struct rte_ether_hdr);
+		ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+		ip_hdr->total_length = rte_cpu_to_be_16(ip_len);
+		ip_hdr->time_to_live = 64;
+		ip_hdr->next_proto_id = IPPROTO_UDP;
+		ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+		ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+		ip_hdr->hdr_checksum = 0;
+		ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+		/* Build UDP header */
+		struct rte_udp_hdr *udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+		uint16_t udp_len = ip_len - sizeof(struct rte_ipv4_hdr);
+		udp_hdr->src_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+		udp_hdr->dgram_len = rte_cpu_to_be_16(udp_len);
+
+		memset(&hdr, 0, sizeof(hdr));
+		hdr.ts.tv_sec = i;
+		hdr.caplen = pkt_size;
+		hdr.len = pkt_size;
+
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	free(pkt_data);
+	return 0;
+}
+
+/*
+ * Helper: Create pcap file with specific timestamps for testing
+ */
+static int
+create_timestamped_pcap(const char *path, unsigned int num_pkts,
+			uint32_t base_sec, uint32_t usec_increment)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	unsigned int i;
+
+	pd = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, PCAP_SNAPLEN,
+						  PCAP_TSTAMP_PRECISION_MICRO);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = sizeof(test_packet);
+	hdr.len = sizeof(test_packet);
+
+	for (i = 0; i < num_pkts; i++) {
+		uint64_t total_usec = (uint64_t)i * usec_increment;
+		hdr.ts.tv_sec = base_sec + total_usec / 1000000;
+		hdr.ts.tv_usec = total_usec % 1000000;
+		pcap_dump((u_char *)dumper, &hdr, test_packet);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Count packets in a pcap file using libpcap
+ */
+static int
+count_pcap_packets(const char *path)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1)
+		count++;
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Get packet sizes from pcap file
+ */
+static int
+get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1 && count < max_pkts) {
+		sizes[count] = hdr->caplen;
+		count++;
+	}
+
+	pcap_close(pd);
+	return count;
+}
+
+/*
+ * Helper: Verify packets in pcap file are truncated correctly
+ * Returns 0 if all packets have caplen == expected_caplen and len == expected_len
+ */
+static int
+verify_pcap_truncation(const char *path, uint32_t expected_caplen,
+		       uint32_t expected_len, unsigned int *pkt_count)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	unsigned int count = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		if (hdr->caplen != expected_caplen || hdr->len != expected_len) {
+			printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n",
+			       count, hdr->caplen, expected_caplen,
+			       hdr->len, expected_len);
+			pcap_close(pd);
+			return -1;
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+	if (pkt_count)
+		*pkt_count = count;
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port with custom config
+ */
+static int
+setup_pcap_port_conf(uint16_t port, const struct rte_eth_conf *conf)
+{
+	int ret;
+
+	ret = rte_eth_dev_configure(port, 1, 1, conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue on port %u: %s",
+		    port, rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port);
+	TEST_ASSERT(ret == 0, "Failed to start port %u: %s",
+		    port, rte_strerror(-ret));
+
+	return 0;
+}
+
+/*
+ * Helper: Configure and start a pcap ethdev port (default: timestamp offload)
+ */
+static int
+setup_pcap_port(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Create a pcap vdev and return its port ID
+ */
+static int
+create_pcap_vdev(const char *name, const char *devargs, uint16_t *port_id)
+{
+	int ret;
+
+	ret = rte_vdev_init(name, devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev %s: %s",
+		    name, rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name(name, port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID for %s", name);
+
+	return 0;
+}
+
+/*
+ * Helper: Cleanup a pcap vdev
+ */
+static void
+cleanup_pcap_vdev(const char *name, uint16_t port_id)
+{
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit(name);
+}
+
+/*
+ * Helper: Create a pcap file with VLAN-tagged packets
+ */
+static int
+create_vlan_tagged_pcap(const char *path, unsigned int num_pkts,
+			uint16_t vlan_id, uint8_t pcp)
+{
+	pcap_t *pd;
+	pcap_dumper_t *dumper;
+	struct pcap_pkthdr hdr;
+	uint8_t pkt_data[128];
+	unsigned int i;
+	size_t pkt_len;
+
+	/* Build VLAN-tagged packet */
+	struct rte_ether_hdr *eth_hdr = (struct rte_ether_hdr *)pkt_data;
+	struct rte_vlan_hdr *vlan_hdr;
+	struct rte_ipv4_hdr *ip_hdr;
+	struct rte_udp_hdr *udp_hdr;
+
+	rte_ether_addr_copy(&src_mac, &eth_hdr->src_addr);
+	rte_ether_addr_copy(&dst_mac, &eth_hdr->dst_addr);
+	eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	vlan_hdr->vlan_tci = rte_cpu_to_be_16((pcp << 13) | vlan_id);
+	vlan_hdr->eth_proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+
+	ip_hdr = (struct rte_ipv4_hdr *)(vlan_hdr + 1);
+	ip_hdr->version_ihl = RTE_IPV4_VHL_DEF;
+	ip_hdr->total_length = rte_cpu_to_be_16(46);  /* 20 IP + 8 UDP + 18 payload */
+	ip_hdr->time_to_live = 64;
+	ip_hdr->next_proto_id = IPPROTO_UDP;
+	ip_hdr->src_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 1));
+	ip_hdr->dst_addr = rte_cpu_to_be_32(IPV4_ADDR(10, 0, 0, 2));
+	ip_hdr->hdr_checksum = 0;
+	ip_hdr->hdr_checksum = rte_ipv4_cksum(ip_hdr);
+
+	udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
+	udp_hdr->src_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dst_port = rte_cpu_to_be_16(1234);
+	udp_hdr->dgram_len = rte_cpu_to_be_16(26);  /* 8 UDP + 18 payload */
+	udp_hdr->dgram_cksum = 0;
+
+	/* Add payload pattern */
+	uint8_t *payload = (uint8_t *)(udp_hdr + 1);
+	for (int j = 0; j < 18; j++)
+		payload[j] = (uint8_t)(j & 0xFF);
+
+	pkt_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		  sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	pd = pcap_open_dead(DLT_EN10MB, PCAP_SNAPLEN);
+	if (pd == NULL)
+		return -1;
+
+	dumper = pcap_dump_open(pd, path);
+	if (dumper == NULL) {
+		pcap_close(pd);
+		return -1;
+	}
+
+	memset(&hdr, 0, sizeof(hdr));
+	hdr.caplen = pkt_len;
+	hdr.len = pkt_len;
+
+	for (i = 0; i < num_pkts; i++) {
+		hdr.ts.tv_sec = i;
+		hdr.ts.tv_usec = 0;
+		/* Vary sequence byte in payload */
+		payload[0] = (uint8_t)(i & 0xFF);
+		pcap_dump((u_char *)dumper, &hdr, pkt_data);
+	}
+
+	pcap_dump_close(dumper);
+	pcap_close(pd);
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has VLAN tag with expected values
+ */
+static int
+verify_vlan_tag(struct rte_mbuf *mbuf, uint16_t expected_vlan_id, uint8_t expected_pcp)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_vlan_hdr *vlan_hdr;
+	uint16_t tci;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	/* Check for VLAN ethertype */
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) != RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Expected VLAN ethertype 0x%04x, got 0x%04x\n",
+		       RTE_ETHER_TYPE_VLAN, rte_be_to_cpu_16(eth_hdr->ether_type));
+		return -1;
+	}
+
+	vlan_hdr = (struct rte_vlan_hdr *)(eth_hdr + 1);
+	tci = rte_be_to_cpu_16(vlan_hdr->vlan_tci);
+
+	if ((tci & 0x0FFF) != expected_vlan_id) {
+		printf("  Error: Expected VLAN ID %u, got %u\n",
+		       expected_vlan_id, tci & 0x0FFF);
+		return -1;
+	}
+
+	if ((tci >> 13) != expected_pcp) {
+		printf("  Error: Expected PCP %u, got %u\n",
+		       expected_pcp, tci >> 13);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Verify packet has NO VLAN tag (plain ethernet)
+ */
+static int
+verify_no_vlan_tag(struct rte_mbuf *mbuf)
+{
+	struct rte_ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_be_to_cpu_16(eth_hdr->ether_type) == RTE_ETHER_TYPE_VLAN) {
+		printf("  Error: Packet still has VLAN tag (ethertype 0x8100)\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Count packets in pcap and verify VLAN tags
+ */
+static int
+count_vlan_packets_in_pcap(const char *path, uint16_t expected_vlan_id,
+			   int expect_vlan_tag)
+{
+	pcap_t *pd;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	struct pcap_pkthdr *hdr;
+	const u_char *data;
+	int count = 0;
+	int errors = 0;
+
+	pd = pcap_open_offline(path, errbuf);
+	if (pd == NULL)
+		return -1;
+
+	while (pcap_next_ex(pd, &hdr, &data) == 1) {
+		const struct rte_ether_hdr *eth = (const struct rte_ether_hdr *)data;
+		uint16_t etype = rte_be_to_cpu_16(eth->ether_type);
+
+		if (expect_vlan_tag) {
+			if (etype != RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: expected VLAN tag, got ethertype 0x%04x\n",
+				       count, etype);
+				errors++;
+			} else {
+				const struct rte_vlan_hdr *vlan =
+					(const struct rte_vlan_hdr *)(eth + 1);
+				uint16_t tci = rte_be_to_cpu_16(vlan->vlan_tci);
+				if ((tci & 0x0FFF) != expected_vlan_id) {
+					printf("  Packet %d: VLAN ID %u != expected %u\n",
+					       count, tci & 0x0FFF, expected_vlan_id);
+					errors++;
+				}
+			}
+		} else {
+			if (etype == RTE_ETHER_TYPE_VLAN) {
+				printf("  Packet %d: unexpected VLAN tag present\n", count);
+				errors++;
+			}
+		}
+		count++;
+	}
+
+	pcap_close(pd);
+
+	if (errors > 0)
+		return -errors;
+
+	return count;
+}
+
+/*
+ * Helper: Configure port with VLAN strip offload enabled
+ */
+static int
+setup_pcap_port_vlan_strip(uint16_t port)
+{
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+
+	return setup_pcap_port_conf(port, &port_conf);
+}
+
+/*
+ * Helper: Allocate mbufs with VLAN TX offload info set
+ */
+static int
+alloc_vlan_tx_mbufs(struct rte_mbuf **mbufs, unsigned int count,
+		    uint16_t vlan_id, uint8_t pcp)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		/* Copy untagged test packet */
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+
+		/* Set VLAN TX offload flags */
+		mbufs[i]->ol_flags |= RTE_MBUF_F_TX_VLAN;
+		mbufs[i]->vlan_tci = (pcp << 13) | vlan_id;
+	}
+
+	return 0;
+}
+
+/*
+ * Helper: Generate test packets using packet_burst_generator
+ */
+static int
+generate_test_packets(struct rte_mempool *pool, struct rte_mbuf **mbufs,
+		      unsigned int count, uint16_t pkt_len)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t ip_pkt_data_len;
+	int nb_pkt;
+
+	/* Initialize ethernet header */
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac,
+			      RTE_ETHER_TYPE_IPV4, 0, 0);
+
+	/* Calculate IP payload length (total - eth - ip headers) */
+	ip_pkt_data_len = pkt_len - sizeof(struct rte_ether_hdr) -
+			  sizeof(struct rte_ipv4_hdr);
+
+	/* Initialize UDP header */
+	initialize_udp_header(&udp_hdr, 1234, 1234,
+			      ip_pkt_data_len - sizeof(struct rte_udp_hdr));
+
+	/* Initialize IPv4 header */
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(10, 0, 0, 1),
+			       IPV4_ADDR(10, 0, 0, 2), ip_pkt_data_len);
+
+	/* Generate packet burst */
+	nb_pkt = generate_packet_burst(pool, mbufs, &eth_hdr, 0,
+				       &ip_hdr, 1, &udp_hdr,
+				       count, pkt_len, 1);
+
+	return nb_pkt;
+}
+
+/*
+ * Helper: Allocate mbufs and fill with test packet data (legacy method)
+ */
+static int
+alloc_test_mbufs(struct rte_mbuf **mbufs, unsigned int count)
+{
+	unsigned int i;
+	int ret;
+
+	ret = rte_pktmbuf_alloc_bulk(mp, mbufs, count);
+	if (ret != 0)
+		return -1;
+
+	for (i = 0; i < count; i++) {
+		memcpy(rte_pktmbuf_mtod(mbufs[i], void *),
+		       test_packet, sizeof(test_packet));
+		mbufs[i]->data_len = sizeof(test_packet);
+		mbufs[i]->pkt_len = sizeof(test_packet);
+	}
+	return 0;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf for jumbo frames
+ * Returns the head mbuf with chained segments, or NULL on failure
+ */
+static struct rte_mbuf *
+alloc_jumbo_mbuf(uint32_t pkt_len, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t seg_size;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		seg_size = RTE_MIN(remaining, rte_pktmbuf_tailroom(seg));
+		seg->data_len = seg_size;
+
+		/* Fill segment with pattern */
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, seg_size);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= seg_size;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Allocate a multi-segment mbuf with controlled segment size.
+ *
+ * Unlike alloc_jumbo_mbuf which fills segments to tailroom capacity,
+ * this limits each segment to seg_size bytes, guaranteeing that the
+ * resulting mbuf chain has multiple segments even for moderate pkt_len.
+ */
+static struct rte_mbuf *
+alloc_multiseg_mbuf(uint32_t pkt_len, uint16_t seg_size, uint8_t fill_byte)
+{
+	struct rte_mbuf *head = NULL;
+	struct rte_mbuf **prev = &head;
+	uint32_t remaining = pkt_len;
+	uint16_t nb_segs = 0;
+
+	while (remaining > 0) {
+		struct rte_mbuf *seg = rte_pktmbuf_alloc(mp);
+		uint16_t this_len;
+
+		if (seg == NULL) {
+			rte_pktmbuf_free(head);
+			return NULL;
+		}
+
+		this_len = RTE_MIN(remaining, seg_size);
+		this_len = RTE_MIN(this_len, rte_pktmbuf_tailroom(seg));
+		seg->data_len = this_len;
+
+		memset(rte_pktmbuf_mtod(seg, void *), fill_byte, this_len);
+
+		*prev = seg;
+		prev = &seg->next;
+		remaining -= this_len;
+		nb_segs++;
+	}
+
+	if (head != NULL) {
+		head->pkt_len = pkt_len;
+		head->nb_segs = nb_segs;
+	}
+
+	return head;
+}
+
+/*
+ * Helper: Receive packets from port (no retry needed for file-based RX)
+ */
+static int
+receive_packets(uint16_t port, struct rte_mbuf **mbufs,
+		unsigned int max_pkts, unsigned int *received)
+{
+	unsigned int total = 0;
+
+	while (total < max_pkts) {
+		uint16_t nb_rx = rte_eth_rx_burst(port, 0, &mbufs[total], max_pkts - total);
+		if (nb_rx == 0)
+			break;
+		total += nb_rx;
+	}
+	*received = total;
+	return 0;
+}
+
+/*
+ * Helper: Verify mbuf contains expected test packet
+ */
+static int
+verify_packet(struct rte_mbuf *mbuf)
+{
+	TEST_ASSERT_EQUAL(rte_pktmbuf_data_len(mbuf), sizeof(test_packet),
+			  "Packet length mismatch");
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(rte_pktmbuf_mtod(mbuf, void *),
+				      test_packet, sizeof(test_packet),
+				      "Packet data mismatch");
+	return 0;
+}
+
+/*
+ * Helper: Check if interface supports Ethernet (DLT_EN10MB)
+ *
+ * The pcap PMD only works with Ethernet interfaces. On FreeBSD/macOS,
+ * the loopback interface uses DLT_NULL which is incompatible.
+ */
+static int
+iface_is_ethernet(const char *name)
+{
+	char errbuf[PCAP_ERRBUF_SIZE];
+	pcap_t *pcap;
+	int datalink;
+
+	pcap = pcap_open_live(name, 256, 0, 0, errbuf);
+	if (pcap == NULL)
+		return 0;
+
+	datalink = pcap_datalink(pcap);
+	pcap_close(pcap);
+
+	return datalink == DLT_EN10MB;
+}
+
+/*
+ * Helper: Find a usable test interface using pcap_findalldevs
+ *
+ * Uses libpcap's portable interface enumeration which works on
+ * Linux, FreeBSD, macOS, and Windows.
+ *
+ * Only selects interfaces that support Ethernet link type (DLT_EN10MB).
+ * This excludes loopback on FreeBSD/macOS which uses DLT_NULL.
+ *
+ * Preference order:
+ * 1. Loopback interface (if Ethernet - Linux only)
+ * 2. Any interface that is UP and RUNNING
+ * 3. Any available Ethernet interface
+ *
+ * Returns static buffer with interface name, or NULL if none found.
+ */
+static const char *
+find_test_iface(void)
+{
+	static char iface_name[256];
+	pcap_if_t *alldevs, *dev;
+	char errbuf[PCAP_ERRBUF_SIZE];
+	const char *loopback = NULL;
+	const char *any_up = NULL;
+	const char *any_ether = NULL;
+
+	if (pcap_findalldevs(&alldevs, errbuf) != 0) {
+		printf("pcap_findalldevs failed: %s\n", errbuf);
+		return NULL;
+	}
+
+	if (alldevs == NULL) {
+		printf("No interfaces found\n");
+		return NULL;
+	}
+
+	for (dev = alldevs; dev != NULL; dev = dev->next) {
+		if (dev->name == NULL)
+			continue;
+
+		/* Only consider Ethernet interfaces */
+		if (!iface_is_ethernet(dev->name))
+			continue;
+
+		if (any_ether == NULL)
+			any_ether = dev->name;
+
+		/* Prefer loopback for safety (Linux lo supports DLT_EN10MB) */
+		if ((dev->flags & PCAP_IF_LOOPBACK) && loopback == NULL) {
+			loopback = dev->name;
+			continue;
+		}
+
+#ifdef PCAP_IF_UP
+		if ((dev->flags & PCAP_IF_UP) &&
+		    (dev->flags & PCAP_IF_RUNNING) &&
+		    any_up == NULL)
+			any_up = dev->name;
+#else
+		if (any_up == NULL)
+			any_up = dev->name;
+#endif
+	}
+
+	/* Select best available interface */
+	const char *selected = NULL;
+	if (loopback != NULL)
+		selected = loopback;
+	else if (any_up != NULL)
+		selected = any_up;
+	else if (any_ether != NULL)
+		selected = any_ether;
+
+	if (selected != NULL)
+		strlcpy(iface_name, selected, sizeof(iface_name));
+
+	pcap_freealldevs(alldevs);
+	return selected ? iface_name : NULL;
+}
+
+/*
+ * Test: Transmit packets to pcap file
+ */
+static int
+test_tx_to_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing TX to pcap file\n");
+
+	TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+				     "pcap_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_tx", port_id);
+
+	pkt_count = count_pcap_packets(tx_pcap_path);
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("TX to file PASSED: %d packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Receive packets from pcap file
+ * Uses output from TX test as input
+ */
+static int
+test_rx_from_file(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX from pcap file\n");
+
+	/* Create input file if TX test didn't run */
+	if (access(tx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(tx_pcap_path, sizeof(tx_pcap_path),
+					     "pcap_rx_input") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(tx_pcap_path, NUM_PACKETS) == 0,
+			    "Failed to create input pcap");
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	for (i = 0; i < received; i++) {
+		TEST_ASSERT(verify_packet(mbufs[i]) == 0,
+			    "Packet %u verification failed", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	cleanup_pcap_vdev("net_pcap_rx", port_id);
+
+	printf("RX from file PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX with varied packet sizes using packet_burst_generator
+ */
+static int
+test_tx_varied_sizes(void)
+{
+	static const uint16_t test_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, 200
+	};
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int i;
+	int ret;
+
+	printf("Testing TX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_tx_varied") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_tx_var", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	unsigned int total_tx = 0;
+
+	for (i = 0; i < RTE_DIM(test_sizes); i++) {
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int nb_pkt, nb_tx;
+
+		nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+					       test_sizes[i]);
+		TEST_ASSERT(nb_pkt > 0,
+			    "Failed to generate packets of size %u",
+			    test_sizes[i]);
+
+		nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+		if (nb_tx < nb_pkt)
+			rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+		printf("  Size %u: generated %d, transmitted %d\n",
+		       test_sizes[i], nb_pkt, nb_tx);
+		TEST_ASSERT(nb_tx > 0, "Failed to TX packets of size %u",
+			    test_sizes[i]);
+		total_tx += nb_tx;
+	}
+
+	cleanup_pcap_vdev("net_pcap_tx_var", port_id);
+
+	/* Read back pcap file and verify packet sizes match what was sent */
+	{
+		uint16_t sizes[MAX_PKT_BURST * RTE_DIM(test_sizes)];
+		int pkt_count;
+		unsigned int idx = 0;
+
+		pkt_count = get_pcap_packet_sizes(tx_path, sizes,
+						  RTE_DIM(sizes));
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, total_tx,
+				  "Pcap has %d packets, expected %u",
+				  pkt_count, total_tx);
+
+		for (i = 0; i < RTE_DIM(test_sizes); i++) {
+			unsigned int j;
+			/* Each size produced MAX_PKT_BURST (or fewer) packets */
+			for (j = 0; j < MAX_PKT_BURST && idx < (unsigned int)pkt_count; j++, idx++) {
+				TEST_ASSERT_EQUAL(sizes[idx], test_sizes[i],
+						  "Packet %u: size %u, expected %u",
+						  idx, sizes[idx], test_sizes[i]);
+			}
+		}
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("TX varied sizes PASSED: %u packets verified\n", total_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX with varied packet sizes
+ */
+static int
+test_rx_varied_sizes(void)
+{
+	static const uint16_t expected_sizes[] = {
+		PKT_SIZE_MIN, PKT_SIZE_SMALL, PKT_SIZE_MEDIUM,
+		PKT_SIZE_LARGE, PKT_SIZE_MTU
+	};
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	uint16_t rx_sizes[NUM_PACKETS];
+	char varied_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+
+	printf("Testing RX with varied packet sizes\n");
+
+	TEST_ASSERT(create_temp_path(varied_pcap_path, sizeof(varied_pcap_path),
+				     "pcap_varied") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_varied_pcap(varied_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create varied pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", varied_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_var", devargs, &port_id) == 0,
+		    "Failed to create varied RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup varied RX port");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Verify packet sizes match expected pattern */
+	for (i = 0; i < received; i++) {
+		uint16_t expected = expected_sizes[i % RTE_DIM(expected_sizes)];
+		rx_sizes[i] = rte_pktmbuf_pkt_len(mbufs[i]);
+		TEST_ASSERT_EQUAL(rx_sizes[i], expected,
+				  "Packet %u: size %u, expected %u",
+				  i, rx_sizes[i], expected);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_var", port_id);
+	remove_temp_file(varied_pcap_path);
+
+	printf("RX varied sizes PASSED: %u packets with correct sizes\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Infinite RX mode - loops through pcap file continuously
+ */
+static int
+test_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char infinite_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	int iter, attempts;
+	int ret;
+
+	printf("Testing infinite RX mode\n");
+
+	TEST_ASSERT(create_temp_path(infinite_pcap_path, sizeof(infinite_pcap_path),
+				     "pcap_inf") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(infinite_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", infinite_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_inf", devargs, &port_id) == 0,
+		    "Failed to create infinite RX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup infinite RX port");
+
+	/* Read more packets than file contains to verify looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2;
+		     attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+							  MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_inf", port_id);
+	remove_temp_file(infinite_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d",
+		    total_rx, NUM_PACKETS * 2);
+
+	printf("Infinite RX PASSED: %u packets (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX drop mode - packets dropped when no tx_pcap specified
+ */
+static int
+test_tx_drop(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	int nb_tx;
+	int ret;
+
+	printf("Testing TX drop mode\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_drop") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	/* Only rx_pcap - TX should silently drop */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_drop", devargs, &port_id) == 0,
+		    "Failed to create drop vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup drop port");
+	TEST_ASSERT(alloc_test_mbufs(mbufs, NUM_PACKETS) == 0,
+		    "Failed to allocate mbufs");
+
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+
+	/* Packets should be accepted even in drop mode */
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "Drop mode TX: %d/%d accepted", nb_tx, NUM_PACKETS);
+
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	cleanup_pcap_vdev("net_pcap_drop", port_id);
+	remove_temp_file(rx_pcap_path);
+
+	printf("TX drop PASSED: %d packets dropped, opackets=%" PRIu64"\n",
+	       nb_tx, stats.opackets);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics accuracy and reset
+ */
+static int
+test_stats(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_stats stats;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	char stats_tx_path[PATH_MAX];
+	uint16_t port_id;
+	unsigned int received;
+	int nb_tx;
+	int ret;
+
+	printf("Testing statistics accuracy\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_stats_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(stats_tx_path, sizeof(stats_tx_path), "pcap_stats_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create input pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, stats_tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_stats", devargs, &port_id) == 0,
+		    "Failed to create stats vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup stats port");
+
+	/* Verify stats start at zero */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0 &&
+		    stats.ibytes == 0 && stats.obytes == 0,
+		    "Initial stats not zero");
+
+	/* RX and verify stats */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after RX");
+	TEST_ASSERT_EQUAL(stats.ipackets, received,
+			  "RX stats: ipackets=%"PRIu64", received=%u",
+			  stats.ipackets, received);
+	TEST_ASSERT(stats.ibytes > 0,
+		    "RX stats: ibytes should be > 0");
+	TEST_ASSERT_EQUAL(stats.ibytes, (uint64_t)received * sizeof(test_packet),
+			  "RX stats: ibytes=%"PRIu64", expected=%"PRIu64,
+			  stats.ibytes,
+			  (uint64_t)received * sizeof(test_packet));
+
+	/* TX and verify stats */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, received);
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after TX");
+	TEST_ASSERT_EQUAL(stats.opackets, (uint64_t)nb_tx,
+			  "TX stats: opackets=%"PRIu64", sent=%u",
+			  stats.opackets, nb_tx);
+	TEST_ASSERT(stats.obytes > 0,
+		    "TX stats: obytes should be > 0");
+	TEST_ASSERT_EQUAL(stats.obytes, (uint64_t)nb_tx * sizeof(test_packet),
+			  "TX stats: obytes=%"PRIu64", expected=%"PRIu64,
+			  stats.obytes,
+			  (uint64_t)nb_tx * sizeof(test_packet));
+
+	/* Verify stats reset */
+	TEST_ASSERT(rte_eth_stats_reset(port_id) == 0,
+		    "Failed to reset stats");
+	TEST_ASSERT(rte_eth_stats_get(port_id, &stats) == 0,
+		    "Failed to get stats after reset");
+	TEST_ASSERT(stats.ipackets == 0 && stats.opackets == 0,
+		    "Stats not reset to zero");
+
+	cleanup_pcap_vdev("net_pcap_stats", port_id);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(stats_tx_path);
+
+	printf("Statistics PASSED: RX=%u, TX=%d\n", received, nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame RX (multi-segment mbufs)
+ */
+static int
+test_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char jumbo_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const unsigned int num_jumbo = 16;
+
+	printf("Testing jumbo frame RX (%u byte packets, multi-segment)\n",
+	       PKT_SIZE_JUMBO);
+
+	TEST_ASSERT(create_temp_path(jumbo_pcap_path, sizeof(jumbo_pcap_path), "pcap_jumbo") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_sized_pcap(jumbo_pcap_path, num_jumbo,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", jumbo_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo", devargs, &port_id) == 0,
+		    "Failed to create jumbo RX vdev");
+
+	/* Jumbo frames require scatter to receive into multi-segment mbufs */
+	struct rte_eth_conf jumbo_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_SCATTER |
+				   RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &jumbo_conf) == 0,
+		    "Failed to setup jumbo RX port");
+
+	receive_packets(port_id, mbufs, num_jumbo, &received);
+	TEST_ASSERT_EQUAL(received, num_jumbo,
+			  "Received %u packets, expected %u", received, num_jumbo);
+
+	/* Verify all packets are jumbo size (may be multi-segment) */
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		/* Jumbo frames should use multiple segments */
+		if (nb_segs > 1)
+			printf("  Packet %u: %u segments\n", i, nb_segs);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_jumbo", port_id);
+	remove_temp_file(jumbo_pcap_path);
+
+	printf("Jumbo RX PASSED: %u jumbo packets received\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX (multi-segment mbufs)
+ */
+static int
+test_jumbo_tx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char tx_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t sizes[MAX_PKT_BURST];
+	int nb_tx, pkt_count;
+	unsigned int i;
+	int ret;
+	const unsigned int num_jumbo = 8;
+
+	printf("Testing jumbo frame TX (multi-segment mbufs)\n");
+
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_jumbo_tx") == 0,
+		    "Failed to create temp file path");
+
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", tx_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_jumbo_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate multi-segment mbufs for jumbo frames */
+	for (i = 0; i < num_jumbo; i++) {
+		mbufs[i] = alloc_jumbo_mbuf(PKT_SIZE_JUMBO, (uint8_t)(i & 0xFF));
+		if (mbufs[i] == NULL) {
+			/* Free already allocated mbufs */
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+		printf("  Packet %u: %u segments for %u bytes\n",
+		       i, mbufs[i]->nb_segs, PKT_SIZE_JUMBO);
+	}
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_jumbo);
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_jumbo; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_jumbo,
+			  "TX burst failed: sent %d/%u", nb_tx, num_jumbo);
+
+	cleanup_pcap_vdev("net_pcap_jumbo_tx", port_id);
+
+	/* Verify pcap file has correct packet count and sizes */
+	pkt_count = get_pcap_packet_sizes(tx_path, sizes, MAX_PKT_BURST);
+	TEST_ASSERT_EQUAL(pkt_count, (int)num_jumbo,
+			  "Pcap file has %d packets, expected %u",
+			  pkt_count, num_jumbo);
+
+	for (i = 0; i < (unsigned int)pkt_count; i++) {
+		TEST_ASSERT_EQUAL(sizes[i], PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, sizes[i], PKT_SIZE_JUMBO);
+	}
+
+	remove_temp_file(tx_path);
+
+	printf("Jumbo TX PASSED: %d jumbo packets written\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Layering on Linux network interface
+ */
+static int
+test_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing pcap on network interface\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_iface", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	TEST_ASSERT(rte_eth_dev_get_port_by_name("net_pcap_iface",
+						 &port_id) == 0,
+		    "Failed to get iface port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup iface port");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info: %s", rte_strerror(-ret));
+
+	printf("Driver: %s, max_rx_queues=%u, max_tx_queues=%u\n",
+	       dev_info.driver_name, dev_info.max_rx_queues,
+	       dev_info.max_tx_queues);
+
+	/* Use packet_burst_generator for interface test */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	cleanup_pcap_vdev("net_pcap_iface", port_id);
+
+	printf("Interface test PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status and speed reporting
+ *
+ * This test verifies that:
+ * 1. In interface (pass-through) mode, link state reflects the real interface
+ * 2. In file mode, link status follows device started/stopped state
+ * 3. Link speed values are properly reported
+ */
+static int
+test_link_status(void)
+{
+	struct rte_eth_link link;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing link status reporting\n");
+
+	/*
+	 * Test 1: Interface (pass-through) mode
+	 * Link state should reflect the underlying interface
+	 */
+	iface = find_test_iface();
+	if (iface != NULL) {
+		printf("  Testing interface mode with: %s\n", iface);
+
+		ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		if (rte_vdev_init("net_pcap_link_iface", devargs) == 0) {
+			ret = rte_eth_dev_get_port_by_name("net_pcap_link_iface", &port_id);
+			TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+			ret = setup_pcap_port(port_id);
+			TEST_ASSERT(ret == 0, "Failed to setup port");
+
+			/* Get link status */
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			TEST_ASSERT(ret == 0, "Failed to get link: %s", rte_strerror(-ret));
+
+			printf("    Link status: %s\n",
+			       link.link_status ? "UP" : "DOWN");
+			printf("    Link speed: %u Mbps\n", link.link_speed);
+			printf("    Link duplex: %s\n",
+			       link.link_duplex ? "full" : "half");
+			printf("    Link autoneg: %s\n",
+			       link.link_autoneg ? "enabled" : "disabled");
+
+			/*
+			 * For loopback interface, link should be up.
+			 * Speed may be 0 or undefined for virtual interfaces.
+			 */
+			if (strcmp(iface, "lo") == 0) {
+				TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+					    "Loopback should report link UP");
+			}
+
+			/*
+			 * Verify link_get returns consistent results
+			 */
+			struct rte_eth_link link2;
+			ret = rte_eth_link_get(port_id, &link2);
+			TEST_ASSERT(ret == 0, "Second link_get failed");
+			TEST_ASSERT(link.link_status == link2.link_status,
+				    "Link status inconsistent between calls");
+
+			cleanup_pcap_vdev("net_pcap_link_iface", port_id);
+			printf("  Interface mode link test PASSED\n");
+		} else {
+			printf("  Cannot create iface vdev (needs root?), skipping iface test\n");
+		}
+	} else {
+		printf("  No suitable interface found, skipping iface test\n");
+	}
+
+	/*
+	 * Test 2: File mode
+	 * Link status should be DOWN before start, UP after start
+	 */
+	printf("  Testing file mode link status\n");
+
+	/* Create a simple pcap file for testing */
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path), "pcap_link") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, 1) == 0,
+		    "Failed to create test pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_link_file", devargs, &port_id) == 0,
+		    "Failed to create file vdev");
+
+	/* Before starting: configure but don't start */
+	struct rte_eth_conf port_conf = { 0 };
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port");
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "Failed to setup RX queue");
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "Failed to setup TX queue");
+
+	/* Check link before start - should be DOWN */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link before start");
+	printf("    Before start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN before start");
+
+	/* Start the port */
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port");
+
+	/* Check link after start - should be UP */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after start");
+	printf("    After start: link %s, speed %u Mbps\n",
+	       link.link_status ? "UP" : "DOWN", link.link_speed);
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Stop the port */
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	/* Check link after stop - should be DOWN again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after stop");
+	printf("    After stop: link %s\n",
+	       link.link_status ? "UP" : "DOWN");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after stop");
+
+	rte_vdev_uninit("net_pcap_link_file");
+	remove_temp_file(rx_pcap_path);
+
+	printf("Link status test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+#ifdef RTE_EXEC_ENV_WINDOWS
+static int
+test_lsc_iface(void)
+{
+	printf("  Link toggle test not supported on Windows, skipping\n");
+	return TEST_SKIPPED;
+}
+#else
+/*
+ * Test: Link Status Change (LSC) interrupt support
+ *
+ * Verifies that:
+ * 1. LSC capability is NOT advertised for file mode
+ * 2. LSC capability IS advertised for iface mode
+ * 3. LSC callback fires when the underlying interface goes down/up
+ *
+ * Requires a toggleable Ethernet interface created before running:
+ *   Linux:   ip link add dummy0 type dummy && ip link set dummy0 up
+ *   FreeBSD: ifconfig disc0 create && ifconfig disc0 up
+ *
+ * Skipped if no suitable interface is found or on Windows.
+ */
+
+/* Callback counter for LSC test */
+static volatile int lsc_callback_count;
+
+static int
+test_lsc_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	lsc_callback_count++;
+	return 0;
+}
+
+/*
+ * Helper: Set interface link up or down via ioctl.
+ * Returns 0 on success, -errno on failure.
+ */
+static int
+set_iface_up_down(const char *ifname, int up)
+{
+	struct ifreq ifr;
+	int fd, ret;
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (fd < 0)
+		return -errno;
+
+	memset(&ifr, 0, sizeof(ifr));
+	strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
+
+	ret = ioctl(fd, SIOCGIFFLAGS, &ifr);
+	if (ret < 0) {
+		ret = -errno;
+		close(fd);
+		return ret;
+	}
+
+	if (up)
+		ifr.ifr_flags |= IFF_UP;
+	else
+		ifr.ifr_flags &= ~IFF_UP;
+
+	ret = ioctl(fd, SIOCSIFFLAGS, &ifr);
+	if (ret < 0)
+		ret = -errno;
+	else
+		ret = 0;
+
+	close(fd);
+	return ret;
+}
+
+/*
+ * Helper: Find a toggleable test interface for LSC testing.
+ *
+ * Looks for well-known interfaces that are safe to bring up/down:
+ *   Linux:   dummy0 (ip link add dummy0 type dummy)
+ *   FreeBSD: disc0 (ifconfig disc0 create)
+ *
+ * Returns interface name or NULL if none found.
+ */
+static const char *
+find_lsc_test_iface(void)
+{
+	static const char * const candidates[] = { "dummy0", "disc0" };
+	unsigned int i;
+
+	for (i = 0; i < RTE_DIM(candidates); i++) {
+		if (iface_is_ethernet(candidates[i]))
+			return candidates[i];
+	}
+	return NULL;
+}
+
+static int
+test_lsc_iface(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[256];
+	int ret;
+
+	printf("Testing Link Status Change (LSC) support\n");
+
+	/*
+	 * Test 1: Verify LSC is NOT advertised for file mode
+	 */
+	printf("  Testing file mode does not advertise LSC\n");
+	{
+		char lsc_pcap_path[PATH_MAX];
+		uint16_t file_port_id;
+
+		TEST_ASSERT(create_temp_path(lsc_pcap_path, sizeof(lsc_pcap_path),
+					     "pcap_lsc") == 0,
+			    "Failed to create temp path");
+		TEST_ASSERT(create_test_pcap(lsc_pcap_path, 1) == 0,
+			    "Failed to create test pcap");
+
+		ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", lsc_pcap_path);
+		TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+			    "devargs string truncated");
+		TEST_ASSERT(create_pcap_vdev("net_pcap_lsc_file", devargs,
+					     &file_port_id) == 0,
+			    "Failed to create file vdev");
+
+		ret = rte_eth_dev_info_get(file_port_id, &dev_info);
+		TEST_ASSERT(ret == 0, "Failed to get dev info");
+
+		TEST_ASSERT((*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC) == 0,
+			    "File mode should NOT advertise LSC capability");
+
+		rte_vdev_uninit("net_pcap_lsc_file");
+		remove_temp_file(lsc_pcap_path);
+		printf("  File mode LSC check PASSED\n");
+	}
+
+	struct rte_eth_link link;
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	uint16_t port_id;
+
+	/*
+	 * Test 2: Use a toggleable interface to test link change events.
+	 * Skip if not present.
+	 */
+	const char *lsc_iface = find_lsc_test_iface();
+	if (lsc_iface == NULL) {
+		printf("  No toggleable interface found, skipping link change test\n");
+		printf("  Linux:   ip link add dummy0 type dummy && ip link set dummy0 up\n");
+		printf("  FreeBSD: ifconfig disc0 create && ifconfig disc0 up\n");
+		return TEST_SKIPPED;
+	}
+
+	printf("  Testing iface mode LSC with: %s\n", lsc_iface);
+
+	/* Ensure interface is up before we start */
+	ret = set_iface_up_down(lsc_iface, 1);
+	if (ret != 0) {
+		printf("  Cannot set %s up (%s), skipping\n",
+		       lsc_iface, strerror(-ret));
+		return TEST_SKIPPED;
+	}
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", lsc_iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_lsc", devargs);
+	if (ret < 0) {
+		printf("  Cannot create iface vdev for %s, skipping\n", lsc_iface);
+		return TEST_SKIPPED;
+	}
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_lsc", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "Iface mode should advertise LSC capability");
+	printf("    LSC capability advertised: yes\n");
+
+	/* Register LSC callback */
+	lsc_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_lsc_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link status");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+	printf("    Link after start: UP\n");
+
+	/* Bring interface down - should trigger LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 0);
+	TEST_ASSERT(ret == 0, "Failed to set %s down: %s",
+		    lsc_iface, strerror(-ret));
+
+	/* Poll for link state change (1 second poll interval in driver) */
+	{
+		int poll;
+		for (poll = 0; poll < 30; poll++) {
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			if (ret == 0 && link.link_status == RTE_ETH_LINK_DOWN &&
+			    lsc_callback_count >= 1)
+				break;
+			usleep(100 * 1000);
+		}
+	}
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after down");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after interface down");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired, count=%d",
+		    lsc_callback_count);
+	printf("    Interface down: link DOWN, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Bring it back up - should trigger another LSC */
+	lsc_callback_count = 0;
+	ret = set_iface_up_down(lsc_iface, 1);
+	TEST_ASSERT(ret == 0, "Failed to set %s up: %s",
+		    lsc_iface, strerror(-ret));
+
+	/* Poll for link state change back to UP */
+	{
+		int poll;
+		for (poll = 0; poll < 30; poll++) {
+			ret = rte_eth_link_get_nowait(port_id, &link);
+			if (ret == 0 && link.link_status == RTE_ETH_LINK_UP &&
+			    lsc_callback_count >= 1)
+				break;
+			usleep(100 * 1000);
+		}
+	}
+
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after up");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after interface up");
+	TEST_ASSERT(lsc_callback_count >= 1,
+		    "LSC callback should have fired on link restore, count=%d",
+		    lsc_callback_count);
+	printf("    Interface up: link UP, callbacks=%d\n",
+	       lsc_callback_count);
+
+	/* Cleanup */
+	rte_eth_dev_stop(port_id);
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_lsc_callback, NULL);
+	rte_vdev_uninit("net_pcap_lsc");
+
+	printf("LSC test PASSED\n");
+	return TEST_SUCCESS;
+}
+#endif /* RTE_EXEC_ENV_WINDOWS */
+
+/*
+ * Test: EOF notification via link status change
+ *
+ * Verifies that:
+ * 1. The eof devarg causes link down + LSC event at end of pcap file
+ * 2. link_get reports DOWN after EOF
+ * 3. Stop/start resets the EOF state and replays the file
+ * 4. The eof and infinite_rx options are mutually exclusive
+ */
+
+static volatile int eof_callback_count;
+
+static int
+test_eof_callback(uint16_t port_id __rte_unused,
+		  enum rte_eth_event_type event __rte_unused,
+		  void *cb_arg __rte_unused, void *ret_param __rte_unused)
+{
+	eof_callback_count++;
+	return 0;
+}
+
+static int
+test_eof_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.intr_conf.lsc = 1,
+	};
+	struct rte_eth_link link;
+	char eof_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx;
+	int ret;
+
+	printf("Testing EOF notification via link status change\n");
+
+	/* Create pcap file with known number of packets */
+	TEST_ASSERT(create_temp_path(eof_pcap_path, sizeof(eof_pcap_path),
+				     "pcap_eof") == 0,
+		    "Failed to create temp file path");
+	TEST_ASSERT(create_test_pcap(eof_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/*
+	 * Test 1: EOF triggers link down and LSC callback
+	 */
+	printf("  Testing EOF triggers link down and LSC event\n");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,eof=1",
+		       eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create eof vdev: %s",
+		    rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_eof", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Verify LSC capability is advertised */
+	struct rte_eth_dev_info dev_info;
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT(ret == 0, "Failed to get dev info");
+	TEST_ASSERT(*dev_info.dev_flags & RTE_ETH_DEV_INTR_LSC,
+		    "EOF mode should advertise LSC capability");
+
+	/* Register LSC callback */
+	eof_callback_count = 0;
+	ret = rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_INTR_LSC,
+					    test_eof_callback, NULL);
+	TEST_ASSERT(ret == 0, "Failed to register LSC callback");
+
+	/* Configure with LSC enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with LSC");
+
+	/* Verify link is up initially */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after start");
+
+	/* Drain all packets from the pcap file */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			/* Got all packets and rx returned 0 — EOF hit */
+			break;
+		}
+	}
+
+	printf("    Received %u packets (expected %d)\n", total_rx, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Should receive exactly %d packets", NUM_PACKETS);
+
+	/* Verify link went down */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after EOF");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_DOWN,
+		    "Link should be DOWN after EOF");
+
+	/* Poll for the deferred EOF alarm to fire on the interrupt thread */
+	{
+		int poll;
+		for (poll = 0; poll < 20; poll++) {
+			if (eof_callback_count >= 1)
+				break;
+			usleep(100 * 1000);
+		}
+	}
+
+	/* Verify callback fired exactly once */
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "LSC callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    EOF signaled: link DOWN, callback fired\n");
+
+	/*
+	 * Test 2: Stop/start resets EOF and replays the file
+	 */
+	printf("  Testing restart replays pcap file\n");
+
+	ret = rte_eth_dev_stop(port_id);
+	TEST_ASSERT(ret == 0, "Failed to stop port");
+
+	eof_callback_count = 0;
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to restart port");
+
+	/* Verify link is up again */
+	ret = rte_eth_link_get_nowait(port_id, &link);
+	TEST_ASSERT(ret == 0, "Failed to get link after restart");
+	TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+		    "Link should be UP after restart");
+
+	/* Read packets again */
+	total_rx = 0;
+	for (int attempts = 0; attempts < 200; attempts++) {
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs,
+						  MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+		} else if (total_rx >= NUM_PACKETS) {
+			break;
+		}
+	}
+
+	TEST_ASSERT_EQUAL(total_rx, NUM_PACKETS,
+			  "Restart: should receive %d packets, got %u",
+			  NUM_PACKETS, total_rx);
+
+	/* Poll for the deferred EOF alarm to fire on the interrupt thread */
+	{
+		int poll;
+		for (poll = 0; poll < 20; poll++) {
+			if (eof_callback_count >= 1)
+				break;
+			usleep(100 * 1000);
+		}
+	}
+
+	TEST_ASSERT_EQUAL(eof_callback_count, 1,
+			  "Restart: callback should fire once, fired %d times",
+			  eof_callback_count);
+	printf("    Restart replay: %u packets, EOF signaled again\n", total_rx);
+
+	/* Cleanup */
+	rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_INTR_LSC,
+					test_eof_callback, NULL);
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_eof");
+
+	/*
+	 * Test 3: eof + infinite_rx is rejected
+	 */
+	printf("  Testing eof + infinite_rx mutual exclusion\n");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,eof=1,infinite_rx=1", eof_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_eof_bad", devargs);
+	TEST_ASSERT(ret != 0, "eof + infinite_rx should be rejected");
+	printf("    Mutual exclusion check PASSED\n");
+
+	remove_temp_file(eof_pcap_path);
+
+	printf("EOF test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Verify receive timestamps from pcap file
+ */
+static int
+test_rx_timestamp(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char timestamp_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	int ret;
+	const uint32_t base_sec = 1000;
+	const uint32_t usec_increment = 10000; /* 10ms between packets */
+	rte_mbuf_timestamp_t prev_ts = 0;
+
+	printf("Testing RX timestamp accuracy\n");
+
+	TEST_ASSERT(create_temp_path(timestamp_pcap_path, sizeof(timestamp_pcap_path),
+				     "pcap_ts") == 0,
+		    "Failed to create temp path");
+	TEST_ASSERT(create_timestamped_pcap(timestamp_pcap_path, NUM_PACKETS,
+					    base_sec, usec_increment) == 0,
+		    "Failed to create timestamped pcap");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", timestamp_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_ts", devargs, &port_id) == 0,
+		    "Failed to create timestamp vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup timestamp port");
+
+	/* Try to initialize timestamp dynamic field access */
+	TEST_ASSERT(timestamp_init() == 0, "Timestamp dynfield not available");
+
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Check if first packet has timestamp flag set */
+	if (!mbuf_has_timestamp(mbufs[0])) {
+		printf("Timestamps not enabled in mbufs, skipping validation\n");
+		rte_pktmbuf_free_bulk(mbufs, received);
+		cleanup_pcap_vdev("net_pcap_ts", port_id);
+		return TEST_SKIPPED;
+	}
+
+	for (i = 0; i < received; i++) {
+		struct rte_mbuf *m = mbufs[i];
+
+		TEST_ASSERT(mbuf_has_timestamp(m),
+			    "Packet %u missing timestamp flag", i);
+
+		/* PCAP PMD stores timestamp in nanoseconds */
+		rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+		uint64_t expected = (uint64_t)base_sec * NS_PER_S
+			+ (uint64_t)i * usec_increment * 1000;
+
+		TEST_ASSERT_EQUAL(ts, expected,
+				  "Packet %u: timestamp mismatch, expected=%"PRIu64
+				  " actual=%"PRIu64, i, expected, ts);
+
+		/* Verify monotonically increasing timestamps */
+		if (i > 0) {
+			TEST_ASSERT(ts >= prev_ts,
+				    "Packet %u: timestamp not monotonic %"PRIu64" > %"PRIu64,
+				    i, prev_ts, ts);
+		}
+		prev_ts = ts;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_ts", port_id);
+	remove_temp_file(timestamp_pcap_path);
+
+	printf("RX timestamp PASSED: %u packets with valid timestamps\n", received);
+	return TEST_SUCCESS;
+}
+
+/* Helper: Generate packets for multi-queue tests */
+static int
+generate_mq_test_packets(struct rte_mbuf **pkts, unsigned int nb_pkts, uint16_t queue_id)
+{
+	struct rte_ether_hdr eth_hdr;
+	struct rte_ipv4_hdr ip_hdr;
+	struct rte_udp_hdr udp_hdr;
+	uint16_t pkt_data_len;
+	unsigned int i;
+
+	initialize_eth_header(&eth_hdr, &src_mac, &dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
+	pkt_data_len = sizeof(struct rte_udp_hdr);
+	initialize_udp_header(&udp_hdr, 1234, 1234, pkt_data_len);
+	initialize_ipv4_header(&ip_hdr, IPV4_ADDR(192, 168, 1, 1), IPV4_ADDR(192, 168, 1, 2),
+			       pkt_data_len + sizeof(struct rte_udp_hdr));
+
+	for (i = 0; i < nb_pkts; i++) {
+		pkts[i] = rte_pktmbuf_alloc(mp);
+		if (pkts[i] == NULL) {
+			printf("Failed to allocate mbuf\n");
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		char *pkt_data = rte_pktmbuf_append(pkts[i], PACKET_BURST_GEN_PKT_LEN);
+		if (pkt_data == NULL) {
+			printf("Failed to append data to mbuf\n");
+			rte_pktmbuf_free(pkts[i]);
+			while (i > 0)
+				rte_pktmbuf_free(pkts[--i]);
+			return -1;
+		}
+
+		size_t offset = 0;
+		memcpy(pkt_data + offset, &eth_hdr, sizeof(eth_hdr));
+		offset += sizeof(eth_hdr);
+
+		/* Mark packet with queue ID in IP packet_id field for tracing */
+		ip_hdr.packet_id = rte_cpu_to_be_16((queue_id << 8) | (i & 0xFF));
+		ip_hdr.hdr_checksum = 0;
+		ip_hdr.hdr_checksum = rte_ipv4_cksum(&ip_hdr);
+
+		memcpy(pkt_data + offset, &ip_hdr, sizeof(ip_hdr));
+		offset += sizeof(ip_hdr);
+		memcpy(pkt_data + offset, &udp_hdr, sizeof(udp_hdr));
+	}
+	return (int)nb_pkts;
+}
+
+/* Helper: Validate pcap file structure using libpcap */
+static int
+validate_pcap_file(const char *filename)
+{
+	pcap_t *pcap;
+	char errbuf[PCAP_ERRBUF_SIZE];
+
+	pcap = pcap_open_offline(filename, errbuf);
+	if (pcap == NULL) {
+		printf("Failed to validate pcap file %s: %s\n", filename, errbuf);
+		return -1;
+	}
+	if (pcap_datalink(pcap) != DLT_EN10MB) {
+		printf("Unexpected datalink type: %d\n", pcap_datalink(pcap));
+		pcap_close(pcap);
+		return -1;
+	}
+	pcap_close(pcap);
+	return 0;
+}
+
+/*
+ * Test: Multiple TX queues writing to separate pcap files
+ *
+ * This test creates a pcap PMD with multiple TX queues, each configured
+ * to write to its own output file. We verify that:
+ * 1. All packets from all queues are written
+ * 2. Each resulting pcap file is valid
+ * 3. Each file has the expected packet count
+ */
+static int
+test_multi_tx_queue(void)
+{
+	char multi_tx_pcap_paths[MULTI_QUEUE_NUM_QUEUES][PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_txconf tx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_tx = 0;
+	unsigned int tx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+
+	printf("Testing multiple TX queues to separate files\n");
+
+	/* Create temp paths for each TX queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_multi_tx%u", q);
+		TEST_ASSERT(create_temp_path(multi_tx_pcap_paths[q],
+					     sizeof(multi_tx_pcap_paths[q]), prefix) == 0,
+			    "Failed to create temp path for queue %u", q);
+	}
+
+	/* Create the pcap PMD with multiple TX queues to separate files */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,tx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		 multi_tx_pcap_paths[0], multi_tx_pcap_paths[1],
+		 multi_tx_pcap_paths[2], multi_tx_pcap_paths[3]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_tx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_tx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 0, MULTI_QUEUE_NUM_QUEUES, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&tx_conf, 0, sizeof(tx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_tx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &tx_conf);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup TX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Transmit packets from each queue */
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		unsigned int pkts_to_send = MULTI_QUEUE_NUM_PACKETS / MULTI_QUEUE_NUM_QUEUES;
+
+		while (tx_per_queue[q] < pkts_to_send) {
+			unsigned int burst = RTE_MIN(MULTI_QUEUE_BURST_SIZE,
+						     pkts_to_send - tx_per_queue[q]);
+
+			ret = generate_mq_test_packets(pkts, burst, q);
+			TEST_ASSERT(ret >= 0, "Failed to generate packets for queue %u", q);
+
+			uint16_t nb_tx = rte_eth_tx_burst(port_id, q, pkts, burst);
+			for (unsigned int i = nb_tx; i < burst; i++)
+				rte_pktmbuf_free(pkts[i]);
+
+			tx_per_queue[q] += nb_tx;
+			total_tx += nb_tx;
+
+			if (nb_tx == 0) {
+				printf("TX stall on queue %u\n", q);
+				break;
+			}
+		}
+		printf("  Queue %u: transmitted %u packets\n", q, tx_per_queue[q]);
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_tx");
+	rte_delay_ms(100);
+
+	/* Validate each pcap file */
+	unsigned int total_in_files = 0;
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = validate_pcap_file(multi_tx_pcap_paths[q]);
+		TEST_ASSERT_SUCCESS(ret, "pcap file for queue %u is invalid", q);
+
+		int pkt_count = count_pcap_packets(multi_tx_pcap_paths[q]);
+		TEST_ASSERT(pkt_count >= 0, "Could not count packets in pcap file for queue %u", q);
+
+		printf("  Queue %u file: %d packets\n", q, pkt_count);
+		TEST_ASSERT_EQUAL((unsigned int)pkt_count, tx_per_queue[q],
+				  "Queue %u: file has %d packets, expected %u",
+				  q, pkt_count, tx_per_queue[q]);
+		total_in_files += pkt_count;
+	}
+
+	printf("  Total packets transmitted: %u\n", total_tx);
+	printf("  Total packets in all files: %u\n", total_in_files);
+
+	TEST_ASSERT_EQUAL(total_in_files, total_tx,
+			  "Total packet count mismatch: expected %u, got %u",
+			  total_tx, total_in_files);
+
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		remove_temp_file(multi_tx_pcap_paths[q]);
+
+	printf("Multi-TX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple RX queues reading from the same pcap file
+ *
+ * This test creates a pcap PMD with multiple RX queues all configured
+ * to read from the same input file. We verify that:
+ * 1. Each queue can read packets
+ * 2. The total packets read equals the file content (or expected behavior)
+ */
+static int
+test_multi_rx_queue_same_file(void)
+{
+	char multi_rx_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf;
+	struct rte_eth_rxconf rx_conf;
+	struct rte_mbuf *pkts[MULTI_QUEUE_BURST_SIZE];
+	uint16_t q;
+	int ret;
+	unsigned int total_rx = 0;
+	unsigned int rx_per_queue[MULTI_QUEUE_NUM_QUEUES] = {0};
+	unsigned int seed_packets = MULTI_QUEUE_NUM_PACKETS;
+	unsigned int expected_total;
+
+	printf("Testing multiple RX queues from same file\n");
+
+	TEST_ASSERT(create_temp_path(multi_rx_pcap_path, sizeof(multi_rx_pcap_path),
+				     "pcap_multi_rx") == 0,
+		    "Failed to create temp path");
+
+	ret = create_test_pcap(multi_rx_pcap_path, seed_packets);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create seed pcap file");
+	printf("  Created seed pcap file with %u packets\n", seed_packets);
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,rx_pcap=%s",
+		 multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path, multi_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_multi_rx", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_multi_rx", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, MULTI_QUEUE_NUM_QUEUES, 0, &port_conf);
+	TEST_ASSERT_SUCCESS(ret, "Failed to configure device: %s", rte_strerror(-ret));
+
+	memset(&rx_conf, 0, sizeof(rx_conf));
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		ret = rte_eth_rx_queue_setup(port_id, q, RING_SIZE,
+					     rte_eth_dev_socket_id(port_id), &rx_conf, mp);
+		TEST_ASSERT_SUCCESS(ret, "Failed to setup RX queue %u: %s", q, rte_strerror(-ret));
+	}
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT_SUCCESS(ret, "Failed to start device: %s", rte_strerror(-ret));
+
+	/* Receive packets from all queues. Each queue has its own file handle. */
+	int empty_rounds = 0;
+	while (empty_rounds < 10) {
+		int received_this_round = 0;
+		for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, q, pkts, MULTI_QUEUE_BURST_SIZE);
+			if (nb_rx > 0) {
+				rx_per_queue[q] += nb_rx;
+				total_rx += nb_rx;
+				received_this_round += nb_rx;
+				rte_pktmbuf_free_bulk(pkts, nb_rx);
+			}
+		}
+		if (received_this_round == 0)
+			empty_rounds++;
+		else
+			empty_rounds = 0;
+	}
+
+	printf("  RX Results:\n");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++)
+		printf("    Queue %u: received %u packets\n", q, rx_per_queue[q]);
+	printf("    Total received: %u packets\n", total_rx);
+
+	/* Each RX queue opens its own file handle, so each reads all packets */
+	expected_total = seed_packets * MULTI_QUEUE_NUM_QUEUES;
+	printf("    Expected total (each queue reads all): %u packets\n", expected_total);
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_multi_rx");
+
+	TEST_ASSERT(total_rx > 0, "No packets received at all");
+	for (q = 0; q < MULTI_QUEUE_NUM_QUEUES; q++) {
+		TEST_ASSERT(rx_per_queue[q] > 0, "Queue %u received no packets", q);
+		TEST_ASSERT_EQUAL(rx_per_queue[q], seed_packets,
+				  "Queue %u received %u packets, expected %u",
+				  q, rx_per_queue[q], seed_packets);
+	}
+	TEST_ASSERT_EQUAL(total_rx, expected_total,
+			  "Total RX mismatch: expected %u, got %u", expected_total, total_rx);
+
+	remove_temp_file(multi_rx_pcap_path);
+
+	printf("Multi-RX queue PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Device info reports correct queue counts and MTU limits
+ *
+ * This test verifies that rte_eth_dev_info_get() returns correct values:
+ * 1. max_rx_queues matches the number of rx_pcap files passed
+ * 2. max_tx_queues matches the number of tx_pcap files passed
+ * 3. max_rx_pktlen and max_mtu are based on default snapshot length
+ */
+static int
+test_dev_info(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_paths[3][PATH_MAX];
+	char tx_paths[2][PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	unsigned int i;
+	/* Default snapshot length is 65535 */
+	const uint32_t default_snaplen = 65535;
+	const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing device info reporting\n");
+
+	/* Create temp RX pcap files (3 queues) */
+	for (i = 0; i < 3; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_rx%u", i);
+		TEST_ASSERT(create_temp_path(rx_paths[i], sizeof(rx_paths[i]), prefix) == 0,
+			    "Failed to create RX temp path %u", i);
+		TEST_ASSERT(create_test_pcap(rx_paths[i], 1) == 0,
+			    "Failed to create RX pcap %u", i);
+	}
+
+	/* Create temp TX pcap files (2 queues) */
+	for (i = 0; i < 2; i++) {
+		char prefix[32];
+		snprintf(prefix, sizeof(prefix), "pcap_devinfo_tx%u", i);
+		TEST_ASSERT(create_temp_path(tx_paths[i], sizeof(tx_paths[i]), prefix) == 0,
+			    "Failed to create TX temp path %u", i);
+	}
+
+	/* Create device with 3 RX queues and 2 TX queues */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,rx_pcap=%s,rx_pcap=%s,tx_pcap=%s,tx_pcap=%s",
+		       rx_paths[0], rx_paths[1], rx_paths[2], tx_paths[0], tx_paths[1]);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_devinfo", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_devinfo", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Device info:\n");
+	printf("    driver_name: %s\n", dev_info.driver_name);
+	printf("    max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues);
+	printf("    max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues);
+	printf("    max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen);
+	printf("    max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify queue counts match number of pcap files */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U,
+			  "max_rx_queues mismatch: expected 3, got %u", dev_info.max_rx_queues);
+	TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U,
+			  "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues);
+
+	/* Verify max_rx_pktlen equals default snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  default_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snapshot_len minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_devinfo");
+
+	/* Cleanup temp files */
+	for (i = 0; i < 3; i++)
+		remove_temp_file(rx_paths[i]);
+	for (i = 0; i < 2; i++)
+		remove_temp_file(tx_paths[i]);
+
+	printf("Device info PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom snapshot length (snaplen) parameter
+ *
+ * This test verifies that the snaplen devarg works correctly:
+ * 1. max_rx_pktlen reflects the custom snapshot length
+ * 2. max_mtu is calculated as snaplen - ethernet header
+ */
+static int
+test_snaplen(void)
+{
+	struct rte_eth_dev_info dev_info;
+	char devargs[512];
+	char rx_path[PATH_MAX];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret;
+	const uint32_t custom_snaplen = 9000;
+	const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN;
+
+	printf("Testing custom snapshot length parameter\n");
+
+	/* Create temp files */
+	TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_test_pcap(rx_path, 1) == 0,
+		    "Failed to create RX pcap");
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with custom snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u",
+		 rx_path, tx_path, custom_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_snaplen", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	ret = rte_eth_dev_info_get(port_id, &dev_info);
+	TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret));
+
+	printf("  Custom snaplen: %u\n", custom_snaplen);
+	printf("  max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen);
+	printf("  max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu);
+
+	/* Verify max_rx_pktlen equals custom snapshot length */
+	TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen,
+			  "max_rx_pktlen mismatch: expected %u, got %u",
+			  custom_snaplen, dev_info.max_rx_pktlen);
+
+	/* Verify max_mtu is snaplen minus ethernet header */
+	TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu,
+			  "max_mtu mismatch: expected %u, got %u",
+			  expected_max_mtu, dev_info.max_mtu);
+
+	rte_vdev_uninit("net_pcap_snaplen");
+
+	/* Cleanup temp files */
+	remove_temp_file(rx_path);
+	remove_temp_file(tx_path);
+
+	printf("Snapshot length test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation behavior
+ *
+ * This test verifies that packets larger than snaplen are properly truncated
+ * when written to pcap files:
+ * 1. caplen in pcap header is limited to snaplen
+ * 2. len in pcap header preserves original packet length
+ * 3. Only snaplen bytes of data are written
+ */
+static int
+test_snaplen_truncation(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx, nb_gen;
+	unsigned int pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint8_t pkt_size = 200;
+
+	printf("Testing snaplen truncation behavior\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		 tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	ret = rte_vdev_init("net_pcap_trunc", devargs);
+	TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id);
+	TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device");
+
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/* Generate packets larger than snaplen */
+	nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size);
+	TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS,
+			  "Failed to generate packets: got %d, expected %d",
+			  nb_gen, NUM_PACKETS);
+
+	printf("  Sending %d packets of size %u with snaplen=%u\n",
+	       NUM_PACKETS, pkt_size, test_snaplen);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_trunc", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS,
+			  "Packet count mismatch: got %u, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	/* Cleanup */
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Snapshot length truncation with multi-segment mbufs
+ *
+ * This test verifies that the dumper path correctly truncates
+ * non-contiguous (multi-segment) mbufs when the total packet length
+ * exceeds the configured snaplen.  It exercises the RTE_MIN(len, snaplen)
+ * cap in the TX dumper by ensuring:
+ *
+ * 1. caplen in the pcap header equals snaplen (not pkt_len)
+ * 2. len in the pcap header preserves the original packet length
+ * 3. Truncation works when the snaplen boundary falls mid-chain
+ */
+static int
+test_snaplen_truncation_multiseg(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[512];
+	char tx_path[PATH_MAX];
+	uint16_t port_id;
+	int ret, nb_tx;
+	unsigned int i, pkt_count;
+	const uint32_t test_snaplen = 100;
+	const uint32_t pkt_size = 300;
+	const uint16_t seg_size = 64;
+	const unsigned int num_pkts = 8;
+
+	printf("Testing snaplen truncation with multi-segment mbufs\n");
+
+	/* Create temp TX file */
+	TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path),
+				     "pcap_trunc_ms") == 0,
+		    "Failed to create TX temp path");
+
+	/* Create device with small snaplen */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u",
+		       tx_path, test_snaplen);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+
+	TEST_ASSERT(create_pcap_vdev("net_pcap_trunc_ms", devargs,
+				     &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port");
+
+	/*
+	 * Allocate multi-segment mbufs.  With seg_size=64 and pkt_size=300,
+	 * each mbuf will have 5 segments (4×64 + 1×44).  The snaplen of 100
+	 * falls partway through the second segment, forcing the dumper to
+	 * stop writing in the middle of the chain.
+	 */
+	for (i = 0; i < num_pkts; i++) {
+		mbufs[i] = alloc_multiseg_mbuf(pkt_size, seg_size,
+					       (uint8_t)(0xA0 + i));
+		if (mbufs[i] == NULL) {
+			while (i > 0)
+				rte_pktmbuf_free(mbufs[--i]);
+			cleanup_pcap_vdev("net_pcap_trunc_ms", port_id);
+			remove_temp_file(tx_path);
+			return TEST_FAILED;
+		}
+	}
+
+	printf("  Sending %u packets: pkt_len=%u, seg_size=%u (%u segs), snaplen=%u\n",
+	       num_pkts, pkt_size, seg_size, mbufs[0]->nb_segs, test_snaplen);
+
+	/* Verify mbufs are actually multi-segment */
+	TEST_ASSERT(mbufs[0]->nb_segs > 1,
+		    "Expected multi-segment mbufs, got %u segment(s)",
+		    mbufs[0]->nb_segs);
+
+	/* Transmit packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, num_pkts);
+
+	/* Free any unsent mbufs */
+	for (i = nb_tx; i < num_pkts; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	TEST_ASSERT_EQUAL(nb_tx, (int)num_pkts,
+			  "TX burst failed: sent %d/%u", nb_tx, num_pkts);
+
+	cleanup_pcap_vdev("net_pcap_trunc_ms", port_id);
+
+	/* Verify truncation in output file */
+	ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size,
+				     &pkt_count);
+	TEST_ASSERT_SUCCESS(ret, "Truncation verification failed");
+	TEST_ASSERT_EQUAL(pkt_count, num_pkts,
+			  "Packet count mismatch: got %u, expected %u",
+			  pkt_count, num_pkts);
+
+	printf("  Verified %u packets: caplen=%u, len=%u\n",
+	       pkt_count, test_snaplen, pkt_size);
+
+	remove_temp_file(tx_path);
+
+	printf("Snaplen truncation multi-segment test PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip on RX
+ *
+ * This test verifies that when VLAN strip offload is enabled:
+ * 1. VLAN-tagged packets from pcap file have tags removed
+ * 2. VLAN info is stored in mbuf metadata (vlan_tci, ol_flags)
+ * 3. Packet data no longer contains the 4-byte VLAN tag
+ */
+static int
+test_vlan_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN strip on RX\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+				     "pcap_vlan_rx") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets (VLAN ID=%u, PCP=%u)\n",
+	       NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* Create vdev and configure with VLAN strip enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_rx", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	TEST_ASSERT(setup_pcap_port_vlan_strip(port_id) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length after VLAN strip (original - 4 bytes VLAN header) */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;  /* 18 bytes payload */
+
+	/* Verify VLAN was stripped from each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet no longer has VLAN tag in data */
+		TEST_ASSERT(verify_no_vlan_tag(mbufs[i]) == 0,
+			    "Packet %u still has VLAN tag after strip", i);
+
+		/* Check packet length decreased by 4 (VLAN header size) */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu after strip",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* Check VLAN info stored in mbuf metadata */
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN,
+			    "Packet %u: RX_VLAN flag not set", i);
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Packet %u: RX_VLAN_STRIPPED flag not set", i);
+
+		/* Verify the stored VLAN TCI contains expected values */
+		uint16_t expected_tci = (TEST_VLAN_PCP << 13) | TEST_VLAN_ID;
+		TEST_ASSERT_EQUAL(mbufs[i]->vlan_tci, expected_tci,
+				  "Packet %u: vlan_tci %u != expected %u",
+				  i, mbufs[i]->vlan_tci, expected_tci);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_rx", port_id);
+
+	printf("VLAN strip RX PASSED: %u packets verified\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Insert on TX
+ *
+ * This test verifies that when TX VLAN insert offload is used:
+ * 1. Untagged packets with RTE_MBUF_F_TX_VLAN flag get VLAN tag inserted
+ * 2. The written pcap file contains properly VLAN-tagged packets
+ * 3. VLAN ID and PCP from mbuf vlan_tci are correctly inserted
+ */
+static int
+test_vlan_insert_tx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char vlan_tx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	uint16_t nb_prep;
+	int nb_tx, pkt_count;
+	int ret;
+
+	printf("Testing VLAN insert on TX\n");
+
+	/* Create temp file for TX output */
+	TEST_ASSERT(create_temp_path(vlan_tx_pcap_path, sizeof(vlan_tx_pcap_path),
+				     "pcap_vlan_tx") == 0,
+		    "Failed to create temp file path");
+
+	/* Create vdev */
+	ret = snprintf(devargs, sizeof(devargs), "tx_pcap=%s", vlan_tx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_tx", devargs, &port_id) == 0,
+		    "Failed to create TX vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup TX port");
+
+	/* Allocate mbufs with VLAN TX offload configured */
+	TEST_ASSERT(alloc_vlan_tx_mbufs(mbufs, NUM_PACKETS,
+					TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to allocate VLAN TX mbufs");
+
+	printf("  Transmitting %d untagged packets with TX_VLAN offload "
+	       "(VLAN ID=%u, PCP=%u)\n", NUM_PACKETS, TEST_VLAN_ID, TEST_VLAN_PCP);
+
+	/* tx_prepare handles VLAN tag insertion */
+	nb_prep = rte_eth_tx_prepare(port_id, 0, mbufs, NUM_PACKETS);
+	TEST_ASSERT_EQUAL(nb_prep, NUM_PACKETS,
+			  "tx_prepare failed: prepared %u/%d", nb_prep, NUM_PACKETS);
+
+	/* Transmit the prepared packets */
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_prep);
+	TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS,
+			  "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS);
+
+	cleanup_pcap_vdev("net_pcap_vlan_tx", port_id);
+
+	/* Verify the output pcap file contains VLAN-tagged packets */
+	pkt_count = count_vlan_packets_in_pcap(vlan_tx_pcap_path, TEST_VLAN_ID, 1);
+	TEST_ASSERT(pkt_count >= 0, "Error verifying VLAN tags in output pcap");
+	TEST_ASSERT_EQUAL(pkt_count, NUM_PACKETS,
+			  "Pcap file has %d packets, expected %d",
+			  pkt_count, NUM_PACKETS);
+
+	remove_temp_file(vlan_tx_pcap_path);
+
+	printf("VLAN insert TX PASSED: %d VLAN-tagged packets written\n", NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip disabled (packets should remain tagged)
+ *
+ * This test verifies that when VLAN strip is NOT enabled:
+ * 1. VLAN-tagged packets from pcap file keep their tags
+ * 2. Packet data still contains the 4-byte VLAN header
+ */
+static int
+test_vlan_no_strip_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	size_t expected_len;
+	int ret;
+
+	printf("Testing VLAN packets without strip (offload disabled)\n");
+
+	/* Create pcap file with VLAN-tagged packets if not already created */
+	if (access(vlan_rx_pcap_path, F_OK) != 0) {
+		TEST_ASSERT(create_temp_path(vlan_rx_pcap_path, sizeof(vlan_rx_pcap_path),
+					     "pcap_vlan_nostrip") == 0,
+			    "Failed to create temp file path");
+		TEST_ASSERT(create_vlan_tagged_pcap(vlan_rx_pcap_path, NUM_PACKETS,
+						    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Failed to create VLAN-tagged pcap file");
+	}
+
+	/* Create vdev and configure WITHOUT VLAN strip */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", vlan_rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_nostrip", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+	/* Use standard setup which does NOT enable VLAN strip */
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Receive packets */
+	receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+	TEST_ASSERT_EQUAL(received, (unsigned int)NUM_PACKETS,
+			  "Received %u packets, expected %d", received, NUM_PACKETS);
+
+	/* Expected length with VLAN tag still present */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		       sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN tag is still present in each packet */
+	for (i = 0; i < received; i++) {
+		/* Check packet still has VLAN tag */
+		TEST_ASSERT(verify_vlan_tag(mbufs[i], TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+			    "Packet %u: VLAN tag verification failed", i);
+
+		/* Check packet length unchanged */
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), expected_len,
+				  "Packet %u length %u != expected %zu",
+				  i, rte_pktmbuf_pkt_len(mbufs[i]), expected_len);
+
+		/* VLAN strip flags should NOT be set */
+		TEST_ASSERT(!(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED),
+			    "Packet %u: RX_VLAN_STRIPPED flag set unexpectedly", i);
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_vlan_nostrip", port_id);
+
+	printf("VLAN no-strip RX PASSED: %u packets verified with tags intact\n", received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Runtime VLAN offload configuration via rte_eth_dev_set_vlan_offload
+ *
+ * This test verifies that VLAN strip can be enabled/disabled at runtime
+ * using the standard ethdev API rather than only at configure time.
+ * Uses infinite_rx mode so the same packets can be read in each phase.
+ */
+static int
+test_vlan_offload_set(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char vlan_set_pcap_path[PATH_MAX];
+	char devargs[512];
+	uint16_t port_id;
+	struct rte_eth_conf port_conf = { 0 };
+	unsigned int i;
+	uint16_t nb_rx;
+	int ret, current_offload;
+	size_t tagged_len, untagged_len;
+
+	printf("Testing runtime VLAN offload configuration\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_set_pcap_path, sizeof(vlan_set_pcap_path),
+				     "pcap_vlan_set") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_set_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	/* Use infinite_rx so packets are always available */
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,infinite_rx=1", vlan_set_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_vlan_set", devargs, &port_id) == 0,
+		    "Failed to create RX vdev");
+
+	/* Configure WITHOUT VLAN strip initially and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port");
+
+	/* Expected lengths */
+	tagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_vlan_hdr) +
+		     sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + 18;
+	untagged_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Verify VLAN strip is initially disabled */
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled initially");
+
+	/*
+	 * Phase 1: VLAN strip disabled - packets should have tags
+	 */
+	printf("  Phase 1: VLAN strip disabled\n");
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 1");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 1 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact\n", nb_rx);
+
+	/*
+	 * Phase 2: Enable VLAN strip at runtime - packets should be stripped
+	 */
+	printf("  Phase 2: Enabling VLAN strip via rte_eth_dev_set_vlan_offload\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, RTE_ETH_VLAN_STRIP_OFFLOAD);
+	TEST_ASSERT(ret == 0, "Failed to enable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD,
+		    "VLAN strip should be enabled after set_vlan_offload");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 2");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), untagged_len,
+				  "Phase 2 packet %u: expected untagged length %zu, got %u",
+				  i, untagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+		TEST_ASSERT(mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED,
+			    "Phase 2 packet %u: VLAN_STRIPPED flag not set", i);
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags stripped\n", nb_rx);
+
+	/*
+	 * Phase 3: Disable VLAN strip - packets should have tags again
+	 */
+	printf("  Phase 3: Disabling VLAN strip\n");
+	ret = rte_eth_dev_set_vlan_offload(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to disable VLAN strip: %s", rte_strerror(-ret));
+
+	current_offload = rte_eth_dev_get_vlan_offload(port_id);
+	TEST_ASSERT(!(current_offload & RTE_ETH_VLAN_STRIP_OFFLOAD),
+		    "VLAN strip should be disabled after clearing");
+
+	nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+	TEST_ASSERT(nb_rx > 0, "No packets received in phase 3");
+
+	for (i = 0; i < nb_rx; i++) {
+		TEST_ASSERT_EQUAL(rte_pktmbuf_pkt_len(mbufs[i]), tagged_len,
+				  "Phase 3 packet %u: expected tagged length %zu, got %u",
+				  i, tagged_len, rte_pktmbuf_pkt_len(mbufs[i]));
+	}
+	rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	printf("    Received %u packets with VLAN tags intact again\n", nb_rx);
+
+	cleanup_pcap_vdev("net_pcap_vlan_set", port_id);
+	remove_temp_file(vlan_set_pcap_path);
+
+	printf("Runtime VLAN offload PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: VLAN Strip in infinite RX mode
+ *
+ * This test verifies that VLAN strip offload works correctly when combined
+ * with infinite_rx mode, which uses a different RX path (eth_pcap_rx_infinite).
+ */
+static int
+test_vlan_strip_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+	};
+	char vlan_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int stripped_count = 0;
+	int iter, attempts, ret;
+	size_t expected_len;
+
+	printf("Testing VLAN strip with infinite RX mode\n");
+
+	/* Create pcap file with VLAN-tagged packets */
+	TEST_ASSERT(create_temp_path(vlan_inf_pcap_path, sizeof(vlan_inf_pcap_path),
+				     "pcap_vlan_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_vlan_tagged_pcap(vlan_inf_pcap_path, NUM_PACKETS,
+					    TEST_VLAN_ID, TEST_VLAN_PCP) == 0,
+		    "Failed to create VLAN-tagged pcap file");
+
+	printf("  Created VLAN-tagged pcap with %d packets for infinite RX\n", NUM_PACKETS);
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", vlan_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_vlan_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_vlan_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with VLAN strip enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with VLAN strip");
+
+	/* Expected length after VLAN strip */
+	expected_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) +
+		       sizeof(struct rte_udp_hdr) + 18;
+
+	/* Read packets - need more than file contains to verify infinite looping */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				/* Verify VLAN was stripped */
+				if (verify_no_vlan_tag(mbufs[i]) == 0 &&
+				    rte_pktmbuf_pkt_len(mbufs[i]) == expected_len &&
+				    (mbufs[i]->ol_flags & RTE_MBUF_F_RX_VLAN_STRIPPED))
+					stripped_count++;
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_vlan_inf");
+	remove_temp_file(vlan_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(stripped_count, total_rx,
+			  "VLAN strip failed: only %u/%u packets stripped correctly",
+			  stripped_count, total_rx);
+
+	printf("VLAN strip infinite RX PASSED: %u packets stripped (file has %d)\n",
+	       total_rx, NUM_PACKETS);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Timestamps in infinite RX mode
+ *
+ * This test verifies that timestamp offload works correctly when combined
+ * with infinite_rx mode. Since infinite_rx generates packets on-the-fly,
+ * timestamps should reflect the current time rather than pcap file timestamps.
+ */
+static int
+test_timestamp_infinite_rx(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	struct rte_eth_conf port_conf = {
+		.rxmode.offloads = RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+	};
+	char ts_inf_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int total_rx = 0;
+	unsigned int ts_count = 0;
+	int iter, attempts, ret;
+	rte_mbuf_timestamp_t first_ts = 0;
+	rte_mbuf_timestamp_t last_ts = 0;
+
+	printf("Testing timestamps with infinite RX mode\n");
+
+	/* Initialize timestamp dynamic field access */
+	if (timestamp_dynfield_offset < 0) {
+		ret = timestamp_init();
+		if (ret != 0) {
+			printf("Timestamp dynfield not available, skipping\n");
+			return TEST_SKIPPED;
+		}
+	}
+
+	/* Create simple pcap file */
+	TEST_ASSERT(create_temp_path(ts_inf_pcap_path, sizeof(ts_inf_pcap_path),
+				     "pcap_ts_inf") == 0,
+		    "Failed to create temp file path");
+
+	TEST_ASSERT(create_test_pcap(ts_inf_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap file");
+
+	/* Create vdev with infinite_rx enabled */
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s,infinite_rx=1", ts_inf_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_ts_inf", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create infinite RX vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_ts_inf", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure with timestamp offload enabled and start */
+	TEST_ASSERT(setup_pcap_port_conf(port_id, &port_conf) == 0,
+		    "Failed to setup port with timestamps");
+
+	/* Read packets */
+	for (iter = 0; iter < 3 && total_rx < NUM_PACKETS * 2; iter++) {
+		for (attempts = 0; attempts < 100 && total_rx < NUM_PACKETS * 2; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+
+			for (uint16_t i = 0; i < nb_rx; i++) {
+				if (mbuf_has_timestamp(mbufs[i])) {
+					rte_mbuf_timestamp_t ts = mbuf_timestamp_get(mbufs[i]);
+
+					if (ts_count == 0)
+						first_ts = ts;
+					last_ts = ts;
+					ts_count++;
+				}
+			}
+
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+			total_rx += nb_rx;
+
+			if (nb_rx == 0)
+				usleep(100);
+		}
+	}
+
+	rte_eth_dev_stop(port_id);
+	rte_vdev_uninit("net_pcap_ts_inf");
+	remove_temp_file(ts_inf_pcap_path);
+
+	TEST_ASSERT(total_rx >= NUM_PACKETS * 2,
+		    "Infinite RX: got %u packets, need >= %d", total_rx, NUM_PACKETS * 2);
+
+	TEST_ASSERT_EQUAL(ts_count, total_rx,
+			  "Timestamp missing: only %u/%u packets have timestamps",
+			  ts_count, total_rx);
+
+	/* Timestamps should be monotonically increasing (current time) */
+	TEST_ASSERT(last_ts >= first_ts,
+		    "Timestamps not monotonic: first=%" PRIu64 " last=%" PRIu64,
+		    first_ts, last_ts);
+
+	printf("Timestamp infinite RX PASSED: %u packets with valid timestamps\n", total_rx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite setup
+ */
+static int
+test_setup(void)
+{
+	/* Generate random source MAC address */
+	rte_eth_random_addr(src_mac.addr_bytes);
+
+	mp = rte_pktmbuf_pool_create("pcap_test_pool", NB_MBUF, 32, 0,
+				     RTE_MBUF_DEFAULT_BUF_SIZE,
+				     rte_socket_id());
+	TEST_ASSERT_NOT_NULL(mp, "Failed to create mempool");
+
+	return 0;
+}
+
+
+/*
+ * Test: Oversized packets are dropped when scatter is disabled
+ *
+ * Use the default mempool (buf_size ~2048) without scatter enabled.
+ * Read a pcap file containing packets larger than the mbuf data room.
+ * Verify that oversized packets are dropped and counted as errors.
+ */
+static int
+test_scatter_drop_oversized(void)
+{
+	struct rte_eth_conf port_conf;
+	struct rte_eth_stats stats;
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received;
+	int ret;
+	const unsigned int num_pkts = 16;
+
+	printf("Testing scatter: oversized packets dropped without scatter\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_scat_drop") == 0,
+		    "Failed to create temp file path");
+
+	/*
+	 * Create pcap with jumbo packets (9000 bytes) that exceed the
+	 * default mbuf data room (~2048 bytes). Without scatter enabled,
+	 * these should be dropped at receive time.
+	 */
+	TEST_ASSERT(create_sized_pcap(rx_pcap_path, num_pkts,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap file");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_scat_drop", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_scat_drop", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure without scatter - MTU check passes (1514 < 2048) */
+	memset(&port_conf, 0, sizeof(port_conf));
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port: %s", rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "rx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "tx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	ret = rte_eth_stats_reset(port_id);
+	TEST_ASSERT(ret == 0, "Failed to reset stats");
+
+	/*
+	 * Read all packets. The pcap file has 9000-byte packets but
+	 * scatter is not enabled. They should all be dropped.
+	 */
+	receive_packets(port_id, mbufs, num_pkts, &received);
+	rte_pktmbuf_free_bulk(mbufs, received);
+
+	ret = rte_eth_stats_get(port_id, &stats);
+	TEST_ASSERT(ret == 0, "Failed to get stats");
+
+	printf("  Received %u packets, errors=%" PRIu64 "\n",
+	       received, stats.ierrors);
+
+	TEST_ASSERT_EQUAL(received, 0U,
+			  "Expected 0 received packets without scatter, got %u",
+			  received);
+	TEST_ASSERT_EQUAL(stats.ierrors, (uint64_t)num_pkts,
+			  "Expected %u errors for oversized packets, got %" PRIu64,
+			  num_pkts, stats.ierrors);
+
+	cleanup_pcap_vdev("net_pcap_scat_drop", port_id);
+	remove_temp_file(rx_pcap_path);
+
+	printf("Scatter drop oversized PASSED: %" PRIu64 " packets dropped\n",
+	       stats.ierrors);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo packets are scattered when scatter is enabled
+ *
+ * With scatter enabled and a normal mempool, read jumbo-sized packets
+ * from a pcap file. Verify they arrive as multi-segment mbufs with
+ * correct total length.
+ */
+static int
+test_scatter_jumbo_rx(void)
+{
+	struct rte_mbuf *mbufs[NUM_PACKETS];
+	struct rte_eth_conf port_conf;
+	char rx_pcap_path[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	unsigned int received, i;
+	unsigned int multiseg_count = 0;
+	int ret;
+	const unsigned int num_pkts = 16;
+
+	printf("Testing scatter: jumbo RX with scatter enabled\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_scat_jumbo") == 0,
+		    "Failed to create temp file path");
+	TEST_ASSERT(create_sized_pcap(rx_pcap_path, num_pkts,
+				      PKT_SIZE_JUMBO) == 0,
+		    "Failed to create jumbo pcap file");
+
+	ret = snprintf(devargs, sizeof(devargs), "rx_pcap=%s", rx_pcap_path);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	ret = rte_vdev_init("net_pcap_scat_jumbo", devargs);
+	TEST_ASSERT(ret == 0, "Failed to create vdev: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_scat_jumbo", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+
+	/* Configure WITH scatter enabled */
+	memset(&port_conf, 0, sizeof(port_conf));
+	port_conf.rxmode.offloads = RTE_ETH_RX_OFFLOAD_SCATTER;
+	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
+	TEST_ASSERT(ret == 0, "Failed to configure port: %s", rte_strerror(-ret));
+
+	ret = rte_eth_rx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL, mp);
+	TEST_ASSERT(ret == 0, "rx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_tx_queue_setup(port_id, 0, RING_SIZE, SOCKET0, NULL);
+	TEST_ASSERT(ret == 0, "tx_queue_setup failed: %s", rte_strerror(-ret));
+
+	ret = rte_eth_dev_start(port_id);
+	TEST_ASSERT(ret == 0, "Failed to start port: %s", rte_strerror(-ret));
+
+	receive_packets(port_id, mbufs, num_pkts, &received);
+	TEST_ASSERT_EQUAL(received, num_pkts,
+			  "Received %u packets, expected %u", received, num_pkts);
+
+	for (i = 0; i < received; i++) {
+		uint32_t pkt_len = rte_pktmbuf_pkt_len(mbufs[i]);
+		uint16_t nb_segs = mbufs[i]->nb_segs;
+
+		TEST_ASSERT_EQUAL(pkt_len, PKT_SIZE_JUMBO,
+				  "Packet %u: size %u, expected %u",
+				  i, pkt_len, PKT_SIZE_JUMBO);
+
+		if (nb_segs > 1)
+			multiseg_count++;
+	}
+
+	rte_pktmbuf_free_bulk(mbufs, received);
+	cleanup_pcap_vdev("net_pcap_scat_jumbo", port_id);
+	remove_temp_file(rx_pcap_path);
+
+	/* Jumbo packets should require multiple segments */
+	TEST_ASSERT(multiseg_count > 0,
+		    "Expected multi-segment mbufs for jumbo packets");
+
+	printf("Scatter jumbo RX PASSED: %u/%u packets were multi-segment\n",
+	       multiseg_count, received);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Asymmetric rx_iface/tx_iface mode
+ *
+ * Verifies that the rx_iface= and tx_iface= devargs work when
+ * specified separately, which exercises a distinct code path from
+ * the symmetric iface= mode.
+ */
+static int
+test_rx_tx_iface(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_tx, nb_pkt;
+
+	printf("Testing asymmetric rx_iface/tx_iface mode\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_iface=%s,tx_iface=%s", iface, iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_rxtx_iface", devargs) < 0) {
+		printf("Cannot create rx_iface/tx_iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_rxtx_iface", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Transmit some packets to verify TX path works */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	/* RX burst to exercise the receive path (may or may not get packets) */
+	{
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+		if (nb_rx > 0)
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+	}
+
+	cleanup_pcap_vdev("net_pcap_rxtx_iface", port_id);
+
+	printf("rx_iface/tx_iface PASSED: sent %d packets\n", nb_tx);
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: rx_iface_in direction filtering
+ *
+ * Verifies that rx_iface_in= sets pcap direction to PCAP_D_IN,
+ * which filters out outgoing packets. This exercises the
+ * set_iface_direction() code path and PCAP_D_IN filtering.
+ */
+static int
+test_rx_iface_in(void)
+{
+	struct rte_mbuf *mbufs[MAX_PKT_BURST];
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret, nb_pkt, nb_tx;
+
+	printf("Testing rx_iface_in direction filtering\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_iface_in=%s,tx_iface=%s", iface, iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_iface_in", devargs) < 0) {
+		printf("Cannot create rx_iface_in vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_iface_in", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/*
+	 * Send packets on the TX side. With rx_iface_in (PCAP_D_IN),
+	 * our own transmitted packets should NOT appear on the RX side
+	 * because they are outgoing, not incoming.
+	 */
+	nb_pkt = generate_test_packets(mp, mbufs, MAX_PKT_BURST,
+				       PACKET_BURST_GEN_PKT_LEN);
+	TEST_ASSERT(nb_pkt > 0, "Failed to generate packets");
+
+	nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, nb_pkt);
+	if (nb_tx < nb_pkt)
+		rte_pktmbuf_free_bulk(&mbufs[nb_tx], nb_pkt - nb_tx);
+
+	/* Small delay then try to receive - should get 0 (our own TX filtered) */
+	usleep(50 * 1000);
+	{
+		uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, mbufs, MAX_PKT_BURST);
+		if (nb_rx > 0) {
+			printf("  Note: received %u packets (external traffic present)\n",
+			       nb_rx);
+			rte_pktmbuf_free_bulk(mbufs, nb_rx);
+		} else {
+			printf("  No packets received (TX correctly filtered by PCAP_D_IN)\n");
+		}
+	}
+
+	cleanup_pcap_vdev("net_pcap_iface_in", port_id);
+
+	printf("rx_iface_in PASSED: direction filtering exercised\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: Per-queue start and stop
+ *
+ * Verifies that rx_queue_start/stop and tx_queue_start/stop API calls
+ * succeed and return correct status. Note: the pcap PMD burst functions
+ * do not check queue state in the fast path, so this test validates
+ * the API plumbing rather than burst-level gating.
+ */
+static int
+test_queue_start_stop(void)
+{
+	char rx_pcap_path[PATH_MAX];
+	char tx_pcap_path_local[PATH_MAX];
+	char devargs[256];
+	uint16_t port_id;
+	int ret;
+
+	printf("Testing per-queue start/stop\n");
+
+	TEST_ASSERT(create_temp_path(rx_pcap_path, sizeof(rx_pcap_path),
+				     "pcap_qss_rx") == 0,
+		    "Failed to create RX temp path");
+	TEST_ASSERT(create_temp_path(tx_pcap_path_local, sizeof(tx_pcap_path_local),
+				     "pcap_qss_tx") == 0,
+		    "Failed to create TX temp path");
+	TEST_ASSERT(create_test_pcap(rx_pcap_path, NUM_PACKETS) == 0,
+		    "Failed to create test pcap");
+
+	ret = snprintf(devargs, sizeof(devargs),
+		       "rx_pcap=%s,tx_pcap=%s", rx_pcap_path, tx_pcap_path_local);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	TEST_ASSERT(create_pcap_vdev("net_pcap_qss", devargs, &port_id) == 0,
+		    "Failed to create vdev");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Stop RX queue */
+	ret = rte_eth_dev_rx_queue_stop(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to stop RX queue: %s", rte_strerror(-ret));
+
+	/* Restart RX queue */
+	ret = rte_eth_dev_rx_queue_start(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to start RX queue: %s", rte_strerror(-ret));
+
+	/* Stop TX queue */
+	ret = rte_eth_dev_tx_queue_stop(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to stop TX queue: %s", rte_strerror(-ret));
+
+	/* Restart TX queue */
+	ret = rte_eth_dev_tx_queue_start(port_id, 0);
+	TEST_ASSERT(ret == 0, "Failed to start TX queue: %s", rte_strerror(-ret));
+
+	/* Verify burst still works after stop/start cycle */
+	{
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		unsigned int received;
+
+		receive_packets(port_id, mbufs, NUM_PACKETS, &received);
+		TEST_ASSERT(received > 0,
+			    "Expected packets after queue stop/start cycle, got 0");
+		rte_pktmbuf_free_bulk(mbufs, received);
+	}
+
+	{
+		struct rte_mbuf *mbufs[1];
+
+		TEST_ASSERT(alloc_test_mbufs(mbufs, 1) == 0,
+			    "Failed to allocate mbufs");
+		int nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, 1);
+		TEST_ASSERT_EQUAL(nb_tx, 1,
+				  "TX after queue stop/start cycle failed: sent %d/1",
+				  nb_tx);
+	}
+
+	cleanup_pcap_vdev("net_pcap_qss", port_id);
+	remove_temp_file(rx_pcap_path);
+	remove_temp_file(tx_pcap_path_local);
+
+	printf("Per-queue start/stop PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test: imissed statistic in interface mode
+ *
+ * Verifies that the imissed counter (based on pcap_stats kernel drops)
+ * is accessible and starts at zero after stats reset. Kernel-level
+ * drops are hard to trigger deterministically, so this test validates
+ * the counter plumbing rather than forcing drops.
+ */
+static int
+test_imissed_stat(void)
+{
+	struct rte_eth_stats stats;
+	char devargs[256];
+	uint16_t port_id;
+	const char *iface;
+	int ret;
+
+	printf("Testing imissed statistic\n");
+
+	iface = find_test_iface();
+	if (iface == NULL) {
+		printf("No suitable interface, skipping\n");
+		return TEST_SKIPPED;
+	}
+	printf("Using interface: %s\n", iface);
+
+	ret = snprintf(devargs, sizeof(devargs), "iface=%s", iface);
+	TEST_ASSERT(ret > 0 && ret < (int)sizeof(devargs),
+		    "devargs string truncated");
+	if (rte_vdev_init("net_pcap_imissed", devargs) < 0) {
+		printf("Cannot create iface vdev (needs root?), skipping\n");
+		return TEST_SKIPPED;
+	}
+
+	ret = rte_eth_dev_get_port_by_name("net_pcap_imissed", &port_id);
+	TEST_ASSERT(ret == 0, "Failed to get port ID");
+	TEST_ASSERT(setup_pcap_port(port_id) == 0,
+		    "Failed to setup port");
+
+	/* Reset stats and verify imissed starts at zero */
+	ret = rte_eth_stats_reset(port_id);
+	TEST_ASSERT(ret == 0, "Failed to reset stats");
+
+	ret = rte_eth_stats_get(port_id, &stats);
+	TEST_ASSERT(ret == 0, "Failed to get stats");
+
+	TEST_ASSERT_EQUAL(stats.imissed, 0U,
+			  "imissed should be 0 after reset, got %"PRIu64,
+			  stats.imissed);
+
+	/* Do some RX bursts to exercise the pcap_stats path */
+	{
+		struct rte_mbuf *mbufs[MAX_PKT_BURST];
+		int attempts;
+
+		for (attempts = 0; attempts < 5; attempts++) {
+			uint16_t nb_rx = rte_eth_rx_burst(port_id, 0,
+							  mbufs, MAX_PKT_BURST);
+			if (nb_rx > 0)
+				rte_pktmbuf_free_bulk(mbufs, nb_rx);
+		}
+	}
+
+	/* Query stats again - imissed should still be queryable */
+	ret = rte_eth_stats_get(port_id, &stats);
+	TEST_ASSERT(ret == 0, "Failed to get stats after RX");
+	printf("  imissed=%"PRIu64" (kernel drops via pcap_stats)\n",
+	       stats.imissed);
+
+	cleanup_pcap_vdev("net_pcap_imissed", port_id);
+
+	printf("imissed stat PASSED\n");
+	return TEST_SUCCESS;
+}
+
+/*
+ * Test suite teardown
+ */
+static void
+test_teardown(void)
+{
+	/* Cleanup shared temp files */
+	remove_temp_file(tx_pcap_path);
+	remove_temp_file(vlan_rx_pcap_path);
+
+	rte_mempool_free(mp);
+	mp = NULL;
+}
+
+static struct unit_test_suite test_pmd_pcap_suite = {
+	.setup = test_setup,
+	.teardown = test_teardown,
+	.suite_name = "PCAP PMD Unit Test Suite",
+	.unit_test_cases = {
+		TEST_CASE(test_dev_info),
+		TEST_CASE(test_tx_to_file),
+		TEST_CASE(test_rx_from_file),
+		TEST_CASE(test_tx_varied_sizes),
+		TEST_CASE(test_rx_varied_sizes),
+		TEST_CASE(test_jumbo_rx),
+		TEST_CASE(test_jumbo_tx),
+		TEST_CASE(test_infinite_rx),
+		TEST_CASE(test_tx_drop),
+		TEST_CASE(test_stats),
+		TEST_CASE(test_iface),
+		TEST_CASE(test_link_status),
+		TEST_CASE(test_lsc_iface),
+		TEST_CASE(test_eof_rx),
+		TEST_CASE(test_rx_timestamp),
+		TEST_CASE(test_multi_tx_queue),
+		TEST_CASE(test_multi_rx_queue_same_file),
+		TEST_CASE(test_vlan_strip_rx),
+		TEST_CASE(test_vlan_insert_tx),
+		TEST_CASE(test_vlan_no_strip_rx),
+		TEST_CASE(test_vlan_offload_set),
+		TEST_CASE(test_vlan_strip_infinite_rx),
+		TEST_CASE(test_timestamp_infinite_rx),
+		TEST_CASE(test_snaplen),
+		TEST_CASE(test_snaplen_truncation),
+		TEST_CASE(test_snaplen_truncation_multiseg),
+		TEST_CASE(test_scatter_drop_oversized),
+		TEST_CASE(test_scatter_jumbo_rx),
+		TEST_CASE(test_rx_tx_iface),
+		TEST_CASE(test_rx_iface_in),
+		TEST_CASE(test_queue_start_stop),
+		TEST_CASE(test_imissed_stat),
+
+		TEST_CASES_END()
+	}
+};
+
+static int
+test_pmd_pcap(void)
+{
+	return unit_test_suite_runner(&test_pmd_pcap_suite);
+}
+
+REGISTER_FAST_TEST(pcap_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_pcap);
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 6752cf599a..8199149792 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -145,6 +145,7 @@ New Features
   * Added support for Link State interrupt in ``iface`` mode.
   * Added ``eof`` devarg to use link state to signal end of receive
     file input.
+  * Added unit test suite.
 
 
 Removed Items
-- 
2.53.0

RE: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Morten Brørup]

> From: Stephen Hemminger [mailto:stephen@networkplumber.org]
> Sent: Tuesday, 24 March 2026 18.12
> 
> On Mon, 16 Mar 2026 16:55:29 +0100
> Morten Brørup <mb@smartsharesystems.com> wrote:
> 
> > >
> > > This is an example of something I previously flagged. Like with
> real
> > > hardware, I think the PMD should be inserting the VLAN tag into the
> > > packet
> > > as part of the Tx function, not the prepare function.
> >
> > Agree with Bruce on this.
> > For simple stuff like VLAN offload, applications should not be
> required to call tx_prep first.
> >
> > However, the Tx function is supposed to not modify the packets;
> relevant when refcnt > 1.
> >
> > Instead of modifying the packet data to insert/strip the VLAN tag,
> > perhaps the driver can split the write/read operation into multiple
> write/read operations:
> > 1. the Ethernet header
> > 2. the VLAN tag
> > 3. the remaining packet data
> >
> > I haven't really followed the pcap driver, so maybe my suggestion
> doesn't make sense.
> 
> The prepare code and VLAN was copied from virtio.
> I assume virtio is widely used already.

OK, that makes it harder to object to.

<rant>

I checked out the virtio code.
virtio_xmit_pkts_prepare() calls rte_vlan_insert().
And rte_vlan_insert() doesn't support mbuf refcnt > 1.

So basically, these drivers don't support simple VLAN tagging when mbuf refcnt > 1.
This seems like a major limitation, which should be prominently documented.

A decade ago, when we started using DPDK for our projects, one of the things I loved about it was its documentation.
But after a while, I noticed that a lot of the documented mbuf library features weren't fully implemented.
These limitations should be documented.

E.g. if an important driver like virtio doesn't support VLAN tagging of indirect/cloned mbufs, this should be prominently highlighted in documentation!

</rant>

Re: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Bruce Richardson]

On Wed, Mar 25, 2026 at 08:41:39AM +0100, Morten Brørup wrote:
> > From: Stephen Hemminger [mailto:stephen@networkplumber.org]
> > Sent: Tuesday, 24 March 2026 18.12
> > 
> > On Mon, 16 Mar 2026 16:55:29 +0100
> > Morten Brørup <mb@smartsharesystems.com> wrote:
> > 
> > > >
> > > > This is an example of something I previously flagged. Like with
> > real
> > > > hardware, I think the PMD should be inserting the VLAN tag into the
> > > > packet
> > > > as part of the Tx function, not the prepare function.
> > >
> > > Agree with Bruce on this.
> > > For simple stuff like VLAN offload, applications should not be
> > required to call tx_prep first.
> > >
> > > However, the Tx function is supposed to not modify the packets;
> > relevant when refcnt > 1.
> > >
> > > Instead of modifying the packet data to insert/strip the VLAN tag,
> > > perhaps the driver can split the write/read operation into multiple
> > write/read operations:
> > > 1. the Ethernet header
> > > 2. the VLAN tag
> > > 3. the remaining packet data
> > >
> > > I haven't really followed the pcap driver, so maybe my suggestion
> > doesn't make sense.
> > 
> > The prepare code and VLAN was copied from virtio.
> > I assume virtio is widely used already.
> 
> OK, that makes it harder to object to.
> 

Yes, but I also believe that the topic was not previously discussed and
that the virtio driver may be wrong in how it behaves.

I still think, for consistency with HW drivers, SW drivers should do the
tagging in the Tx function.

I also think that we should provide a DPDK-lib level helper function (be it in
ethdev or elsewhere) for doing this sort of thing for all drivers. That way
we can put in the necessary copying of packets with refcnt > 1 and have it
apply globally.

/Bruce

RE: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Morten Brørup]

> From: Bruce Richardson [mailto:bruce.richardson@intel.com]
> Sent: Wednesday, 25 March 2026 10.13
> 
> On Wed, Mar 25, 2026 at 08:41:39AM +0100, Morten Brørup wrote:
> > > From: Stephen Hemminger [mailto:stephen@networkplumber.org]
> > > Sent: Tuesday, 24 March 2026 18.12
> > >
> > > On Mon, 16 Mar 2026 16:55:29 +0100
> > > Morten Brørup <mb@smartsharesystems.com> wrote:
> > >
> > > > >
> > > > > This is an example of something I previously flagged. Like with
> > > real
> > > > > hardware, I think the PMD should be inserting the VLAN tag into
> the
> > > > > packet
> > > > > as part of the Tx function, not the prepare function.
> > > >
> > > > Agree with Bruce on this.
> > > > For simple stuff like VLAN offload, applications should not be
> > > required to call tx_prep first.
> > > >
> > > > However, the Tx function is supposed to not modify the packets;
> > > relevant when refcnt > 1.
> > > >
> > > > Instead of modifying the packet data to insert/strip the VLAN
> tag,
> > > > perhaps the driver can split the write/read operation into
> multiple
> > > write/read operations:
> > > > 1. the Ethernet header
> > > > 2. the VLAN tag
> > > > 3. the remaining packet data
> > > >
> > > > I haven't really followed the pcap driver, so maybe my suggestion
> > > doesn't make sense.
> > >
> > > The prepare code and VLAN was copied from virtio.
> > > I assume virtio is widely used already.
> >
> > OK, that makes it harder to object to.
> >
> 
> Yes, but I also believe that the topic was not previously discussed and
> that the virtio driver may be wrong in how it behaves.
> 
> I still think, for consistency with HW drivers, SW drivers should do
> the
> tagging in the Tx function.

+1

> 
> I also think that we should provide a DPDK-lib level helper function
> (be it in
> ethdev or elsewhere) for doing this sort of thing for all drivers. That
> way
> we can put in the necessary copying of packets with refcnt > 1 and have
> it
> apply globally.

If an application clones packets instead of copying them, it is probably for performance reasons.
If the drivers start copying those clones, it may defeat the performance purpose.

<brainstorming>
Maybe segmentation can be used instead of copying the full packet:
Make the "copy" packet of two (or more) segments, where the header is copied into a new mbuf (where the VLAN tag is added), and the remaining part of the packet uses an indirect mbuf referring to the "original" packet at the offset after the header.
</brainstorming>

Furthermore...
If drivers start copying packets in the Tx function, the Tx queue should have its own mbuf pool to allocate these mbufs from.
Drivers should not steal mbufs from the pools used by the packets being transmitted.
E.g. if a segmented packet has a small mbuf for the first few bytes, followed by a large mbuf (from another pool) for the remaining bytes.
Or if the "original" mbuf comes from a mempool allocated on different CPU socket, the "copy" would too.

> 
> /Bruce

Re: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Bruce Richardson]

On Wed, Mar 25, 2026 at 10:36:56AM +0100, Morten Brørup wrote:
> > From: Bruce Richardson [mailto:bruce.richardson@intel.com]
> > Sent: Wednesday, 25 March 2026 10.13
> > 
> > On Wed, Mar 25, 2026 at 08:41:39AM +0100, Morten Brørup wrote:
> > > > From: Stephen Hemminger [mailto:stephen@networkplumber.org]
> > > > Sent: Tuesday, 24 March 2026 18.12
> > > >
> > > > On Mon, 16 Mar 2026 16:55:29 +0100
> > > > Morten Brørup <mb@smartsharesystems.com> wrote:
> > > >
> > > > > >
> > > > > > This is an example of something I previously flagged. Like with
> > > > real
> > > > > > hardware, I think the PMD should be inserting the VLAN tag into
> > the
> > > > > > packet
> > > > > > as part of the Tx function, not the prepare function.
> > > > >
> > > > > Agree with Bruce on this.
> > > > > For simple stuff like VLAN offload, applications should not be
> > > > required to call tx_prep first.
> > > > >
> > > > > However, the Tx function is supposed to not modify the packets;
> > > > relevant when refcnt > 1.
> > > > >
> > > > > Instead of modifying the packet data to insert/strip the VLAN
> > tag,
> > > > > perhaps the driver can split the write/read operation into
> > multiple
> > > > write/read operations:
> > > > > 1. the Ethernet header
> > > > > 2. the VLAN tag
> > > > > 3. the remaining packet data
> > > > >
> > > > > I haven't really followed the pcap driver, so maybe my suggestion
> > > > doesn't make sense.
> > > >
> > > > The prepare code and VLAN was copied from virtio.
> > > > I assume virtio is widely used already.
> > >
> > > OK, that makes it harder to object to.
> > >
> > 
> > Yes, but I also believe that the topic was not previously discussed and
> > that the virtio driver may be wrong in how it behaves.
> > 
> > I still think, for consistency with HW drivers, SW drivers should do
> > the
> > tagging in the Tx function.
> 
> +1
> 
> > 
> > I also think that we should provide a DPDK-lib level helper function
> > (be it in
> > ethdev or elsewhere) for doing this sort of thing for all drivers. That
> > way
> > we can put in the necessary copying of packets with refcnt > 1 and have
> > it
> > apply globally.
> 
> If an application clones packets instead of copying them, it is probably for performance reasons.
> If the drivers start copying those clones, it may defeat the performance purpose.
> 
> <brainstorming>
> Maybe segmentation can be used instead of copying the full packet:
> Make the "copy" packet of two (or more) segments, where the header is copied into a new mbuf (where the VLAN tag is added), and the remaining part of the packet uses an indirect mbuf referring to the "original" packet at the offset after the header.
> </brainstorming>
> 
> Furthermore...
> If drivers start copying packets in the Tx function, the Tx queue should have its own mbuf pool to allocate these mbufs from.
> Drivers should not steal mbufs from the pools used by the packets being transmitted.
> E.g. if a segmented packet has a small mbuf for the first few bytes, followed by a large mbuf (from another pool) for the remaining bytes.
> Or if the "original" mbuf comes from a mempool allocated on different CPU socket, the "copy" would too.
> 
Yes, agree on using a chain of buffers for Tx in this case. Not bothered
much either way about the separate mempool.

/Bruce

Re: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Stephen Hemminger]

On Wed, 25 Mar 2026 10:36:56 +0100
Morten Brørup <mb@smartsharesystems.com> wrote:

> If an application clones packets instead of copying them, it is probably for performance reasons.
> If the drivers start copying those clones, it may defeat the performance purpose.
> 
> <brainstorming>
> Maybe segmentation can be used instead of copying the full packet:
> Make the "copy" packet of two (or more) segments, where the header is copied into a new mbuf (where the VLAN tag is added), and the remaining part of the packet uses an indirect mbuf referring to the "original" packet at the offset after the header.
> </brainstorming>
> 
> Furthermore...
> If drivers start copying packets in the Tx function, the Tx queue should have its own mbuf pool to allocate these mbufs from.
> Drivers should not steal mbufs from the pools used by the packets being transmitted.
> E.g. if a segmented packet has a small mbuf for the first few bytes, followed by a large mbuf (from another pool) for the remaining bytes.
> Or if the "original" mbuf comes from a mempool allocated on different CPU socket, the "copy" would too.


The problem with the Tx function is how backpressure gets handled.
Not sure that it is documented well enough that if a packet is not sent
due to backpressure, the mbuf in the array may still have been replaced.

Re: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Bruce Richardson]

On Wed, Mar 25, 2026 at 09:19:21AM -0700, Stephen Hemminger wrote:
> On Wed, 25 Mar 2026 10:36:56 +0100
> Morten Brørup <mb@smartsharesystems.com> wrote:
> 
> > If an application clones packets instead of copying them, it is probably for performance reasons.
> > If the drivers start copying those clones, it may defeat the performance purpose.
> > 
> > <brainstorming>
> > Maybe segmentation can be used instead of copying the full packet:
> > Make the "copy" packet of two (or more) segments, where the header is copied into a new mbuf (where the VLAN tag is added), and the remaining part of the packet uses an indirect mbuf referring to the "original" packet at the offset after the header.
> > </brainstorming>
> > 
> > Furthermore...
> > If drivers start copying packets in the Tx function, the Tx queue should have its own mbuf pool to allocate these mbufs from.
> > Drivers should not steal mbufs from the pools used by the packets being transmitted.
> > E.g. if a segmented packet has a small mbuf for the first few bytes, followed by a large mbuf (from another pool) for the remaining bytes.
> > Or if the "original" mbuf comes from a mempool allocated on different CPU socket, the "copy" would too.
> 
> 
> The problem with the Tx function is how backpressure gets handled.
> Not sure that it is documented well enough that if a packet is not sent
> due to backpressure, the mbuf in the array may still have been replaced.

Most drivers should be able to check for space in a Tx ring, or whatever
other backpressure mechanism is being used, before modifying a buffer.

/Bruce

Re: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Stephen Hemminger]

On Wed, 25 Mar 2026 16:22:45 +0000
Bruce Richardson <bruce.richardson@intel.com> wrote:

> On Wed, Mar 25, 2026 at 09:19:21AM -0700, Stephen Hemminger wrote:
> > On Wed, 25 Mar 2026 10:36:56 +0100
> > Morten Brørup <mb@smartsharesystems.com> wrote:
> >   
> > > If an application clones packets instead of copying them, it is probably for performance reasons.
> > > If the drivers start copying those clones, it may defeat the performance purpose.
> > > 
> > > <brainstorming>
> > > Maybe segmentation can be used instead of copying the full packet:
> > > Make the "copy" packet of two (or more) segments, where the header is copied into a new mbuf (where the VLAN tag is added), and the remaining part of the packet uses an indirect mbuf referring to the "original" packet at the offset after the header.
> > > </brainstorming>
> > > 
> > > Furthermore...
> > > If drivers start copying packets in the Tx function, the Tx queue should have its own mbuf pool to allocate these mbufs from.
> > > Drivers should not steal mbufs from the pools used by the packets being transmitted.
> > > E.g. if a segmented packet has a small mbuf for the first few bytes, followed by a large mbuf (from another pool) for the remaining bytes.
> > > Or if the "original" mbuf comes from a mempool allocated on different CPU socket, the "copy" would too.  
> > 
> > 
> > The problem with the Tx function is how backpressure gets handled.
> > Not sure that it is documented well enough that if a packet is not sent
> > due to backpressure, the mbuf in the array may still have been replaced.  
> 
> Most drivers should be able to check for space in a Tx ring, or whatever
> other backpressure mechanism is being used, before modifying a buffer.
> 
> /Bruce

Not in case of drivers that need syscall to push packets.

Re: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Stephen Hemminger]

On Wed, 25 Mar 2026 09:12:38 +0000
Bruce Richardson <bruce.richardson@intel.com> wrote:

> On Wed, Mar 25, 2026 at 08:41:39AM +0100, Morten Brørup wrote:
> > > From: Stephen Hemminger [mailto:stephen@networkplumber.org]
> > > Sent: Tuesday, 24 March 2026 18.12
> > > 
> > > On Mon, 16 Mar 2026 16:55:29 +0100
> > > Morten Brørup <mb@smartsharesystems.com> wrote:
> > >   
> > > > >
> > > > > This is an example of something I previously flagged. Like with  
> > > real  
> > > > > hardware, I think the PMD should be inserting the VLAN tag into the
> > > > > packet
> > > > > as part of the Tx function, not the prepare function.  
> > > >
> > > > Agree with Bruce on this.
> > > > For simple stuff like VLAN offload, applications should not be  
> > > required to call tx_prep first.  
> > > >
> > > > However, the Tx function is supposed to not modify the packets;  
> > > relevant when refcnt > 1.  
> > > >
> > > > Instead of modifying the packet data to insert/strip the VLAN tag,
> > > > perhaps the driver can split the write/read operation into multiple  
> > > write/read operations:  
> > > > 1. the Ethernet header
> > > > 2. the VLAN tag
> > > > 3. the remaining packet data
> > > >
> > > > I haven't really followed the pcap driver, so maybe my suggestion  
> > > doesn't make sense.
> > > 
> > > The prepare code and VLAN was copied from virtio.
> > > I assume virtio is widely used already.  
> > 
> > OK, that makes it harder to object to.
> >   
> 
> Yes, but I also believe that the topic was not previously discussed and
> that the virtio driver may be wrong in how it behaves.
> 
> I still think, for consistency with HW drivers, SW drivers should do the
> tagging in the Tx function.
> 
> I also think that we should provide a DPDK-lib level helper function (be it in
> ethdev or elsewhere) for doing this sort of thing for all drivers. That way
> we can put in the necessary copying of packets with refcnt > 1 and have it
> apply globally.
> 
> /Bruce

Virtio also requires tx_prepare if doing any form of segmentation offload.

If this is not ok, it should be put somewhere in the docs and virtio fixed.

Re: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Bruce Richardson]

On Wed, Mar 25, 2026 at 09:52:37AM -0700, Stephen Hemminger wrote:
> On Wed, 25 Mar 2026 16:22:45 +0000
> Bruce Richardson <bruce.richardson@intel.com> wrote:
> 
> > On Wed, Mar 25, 2026 at 09:19:21AM -0700, Stephen Hemminger wrote:
> > > On Wed, 25 Mar 2026 10:36:56 +0100
> > > Morten Brørup <mb@smartsharesystems.com> wrote:
> > >   
> > > > If an application clones packets instead of copying them, it is probably for performance reasons.
> > > > If the drivers start copying those clones, it may defeat the performance purpose.
> > > > 
> > > > <brainstorming>
> > > > Maybe segmentation can be used instead of copying the full packet:
> > > > Make the "copy" packet of two (or more) segments, where the header is copied into a new mbuf (where the VLAN tag is added), and the remaining part of the packet uses an indirect mbuf referring to the "original" packet at the offset after the header.
> > > > </brainstorming>
> > > > 
> > > > Furthermore...
> > > > If drivers start copying packets in the Tx function, the Tx queue should have its own mbuf pool to allocate these mbufs from.
> > > > Drivers should not steal mbufs from the pools used by the packets being transmitted.
> > > > E.g. if a segmented packet has a small mbuf for the first few bytes, followed by a large mbuf (from another pool) for the remaining bytes.
> > > > Or if the "original" mbuf comes from a mempool allocated on different CPU socket, the "copy" would too.  
> > > 
> > > 
> > > The problem with the Tx function is how backpressure gets handled.
> > > Not sure that it is documented well enough that if a packet is not sent
> > > due to backpressure, the mbuf in the array may still have been replaced.  
> > 
> > Most drivers should be able to check for space in a Tx ring, or whatever
> > other backpressure mechanism is being used, before modifying a buffer.
> > 
> > /Bruce
> 
> Not in case of drivers that need syscall to push packets.

Modifications will have to be rolled back in that case. Alternatively, the
driver just doesn't offer the offload, which is IMHO a perfectly reasonable
approach to take.

/Bruce

Re: [PATCH v20 25/25] app/pdump: preserve VLAN tags in captured packets

[Stephen Hemminger]

On Wed, 25 Mar 2026 16:22:45 +0000
Bruce Richardson <bruce.richardson@intel.com> wrote:

> On Wed, Mar 25, 2026 at 09:19:21AM -0700, Stephen Hemminger wrote:
> > On Wed, 25 Mar 2026 10:36:56 +0100
> > Morten Brørup <mb@smartsharesystems.com> wrote:
> >   
> > > If an application clones packets instead of copying them, it is probably for performance reasons.
> > > If the drivers start copying those clones, it may defeat the performance purpose.
> > > 
> > > <brainstorming>
> > > Maybe segmentation can be used instead of copying the full packet:
> > > Make the "copy" packet of two (or more) segments, where the header is copied into a new mbuf (where the VLAN tag is added), and the remaining part of the packet uses an indirect mbuf referring to the "original" packet at the offset after the header.
> > > </brainstorming>
> > > 
> > > Furthermore...
> > > If drivers start copying packets in the Tx function, the Tx queue should have its own mbuf pool to allocate these mbufs from.
> > > Drivers should not steal mbufs from the pools used by the packets being transmitted.
> > > E.g. if a segmented packet has a small mbuf for the first few bytes, followed by a large mbuf (from another pool) for the remaining bytes.
> > > Or if the "original" mbuf comes from a mempool allocated on different CPU socket, the "copy" would too.  
> > 
> > 
> > The problem with the Tx function is how backpressure gets handled.
> > Not sure that it is documented well enough that if a packet is not sent
> > due to backpressure, the mbuf in the array may still have been replaced.  
> 
> Most drivers should be able to check for space in a Tx ring, or whatever
> other backpressure mechanism is being used, before modifying a buffer.
> 
> /Bruce

The wording in tx_prepare documentation mentions checksums requirement but not vlans.