本文转载自:http://bbs.chinaunix.net/thread-2011776-1-1.html

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

2.通知链表数据结构
    通知链表的节点类型为notifier_block,其定义如下:

 struct notifier_block
{
int (*notifier_call)(struct notifier_block *self, unsigned long, void *);
struct notifier_block *next;
int priority;
};

其中最重要的就是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指向的链表上的所有节点上注册的函数。简单地说,如下所示:

     struct notifier_block *nb = *n;

     while (nb)
{
ret = nb->notifier_call(nb, val, v);
if (ret & NOTIFY_STOP_MASK)
{
return ret;
}
nb = nb->next;
}

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

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

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

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

 #include <asm/uaccess.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/notifier.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/module.h>
MODULE_LICENSE("GPL"); /*
* 定义自己的通知链头结点以及注册和卸载通知链的外包函数
*/ /*
* RAW_NOTIFIER_HEAD是定义一个通知链的头部结点,
* 通过这个头部结点可以找到这个链中的其它所有的notifier_block
*/ static RAW_NOTIFIER_HEAD(test_chain); /*
* 自定义的注册函数,将notifier_block节点加到刚刚定义的test_chain这个链表中来
* raw_notifier_chain_register会调用notifier_chain_register
*/ int register_test_notifier(struct notifier_block *nb)
{
return raw_notifier_chain_register(&test_chain, nb);
}
EXPORT_SYMBOL(register_test_notifier); int unregister_test_notifier(struct notifier_block *nb)
{
return raw_notifier_chain_unregister(&test_chain, nb);
}
EXPORT_SYMBOL(unregister_test_notifier); /*
* 自定义的通知链表的函数,即通知test_chain指向的链表中的所有节点执行相应的函数
*/ int test_notifier_call_chain(unsigned long val, void *v)
{
return raw_notifier_call_chain(&test_chain, val, v);
}
EXPORT_SYMBOL(test_notifier_call_chain); /*
* init and exit
*/ static int __init init_notifier(void)
{
printk("init_notifier\n");
return ;
} static void __exit exit_notifier(void)
{
printk("exit_notifier\n");
}
module_init(init_notifier);
module_exit(exit_notifier);

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

 #include <asm/uaccess.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/notifier.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/module.h>
MODULE_LICENSE("GPL"); /*
* 注册通知链
*/ extern int register_test_notifier(struct notifier_block*); extern int unregister_test_notifier(struct notifier_block*); static int test_event1(struct notifier_block *this, unsigned long event, void *ptr)
{
printk("In Event 1: Event Number is %d\n", event);
return ;
} static int test_event2(struct notifier_block *this, unsigned long event, void *ptr)
{
printk("In Event 2: Event Number is %d\n", event);
return ;
} static int test_event3(struct notifier_block *this, unsigned long event, void *ptr)
{
printk("In Event 3: Event Number is %d\n", event);
return ;
} /*
* 事件1,该节点执行的函数为test_event1
*/ static struct notifier_block test_notifier1 =
{
.notifier_call = test_event1,
}; /*
* 事件2,该节点执行的函数为test_event1
*/ static struct notifier_block test_notifier2 =
{
.notifier_call = test_event2,
}; /*
* 事件3,该节点执行的函数为test_event1
*/ static struct notifier_block test_notifier3 =
{
.notifier_call = test_event3,
}; /*
* 对这些事件进行注册
*/ static int __init reg_notifier(void)
{
int err;
printk("Begin to register:\n"); err = register_test_notifier(&test_notifier1);
if (err)
{
printk("register test_notifier1 error\n");
return -;
}
printk("register test_notifier1 completed\n"); err = register_test_notifier(&test_notifier2);
if (err)
{
printk("register test_notifier2 error\n");
return -;
}
printk("register test_notifier2 completed\n"); err = register_test_notifier(&test_notifier3);
if (err)
{
printk("register test_notifier3 error\n");
return -;
}
printk("register test_notifier3 completed\n");
return err;
} /*
* 卸载刚刚注册了的通知链
*/ static void __exit unreg_notifier(void)
{
printk("Begin to unregister\n");
unregister_test_notifier(&test_notifier1);
unregister_test_notifier(&test_notifier2);
unregister_test_notifier(&test_notifier3);
printk("Unregister finished\n");
}
module_init(reg_notifier);
module_exit(unreg_notifier);

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

 #include <asm/uaccess.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/notifier.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/module.h>
MODULE_LICENSE("GPL"); extern int test_notifier_call_chain(unsigned long val, void *v); /*
* 向通知链发送消息以触发注册了的函数
*/ static int __init call_notifier(void)
{
int err;
printk("Begin to notify:\n"); /*
* 调用自定义的函数,向test_chain链发送消息
*/ printk("==============================\n");
err = test_notifier_call_chain(, NULL);
printk("==============================\n");
if (err)
printk("notifier_call_chain error\n");
return err;
} static void __exit uncall_notifier(void)
{
printk("End notify\n");
}
module_init(call_notifier);
module_exit(uncall_notifier);

Makefile文件

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

 KERNELDIR:=/lib/modules/$(shell uname -r)/build

 default:
make -C $(KERNELDIR) M=$(shell pwd) modules

运行:

 make

 insmod buildchain.ko
insmod regchain.ko
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 : Event Number is
In Event : Event Number is
In Event : Event Number is
==============================

callback机制之内核通知链表【转】的更多相关文章

  1. Linux内核调试方法总结之内核通知链

    Linux内核通知链notifier 1.内核通知链表简介(引用网络资料)    大多数内核子系统都是相互独立的,因此某个子系统可能对其它子系统产生的事件感兴趣.为了满足这个需求,也即是让某个子系统在 ...

  2. Linux 内核通知链机制的原理及实现

    一.概念: 大多数内核子系统都是相互独立的,因此某个子系统可能对其它子系统产生的事件感兴趣.为了满足这个需求,也即是让某个子系统在发生某个事件时通知其它的子 系统,Linux内核提供了通知链的机制.通 ...

  3. Linux内核通知链机制的原理及实现【转】

    转自:http://www.cnblogs.com/armlinux/archive/2011/11/11/2396781.html 一.概念: 大多数内核子系统都是相互独立的,因此某个子系统可能对其 ...

  4. 深入理解Linux网络技术内幕——Notification内核通知表链

    为什么要有内核通知表链:     Linux由多个相互依赖的子系统组成.其中一些子系统可能需要对其他子系统的一些事件感兴趣.这样子系统之间需要一些通信机制来实现这一功能.     在接触Notific ...

  5. Linux内核通知链模块

    通知链描写叙述 大多数内核子系统都是相互独立的,因此某个子系统可能对其他子系统产生的事件感兴趣. 为了满足这个需求,也即是让某个子系统在发生某个事件时通知其他的子系统.Linux内核提供了通知链的机制 ...

  6. Linux内核通知链分析【转】

    转自:http://www.cnblogs.com/jason-lu/articles/2807758.html Linux内核通知链分析 1. 引言 Linux是单内核架构(monolithic k ...

  7. notifier chain — 内核通知链【转】

    转自:http://blog.csdn.net/g_salamander/article/details/8081724 大多数内核子系统都是相互独立的,因此某个子系统可能对其它子系统产生的事件感兴趣 ...

  8. Linux内核【链表】整理笔记(1)

    我们都知道Linux内核里的双向链表和学校里教给我们的那种数据结构还是些不一样.Linux采用了一种更通用的设计,将链表以及其相关操作函数从数据本身进行剥离,这样我们在使用链表的时候就不用自己去实现诸 ...

  9. linux 内核的链表操作(好文不得不转)

    以下全部来自于http://www.ibm.com/developerworks/cn/linux/kernel/l-chain/index.html 无任何个人意见. 本文详细分析了 2.6.x 内 ...

随机推荐

  1. MySQL---SQL记录

    MySQL在已有字段后追加相应的值值 需求:在MySQL中的topic表中,需要将每一个cover字段后添加上: -400.webp update topic set cover = CONCAT(c ...

  2. freemarker中include与import的区别

    在inc1.ftl与inc2.ftl中的内容分别是: <#assign username="刘德华">与<#assign username="张学友&q ...

  3. MetaQ简单实用demo

    Metaq的生产者代码 import java.io.BufferedReader; import java.io.InputStreamReader; import com.taobao.metam ...

  4. C++ 关于类与对象在虚函数表上唯一性问题 浅析

    [摘要] 非常多教材上都有介绍到虚指针.虚函数与虚函数表.有的说类对象共享一个虚函数表,有的说,一个类对象拥有一个虚函数表.还有的说,不管用户声明了多少个类对象,可是,这个VTABLE虚函数表仅仅有一 ...

  5. 即将到来的Android N,将具备这些新特性

    原文转自:http://www.leiphone.com/news/201602/pSRQAuAjMFJITqHe.html         原创 訾竣喆 即将到来的Android N,将具备这些新特 ...

  6. Java常见问题分析(内存溢出、内存泄露、线程阻塞等)

    Java垃圾回收机制(GC) 1.1 GC机制作用 1.2 堆内存3代分布(年轻代.老年代.持久代) 1.3 GC分类 1.4 GC过程 Java应用内存问题分析 2.1 Java内存划分 2.2 J ...

  7. 使用Unitils测试DAO层

    Spring 的测试框架为我们提供一个强大的测试环境,解决日常单元测试中遇到的大部分测试难题:如运行多个测试用例和测试方法时,Spring上下文只需创建一次:数据库现场不受破坏:方便手工指定Sprin ...

  8. [Python] SQLBuilder 演示样例代码

    用Python写一个SQLBuilder.Java版能够从 http://www.java2s.com/Code/Java/Database-SQL-JDBC/SQLBuilder.htm 看到. 附 ...

  9. vue class绑定方式

    1.对象语法 <div class="static" v-bind:class="{ active: isActive, 'text-danger': hasErr ...

  10. Flash威胁的不不过浏览器

    Adobe为提升Flash的安全性.在最新版本号的Flash(18.0.0.209)增加了很多攻击缓解技术. 新的攻击缓解技术为: l  <*>长度验证–添加长度cookie到Vector ...