linux 通知链

在Linux内核中，各个子系统之间有很强的相互关系，某些子系统可能对其它子系统产生的事件感兴趣。为了让某个子系统在发生某个事件时通知感兴趣的子系统，Linux内核引入了通知链技术。通知链只能够在内核的子系统之间使用，而不能够在内核和用户空间进行事件的通知。

1 数据结构：

通知链有四种类型：

·原子通知链（ Atomic notifier chains ）：通知链元素的回调函数（当事件发生时要执行的函数）只能在中断上下文中运行，不允许阻塞。对应的链表头结构：

struct atomic_notifier_head {

     spinlock_t lock;

     struct notifier_block *head;

};

·可阻塞通知链（ Blocking notifier chains ）：通知链元素的回调函数在进程上下文中运行，允许阻塞。对应的链表头：

struct blocking_notifier_head {

    struct rw_semaphore rwsem;

    struct notifier_block *head;

};

·原始通知链（ Raw notifier chains ）：对通知链元素的回调函数没有任何限制，所有锁和保护机制都由调用者维护。对应的链表头：

struct raw_notifier_head {

    struct notifier_block *head;

};

·SRCU 通知链（ SRCU notifier chains ）：可阻塞通知链的一种变体。对应的链表头：

struct srcu_notifier_head {

    struct mutex mutex;

    struct srcu_struct srcu;

    struct notifier_block *head;

};

通知链的核心结构：

struct notifier_block {

    int (*notifier_call)(struct notifier_block *, unsigned long, void *);

    struct notifier_block *next;

    int priority;

};

其中notifier_call是通知链要执行的函数指针，next用来连接其它的通知结构，priority是这个通知的优先级，同一条链上的notifier_block{}是按优先级排列的。内核代码中一般把通知链命名为xxx_chain, xxx_nofitier_chain这种形式的变量名。

2 运作机制

通知链的运作机制包括两个角色：

·被通知者：对某一事件感兴趣一方。定义了当事件发生时，相应的处理函数，即回调函数。但需要事先将其注册到通知链中（被通知者注册的动作就是在通知链中增加一项）。

·通知者：事件的通知者。当检测到某事件，或者本身产生事件时，通知所有对该事件感兴趣的一方事件发生。他定义了一个通知链，其中保存了每一个被通知者对事件的处理函数（回调函数）。通知这个过程实际上就是遍历通知链中的每一项，然后调用相应的事件处理函数。

包括以下过程：

·通知者定义通知链

·被通知者向通知链中注册回调函数

·当事件发生时，通知者发出通知（执行通知链中所有元素的回调函数）

被通知者调用 notifier_chain_register 函数注册回调函数，该函数按照优先级将回调函数加入到通知链中：

static int notifier_chain_register(struct notifier_block **nl,

struct notifier_block *n)

{

    while ((*nl) != NULL) {

        if (n->priority > (*nl)->priority)

            break;

        nl = &((*nl)->next);

    }

    n->next = *nl;

    rcu_assign_pointer(*nl, n);

    return 0;

}

注销回调函数则使用 notifier_chain_unregister 函数，即将回调函数从通知链中删除：

static int notifier_chain_unregister(struct notifier_block **nl,

struct notifier_block *n)

{

    while ((*nl) != NULL) {

       if ((*nl) == n) {

           rcu_assign_pointer(*nl, n->next);

           return 0;

       }

      nl = &((*nl)->next);

    }

    return -ENOENT;

}

通知者调用 notifier_call_chain 函数通知事件的到达，这个函数会遍历通知链中所有的元素，然后依次调用每一个的回调函数（即完成通知动作）：

/**

* notifier_call_chain - Informs the registered notifiers about an event.

* @nl: Pointer to head of the blocking notifier chain

* @val: Value passed unmodified to notifier function

* @v: Pointer passed unmodified to notifier function

* @nr_to_call: Number of notifier functions to be called. Don't care

* value of this parameter is -1.

* @nr_calls: Records the number of notifications sent. Don't care

* value of this field is NULL.

* @returns: notifier_call_chain returns the value returned by the

* last notifier function called.

*/

static int __kprobes notifier_call_chain(struct notifier_block **nl,

unsigned long val, void *v,

int nr_to_call, int *nr_calls)

{

    int ret = NOTIFY_DONE;

    struct notifier_block *nb, *next_nb;

    nb = rcu_dereference(*nl);

    while (nb && nr_to_call) {

        next_nb = rcu_dereference(nb->next);

       #ifdef CONFIG_DEBUG_NOTIFIERS

       if (unlikely(!func_ptr_is_kernel_text(nb->notifier_call))) {

            WARN(1, "Invalid notifier called!");

           nb = next_nb;

            continue;

       }

      #endif

       ret = nb->notifier_call(nb, val, v);

       if (nr_calls)

            (*nr_calls)++;

       if ((ret & NOTIFY_STOP_MASK) == NOTIFY_STOP_MASK)

            break;

       nb = next_nb;

      nr_to_call--;

   }

   return ret;

}

参数nl是通知链的头部，val表示事件类型，v用来指向通知链上的函数执行时需要用到的参数，一般不同的通知链，参数类型也不一样，例如当通知一个网卡被注册时，v就指向net_device结构，nr_to_call表示准备最多通知几个，-1表示整条链都通知，nr_calls非空的话，返回通知了多少个。

每个被执行的notifier_block回调函数的返回值可能取值为以下几个：

·NOTIFY_DONE：表示对相关的事件类型不关心

·NOTIFY_OK：顺利执行

·NOTIFY_BAD：执行有错

·NOTIFY_STOP：停止执行后面的回调函数

·NOTIFY_STOP_MASK：停止执行的掩码

Notifier_call_chain()把最后一个被调用的回调函数的返回值作为它的返回值。

 

 

3 内核网络代码中对通知链的使用

内核网络部分使用的一些通知链：

·inetaddr_chain：ipv4地址变动时的通知链

·netdev_chain：网络设备状态变动时的通知链

网络代码中对通知链的调用一般都有一个包装函数，例如对netdev_chain的注册就是由register_netdevice_notifier()函数完成的：

int register_netdevice_notifier(struct notifier_block *nb)

{

   struct net_device *dev;

   struct net_device *last;

    struct net *net;

   int err;

   rtnl_lock();

   err = raw_notifier_chain_register(&netdev_chain, nb);

   if (err)

      goto unlock;

   if (dev_boot_phase)

     goto unlock;

   for_each_net(net) {

      for_each_netdev(net, dev) {

          err = nb->notifier_call(nb, NETDEV_REGISTER, dev);

          err = notifier_to_errno(err);

          if (err)

             goto rollback;

          if (!(dev->flags & IFF_UP))

             continue;

         nb->notifier_call(nb, NETDEV_UP, dev);

      }

   }

unlock:

   rtnl_unlock();

return err;

rollback:

    last = dev;

   for_each_net(net) {

      for_each_netdev(net, dev) {

          if (dev == last)

              break;

          if (dev->flags & IFF_UP) {

              nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);

              nb->notifier_call(nb, NETDEV_DOWN, dev);

          }

          nb->notifier_call(nb, NETDEV_UNREGISTER, dev);

       }

   }

   raw_notifier_chain_unregister(&netdev_chain, nb);

   goto unlock;

}

这个函数主要完成两件事情：

1）把参数struct notifier_block *nb注册到netdev_chain通知链上；

2）系统中所有已经被注册过的或者激活的网络设备的事件都要被新增的这个通知的回调函数重新调用一遍，使设备更新到一个完整的状态。

dev_boot_phase定义如下，表示在启动阶段。

static int dev_boot_phase = 1;

例如，在启动阶段的网络模块初始化过程中，有一个调用过程inet_init()-->ip_init()-->ip_rt_init()-->devinet_init()，会注册一个ip_netdev_notifier通知链：

register_netdevice_notifier(&ip_netdev_notifier);

而ip_netdev_notifier定义为：

static struct notifier_block ip_netdev_notifier = {

    .notifier_call = inetdev_event,

};

inetdev_event()实现为：

static int inetdev_event(struct notifier_block *this, unsigned long event,

void *ptr)

{

     struct net_device *dev = ptr;

     struct in_device *in_dev = __in_dev_get_rtnl(dev);

     ASSERT_RTNL();

    if (!in_dev) {

       if (event == NETDEV_REGISTER) {

             in_dev = inetdev_init(dev);

           if (!in_dev)

                return notifier_from_errno(-ENOMEM);

            if (dev->flags & IFF_LOOPBACK) {

                IN_DEV_CONF_SET(in_dev, NOXFRM, 1);

                IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);

            }

        } else if (event == NETDEV_CHANGEMTU) {

        /* Re-enabling IP */

           if (inetdev_valid_mtu(dev->mtu))

              in_dev = inetdev_init(dev);

        }

        goto out;

    }

    switch (event) {

     case NETDEV_REGISTER:

        printk(KERN_DEBUG "inetdev_event: bug\n");

        dev->ip_ptr = NULL;

        break;

     case NETDEV_UP:

       if (!inetdev_valid_mtu(dev->mtu))

           break;

    ……

}

在注册的时候传递的是NETDEV_REGISTER事件，所以在in_dev不为空时，只做switch语句中的一个动作：dev->ip_ptr = NULL；在in_dev为空时，调用inetdev_init()函数分配一个struct in_device，此时如果是Loopback设备才有动作了。

4 参考文章：

1 http://hi.baidu.com/mczyh/blog/item/80f4200098588c087bec2ce8.html

2

3 http://blog.chinaunix.net/u2/67414/showart_1993495.html

其中参考文章2中有一个很好的例子。