net: add retry mechanism to ndo_set_rx_mode_async

When ndo_set_rx_mode_async returns an error, schedule a retry with
exponential backoff (1s, 2s, 4s, 8s -- 15s total). Give up after the
4th retry and log an error via netdev_err().

This moves retry logic from individual drivers into the core stack.

Timer callback does not hold a ref on dev. Safe because the timer can
only be armed when dev is IFF_UP, and __dev_close_many runs
timer_delete_sync before clearing IFF_UP. Unregister always closes
IFF_UP devices first, so by the time dev can be freed the timer is
dead and cannot be re-armed.

Reviewed-by: Jakub Kicinski <kuba@kernel.org>
Signed-off-by: Stanislav Fomichev <sdf@fomichev.me>
Link: https://patch.msgid.link/20260608154014.227538-3-sdf@fomichev.me
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 51ec2df020943ddc6619c7763d6b2e304b0fb9cf..7f4f0837c09f9b5e76db76607f8f799cff010cb0 100644 (file)
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -1933,6 +1933,8 @@ enum netdev_reg_state {
  *     @rx_mode_node:          List entry for rx_mode work processing
  *     @rx_mode_tracker:       Refcount tracker for rx_mode work
  *     @rx_mode_addr_cache:    Recycled snapshot entries for rx_mode work
+ *     @rx_mode_retry_timer:   Timer that re-queues rx_mode work after failure
+ *     @rx_mode_retry_count:   Number of consecutive retries already scheduled
  *     @uc:                    unicast mac addresses
  *     @mc:                    multicast mac addresses
  *     @dev_addrs:             list of device hw addresses
@@ -2326,6 +2328,8 @@ struct net_device {
        struct list_head        rx_mode_node;
        netdevice_tracker       rx_mode_tracker;
        struct netdev_hw_addr_list      rx_mode_addr_cache;
+       struct timer_list       rx_mode_retry_timer;
+       unsigned int            rx_mode_retry_count;
 #ifdef CONFIG_LOCKDEP
        unsigned char           nested_level;
 #endif
@@ -5152,6 +5156,7 @@ static inline void __dev_mc_unsync(struct net_device *dev,
 
 /* Functions used for secondary unicast and multicast support */
 void dev_set_rx_mode(struct net_device *dev);
+void netif_rx_mode_schedule_retry(struct net_device *dev);
 int netif_set_promiscuity(struct net_device *dev, int inc);
 int dev_set_promiscuity(struct net_device *dev, int inc);
 int netif_set_allmulti(struct net_device *dev, int inc, bool notify);

diff --git a/net/core/dev.c b/net/core/dev.c
index 1ecd5691992ea46634fd869bd9e278b254fea1e6..202e35acb15b441e046a094cb443d3769c5174ee 100644 (file)
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1775,6 +1775,7 @@ static void __dev_close_many(struct list_head *head)
                if (ops->ndo_stop)
                        ops->ndo_stop(dev);
 
+               netif_rx_mode_cancel_retry(dev);
                netif_set_up(dev, false);
                netpoll_poll_enable(dev);
        }
@@ -12094,8 +12095,7 @@ struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
 #endif
 
        mutex_init(&dev->lock);
-       INIT_LIST_HEAD(&dev->rx_mode_node);
-       __hw_addr_init(&dev->rx_mode_addr_cache);
+       netif_rx_mode_init(dev);
 
        dev->priv_flags = IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM;
        setup(dev);

diff --git a/net/core/dev.h b/net/core/dev.h
index 9e94314408695be763320aa8282340842f7303e2..4121c50e7c88bee1312a36a72517c3d55391dd11 100644 (file)
--- a/net/core/dev.h
+++ b/net/core/dev.h
@@ -166,8 +166,10 @@ int dev_change_carrier(struct net_device *dev, bool new_carrier);
 
 void __dev_set_rx_mode(struct net_device *dev);
 int __dev_set_promiscuity(struct net_device *dev, int inc, bool notify);
+void netif_rx_mode_init(struct net_device *dev);
 bool netif_rx_mode_clean(struct net_device *dev);
 void netif_rx_mode_sync(struct net_device *dev);
+void netif_rx_mode_cancel_retry(struct net_device *dev);
 
 void __dev_notify_flags(struct net_device *dev, unsigned int old_flags,
                        unsigned int gchanges, u32 portid,

diff --git a/net/core/dev_addr_lists.c b/net/core/dev_addr_lists.c
index 6b493af8dc8be363f87fd66b764649997ac73915..e17f64a65e17be606d05c2ab7add02c11f2167a9 100644 (file)
--- a/net/core/dev_addr_lists.c
+++ b/net/core/dev_addr_lists.c
@@ -1252,6 +1252,35 @@ static int netif_uc_promisc_update(struct net_device *dev)
        return 0;
 }
 
+/* Total retry budget (4): 1+2+4+8 = 15 seconds */
+#define NETIF_RX_MODE_RETRY_MAX        4
+
+void netif_rx_mode_schedule_retry(struct net_device *dev)
+{
+       unsigned long delay;
+
+       netdev_assert_locked_ops_compat(dev);
+
+       if (dev->rx_mode_retry_count >= NETIF_RX_MODE_RETRY_MAX) {
+               netdev_err(dev, "rx_mode retry limit reached, giving up\n");
+               return;
+       }
+
+       delay = HZ << dev->rx_mode_retry_count;
+       if (mod_timer(&dev->rx_mode_retry_timer, jiffies + delay))
+               return;
+       if (!dev->rx_mode_retry_count)
+               netdev_info(dev, "rx_mode install failed, retrying with backoff\n");
+       dev->rx_mode_retry_count++;
+}
+EXPORT_SYMBOL_GPL(netif_rx_mode_schedule_retry);
+
+void netif_rx_mode_cancel_retry(struct net_device *dev)
+{
+       timer_delete_sync(&dev->rx_mode_retry_timer);
+       dev->rx_mode_retry_count = 0;
+}
+
 static void netif_rx_mode_run(struct net_device *dev)
 {
        struct netdev_hw_addr_list uc_snap, mc_snap, uc_ref, mc_ref;
@@ -1275,8 +1304,8 @@ static void netif_rx_mode_run(struct net_device *dev)
                err = netif_addr_lists_snapshot(dev, &uc_snap, &mc_snap,
                                                &uc_ref, &mc_ref);
                if (err) {
-                       netdev_WARN(dev, "failed to sync uc/mc addresses\n");
                        netif_addr_unlock_bh(dev);
+                       netif_rx_mode_schedule_retry(dev);
                        return;
                }
 
@@ -1292,12 +1321,17 @@ static void netif_rx_mode_run(struct net_device *dev)
                __dev_set_promiscuity(dev, promisc_inc, false);
 
        if (ops->ndo_set_rx_mode_async) {
-               ops->ndo_set_rx_mode_async(dev, &uc_snap, &mc_snap);
+               err = ops->ndo_set_rx_mode_async(dev, &uc_snap, &mc_snap);
 
                netif_addr_lock_bh(dev);
                netif_addr_lists_reconcile(dev, &uc_snap, &mc_snap,
                                           &uc_ref, &mc_ref);
                netif_addr_unlock_bh(dev);
+
+               if (err)
+                       netif_rx_mode_schedule_retry(dev);
+               else
+                       dev->rx_mode_retry_count = 0;
        } else if (ops->ndo_set_rx_mode) {
                netif_addr_lock_bh(dev);
                ops->ndo_set_rx_mode(dev);
@@ -1350,6 +1384,21 @@ static void netif_rx_mode_queue(struct net_device *dev)
        schedule_work(&rx_mode_work);
 }
 
+static void netif_rx_mode_retry(struct timer_list *t)
+{
+       struct net_device *dev =
+               timer_container_of(dev, t, rx_mode_retry_timer);
+
+       netif_rx_mode_queue(dev);
+}
+
+void netif_rx_mode_init(struct net_device *dev)
+{
+       INIT_LIST_HEAD(&dev->rx_mode_node);
+       __hw_addr_init(&dev->rx_mode_addr_cache);
+       timer_setup(&dev->rx_mode_retry_timer, netif_rx_mode_retry, 0);
+}
+
 /**
  * __dev_set_rx_mode() - upload unicast and multicast address lists to device
  * and configure RX filtering.