notifier_call -----总结

最新推荐文章于 2024-12-12 10:24:12 发布
原创最新推荐文章于 2024-12-12 10:24:12 发布 · 2.7k 阅读
12 ·
CC 4.0 BY-SA版权
Linux demo (base) 专栏收录该内容
77 篇文章
订阅专栏
本文详细探讨了Notifier Call的工作原理及其在系统中的应用，包括其在事件通知、状态改变等方面的关键角色。通过实例分析，阐述了如何利用Notifier Call实现高效的消息传递和系统间的协调。


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;
};

===============================================================================================
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.示例
    在这里，写了一个简单的通知链表的代码。

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

    我这里将第一个过程分成了两步来写，
	第一步是定义了头节点和一些自定义的注册函数（针对该头节点的），
	第二步则是使用自定义的注册函数注册了一些通知链节点。分别在代码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 0;
}

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 0; 
}

static int test_event2(struct notifier_block *this, unsigned long event, void *ptr)
{
        printk("In Event 2: Event Number is %d\n", event);
        return 0; 
}

static int test_event3(struct notifier_block *this, unsigned long event, void *ptr)
{
        printk("In Event 3: Event Number is %d\n", event);
        return 0; 
}

/*
* 事件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 -1; 
        }
        printk("register test_notifier1 completed\n");

        err = register_test_notifier(&test_notifier2);
        if (err)
        {
                printk("register test_notifier2 error\n");
                return -1; 
        }
        printk("register test_notifier2 completed\n");

        err = register_test_notifier(&test_notifier3);
        if (err)
        {
                printk("register test_notifier3 error\n");
                return -1; 
        }
        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(1, 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 1: Event Number is 1
In Event 2: Event Number is 1
In Event 3: Event Number is 1
==============================


===============================================================================================


/msm-4.4/kernel/notifier.c

	/*
	 *	Notifier list for kernel code which wants to be called
	 *	at shutdown. This is used to stop any idling DMA operations
	 *	and the like.
	 */
	===============================================================================================
	BLOCKING_NOTIFIER_HEAD(reboot_notifier_list);
	===============================================================================================

	/**
	 * notifier_call_chain - Informs the registered notifiers about an event.
	 *	@nl:		Pointer to head of the blocking notifier chain
	 *	@val:		Value passed unmodified to notifier function
	 *	@v:		Pointer passed unmodified to notifier function
	 *	@nr_to_call:	Number of notifier functions to be called. Don't care
	 *			value of this parameter is -1.
	 *	@nr_calls:	Records the number of notifications sent. Don't care
	 *			value of this field is NULL.
	 *	@returns:	notifier_call_chain returns the value returned by the
	 *			last notifier function called.
	 */
===============================================================================================
	static int notifier_call_chain(struct notifier_block **nl,
					   unsigned long val, void *v,
					   int nr_to_call, int *nr_calls)
===============================================================================================


	/*
	 *	Atomic notifier chain routines.  Registration and unregistration
	 *	use a spinlock, and call_chain is synchronized by RCU (no locks).
	 */

	/**
	 *	atomic_notifier_chain_register - Add notifier to an atomic notifier chain
	 *	@nh: Pointer to head of the atomic notifier chain
	 *	@n: New entry in notifier chain
	 *
	 *	Adds a notifier to an atomic notifier chain.
	 *
	 *	Currently always returns zero.
	 */
===============================================================================================
	int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
			struct notifier_block *n)
===============================================================================================


	/**
	 *	atomic_notifier_chain_unregister - Remove notifier from an atomic notifier chain
	 *	@nh: Pointer to head of the atomic notifier chain
	 *	@n: Entry to remove from notifier chain
	 *
	 *	Removes a notifier from an atomic notifier chain.
	 *
	 *	Returns zero on success or %-ENOENT on failure.
	 */
===============================================================================================
	int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
			struct notifier_block *n)
===============================================================================================



	/*
	 *	Blocking notifier chain routines.  All access to the chain is
	 *	synchronized by an rwsem.
	 */

	/**
	 *	blocking_notifier_chain_register - Add notifier to a blocking notifier chain
	 *	@nh: Pointer to head of the blocking notifier chain
	 *	@n: New entry in notifier chain
	 *
	 *	Adds a notifier to a blocking notifier chain.
	 *	Must be called in process context.
	 *
	 *	Currently always returns zero.
	 */
===============================================================================================
	int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
			struct notifier_block *n)
===============================================================================================


	/**
	 *	blocking_notifier_chain_unregister - Remove notifier from a blocking notifier chain
	 *	@nh: Pointer to head of the blocking notifier chain
	 *	@n: Entry to remove from notifier chain
	 *
	 *	Removes a notifier from a blocking notifier chain.
	 *	Must be called from process context.
	 *
	 *	Returns zero on success or %-ENOENT on failure.
	 */
===============================================================================================
	int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
			struct notifier_block *n)
===============================================================================================



	/*
	 *	Raw notifier chain routines.  There is no protection;
	 *	the caller must provide it.  Use at your own risk!
	 */

	/**
	 *	raw_notifier_chain_register - Add notifier to a raw notifier chain
	 *	@nh: Pointer to head of the raw notifier chain
	 *	@n: New entry in notifier chain
	 *
	 *	Adds a notifier to a raw notifier chain.
	 *	All locking must be provided by the caller.
	 *
	 *	Currently always returns zero.
	 */
===============================================================================================
	int raw_notifier_chain_register(struct raw_notifier_head *nh,
			struct notifier_block *n)
===============================================================================================

	/**
	 *	raw_notifier_chain_unregister - Remove notifier from a raw notifier chain
	 *	@nh: Pointer to head of the raw notifier chain
	 *	@n: Entry to remove from notifier chain
	 *
	 *	Removes a notifier from a raw notifier chain.
	 *	All locking must be provided by the caller.
	 *
	 *	Returns zero on success or %-ENOENT on failure.
	 */
===============================================================================================
	int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
			struct notifier_block *n)
===============================================================================================




	/*
	 *	SRCU notifier chain routines.    Registration and unregistration
	 *	use a mutex, and call_chain is synchronized by SRCU (no locks).
	 */

	/**
	 *	srcu_notifier_chain_register - Add notifier to an SRCU notifier chain
	 *	@nh: Pointer to head of the SRCU notifier chain
	 *	@n: New entry in notifier chain
	 *
	 *	Adds a notifier to an SRCU notifier chain.
	 *	Must be called in process context.
	 *
	 *	Currently always returns zero.
	 */
===============================================================================================
	int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
			struct notifier_block *n)
===============================================================================================


	/**
	 *	srcu_notifier_chain_unregister - Remove notifier from an SRCU notifier chain
	 *	@nh: Pointer to head of the SRCU notifier chain
	 *	@n: Entry to remove from notifier chain
	 *
	 *	Removes a notifier from an SRCU notifier chain.
	 *	Must be called from process context.
	 *
	 *	Returns zero on success or %-ENOENT on failure.
	 */
===============================================================================================
	int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
			struct notifier_block *n)
===============================================================================================