mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 18:44:19 +08:00
d62607c3fe
Netdev reference helpers have a dev_ prefix for historic reasons. Renaming the old helpers would be too much churn but we can rename the tracking ones which are relatively recent and should be the default for new code. Rename: dev_hold_track() -> netdev_hold() dev_put_track() -> netdev_put() dev_replace_track() -> netdev_ref_replace() Link: https://lore.kernel.org/r/20220608043955.919359-1-kuba@kernel.org Signed-off-by: Jakub Kicinski <kuba@kernel.org>
281 lines
6.2 KiB
C
281 lines
6.2 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Linux network device link state notification
|
|
*
|
|
* Author:
|
|
* Stefan Rompf <sux@loplof.de>
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/if.h>
|
|
#include <net/sock.h>
|
|
#include <net/pkt_sched.h>
|
|
#include <linux/rtnetlink.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/types.h>
|
|
|
|
#include "dev.h"
|
|
|
|
enum lw_bits {
|
|
LW_URGENT = 0,
|
|
};
|
|
|
|
static unsigned long linkwatch_flags;
|
|
static unsigned long linkwatch_nextevent;
|
|
|
|
static void linkwatch_event(struct work_struct *dummy);
|
|
static DECLARE_DELAYED_WORK(linkwatch_work, linkwatch_event);
|
|
|
|
static LIST_HEAD(lweventlist);
|
|
static DEFINE_SPINLOCK(lweventlist_lock);
|
|
|
|
static unsigned char default_operstate(const struct net_device *dev)
|
|
{
|
|
if (netif_testing(dev))
|
|
return IF_OPER_TESTING;
|
|
|
|
if (!netif_carrier_ok(dev))
|
|
return (dev->ifindex != dev_get_iflink(dev) ?
|
|
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(&dev_base_lock);
|
|
|
|
switch(dev->link_mode) {
|
|
case IF_LINK_MODE_TESTING:
|
|
if (operstate == IF_OPER_UP)
|
|
operstate = IF_OPER_TESTING;
|
|
break;
|
|
|
|
case IF_LINK_MODE_DORMANT:
|
|
if (operstate == IF_OPER_UP)
|
|
operstate = IF_OPER_DORMANT;
|
|
break;
|
|
case IF_LINK_MODE_DEFAULT:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
dev->operstate = operstate;
|
|
|
|
write_unlock(&dev_base_lock);
|
|
}
|
|
|
|
|
|
void linkwatch_init_dev(struct net_device *dev)
|
|
{
|
|
/* Handle pre-registration link state changes */
|
|
if (!netif_carrier_ok(dev) || netif_dormant(dev) ||
|
|
netif_testing(dev))
|
|
rfc2863_policy(dev);
|
|
}
|
|
|
|
|
|
static bool linkwatch_urgent_event(struct net_device *dev)
|
|
{
|
|
if (!netif_running(dev))
|
|
return false;
|
|
|
|
if (dev->ifindex != dev_get_iflink(dev))
|
|
return true;
|
|
|
|
if (netif_is_lag_port(dev) || netif_is_lag_master(dev))
|
|
return true;
|
|
|
|
return netif_carrier_ok(dev) && qdisc_tx_changing(dev);
|
|
}
|
|
|
|
|
|
static void linkwatch_add_event(struct net_device *dev)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&lweventlist_lock, flags);
|
|
if (list_empty(&dev->link_watch_list)) {
|
|
list_add_tail(&dev->link_watch_list, &lweventlist);
|
|
netdev_hold(dev, &dev->linkwatch_dev_tracker, GFP_ATOMIC);
|
|
}
|
|
spin_unlock_irqrestore(&lweventlist_lock, flags);
|
|
}
|
|
|
|
|
|
static void linkwatch_schedule_work(int urgent)
|
|
{
|
|
unsigned long delay = linkwatch_nextevent - jiffies;
|
|
|
|
if (test_bit(LW_URGENT, &linkwatch_flags))
|
|
return;
|
|
|
|
/* Minimise down-time: drop delay for up event. */
|
|
if (urgent) {
|
|
if (test_and_set_bit(LW_URGENT, &linkwatch_flags))
|
|
return;
|
|
delay = 0;
|
|
}
|
|
|
|
/* If we wrap around we'll delay it by at most HZ. */
|
|
if (delay > HZ)
|
|
delay = 0;
|
|
|
|
/*
|
|
* If urgent, schedule immediate execution; otherwise, don't
|
|
* override the existing timer.
|
|
*/
|
|
if (test_bit(LW_URGENT, &linkwatch_flags))
|
|
mod_delayed_work(system_wq, &linkwatch_work, 0);
|
|
else
|
|
schedule_delayed_work(&linkwatch_work, delay);
|
|
}
|
|
|
|
|
|
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_atomic();
|
|
|
|
/* 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);
|
|
}
|
|
/* Note: our callers are responsible for calling netdev_tracker_free().
|
|
* This is the reason we use __dev_put() instead of dev_put().
|
|
*/
|
|
__dev_put(dev);
|
|
}
|
|
|
|
static void __linkwatch_run_queue(int urgent_only)
|
|
{
|
|
#define MAX_DO_DEV_PER_LOOP 100
|
|
|
|
int do_dev = MAX_DO_DEV_PER_LOOP;
|
|
struct net_device *dev;
|
|
LIST_HEAD(wrk);
|
|
|
|
/* Give urgent case more budget */
|
|
if (urgent_only)
|
|
do_dev += MAX_DO_DEV_PER_LOOP;
|
|
|
|
/*
|
|
* 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;
|
|
/* Limit wrap-around effect on delay. */
|
|
else if (time_after(linkwatch_nextevent, jiffies + HZ))
|
|
linkwatch_nextevent = jiffies;
|
|
|
|
clear_bit(LW_URGENT, &linkwatch_flags);
|
|
|
|
spin_lock_irq(&lweventlist_lock);
|
|
list_splice_init(&lweventlist, &wrk);
|
|
|
|
while (!list_empty(&wrk) && do_dev > 0) {
|
|
|
|
dev = list_first_entry(&wrk, struct net_device, link_watch_list);
|
|
list_del_init(&dev->link_watch_list);
|
|
|
|
if (!netif_device_present(dev) ||
|
|
(urgent_only && !linkwatch_urgent_event(dev))) {
|
|
list_add_tail(&dev->link_watch_list, &lweventlist);
|
|
continue;
|
|
}
|
|
/* We must free netdev tracker under
|
|
* the spinlock protection.
|
|
*/
|
|
netdev_tracker_free(dev, &dev->linkwatch_dev_tracker);
|
|
spin_unlock_irq(&lweventlist_lock);
|
|
linkwatch_do_dev(dev);
|
|
do_dev--;
|
|
spin_lock_irq(&lweventlist_lock);
|
|
}
|
|
|
|
/* Add the remaining work back to lweventlist */
|
|
list_splice_init(&wrk, &lweventlist);
|
|
|
|
if (!list_empty(&lweventlist))
|
|
linkwatch_schedule_work(0);
|
|
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;
|
|
/* We must release netdev tracker under
|
|
* the spinlock protection.
|
|
*/
|
|
netdev_tracker_free(dev, &dev->linkwatch_dev_tracker);
|
|
}
|
|
spin_unlock_irqrestore(&lweventlist_lock, flags);
|
|
if (clean)
|
|
linkwatch_do_dev(dev);
|
|
}
|
|
|
|
|
|
/* 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)
|
|
{
|
|
rtnl_lock();
|
|
__linkwatch_run_queue(time_after(linkwatch_nextevent, jiffies));
|
|
rtnl_unlock();
|
|
}
|
|
|
|
|
|
void linkwatch_fire_event(struct net_device *dev)
|
|
{
|
|
bool urgent = linkwatch_urgent_event(dev);
|
|
|
|
if (!test_and_set_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state)) {
|
|
linkwatch_add_event(dev);
|
|
} else if (!urgent)
|
|
return;
|
|
|
|
linkwatch_schedule_work(urgent);
|
|
}
|
|
EXPORT_SYMBOL(linkwatch_fire_event);
|