linux下notify機制（僅用於內核模塊之間的通訊）

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=$(shell pwd) modules

複製代碼

運行：

1. make
3. insmod buildchain.ko
4. insmod regchain.ko
5. insmod notify.ko

複製代碼

這樣就能夠看到通知鏈運行的效果了

下面是我在本身的機器上面運行獲得的結果:

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 ==============================