检查网线的插拔

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 套接字：

1. fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);  

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

view plaincopy to clipboardprint?

1. addr.nl_family = AF_NETLINK;  
2. addr.nl_groups = RTNLGRP_LINK; //指定接收路由多播组消息  
3. 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 

通知的信息包括：

1. netdev_chain通知链接收的事件信息；
2. 设备状态改变时，如打开关闭的设备，或打开的设备关闭，在netdev_state_change函数中；
3. 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);