[PATCH net-next v3 3/6] net: guard memory provider RX queue open and close on unregister

From: Mina Almasry

Date: Sat Nov 14 2026 - 21:26:39 EST


When an RX queue is leased from a physical backing net_device to a
virtual net_device (e.g., netkit), memory provider operations reach the
physical net_device through rxq->lease and lock it directly via
netdev_lock(dev) rather than looking it up via
netdev_get_by_index_lock().

Introduce a netif_lease_valid() helper checking netif_is_alive(dev)
under netdev_lock(dev) and use it in the lease-aware callers while
keeping __netif_mp_open_rxq() and __netif_mp_close_rxq() unaware of
queue leasing:

1. In netif_mp_open_rxq(), if the leased physical device is already
unregistering (!netif_lease_valid(dev)), netdev_get_by_index_lock()
on the virtual netdev succeeds before cascaded unregistration runs,
allowing a new memory provider to be installed on the physical device
while it is unregistering. Reject the open with -ENODEV.

2. In netif_mp_close_rxq() and netif_rxq_cleanup_unlease(),
__netif_mp_close_rxq() reconfigures the physical RX queue so that it
can continue operating with a regular page_pool when the physical
netdev outlives the virtual queue or memory provider. When the
physical backing netdev is itself unregistering
(!netif_lease_valid(dev)), its queue will not outlive the lease and,
matching the non-leased unregistration path (where
dev_memory_provider_uninstall() detaches the provider without calling
netdev_rx_queue_reconfig()), the physical queue should not be
reconfigured. However, unlike non-leased queues,
mp_dmabuf_devmem_uninstall() on the physical netdev does not match
bound_rxqs (which stores the virtual rxq), leaving
phys_rxq->mp_params populated until socket teardown or the virtual
leasee's netif_rxq_cleanup_unlease() runs. When
!netif_lease_valid(dev), skip __netif_mp_close_rxq() and clear
mp_params on the physical queue directly so that a subsequent
netif_rxq_cleanup_unlease() or dev_memory_provider_uninstall() sees
!mp_ops and does not uninstall a second time.

Suggested-by: Stanislav Fomichev <sdf@xxxxxxxxxxx>
Signed-off-by: Mina Almasry <almasrymina@xxxxxxxxxx>
---
net/core/dev.h | 7 +++++++
net/core/netdev_rx_queue.c | 31 ++++++++++++++++++++++++++-----
2 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/net/core/dev.h b/net/core/dev.h
index 4e9e8cd156977..50cfede051db1 100644
--- a/net/core/dev.h
+++ b/net/core/dev.h
@@ -119,6 +119,13 @@ bool netif_rxq_has_mp(struct net_device *dev, unsigned int rxq_idx);
bool netif_rxq_is_leased(struct net_device *dev, unsigned int rxq_idx);
bool netif_is_queue_leasee(const struct net_device *dev);

+static inline bool netif_lease_valid(const struct net_device *dev)
+{
+ netdev_assert_locked(dev);
+
+ return netif_is_alive(dev);
+}
+
void __netif_mp_uninstall_rxq(struct netdev_rx_queue *rxq,
const struct pp_memory_provider_params *p);

diff --git a/net/core/netdev_rx_queue.c b/net/core/netdev_rx_queue.c
index a7261fedd5e76..98b51b2ac8ee1 100644
--- a/net/core/netdev_rx_queue.c
+++ b/net/core/netdev_rx_queue.c
@@ -270,7 +270,12 @@ int netif_mp_open_rxq(struct net_device *dev, unsigned int rxq_idx,
}

netdev_lock(dev);
- ret = __netif_mp_open_rxq(dev, rxq_idx, p, extack);
+ if (netif_lease_valid(dev)) {
+ ret = __netif_mp_open_rxq(dev, rxq_idx, p, extack);
+ } else {
+ NL_SET_ERR_MSG(extack, "Device is being unregistered");
+ ret = -ENODEV;
+ }
netdev_unlock(dev);
return ret;
}
@@ -309,19 +314,29 @@ static int __netif_mp_close_rxq(struct net_device *dev, unsigned int rxq_idx,
int netif_mp_close_rxq(struct net_device *dev, unsigned int rxq_idx,
const struct pp_memory_provider_params *old_p)
{
- int ret;
+ struct netdev_rx_queue *rxq;
+ int ret = 0;

if (WARN_ON_ONCE(rxq_idx >= dev->real_num_rx_queues))
return -EINVAL;
if (!netif_rxq_is_leased(dev, rxq_idx))
return __netif_mp_close_rxq(dev, rxq_idx, old_p);

- if (!__netif_get_rx_queue_lease(&dev, &rxq_idx, NETIF_VIRT_TO_PHYS)) {
+ rxq = __netif_get_rx_queue_lease(&dev, &rxq_idx, NETIF_VIRT_TO_PHYS);
+ if (!rxq) {
WARN_ON_ONCE(1);
return -EINVAL;
}
netdev_lock(dev);
- ret = __netif_mp_close_rxq(dev, rxq_idx, old_p);
+ /* If the physical netdev is already unregistering, the queue will not
+ * outlive the lease; only clear mp_params so subsequent
+ * netif_rxq_cleanup_unlease() or dev_memory_provider_uninstall() is a
+ * no-op.
+ */
+ if (netif_lease_valid(dev))
+ ret = __netif_mp_close_rxq(dev, rxq_idx, old_p);
+ else
+ memset(&rxq->mp_params, 0, sizeof(rxq->mp_params));
netdev_unlock(dev);
return ret;
}
@@ -340,6 +355,9 @@ void __netif_mp_uninstall_rxq(struct netdev_rx_queue *rxq,
* the lease redirection. The extra __netif_mp_close_rxq is needed
* since the physical queue can outlive the virtual queue in the lease
* case, so it needs to be reconfigured to clear the memory provider.
+ * If the physical netdev is also unregistering, its queue will not
+ * outlive the lease, so only clear mp_params without reconfiguring the
+ * queue.
*/
void netif_rxq_cleanup_unlease(struct netdev_rx_queue *phys_rxq,
struct netdev_rx_queue *virt_rxq)
@@ -350,6 +368,9 @@ void netif_rxq_cleanup_unlease(struct netdev_rx_queue *phys_rxq,
if (!p.mp_ops)
return;

- __netif_mp_close_rxq(phys_rxq->dev, rxq_idx, &p);
+ if (netif_lease_valid(phys_rxq->dev))
+ __netif_mp_close_rxq(phys_rxq->dev, rxq_idx, &p);
+ else
+ memset(&phys_rxq->mp_params, 0, sizeof(phys_rxq->mp_params));
__netif_mp_uninstall_rxq(virt_rxq, &p);
}
--
2.56.0.611.g1030f0b940-goog