[PATCH] app/test: add standalone test for af_packet
Stephen Hemminger
stephen at networkplumber.org
Wed Mar 11 00:35:55 CET 2026
Recent updates ot af_packet prompted me to resubmit this.
I expect test will fail until jumbo support for AF_PACKET is merged.
Add comprehensive unit test suite for AF_PACKET PMD covering:
- Device info and link status
- TX/RX packet handling
- Loopback verification
- Promiscuous mode
- MAC address operations
- MTU configuration
- Statistics and reset
- Multi-threaded concurrent TX/RX
- Invalid configuration handling
- Multi-queue support
- Jumbo frame support (9K packets)
Uses TAP interface as the underlying device for testing.
Signed-off-by: Stephen Hemminger <stephen at networkplumber.org>
---
app/test/meson.build | 1 +
app/test/test_pmd_af_packet.c | 1356 +++++++++++++++++++++++++++++++++
2 files changed, 1357 insertions(+)
create mode 100644 app/test/test_pmd_af_packet.c
diff --git a/app/test/meson.build b/app/test/meson.build
index 7d458f9c07..24f71fb987 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_af_packet.c': ['net_af_packet', 'ethdev', 'bus_vdev'],
'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'],
diff --git a/app/test/test_pmd_af_packet.c b/app/test/test_pmd_af_packet.c
new file mode 100644
index 0000000000..3c2a3a4965
--- /dev/null
+++ b/app/test/test_pmd_af_packet.c
@@ -0,0 +1,1356 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2026 Stephen Hemminger
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <linux/if.h>
+#include <linux/if_tun.h>
+#include <linux/sockios.h>
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <rte_bus_vdev.h>
+#include <rte_config.h>
+#include <rte_cycles.h>
+#include <rte_ethdev.h>
+#include <rte_ether.h>
+#include <rte_lcore.h>
+#include <rte_mbuf.h>
+#include <rte_mempool.h>
+#include <rte_stdatomic.h>
+
+#include "test.h"
+
+#ifndef RTE_EXEC_ENV_LINUX
+static int
+test_pmd_af_packet(void)
+{
+ printf("af_packet only supported on Linux, skipping test\n");
+ return TEST_SKIPPED;
+}
+
+#else
+
+#define NUM_MBUFS 512
+#define MBUF_CACHE_SIZE 32
+#define BURST_SIZE 32
+#define RING_SIZE 256
+
+/* Polling and timeout constants */
+#define STATS_POLL_INTERVAL_US 100
+#define STATS_POLL_TIMEOUT_US 100000 /* 100ms overall timeout */
+#define LOOPBACK_TIMEOUT_US 500000 /* 500ms for loopback test */
+
+/* Multi-threaded test constants */
+#define MT_NUM_PACKETS 100
+#define MT_TEST_DURATION_SEC 2
+
+/* Jumbo frame test constants */
+#define JUMBO_FRAME_SIZE 9000
+#define JUMBO_FRAME_BLOCKSZ (1 << 14) /* 16384 */
+#define JUMBO_FRAME_FRAMESZ (1 << 14)
+
+/* Test device names */
+#define AF_PACKET_DEV_NAME "net_af_packet_test"
+#define TAP_DEV_NAME "dpdkafptest"
+
+static struct rte_mempool *mp;
+static uint16_t port_id = RTE_MAX_ETHPORTS;
+static int tap_fd = -1;
+static bool tap_created;
+static bool port_created;
+static bool port_started;
+
+/*
+ * Create a TAP interface for testing.
+ * Returns fd on success, -1 on failure.
+ */
+static int
+create_tap_interface(const char *name)
+{
+ struct ifreq ifr;
+ int fd, ret;
+
+ fd = open("/dev/net/tun", O_RDWR);
+ if (fd < 0) {
+ printf("Cannot open /dev/net/tun: %s\n", strerror(errno));
+ printf("(Are you running as root?)\n");
+ return -1;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
+ snprintf(ifr.ifr_name, IFNAMSIZ, "%s", name);
+
+ ret = ioctl(fd, TUNSETIFF, &ifr);
+ if (ret < 0) {
+ printf("Cannot create TAP interface '%s': %s\n",
+ name, strerror(errno));
+ close(fd);
+ return -1;
+ }
+
+ /* Bring the interface up */
+ int sock = socket(AF_INET, SOCK_DGRAM, 0);
+ if (sock >= 0) {
+ memset(&ifr, 0, sizeof(ifr));
+ snprintf(ifr.ifr_name, IFNAMSIZ, "%s", name);
+
+ /* Get current flags */
+ if (ioctl(sock, SIOCGIFFLAGS, &ifr) == 0) {
+ ifr.ifr_flags |= IFF_UP;
+ ioctl(sock, SIOCSIFFLAGS, &ifr);
+ }
+ close(sock);
+ }
+
+ printf("Created TAP interface '%s'\n", name);
+ return fd;
+}
+
+static void
+destroy_tap_interface(int fd)
+{
+ if (fd >= 0)
+ close(fd);
+}
+
+/*
+ * Set MTU on a network interface.
+ * Returns 0 on success, -1 on failure.
+ */
+static int
+set_tap_mtu(const char *name, uint16_t mtu)
+{
+ struct ifreq ifr;
+ int sock, ret;
+
+ sock = socket(AF_INET, SOCK_DGRAM, 0);
+ if (sock < 0)
+ return -1;
+
+ memset(&ifr, 0, sizeof(ifr));
+ snprintf(ifr.ifr_name, IFNAMSIZ, "%s", name);
+ ifr.ifr_mtu = mtu;
+
+ ret = ioctl(sock, SIOCSIFMTU, &ifr);
+ close(sock);
+
+ if (ret < 0) {
+ printf("Failed to set MTU %u on %s: %s\n",
+ mtu, name, strerror(errno));
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+create_af_packet_port(const char *name, const char *args, uint16_t *out_port_id)
+{
+ int ret;
+
+ ret = rte_vdev_init(name, args);
+ if (ret != 0) {
+ printf("Failed to create af_packet device '%s': %d\n", name, ret);
+ return ret;
+ }
+
+ ret = rte_eth_dev_get_port_by_name(name, out_port_id);
+ if (ret != 0) {
+ printf("Failed to get port id for '%s': %d\n", name, ret);
+ rte_vdev_uninit(name);
+ return ret;
+ }
+
+ return 0;
+}
+
+static int
+configure_af_packet_port(uint16_t pid, uint16_t nb_rx_q, uint16_t nb_tx_q)
+{
+ struct rte_eth_conf port_conf = {0};
+ struct rte_eth_dev_info dev_info;
+ int ret;
+ uint16_t q;
+
+ ret = rte_eth_dev_info_get(pid, &dev_info);
+ if (ret != 0) {
+ printf("Failed to get device info for port %u: %d\n", pid, ret);
+ return ret;
+ }
+
+ ret = rte_eth_dev_configure(pid, nb_rx_q, nb_tx_q, &port_conf);
+ if (ret != 0) {
+ printf("Failed to configure port %u: %d\n", pid, ret);
+ return ret;
+ }
+
+ for (q = 0; q < nb_rx_q; q++) {
+ ret = rte_eth_rx_queue_setup(pid, q, RING_SIZE,
+ rte_eth_dev_socket_id(pid),
+ NULL, mp);
+ if (ret != 0) {
+ printf("Failed to setup RX queue %u for port %u: %d\n",
+ q, pid, ret);
+ return ret;
+ }
+ }
+
+ for (q = 0; q < nb_tx_q; q++) {
+ ret = rte_eth_tx_queue_setup(pid, q, RING_SIZE,
+ rte_eth_dev_socket_id(pid),
+ NULL);
+ if (ret != 0) {
+ printf("Failed to setup TX queue %u for port %u: %d\n",
+ q, pid, ret);
+ return ret;
+ }
+ }
+
+ ret = rte_eth_dev_start(pid);
+ if (ret != 0) {
+ printf("Failed to start port %u: %d\n", pid, ret);
+ return ret;
+ }
+
+ return 0;
+}
+
+/*
+ * Helper: Allocate and prepare a burst of TX mbufs with minimal Ethernet frames.
+ * Returns the number of successfully allocated mbufs.
+ */
+static unsigned int
+alloc_tx_mbufs(struct rte_mbuf **bufs, unsigned int count)
+{
+ unsigned int i;
+ int ret;
+
+ ret = rte_pktmbuf_alloc_bulk(mp, bufs, count);
+ if (ret != 0)
+ return 0;
+
+ for (i = 0; i < count; i++) {
+ struct rte_ether_hdr *eth_hdr;
+ eth_hdr = (struct rte_ether_hdr *)rte_pktmbuf_append(bufs[i],
+ sizeof(struct rte_ether_hdr) + 46);
+ if (eth_hdr == NULL) {
+ /* Free all allocated mbufs on failure */
+ rte_pktmbuf_free_bulk(bufs, count);
+ return 0;
+ }
+
+ /* Set broadcast destination and zero source MAC */
+ memset(ð_hdr->dst_addr, 0xFF, RTE_ETHER_ADDR_LEN);
+ memset(ð_hdr->src_addr, 0x00, RTE_ETHER_ADDR_LEN);
+ eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+ }
+
+ return count;
+}
+
+/*
+ * Helper: Transmit packets and free unsent mbufs.
+ * Returns the number of packets successfully transmitted.
+ */
+static uint16_t
+do_tx_burst(uint16_t pid, uint16_t queue_id, struct rte_mbuf **bufs,
+ unsigned int count)
+{
+ uint16_t nb_tx;
+
+ nb_tx = rte_eth_tx_burst(pid, queue_id, bufs, count);
+
+ /* Free any unsent mbufs */
+ rte_pktmbuf_free_bulk(&bufs[nb_tx], count - nb_tx);
+
+ return nb_tx;
+}
+
+/*
+ * Helper: Receive packets and free received mbufs.
+ * Returns the number of packets received.
+ */
+static uint16_t
+do_rx_burst(uint16_t pid, uint16_t queue_id, struct rte_mbuf **bufs,
+ unsigned int count)
+{
+ uint16_t nb_rx;
+
+ nb_rx = rte_eth_rx_burst(pid, queue_id, bufs, count);
+ rte_pktmbuf_free_bulk(bufs, nb_rx);
+
+ return nb_rx;
+}
+
+/*
+ * Helper: Wait for stats to update by polling at intervals.
+ * Returns 0 on success (stats updated), -1 on timeout.
+ */
+static int
+wait_for_stats_update(uint16_t pid, uint64_t expected_opackets,
+ uint64_t timeout_us)
+{
+ struct rte_eth_stats stats;
+ uint64_t elapsed = 0;
+
+ while (elapsed < timeout_us) {
+ if (rte_eth_stats_get(pid, &stats) == 0) {
+ if (stats.opackets >= expected_opackets)
+ return 0;
+ }
+ rte_delay_us_block(STATS_POLL_INTERVAL_US);
+ elapsed += STATS_POLL_INTERVAL_US;
+ }
+
+ return -1;
+}
+
+static int
+test_af_packet_setup(void)
+{
+ char devargs[256];
+ int ret;
+
+ /* Create mempool for mbufs */
+ mp = rte_pktmbuf_pool_create("af_packet_test_pool", NUM_MBUFS,
+ MBUF_CACHE_SIZE, 0,
+ RTE_MBUF_DEFAULT_BUF_SIZE,
+ rte_socket_id());
+ if (mp == NULL) {
+ printf("Failed to create mempool\n");
+ return -1;
+ }
+
+ /* Create TAP interface for testing */
+ tap_fd = create_tap_interface(TAP_DEV_NAME);
+ if (tap_fd >= 0)
+ tap_created = true;
+ else {
+ printf("TAP interface creation failed - tests will be skipped\n");
+ return 0; /* Return success to allow skipped tests */
+ }
+
+ /* Create and configure af_packet port */
+ snprintf(devargs, sizeof(devargs), "iface=%s", TAP_DEV_NAME);
+ ret = create_af_packet_port(AF_PACKET_DEV_NAME, devargs, &port_id);
+ if (ret != 0) {
+ printf("Failed to create af_packet port\n");
+ return -1;
+ }
+ port_created = true;
+
+ ret = configure_af_packet_port(port_id, 1, 1);
+ if (ret != 0) {
+ printf("Failed to configure af_packet port\n");
+ return -1;
+ }
+ port_started = true;
+
+ return 0;
+}
+
+static void
+test_af_packet_teardown(void)
+{
+ /* Stop and close test port */
+ if (port_started) {
+ rte_eth_dev_stop(port_id);
+ port_started = false;
+ }
+
+ if (port_created) {
+ rte_eth_dev_close(port_id);
+ rte_vdev_uninit(AF_PACKET_DEV_NAME);
+ port_id = RTE_MAX_ETHPORTS;
+ port_created = false;
+ }
+
+ /* Destroy TAP interface */
+ if (tap_created) {
+ destroy_tap_interface(tap_fd);
+ tap_fd = -1;
+ tap_created = false;
+ }
+
+ if (mp != NULL) {
+ rte_mempool_free(mp);
+ mp = NULL;
+ }
+}
+
+/*
+ * Test: Device info verification
+ */
+static int
+test_af_packet_dev_info(void)
+{
+ struct rte_eth_dev_info dev_info;
+ int ret;
+
+ if (!tap_created || port_id >= RTE_MAX_ETHPORTS) {
+ printf("SKIPPED: Port not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ ret = rte_eth_dev_info_get(port_id, &dev_info);
+ TEST_ASSERT(ret == 0, "Failed to get device info");
+
+ /* Verify expected device info values */
+ TEST_ASSERT(dev_info.max_mac_addrs == 1,
+ "Expected max_mac_addrs=1, got %u", dev_info.max_mac_addrs);
+ TEST_ASSERT(dev_info.max_rx_pktlen >= RTE_ETHER_MAX_LEN,
+ "Unexpected max_rx_pktlen: %u (expected >= %u)",
+ dev_info.max_rx_pktlen, RTE_ETHER_MAX_LEN);
+ TEST_ASSERT(dev_info.min_rx_bufsize == 0,
+ "Expected min_rx_bufsize=0, got %u", dev_info.min_rx_bufsize);
+ TEST_ASSERT(dev_info.max_rx_queues >= 1, "No RX queues available");
+ TEST_ASSERT(dev_info.max_tx_queues >= 1, "No TX queues available");
+ TEST_ASSERT(dev_info.if_index > 0, "Invalid interface index");
+
+ /* Check TX offload capabilities */
+ TEST_ASSERT(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_MULTI_SEGS,
+ "Expected MULTI_SEGS TX offload capability");
+ TEST_ASSERT(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_VLAN_INSERT,
+ "Expected VLAN_INSERT TX offload capability");
+
+ /* Check RX offload capabilities */
+ TEST_ASSERT(dev_info.rx_offload_capa & RTE_ETH_RX_OFFLOAD_VLAN_STRIP,
+ "Expected VLAN_STRIP RX offload capability");
+ TEST_ASSERT(dev_info.rx_offload_capa & RTE_ETH_RX_OFFLOAD_TIMESTAMP,
+ "Expected TIMESTAMP RX offload capability");
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Link status
+ * Note: af_packet PMD link status reflects the underlying interface state,
+ * not the DPDK device start/stop state.
+ */
+static int
+test_af_packet_link_status(void)
+{
+ struct rte_eth_link link;
+ int ret;
+
+ if (!tap_created || port_id >= RTE_MAX_ETHPORTS) {
+ printf("SKIPPED: Port not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ ret = rte_eth_link_get_nowait(port_id, &link);
+ TEST_ASSERT(ret == 0, "Failed to get link status");
+
+ /* TAP interface was brought up during setup, so link should be UP */
+ TEST_ASSERT(link.link_status == RTE_ETH_LINK_UP,
+ "Expected link UP (TAP interface is up)");
+ TEST_ASSERT(link.link_speed == RTE_ETH_SPEED_NUM_10G,
+ "Expected 10G link speed");
+ TEST_ASSERT(link.link_duplex == RTE_ETH_LINK_FULL_DUPLEX,
+ "Expected full duplex");
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Statistics initial state
+ */
+static int
+test_af_packet_stats_init(void)
+{
+ struct rte_eth_stats stats;
+ int ret;
+
+ if (!tap_created || port_id >= RTE_MAX_ETHPORTS) {
+ printf("SKIPPED: Port not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Reset stats */
+ ret = rte_eth_stats_reset(port_id);
+ TEST_ASSERT(ret == 0, "Failed to reset stats");
+
+ /* Get initial stats */
+ ret = rte_eth_stats_get(port_id, &stats);
+ TEST_ASSERT(ret == 0, "Failed to get stats");
+
+ /* After reset, stats should be zero */
+ TEST_ASSERT(stats.ipackets == 0,
+ "Expected ipackets=0 after reset, got %"PRIu64,
+ stats.ipackets);
+ TEST_ASSERT(stats.opackets == 0,
+ "Expected opackets=0 after reset, got %"PRIu64,
+ stats.opackets);
+ TEST_ASSERT(stats.ibytes == 0,
+ "Expected ibytes=0 after reset, got %"PRIu64,
+ stats.ibytes);
+ TEST_ASSERT(stats.obytes == 0,
+ "Expected obytes=0 after reset, got %"PRIu64,
+ stats.obytes);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: TX packets (packets will be sent to TAP interface)
+ */
+static int
+test_af_packet_tx(void)
+{
+ struct rte_mbuf *bufs[BURST_SIZE];
+ struct rte_eth_stats stats;
+ uint16_t nb_tx;
+ unsigned int allocated;
+ int ret;
+
+ if (!tap_created || port_id >= RTE_MAX_ETHPORTS) {
+ printf("SKIPPED: Port not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Reset stats */
+ ret = rte_eth_stats_reset(port_id);
+ TEST_ASSERT(ret == 0, "Failed to reset stats");
+
+ /* Allocate and prepare mbufs for TX using helper */
+ allocated = alloc_tx_mbufs(bufs, BURST_SIZE);
+ TEST_ASSERT(allocated == BURST_SIZE, "Failed to allocate all mbufs");
+
+ /* TX burst using helper */
+ nb_tx = do_tx_burst(port_id, 0, bufs, BURST_SIZE);
+
+ /* Poll for stats update instead of fixed delay */
+ if (nb_tx > 0) {
+ ret = wait_for_stats_update(port_id, nb_tx, STATS_POLL_TIMEOUT_US);
+ if (ret == 0) {
+ ret = rte_eth_stats_get(port_id, &stats);
+ TEST_ASSERT(ret == 0, "Failed to get stats");
+ TEST_ASSERT(stats.opackets > 0,
+ "Expected opackets > 0 after TX");
+ }
+ /* Timeout is acceptable - stats may not update immediately */
+ }
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: RX packets (non-blocking, may not receive anything)
+ */
+static int
+test_af_packet_rx(void)
+{
+ struct rte_mbuf *bufs[BURST_SIZE];
+
+ if (!tap_created || port_id >= RTE_MAX_ETHPORTS) {
+ printf("SKIPPED: Port not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Try to receive packets (non-blocking) using helper */
+ do_rx_burst(port_id, 0, bufs, BURST_SIZE);
+
+ /* RX from tap interface without external traffic will return 0 */
+ /* This test just verifies the RX path doesn't crash */
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Loopback - TX packets and receive them back via TAP interface.
+ * This exercises both the TX and RX paths in a round-trip.
+ */
+static int
+test_af_packet_loopback(void)
+{
+ struct rte_mbuf *tx_bufs[BURST_SIZE];
+ struct rte_mbuf *rx_bufs[BURST_SIZE];
+ uint16_t nb_tx, total_rx = 0;
+ uint64_t elapsed = 0;
+ unsigned int allocated;
+ ssize_t bytes_read;
+ char tap_buf[2048];
+
+ if (!tap_created || port_id >= RTE_MAX_ETHPORTS) {
+ printf("SKIPPED: Port not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Set TAP fd to non-blocking for reading */
+ int flags = fcntl(tap_fd, F_GETFL, 0);
+ fcntl(tap_fd, F_SETFL, flags | O_NONBLOCK);
+
+ /* Allocate and send packets */
+ allocated = alloc_tx_mbufs(tx_bufs, BURST_SIZE);
+ if (allocated == 0) {
+ printf("SKIPPED: Could not allocate mbufs\n");
+ return TEST_SKIPPED;
+ }
+
+ nb_tx = do_tx_burst(port_id, 0, tx_bufs, allocated);
+ if (nb_tx == 0) {
+ printf("SKIPPED: No packets transmitted\n");
+ return TEST_SKIPPED;
+ }
+
+ /*
+ * Read packets from TAP interface (they were sent there by af_packet).
+ * Then write them back to TAP so af_packet can receive them.
+ */
+ while (elapsed < LOOPBACK_TIMEOUT_US) {
+ /* Read from TAP (what af_packet sent) */
+ bytes_read = read(tap_fd, tap_buf, sizeof(tap_buf));
+ if (bytes_read > 0) {
+ /* Write back to TAP for af_packet to receive */
+ write(tap_fd, tap_buf, bytes_read);
+ }
+
+ /* Try to receive via af_packet RX */
+ uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, rx_bufs, BURST_SIZE);
+ if (nb_rx > 0) {
+ total_rx += nb_rx;
+ rte_pktmbuf_free_bulk(rx_bufs, nb_rx);
+ }
+
+ /* Check if we've received enough */
+ if (total_rx >= nb_tx)
+ break;
+
+ rte_delay_us_block(STATS_POLL_INTERVAL_US);
+ elapsed += STATS_POLL_INTERVAL_US;
+ }
+
+ /* Restore TAP fd flags */
+ fcntl(tap_fd, F_SETFL, flags);
+
+ /*
+ * Note: We may not receive all packets due to timing, but receiving
+ * any packets proves the loopback path works.
+ */
+ printf("Loopback: TX=%u, RX=%u\n", nb_tx, total_rx);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Promiscuous mode
+ */
+static int
+test_af_packet_promiscuous(void)
+{
+ int ret;
+
+ if (!tap_created || port_id >= RTE_MAX_ETHPORTS) {
+ printf("SKIPPED: Port not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Enable promiscuous mode */
+ ret = rte_eth_promiscuous_enable(port_id);
+ TEST_ASSERT(ret == 0, "Failed to enable promiscuous mode");
+
+ ret = rte_eth_promiscuous_get(port_id);
+ TEST_ASSERT(ret == 1, "Expected promiscuous mode enabled");
+
+ /* Disable promiscuous mode */
+ ret = rte_eth_promiscuous_disable(port_id);
+ TEST_ASSERT(ret == 0, "Failed to disable promiscuous mode");
+
+ ret = rte_eth_promiscuous_get(port_id);
+ TEST_ASSERT(ret == 0, "Expected promiscuous mode disabled");
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: MAC address operations
+ */
+static int
+test_af_packet_mac_addr(void)
+{
+ struct rte_ether_addr mac_addr;
+ struct rte_ether_addr new_mac = {
+ .addr_bytes = {0x02, 0x11, 0x22, 0x33, 0x44, 0x55}
+ };
+ int ret;
+
+ if (!tap_created || port_id >= RTE_MAX_ETHPORTS) {
+ printf("SKIPPED: Port not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Get current MAC address */
+ ret = rte_eth_macaddr_get(port_id, &mac_addr);
+ TEST_ASSERT(ret == 0, "Failed to get MAC address");
+
+ /* Set new MAC address (use locally administered address) */
+ ret = rte_eth_dev_default_mac_addr_set(port_id, &new_mac);
+ TEST_ASSERT(ret == 0, "Failed to set MAC address");
+
+ /* Verify MAC was set */
+ ret = rte_eth_macaddr_get(port_id, &mac_addr);
+ TEST_ASSERT(ret == 0, "Failed to get MAC address after set");
+
+ TEST_ASSERT(memcmp(&mac_addr, &new_mac, sizeof(mac_addr)) == 0,
+ "MAC address mismatch after set");
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: MTU operations
+ * Get min/max supported MTU from device info and verify setting works.
+ */
+static int
+test_af_packet_mtu(void)
+{
+ struct rte_eth_dev_info dev_info;
+ uint16_t mtu, original_mtu;
+ int ret;
+
+ if (!tap_created || port_id >= RTE_MAX_ETHPORTS) {
+ printf("SKIPPED: Port not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Get device info for min/max MTU */
+ ret = rte_eth_dev_info_get(port_id, &dev_info);
+ TEST_ASSERT(ret == 0, "Failed to get device info");
+
+ /* Get current MTU */
+ ret = rte_eth_dev_get_mtu(port_id, &original_mtu);
+ TEST_ASSERT(ret == 0, "Failed to get MTU");
+
+ printf("MTU: current=%u, min=%u, max=%u\n",
+ original_mtu, dev_info.min_mtu, dev_info.max_mtu);
+
+ /* Test setting minimum MTU if supported and different from current */
+ if (dev_info.min_mtu > 0 && dev_info.min_mtu != original_mtu) {
+ ret = rte_eth_dev_set_mtu(port_id, dev_info.min_mtu);
+ if (ret == 0) {
+ ret = rte_eth_dev_get_mtu(port_id, &mtu);
+ TEST_ASSERT(ret == 0, "Failed to get MTU after set to min");
+ TEST_ASSERT(mtu == dev_info.min_mtu,
+ "MTU not set to min: expected %u, got %u",
+ dev_info.min_mtu, mtu);
+ }
+ /* MTU set may fail depending on interface, that's acceptable */
+ }
+
+ /* Test setting maximum MTU if supported and different from current */
+ if (dev_info.max_mtu > 0 && dev_info.max_mtu != original_mtu &&
+ dev_info.max_mtu != dev_info.min_mtu) {
+ ret = rte_eth_dev_set_mtu(port_id, dev_info.max_mtu);
+ if (ret == 0) {
+ ret = rte_eth_dev_get_mtu(port_id, &mtu);
+ TEST_ASSERT(ret == 0, "Failed to get MTU after set to max");
+ TEST_ASSERT(mtu == dev_info.max_mtu,
+ "MTU not set to max: expected %u, got %u",
+ dev_info.max_mtu, mtu);
+ }
+ /* MTU set may fail depending on interface capabilities */
+ }
+
+ /* Restore original MTU */
+ rte_eth_dev_set_mtu(port_id, original_mtu);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Stats reset verification
+ */
+static int
+test_af_packet_stats_reset(void)
+{
+ struct rte_eth_stats stats;
+ struct rte_mbuf *bufs[BURST_SIZE / 2];
+ uint16_t nb_tx;
+ unsigned int allocated;
+ int ret;
+
+ if (!tap_created || port_id >= RTE_MAX_ETHPORTS) {
+ printf("SKIPPED: Port not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Generate some TX traffic using helpers */
+ allocated = alloc_tx_mbufs(bufs, BURST_SIZE / 2);
+ nb_tx = do_tx_burst(port_id, 0, bufs, allocated);
+
+ /* Poll for stats to update */
+ if (nb_tx > 0)
+ wait_for_stats_update(port_id, nb_tx, STATS_POLL_TIMEOUT_US);
+
+ /* Reset stats */
+ ret = rte_eth_stats_reset(port_id);
+ TEST_ASSERT(ret == 0, "Failed to reset stats");
+
+ /* Verify stats are zero */
+ ret = rte_eth_stats_get(port_id, &stats);
+ TEST_ASSERT(ret == 0, "Failed to get stats after reset");
+
+ TEST_ASSERT(stats.ipackets == 0,
+ "Expected ipackets=0, got %"PRIu64, stats.ipackets);
+ TEST_ASSERT(stats.opackets == 0,
+ "Expected opackets=0, got %"PRIu64, stats.opackets);
+ TEST_ASSERT(stats.ibytes == 0,
+ "Expected ibytes=0, got %"PRIu64, stats.ibytes);
+ TEST_ASSERT(stats.obytes == 0,
+ "Expected obytes=0, got %"PRIu64, stats.obytes);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Invalid configuration handling - missing iface
+ */
+static int
+test_af_packet_invalid_no_iface(void)
+{
+ int ret;
+
+ /* Test without iface argument (should fail) */
+ ret = rte_vdev_init("net_af_packet_invalid1", "");
+ TEST_ASSERT(ret != 0, "Expected failure without iface argument");
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Invalid configuration handling - non-existent interface
+ */
+static int
+test_af_packet_invalid_bad_iface(void)
+{
+ int ret;
+
+ /* Test with non-existent interface (should fail) */
+ ret = rte_vdev_init("net_af_packet_invalid2",
+ "iface=nonexistent_iface_12345");
+ TEST_ASSERT(ret != 0, "Expected failure with non-existent interface");
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Invalid configuration handling - invalid qpairs
+ */
+static int
+test_af_packet_invalid_qpairs(void)
+{
+ int ret;
+
+ if (!tap_created) {
+ printf("SKIPPED: TAP interface not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Test with invalid qpairs (should fail) */
+ ret = rte_vdev_init("net_af_packet_invalid3",
+ "iface=" TAP_DEV_NAME ",qpairs=0");
+ TEST_ASSERT(ret != 0, "Expected failure with qpairs=0");
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Custom frame size configuration
+ */
+static int
+test_af_packet_frame_config(void)
+{
+ struct rte_eth_dev_info dev_info;
+ uint16_t test_port;
+ char devargs[256];
+ int ret;
+
+ if (!tap_created) {
+ printf("SKIPPED: TAP interface not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Create with custom frame parameters */
+ snprintf(devargs, sizeof(devargs),
+ "iface=%s,blocksz=4096,framesz=2048,framecnt=256",
+ TAP_DEV_NAME);
+
+ ret = rte_vdev_init("net_af_packet_frame_test", devargs);
+ if (ret != 0) {
+ printf("SKIPPED: Could not create port with custom frame config\n");
+ return TEST_SKIPPED;
+ }
+
+ ret = rte_eth_dev_get_port_by_name("net_af_packet_frame_test",
+ &test_port);
+ TEST_ASSERT(ret == 0, "Failed to get port id");
+
+ ret = rte_eth_dev_info_get(test_port, &dev_info);
+ TEST_ASSERT(ret == 0, "Failed to get device info");
+
+ /* Cleanup */
+ rte_eth_dev_close(test_port);
+ rte_vdev_uninit("net_af_packet_frame_test");
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Qdisc bypass configuration
+ */
+static int
+test_af_packet_qdisc_bypass(void)
+{
+ uint16_t test_port;
+ char devargs[256];
+ int ret;
+
+ if (!tap_created) {
+ printf("SKIPPED: TAP interface not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Create with qdisc_bypass enabled */
+ snprintf(devargs, sizeof(devargs), "iface=%s,qdisc_bypass=1",
+ TAP_DEV_NAME);
+
+ ret = rte_vdev_init("net_af_packet_qdisc_test", devargs);
+ if (ret != 0) {
+ printf("SKIPPED: qdisc_bypass may not be supported\n");
+ return TEST_SKIPPED;
+ }
+
+ ret = rte_eth_dev_get_port_by_name("net_af_packet_qdisc_test",
+ &test_port);
+ TEST_ASSERT(ret == 0, "Failed to get port id");
+
+ /* Cleanup */
+ rte_eth_dev_close(test_port);
+ rte_vdev_uninit("net_af_packet_qdisc_test");
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Multiple queue pairs
+ */
+static int
+test_af_packet_multi_queue(void)
+{
+ struct rte_eth_dev_info dev_info;
+ struct rte_eth_conf port_conf = {0};
+ struct rte_mbuf *bufs[BURST_SIZE];
+ uint16_t test_port;
+ char devargs[256];
+ const uint16_t num_queues = 2;
+ unsigned int allocated, q;
+ int ret;
+
+ if (!tap_created) {
+ printf("SKIPPED: TAP interface not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ snprintf(devargs, sizeof(devargs), "iface=%s,qpairs=%u",
+ TAP_DEV_NAME, num_queues);
+ ret = rte_vdev_init("net_af_packet_multi_q", devargs);
+ if (ret != 0) {
+ printf("SKIPPED: Could not create multi-queue port\n");
+ return TEST_SKIPPED;
+ }
+
+ ret = rte_eth_dev_get_port_by_name("net_af_packet_multi_q", &test_port);
+ TEST_ASSERT(ret == 0, "Failed to get port id for multi-queue port");
+
+ ret = rte_eth_dev_info_get(test_port, &dev_info);
+ TEST_ASSERT(ret == 0, "Failed to get device info");
+
+ TEST_ASSERT(dev_info.max_rx_queues >= num_queues,
+ "Expected at least %u RX queues, got %u",
+ num_queues, dev_info.max_rx_queues);
+ TEST_ASSERT(dev_info.max_tx_queues >= num_queues,
+ "Expected at least %u TX queues, got %u",
+ num_queues, dev_info.max_tx_queues);
+
+ /* Configure the port */
+ ret = rte_eth_dev_configure(test_port, num_queues, num_queues, &port_conf);
+ TEST_ASSERT(ret == 0, "Failed to configure multi-queue port");
+
+ for (q = 0; q < num_queues; q++) {
+ ret = rte_eth_rx_queue_setup(test_port, q, RING_SIZE,
+ rte_eth_dev_socket_id(test_port),
+ NULL, mp);
+ TEST_ASSERT(ret == 0, "Failed to setup RX queue %u", q);
+
+ ret = rte_eth_tx_queue_setup(test_port, q, RING_SIZE,
+ rte_eth_dev_socket_id(test_port),
+ NULL);
+ TEST_ASSERT(ret == 0, "Failed to setup TX queue %u", q);
+ }
+
+ ret = rte_eth_dev_start(test_port);
+ TEST_ASSERT(ret == 0, "Failed to start multi-queue port");
+
+ /* Test TX on different queues using shared helpers */
+ for (q = 0; q < num_queues; q++) {
+ allocated = alloc_tx_mbufs(bufs, BURST_SIZE / 2);
+ if (allocated > 0)
+ do_tx_burst(test_port, q, bufs, allocated);
+ }
+
+ /* Test RX on different queues */
+ for (q = 0; q < num_queues; q++)
+ do_rx_burst(test_port, q, bufs, BURST_SIZE);
+
+ /* Cleanup */
+ rte_eth_dev_stop(test_port);
+ rte_eth_dev_close(test_port);
+ rte_vdev_uninit("net_af_packet_multi_q");
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Multi-threaded test context
+ */
+struct mt_test_ctx {
+ uint16_t port_id;
+ uint32_t stop;
+ uint32_t tx_count;
+ uint32_t rx_count;
+ int tx_error;
+ int rx_error;
+};
+
+/*
+ * Writer thread function for multi-threaded test
+ */
+static void *
+mt_writer_thread(void *arg)
+{
+ struct mt_test_ctx *ctx = arg;
+ struct rte_mbuf *bufs[BURST_SIZE];
+ unsigned int allocated;
+ uint16_t nb_tx;
+
+ while (!rte_atomic_load_explicit(&ctx->stop, rte_memory_order_acquire)) {
+ allocated = alloc_tx_mbufs(bufs, BURST_SIZE / 4);
+ if (allocated == 0) {
+ ctx->tx_error = -ENOMEM;
+ break;
+ }
+
+ nb_tx = do_tx_burst(ctx->port_id, 0, bufs, allocated);
+ rte_atomic_fetch_add_explicit(&ctx->tx_count, nb_tx,
+ rte_memory_order_relaxed);
+
+ /* Small delay between bursts */
+ rte_delay_us_block(100);
+ }
+
+ return NULL;
+}
+
+/*
+ * Reader thread function for multi-threaded test
+ */
+static void *
+mt_reader_thread(void *arg)
+{
+ struct mt_test_ctx *ctx = arg;
+ struct rte_mbuf *bufs[BURST_SIZE];
+ uint16_t nb_rx;
+
+ while (!rte_atomic_load_explicit(&ctx->stop, rte_memory_order_acquire)) {
+ nb_rx = rte_eth_rx_burst(ctx->port_id, 0, bufs, BURST_SIZE);
+ if (nb_rx > 0) {
+ rte_atomic_fetch_add_explicit(&ctx->rx_count, nb_rx,
+ rte_memory_order_relaxed);
+ rte_pktmbuf_free_bulk(bufs, nb_rx);
+ }
+
+ /* Small delay between polls */
+ rte_delay_us_block(50);
+ }
+
+ return NULL;
+}
+
+/*
+ * Test: Multi-threaded concurrent TX and RX
+ * This test creates separate writer and reader threads to exercise
+ * concurrent access patterns to the af_packet PMD.
+ */
+static int
+test_af_packet_multithread(void)
+{
+ struct mt_test_ctx ctx = {0};
+ pthread_t writer_tid, reader_tid;
+ struct timespec start, now;
+ int ret;
+
+ if (!tap_created || port_id >= RTE_MAX_ETHPORTS) {
+ printf("SKIPPED: Port not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Initialize context */
+ ctx.port_id = port_id;
+ rte_atomic_store_explicit(&ctx.stop, 0, rte_memory_order_release);
+ rte_atomic_store_explicit(&ctx.tx_count, 0, rte_memory_order_release);
+ rte_atomic_store_explicit(&ctx.rx_count, 0, rte_memory_order_release);
+ ctx.tx_error = 0;
+ ctx.rx_error = 0;
+
+ /* Start writer thread */
+ ret = pthread_create(&writer_tid, NULL, mt_writer_thread, &ctx);
+ if (ret != 0) {
+ printf("SKIPPED: Failed to create writer thread: %d\n", ret);
+ return TEST_SKIPPED;
+ }
+
+ /* Start reader thread */
+ ret = pthread_create(&reader_tid, NULL, mt_reader_thread, &ctx);
+ if (ret != 0) {
+ rte_atomic_store_explicit(&ctx.stop, 1, rte_memory_order_release);
+ pthread_join(writer_tid, NULL);
+ printf("SKIPPED: Failed to create reader thread: %d\n", ret);
+ return TEST_SKIPPED;
+ }
+
+ /* Run for configured duration */
+ clock_gettime(CLOCK_MONOTONIC, &start);
+ do {
+ rte_delay_us_block(100000); /* 100ms */
+ clock_gettime(CLOCK_MONOTONIC, &now);
+ } while ((now.tv_sec - start.tv_sec) < MT_TEST_DURATION_SEC);
+
+ /* Signal threads to stop */
+ rte_atomic_store_explicit(&ctx.stop, 1, rte_memory_order_release);
+
+ /* Wait for threads to finish */
+ pthread_join(writer_tid, NULL);
+ pthread_join(reader_tid, NULL);
+
+ /* Report results */
+ printf("Multi-threaded test: TX=%u, RX=%u (duration=%ds)\n",
+ rte_atomic_load_explicit(&ctx.tx_count, rte_memory_order_relaxed),
+ rte_atomic_load_explicit(&ctx.rx_count, rte_memory_order_relaxed),
+ MT_TEST_DURATION_SEC);
+
+ /* Check for errors */
+ TEST_ASSERT(ctx.tx_error == 0,
+ "Writer thread encountered error: %d", ctx.tx_error);
+ TEST_ASSERT(ctx.rx_error == 0,
+ "Reader thread encountered error: %d", ctx.rx_error);
+
+ /* Verify some packets were transmitted */
+ TEST_ASSERT(rte_atomic_load_explicit(&ctx.tx_count,
+ rte_memory_order_relaxed) > 0,
+ "Expected some packets to be transmitted");
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test: Jumbo frame TX and RX
+ * Creates a device with jumbo frame support and verifies large packets
+ * can be transmitted and received.
+ */
+static int
+test_af_packet_jumbo_frames(void)
+{
+ struct rte_mempool *jumbo_mp = NULL;
+ struct rte_eth_conf port_conf = {0};
+ struct rte_eth_stats stats;
+ struct rte_mbuf *bufs[BURST_SIZE];
+ uint16_t test_port;
+ char devargs[256];
+ uint16_t nb_tx;
+ int ret, i;
+
+ if (!tap_created) {
+ printf("SKIPPED: TAP interface not available (need root)\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Set TAP interface MTU for jumbo frames */
+ ret = set_tap_mtu(TAP_DEV_NAME, JUMBO_FRAME_SIZE);
+ if (ret != 0) {
+ printf("SKIPPED: Could not set MTU for jumbo frames\n");
+ return TEST_SKIPPED;
+ }
+
+ /* Create mempool with buffers sized for the AF_PACKET frame size */
+ jumbo_mp = rte_pktmbuf_pool_create("jumbo_test_pool", NUM_MBUFS,
+ MBUF_CACHE_SIZE, 0,
+ JUMBO_FRAME_FRAMESZ + RTE_PKTMBUF_HEADROOM,
+ rte_socket_id());
+ if (jumbo_mp == NULL) {
+ printf("SKIPPED: Could not create jumbo mempool\n");
+ set_tap_mtu(TAP_DEV_NAME, RTE_ETHER_MTU);
+ return TEST_SKIPPED;
+ }
+
+ /* Create af_packet port with jumbo frame support */
+ snprintf(devargs, sizeof(devargs),
+ "iface=%s,blocksz=%u,framesz=%u,framecnt=256",
+ TAP_DEV_NAME, JUMBO_FRAME_BLOCKSZ, JUMBO_FRAME_FRAMESZ);
+
+ ret = rte_vdev_init("net_af_packet_jumbo", devargs);
+ if (ret != 0) {
+ printf("SKIPPED: Could not create jumbo frame port\n");
+ rte_mempool_free(jumbo_mp);
+ set_tap_mtu(TAP_DEV_NAME, RTE_ETHER_MTU);
+ return TEST_SKIPPED;
+ }
+
+ ret = rte_eth_dev_get_port_by_name("net_af_packet_jumbo", &test_port);
+ if (ret != 0) {
+ printf("Failed to get jumbo port id\n");
+ goto cleanup;
+ }
+
+ /* Configure port with jumbo MTU */
+ port_conf.rxmode.mtu = JUMBO_FRAME_SIZE;
+ ret = rte_eth_dev_configure(test_port, 1, 1, &port_conf);
+ if (ret != 0) {
+ printf("Failed to configure jumbo port: %d\n", ret);
+ goto cleanup;
+ }
+
+ ret = rte_eth_rx_queue_setup(test_port, 0, RING_SIZE,
+ rte_eth_dev_socket_id(test_port),
+ NULL, jumbo_mp);
+ if (ret != 0) {
+ printf("Failed to setup RX queue for jumbo port: %d\n", ret);
+ goto cleanup;
+ }
+
+ ret = rte_eth_tx_queue_setup(test_port, 0, RING_SIZE,
+ rte_eth_dev_socket_id(test_port), NULL);
+ if (ret != 0) {
+ printf("Failed to setup TX queue for jumbo port: %d\n", ret);
+ goto cleanup;
+ }
+
+ ret = rte_eth_dev_start(test_port);
+ if (ret != 0) {
+ printf("Failed to start jumbo port: %d\n", ret);
+ goto cleanup;
+ }
+
+ /* Reset stats */
+ rte_eth_stats_reset(test_port);
+
+ /* Allocate and send jumbo packets */
+ ret = rte_pktmbuf_alloc_bulk(jumbo_mp, bufs, BURST_SIZE);
+ if (ret != 0) {
+ printf("Failed to allocate jumbo mbufs\n");
+ ret = -1;
+ goto cleanup_stop;
+ }
+
+ /* Prepare jumbo frames (just under max size to fit in frame) */
+ for (i = 0; i < BURST_SIZE; i++) {
+ struct rte_ether_hdr *eth_hdr;
+ uint16_t pkt_len = JUMBO_FRAME_SIZE - 100; /* Leave some headroom */
+
+ eth_hdr = (struct rte_ether_hdr *)rte_pktmbuf_append(bufs[i], pkt_len);
+ if (eth_hdr == NULL) {
+ printf("Failed to append data to jumbo mbuf\n");
+ rte_pktmbuf_free_bulk(bufs, BURST_SIZE);
+ ret = -1;
+ goto cleanup_stop;
+ }
+
+ memset(ð_hdr->dst_addr, 0xFF, RTE_ETHER_ADDR_LEN);
+ memset(ð_hdr->src_addr, 0x02, RTE_ETHER_ADDR_LEN);
+ eth_hdr->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
+ }
+
+ /* TX burst */
+ nb_tx = rte_eth_tx_burst(test_port, 0, bufs, BURST_SIZE);
+ rte_pktmbuf_free_bulk(&bufs[nb_tx], BURST_SIZE - nb_tx);
+
+ /* Wait for stats to update */
+ if (nb_tx > 0)
+ wait_for_stats_update(test_port, nb_tx, STATS_POLL_TIMEOUT_US);
+
+ /* Verify stats */
+ ret = rte_eth_stats_get(test_port, &stats);
+ if (ret == 0 && stats.opackets > 0) {
+ printf("Jumbo frame test: TX=%"PRIu64" packets, %"PRIu64" bytes\n",
+ stats.opackets, stats.obytes);
+ ret = 0;
+ } else {
+ printf("Jumbo frame test: no packets transmitted\n");
+ ret = -1;
+ }
+
+cleanup_stop:
+ rte_eth_dev_stop(test_port);
+
+cleanup:
+ rte_eth_dev_close(test_port);
+ rte_vdev_uninit("net_af_packet_jumbo");
+ rte_mempool_free(jumbo_mp);
+
+ /* Restore original MTU */
+ set_tap_mtu(TAP_DEV_NAME, RTE_ETHER_MTU);
+
+ if (ret != 0)
+ return TEST_FAILED;
+
+ return TEST_SUCCESS;
+}
+
+static struct unit_test_suite af_packet_test_suite = {
+ .suite_name = "AF_PACKET PMD Unit Test Suite",
+ .setup = test_af_packet_setup,
+ .teardown = test_af_packet_teardown,
+ .unit_test_cases = {
+ /* Tests that don't modify device state */
+ TEST_CASE(test_af_packet_dev_info),
+ TEST_CASE(test_af_packet_link_status),
+ TEST_CASE(test_af_packet_stats_init),
+ TEST_CASE(test_af_packet_tx),
+ TEST_CASE(test_af_packet_rx),
+ TEST_CASE(test_af_packet_loopback),
+ TEST_CASE(test_af_packet_promiscuous),
+ TEST_CASE(test_af_packet_mac_addr),
+ TEST_CASE(test_af_packet_mtu),
+ TEST_CASE(test_af_packet_stats_reset),
+ TEST_CASE(test_af_packet_multithread),
+
+ /* Tests that create their own devices */
+ TEST_CASE(test_af_packet_invalid_no_iface),
+ TEST_CASE(test_af_packet_invalid_bad_iface),
+ TEST_CASE(test_af_packet_invalid_qpairs),
+ TEST_CASE(test_af_packet_frame_config),
+ TEST_CASE(test_af_packet_qdisc_bypass),
+ TEST_CASE(test_af_packet_multi_queue),
+ TEST_CASE(test_af_packet_jumbo_frames),
+
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
+
+static int
+test_pmd_af_packet(void)
+{
+ return unit_test_suite_runner(&af_packet_test_suite);
+}
+#endif
+
+REGISTER_FAST_TEST(af_packet_pmd_autotest, NOHUGE_OK, ASAN_OK, test_pmd_af_packet);
--
2.51.0
More information about the dev
mailing list