[RFC] net: add experimental UDP encapsulation PMD

[Stephen Hemminger <stephen@networkplumber.org>]

This is a new PMD which can be useful to test a DPDK application
from another test program. The PMD binds to a connected UDP socket
and expects to receive and send raw Ethernet packets over that
socket.

This is especially useful for testing envirionments where you
can't/don't want to give the test driver program route permission.

Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
---
This is 1st draft port of some test infrastructure to get
feedback and comments from community.

Later version will include an example and unit tests.

 doc/guides/nics/features/udp.ini |  10 +
 doc/guides/nics/udp.rst          |  30 ++
 drivers/net/meson.build          |   1 +
 drivers/net/udp/meson.build      |  11 +
 drivers/net/udp/rte_eth_udp.c    | 728 +++++++++++++++++++++++++++++++
 drivers/net/udp/version.map      |   3 +
 6 files changed, 783 insertions(+)
 create mode 100644 doc/guides/nics/features/udp.ini
 create mode 100644 doc/guides/nics/udp.rst
 create mode 100644 drivers/net/udp/meson.build
 create mode 100644 drivers/net/udp/rte_eth_udp.c
 create mode 100644 drivers/net/udp/version.map

diff --git a/doc/guides/nics/features/udp.ini b/doc/guides/nics/features/udp.ini
new file mode 100644
index 000000000000..dfc39204dacf
--- /dev/null
+++ b/doc/guides/nics/features/udp.ini
@@ -0,0 +1,10 @@
+;
+; Supported features of the 'udp' network poll mode driver.
+;
+; Refer to default.ini for the full list of available PMD features.
+;
+[Features]
+Basic stats          = Y
+Stats per queue      = Y
+Multiprocess aware   = Y
+Scattered Rx         = P
diff --git a/doc/guides/nics/udp.rst b/doc/guides/nics/udp.rst
new file mode 100644
index 000000000000..7b86f5e273e9
--- /dev/null
+++ b/doc/guides/nics/udp.rst
@@ -0,0 +1,30 @@
+..  SPDX-License-Identifier: BSD-3-Clause
+    Copyright(c) 2018 Intel Corporation.
+
+UDP Poll Mode Driver
+====================
+
+UDP Poll Mode Driver (PMD) is a basic virtual driver useful for testing.
+It provides a simple bare encapsulation of Ethernet frames in a UDP
+socket.  This is useful since the test driver application can
+easily open a local UDP socket and interact with a DPDK application.
+This can even be done inside a VM or container in automated test setup.
+
+
+Driver Configuration
+--------------------
+
+The driver is a virtual device configured with the --vdev option.
+The device name must start with the net_udp prefix follwed by numbers
+or letters The name is unique for each device. Each device can have
+multiple stream options and multiple devices can be used.
+Multiple device definitions can be arranged using multiple --vdev.
+
+Both local and remote address must be specified. Both IPv4 and IPv6
+are supported examples:
+
+.. code-block:: console
+
+   ./<build_dir>/app/dpdk-testpmd -l 0-3 -n 4 \
+       --vdev 'net_udp0,local=127.0.0.1:9000,remote=192.0.2.1:9000',
+       --vdev 'net_udp1,local=[:0],9000,remote=[2001:DB8::1]:9000'
diff --git a/drivers/net/meson.build b/drivers/net/meson.build
index 35bfa78dee66..36f2d9ed9b96 100644
--- a/drivers/net/meson.build
+++ b/drivers/net/meson.build
@@ -56,6 +56,7 @@ drivers = [
         'tap',
         'thunderx',
         'txgbe',
+        'udp',
         'vdev_netvsc',
         'vhost',
         'virtio',
diff --git a/drivers/net/udp/meson.build b/drivers/net/udp/meson.build
new file mode 100644
index 000000000000..e7bfd843f4b2
--- /dev/null
+++ b/drivers/net/udp/meson.build
@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+if is_windows
+    build = false
+    reason = 'not supported on Windows'
+    subdir_done()
+endif
+
+sources = files('rte_eth_udp.c')
+
+pmd_supports_disable_iova_as_pa = true
diff --git a/drivers/net/udp/rte_eth_udp.c b/drivers/net/udp/rte_eth_udp.c
new file mode 100644
index 000000000000..8ce65721b3ec
--- /dev/null
+++ b/drivers/net/udp/rte_eth_udp.c
@@ -0,0 +1,728 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Copyright (c) 2022 Microsoft Corp.
+ * All rights reserved.
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <string.h>
+
+#include <rte_bus_vdev.h>
+#include <rte_common.h>
+#include <rte_ethdev.h>
+#include <ethdev_vdev.h>
+#include <ethdev_driver.h>
+#include <bus_vdev_driver.h>
+#include <rte_ether.h>
+#include <rte_kvargs.h>
+#include <rte_log.h>
+#include <rte_mbuf.h>
+
+/* Which strings are valid kvargs for this driver */
+#define ETH_UDP_LOCAL_ARG	"local"
+#define ETH_UDP_REMOTE_ARG	"remote"
+
+static int eth_udp_logtype;
+#define PMD_LOG(level, fmt, args...) \
+	rte_log(RTE_LOG_ ## level, eth_udp_logtype, \
+		"%s(): " fmt "\n", __func__, ##args)
+
+struct pmd_internals;
+
+struct udp_queue {
+	struct rte_mempool *mb_pool;
+	struct pmd_internals *internals;
+	uint16_t queue_id;
+	int sock_fd;
+
+	uint64_t pkts;
+	uint64_t bytes;
+	uint64_t nobufs;
+};
+
+struct pmd_internals {
+	uint16_t port_id;
+	int sock_fd;
+
+	struct sockaddr_storage remote;
+	struct sockaddr_storage local;
+	struct rte_ether_addr eth_addr;
+
+	struct udp_queue rx_queues[RTE_MAX_QUEUES_PER_PORT];
+	struct udp_queue tx_queues[RTE_MAX_QUEUES_PER_PORT];
+};
+
+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,
+};
+
+static int
+parse_ipv6_address(const char *value, struct sockaddr_in6 *sin6)
+{
+	char *str = strdupa(value);
+	char *endp;
+
+	++str;	 /* skip leading '[' */
+	endp = strchr(str, ']');
+	if (endp == NULL) {
+		PMD_LOG(ERR, "missing closing ]");
+		return -EINVAL;
+	}
+
+	*endp++ = '\0';
+	sin6->sin6_family = AF_INET6;
+
+	if (inet_pton(AF_INET6, ++str, &sin6->sin6_addr) != 1) {
+		PMD_LOG(ERR, "invalid ipv6 address '%s'", str);
+		return -EINVAL;
+	}
+
+	/* Handle [ff80::1]:999 as address and port */
+	if (*endp == ':') {
+		sin6->sin6_port = htons(strtoul(endp + 1, NULL, 0));
+	} else if (*endp != '\0') {
+		PMD_LOG(ERR, "incorrect ipv6 port syntax");
+		return -EINVAL;
+	}
+	return 0;
+}
+
+static int
+parse_ipv4_address(const char *value, struct sockaddr_in *sin)
+{
+	char *str = strdupa(value);
+	char *endp;
+
+	endp = strchr(str, ':');
+	if (endp)
+		*endp++ = '\0';
+
+	memset(sin, 0, sizeof(*sin));
+	sin->sin_family = AF_INET;
+
+	if (inet_pton(AF_INET, str, &sin->sin_addr) != 1) {
+		PMD_LOG(ERR, "invalid ipv4 address '%s'", str);
+		return -EINVAL;
+	}
+
+	if (endp != NULL)
+		sin->sin_port = htons(strtoul(endp, NULL, 0));
+
+	return 0;
+}
+
+/* Addresses are given on Kvargs as:
+ *   127.0.0.1:9000
+ *   [::1]:9000
+ */
+static int
+get_address_arg(const char *key, const char *value, void *sarg)
+{
+	if (value == NULL)
+		return -EINVAL;
+
+	PMD_LOG(DEBUG, "%s='%s'", key, value);
+
+	if (*value == '[')
+		return parse_ipv6_address(value, sarg);
+	else
+		return parse_ipv4_address(value, sarg);
+}
+
+/* Helper function to determine how many mbufs are needed per packet  */
+static uint16_t
+eth_mbuf_per_pkt(uint16_t port_id,
+		 struct rte_mempool *mb_pool)
+{
+	const struct rte_eth_dev *dev = &rte_eth_devices[port_id];
+	uint16_t buf_size = rte_pktmbuf_data_room_size(mb_pool);
+
+	return (dev->data->mtu + buf_size - 1) / buf_size;
+}
+
+
+/*
+ * Receive packets from socket into mbufs.
+ *
+ * In order to handle multiple packets at a time and scattered receive
+ * this allocates the worst case number of buffers.
+ *
+ * If out of memory, or socket gives error returns 0.
+ */
+static uint16_t
+eth_udp_rx(void *queue, struct rte_mbuf **pkts, uint16_t nb_pkts)
+{
+	struct udp_queue *udp_q = queue;
+	uint16_t port_id = udp_q->internals->port_id;
+	struct rte_mempool *mpool = udp_q->mb_pool;
+	unsigned int segs_per_pkt = eth_mbuf_per_pkt(port_id, mpool);
+	unsigned int num_segs = nb_pkts * segs_per_pkt;
+	struct rte_mbuf *bufs[num_segs];
+	struct iovec iovecs[num_segs];
+	struct mmsghdr msgs[nb_pkts];
+	unsigned int seg_idx = 0, nb_iovs = 0;
+	uint64_t num_rx_bytes = 0;
+	int ret;
+
+	/* Allocate worst case number of buffers to be used. */
+	if (rte_pktmbuf_alloc_bulk(mpool, bufs, num_segs) != 0) {
+		PMD_LOG(ERR, "alloc mbuf failed");
+		++udp_q->nobufs;
+		return 0;
+	}
+
+	/* Initialize the multi-packet headers and link the mbufs per packet */
+	memset(msgs, 0, sizeof(msgs));
+	for (uint16_t i = 0; i < nb_pkts; i++) {
+		msgs[i].msg_hdr.msg_iov    = &iovecs[nb_iovs];
+		msgs[i].msg_hdr.msg_iovlen = segs_per_pkt;
+
+		for (unsigned int n = 0; n < segs_per_pkt; n++, nb_iovs++) {
+			struct rte_mbuf *mb = bufs[nb_iovs];
+
+			iovecs[nb_iovs].iov_base = rte_pktmbuf_mtod(mb, void *);
+			iovecs[nb_iovs].iov_len = rte_pktmbuf_tailroom(mb);
+		}
+	}
+	assert(nb_iovs == num_segs);
+
+	ret = recvmmsg(udp_q->sock_fd, msgs, nb_pkts, 0, NULL);
+	if (ret < 0) {
+		if (!(errno == EWOULDBLOCK || errno == EINTR))
+			PMD_LOG(ERR, "recv failed: %s", strerror(errno));
+
+		rte_pktmbuf_free_bulk(bufs, num_segs);
+		return 0;
+	}
+	PMD_LOG(DEBUG, "recvmmsg returned %d", ret);
+
+	/* Adjust mbuf length and segments based on result. */
+	for (int i = 0; i < ret; i++) {
+		struct rte_mbuf **top = &pkts[i];
+		struct rte_mbuf *m0, *mb;
+		unsigned int unfilled;
+		size_t len;
+
+		/* Number of bytes in this packet */
+		len = msgs[i].msg_len;
+		num_rx_bytes += len;
+
+		m0 = mb = bufs[seg_idx];
+		m0->pkt_len = len;
+		m0->port = port_id;
+		m0->nb_segs = 0;
+
+		while (len > 0) {
+			mb->data_len  = RTE_MIN(len,
+						rte_pktmbuf_tailroom(mb));
+			len -= mb->data_len;
+			*top = mb;
+			top = &mb->next;
+
+			++m0->nb_segs;
+			mb = bufs[++seg_idx];
+
+		}
+		*top = NULL;
+
+		/* Drop rest of chain */
+		unfilled = segs_per_pkt - m0->nb_segs;
+		if (unfilled > 0) {
+			rte_pktmbuf_free_bulk(bufs + seg_idx, unfilled);
+			seg_idx += unfilled;
+		}
+	}
+
+	udp_q->pkts += ret;
+	udp_q->bytes += num_rx_bytes;
+
+	/* Free any unused buffers */
+	if (seg_idx < num_segs)
+		rte_pktmbuf_free_bulk(bufs + seg_idx, num_segs - seg_idx);
+
+	return ret;
+}
+
+/*
+ * Send mbufs over UDP socket.
+ */
+static uint16_t
+eth_udp_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_bufs)
+{
+	struct udp_queue *udp_q = queue;
+	struct iovec iovecs[nb_bufs * RTE_MBUF_MAX_NB_SEGS];
+	struct mmsghdr msgs[nb_bufs];
+	unsigned int iov_iter;
+	int ret;
+
+	memset(msgs, 0, sizeof(msgs));
+	iov_iter = 0;
+	for (uint16_t i = 0; i < nb_bufs; i++) {
+		struct rte_mbuf *mb = bufs[i];
+		unsigned int nsegs = mb->nb_segs;
+
+		msgs[i].msg_hdr.msg_iov    = &iovecs[iov_iter];
+		msgs[i].msg_hdr.msg_iovlen = nsegs;
+
+		for (unsigned int n = 0; n < nsegs; n++) {
+			iovecs[iov_iter].iov_base = rte_pktmbuf_mtod(mb, void *);
+			iovecs[iov_iter].iov_len = rte_pktmbuf_tailroom(mb);
+			iov_iter++;
+			mb = mb->next;
+		}
+		assert(mb == NULL);
+	}
+
+	ret = sendmmsg(udp_q->sock_fd, msgs, nb_bufs, 0);
+	if (ret < 0) {
+		if (!(errno == EWOULDBLOCK || errno == EINTR))
+			PMD_LOG(ERR, "sendmmsg failed: %s", strerror(errno));
+		ret = 0;
+	} else {
+		uint64_t num_tx_bytes = 0;
+
+		for (int i = 0; i < ret; i++)
+			num_tx_bytes += msgs[i].msg_len;
+
+		udp_q->pkts += ret;
+		udp_q->bytes += num_tx_bytes;
+	}
+
+	if (ret < nb_bufs)
+		rte_pktmbuf_free_bulk(bufs + ret, nb_bufs - ret);
+
+	return ret;
+}
+
+static int
+eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
+{
+	return 0;
+}
+
+static int
+eth_dev_start(struct rte_eth_dev *dev)
+{
+	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
+	return 0;
+}
+
+static int
+eth_dev_stop(struct rte_eth_dev *dev)
+{
+	struct pmd_internals *internal = dev->data->dev_private;
+	unsigned int i;
+
+
+	for (i = 0; i < dev->data->nb_tx_queues; i++)
+		internal->tx_queues[i].sock_fd = -1;
+
+	for (i = 0; i < dev->data->nb_rx_queues; i++) {
+		struct udp_queue *rxq = &internal->rx_queues[i];
+
+		close(rxq->sock_fd);
+		rxq->sock_fd = -1;
+	}
+
+	dev->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
+	return 0;
+}
+
+static int create_socket(struct pmd_internals *internals)
+{
+	socklen_t addrlen;
+	int family, sock_fd, on = 1;
+
+	family = internals->local.ss_family;
+	sock_fd = socket(family, SOCK_DGRAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
+	if (sock_fd < 0) {
+		PMD_LOG(ERR, "socket(): failed %s", strerror(errno));
+		return -1;
+	}
+
+	if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)) < 0) {
+		PMD_LOG(ERR, "setsockopt(SO_REUSEPORT): failed %s", strerror(errno));
+		goto fail;
+	}
+
+	if (family == AF_INET6)
+		addrlen = sizeof(struct sockaddr_in6);
+	else
+		addrlen = sizeof(struct sockaddr_in);
+
+
+	/* if address family is not set, then local address not specified */
+	if (bind(sock_fd, (struct sockaddr *)&internals->local, addrlen) < 0) {
+		PMD_LOG(ERR, "bind: failed %s", strerror(errno));
+		goto fail;
+	}
+
+	if (connect(sock_fd, (struct sockaddr *)&internals->remote, addrlen) < 0) {
+		PMD_LOG(ERR, "connect: failed %s", strerror(errno));
+		goto fail;
+	}
+
+	/* Get actual local family to reuse same address */
+	addrlen = sizeof(internals->local);
+	if (getsockname(sock_fd, (struct sockaddr *)&internals->local, &addrlen) < 0) {
+		PMD_LOG(ERR, "getsockname failed %s", strerror(errno));
+		goto fail;
+	}
+
+	addrlen = sizeof(internals->remote);
+	if (getpeername(sock_fd, (struct sockaddr *)&internals->remote, &addrlen) < 0) {
+		PMD_LOG(ERR, "getsockname failed %s", strerror(errno));
+		goto fail;
+	}
+
+	return sock_fd;
+
+fail:
+	close(sock_fd);
+	return -1;
+}
+
+static int
+eth_rx_queue_setup(struct rte_eth_dev *dev, uint16_t rx_queue_id,
+		uint16_t nb_rx_desc __rte_unused,
+		unsigned int socket_id __rte_unused,
+		const struct rte_eth_rxconf *rx_conf __rte_unused,
+		struct rte_mempool *mb_pool)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct udp_queue *rx_q = &internals->rx_queues[rx_queue_id];
+
+	dev->data->rx_queues[rx_queue_id] = rx_q;
+	rx_q->internals = internals;
+	rx_q->queue_id = rx_queue_id;
+	rx_q->mb_pool = mb_pool;
+
+	if (rx_queue_id == 0)
+		rx_q->sock_fd = internals->sock_fd;
+	else
+		rx_q->sock_fd = create_socket(internals);
+
+	return (rx_q->sock_fd < 0) ? -1 : 0;
+}
+
+static void
+eth_rx_queue_release(struct rte_eth_dev *dev, uint16_t rx_queue_id)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct udp_queue *rx_q = &internals->rx_queues[rx_queue_id];
+
+	if (rx_q->queue_id > 0)
+		close(rx_q->sock_fd);
+
+	rx_q->sock_fd = -1;
+}
+
+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,
+		const struct rte_eth_txconf *tx_conf __rte_unused)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct udp_queue *tx_q = &internals->tx_queues[tx_queue_id];
+
+	dev->data->tx_queues[tx_queue_id] = tx_q;
+	tx_q->queue_id = tx_queue_id;
+	tx_q->internals = internals;
+	tx_q->sock_fd = internals->sock_fd;
+
+	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 udp_queue *tx_q = &internals->tx_queues[tx_queue_id];
+
+	tx_q->sock_fd = -1;
+}
+
+static int
+eth_mtu_set(struct rte_eth_dev *dev __rte_unused, uint16_t mtu __rte_unused)
+{
+	return 0;
+}
+
+static int
+eth_dev_info(struct rte_eth_dev *dev __rte_unused,
+	     struct rte_eth_dev_info *dev_info)
+{
+	dev_info->max_mac_addrs = 1;
+	dev_info->max_rx_pktlen = UINT16_MAX;
+	dev_info->max_rx_queues = RTE_MAX_QUEUES_PER_PORT;
+	dev_info->max_tx_queues = RTE_MAX_QUEUES_PER_PORT;
+	dev_info->min_rx_bufsize = 0;
+	dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+	dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_SCATTER;
+
+	return 0;
+}
+
+static int
+eth_link_update(struct rte_eth_dev *dev __rte_unused,
+		int wait_to_complete __rte_unused)
+{
+	return 0;
+}
+
+static int
+eth_mac_address_set(__rte_unused struct rte_eth_dev *dev,
+		    __rte_unused struct rte_ether_addr *addr)
+{
+	return 0;
+}
+
+static int
+eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
+{
+	const struct pmd_internals *internal = dev->data->dev_private;
+	unsigned int i, num_stats;
+
+	num_stats = RTE_MIN((unsigned)RTE_ETHDEV_QUEUE_STAT_CNTRS,
+			    dev->data->nb_rx_queues);
+	for (i = 0; i < num_stats; i++) {
+		const struct udp_queue *q = &internal->rx_queues[i];
+
+		stats->q_ipackets[i] = q->pkts;
+		stats->ipackets += q->pkts;
+		stats->q_ibytes[i] += q->bytes;
+		stats->ibytes += q->bytes;
+		stats->rx_nombuf += q->nobufs;
+	}
+
+	num_stats = RTE_MIN((unsigned)RTE_ETHDEV_QUEUE_STAT_CNTRS,
+			    dev->data->nb_tx_queues);
+	for (i = 0; i < num_stats; i++) {
+		const struct udp_queue *q = &internal->tx_queues[i];
+
+		stats->q_opackets[i] = q->pkts;
+		stats->opackets += q->pkts;
+		stats->q_obytes[i] += q->bytes;
+		stats->obytes += q->bytes;
+	}
+
+	return 0;
+}
+
+static int
+eth_stats_reset(struct rte_eth_dev *dev)
+{
+	struct pmd_internals *internal = dev->data->dev_private;
+	unsigned int i;
+
+	for (i = 0; i < RTE_DIM(internal->rx_queues); i++) {
+		struct udp_queue *q = &internal->rx_queues[i];
+
+		q->pkts = 0;
+		q->bytes = 0;
+		q->nobufs = 0;
+	}
+
+
+	for (i = 0; i < RTE_DIM(internal->tx_queues); i++) {
+		struct udp_queue *q = &internal->tx_queues[i];
+
+		q->pkts = 0;
+		q->bytes = 0;
+		q->nobufs = 0;
+	}
+
+	return 0;
+}
+
+static const struct eth_dev_ops ops = {
+	.dev_start = eth_dev_start,
+	.dev_stop = eth_dev_stop,
+	.dev_configure = eth_dev_configure,
+	.dev_infos_get = eth_dev_info,
+	.rx_queue_setup = eth_rx_queue_setup,
+	.tx_queue_setup = eth_tx_queue_setup,
+	.rx_queue_release = eth_rx_queue_release,
+	.tx_queue_release = eth_tx_queue_release,
+	.mtu_set = eth_mtu_set,
+	.link_update = eth_link_update,
+	.mac_addr_set = eth_mac_address_set,
+	.stats_get = eth_stats_get,
+	.stats_reset = eth_stats_reset,
+};
+
+static int
+parse_parameters(struct pmd_internals *internals, const char *params)
+{
+	static const char * const valid_args[] = {
+		"local", "remote", NULL
+	};
+	struct rte_kvargs *kvlist;
+	int ret;
+
+	if (params == NULL && params[0] == '\0')
+		return 0;
+
+	PMD_LOG(INFO, "parameters \"%s\"", params);
+	kvlist = rte_kvargs_parse(params, valid_args);
+	if (kvlist == NULL)
+		return -1;
+
+	ret = rte_kvargs_process(kvlist, ETH_UDP_LOCAL_ARG,
+				 &get_address_arg, &internals->local);
+	if (ret < 0)
+		goto out;
+
+	ret = rte_kvargs_process(kvlist, ETH_UDP_REMOTE_ARG,
+				 &get_address_arg, &internals->remote);
+
+out:
+	rte_kvargs_free(kvlist);
+	return ret;
+}
+
+static int
+validate_parameters(struct pmd_internals *internals)
+{
+	int family = internals->remote.ss_family;
+
+	if (family == AF_UNSPEC) {
+		PMD_LOG(ERR, "remote address required");
+		return -EINVAL;
+	}
+
+	/*
+	 * if no local address is specified,
+	 * then use same port and  and let kernel choose.
+	 */
+	if (internals->local.ss_family == AF_UNSPEC) {
+		internals->local.ss_family = family;
+	} else if (internals->local.ss_family != family) {
+		PMD_LOG(ERR, "Local and remote address family differ");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int
+rte_pmd_udp_probe(struct rte_vdev_device *dev)
+{
+	struct pmd_internals *internals;
+	struct rte_eth_dev *eth_dev;
+	struct rte_eth_dev_data *data;
+	const char *name;
+	int ret;
+
+	name = rte_vdev_device_name(dev);
+
+	PMD_LOG(INFO, "Initializing pmd_udp for %s", name);
+
+	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
+		PMD_LOG(ERR, "Secondary not supported");
+		return -ENOTSUP;
+	}
+
+	eth_dev = rte_eth_vdev_allocate(dev, sizeof(*internals));
+	if (!eth_dev)
+		return -ENOMEM;
+
+	internals = eth_dev->data->dev_private;
+	internals->port_id = eth_dev->data->port_id;
+
+	ret = parse_parameters(internals, rte_vdev_device_args(dev));
+	if (ret < 0)
+		goto fail;
+
+	ret = validate_parameters(internals);
+	if (ret < 0)
+		goto fail;
+
+	/*
+	 * Note: first socket is used for transmit and for
+	 * receive queue 0.
+	 */
+	internals->sock_fd = create_socket(internals);
+	if (internals->sock_fd < 0) {
+		ret = errno ? -errno : -EINVAL;
+		goto fail;
+	}
+
+	rte_eth_random_addr(internals->eth_addr.addr_bytes);
+
+	data = eth_dev->data;
+	data->dev_link = pmd_link;
+	data->mac_addrs = &internals->eth_addr;
+	data->promiscuous = 1;
+	data->all_multicast = 1;
+
+	eth_dev->dev_ops = &ops;
+	eth_dev->rx_pkt_burst = eth_udp_rx;
+	eth_dev->tx_pkt_burst = eth_udp_tx;
+
+	rte_eth_dev_probing_finish(eth_dev);
+
+fail:
+	if (ret != 0) {
+		eth_dev->data->mac_addrs = NULL;
+		rte_eth_dev_release_port(eth_dev);
+	}
+
+	return ret;
+}
+
+static int
+rte_pmd_udp_remove(struct rte_vdev_device *dev)
+{
+	struct rte_eth_dev *eth_dev = NULL;
+	const char *name;
+
+	name = rte_vdev_device_name(dev);
+
+	PMD_LOG(INFO, "Closing udp ethdev %s", name);
+
+	/* find the ethdev entry */
+	eth_dev = rte_eth_dev_allocated(name);
+	if (eth_dev == NULL)
+		return -1;
+
+	/* mac_addrs must not be freed alone because part of dev_private */
+	if (rte_eal_process_type() == RTE_PROC_PRIMARY)
+		eth_dev->data->mac_addrs = NULL;
+
+	rte_eth_dev_release_port(eth_dev);
+
+	return 0;
+}
+
+static struct rte_vdev_driver pmd_udp_drv = {
+	.probe = rte_pmd_udp_probe,
+	.remove = rte_pmd_udp_remove,
+};
+
+RTE_PMD_REGISTER_VDEV(net_udp, pmd_udp_drv);
+RTE_PMD_REGISTER_ALIAS(net_udp, eth_udp);
+RTE_PMD_REGISTER_PARAM_STRING(net_udp,
+	"local=<string>"
+	"remote=<string>");
+
+RTE_INIT(eth_udp_init_log)
+{
+	eth_udp_logtype = rte_log_register("pmd.net.udp");
+	if (eth_udp_logtype >= 0)
+		rte_log_set_level(eth_udp_logtype, RTE_LOG_NOTICE);
+}
diff --git a/drivers/net/udp/version.map b/drivers/net/udp/version.map
new file mode 100644
index 000000000000..78c3585d7c6b
--- /dev/null
+++ b/drivers/net/udp/version.map
@@ -0,0 +1,3 @@
+DPDK_23 {
+	local: *;
+};
-- 
2.35.1