Linux内核中网络设备连接状态监测
在Linux中，网络设备会定时地检测设备是否处于可传递状态。当状态发生变化时，网络设备驱动程序会调用netif_carrier_on()或者netif_carrier_off()函数来通知内核。插拔网络设备网线或者另一端的设备关闭或禁止，都会导致连接状态改变。
netif_carrier_on() - 设备驱动监测到设备传递信号时调用
netif_carrier_off() - 设备驱动监测到设备丢失信号时调用
Linux内核中实现上述两个函数的代码位于net/sched/sch_generic.c文件中。它们均会调用linkwatch_fire_event()将事件加入到事件队列进行调度。
以netif_carrier_on()为例，函数调用过程如下：
netif_carrier_on() - net/sched/sch_generic.c
linkwatch_fire_event() - net/core/link_watch.c
linkwatch_add_event() - net/core/link_watch.c
linkwatch_schedule_work() - net/core/link_watch.c
mod_delayed_work() - include/linux/workqueue.h
mod_delayed_work_on() - kernel/workqueue.c
__queue_delayed_work() - kernel/workqueue.c
schedule_delayed_work() - include/linux/workqueue.h
queue_delayed_work() - include/linux/workqueue.h
queue_delayed_work_on() - kernel/workqueue.c
__queue_delayed_work() - kernel/workqueue.c
接收到信号
当监测到设备传递信号时函数netif_carrier_on()会被调用，并调用linkwatch_fire_event()函数将设备加入到事件处理队列进行处理。
/**
* netif_carrier_on - set carrier
* @dev: network device
*
* Device has detected acquisition of carrier.
*/
void netif_carrier_on(struct net_device *dev)
{
// 清除nocarrier状态
if (test_and_clear_bit(__LINK_STATE_NOCARRIER, &dev->state)) {
// 设备未注册则直接返回
if (dev->reg_state == NETREG_UNINITIALIZED)
return;
// 增加设备carrier up状态次数
atomic_inc(&dev->carrier_up_count);
// 加入事件处理队列进行处理
linkwatch_fire_event(dev);
if (netif_running(dev))
__netdev_watchdog_up(dev);
}
}
EXPORT_SYMBOL(netif_carrier_on);
丢失信号
当监测到设备信号丢失时函数netif_carrier_off()会被调用，并调用linkwatch_fire_event()函数将设备加入到事件处理队列进行处理。
/**
* netif_carrier_off - clear carrier
* @dev: network device
*
* Device has detected loss of carrier.
*/
void netif_carrier_off(struct net_device *dev)
{
// 设置nocarrier状态
if (!test_and_set_bit(__LINK_STATE_NOCARRIER, &dev->state)) {
// 设备未注册则直接返回
if (dev->reg_state == NETREG_UNINITIALIZED)
return;
// 增加设备carrier down状态次数
atomic_inc(&dev->carrier_down_count);
// 加入事件处理队列进行处理
linkwatch_fire_event(dev);
}
}
EXPORT_SYMBOL(netif_carrier_off);
加入队列
linkwatch_fire_event()函数将设备加入到事件队列，并且进行事件调度，调度中会根据是否为紧急事件做不同处理。
void linkwatch_fire_event(struct net_device *dev)
{
// 事件是否紧急
bool urgent = linkwatch_urgent_event(dev);
// 设置待处理(pending)事件标记
if (!test_and_set_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state)) {
// 添加事件到事件列表
linkwatch_add_event(dev);
} else if (!urgent)
// 设置pending后，不紧急，直接返回
return;
// 事件调度
linkwatch_schedule_work(urgent);
}
EXPORT_SYMBOL(linkwatch_fire_event);
static bool linkwatch_urgent_event(struct net_device *dev)
{
// 设备未运行，不紧急
if (!netif_running(dev))
return false;
// 设备的索引号与链路索引号不等，紧急
if (dev->ifindex != dev_get_iflink(dev))
return true;
// 设备作为bond接口或者team接口，紧急
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);
// 若未添加，则添加设备到事件列表lweventlist
if (list_empty(&dev->link_watch_list)) {
list_add_tail(&dev->link_watch_list, &lweventlist);
dev_hold_track(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. */
// 紧急，delay = 0，立即执行
if (urgent) {
// 已经设置了紧急标记，则返回
if (test_and_set_bit(LW_URGENT, &linkwatch_flags))
return;
// 紧急，设置delay = 0，立即执行
delay = 0;
}
/* If we wrap around we'll delay it by at most HZ. */
// 如果大于1s则立即执行
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);
// 未设置紧急标记，则按照delay执行
else
schedule_delayed_work(&linkwatch_work, delay);
}
事件处理
在net/core/link_watch.c中声明了delayed_work结构(即linkwatch_work)和事件处理函数linkwatch_event()。
static DECLARE_DELAYED_WORK(linkwatch_work, linkwatch_event);
static void linkwatch_event(struct work_struct *dummy)
{
rtnl_lock();
__linkwatch_run_queue(time_after(linkwatch_nextevent, jiffies));
rtnl_unlock();
}
static void __linkwatch_run_queue(int urgent_only)
{
// urgent_only: 1 - 未到达下一次调度时间, 0 - 已到达下次调度时间
#define MAX_DO_DEV_PER_LOOP 100
// 每次处理的设备个数，最大100个
int do_dev = MAX_DO_DEV_PER_LOOP;
struct net_device *dev;
LIST_HEAD(wrk);
/* Give urgent case more budget */
// 紧急，则加大为200个
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. */
// 未到达调度时间，并且下一次调度在当前时间的1s以后，那么设置调度时间是当前时间
else if (time_after(linkwatch_nextevent, jiffies + HZ))
linkwatch_nextevent = jiffies;
// 清除紧急标志
clear_bit(LW_URGENT, &linkwatch_flags);
spin_lock_irq(&lweventlist_lock);
// 将两个链表进行合并为一个链表并初始化为空表，合并后为wrk，清空lweventlist
list_splice_init(&lweventlist, &wrk);
// 遍历合并后的链表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 */
// 将两个链表进行合并为一个链表并初始化为空表，合并后为lweventlist，清空wrk
list_splice_init(&wrk, &lweventlist);
// 链表有未处理事件，则以非紧急状态调度队列
if (!list_empty(&lweventlist))
linkwatch_schedule_work(0);
spin_unlock_irq(&lweventlist_lock);
}
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
*/
// 清除待处理(pending)标志
clear_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state);
rfc2863_policy(dev);
// 设备是up状态
if (dev->flags & IFF_UP) {
// 链路连接
if (netif_carrier_ok(dev))
// 启用流控排队规则qdisc
dev_activate(dev);
else
// 关闭流控排队规则qdisc
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);
}
