检查网线的插拔

1、Shell查看网线插拔状态：

使用ifconfig命令，如果含有“RUNNING”，说明网线接入，否则就没有。

例：

ifconfig

ifconfig eth0

ifconfig eth0|grep "RUNNING"

eth0 Link encap:Ethernet HWaddr 00:30:48:xx:xx:xx

inet addr:10.210.xxx.xxx Bcast:10.210.xxx.xxx Mask:255.255.255.0

inet6 addr: fe80::230:48xx:xxxx:7bd4/64 Scope:Link

UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1

~~

或者 ip 命令

~$ ip link show

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 16436 qdisc noqueue state UNKNOWN

link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00

2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000

UP只能说明网口设备是打开的，不能说明是否物理连接是否通，通过RUNNING来判断物理连接是否通。

说明：由于linux下的ifconfig命令就能够实现在应用层监控网线插拔状态，例如当网线连接正常时，使用ifconfig eth0命令，打印的信息中会有RUNNING，而拔掉网线后，再使用ifconfig eth0命令，RUNNING就不见了。

2、代码判断网线插拔状态

Netlink 是一种特殊的套接字，为2.6.14及更高版本的Linux所特有，通过它，应用层程序可以方便地向内核订制指定消息，如网卡上下线。也可以设置或查询配置，如IP、路由、网络流量信息等。

a、创建一个 netlink 套接字：

fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);

b、绑定路由多播组，监控网卡信息：

view
plaincopy
to clipboardprint?

addr.nl_family = AF_NETLINK;

addr.nl_groups = RTNLGRP_LINK; //指定接收路由多播组消息

bind(fd, (struct sockaddr*)&addr, sizeof(addr));

c、监听套接字，一旦可读，解析其内容，实时监控网卡上下线事件。

If(ptr->flags &IFF_RUNNIG)

{

Printf(__("RUNNING"));

}

优点：实时性高，使用方便。

缺点：跨平台性不佳，只能检测自身网络故障。
3、实现分析

网络设备在系统中注册、注销和关闭、打开等事件都可以通知给相应的内核组件或用户空间应用程序，其中内核组件通过netdev_chain通知链获取消息，而用户空间应用程序则通过注册Netlink
RTMGRP_LINK多播群组获取事件消息。网络设备事件消息的内核组件通过register_netdevice_notifier和unregister_netdevice_notifier分别对netdev_chain通知链进行注册和注销。在网络设备相应的事件发生时，会调用这个通知链通知这些内核组件，主要的网络设备事件包括：

#define NETDEV_UP 0x0001 /* 网络设备开启，由dev_open函数产生*/

#define NETDEV_DOWN 0x0002 /*网络设备已经关闭，由dev_close函数产生*/

#define NETDEV_REBOOT 0x0003 /* Tell a protocol stack a network interface

detected a hardware crash and restarted

- we can use this eg to kick tcp sessions

once done */

#define NETDEV_CHANGE 0x0004 /* Notify device state change */

#define NETDEV_REGISTER 0x0005 /*设备已注册，由register_netdevice产生*/

#define NETDEV_UNREGISTER 0x0006 /*设备已注销，由unregister_netdevice产生*/

#define NETDEV_CHANGEMTU 0x0007

#define NETDEV_CHANGEADDR 0x0008

#define NETDEV_GOING_DOWN 0x0009

#define NETDEV_CHANGENAME 0x000A

#define NETDEV_FEAT_CHANGE 0x000B

#define NETDEV_BONDING_FAILOVER 0x000C

#define NETDEV_PRE_UP 0x000D

#define NETDEV_PRE_TYPE_CHANGE 0x000E

#define NETDEV_POST_TYPE_CHANGE 0x000F

#define NETDEV_POST_INIT 0x0010

#define NETDEV_UNREGISTER_BATCH 0x0011

#define NETDEV_BONDING_DESLAVE 0x0012

#define NETDEV_NOTIFY_PEERS 0x0013

3.1 内核组件

在内核中，网络设备通过函数register_netdev和unregister_netdev在内核中注册和注销，这两个函数对实际操作函数register_netdevice和unregister_netdevice进行封装，在调用这两个函数之前负责上锁。

在分析网络设备的注册状态改变时，注销时多了一个NETREG_UNREGISTERING状态，这个状态表示将设备从内核设备链中摘除了，但还有一些操作没有完成，而是将设备放到了net_todo_list链表中，由netdev_run_todo函数来完成所有的注销操作。在net_device结构中有一个const struct net_device_ops *netdev_ops成员，其中有两个特殊的成员函数：

struct net_device_ops {

int (*ndo_init)(struct net_device *dev);

void (*ndo_uninit)(struct net_device *dev);

……

}

这两个成员函数分别在注册和注销设备时，对net_device结构的私有数据区进行处理。其调用位置分别为：

static void rollback_registered_many(struct list_head *head)

{

……

if (dev->netdev_ops->ndo_uninit)

dev->netdev_ops->ndo_uninit(dev);

……

}

注册时，初始化私有数据结构：

int register_netdevice(struct net_device *dev)

{

……

if (dev->netdev_ops->ndo_init) {

ret = dev->netdev_ops->ndo_init(dev);

……

}

因此，若没有私有数据区，则不需要实现这两个函数，赋值为NULL即可。





在注销了，为了减少占用锁的时间，unregister_netdevice函数将设备从内核的设备链表中移除后，将net_device结构放入net_todo_list链表，由net_device结构的todo_list成员保存链表。因为对设备注销时，需要等待所有和ney_device结构关联的引用全部释放，才能释放这个结构和设备，因此将这个耗费时间的操作放到解锁之后完成。在netdev_run_todo函数中会调用netdev_wait_allrefs函数来等待net_device结构的所有引用全部释放，否则这个函数不会返回。

设备的注销过程，多了todo过程，这里分析一下，首先调用：

void unregister_netdev(struct net_device *dev)

{

rtnl_lock();

unregister_netdevice(dev);

rtnl_unlock();

}

其中rtnl_lockhe 和rtnl_unlock的实现比较有意思，在rtnl_lock中获取了互斥量rtnl_mutex，而rtnl_unlock中则没有释放这个互斥量，而是rtnl_unlock调用netdev_run_todo函数，在这个函数的开始调用__rtnl_unlock函数释放这个互斥量。

上锁：

void rtnl_lock(void)

{

mutex_lock(&rtnl_mutex);

}

EXPORT_SYMBOL(rtnl_lock);

解锁其实是进入netdev_run_todo函数：

void rtnl_unlock(void)

{

/* This fellow will unlock it for us. */

netdev_run_todo();

}

这里才是实际解锁操作：

void netdev_run_todo(void)

{

struct list_head list;

/* Snapshot list, allow later requests */

list_replace_init(&net_todo_list, &list); //将全局变量net_todo_list的值复制到局部变量list中，然后再释放互斥量，全局变量net_todo_list重新初始化，这里的实现值得借鉴

__rtnl_unlock(); //释放互斥量

……

}

设备注销，函数的调用过程：

static inline void unregister_netdevice(struct net_device *dev)

{

unregister_netdevice_queue(dev, NULL);

}

void unregister_netdevice_queue(struct net_device *dev, struct list_head *head)

{

ASSERT_RTNL();

if (head) {

list_move_tail(&dev->unreg_list, head);

} else {

rollback_registered(dev);

/* Finish processing unregister after unlock */

net_set_todo(dev); //将dev加入到全局变量Net_todo_list链表中

}

}

static void rollback_registered(struct net_device *dev)

{

LIST_HEAD(single);

list_add(&dev->unreg_list, &single);//将设备加入链表，这里实现这么繁琐，应该是为了适应调用rollback_registered_many函数，可以注销多个设备

rollback_registered_many(&single);

list_del(&single);

}

static void rollback_registered_many(struct list_head *head)

{

struct net_device *dev, *tmp;

BUG_ON(dev_boot_phase);

ASSERT_RTNL(); //检查是否获取了rtnl互斥量

list_for_each_entry_safe(dev, tmp, head, unreg_list) {

/* Some devices call without registering

* for initialization unwind. Remove those

* devices and proceed with the remaining.

*/

if (dev->reg_state == NETREG_UNINITIALIZED) { //处理在注册过程中失败的设备

pr_debug("unregister_netdevice: device %s/%p never "

"was registered\n", dev->name, dev);

WARN_ON(1);

list_del(&dev->unreg_list);//将其从链表删除即可

continue;

}

BUG_ON(dev->reg_state != NETREG_REGISTERED); //程序到这里则设备不可能不处于已注册状态

}

/* If device is running, close it first. */

dev_close_many(head); //关闭在运行的设备

list_for_each_entry(dev, head, unreg_list) {

/* And unlink it from device chain. */

unlist_netdevice(dev);

/*

这里说明，只是将其从系统中的三个链表上移除

static void unlist_netdevice(struct net_device *dev)

{

ASSERT_RTNL();

/* Unlink dev from the device chain */

write_lock_bh(&dev_base_lock); //dev_base_lock是保证这三个链表互斥的读写锁

list_del_rcu(&dev->dev_list);

hlist_del_rcu(&dev->name_hlist);

hlist_del_rcu(&dev->index_hlist);

write_unlock_bh(&dev_base_lock);

}

*/

dev->reg_state = NETREG_UNREGISTERING; //然后，更新设备的注册状态

}

synchronize_net();

list_for_each_entry(dev, head, unreg_list) {

/* Shutdown queueing discipline. */

dev_shutdown(dev); //处理设备的接收队列等

/* Notify protocols, that we are about to destroy

this device. They should clean all the things.

*/

call_netdevice_notifiers(NETDEV_UNREGISTER, dev); //发出注销通知

if (!dev->rtnl_link_ops ||

dev->rtnl_link_state == RTNL_LINK_INITIALIZED)

rtmsg_ifinfo(RTM_DELLINK, dev, ~0U);

/*

* Flush the unicast and multicast chains

*/

dev_uc_flush(dev);

dev_mc_flush(dev);

if (dev->netdev_ops->ndo_uninit) //处理私有数据区

dev->netdev_ops->ndo_uninit(dev);

/* Notifier chain MUST detach us from master device. */

WARN_ON(dev->master);

/* Remove entries from kobject tree */

netdev_unregister_kobject(dev); //从内核移除对象，涉及到内核设备管理层的东西

}

/* Process any work delayed until the end of the batch */

dev = list_first_entry(head, struct net_device, unreg_list);

call_netdevice_notifiers(NETDEV_UNREGISTER_BATCH, dev);

rcu_barrier();

list_for_each_entry(dev, head, unreg_list)

dev_put(dev); //释放设备，对其引用计数减一

}

这里在获取锁的时间范围内的注销操作就完成了，这时设备已经和内核的设备链脱离了关系，也就是内核已经不知道这个设备的存在了。但这个设备可以还被内核中的其他模块，因此，剩余的操作需要在释放了rtnl互斥量后，在net_run_todo函数中处理。

//在这里，释放了互斥量后，可以在等待设备的引用计数归零过程中睡眠

void netdev_run_todo(void)

{

struct list_head list;

/* Snapshot list, allow later requests */

list_replace_init(&net_todo_list, &list); //复制全局变量net_todo_list的值，然后初始化

__rtnl_unlock(); //释放互斥量

while (!list_empty(&list)) { //对链表中的元素进行处理

struct net_device *dev

= list_first_entry(&list, struct net_device, todo_list); //处理一个，移除一个

list_del(&dev->todo_list);

if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) { //内核出现重大BUG

printk(KERN_ERR "network todo '%s' but state %d\n",

dev->name, dev->reg_state);

dump_stack();

continue;

}

dev->reg_state = NETREG_UNREGISTERED; //更新注册状态

on_each_cpu(flush_backlog, dev, 1);

netdev_wait_allrefs(dev); //等待引用计数归零，可能睡眠

/* paranoia */

BUG_ON(netdev_refcnt_read(dev));

WARN_ON(rcu_dereference_raw(dev->ip_ptr));

WARN_ON(rcu_dereference_raw(dev->ip6_ptr));

WARN_ON(dev->dn_ptr);

if (dev->destructor)

dev->destructor(dev);

/* Free network device */

kobject_put(&dev->dev.kobj); //释放这个结构，到这里设备的注销完全完成，net_device结构将被释放

}

}

其实查看netdev_wait_allrefs函数，就是定时查看设备的引用计数是否为0，不为0则再次向其他模块发设备注销通知，让它们释放这个设备，然后进入休眠等待的过程。

static void netdev_wait_allrefs(struct net_device *dev)

{

unsigned long rebroadcast_time, warning_time;

int refcnt;

linkwatch_forget_dev(dev);

rebroadcast_time = warning_time = jiffies;

refcnt = netdev_refcnt_read(dev);

while (refcnt != 0) {

if (time_after(jiffies, rebroadcast_time + 1 * HZ)) { //过一秒

rtnl_lock();

/* Rebroadcast unregister notification */

call_netdevice_notifiers(NETDEV_UNREGISTER, dev); //发注销广播通知

/* don't resend NETDEV_UNREGISTER_BATCH, _BATCH users

* should have already handle it the first time */

if (test_bit(__LINK_STATE_LINKWATCH_PENDING,

&dev->state)) {

/* We must not have linkwatch events

* pending on unregister. If this

* happens, we simply run the queue

* unscheduled, resulting in a noop

* for this device.

*/

linkwatch_run_queue();

}

__rtnl_unlock();

rebroadcast_time = jiffies;

}

msleep(250); //睡眠250毫秒

refcnt = netdev_refcnt_read(dev); //夺取引用计数

if (time_after(jiffies, warning_time + 10 * HZ)) { //等待10秒

printk(KERN_EMERG "unregister_netdevice: "

"waiting for %s to become free. Usage "

"count = %d\n",

dev->name, refcnt);

warning_time = jiffies;

}

}

}

3.2 用户空间应用程序

Netlink的RTMGRP_LINK多播群组，用户空间程序可以注册netlink的RTMGRP_LINK多播群组，当设备的状态或配置中有变更时，就会用rtmsg_ifinfo把通知信息传送给Link多播群组RTMGRP_LINK。

3.2.1RTMGRP_LINK注册

netlink API用起来相对麻烦，可以考虑采用libnl开源库，其官方网站为http://www.infradead.org/~tgr/libnl/。libnl的内容也不少，其架构如图3-50所示。



由图3-50可知，以下三个库都基于其核心库libnl。

libnl-route：用于和Kernel中的Routing子系统交互。

libnl-nf：用于和Kernel中的Netfilter子系统交互。

libnl-genl：用于和Kernel中的Generic Netlink模块交互。

提示　从图也可看出netlink使用的复杂性。

本节介绍libnl中的一些常用API。详细内容还请读者参考其官方网站中的文档，地址为http://www.infradead.org/～tgr/libnl/doc/core.html。

（1）nl_sock结构体的使用

libnl以面向对象的方式重新封装了netlink原有的API。其使用时必须分配一个nl_sock结构体。下面展示了和它相关的一些API及使用方法。

#include <netlink/socket.h>

// 分配和释放nl_sock结构体

struct nl_sock *nl_socket_alloc(void)

void nl_socket_free(struct nl_sock *sk)

// nl_connet内部将通过bind函数将netlink socket和protocol对应的模块进行绑定

int nl_connect(struct nl_sock *sk, int protocol)

linbl还可为每个nl_sock设置消息处理函数，相关API如下。

// 为nl_sock对象设置一个回调函数，当该socket上收到消息后，就会回调此函数进行处理

// 回调函数及参数封装在结构体struct nl_cb中

void nl_socket_set_cb(struct nl_sock *sk, struct nl_cb *cb);

// 获取该nl_sock设置的回调函数信息

struct nl_cb *nl_socket_get_cb(const struct nl_sock *sk);

注意，以上两个函数没有文档说明。建议使用另外一个控制力度更为精细的API。

/*

此API对消息接收及处理的力度更为精细，其中：

type类型包括NL_CB_ACK、NL_CB_SEQ_CHECK、NL_CB_INVALID等，可用于处理底层不同netlink消息的情况。

例如，当收到的netlink消息无效时，将调用NL_CB_INVALIDE设置的回调函数进行处理。

nl_cb_kinds指定消息回调函数的类型，可选值有NL_CB_CUSTOM，代表用户设置的回调函数，NL_CB_DEFAULT 代表默认的处理函数。

回调函数的返回值包括以下。

NL_OK:表示处理正常。

NL_SKIP：表示停止当前netlink消息分析，转而去分析接收buffer中下一条netlink消息（消息分

　　　 片的情况）。

NL_STOP：表示停止此次接收buffer中的消息分析。

*/

int nl_socket_modify_cb(struct nl_sock *sk,

enum nl_cb_type type, enum nl_cb_kind kind,

nl_recvmsg_msg_cb_t func, void *arg);

添加group：nl_socket_add_membership(sk, RTNLGRP_LINK);

另外，netlink还可设置错误消息（即专门处理nlmsgerr数据）处理回调函数，相关API如下。

#include <netlink/handlers.h> // 必须包含此头文件

// 设置错误消息处理

int nl_cb_err(struct nl_cb *cb, enum nl_cb_kind kind,

nl_recvmsg_err_cb_t func, void * arg);

typedef int(* nl_recvmsg_err_cb_t)(struct sockaddr_nl *nla,

struct nlmsgerr *nlerr, void *arg);

（2）libnl中的消息处理

libnl定义了自己的消息结构体struct nl_msg。不过它也提供API直接处理netlink的消息。常用的API如下。

#include <netlink/msg.h> // 必须包含这个头文件

// 下面这两个函数计算netlink消息体中对应部分的长度

int nlmsg_size(int payloadlen); // 请参考图来理解这两个函数返回值的意义

int nlmsg_total_size(int payloadlen);

关于netlink消息的长度如图3-51所示。



其他可直接处理netlink消息的API如下。

struct nlmsghdr *nlmsg_next(struct nlmsghdr *hdr, int *remaining);

int nlmsg_ok(const struct nlmsghdr *hdr, int remaining);

/*定义一个消息处理的for循环宏，其值等于

for (int rem = len, pos = head; nlmsg_ok(pos, rem);\

pos = nlmsg_next(pos, &rem))

*/

#define nlmsg_for_each(pos,head,en)

开发者也可以通过libnl定义的消息结构体nl_msg进行相关操作，和nl_msg有关的API如下。

struct nl_msg *nlmsg_alloc(void);

void nlmsg_free(struct nl_msg *msg);

// nl_msg内部肯定会指向一个netlink消息头实例，下面这个函数用于填充netlink消息头

struct nlmsghdr *nlmsg_put(struct nl_msg *msg,

uint32_t port, uint32_t seqnr,

int nlmsg_type, int payload, int nlmsg_flags);

（3）libnl中的消息发送和接收

netlink直接利用系统调用（如send、recv、sendmsg、recvmsg等）进行数据收发，而libnl封装了自己特有的数据收发API。其中和发送有关的几个主要API如下。

// 直接发送netlink消息

int nl_sendto (struct nl_sock *sk, void *buf, size_t size)

// 发送nl_msg消息

int nl_send (struct nl_sock *sk, struct nl_msg *msg)

int nl_send_simple(struct nl_sock *sk, int type,

int flags,void *buf, size_t size);

常用的数据接收API如下。

// 核心接收函数。nla参数用于存储发送端的地址信息。creds用于存储权限相关的信息

int nl_recv(struct nl_sock *sk, struct sockaddr_nl *nla,

unsigned char **buf, struct ucred **creds)

// 内部通过nl_recv接收消息，然后通过cb回调结构体中的回调函数传给接收者

int nl_recvmsgs (struct nl_sock *sk, struct nl_cb *cb)

（4）libnl-genl API介绍[41]

由图3-50可知，libnl-genl封装了对generic netlink模块的处理，它基于libnl。Linux中关于generic netlink的说明几乎没有，建议大家参考libnl中的说明。一条genl消息的结构如图3-52所示。



其中，genlmsghdr的原型如下。

struct genlmsghdr {

__u8 cmd; // cmd和version都和具体的案例有关

__u8 version;

__u16 reserved; // 保留

};

genl常用的API如下。

// 和libnl的nl_connect类型，只不过协议类型为GENERIC_NETLINK

int genl_connect (struct nl_sock *sk)

// genlmsg_put用于填充图中的nlmsghdr、genlmsghder和用户自定义的消息头。详细内容见下文

void* genlmsg_put (struct nl_msg *msg, uint32_t port,

uint32_t seq, int family, int hdrlen,

int flags, uint8_t cmd, uint8_t version)

// 用于获取genl消息中携带的nlattr内容

struct nlattr* genlmsg_attrdata(const struct genlmsghdr *gnlh,int hdrlen)

另外，genl还有几个比较重要的API，它们和genl机制的内核实现有关，这里仅简单介绍其中几点内容。为实现genl机制，内核创建了一个虚拟的Generic Netlink Bus。所有genl的使用者（包含内核模块或用户空间进程）都会注册到此Bus上。这些使用者注册时，都需要填充一个名为genl_family的数据结构，该结构是一种身份标示。所以某一方只要设置好genlmsg_put中的family参数，数据就能传递到对应的模块。

family是一个整型，可读性较差，所以genl使用者往往会指定一个字符串作为family name。而family name和family的对应关系则由genl中另外一个重要模块去处理。这个模块就是genl中的Controller，它也是Generic Bus使用者。其family name为“nlctrl”，只不过它的family是固定的，目前取值为16（一般为它定义一个NETLINK_GENERIC宏）。Controller的一个重要作用就是为其他注册者建立family name和family之间关系，也就是动态为其他注册者分配family编号。另外，Controller也支持查询，即返回当前Kernel中注册的所有genl模块的family
name和family的值。

对用户空间程序来说，只要知道family的值，就可和指定模块进行通信了。libnl-genl封装了上述操作，并提供了几个常用的API。

// 根据family name字符串去查询family，该函数内部实现将发送查询消息给Controller

int genl_ctrl_resolve (struct nl_sock *sk, const char *name)

/*

如果每次都向Controller去查询family编号将严重影响效率，所以libnl-genl会把查询到的信息

缓存起来。

下面这个函数将分配一个nl_cache列表，其内容存储了当前注册到Generic Netlink Bus上所有注

册者的信息。

*/

int genl_ctrl_alloc_cache (struct nl_sock *sk, struct nl_cache **result)

// 根据family name从缓存中获取对应的genl_family信息

struct genl_family * genl_ctrl_search_by_name

(struct nl_cache *cache, const char *name)

提示　相比直接使用netlink API，libnl对开发者更加友好，即使libnl封装得再好，netlink编程依然不是一件轻松的事情。

3.2.2

通知的信息包括：

netdev_chain通知链接收的事件信息；

设备状态改变时，如打开关闭的设备，或打开的设备关闭，在netdev_state_change函数中；

net_device->flags中的标记有改变时，如用户配置命令修改标记，在dev_change_flags函数中；

用户空间的netplugd守护进程(net-utils套件)会监测到这些事件，从而根据用户配置文件进行反应。

void netdev_state_change(struct net_device *dev)

{

if (dev->flags & IFF_UP) {

call_netdevice_notifiers(NETDEV_CHANGE, dev);

rtmsg_ifinfo(RTM_NEWLINK, dev, 0);

}

}

int dev_change_flags(struct net_device *dev, unsigned flags)

{

int ret, changes;

int old_flags = dev->flags;

ret = __dev_change_flags(dev, flags);

if (ret < 0)

return ret;

changes = old_flags ^ dev->flags;

if (changes)

rtmsg_ifinfo(RTM_NEWLINK, dev, changes);

__dev_notify_flags(dev, old_flags);

return ret;

}

EXPORT_SYMBOL(dev_change_flags);