UDN-企业互联网技术人气社区

板块导航

浏览  : 1195
回复  : 0

[运维] Linux 内核通知链机制的原理及实现

[复制链接]
哥屋恩的头像 楼主
发表于 2016-10-23 19:06:29 | 显示全部楼层 |阅读模式
  一、概念:

  大多数内核子系统都是相互独立的,因此某个子系统可能对其它子系统产生的事件感兴趣。为了满足这个需求,也即是让某个子系统在发生某个事件时通知其它的子 系统,Linux内核提供了通知链的机制。通知链表只能够在内核的子系统之间使用,而不能够在内核与用户空间之间进行事件的通知。 通知链表是一个函数链表,链表上的每一个节点都注册了一个函数。当某个事情发生时,链表上所有节点对应的函数就会被执行。所以对于通知链表来说有一个通知 方与一个接收方。在通知这个事件时所运行的函数由被通知方决定,实际上也即是被通知方注册了某个函数,在发生某个事件时这些函数就得到执行。其实和系统调 用signal的思想差不多。

  二、数据结构:

  通知链有四种类型:

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

  1.   struct atomic_notifier_head

  2.   {

  3.   spinlock_t lock;

  4.   struct notifier_block *head;

  5.   };
复制代码


  2.可阻塞通知链( Blocking notifier chains ):通知链元素的回调函数在进程上下文中运行,允许阻塞。对应的链表头:

  1.   struct blocking_notifier_head

  2.   {

  3.   struct rw_semaphore rwsem;

  4.   struct notifier_block *head;

  5.   };
复制代码


  3.原始通知链( Raw notifier chains ):对通知链元素的回调函数没有任何限制,所有锁和保护机制都由调用者维护。对应的链表头:

  1.   struct raw_notifier_head

  2.   {

  3.   struct notifier_block *head;

  4.   };
复制代码


  4.SRCU 通知链( SRCU notifier chains ):可阻塞通知链的一种变体。对应的链表头:

  1.   struct srcu_notifier_head

  2.   {

  3.   struct mutex mutex;

  4.   struct srcu_struct srcu;

  5.   struct notifier_block *head;

  6.   };

  7.   通知链的核心结构:

  8.   struct notifier_block

  9.   {

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

  11.   struct notifier_block *next;

  12.   int priority;

  13.   };
复制代码


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

  三、运作机制:

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

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

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

  包括以下过程:

  通知者定义通知链。

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

  当事件发生时,通知者发出通知(执行通知链中所有元素的回调函数)。

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

  1.   static int notifier_chain_register(struct notifier_block **nl, struct notifier_block *n)

  2.   {

  3.   while ((*nl) != NULL)

  4.   {

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

  6.   break;

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

  8.   }

  9.   n->next = *nl;

  10.   rcu_assign_pointer(*nl, n);

  11.   return 0;

  12.   }
复制代码


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

  1.   static int notifier_chain_unregister(struct notifier_block **nl, struct notifier_block *n)

  2.   {

  3.   while ((*nl) != NULL)

  4.   {

  5.   if ((*nl) == n)

  6.   {

  7.   rcu_assign_pointer(*nl, n->next);

  8.   return 0;

  9.   }

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

  11.   }

  12.   return -ENOENT;

  13.   }
复制代码


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

  1.   static int __kprobes notifier_call_chain(struct notifier_block **nl, unsigned long val, void *v, int nr_to_call, int *nr_calls)

  2.   {

  3.   int ret = NOTIFY_DONE;

  4.   struct notifier_block *nb, *next_nb;

  5.   nb = rcu_dereference(*nl);

  6.   while (nb && nr_to_call)

  7.   {

  8.   next_nb = rcu_dereference(nb->next);

  9.   #ifdef CONFIG_DEBUG_NOTIFIERS

  10.   if (unlikely(!func_ptr_is_kernel_text(nb->notifier_call)))

  11.   {

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

  13.   nb = next_nb;

  14.   continue;

  15.   }

  16.   #endif

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

  18.   if (nr_calls)

  19.   (*nr_calls)++;

  20.   if ((ret & NOTIFY_STOP_MASK) == NOTIFY_STOP_MASK)

  21.   break;

  22.   nb = next_nb;

  23.   nr_to_call--;

  24.   }

  25.   return ret;

  26.   }
复制代码


  参数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()把最后一个被调用的回调函数的返回值作为它的返回值。

  四、举例应用:

  在这里,写了一个简单的通知链表的代码。实际上,整个通知链的编写也就两个过程:

  首先是定义自己的通知链的头节点,并将要执行的函数注册到自己的通知链中。

  其次则是由另外的子系统来通知这个链,让其上面注册的函数运行。

  这里将第一个过程分成了两步来写,第一步是定义了头节点和一些自定义的注册函数(针对该头节点的),第二步则是使用自定义的注册函数注册了一些通知链节点。分别在代码buildchain.c与regchain.c中。发送通知信息的代码为notify.c。

  代码1 buildchain.c。它的作用是自定义一个通知链表test_chain,然后再自定义两个函数分别向这个通知链中加入或删除节点,最后再定义一个函数通知这个test_chain链:

  1.   #include

  2.   #include

  3.   #include

  4.   #include

  5.   #include

  6.   #include

  7.   #include

  8.   #include

  9.   MODULE_LICENSE("GPL");

  10.   /*

  11.   * 定义自己的通知链头结点以及注册和卸载通知链的外包函数

  12.   */

  13.   /*

  14.   * RAW_NOTIFIER_HEAD是定义一个通知链的头部结点,

  15.   * 通过这个头部结点可以找到这个链中的其它所有的notifier_block

  16.   */

  17.   static RAW_NOTIFIER_HEAD(test_chain);

  18.   /*

  19.   * 自定义的注册函数,将notifier_block节点加到刚刚定义的test_chain这个链表中来

  20.   * raw_notifier_chain_register会调用notifier_chain_register

  21.   */

  22.   int register_test_notifier(struct notifier_block *nb)

  23.   {

  24.   return raw_notifier_chain_register(&test_chain, nb);

  25.   }

  26.   EXPORT_SYMBOL(register_test_notifier);

  27.   int unregister_test_notifier(struct notifier_block *nb)

  28.   {

  29.   return raw_notifier_chain_unregister(&test_chain, nb);

  30.   }

  31.   EXPORT_SYMBOL(unregister_test_notifier);

  32.   /*

  33.   * 自定义的通知链表的函数,即通知test_chain指向的链表中的所有节点执行相应的函数

  34.   */

  35.   int test_notifier_call_chain(unsigned long val, void *v)

  36.   {

  37.   return raw_notifier_call_chain(&test_chain, val, v);

  38.   }

  39.   EXPORT_SYMBOL(test_notifier_call_chain);

  40.   /*

  41.   * init and exit

  42.   */

  43.   static int __init init_notifier(void)

  44.   {

  45.   printk("init_notifier\n");

  46.   return 0;

  47.   }

  48.   static void __exit exit_notifier(void)

  49.   {

  50.   printk("exit_notifier\n");

  51.   }

  52.   module_init(init_notifier);

  53.   module_exit(exit_notifier);
复制代码


  代码2 regchain.c。该代码的作用是将test_notifier1 test_notifier2 test_notifier3这三个节点加到之前定义的test_chain这个通知链表上,同时每个节点都注册了一个函数:

  1.   #include

  2.   #include

  3.   #include

  4.   #include

  5.   #include

  6.   #include

  7.   #include

  8.   #include

  9.   MODULE_LICENSE("GPL");

  10.   /*

  11.   * 注册通知链

  12.   */

  13.   extern int register_test_notifier(struct notifier_block*);

  14.   extern int unregister_test_notifier(struct notifier_block*);

  15.   static int test_event1(struct notifier_block *this, unsigned long event, void *ptr)

  16.   {

  17.   printk("In Event 1: Event Number is %d\n", event);

  18.   return 0;

  19.   }

  20.   static int test_event2(struct notifier_block *this, unsigned long event, void *ptr)

  21.   {

  22.   printk("In Event 2: Event Number is %d\n", event);

  23.   return 0;

  24.   }

  25.   static int test_event3(struct notifier_block *this, unsigned long event, void *ptr)

  26.   {

  27.   printk("In Event 3: Event Number is %d\n", event);

  28.   return 0;

  29.   }

  30.   /*

  31.   * 事件1,该节点执行的函数为test_event1

  32.   */

  33.   static struct notifier_block test_notifier1 =

  34.   {

  35.   .notifier_call = test_event1,

  36.   };

  37.   /*

  38.   * 事件2,该节点执行的函数为test_event1

  39.   */

  40.   static struct notifier_block test_notifier2 =

  41.   {

  42.   .notifier_call = test_event2,

  43.   };

  44.   /*

  45.   * 事件3,该节点执行的函数为test_event1

  46.   */

  47.   static struct notifier_block test_notifier3 =

  48.   {

  49.   .notifier_call = test_event3,

  50.   };

  51.   /*

  52.   * 对这些事件进行注册

  53.   */

  54.   static int __init reg_notifier(void)

  55.   {

  56.   int err;

  57.   printk("Begin to register:\n");

  58.   err = register_test_notifier(&test_notifier1);

  59.   if (err)

  60.   {

  61.   printk("register test_notifier1 error\n");

  62.   return -1;

  63.   }

  64.   printk("register test_notifier1 completed\n");

  65.   err = register_test_notifier(&test_notifier2);

  66.   if (err)

  67.   {

  68.   printk("register test_notifier2 error\n");

  69.   return -1;

  70.   }

  71.   printk("register test_notifier2 completed\n");

  72.   err = register_test_notifier(&test_notifier3);

  73.   if (err)

  74.   {

  75.   printk("register test_notifier3 error\n");

  76.   return -1;

  77.   }

  78.   printk("register test_notifier3 completed\n");

  79.   return err;

  80.   }

  81.   /*

  82.   * 卸载刚刚注册了的通知链

  83.   */

  84.   static void __exit unreg_notifier(void)

  85.   {

  86.   printk("Begin to unregister\n");

  87.   unregister_test_notifier(&test_notifier1);

  88.   unregister_test_notifier(&test_notifier2);

  89.   unregister_test_notifier(&test_notifier3);

  90.   printk("Unregister finished\n");

  91.   }

  92.   module_init(reg_notifier);

  93.   module_exit(unreg_notifier);
复制代码


  代码3 notify.c。该代码的作用就是向test_chain通知链中发送消息,让链中的函数运行:

  1.   #include

  2.   #include

  3.   #include

  4.   #include

  5.   #include

  6.   #include

  7.   #include

  8.   #include

  9.   MODULE_LICENSE("GPL");

  10.   extern int test_notifier_call_chain(unsigned long val, void *v);

  11.   /*

  12.   * 向通知链发送消息以触发注册了的函数

  13.   */

  14.   static int __init call_notifier(void)

  15.   {

  16.   int err;

  17.   printk("Begin to notify:\n");

  18.   /*

  19.   * 调用自定义的函数,向test_chain链发送消息

  20.   */

  21.   printk("==============================\n");

  22.   err = test_notifier_call_chain(1, NULL);

  23.   printk("==============================\n");

  24.   if (err)

  25.   printk("notifier_call_chain error\n");

  26.   return err;

  27.   }

  28.   static void __exit uncall_notifier(void)

  29.   {

  30.   printk("End notify\n");

  31.   }

  32.   module_init(call_notifier);

  33.   module_exit(uncall_notifier);
复制代码


  Makefile文件:

  1.   obj-m:=buildchain.o regchain.o notify.o

  2.   CURRENT_PATH := $(shell pwd)

  3.   LINUX_KERNEL := $(shell uname -r)

  4.   KERNELDIR := /usr/src/linux-headers-$(LINUX_KERNEL)

  5.   all:

  6.   make -C $(KERNELDIR) M=$(CURRENT_PATH) modules

  7.   clean:

  8.   make -C $(KERNELDIR) M=$(CURRENT_PATH) clean
复制代码


  运行(注意insmod要root权限):

  1.   make

  2.   insmod buildchain.ko

  3.   insmod regchain.ko

  4.   insmod notify.ko
复制代码


  这样就可以看到通知链运行的效果了:

  1.   init_notifier

  2.   Begin to register:

  3.   register test_notifier1 completed

  4.   register test_notifier2 completed

  5.   register test_notifier3 completed

  6.   Begin to notify:

  7.   ==============================

  8.   In Event 1: Event Number is 1

  9.   In Event 2: Event Number is 1

  10.   In Event 3: Event Number is 1
复制代码


原文作者:佚名  来源:开发者头条

相关帖子

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

关于我们
联系我们
  • 电话:010-86393388
  • 邮件:udn@yonyou.com
  • 地址:北京市海淀区北清路68号
移动客户端下载
关注我们
  • 微信公众号:yonyouudn
  • 扫描右侧二维码关注我们
  • 专注企业互联网的技术社区
版权所有:用友网络科技股份有限公司82041 京ICP备05007539号-11 京公网网备安1101080209224 Powered by Discuz!
快速回复 返回列表 返回顶部