[RFC] net/ring: add veth-like peer link state tracking

[Stephen Hemminger]

The ring PMD currently reports link-up unconditionally when a port is
started, making it impossible for applications to detect whether the
other end of a ring-based virtual link is ready.

Add an optional peer-awareness mechanism modelled on the Linux veth
driver's carrier semantics.

Introduce the experimental API rte_eth_ring_attach_peer()
which pairs two ring PMD ports so that each port's link state
reflects whether its peer is started and administratively up.
Unpaired ports retain the existing behaviour.

Signed-off-by: Stephen Hemminger <stephen at networkplumber.org>
---
 app/test/test_pmd_ring.c               | 191 +++++++++++++++++++++++
 doc/guides/nics/ring.rst               |  42 +++++
 doc/guides/rel_notes/release_26_03.rst |   8 +
 drivers/net/ring/rte_eth_ring.c        | 205 ++++++++++++++++++++++++-
 drivers/net/ring/rte_eth_ring.h        |  26 ++++
 5 files changed, 468 insertions(+), 4 deletions(-)

diff --git a/app/test/test_pmd_ring.c b/app/test/test_pmd_ring.c
index cb08dcf1d9..c0ebc4fe29 100644
--- a/app/test/test_pmd_ring.c
+++ b/app/test/test_pmd_ring.c
@@ -425,6 +425,196 @@ test_pmd_ring_pair_create_attach(void)
 	return TEST_SUCCESS;
 }
 
+static int
+test_pmd_ring_link_status(void)
+{
+	struct rte_eth_conf null_conf;
+	struct rte_eth_link link_d, link_e;
+	struct rte_ring *ring_de[1], *ring_ed[1];
+	int portd, porte;
+	int ret;
+
+	printf("Testing veth-like link state via rte_eth_ring_attach_peer\n");
+
+	memset(&null_conf, 0, sizeof(struct rte_eth_conf));
+
+	/*
+	 * Create two cross-connected ring ports:
+	 *   portd TX -> ring_de -> porte RX
+	 *   porte TX -> ring_ed -> portd RX
+	 * Then pair them so link state reflects peer status.
+	 */
+	ring_de[0] = rte_ring_create("VETH_DE", RING_SIZE, SOCKET0,
+				     RING_F_SP_ENQ | RING_F_SC_DEQ);
+	ring_ed[0] = rte_ring_create("VETH_ED", RING_SIZE, SOCKET0,
+				     RING_F_SP_ENQ | RING_F_SC_DEQ);
+	if (ring_de[0] == NULL || ring_ed[0] == NULL) {
+		printf("Error creating veth rings\n");
+		return TEST_FAILED;
+	}
+
+	/* portd: RX from ring_ed, TX into ring_de */
+	portd = rte_eth_from_rings("net_vethd", ring_ed, 1, ring_de, 1, SOCKET0);
+	/* porte: RX from ring_de, TX into ring_ed */
+	porte = rte_eth_from_rings("net_vethe", ring_de, 1, ring_ed, 1, SOCKET0);
+	if (portd < 0 || porte < 0) {
+		printf("Error creating veth ethdev ports\n");
+		return TEST_FAILED;
+	}
+
+	/* Pair the ports for veth-like carrier detection */
+	ret = rte_eth_ring_attach_peer(portd, porte);
+	if (ret != 0) {
+		printf("Error: rte_eth_ring_attach_peer failed\n");
+		return TEST_FAILED;
+	}
+
+	/* Configure and set up queues */
+	if ((rte_eth_dev_configure(portd, 1, 1, &null_conf) < 0) ||
+	    (rte_eth_dev_configure(porte, 1, 1, &null_conf) < 0)) {
+		printf("Configure failed for veth pair\n");
+		return TEST_FAILED;
+	}
+
+	if ((rte_eth_tx_queue_setup(portd, 0, RING_SIZE, SOCKET0, NULL) < 0) ||
+	    (rte_eth_tx_queue_setup(porte, 0, RING_SIZE, SOCKET0, NULL) < 0)) {
+		printf("TX queue setup failed for veth pair\n");
+		return TEST_FAILED;
+	}
+
+	if ((rte_eth_rx_queue_setup(portd, 0, RING_SIZE, SOCKET0, NULL, mp) < 0) ||
+	    (rte_eth_rx_queue_setup(porte, 0, RING_SIZE, SOCKET0, NULL, mp) < 0)) {
+		printf("RX queue setup failed for veth pair\n");
+		return TEST_FAILED;
+	}
+
+	/*
+	 * Test 1: neither side started – both links should be down.
+	 */
+	printf("  Test 1: both stopped -> both links down\n");
+	ret = rte_eth_link_get_nowait(portd, &link_d);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	ret = rte_eth_link_get_nowait(porte, &link_e);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	if (link_d.link_status != RTE_ETH_LINK_DOWN ||
+	    link_e.link_status != RTE_ETH_LINK_DOWN) {
+		printf("Error: expected both links DOWN before start\n");
+		return TEST_FAILED;
+	}
+
+	/*
+	 * Test 2: start only one side – that side should report link down
+	 *         because the peer is not started yet (veth semantics).
+	 */
+	printf("  Test 2: start portd only -> portd link down (no peer)\n");
+	if (rte_eth_dev_start(portd) < 0) {
+		printf("Error starting portd\n");
+		return TEST_FAILED;
+	}
+	ret = rte_eth_link_get_nowait(portd, &link_d);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	ret = rte_eth_link_get_nowait(porte, &link_e);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	if (link_d.link_status != RTE_ETH_LINK_DOWN) {
+		printf("Error: portd link should be DOWN (peer not started)\n");
+		return TEST_FAILED;
+	}
+	if (link_e.link_status != RTE_ETH_LINK_DOWN) {
+		printf("Error: porte link should be DOWN (not started)\n");
+		return TEST_FAILED;
+	}
+
+	/*
+	 * Test 3: start the second side – both should now have carrier.
+	 */
+	printf("  Test 3: start porte -> both links up\n");
+	if (rte_eth_dev_start(porte) < 0) {
+		printf("Error starting porte\n");
+		return TEST_FAILED;
+	}
+	ret = rte_eth_link_get_nowait(portd, &link_d);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	ret = rte_eth_link_get_nowait(porte, &link_e);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	if (link_d.link_status != RTE_ETH_LINK_UP) {
+		printf("Error: portd link should be UP\n");
+		return TEST_FAILED;
+	}
+	if (link_e.link_status != RTE_ETH_LINK_UP) {
+		printf("Error: porte link should be UP\n");
+		return TEST_FAILED;
+	}
+
+	/*
+	 * Test 4: stop one side – peer should lose carrier.
+	 */
+	printf("  Test 4: stop portd -> both links down\n");
+	ret = rte_eth_dev_stop(portd);
+	if (ret != 0) {
+		printf("Error stopping portd: %s\n", rte_strerror(-ret));
+		return TEST_FAILED;
+	}
+	ret = rte_eth_link_get_nowait(portd, &link_d);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	ret = rte_eth_link_get_nowait(porte, &link_e);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	if (link_d.link_status != RTE_ETH_LINK_DOWN) {
+		printf("Error: portd link should be DOWN after stop\n");
+		return TEST_FAILED;
+	}
+	if (link_e.link_status != RTE_ETH_LINK_DOWN) {
+		printf("Error: porte should lose carrier when peer stops\n");
+		return TEST_FAILED;
+	}
+
+	/*
+	 * Test 5: restart the stopped side – both should come back up
+	 *         (porte was still started).
+	 */
+	printf("  Test 5: restart portd -> both links up again\n");
+	if (rte_eth_dev_start(portd) < 0) {
+		printf("Error restarting portd\n");
+		return TEST_FAILED;
+	}
+	ret = rte_eth_link_get_nowait(portd, &link_d);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	ret = rte_eth_link_get_nowait(porte, &link_e);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	if (link_d.link_status != RTE_ETH_LINK_UP ||
+	    link_e.link_status != RTE_ETH_LINK_UP) {
+		printf("Error: both links should be UP after restart\n");
+		return TEST_FAILED;
+	}
+
+	/*
+	 * Test 6: admin set_link_down on one side – peer should lose carrier.
+	 */
+	printf("  Test 6: set_link_down portd -> both links down\n");
+	rte_eth_dev_set_link_down(portd);
+	ret = rte_eth_link_get_nowait(portd, &link_d);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	ret = rte_eth_link_get_nowait(porte, &link_e);
+	TEST_ASSERT(ret >= 0, "Link get failed: %s", rte_strerror(-ret));
+	if (link_d.link_status != RTE_ETH_LINK_DOWN) {
+		printf("Error: portd link should be DOWN after set_link_down\n");
+		return TEST_FAILED;
+	}
+	if (link_e.link_status != RTE_ETH_LINK_DOWN) {
+		printf("Error: porte should lose carrier on peer set_link_down\n");
+		return TEST_FAILED;
+	}
+
+	/* Clean up */
+	rte_eth_dev_stop(portd);
+	rte_eth_dev_stop(porte);
+	rte_vdev_uninit("net_ring_net_vethd");
+	rte_vdev_uninit("net_ring_net_vethe");
+	rte_ring_free(ring_de[0]);
+	rte_ring_free(ring_ed[0]);
+
+	return TEST_SUCCESS;
+}
+
 static void
 test_cleanup_resources(void)
 {
@@ -582,6 +772,7 @@ unit_test_suite test_pmd_ring_suite  = {
 		TEST_CASE(test_get_stats_for_port),
 		TEST_CASE(test_stats_reset_for_port),
 		TEST_CASE(test_pmd_ring_pair_create_attach),
+		TEST_CASE(test_pmd_ring_link_status),
 		TEST_CASE(test_command_line_ring_port),
 		TEST_CASES_END()
 	}
diff --git a/doc/guides/nics/ring.rst b/doc/guides/nics/ring.rst
index a6b2458a7f..caa461a2f2 100644
--- a/doc/guides/nics/ring.rst
+++ b/doc/guides/nics/ring.rst
@@ -104,6 +104,48 @@ the final two lines can be changed as follows:
 This type of configuration is useful in a pipeline model where inter-core communication
 using pseudo Ethernet devices is preferred over raw rings for API consistency.
 
+Peer Link State (veth-like Carrier Detection)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+By default, a ring-based port reports link-up as soon as it is started,
+regardless of the state of any other port.  For use cases that model a
+virtual Ethernet cable between two ports, this can be changed by pairing
+the ports with ``rte_eth_ring_attach_peer()``.
+
+Once two ports are paired, their link state follows the same rules as the
+Linux veth driver:
+
+* The link comes up only when **both** sides are started.
+* Stopping, closing, or administratively setting link-down on one side
+  causes the other side to report link-down as well.
+* When the stopped side is restarted, both sides regain carrier.
+
+Pairing is supported for any two ring-based ports, whether they were created
+with ``rte_eth_from_rings()`` or via the ``--vdev=net_ring`` EAL option.
+
+.. code-block:: c
+
+   struct rte_ring *ring_ab, *ring_ba;
+
+   ring_ab = rte_ring_create("AB", 1024, 0, RING_F_SP_ENQ | RING_F_SC_DEQ);
+   ring_ba = rte_ring_create("BA", 1024, 0, RING_F_SP_ENQ | RING_F_SC_DEQ);
+
+   /* Port A: TX into ring_ab, RX from ring_ba */
+   int port_a = rte_eth_from_rings("veth_a", &ring_ba, 1, &ring_ab, 1, 0);
+   /* Port B: TX into ring_ba, RX from ring_ab */
+   int port_b = rte_eth_from_rings("veth_b", &ring_ab, 1, &ring_ba, 1, 0);
+
+   /* Enable veth-like link state tracking */
+   rte_eth_ring_attach_peer(port_a, port_b);
+
+   /* At this point both links are down.
+    * Starting port_a alone still shows link-down (peer is not ready).
+    * Starting port_b as well brings both links up.
+    */
+
+Unpaired ports (the default) are unaffected and retain the original
+behaviour where link-up is reported immediately on start.
+
 Enqueuing and dequeuing items from an ``rte_ring``
 using the ring-based PMD may be slower than using the native ring API.
 DPDK Ethernet drivers use function pointers
diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst
index 5c2a4bb32e..33fd354be8 100644
--- a/doc/guides/rel_notes/release_26_03.rst
+++ b/doc/guides/rel_notes/release_26_03.rst
@@ -82,6 +82,14 @@ New Features
   * NEA5, NIA5, NCA5: AES 256 confidentiality, integrity and AEAD modes.
   * NEA6, NIA6, NCA6: ZUC 256 confidentiality, integrity and AEAD modes.
 
+* **Updated ring-based PMD with veth-like link state.**
+
+  Added peer link state tracking to the ring-based PMD (``net_ring``).
+  Two ring PMD ports can now be paired via the new experimental
+  ``rte_eth_ring_attach_peer()`` API so that each port's link status
+  reflects whether its peer is started, mirroring the carrier semantics
+  of the Linux veth driver.  Unpaired ports retain the existing behaviour.
+
 
 Removed Items
 -------------
diff --git a/drivers/net/ring/rte_eth_ring.c b/drivers/net/ring/rte_eth_ring.c
index b639544eab..d7a8ee8796 100644
--- a/drivers/net/ring/rte_eth_ring.c
+++ b/drivers/net/ring/rte_eth_ring.c
@@ -59,6 +59,9 @@ struct pmd_internals {
 
 	struct rte_ether_addr address;
 	enum dev_action action;
+
+	uint16_t peer_port_id;	/**< port id of the peer, or RTE_MAX_ETHPORTS */
+	uint8_t link_admin_down; /**< true when set_link_down has been called */
 };
 
 static struct rte_eth_link pmd_link = {
@@ -111,13 +114,41 @@ 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;
+	struct pmd_internals *internals = dev->data->dev_private;
+
+	internals->link_admin_down = 0;
+
+	if (internals->peer_port_id < RTE_MAX_ETHPORTS) {
+		struct rte_eth_dev *peer = &rte_eth_devices[internals->peer_port_id];
+		struct pmd_internals *peer_internals = peer->data->dev_private;
+
+		/*
+		 * Veth-like carrier: link comes up only when the peer
+		 * is also started and not administratively down.
+		 * When we start, we also give the peer carrier if it
+		 * was already started.
+		 */
+		if (peer_internals != NULL &&
+		    peer_internals->peer_port_id == dev->data->port_id &&
+		    peer->data->dev_started &&
+		    !peer_internals->link_admin_down) {
+			dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
+			peer->data->dev_link.link_status = RTE_ETH_LINK_UP;
+		} else {
+			dev->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
+		}
+	} else {
+		/* Unpaired port: link follows admin state directly */
+		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 *internals = dev->data->dev_private;
 	uint16_t i;
 
 	dev->data->dev_started = 0;
@@ -127,14 +158,30 @@ eth_dev_stop(struct rte_eth_dev *dev)
 		dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
 	for (i = 0; i < dev->data->nb_tx_queues; i++)
 		dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
+
+	/*
+	 * When this side stops, the peer loses carrier,
+	 * mirroring Linux veth behavior.
+	 */
+	if (internals->peer_port_id < RTE_MAX_ETHPORTS) {
+		struct rte_eth_dev *peer = &rte_eth_devices[internals->peer_port_id];
+		struct pmd_internals *peer_internals = peer->data->dev_private;
+
+		if (peer_internals != NULL &&
+		    peer_internals->peer_port_id == dev->data->port_id)
+			peer->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
+	}
+
 	return 0;
 }
 
 static int
 eth_dev_set_link_down(struct rte_eth_dev *dev)
 {
+	struct pmd_internals *internals = dev->data->dev_private;
 	uint16_t i;
 
+	internals->link_admin_down = 1;
 	dev->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
 
 	for (i = 0; i < dev->data->nb_rx_queues; i++)
@@ -142,13 +189,47 @@ eth_dev_set_link_down(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_STOPPED;
 
+	/* Peer also loses carrier when this side is forced down */
+	if (internals->peer_port_id < RTE_MAX_ETHPORTS) {
+		struct rte_eth_dev *peer = &rte_eth_devices[internals->peer_port_id];
+		struct pmd_internals *peer_internals = peer->data->dev_private;
+
+		if (peer_internals != NULL &&
+		    peer_internals->peer_port_id == dev->data->port_id)
+			peer->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
+	}
+
 	return 0;
 }
 
 static int
 eth_dev_set_link_up(struct rte_eth_dev *dev)
 {
-	dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
+	struct pmd_internals *internals = dev->data->dev_private;
+
+	internals->link_admin_down = 0;
+
+	if (internals->peer_port_id < RTE_MAX_ETHPORTS) {
+		struct rte_eth_dev *peer = &rte_eth_devices[internals->peer_port_id];
+		struct pmd_internals *peer_internals = peer->data->dev_private;
+
+		/*
+		 * With a peer, link can only come up if the peer is also
+		 * started and not administratively down.
+		 */
+		if (peer_internals != NULL &&
+		    peer_internals->peer_port_id == dev->data->port_id &&
+		    peer->data->dev_started &&
+		    !peer_internals->link_admin_down) {
+			dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
+			peer->data->dev_link.link_status = RTE_ETH_LINK_UP;
+		} else {
+			dev->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
+		}
+	} else {
+		dev->data->dev_link.link_status = RTE_ETH_LINK_UP;
+	}
+
 	return 0;
 }
 
@@ -277,8 +358,38 @@ eth_allmulticast_disable(struct rte_eth_dev *dev __rte_unused)
 }
 
 static int
-eth_link_update(struct rte_eth_dev *dev __rte_unused,
-		int wait_to_complete __rte_unused) { return 0; }
+eth_link_update(struct rte_eth_dev *dev,
+		int wait_to_complete __rte_unused)
+{
+	struct pmd_internals *internals = dev->data->dev_private;
+	struct rte_eth_link link;
+
+	link = pmd_link;
+
+	if (!dev->data->dev_started || internals->link_admin_down) {
+		link.link_status = RTE_ETH_LINK_DOWN;
+	} else if (internals->peer_port_id < RTE_MAX_ETHPORTS) {
+		/*
+		 * Paired port: carrier depends on peer being started
+		 * and not administratively down, similar to Linux veth.
+		 */
+		struct rte_eth_dev *peer = &rte_eth_devices[internals->peer_port_id];
+		struct pmd_internals *peer_internals = peer->data->dev_private;
+
+		if (peer_internals != NULL &&
+		    peer_internals->peer_port_id == dev->data->port_id &&
+		    peer->data->dev_started &&
+		    !peer_internals->link_admin_down)
+			link.link_status = RTE_ETH_LINK_UP;
+		else
+			link.link_status = RTE_ETH_LINK_DOWN;
+	} else {
+		/* Unpaired port: link follows admin state */
+		link.link_status = dev->data->dev_link.link_status;
+	}
+
+	return rte_eth_linkstatus_set(dev, &link);
+}
 
 static int
 eth_dev_close(struct rte_eth_dev *dev)
@@ -294,6 +405,19 @@ eth_dev_close(struct rte_eth_dev *dev)
 	ret = eth_dev_stop(dev);
 
 	internals = dev->data->dev_private;
+
+	/* Unlink peer so it no longer references this port */
+	if (internals->peer_port_id < RTE_MAX_ETHPORTS) {
+		struct rte_eth_dev *peer = &rte_eth_devices[internals->peer_port_id];
+		struct pmd_internals *peer_internals = peer->data->dev_private;
+
+		if (peer_internals != NULL &&
+		    peer_internals->peer_port_id == dev->data->port_id)
+			peer_internals->peer_port_id = RTE_MAX_ETHPORTS;
+
+		internals->peer_port_id = RTE_MAX_ETHPORTS;
+	}
+
 	if (internals->action == DEV_CREATE) {
 		/*
 		 * it is only necessary to delete the rings in rx_queues because
@@ -420,6 +544,7 @@ do_eth_dev_ring_create(const char *name,
 	internals->action = action;
 	internals->max_rx_queues = nb_rx_queues;
 	internals->max_tx_queues = nb_tx_queues;
+	internals->peer_port_id = RTE_MAX_ETHPORTS;
 	for (i = 0; i < nb_rx_queues; i++) {
 		internals->rx_ring_queues[i].rng = rx_queues[i];
 		internals->rx_ring_queues[i].in_port = -1;
@@ -527,6 +652,49 @@ rte_eth_from_ring(struct rte_ring *r)
 			r->memzone ? r->memzone->socket_id : SOCKET_ID_ANY);
 }
 
+RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_eth_ring_attach_peer, 26.03)
+int
+rte_eth_ring_attach_peer(uint16_t port_id_a, uint16_t port_id_b)
+{
+	struct rte_eth_dev *dev_a, *dev_b;
+	struct pmd_internals *internals_a, *internals_b;
+
+	if (port_id_a >= RTE_MAX_ETHPORTS || port_id_b >= RTE_MAX_ETHPORTS ||
+	    port_id_a == port_id_b) {
+		rte_errno = EINVAL;
+		return -1;
+	}
+
+	dev_a = &rte_eth_devices[port_id_a];
+	dev_b = &rte_eth_devices[port_id_b];
+
+	/* Verify both are ring PMD ports */
+	if (dev_a->dev_ops != &ops || dev_b->dev_ops != &ops) {
+		rte_errno = EINVAL;
+		return -1;
+	}
+
+	internals_a = dev_a->data->dev_private;
+	internals_b = dev_b->data->dev_private;
+
+	if (internals_a == NULL || internals_b == NULL) {
+		rte_errno = EINVAL;
+		return -1;
+	}
+
+	/* Neither port may already have a peer */
+	if (internals_a->peer_port_id < RTE_MAX_ETHPORTS ||
+	    internals_b->peer_port_id < RTE_MAX_ETHPORTS) {
+		rte_errno = EBUSY;
+		return -1;
+	}
+
+	internals_a->peer_port_id = port_id_b;
+	internals_b->peer_port_id = port_id_a;
+
+	return 0;
+}
+
 static int
 eth_dev_ring_create(const char *name,
 		struct rte_vdev_device *vdev,
@@ -564,6 +732,35 @@ eth_dev_ring_create(const char *name,
 		numa_node, action, eth_dev) < 0)
 		return -1;
 
+	/*
+	 * For ATTACH, find the CREATE peer that shares our rings and
+	 * establish a bidirectional peer link. This allows veth-like
+	 * carrier detection: each side's link state reflects whether
+	 * the other side is started.
+	 */
+	if (action == DEV_ATTACH) {
+		struct pmd_internals *internals = (*eth_dev)->data->dev_private;
+		uint16_t pid;
+
+		RTE_ETH_FOREACH_DEV(pid) {
+			struct rte_eth_dev *candidate = &rte_eth_devices[pid];
+			struct pmd_internals *ci;
+
+			if (candidate == *eth_dev)
+				continue;
+			ci = candidate->data->dev_private;
+			if (ci == NULL || ci->action != DEV_CREATE)
+				continue;
+
+			/* Check if the candidate shares our rings */
+			if (ci->rx_ring_queues[0].rng == internals->rx_ring_queues[0].rng) {
+				internals->peer_port_id = pid;
+				ci->peer_port_id = (*eth_dev)->data->port_id;
+				break;
+			}
+		}
+	}
+
 	return 0;
 }
 
diff --git a/drivers/net/ring/rte_eth_ring.h b/drivers/net/ring/rte_eth_ring.h
index 98292c7b33..5bb619198a 100644
--- a/drivers/net/ring/rte_eth_ring.h
+++ b/drivers/net/ring/rte_eth_ring.h
@@ -5,6 +5,7 @@
 #ifndef _RTE_ETH_RING_H_
 #define _RTE_ETH_RING_H_
 
+#include <rte_compat.h>
 #include <rte_ring.h>
 
 #ifdef __cplusplus
@@ -50,6 +51,31 @@ int rte_eth_from_rings(const char *name,
  */
 int rte_eth_from_ring(struct rte_ring *r);
 
+/**
+ * @warning
+ * @b EXPERIMENTAL: this API may change without prior notice.
+ *
+ * Attach two ring-backed ethdev ports as peers.
+ *
+ * After this call the link state of each port reflects whether its
+ * peer is started, similar to how carrier is handled on Linux veth
+ * devices.  Stopping, closing, or setting link-down on one side will
+ * cause the other side to report link-down as well.
+ *
+ * Only ring-backed ports (created by rte_eth_from_rings or the
+ * net_ring vdev driver) can be paired.  A port that already has a
+ * peer must be un-paired first (by closing or removing it).
+ *
+ * @param port_id_a
+ *    port id of the first ring-backed ethdev
+ * @param port_id_b
+ *    port id of the second ring-backed ethdev
+ * @return
+ *    0 on success, -1 on error (rte_errno is set).
+ */
+__rte_experimental
+int rte_eth_ring_attach_peer(uint16_t port_id_a, uint16_t port_id_b);
+
 #ifdef __cplusplus
 }
 #endif
-- 
2.51.0