Linux内核基础--事件通知链(notifier chain)【转】

简介:

转自:http://blog.csdn.net/wuhzossibility/article/details/8079025

内核通知链

1.1. 概述

       Linux内核中各个子系统相互依赖,当其中某个子系统状态发生改变时,就必须使用一定的机制告知使用其服务的其他子系统,以便其他子系统采取相应的措施。为满足这样的需求,内核实现了事件通知链机制(notificationchain)。

       通知链只能用在各个子系统之间,而不能在内核和用户空间进行事件的通知。组成内核的核心系统代码均位于kernel目录下,通知链表位于kernel/notifier.c中,对应的头文件为include/linux/notifier.h。通知链表机制并不复杂,实现它的代码只有区区几百行。

       事件通知链表是一个事件处理函数的列表,每个通知链都与某个或某些事件有关,当特定的事件发生时,就调用相应的事件通知链中的回调函数,进行相应的处理。

 

图 1  内核通知链

1.2.数据结构

如图 1中所示,Linux的网络子系统一共有3个通知链:表示ipv4地址发生变化时的inetaddr_chain;表示ipv6地址发生变化的inet6addr_chain;还有表示设备注册、状态变化的netdev_chain。

在这些链中都是一个个notifier_block结构: 

 

[cpp]  view plain  copy
 
  1. struct notifier_block {  
  2.        int (*notifier_call)(struct notifier_block *, unsigned long, void *);  
  3.        struct notifier_block *next;  
  4.        int priority;  
  5. };  

 

其中,

1.     notifier_call:当相应事件发生时应该调用的函数,由被通知方提供,如other_subsys_1;

2.     notifier_block *next:用于链接成链表的指针;

3.     priority:回调函数的优先级,一般默认为0。

内核代码中一般把通知链命名为xxx_chain, xxx_nofitier_chain这种形式的变量名。围绕核心数据结构notifier_block,内核定义了四种通知链类型:

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

 

[cpp]  view plain  copy
 
  1. struct atomic_notifier_head {  
  2.         spinlock_t  lock;  
  3.         struct  notifier_block *head;  
  4. };  

 

 

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

 

[cpp]  view plain  copy
 
  1. struct  blocking_notifier_head {  
  2.         struct  rw_semaphore  rwsem;  
  3.         struct  notifier_block   *head;  
  4. };  


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

 

网络子系统就是该类型,通过以下宏实现head的初始化

 

[cpp]  view plain  copy
 
  1. static RAW_NOTIFIER_HEAD(netdev_chain);  
  2. #define RAW_NOTIFIER_INIT(name)     {      \  
  3.               .head= NULL }  
  4. #define RAW_NOTIFIER_HEAD(name)         \      //调用他就好了  
  5. struct raw_notifier_head name =         \  
  6.                      RAW_NOTIFIER_INIT(name)     
  7. 即:  
  8. struct raw_notifier_head netdev_chain = {  
  9.           .head = NULL;  
  10. }  

 

而其回调函数的注册,比如向netdev_chain的注册函数:register_netdevice_notifier。

 

[cpp]  view plain  copy
 
  1. struct  raw_notifier_head {  
  2.         struct  notifier_block   *head;  
  3. };  
  4.    

 

 

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

 

[cpp]  view plain  copy
 
  1. struct  srcu_notifier_head {  
  2.         struct  mutex mutex;  
  3.         struct  srcu_struct  srcu;  
  4.         struct  notifier_block  *head;  
  5. };  


1.3.  运行机理

 

被通知一方(other_subsys_x)通过notifier_chain_register向特定的chain注册回调函数,并且一般而言特定的子系统会用特定的notifier_chain_register包装函数来注册,比如路由子系统使用的是网络子系统的:register_netdevice_notifier来注册他的notifier_block。

1.3.1.  向事件通知链注册的步骤

1. 申明struct notifier_block结构

2. 编写notifier_call函数

3. 调用特定的事件通知链的注册函数,将notifier_block注册到通知链中

如果内核组件需要处理够某个事件通知链上发出的事件通知,其就该在初始化时在该通知链上注册回调函数。

1.3.2.  通知子系统有事件发生

inet_subsys是通过notifier_call_chain来通知其他的子系统(other_subsys_x)的。

notifier_call_chain会按照通知链上各成员的优先级顺序执行回调函数(notifier_call_x);回调函数的执行现场在notifier_call_chain进程地址空间;其返回值是NOTIFY_XXX的形式,在include/linux/notifier.h中:

 

[cpp]  view plain  copy
 
  1. #define NOTIFY_DONE            0x0000         /* 对事件视而不见 */  
  2. #define NOTIFY_OK          0x0001         /* 事件正确处理 */  
  3. #define NOTIFY_STOP_MASK  0x8000         /*由notifier_call_chain检查,看继续调用回调函数,还是停止,_BAD和_STOP中包含该标志 */  
  4. #define NOTIFY_BAD        (NOTIFY_STOP_MASK|0x0002)       /*事件处理出错,不再继续调用回调函数 */  
  5. /* 
  6.  *Clean way to return from the notifier and stop further calls. 
  7.  */  
  8. #define NOTIFY_STOP             (NOTIFY_OK|NOTIFY_STOP_MASK)    /*  回调出错,不再继续调用该事件回调函数 */  

notifier_call_chain捕获并返回最后一个事件处理函数的返回值;注意:notifier_call_chain可能同时被不同的cpu调用,故而调用者必须保证互斥。

1.3.3.  事件列表

       对于网络子系统而言,其事件常以NETDEV_XXX命名;描述了网络设备状态(dev->flags)、传送队列状态(dev->state)、设备注册状态(dev->reg_state),以及设备的硬件功能特性(dev->features):

include/linux/notifier.h中

 

[cpp]  view plain  copy
 
  1. /* netdevice notifier chain */  
  2. #define NETDEV_UP  0x0001  /* 激活一个网络设备 */  
  3. #define NETDEV_DOWN  0x0002f /* 停止一个网络设备,所有对该设备的引用都应释放 */  
  4. #define NETDEV_REBOOT       0x0003       /* 检查到网络设备接口硬件崩溃,硬件重启 */  
  5. #define NETDEV_CHANGE       0x0004  /* 网络设备的数据包队列状态发生改变 */  
  6. #define NETDEV_REGISTER  0x0005   /*一个网络设备事例注册到系统中,但尚未激活 */  
  7. #define NETDEV_UNREGISTER       0x0006       /*网络设备驱动已卸载 */  
  8. #define NETDEV_CHANGEMTU      0x0007  /*MTU发生了改变 */  
  9. #define NETDEV_CHANGEADDR    0x0008  /*硬件地址发生了改变 */  
  10. #define NETDEV_GOING_DOWN   0x0009  /*网络设备即将注销,有dev->close报告,通知相关子系统处理 */  
  11. #define NETDEV_CHANGENAME   0x000A  /*网络设备名改变 */  
  12. #define NETDEV_FEAT_CHANGE    0x000B  /*feature网络硬件功能改变 */  
  13. #define NETDEV_BONDING_FAILOVER 0x000C  /*    */  
  14. #define NETDEV_PRE_UP        0x000D  /*    */  
  15. #define NETDEV_BONDING_OLDTYPE  0x000E              /*    */  
  16. #define NETDEV_BONDING_NEWTYPE  0x000F      /*    */  

 

1.4.  简单一例:

       通过上面所述,notifier_chain机制只能在内核个子系统间使用,因此,这里使用3个模块:test_notifier_chain_0、test_notifier_chain_1、test_notifier_chain_2;当 test_notifier_chain_2通过module_init初始化模块时发出事件TESTCHAIN_2_INIT;然后 test_notifier_chain_1作出相应的处理:打印 test_notifier_chain_2正在初始化。

 

[cpp]  view plain  copy
 
  1. /* test_chain_0.c :0. 申明一个通知链;1. 向内核注册通知链;2. 定义事件; 3. 导出符号,因而必需最后退出*/  
  2.   
  3. #include <linux/notifier.h>  
  4. #include <linux/module.h>  
  5. #include <linux/init.h>  
  6. #include <linux/kernel.h> /* printk() */  
  7. #include <linux/fs.h> /* everything() */  
  8.   
  9. #define TESTCHAIN_INIT 0x52U  
  10. static RAW_NOTIFIER_HEAD(test_chain);  
  11.   
  12. /* define our own notifier_call_chain */  
  13. static int call_test_notifiers(unsigned long val, void *v)  
  14. {  
  15.     return raw_notifier_call_chain(&test_chain, val, v);  
  16. }  
  17. EXPORT_SYMBOL(call_test_notifiers);  
  18.   
  19. /* define our own notifier_chain_register func */  
  20.  static int register_test_notifier(struct notifier_block *nb)  
  21. {  
  22.     int err;  
  23.     err = raw_notifier_chain_register(&test_chain, nb);  
  24.   
  25.     if(err)  
  26.         goto out;  
  27.   
  28. out:  
  29.     return err;  
  30. }  
  31.   
  32. EXPORT_SYMBOL(register_test_notifier);  
  33.   
  34. static int __init test_chain_0_init(void)  
  35. {  
  36.     printk(KERN_DEBUG "I'm in test_chain_0\n");  
  37.   
  38.     return 0;  
  39. }  
  40.   
  41. static void __exit test_chain_0_exit(void)  
  42. {  
  43.     printk(KERN_DEBUG "Goodbye to test_chain_0\n");  
  44. //  call_test_notifiers(TESTCHAIN_EXIT, (int *)NULL);  
  45. }  
  46.   
  47. MODULE_LICENSE("GPL v2");  
  48. MODULE_AUTHOR("fishOnFly");  
  49.   
  50. module_init(test_chain_0_init);  
  51. module_exit(test_chain_0_exit);  
  52.   
  53. /* test_chain_1.c :1. 定义回调函数;2. 定义notifier_block;3. 向chain_0注册notifier_block;*/  
  54. #include <linux/notifier.h>  
  55. #include <linux/module.h>  
  56. #include <linux/init.h>  
  57.   
  58. #include <linux/kernel.h> /* printk() */  
  59. #include <linux/fs.h> /* everything() */  
  60.   
  61. extern int register_test_notifier(struct notifier_block *nb);  
  62. #define TESTCHAIN_INIT 0x52U  
  63.   
  64. /* realize the notifier_call func */  
  65. int test_init_event(struct notifier_block *nb, unsigned long event,  
  66.     void *v)  
  67. {  
  68.     switch(event){  
  69.     case TESTCHAIN_INIT:  
  70.         printk(KERN_DEBUG "I got the chain event: test_chain_2 is on the way of init\n");  
  71.         break;  
  72.   
  73.     default:  
  74.         break;  
  75.     }  
  76.   
  77.     return NOTIFY_DONE;  
  78. }  
  79. /* define a notifier_block */  
  80. static struct notifier_block test_init_notifier = {  
  81.     .notifier_call = test_init_event,  
  82. };  
  83. static int __init test_chain_1_init(void)  
  84. {  
  85.     printk(KERN_DEBUG "I'm in test_chain_1\n");  
  86.     register_test_notifier(&test_init_notifier);<span style="white-space:pre">  </span>// 由chain_0提供的设施  
  87.     return 0;  
  88. }  
  89.   
  90. static void __exit test_chain_1_exit(void)  
  91. {  
  92.     printk(KERN_DEBUG "Goodbye to test_clain_l\n");  
  93. }  
  94.   
  95. MODULE_LICENSE("GPL");  
  96. MODULE_AUTHOR("fishOnFly");  
  97.   
  98. module_init(test_chain_1_init);  
  99. module_exit(test_chain_1_exit);  
  100.   
  101. /* test_chain_2.c:发出通知链事件*/  
  102.   
  103. #include <linux/notifier.h>  
  104. #include <linux/module.h>  
  105. #include <linux/init.h>  
  106. #include <linux/kernel.h> /* printk() */  
  107. #include <linux/fs.h> /* everything() */  
  108.   
  109. extern int call_test_notifiers(unsigned long val, void *v);  
  110. #define TESTCHAIN_INIT 0x52U  
  111.   
  112. static int __init test_chain_2_init(void)  
  113. {  
  114.     printk(KERN_DEBUG "I'm in test_chain_2\n");  
  115.     call_test_notifiers(TESTCHAIN_INIT, "no_use");  
  116.       
  117.     return 0;  
  118. }  
  119.   
  120. static void __exit test_chain_2_exit(void)  
  121. {  
  122.     printk(KERN_DEBUG "Goodbye to test_chain_2\n");  
  123. }  
  124.   
  125. MODULE_LICENSE("GPL v2");  
  126. MODULE_AUTHOR("fishOnFly");  
  127.   
  128. module_init(test_chain_2_init);  
  129. module_exit(test_chain_2_exit);  
  130.   
  131. # Makefile  
  132.   
  133. # Comment/uncomment the following line to disable/enable debugging  
  134. # DEBUG = y  
  135.   
  136.   
  137. # Add your debugging flag (or not) to CFLAGS  
  138. ifeq ($(DEBUG),y)  
  139.   DEBFLAGS = -O -g -DSCULL_DEBUG # "-O" is needed to expand inlines  
  140. else  
  141.   DEBFLAGS = -O2  
  142. endif  
  143.   
  144.   
  145. ifneq ($(KERNELRELEASE),)  
  146. # call from kernel build system  
  147.   
  148. obj-m   := test_chain_0.o test_chain_1.o test_chain_2.o  
  149.   
  150. else  
  151.   
  152. KERNELDIR ?= /lib/modules/$(shell uname -r)/build  
  153. PWD       := $(shell pwd)  
  154.   
  155. modules:  
  156.     (MAKE)C(MAKE)−C(KERNELDIR) M=$(PWD) modules  
  157.   
  158. endif  
  159.   
  160.   
  161.   
  162. clean:  
  163.     rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions  
  164.   
  165. depend .depend dep:  
  166.     (CC)(CC)(CFLAGS) -M *.c > .depend  
  167.   
  168.   
  169. ifeq (.depend,$(wildcard .depend))  
  170. include .depend  
  171. endif  
  172.   
  173. [wang2@iwooing: notifier_chian]$ sudo insmod./test_chain_0.ko  
  174. [wang2@iwooing: notifier_chian]$ sudo insmod./test_chain_1.ko  
  175. [wang2@iwooing: notifier_chian]$ sudo insmod./test_chain_2.ko  
  176.    
  177.   
  178. [wang2@iwooing: notifier_chian]$ dmesg  
  179.   
  180. [ 5950.112649] I'm in test_chain_0  
  181. [ 5956.766610] I'm in test_chain_1  
  182. [ 5962.570003] I'm in test_chain_2  
  183. [ 5962.570008] I got the chain event: test_chain_2 is on the way of init  
  184.   
  185. [ 6464.042975] Goodbye to test_chain_2  
  186. [ 6466.368030] Goodbye to test_clain_l  
  187. [ 6468.371479] Goodbye to test_chain_0  



 

[cpp]  view plain  copy
 
    1. <p></p>  









本文转自张昺华-sky博客园博客,原文链接: http://www.cnblogs.com/sky-heaven/p/5355028.html ,如需转载请自行联系原作者


相关文章
|
14天前
|
存储 Linux 数据处理
探索Linux操作系统的内核与文件系统
本文深入探讨了Linux操作系统的核心组件,包括其独特的内核结构和灵活的文件系统。文章首先概述了Linux内核的主要功能和架构,接着详细分析了文件系统的工作原理以及它如何支持数据存储和检索。通过比较不同的文件系统类型,本文旨在为读者提供一个关于如何根据特定需求选择合适文件系统的参考框架。
|
18天前
|
安全 算法 网络协议
探索Linux操作系统的内核管理
【5月更文挑战第31天】本文将深入探讨Linux操作系统的内核管理机制,包括其设计原则、主要组件以及它们如何协同工作以提供高效的系统性能。通过分析Linux内核的关键特性和功能,我们将揭示这一开源操作系统如何在各种计算环境中保持其稳定性和灵活性。
|
19天前
|
机器学习/深度学习 人工智能 负载均衡
深度解析:Linux内核调度策略的演变与优化
【5月更文挑战第30天】 随着计算技术的不断进步,操作系统的性能调优成为了提升计算机系统效率的关键。在众多操作系统中,Linux因其开源和高度可定制性而备受青睐。本文将深入剖析Linux操作系统的内核调度策略,追溯其历史演变过程,并重点探讨近年来为适应多核处理器和实时性要求而产生的调度策略优化。通过分析比较不同的调度算法,如CFS(完全公平调度器)、实时调度类和批处理作业的调度需求,本文旨在为系统管理员和开发者提供对Linux调度机制深层次理解,同时指出未来可能的发展趋势。
|
29天前
|
算法 安全 Linux
探索Linux内核的虚拟内存管理
【5月更文挑战第20天】 在本文中,我们将深入探讨Linux操作系统的核心组成部分之一——虚拟内存管理。通过剖析其关键组件和运作机制,揭示虚拟内存如何提供高效的内存抽象,支持庞大的地址空间,以及实现内存保护和共享。文章将重点讨论分页机制、虚拟内存区域(VMAs)的管理、页面置换算法,并简要分析这些技术是如何支撑起现代操作系统复杂而多变的内存需求的。
|
7天前
|
Linux 编译器 C语言
编译Linux内核:基础、重要性和交叉编译方法
Linux内核作为操作系统的心脏,负责管理计算机的硬件资源,同时也是运行所有其他程序的基础。理解如何编译Linux内核对于系统管理员、开发者乃至高级用户来说都是一项极其宝贵的技能。本文将介绍编译Linux内核的基本知识、编译的重要性、具体步骤以及交叉编译的概念。
17 0
|
12天前
|
运维 NoSQL Ubuntu
深入理解Linux中的"crash"命令:内核崩溃的调试利器
`crash`是Linux内核崩溃调试工具,用于分析内核崩溃转储文件,提供GDB-like的交互式CLI。通过加载`vmcore`文件和内核映像,管理员可以查看系统状态、调用栈、内存布局等。安装`crash`可使用包管理器,如`apt-get`或`yum/dnf`。尽管有学习曲线且依赖转储文件,但`crash`在系统故障排查中极其重要。
|
19天前
|
Linux
探索Linux操作系统的内核模块
本文将深入探讨Linux操作系统的核心组成部分——内核模块,揭示其背后的工作机制和实现方式。我们将从内核模块的定义开始,逐步解析其加载、卸载以及与操作系统其他部分的交互过程,最后探讨内核模块在系统性能优化中的关键作用。
|
20天前
|
缓存 算法 安全
探索Linux内核的虚拟内存管理
【5月更文挑战第29天】 在现代操作系统中,虚拟内存是支持多任务处理和内存保护的关键组件。本文深入分析了Linux操作系统中的虚拟内存管理机制,包括其地址空间布局、分页系统以及内存分配策略。我们将探讨虚拟内存如何允许多个进程独立地访问它们自己的地址空间,同时由操作系统管理物理内存资源。此外,文章还将涉及虚拟内存所带来的性能影响及其优化方法。
|
21天前
|
算法 Linux 调度
深度解析:Linux内核的进程调度机制
【5月更文挑战第29天】 在现代操作系统中,尤其是类Unix系统如Linux中,进程调度机制是保证多任务高效运行的核心。本文将深入探讨Linux操作系统内核的进程调度器——负责管理CPU资源分配的关键组件。我们会详细分析其调度策略、调度器的演进及其在多核处理器环境下的表现。通过剖析进程调度器的工作原理和设计哲学,旨在为读者提供一个清晰的视角来理解这一复杂的系统功能。
24 0
|
27天前
|
存储 算法 Linux
【Linux】程序地址空间 -- 详解 & Linux 2.6 内核进程调度队列 -- 了解
【Linux】程序地址空间 -- 详解 & Linux 2.6 内核进程调度队列 -- 了解