hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[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>
This commit is contained in:
Herbert Xu 2007-05-08 18:36:28 -07:00 committed by David S. Miller
parent 572a103ded
commit 294cc44b7e
1 changed files with 67 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
net/core/link_watch.c
View File

@ -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);
}
/* Must be called with the rtnl semaphore held */
void linkwatch_run_queue(void)
{
__linkwatch_run_queue(0);
}
static void linkwatch_event(struct work_struct *dummy)
{
/* 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);
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);
}
}