备案控制台
开发者社区 开发与运维 文章 正文

内核通知链 学习笔记 【转】

2017-11-16 1549
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
最近在看《深入理解Linux 网络内幕》一书，学习了一下书中讲到的内核通知链方面的知识，写了一个读书笔记和一点代码来加深理解，希望能够对大家有一点帮助。内核通知链在网络方面得到了广泛的使用。


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

2.通知链表数据结构
    通知链表的节点类型为notifier_block，其定义如下：
  1. struct notifier_block
  2. {
  3.     int (*notifier_call)(struct notifier_block *self, unsigned long, void *);
  4.     struct notifier_block *next;
  5.     int priority;
  6. };
复制代码

    其中最重要的就是notifier_call这个函数指针，表示了这个节点所对应的要运行的那个函数。next指向下一个节点，即当前事件发生时还要继续执行的那些节点。

3.注册通知链
    在通知链注册时，需要有一个链表头，它指向这个通知链表的第一个元素。这样，之后的事件对该链表通知时就会根据这个链表头而找到这个链表中所有的元素。
    注册的函数是：
int notifier_chain_register(struct notifier_block **nl, struct notifier_block *n)
    也即是将新的节点n加入到nl所指向的链表中去。
    卸载的函数是：
int notifier_chain_unregister(strut notifier_block **nl, struct notifier_block *n)
    也即是将节点n从nl所指向的链表中删除。

4.通知链表
    当有事件发生时，就使用notifier_call_chain向某个通知链表发送消息。
int notifier_call_chain(struct notifier_block **nl, unsigned long val, void *v)
    这个函数是按顺序运行nl指向的链表上的所有节点上注册的函数。简单地说，如下所示：
  1.     struct notifier_block *nb = *n;
  3.     while (nb)
  4.     {
  5.         ret = nb->notifier_call(nb, val, v);
  6.         if (ret & NOTIFY_STOP_MASK)
  7.         {
  8.             return ret;
  9.         }
  10.         nb = nb->next;
  11.     }
复制代码


5.示例
    在这里，写了一个简单的通知链表的代码。

    实际上，整个通知链的编写也就两个过程：
    首先是定义自己的通知链的头节点，并将要执行的函数注册到自己的通知链中。
    其次则是由另外的子系统来通知这个链，让其上面注册的函数运行。

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

代码1 buildchain.c
    它的作用是自定义一个通知链表test_chain，然后再自定义两个函数分别向这个通知链中加入或删除节点，最后再定义一个函数通知这个test_chain链。
  1. #include <asm/uaccess.h>
  2. #include <linux/types.h>
  3. #include <linux/kernel.h>
  4. #include <linux/sched.h>
  5. #include <linux/notifier.h>
  6. #include <linux/init.h>
  7. #include <linux/types.h>
  8. #include <linux/module.h>
  9. MODULE_LICENSE("GPL");
  11. /*
  12. * 定义自己的通知链头结点以及注册和卸载通知链的外包函数
  13. */
  15. /*
  16. * RAW_NOTIFIER_HEAD是定义一个通知链的头部结点，
  17. * 通过这个头部结点可以找到这个链中的其它所有的notifier_block
  18. */
  20. static RAW_NOTIFIER_HEAD(test_chain);
  22. /*
  23. * 自定义的注册函数，将notifier_block节点加到刚刚定义的test_chain这个链表中来
  24. * raw_notifier_chain_register会调用notifier_chain_register
  25. */
  27. int register_test_notifier(struct notifier_block *nb)
  28. {
  29.         return raw_notifier_chain_register(&test_chain, nb);
  30. }
  31. EXPORT_SYMBOL(register_test_notifier);
  33. int unregister_test_notifier(struct notifier_block *nb)
  34. {
  35.         return raw_notifier_chain_unregister(&test_chain, nb);
  36. }
  37. EXPORT_SYMBOL(unregister_test_notifier);
  39. /*
  40. * 自定义的通知链表的函数，即通知test_chain指向的链表中的所有节点执行相应的函数
  41. */
  43. int test_notifier_call_chain(unsigned long val, void *v)
  44. {
  45.         return raw_notifier_call_chain(&test_chain, val, v);
  46. }
  47. EXPORT_SYMBOL(test_notifier_call_chain);
  49. /*
  50. * init and exit
  51. */
  53. static int __init init_notifier(void)
  54. {
  55.         printk("init_notifier\n");
  56.         return 0;
  57. }
  59. static void __exit exit_notifier(void)
  60. {
  61.         printk("exit_notifier\n");
  62. }
  63. module_init(init_notifier);
  64. module_exit(exit_notifier);
复制代码


代码2 regchain.c
    该代码的作用是将test_notifier1 test_notifier2 test_notifier3这三个节点加到之前定义的test_chain这个通知链表上，同时每个节点都注册了一个函数。
  1. #include <asm/uaccess.h>
  2. #include <linux/types.h>
  3. #include <linux/kernel.h>
  4. #include <linux/sched.h>
  5. #include <linux/notifier.h>
  6. #include <linux/init.h>
  7. #include <linux/types.h>
  8. #include <linux/module.h>
  9. MODULE_LICENSE("GPL");
  11. /*
  12. * 注册通知链
  13. */
  15. extern int register_test_notifier(struct notifier_block*);
  17. extern int unregister_test_notifier(struct notifier_block*);
  19. static int test_event1(struct notifier_block *this, unsigned long event, void *ptr)
  20. {
  21.         printk("In Event 1: Event Number is %d\n", event);
  22.         return 0;
  23. }
  25. static int test_event2(struct notifier_block *this, unsigned long event, void *ptr)
  26. {
  27.         printk("In Event 2: Event Number is %d\n", event);
  28.         return 0;
  29. }
  31. static int test_event3(struct notifier_block *this, unsigned long event, void *ptr)
  32. {
  33.         printk("In Event 3: Event Number is %d\n", event);
  34.         return 0;
  35. }
  37. /*
  38. * 事件1，该节点执行的函数为test_event1
  39. */
  41. static struct notifier_block test_notifier1 =
  42. {
  43.         .notifier_call = test_event1,
  44. };
  46. /*
  47. * 事件2，该节点执行的函数为test_event1
  48. */
  50. static struct notifier_block test_notifier2 =
  51. {
  52.         .notifier_call = test_event2,
  53. };
  55. /*
  56. * 事件3，该节点执行的函数为test_event1
  57. */
  59. static struct notifier_block test_notifier3 =
  60. {
  61.         .notifier_call = test_event3,
  62. };
  64. /*
  65. * 对这些事件进行注册
  66. */
  68. static int __init reg_notifier(void)
  69. {
  70.         int err;
  71.         printk("Begin to register:\n");
  72.        
  73.         err = register_test_notifier(&test_notifier1);
  74.         if (err)
  75.         {
  76.                 printk("register test_notifier1 error\n");
  77.                 return -1;
  78.         }
  79.         printk("register test_notifier1 completed\n");
  81.         err = register_test_notifier(&test_notifier2);
  82.         if (err)
  83.         {
  84.                 printk("register test_notifier2 error\n");
  85.                 return -1;
  86.         }
  87.         printk("register test_notifier2 completed\n");
  89.         err = register_test_notifier(&test_notifier3);
  90.         if (err)
  91.         {
  92.                 printk("register test_notifier3 error\n");
  93.                 return -1;
  94.         }
  95.         printk("register test_notifier3 completed\n");
  96.         return err;
  97. }
  99. /*
  100. * 卸载刚刚注册了的通知链
  101. */
  103. static void __exit unreg_notifier(void)
  104. {
  105.         printk("Begin to unregister\n");
  106.         unregister_test_notifier(&test_notifier1);
  107.         unregister_test_notifier(&test_notifier2);
  108.         unregister_test_notifier(&test_notifier3);
  109.         printk("Unregister finished\n");
  110. }
  111. module_init(reg_notifier);
  112. module_exit(unreg_notifier);
复制代码


代码3 notify.c
    该代码的作用就是向test_chain通知链中发送消息，让链中的函数运行。
  1. #include <asm/uaccess.h>
  2. #include <linux/types.h>
  3. #include <linux/kernel.h>
  4. #include <linux/sched.h>
  5. #include <linux/notifier.h>
  6. #include <linux/init.h>
  7. #include <linux/types.h>
  8. #include <linux/module.h>
  9. MODULE_LICENSE("GPL");
  11. extern int test_notifier_call_chain(unsigned long val, void *v);
  13. /*
  14. * 向通知链发送消息以触发注册了的函数
  15. */
  17. static int __init call_notifier(void)
  18. {
  19.         int err;
  20.         printk("Begin to notify:\n");
  22. /*
  23. * 调用自定义的函数，向test_chain链发送消息
  24. */
  26.         printk("==============================\n");
  27.         err = test_notifier_call_chain(1, NULL);
  28.         printk("==============================\n");
  29.         if (err)
  30.                 printk("notifier_call_chain error\n");
  31.         return err;
  32. }
  35. static void __exit uncall_notifier(void)
  36. {
  37.         printk("End notify\n");
  38. }
  39. module_init(call_notifier);
  40. module_exit(uncall_notifier);
复制代码


Makefile文件
  1. obj-m:=buildchain.o regchain.o notify.o
  3. KERNELDIR:=/lib/modules/$(shell uname -r)/build
  5. default:
  6.         make -C (KERNELDIR)M=(KERNELDIR)M=(shell pwd) modules
复制代码


运行：
  1. make
  3. insmod buildchain.ko
  4. insmod regchain.ko
  5. insmod notify.ko
复制代码


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

下面是我在自己的机器上面运行得到的结果:
QUOTE:
init_notifier
Begin to register:
register test_notifier1 completed
register test_notifier2 completed
register test_notifier3 completed
Begin to notify:
==============================
In Event 1: Event Number is 1
In Event 2: Event Number is 1
In Event 3: Event Number is 1
==============================















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


文章标签：
Linux
桃子红了呐
目录
相关文章
沐多
|
3天前
|
Linux 调度 数据库
xenomai内核解析--xenomai与普通linux进程之间通讯XDDP(二)--实时与非实时关联(bind流程)
本文是关于Xenomai实时端socket的bind操作解析。
沐多
13 0
xenomai内核解析--xenomai与普通linux进程之间通讯XDDP(二)--实时与非实时关联(bind流程)
lyshark
|
5月前
|
监控 安全 API
7.2 Windows驱动开发：内核注册并监控对象回调
在笔者上一篇文章`《内核枚举进程与线程ObCall回调》`简单介绍了如何枚举系统中已经存在的`进程与线程`回调，本章`LyShark`将通过对象回调实现对进程线程的`句柄`监控，在内核中提供了`ObRegisterCallbacks`回调，使用这个内核`回调`函数，可注册一个`对象`回调，不过目前该函数`只能`监控进程与线程句柄操作，通过监控进程或线程句柄，可实现保护指定进程线程不被终止的目的。
lyshark
31 0
7.2 Windows驱动开发：内核注册并监控对象回调
lyshark
|
5月前
|
监控 安全 API
7.1 Windows驱动开发：内核监控进程与线程回调
在前面的文章中`LyShark`一直在重复的实现对系统底层模块的枚举，今天我们将展开一个新的话题，内核监控，我们以`监控进程线程`创建为例，在`Win10`系统中监控进程与线程可以使用微软提供给我们的两个新函数来实现，此类函数的原理是创建一个回调事件，当有进程或线程被创建或者注销时，系统会通过回调机制将该进程相关信息优先返回给我们自己的函数待处理结束后再转向系统层。
lyshark
62 0
7.1 Windows驱动开发：内核监控进程与线程回调
lyshark
|
11月前
|
开发者
驱动开发：基于事件同步的反向通信
在之前的文章中`LyShark`一直都在教大家如何让驱动程序与应用层进行`正向通信`，而在某些时候我们不仅仅只需要正向通信，也需要反向通信，例如杀毒软件如果驱动程序拦截到恶意操作则必须将这个请求动态的转发到应用层以此来通知用户，而这种通信方式的实现有多种，通常可以使用创建Socket套接字的方式实现，亦或者使用本章所介绍的通过`事件同步`的方法实现反向通信。
lyshark
170 0
lyshark
|
11月前
|
Windows
驱动开发：内核扫描SSDT挂钩状态
在笔者上一篇文章`《驱动开发：内核实现SSDT挂钩与摘钩》`中介绍了如何对`SSDT`函数进行`Hook`挂钩与摘钩的，本章将继续实现一个新功能，如何`检测SSDT`函数是否挂钩，要实现检测`挂钩状态`有两种方式，第一种方式则是类似于`《驱动开发：摘除InlineHook内核钩子》`文章中所演示的通过读取函数的前16个字节与`原始字节`做对比来判断挂钩状态，另一种方式则是通过对比函数的`当前地址`与`起源地址`进行判断，为了提高检测准确性本章将采用两种方式混合检测。
lyshark
179 0
ST小智
|
API
HarmonyOS系统内核中使用事件标志的方法
大家好，今天主要和大家聊一聊，如何利用HarmonyOS系统中事件标志。
ST小智
219 0
HarmonyOS系统内核中使用事件标志的方法
lyshark
|
监控
驱动开发：内核注册并监控对象回调
在笔者上一篇文章`《驱动开发：内核枚举进程与线程ObCall回调》`简单介绍了如何枚举系统中已经存在的`进程与线程`回调，本章`LyShark`将通过对象回调实现对进程线程的`句柄`监控，在内核中提供了`ObRegisterCallbacks`回调，使用这个内核`回调`函数，可注册一个`对象`回调，不过目前该函数`只能`监控进程与线程句柄操作，通过监控进程或线程句柄，可实现保护指定进程线程不被终止的目的。
lyshark
405 0
驱动开发：内核注册并监控对象回调
lyshark
|
监控
驱动开发：内核监控进程与线程回调
在前面的文章中`LyShark`一直在重复的实现对系统底层模块的枚举，今天我们将展开一个新的话题，内核监控，我们以`监控进程线程`创建为例，在`Win10`系统中监控进程与线程可以使用微软提供给我们的两个新函数来实现，此类函数的原理是创建一个回调事件，当有进程或线程被创建或者注销时，系统会通过回调机制将该进程相关信息优先返回给我们自己的函数待处理结束后再转向系统层。
lyshark
333 0
驱动开发：内核监控进程与线程回调
矜辰所致
|
消息中间件 测试技术 API
FreeRTOS记录（七、FreeRTOS信号量、事件标志组、邮箱和消息队列、任务通知的关系）
我们在前面单独介绍过FreeRTOS的任务通知和消息队列， 但是在FreeRTOS中任务间的通讯还有信号量，邮箱，事件组标志等可以使用 这篇文章就这些成员与消息队列和任务通知的关系进行说明分析
矜辰所致
809 0
FreeRTOS记录（七、FreeRTOS信号量、事件标志组、邮箱和消息队列、任务通知的关系）
binarydady
|
Linux 网络协议
Linux通知链机制及实例
binarydady
3346 0