Linux内核基础 | 通知链机制

struct raw_notifier_head {
 struct notifier_block __rcu *head;
};

#define RAW_NOTIFIER_HEAD(name)     \
 struct raw_notifier_head name =    \
  RAW_NOTIFIER_INIT(name)

#define RAW_NOTIFIER_INIT(name) {    \
  .head = NULL }

例如创建一个设备通知链队列头：

RAW_NOTIFIER_HEAD(netdev_chain)

struct raw_notifier_head就相当于存放这条通知链单链表头，每一个通知链上的元素也就是通知块如下定义：

struct notifier_block { 
notifier_fn_t notifier_call; //通知调用的函数 
struct notifier_block __rcu *next;//指向下一个通知节点，从而形成链队 
int priority;//优先级，会根据优先级在单链表中排序
};

typedef int (*notifier_fn_t)(struct notifier_block *nb,
unsigned long action, void *data);

int raw_notifier_chain_register(struct raw_notifier_head *nh,
  struct notifier_block *n)
{
 return notifier_chain_register(&nh->head, n);
}

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;
}

4、调用通知链

int raw_notifier_call_chain(struct raw_notifier_head *nh,
  unsigned long val, void *v)
{
 return __raw_notifier_call_chain(nh, val, v, -1, NULL);
}

int __raw_notifier_call_chain(struct raw_notifier_head *nh,
         unsigned long val, void *v,
         int nr_to_call, int *nr_calls)
{
 return notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
}

static int 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_raw(*nl);
  //循环遍历调用链上的调用块
 while (nb && nr_to_call) {
  next_nb = rcu_dereference_raw(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)++;
    //如果该调用块的回调函数返回值为NOTIFY_STOP_MASK则跳出调用链的遍历，也就不执行后面的调用块的回调函数了
  if (ret & NOTIFY_STOP_MASK)
   break;
  nb = next_nb;
  nr_to_call--;
 }
 return ret;
}

三、编写内核模块进行实验

编写内核模块作为被通知者，向内核netdev_chain通知链中插入自定义通知块(在通知块中自定义事件触发的回调函数),源码如下：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/netdevice.h>
#include <linux/inetdevice.h>
 
//处理网络设备的启动与禁用等事件
int test_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
{
   struct net_device *dev = (struct net_device *)ptr;
 
 
    switch(event)
    {
        case NETDEV_UP:
             if(dev && dev->name)
                 printk("dev[%s] is up\n",dev->name);
             break;
        case NETDEV_DOWN:
             if(dev && dev->name)
                 printk("dev[%s] is down\n",dev->name);
                break;
        default:
             break;
    }
 
    return NOTIFY_DONE;
}          
       
                       
struct notifier_block devhandle={
    .notifier_call = test_netdev_event
};
 
static int __init  test_init(void)
{   
    /*
    在netdev_chain通知链上注册消息块 
    netdev_chain通知链是内核中用于传递有关网络设备注册状态的通知信息
 */
    register_netdevice_notifier(&devhandle);
 
    return 0; 
}   
 
static void __exit test_exit(void)
{
    unregister_netdevice_notifier(&devhandle);

    return;
}
 
 
module_init(test_init);
module_exit(test_exit);
 
MODULE_LICENSE("GPL");

obj-m:=Demo.o
                                    
CURRENT_PATH:=$(shell pwd)    
LINUX_KERNEL:=$(shell uname -r)  
LINUX_KERNEL_PATH:=/usr/src/linux-headers-$(LINUX_KERNEL)  
                                    
all:
 make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules  
clean:
 make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) clean   

将模块插入内核后，将网卡关闭再重启一次，查看日志信息：

dx@ubuntu:~/Linux_Sys_code/Notice/Module3$sudo insmod Demo.ko
 dx@ubuntu:~/Linux_Sys_code/Notice/Module3$ dmesg
[24309.137937] inet[00000000baf272e6] is down
[24313.046209] inet[00000000baf272e6] is up

2、案例2

通过写两个内核模块，其中一个作为通知者一个作为被通知者

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/notifier.h>

/*
模块功能：1、初始化一个通知链
         2、定义事件的回调函数并向通知链中插入三个通知块(与之前定义的回调函数相对应)
         3、测试通知链：循环遍历通知链的通知块，并同时调用对应的回调函数
*/
static RAW_NOTIFIER_HEAD(test_chain_head);
EXPORT_SYMBOL_GPL(test_chain_head);

//通知块1的执行函数
static int A_call(struct notifier_block *nb, unsigned long event, void *v)
{

    printk("AAAAAAAAAA---------event_A occur!---------AAAAAAAAAA\n");
    printk("my priority:%d\n",nb->priority);
    return NOTIFY_DONE;
} 
//通知块1：testA
static struct notifier_block testA = {
    .notifier_call = A_call,
    .priority = 7,
};

//通知块2的执行函数
static int B_call(struct notifier_block *nb, unsigned long event, void *v)
{

    printk("BBBBBBBBBB---------event_B occur!---------BBBBBBBBB\n");
    printk("my priority:%d\n",nb->priority);
    return NOTIFY_STOP_MASK;
} 
//通知块2：testB
static struct notifier_block testB = {
    .notifier_call = B_call,
    .priority = 9,
};

//通知块1的执行函数
static int C_call(struct notifier_block *nb, unsigned long event, void *v)
{
    printk("CCCCCCCCCC---------event_c occur!---------CCCCCCCCCC\n");
    printk("my priority:%d\n",nb->priority);
    return NOTIFY_DONE;

}
static struct notifier_block testC = {
    .notifier_call = C_call,
    .priority = 6,
};


static int __init my_register(void)
{
    printk("----------register notice chain---------\n");
    raw_notifier_chain_register(&test_chain_head,&testA);
    raw_notifier_chain_register(&test_chain_head,&testB);
    raw_notifier_chain_register(&test_chain_head,&testC);
    printk("----------register notice chain done---------\n");
    //遍历已经注册的调用链
 struct notifier_block *nb, *next_nb;
    struct raw_notifier_head *tmp = &test_chain_head;
    struct notifier_block *head = tmp->head;
 nb = rcu_dereference_raw(head);
    printk("----Test registed notice call----\n");
//循环遍历调用链，测试一下所插入的通知块
 while (nb) {
        int ret = NOTIFY_DONE;
        int index=0;
        next_nb = rcu_dereference_raw(nb->next);
        printk("notice%d fun:%p,priority:%d",++index,nb->notifier_call,nb->priority);
        ret = nb->notifier_call(nb, 1, NULL);          //调用注册的回调函数
        nb = next_nb;
 }
   printk("--------------Module_1 test end-------------\n");
    return 0;
}
static void __exit my_unregister(void)
{
    raw_notifier_chain_unregister(&test_chain_head,&testA);
    raw_notifier_chain_unregister(&test_chain_head,&testB);
    raw_notifier_chain_unregister(&test_chain_head,&testC);
}


module_init(my_register);
module_exit(my_unregister);

MODULE_AUTHOR("Dong Xu");
MODULE_LICENSE("GPL");

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/notifier.h>

/*
模块功能：模拟某事件发生，并调用通知链.

*/

extern struct raw_notifier_head test_chain_head;

//某事件
static int event(unsigned long val)
{
    int ret = raw_notifier_call_chain(&test_chain_head,val,NULL);
    return notifier_to_errno(ret);
}

static int __init my_entry(void)
{
    event(666);//模拟某事件发生
    return 0;
}
static void __exit my_exit(void)
{
    printk("test end\n");
}
module_init(my_entry);
module_exit(my_exit);

MODULE_AUTHOR("Dong Xu");
MODULE_LICENSE("GPL");