2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Linux network device link state notification
|
|
|
|
*
|
|
|
|
* Author:
|
|
|
|
* Stefan Rompf <sux@loplof.de>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/if.h>
|
|
|
|
#include <net/sock.h>
|
2005-05-03 17:18:52 -06:00
|
|
|
#include <net/pkt_sched.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/rtnetlink.h>
|
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <asm/types.h>
|
|
|
|
|
|
|
|
|
|
|
|
enum lw_bits {
|
2007-05-09 01:17:30 -06:00
|
|
|
LW_URGENT = 0,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static unsigned long linkwatch_flags;
|
|
|
|
static unsigned long linkwatch_nextevent;
|
|
|
|
|
2006-11-22 07:55:48 -07:00
|
|
|
static void linkwatch_event(struct work_struct *dummy);
|
|
|
|
static DECLARE_DELAYED_WORK(linkwatch_work, linkwatch_event);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
linkwatch: linkwatch_forget_dev() to speedup device dismantle
Herbert Xu a écrit :
> On Tue, Nov 17, 2009 at 04:26:04AM -0800, David Miller wrote:
>> Really, the link watch stuff is just due for a redesign. I don't
>> think a simple hack is going to cut it this time, sorry Eric :-)
>
> I have no objections against any redesigns, but since the only
> caller of linkwatch_forget_dev runs in process context with the
> RTNL, it could also legally emit those events.
Thanks guys, here an updated version then, before linkwatch surgery ?
In this version, I force the event to be sent synchronously.
[PATCH net-next-2.6] linkwatch: linkwatch_forget_dev() to speedup device dismantle
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.266s
user 0m0.000s
sys 0m0.001s
real 0m0.770s
user 0m0.000s
sys 0m0.000s
real 0m1.022s
user 0m0.000s
sys 0m0.000s
One problem of current schem in vlan dismantle phase is the
holding of device done by following chain :
vlan_dev_stop() ->
netif_carrier_off(dev) ->
linkwatch_fire_event(dev) ->
dev_hold() ...
And __linkwatch_run_queue() runs up to one second later...
A generic fix to this problem is to add a linkwatch_forget_dev() method
to unlink the device from the list of watched devices.
dev->link_watch_next becomes dev->link_watch_list (and use a bit more memory),
to be able to unlink device in O(1).
After patch :
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.024s
user 0m0.000s
sys 0m0.000s
real 0m0.032s
user 0m0.000s
sys 0m0.001s
real 0m0.033s
user 0m0.000s
sys 0m0.000s
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-11-16 22:59:21 -07:00
|
|
|
static LIST_HEAD(lweventlist);
|
2005-04-16 16:20:36 -06:00
|
|
|
static DEFINE_SPINLOCK(lweventlist_lock);
|
|
|
|
|
2006-03-20 18:09:11 -07:00
|
|
|
static unsigned char default_operstate(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
if (!netif_carrier_ok(dev))
|
|
|
|
return (dev->ifindex != dev->iflink ?
|
|
|
|
IF_OPER_LOWERLAYERDOWN : IF_OPER_DOWN);
|
|
|
|
|
|
|
|
if (netif_dormant(dev))
|
|
|
|
return IF_OPER_DORMANT;
|
|
|
|
|
|
|
|
return IF_OPER_UP;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void rfc2863_policy(struct net_device *dev)
|
|
|
|
{
|
|
|
|
unsigned char operstate = default_operstate(dev);
|
|
|
|
|
|
|
|
if (operstate == dev->operstate)
|
|
|
|
return;
|
|
|
|
|
|
|
|
write_lock_bh(&dev_base_lock);
|
|
|
|
|
|
|
|
switch(dev->link_mode) {
|
|
|
|
case IF_LINK_MODE_DORMANT:
|
|
|
|
if (operstate == IF_OPER_UP)
|
|
|
|
operstate = IF_OPER_DORMANT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IF_LINK_MODE_DEFAULT:
|
|
|
|
default:
|
|
|
|
break;
|
2007-04-20 18:09:22 -06:00
|
|
|
}
|
2006-03-20 18:09:11 -07:00
|
|
|
|
|
|
|
dev->operstate = operstate;
|
|
|
|
|
|
|
|
write_unlock_bh(&dev_base_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-09 00:01:06 -06:00
|
|
|
static bool linkwatch_urgent_event(struct net_device *dev)
|
2007-05-08 19:36:28 -06:00
|
|
|
{
|
|
|
|
return netif_running(dev) && netif_carrier_ok(dev) &&
|
2008-07-09 00:01:06 -06:00
|
|
|
qdisc_tx_changing(dev);
|
2007-05-08 19:36:28 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void linkwatch_add_event(struct net_device *dev)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&lweventlist_lock, flags);
|
linkwatch: linkwatch_forget_dev() to speedup device dismantle
Herbert Xu a écrit :
> On Tue, Nov 17, 2009 at 04:26:04AM -0800, David Miller wrote:
>> Really, the link watch stuff is just due for a redesign. I don't
>> think a simple hack is going to cut it this time, sorry Eric :-)
>
> I have no objections against any redesigns, but since the only
> caller of linkwatch_forget_dev runs in process context with the
> RTNL, it could also legally emit those events.
Thanks guys, here an updated version then, before linkwatch surgery ?
In this version, I force the event to be sent synchronously.
[PATCH net-next-2.6] linkwatch: linkwatch_forget_dev() to speedup device dismantle
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.266s
user 0m0.000s
sys 0m0.001s
real 0m0.770s
user 0m0.000s
sys 0m0.000s
real 0m1.022s
user 0m0.000s
sys 0m0.000s
One problem of current schem in vlan dismantle phase is the
holding of device done by following chain :
vlan_dev_stop() ->
netif_carrier_off(dev) ->
linkwatch_fire_event(dev) ->
dev_hold() ...
And __linkwatch_run_queue() runs up to one second later...
A generic fix to this problem is to add a linkwatch_forget_dev() method
to unlink the device from the list of watched devices.
dev->link_watch_next becomes dev->link_watch_list (and use a bit more memory),
to be able to unlink device in O(1).
After patch :
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.024s
user 0m0.000s
sys 0m0.000s
real 0m0.032s
user 0m0.000s
sys 0m0.001s
real 0m0.033s
user 0m0.000s
sys 0m0.000s
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-11-16 22:59:21 -07:00
|
|
|
if (list_empty(&dev->link_watch_list)) {
|
|
|
|
list_add_tail(&dev->link_watch_list, &lweventlist);
|
|
|
|
dev_hold(dev);
|
|
|
|
}
|
2007-05-08 19:36:28 -06:00
|
|
|
spin_unlock_irqrestore(&lweventlist_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-05-09 01:17:30 -06:00
|
|
|
static void linkwatch_schedule_work(int urgent)
|
2007-05-08 19:36:28 -06:00
|
|
|
{
|
2007-05-09 01:17:30 -06:00
|
|
|
unsigned long delay = linkwatch_nextevent - jiffies;
|
|
|
|
|
|
|
|
if (test_bit(LW_URGENT, &linkwatch_flags))
|
2007-05-08 19:36:28 -06:00
|
|
|
return;
|
|
|
|
|
2007-05-09 01:17:30 -06:00
|
|
|
/* Minimise down-time: drop delay for up event. */
|
|
|
|
if (urgent) {
|
|
|
|
if (test_and_set_bit(LW_URGENT, &linkwatch_flags))
|
|
|
|
return;
|
2007-05-08 19:36:28 -06:00
|
|
|
delay = 0;
|
2007-05-09 00:22:43 -06:00
|
|
|
}
|
2007-05-08 19:36:28 -06:00
|
|
|
|
2007-05-09 01:17:30 -06:00
|
|
|
/* If we wrap around we'll delay it by at most HZ. */
|
|
|
|
if (delay > HZ)
|
|
|
|
delay = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is true if we've scheduled it immeditately or if we don't
|
|
|
|
* need an immediate execution and it's already pending.
|
|
|
|
*/
|
|
|
|
if (schedule_delayed_work(&linkwatch_work, delay) == !delay)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Don't bother if there is nothing urgent. */
|
|
|
|
if (!test_bit(LW_URGENT, &linkwatch_flags))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* It's already running which is good enough. */
|
|
|
|
if (!cancel_delayed_work(&linkwatch_work))
|
|
|
|
return;
|
|
|
|
|
2011-03-30 19:57:33 -06:00
|
|
|
/* Otherwise we reschedule it again for immediate execution. */
|
2007-05-09 01:17:30 -06:00
|
|
|
schedule_delayed_work(&linkwatch_work, 0);
|
2007-05-08 19:36:28 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
linkwatch: linkwatch_forget_dev() to speedup device dismantle
Herbert Xu a écrit :
> On Tue, Nov 17, 2009 at 04:26:04AM -0800, David Miller wrote:
>> Really, the link watch stuff is just due for a redesign. I don't
>> think a simple hack is going to cut it this time, sorry Eric :-)
>
> I have no objections against any redesigns, but since the only
> caller of linkwatch_forget_dev runs in process context with the
> RTNL, it could also legally emit those events.
Thanks guys, here an updated version then, before linkwatch surgery ?
In this version, I force the event to be sent synchronously.
[PATCH net-next-2.6] linkwatch: linkwatch_forget_dev() to speedup device dismantle
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.266s
user 0m0.000s
sys 0m0.001s
real 0m0.770s
user 0m0.000s
sys 0m0.000s
real 0m1.022s
user 0m0.000s
sys 0m0.000s
One problem of current schem in vlan dismantle phase is the
holding of device done by following chain :
vlan_dev_stop() ->
netif_carrier_off(dev) ->
linkwatch_fire_event(dev) ->
dev_hold() ...
And __linkwatch_run_queue() runs up to one second later...
A generic fix to this problem is to add a linkwatch_forget_dev() method
to unlink the device from the list of watched devices.
dev->link_watch_next becomes dev->link_watch_list (and use a bit more memory),
to be able to unlink device in O(1).
After patch :
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.024s
user 0m0.000s
sys 0m0.000s
real 0m0.032s
user 0m0.000s
sys 0m0.001s
real 0m0.033s
user 0m0.000s
sys 0m0.000s
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-11-16 22:59:21 -07:00
|
|
|
static void linkwatch_do_dev(struct net_device *dev)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Make sure the above read is complete since it can be
|
|
|
|
* rewritten as soon as we clear the bit below.
|
|
|
|
*/
|
|
|
|
smp_mb__before_clear_bit();
|
|
|
|
|
|
|
|
/* We are about to handle this device,
|
|
|
|
* so new events can be accepted
|
|
|
|
*/
|
|
|
|
clear_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state);
|
|
|
|
|
|
|
|
rfc2863_policy(dev);
|
|
|
|
if (dev->flags & IFF_UP) {
|
|
|
|
if (netif_carrier_ok(dev))
|
|
|
|
dev_activate(dev);
|
|
|
|
else
|
|
|
|
dev_deactivate(dev);
|
|
|
|
|
|
|
|
netdev_state_change(dev);
|
|
|
|
}
|
|
|
|
dev_put(dev);
|
|
|
|
}
|
|
|
|
|
2007-05-08 19:36:28 -06:00
|
|
|
static void __linkwatch_run_queue(int urgent_only)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
linkwatch: linkwatch_forget_dev() to speedup device dismantle
Herbert Xu a écrit :
> On Tue, Nov 17, 2009 at 04:26:04AM -0800, David Miller wrote:
>> Really, the link watch stuff is just due for a redesign. I don't
>> think a simple hack is going to cut it this time, sorry Eric :-)
>
> I have no objections against any redesigns, but since the only
> caller of linkwatch_forget_dev runs in process context with the
> RTNL, it could also legally emit those events.
Thanks guys, here an updated version then, before linkwatch surgery ?
In this version, I force the event to be sent synchronously.
[PATCH net-next-2.6] linkwatch: linkwatch_forget_dev() to speedup device dismantle
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.266s
user 0m0.000s
sys 0m0.001s
real 0m0.770s
user 0m0.000s
sys 0m0.000s
real 0m1.022s
user 0m0.000s
sys 0m0.000s
One problem of current schem in vlan dismantle phase is the
holding of device done by following chain :
vlan_dev_stop() ->
netif_carrier_off(dev) ->
linkwatch_fire_event(dev) ->
dev_hold() ...
And __linkwatch_run_queue() runs up to one second later...
A generic fix to this problem is to add a linkwatch_forget_dev() method
to unlink the device from the list of watched devices.
dev->link_watch_next becomes dev->link_watch_list (and use a bit more memory),
to be able to unlink device in O(1).
After patch :
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.024s
user 0m0.000s
sys 0m0.000s
real 0m0.032s
user 0m0.000s
sys 0m0.001s
real 0m0.033s
user 0m0.000s
sys 0m0.000s
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-11-16 22:59:21 -07:00
|
|
|
struct net_device *dev;
|
|
|
|
LIST_HEAD(wrk);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-08 19:36:28 -06:00
|
|
|
/*
|
|
|
|
* 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;
|
2007-05-09 01:17:30 -06:00
|
|
|
/* Limit wrap-around effect on delay. */
|
|
|
|
else if (time_after(linkwatch_nextevent, jiffies + HZ))
|
|
|
|
linkwatch_nextevent = jiffies;
|
|
|
|
|
|
|
|
clear_bit(LW_URGENT, &linkwatch_flags);
|
2007-05-08 19:36:28 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_lock_irq(&lweventlist_lock);
|
linkwatch: linkwatch_forget_dev() to speedup device dismantle
Herbert Xu a écrit :
> On Tue, Nov 17, 2009 at 04:26:04AM -0800, David Miller wrote:
>> Really, the link watch stuff is just due for a redesign. I don't
>> think a simple hack is going to cut it this time, sorry Eric :-)
>
> I have no objections against any redesigns, but since the only
> caller of linkwatch_forget_dev runs in process context with the
> RTNL, it could also legally emit those events.
Thanks guys, here an updated version then, before linkwatch surgery ?
In this version, I force the event to be sent synchronously.
[PATCH net-next-2.6] linkwatch: linkwatch_forget_dev() to speedup device dismantle
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.266s
user 0m0.000s
sys 0m0.001s
real 0m0.770s
user 0m0.000s
sys 0m0.000s
real 0m1.022s
user 0m0.000s
sys 0m0.000s
One problem of current schem in vlan dismantle phase is the
holding of device done by following chain :
vlan_dev_stop() ->
netif_carrier_off(dev) ->
linkwatch_fire_event(dev) ->
dev_hold() ...
And __linkwatch_run_queue() runs up to one second later...
A generic fix to this problem is to add a linkwatch_forget_dev() method
to unlink the device from the list of watched devices.
dev->link_watch_next becomes dev->link_watch_list (and use a bit more memory),
to be able to unlink device in O(1).
After patch :
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.024s
user 0m0.000s
sys 0m0.000s
real 0m0.032s
user 0m0.000s
sys 0m0.001s
real 0m0.033s
user 0m0.000s
sys 0m0.000s
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-11-16 22:59:21 -07:00
|
|
|
list_splice_init(&lweventlist, &wrk);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
linkwatch: linkwatch_forget_dev() to speedup device dismantle
Herbert Xu a écrit :
> On Tue, Nov 17, 2009 at 04:26:04AM -0800, David Miller wrote:
>> Really, the link watch stuff is just due for a redesign. I don't
>> think a simple hack is going to cut it this time, sorry Eric :-)
>
> I have no objections against any redesigns, but since the only
> caller of linkwatch_forget_dev runs in process context with the
> RTNL, it could also legally emit those events.
Thanks guys, here an updated version then, before linkwatch surgery ?
In this version, I force the event to be sent synchronously.
[PATCH net-next-2.6] linkwatch: linkwatch_forget_dev() to speedup device dismantle
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.266s
user 0m0.000s
sys 0m0.001s
real 0m0.770s
user 0m0.000s
sys 0m0.000s
real 0m1.022s
user 0m0.000s
sys 0m0.000s
One problem of current schem in vlan dismantle phase is the
holding of device done by following chain :
vlan_dev_stop() ->
netif_carrier_off(dev) ->
linkwatch_fire_event(dev) ->
dev_hold() ...
And __linkwatch_run_queue() runs up to one second later...
A generic fix to this problem is to add a linkwatch_forget_dev() method
to unlink the device from the list of watched devices.
dev->link_watch_next becomes dev->link_watch_list (and use a bit more memory),
to be able to unlink device in O(1).
After patch :
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.024s
user 0m0.000s
sys 0m0.000s
real 0m0.032s
user 0m0.000s
sys 0m0.001s
real 0m0.033s
user 0m0.000s
sys 0m0.000s
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-11-16 22:59:21 -07:00
|
|
|
while (!list_empty(&wrk)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
linkwatch: linkwatch_forget_dev() to speedup device dismantle
Herbert Xu a écrit :
> On Tue, Nov 17, 2009 at 04:26:04AM -0800, David Miller wrote:
>> Really, the link watch stuff is just due for a redesign. I don't
>> think a simple hack is going to cut it this time, sorry Eric :-)
>
> I have no objections against any redesigns, but since the only
> caller of linkwatch_forget_dev runs in process context with the
> RTNL, it could also legally emit those events.
Thanks guys, here an updated version then, before linkwatch surgery ?
In this version, I force the event to be sent synchronously.
[PATCH net-next-2.6] linkwatch: linkwatch_forget_dev() to speedup device dismantle
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.266s
user 0m0.000s
sys 0m0.001s
real 0m0.770s
user 0m0.000s
sys 0m0.000s
real 0m1.022s
user 0m0.000s
sys 0m0.000s
One problem of current schem in vlan dismantle phase is the
holding of device done by following chain :
vlan_dev_stop() ->
netif_carrier_off(dev) ->
linkwatch_fire_event(dev) ->
dev_hold() ...
And __linkwatch_run_queue() runs up to one second later...
A generic fix to this problem is to add a linkwatch_forget_dev() method
to unlink the device from the list of watched devices.
dev->link_watch_next becomes dev->link_watch_list (and use a bit more memory),
to be able to unlink device in O(1).
After patch :
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.024s
user 0m0.000s
sys 0m0.000s
real 0m0.032s
user 0m0.000s
sys 0m0.001s
real 0m0.033s
user 0m0.000s
sys 0m0.000s
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-11-16 22:59:21 -07:00
|
|
|
dev = list_first_entry(&wrk, struct net_device, link_watch_list);
|
|
|
|
list_del_init(&dev->link_watch_list);
|
2007-05-08 19:34:17 -06:00
|
|
|
|
2007-05-08 19:36:28 -06:00
|
|
|
if (urgent_only && !linkwatch_urgent_event(dev)) {
|
linkwatch: linkwatch_forget_dev() to speedup device dismantle
Herbert Xu a écrit :
> On Tue, Nov 17, 2009 at 04:26:04AM -0800, David Miller wrote:
>> Really, the link watch stuff is just due for a redesign. I don't
>> think a simple hack is going to cut it this time, sorry Eric :-)
>
> I have no objections against any redesigns, but since the only
> caller of linkwatch_forget_dev runs in process context with the
> RTNL, it could also legally emit those events.
Thanks guys, here an updated version then, before linkwatch surgery ?
In this version, I force the event to be sent synchronously.
[PATCH net-next-2.6] linkwatch: linkwatch_forget_dev() to speedup device dismantle
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.266s
user 0m0.000s
sys 0m0.001s
real 0m0.770s
user 0m0.000s
sys 0m0.000s
real 0m1.022s
user 0m0.000s
sys 0m0.000s
One problem of current schem in vlan dismantle phase is the
holding of device done by following chain :
vlan_dev_stop() ->
netif_carrier_off(dev) ->
linkwatch_fire_event(dev) ->
dev_hold() ...
And __linkwatch_run_queue() runs up to one second later...
A generic fix to this problem is to add a linkwatch_forget_dev() method
to unlink the device from the list of watched devices.
dev->link_watch_next becomes dev->link_watch_list (and use a bit more memory),
to be able to unlink device in O(1).
After patch :
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.024s
user 0m0.000s
sys 0m0.000s
real 0m0.032s
user 0m0.000s
sys 0m0.001s
real 0m0.033s
user 0m0.000s
sys 0m0.000s
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-11-16 22:59:21 -07:00
|
|
|
list_add_tail(&dev->link_watch_list, &lweventlist);
|
2007-05-08 19:36:28 -06:00
|
|
|
continue;
|
|
|
|
}
|
linkwatch: linkwatch_forget_dev() to speedup device dismantle
Herbert Xu a écrit :
> On Tue, Nov 17, 2009 at 04:26:04AM -0800, David Miller wrote:
>> Really, the link watch stuff is just due for a redesign. I don't
>> think a simple hack is going to cut it this time, sorry Eric :-)
>
> I have no objections against any redesigns, but since the only
> caller of linkwatch_forget_dev runs in process context with the
> RTNL, it could also legally emit those events.
Thanks guys, here an updated version then, before linkwatch surgery ?
In this version, I force the event to be sent synchronously.
[PATCH net-next-2.6] linkwatch: linkwatch_forget_dev() to speedup device dismantle
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.266s
user 0m0.000s
sys 0m0.001s
real 0m0.770s
user 0m0.000s
sys 0m0.000s
real 0m1.022s
user 0m0.000s
sys 0m0.000s
One problem of current schem in vlan dismantle phase is the
holding of device done by following chain :
vlan_dev_stop() ->
netif_carrier_off(dev) ->
linkwatch_fire_event(dev) ->
dev_hold() ...
And __linkwatch_run_queue() runs up to one second later...
A generic fix to this problem is to add a linkwatch_forget_dev() method
to unlink the device from the list of watched devices.
dev->link_watch_next becomes dev->link_watch_list (and use a bit more memory),
to be able to unlink device in O(1).
After patch :
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.024s
user 0m0.000s
sys 0m0.000s
real 0m0.032s
user 0m0.000s
sys 0m0.001s
real 0m0.033s
user 0m0.000s
sys 0m0.000s
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-11-16 22:59:21 -07:00
|
|
|
spin_unlock_irq(&lweventlist_lock);
|
|
|
|
linkwatch_do_dev(dev);
|
|
|
|
spin_lock_irq(&lweventlist_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-05-08 19:36:28 -06:00
|
|
|
|
linkwatch: linkwatch_forget_dev() to speedup device dismantle
Herbert Xu a écrit :
> On Tue, Nov 17, 2009 at 04:26:04AM -0800, David Miller wrote:
>> Really, the link watch stuff is just due for a redesign. I don't
>> think a simple hack is going to cut it this time, sorry Eric :-)
>
> I have no objections against any redesigns, but since the only
> caller of linkwatch_forget_dev runs in process context with the
> RTNL, it could also legally emit those events.
Thanks guys, here an updated version then, before linkwatch surgery ?
In this version, I force the event to be sent synchronously.
[PATCH net-next-2.6] linkwatch: linkwatch_forget_dev() to speedup device dismantle
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.266s
user 0m0.000s
sys 0m0.001s
real 0m0.770s
user 0m0.000s
sys 0m0.000s
real 0m1.022s
user 0m0.000s
sys 0m0.000s
One problem of current schem in vlan dismantle phase is the
holding of device done by following chain :
vlan_dev_stop() ->
netif_carrier_off(dev) ->
linkwatch_fire_event(dev) ->
dev_hold() ...
And __linkwatch_run_queue() runs up to one second later...
A generic fix to this problem is to add a linkwatch_forget_dev() method
to unlink the device from the list of watched devices.
dev->link_watch_next becomes dev->link_watch_list (and use a bit more memory),
to be able to unlink device in O(1).
After patch :
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.024s
user 0m0.000s
sys 0m0.000s
real 0m0.032s
user 0m0.000s
sys 0m0.001s
real 0m0.033s
user 0m0.000s
sys 0m0.000s
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-11-16 22:59:21 -07:00
|
|
|
if (!list_empty(&lweventlist))
|
2007-05-09 01:17:30 -06:00
|
|
|
linkwatch_schedule_work(0);
|
linkwatch: linkwatch_forget_dev() to speedup device dismantle
Herbert Xu a écrit :
> On Tue, Nov 17, 2009 at 04:26:04AM -0800, David Miller wrote:
>> Really, the link watch stuff is just due for a redesign. I don't
>> think a simple hack is going to cut it this time, sorry Eric :-)
>
> I have no objections against any redesigns, but since the only
> caller of linkwatch_forget_dev runs in process context with the
> RTNL, it could also legally emit those events.
Thanks guys, here an updated version then, before linkwatch surgery ?
In this version, I force the event to be sent synchronously.
[PATCH net-next-2.6] linkwatch: linkwatch_forget_dev() to speedup device dismantle
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.266s
user 0m0.000s
sys 0m0.001s
real 0m0.770s
user 0m0.000s
sys 0m0.000s
real 0m1.022s
user 0m0.000s
sys 0m0.000s
One problem of current schem in vlan dismantle phase is the
holding of device done by following chain :
vlan_dev_stop() ->
netif_carrier_off(dev) ->
linkwatch_fire_event(dev) ->
dev_hold() ...
And __linkwatch_run_queue() runs up to one second later...
A generic fix to this problem is to add a linkwatch_forget_dev() method
to unlink the device from the list of watched devices.
dev->link_watch_next becomes dev->link_watch_list (and use a bit more memory),
to be able to unlink device in O(1).
After patch :
time ip link del eth3.103 ; time ip link del eth3.104 ; time ip link del eth3.105
real 0m0.024s
user 0m0.000s
sys 0m0.000s
real 0m0.032s
user 0m0.000s
sys 0m0.001s
real 0m0.033s
user 0m0.000s
sys 0m0.000s
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-11-16 22:59:21 -07:00
|
|
|
spin_unlock_irq(&lweventlist_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void linkwatch_forget_dev(struct net_device *dev)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int clean = 0;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&lweventlist_lock, flags);
|
|
|
|
if (!list_empty(&dev->link_watch_list)) {
|
|
|
|
list_del_init(&dev->link_watch_list);
|
|
|
|
clean = 1;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&lweventlist_lock, flags);
|
|
|
|
if (clean)
|
|
|
|
linkwatch_do_dev(dev);
|
2007-02-09 07:24:36 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
2007-05-08 19:36:28 -06:00
|
|
|
/* Must be called with the rtnl semaphore held */
|
|
|
|
void linkwatch_run_queue(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-08 19:36:28 -06:00
|
|
|
__linkwatch_run_queue(0);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-08 19:36:28 -06:00
|
|
|
static void linkwatch_event(struct work_struct *dummy)
|
|
|
|
{
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_lock();
|
2007-05-08 19:36:28 -06:00
|
|
|
__linkwatch_run_queue(time_after(linkwatch_nextevent, jiffies));
|
2006-03-20 23:23:58 -07:00
|
|
|
rtnl_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void linkwatch_fire_event(struct net_device *dev)
|
|
|
|
{
|
2008-07-09 00:01:06 -06:00
|
|
|
bool urgent = linkwatch_urgent_event(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-09 01:17:30 -06:00
|
|
|
if (!test_and_set_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state)) {
|
2007-05-08 19:36:28 -06:00
|
|
|
linkwatch_add_event(dev);
|
2007-05-09 01:17:30 -06:00
|
|
|
} else if (!urgent)
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-09 01:17:30 -06:00
|
|
|
linkwatch_schedule_work(urgent);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(linkwatch_fire_event);
|