[NET]: Remove link_watch delay for up even when we're down

Currently all link carrier events are delayed by up to a second
before they're processed to prevent link storms.  This causes
unnecessary packet loss during that interval.

In fact, we can achieve the same effect in preventing storms by
only delaying down events and unnecssary up events.  The latter
is defined as up events when we're already up.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/net/core/link_watch.c b/net/core/link_watch.c
index 71a35da275d4fd24c2d696b00031ca5836495b46..b5f45799c2f3905300fac9d4eb061cae89534731 100644 (file)
--- a/net/core/link_watch.c
+++ b/net/core/link_watch.c
@@ -77,11 +77,52 @@ static void rfc2863_policy(struct net_device *dev)
 }
 
 
-/* Must be called with the rtnl semaphore held */
-void linkwatch_run_queue(void)
+static int linkwatch_urgent_event(struct net_device *dev)
+{
+       return netif_running(dev) && netif_carrier_ok(dev) &&
+              dev->qdisc != dev->qdisc_sleeping;
+}
+
+
+static void linkwatch_add_event(struct net_device *dev)
+{
+       unsigned long flags;
+
+       spin_lock_irqsave(&lweventlist_lock, flags);
+       dev->link_watch_next = lweventlist;
+       lweventlist = dev;
+       spin_unlock_irqrestore(&lweventlist_lock, flags);
+}
+
+
+static void linkwatch_schedule_work(unsigned long delay)
+{
+       if (test_and_set_bit(LW_RUNNING, &linkwatch_flags))
+               return;
+
+       /* If we wrap around we'll delay it by at most HZ. */
+       if (delay > HZ)
+               delay = 0;
+
+       schedule_delayed_work(&linkwatch_work, delay);
+}
+
+
+static void __linkwatch_run_queue(int urgent_only)
 {
        struct net_device *next;
 
+       /*
+        * Limit the number of linkwatch events to one
+        * per second so that a runaway driver does not
+        * cause a storm of messages on the netlink
+        * socket.  This limit does not apply to up events
+        * while the device qdisc is down.
+        */
+       if (!urgent_only)
+               linkwatch_nextevent = jiffies + HZ;
+       clear_bit(LW_RUNNING, &linkwatch_flags);
+
        spin_lock_irq(&lweventlist_lock);
        next = lweventlist;
        lweventlist = NULL;
@@ -92,6 +133,11 @@ void linkwatch_run_queue(void)
 
                next = dev->link_watch_next;
 
+               if (urgent_only && !linkwatch_urgent_event(dev)) {
+                       linkwatch_add_event(dev);
+                       continue;
+               }
+
                /*
                 * Make sure the above read is complete since it can be
                 * rewritten as soon as we clear the bit below.
@@ -116,21 +162,23 @@ void linkwatch_run_queue(void)
 
                dev_put(dev);
        }
+
+       if (lweventlist)
+               linkwatch_schedule_work(linkwatch_nextevent - jiffies);
 }
 
 
-static void linkwatch_event(struct work_struct *dummy)
+/* Must be called with the rtnl semaphore held */
+void linkwatch_run_queue(void)
 {
-       /* Limit the number of linkwatch events to one
-        * per second so that a runaway driver does not
-        * cause a storm of messages on the netlink
-        * socket
-        */
-       linkwatch_nextevent = jiffies + HZ;
-       clear_bit(LW_RUNNING, &linkwatch_flags);
+       __linkwatch_run_queue(0);
+}
+
 
+static void linkwatch_event(struct work_struct *dummy)
+{
        rtnl_lock();
-       linkwatch_run_queue();
+       __linkwatch_run_queue(time_after(linkwatch_nextevent, jiffies));
        rtnl_unlock();
 }
 
@@ -138,23 +186,19 @@ static void linkwatch_event(struct work_struct *dummy)
 void linkwatch_fire_event(struct net_device *dev)
 {
        if (!test_and_set_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state)) {
-               unsigned long flags;
+               unsigned long delay;
 
                dev_hold(dev);
 
-               spin_lock_irqsave(&lweventlist_lock, flags);
-               dev->link_watch_next = lweventlist;
-               lweventlist = dev;
-               spin_unlock_irqrestore(&lweventlist_lock, flags);
+               linkwatch_add_event(dev);
 
-               if (!test_and_set_bit(LW_RUNNING, &linkwatch_flags)) {
-                       unsigned long delay = linkwatch_nextevent - jiffies;
+               delay = linkwatch_nextevent - jiffies;
 
-                       /* If we wrap around we'll delay it by at most HZ. */
-                       if (delay > HZ)
-                               delay = 0;
-                       schedule_delayed_work(&linkwatch_work, delay);
-               }
+               /* Minimise down-time: drop delay for up event. */
+               if (linkwatch_urgent_event(dev))
+                       delay = 0;
+
+               linkwatch_schedule_work(delay);
        }
 }