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. These issues were discovered during AI code review (Sashiko) of the earlier non-leased devmem unregister series and confirmed by code inspection (not observed in production or reproduced on real hardware). Tested with the nl_netdev.py selftest on netdevsim added in this series. Suggested-by: Stanislav Fomichev Signed-off-by: Mina Almasry --- 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.1.750.gf70dc682cf-goog