Linux内核通知链分析【转】

转自：http://www.cnblogs.com/jason-lu/articles/2807758.html

Linux内核通知链分析

1. 引言

Linux是单内核架构(monolithic kernel),大多数内核子系统和模块是相互独立的,它们被动态地加载或卸载,以使内核变得小巧和可扩展.然而,子系统或模块之间需要通信,或者说某个特定模块扑捉到的事件可能其它模块对此感兴趣,这就需要一种机制来满足子系统或模块之间交互的需求.

Linux使用通知链表来实现这一需求,它是一个简单的函数链表,当某件事件发生时,链表上的函数就会执行.这是一种发布-订阅(publish-subscribe)模式,当客户(订阅者)需要某个特定事件的通知时,会向主机(发布者)注册自己;接下来,只要感兴趣的事件一发生,主机便会通知客户.

讨论内核通知链之前,有必要注意以下几点:

• 通知链表只能够在内核的子系统之间使用,而不能够在内核与用户空间之间进行事件的通知.
• 通知链表是一个函数链表,链表上的每一个节点都注册了一个函数.当某个事情发生时,链表上所有节点对应的函数就会被执行.所以对于通知链表来说有一个通知方(主机)与一个接收方(订阅者).
• 在通知这个事件时所运行的函数由被通知方(订阅者通过回调函数)决定,实际上也即是被通知方注册(订阅者实现)了某个函数,在发生某个事件时这些函数就得到执行.

2. 数据结构

清单1. 原子通知链(Atomic notifier chains):

通知链元素的回调函数(当事件发生时要执行的函数)只能在中断上下文中运行,不允许阻塞

1 struct atomic_notifier_head {
2     spinlock_t lock;        /*锁*/
3     struct notifier_block *head;
4 };

清单2. 可阻塞通知链(Blocking notifier chains):

阻塞通知头结构,增加了一个读写信号灯,通知链元素的回调函数在进程上下文中运行,允许阻塞

1 struct blocking_notifier_head {
2     struct rw_semaphore rwsem;    /*读写控制信号量*/
3     struct notifier_block *head;
4 };

清单3. 原始通知链(Raw notifier chains):

原始通知头结构,就是一个通知块指针,对通知链元素的回调函数没有任何限制,所有锁和保护机制都由调用者维护

1 struct raw_notifier_head {
2     struct notifier_block *head;
3 };

清单4. SRCU 通知链(SRCU notifier chains):

可阻塞通知链的一种变体,(SRCU)Sleepable Read Copy Update 的链表通知,与block链表通知类似,不同在处理锁与保护上,SRCU在调用通知时的系统开销小,而从通知链表中去除通知调用的系统开销大,因此适合用在调用通知频繁,而移除调用通知少的情况中

1 struct srcu_notifier_head {
2     struct mutex mutex;
3     struct srcu_struct srcu;
4     struct notifier_block *head;
5 };

参看：http://geyingzhen.blog.163.com/blog/static/6558665520091165531675/

清单5. 基本的通知块结构(notifier_block):

通知链的核心结构

1 struct notifier_block {
2     int (*notifier_call)(struct notifier_block *, unsigned long, void *);        /*回调函数*/
3     struct notifier_block *next;        /*指向链表的下一个元素节点，这是一个单向链表*/
4     int priority;        /*该块的优先级, 在链表中各个块是按此优先级值进
5                     *行排序的, 值大的在链表前, 表明
6                     *相应回调函数执行的顺序*/
7 };

其中,函数指针notifier_call注册了当某个事件发生时需要调用的函数;next指向下一个链表节点;priority设定链表节点的优先级;数值越大优先级越高,默认为0.因此,所有的通知链表节点组成了一个单链表,并以优先级(priority)排列.

3. 运行机制

通知链的运作机制包括两个角色:

• 被通知者(订阅者):对某一事件感兴趣一方,定义了当事件发生时,相应的处理函数,即回调函数.但需要事先将其注册到通知链中(被通知者注册的动作就是在通知链中增加一项).
• 通知者(主机):事件的通知者.当检测到某事件,或者本身产生事件时,通知所有对该事件感兴趣的一方事件发生.他定义了一个通知链,其中保存了每一个被通知者对事件的处理函数(回调函数).通知这个过程实际上就是遍历通知链中的每一项,然后调用相应的事件处理函数.

通知机制实现包括以下三个步骤:

1. 通知者(主机)定义通知链;
2. 被通知者(订阅者)向通知链中注册回调函数;
3. 当事件发生时,通知者(主机)发出通知(执行通知链中所有元素的回调函数).

清单6. notifier_chain_register函数:

被通知者(订阅者)调用 notifier_chain_register函数注册回调函数,该函数按照优先级将回调函数加入到通知链中:

 1 /*
 2  *    Notifier chain core routines.  The exported routines below
 3  *    are layered on top of these, with appropriate locking added.
 4  */
 5 /*nl是链表头块的地址, n是要添加到该链表的通知块*/
 6 static int notifier_chain_register(struct notifier_block **nl,
 7         struct notifier_block *n)
 8 {
 9     while ((*nl) != NULL) {    /*使用的是dummy header算法, 即使刚开始时链表为空也不用显示判断区分*/
10         if (n->priority > (*nl)->priority)        /*判断优先权值, 优先权值越大位置越靠前*/
11             break;
12         nl = &((*nl)->next);
13     }
14     n->next = *nl;    /*将节点n链接到链表nl中的合适位置*/
15     rcu_assign_pointer(*nl, n);    /*使用rcu处理函数保证SMP下的安全性, 相当于加上锁再赋值*/
16     return 0;
17 }

清单7. notifier_chain_unregister函数:

注销回调函数则使用notifier_chain_unregister函数,即将回调函数从通知链中删除:

 1 /*nl是链表头块的地址, n是要删除的通知块*/
 2 static int notifier_chain_unregister(struct notifier_block **nl,
 3         struct notifier_block *n)
 4 {
 5     while ((*nl) != NULL) {
 6         if ((*nl) == n) {
 7             rcu_assign_pointer(*nl, n->next);    /* *nl=n->next的安全赋值操作,相当于将节点从链表断开*/
 8             return 0;
 9         }
10         nl = &((*nl)->next);
11     }
12     return -ENOENT;
13 }

清单8. notifier_call_chain函数:

通知者(主机)调用 notifier_call_chain函数通知事件的到达,这个函数会遍历通知链中所有的元素,然后依次调用每一个的回调函数(即完成通知动作):

 1 /**
 2  * notifier_call_chain - Informs the registered notifiers about an event.
 3  *    @nl:        Pointer to head of the blocking notifier chain
 4  *    @val:        Value passed unmodified to notifier function
 5  *    @v:        Pointer passed unmodified to notifier function
 6  *    @nr_to_call:    Number of notifier functions to be called. Don't care
 7  *            value of this parameter is -1.
 8  *    @nr_calls:    Records the number of notifications sent. Don't care
 9  *            value of this field is NULL.
10  *    @returns:    notifier_call_chain returns the value returned by the
11  *            last notifier function called.
12  */
13 static int __kprobes notifier_call_chain(struct notifier_block **nl,
14                     unsigned long val, void *v,
15                     int nr_to_call,    int *nr_calls)
16 {
17     int ret = NOTIFY_DONE;
18     struct notifier_block *nb, *next_nb;
19
20     nb = rcu_dereference(*nl);    /*安全地获取通知块指针*/
21
22     while (nb && nr_to_call) {        /*链表循环*/
23         next_nb = rcu_dereference(nb->next);    /*找下一个块*/
24
25 #ifdef CONFIG_DEBUG_NOTIFIERS
26         if (unlikely(!func_ptr_is_kernel_text(nb->notifier_call))) {
27             WARN(1, "Invalid notifier called!");
28             nb = next_nb;
29             continue;
30         }
31 #endif
32         ret = nb->notifier_call(nb, val, v);    /*执行订阅者注册的回调函数，对此通知做出响应*/
33
34         if (nr_calls)
35             (*nr_calls)++;
36
37         if ((ret & NOTIFY_STOP_MASK) == NOTIFY_STOP_MASK)    /*如果返回停止标志, 不执行后续结构*/
38             break;
39         nb = next_nb;        /*循环执行，进入下一个节点*/
40         nr_to_call--;
41     }
42     return ret;
43 }

参数nl是通知链的头部,val表示事件类型,v用来指向通知链上的函数执行时需要用到的参数,一般不同的通知链,参数类型也不一样,例如当通知一个网卡被注册时,v就指向net_device结构,nr_to_call表示准备最多通知几个,-1表示整条链都通知,nr_calls非空的话,返回通知了多少个.

每个被执行的notifier_block回调函数的返回值可能取值为以下几个:

• NOTIFY_DONE:表示对相关的事件类型不关心;
• NOTIFY_OK:顺利执行;
• NOTIFY_BAD:执行有错;
• NOTIFY_STOP:停止执行后面的回调函数;
• NOTIFY_STOP_MASK:停止执行的掩码;
• Notifier_call_chain()把最后一个被调用的回调函数的返回值作为它的返回值.

4. 应用实例

在这里,写了一个简单的通知链表的代码.实际上,整个通知链的编写也就两个过程:

1. 首先是定义自己的通知链的头节点,并将要执行的函数注册到自己的通知链中;
2. 其次则是由另外的子系统来通知这个链,让其上面注册的函数运行.

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

清单9. buildchain.c

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

buildchain.c

清单10. regchain.c

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

regchain.c

清单11. notify.c

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

notify.c

清单12. Makefile

 1 obj-m:=buildchain.o regchain.o notify.o
 2 CURRENT_PATH := $(shell pwd)
 3 LINUX_KERNEL := $(shell uname -r)
 4 KERNELDIR := /usr/src/linux-headers-$(LINUX_KERNEL)
 5
 6 all:
 7 make -C $(KERNELDIR) M=$(CURRENT_PATH) modules
 8
 9 clean:
10
11 make -C $(KERNELDIR) M=$(CURRENT_PATH) clean

清单13. compile&load

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

清单14. result

 1 init_notifier
 2 Begin to register:
 3 register test_notifier1 completed
 4 register test_notifier2 completed
 5 register test_notifier3 completed
 6 Begin to notify:
 7 ==============================
 8 In Event 1: Event Number is 1
 9 In Event 2: Event Number is 1
10 In Event 3: Event Number is 1
11 ==============================

5. 通知头结构的有关宏

清单15. Head-macro

 1 /*以下是一些宏来初始化各种类型的通知头结构, 一般在程序中使用*/
 2 #define ATOMIC_INIT_NOTIFIER_HEAD(name) do{ \
 3   spin_lock_init(&(name)->lock); \
 4   (name)->head =NULL;  \
 5  } while (0)
 6
 7 #define BLOCKING_INIT_NOTIFIER_HEAD(name) do{ \
 8   init_rwsem(&(name)->rwsem); \
 9   (name)->head =NULL;  \
10  } while (0)
11
12 #define RAW_INIT_NOTIFIER_HEAD(name) do{ \
13   (name)->head =NULL;  \
14  } while (0)
15
16
17 /*以下这些宏也是用来初始化各种类型的通知头结构,但是在参数定义时使用（即作为赋值的右半部分，作为等号右边的部分）*/
18 #define ATOMIC_NOTIFIER_INIT(name){    \
19   .lock =__SPIN_LOCK_UNLOCKED(name.lock), \
20   .head = NULL }
21 #define BLOCKING_NOTIFIER_INIT(name){    \
22   .rwsem =__RWSEM_INITIALIZER((name).rwsem), \
23   .head = NULL }
24 #defineRAW_NOTIFIER_INIT(name) {    \
25   .head = NULL }
26
27 /*注意, 没有定义scru通知头结构的初始化, 因为scru是不能静态初始化的.*/
28
29
30 /*以下这些宏用来直接定义通知头结构*/
31 #defineATOMIC_NOTIFIER_HEAD(name)    \
32  struct atomic_notifier_head name=   \
33   ATOMIC_NOTIFIER_INIT(name)
34 #defineBLOCKING_NOTIFIER_HEAD(name)    \
35  struct blocking_notifier_head name=   \
36   BLOCKING_NOTIFIER_INIT(name)
37 #defineRAW_NOTIFIER_HEAD(name)     \
38  struct raw_notifier_head name=    \
39   RAW_NOTIFIER_INIT(name)

6. 扩展的通知块操作

扩展的通知块操作功能和基本通知块类似,但使用了扩展的结构中的参数保证操作的安全

6.1 原子通知块

6.1.1 登记

 1 /**
 2  *    atomic_notifier_chain_register - Add notifier to an atomic notifier chain
 3  *    @nh: Pointer to head of the atomic notifier chain
 4  *    @n: New entry in notifier chain
 5  *
 6  *    Adds a notifier to an atomic notifier chain.
 7  *
 8  *    Currently always returns zero.
 9  */
10 /*只在基本通知登记操作前后加锁进行保护*/
11 int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
12         struct notifier_block *n)
13 {
14     unsigned long flags;
15     int ret;
16
17     spin_lock_irqsave(&nh->lock, flags);    /*加锁*/
18     ret = notifier_chain_register(&nh->head, n);
19     spin_unlock_irqrestore(&nh->lock, flags);    /*解锁*/
20     return ret;
21 }
22 EXPORT_SYMBOL_GPL(atomic_notifier_chain_register);

6.1.2 撤销

 1 /**
 2  *    atomic_notifier_chain_unregister - Remove notifier from an atomic notifier chain
 3  *    @nh: Pointer to head of the atomic notifier chain
 4  *    @n: Entry to remove from notifier chain
 5  *
 6  *    Removes a notifier from an atomic notifier chain.
 7  *
 8  *    Returns zero on success or %-ENOENT on failure.
 9  */
10  /*只是在基本通知块撤销操作前后加锁解锁进行保护*/
11 int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
12         struct notifier_block *n)
13 {
14     unsigned long flags;
15     int ret;
16
17     spin_lock_irqsave(&nh->lock, flags);    /*加锁*/
18     ret = notifier_chain_unregister(&nh->head, n);
19     spin_unlock_irqrestore(&nh->lock, flags);    /*解锁*/
20     synchronize_rcu();    /*同步rcu, 等待一个grace period*/
21     return ret;
22 }
23 EXPORT_SYMBOL_GPL(atomic_notifier_chain_unregister);

6.1.3 原子回调

 1 /**
 2  *    __atomic_notifier_call_chain - Call functions in an atomic notifier chain
 3  *    @nh: Pointer to head of the atomic notifier chain
 4  *    @val: Value passed unmodified to notifier function
 5  *    @v: Pointer passed unmodified to notifier function
 6  *    @nr_to_call: See the comment for notifier_call_chain.
 7  *    @nr_calls: See the comment for notifier_call_chain.
 8  *
 9  *    Calls each function in a notifier chain in turn.  The functions
10  *    run in an atomic context, so they must not block.
11  *    This routine uses RCU to synchronize with changes to the chain.
12  *
13  *    If the return value of the notifier can be and'ed
14  *    with %NOTIFY_STOP_MASK then atomic_notifier_call_chain()
15  *    will return immediately, with the return value of
16  *    the notifier function which halted execution.
17  *    Otherwise the return value is the return value
18  *    of the last notifier function called.
19  */
20 int __kprobes __atomic_notifier_call_chain(struct atomic_notifier_head *nh,
21                     unsigned long val, void *v,
22                     int nr_to_call, int *nr_calls)
23 {
24     int ret;
25
26     rcu_read_lock();        /*禁止抢占*/
27     ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);    /*使用基本通知块回调*/
28     rcu_read_unlock();    /*使能抢占*/
29     return ret;
30 }
31 EXPORT_SYMBOL_GPL(__atomic_notifier_call_chain);
32
33 /*这个函数是在原子操作上下文中调用, 是不能阻塞的*/
34 int __kprobes atomic_notifier_call_chain(struct atomic_notifier_head *nh,
35         unsigned long val, void *v)
36 {
37     return __atomic_notifier_call_chain(nh, val, v, -1, NULL);
38 }
39 EXPORT_SYMBOL_GPL(atomic_notifier_call_chain);

6.2 可阻塞通知块

6.2.1 登记

 1 /**
 2  *    blocking_notifier_chain_register - Add notifier to a blocking notifier chain
 3  *    @nh: Pointer to head of the blocking notifier chain
 4  *    @n: New entry in notifier chain
 5  *
 6  *    Adds a notifier to a blocking notifier chain.
 7  *    Must be called in process context.
 8  *
 9  *    Currently always returns zero.
10  */
11 int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
12         struct notifier_block *n)
13 {
14     int ret;
15
16     /*
17      * This code gets used during boot-up, when task switching is
18      * not yet working and interrupts must remain disabled.  At
19      * such times we must not call down_write().
20      */
21     if (unlikely(system_state == SYSTEM_BOOTING))    /*此时是不能阻塞*/
22         return notifier_chain_register(&nh->head, n);
23
24     down_write(&nh->rwsem);    /*使用信号灯进行同步, 可能阻塞*/
25     ret = notifier_chain_register(&nh->head, n);    /*基本登记函数*/
26     up_write(&nh->rwsem);        /*释放信号量*/
27     return ret;
28 }
29 EXPORT_SYMBOL_GPL(blocking_notifier_chain_register);

6.2.2 撤销

 1 /**
 2  *    blocking_notifier_chain_unregister - Remove notifier from a blocking notifier chain
 3  *    @nh: Pointer to head of the blocking notifier chain
 4  *    @n: Entry to remove from notifier chain
 5  *
 6  *    Removes a notifier from a blocking notifier chain.
 7  *    Must be called from process context.
 8  *
 9  *    Returns zero on success or %-ENOENT on failure.
10  */
11  /*该函数是在进程处理过程中调用,可阻塞*/
12 int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
13         struct notifier_block *n)
14 {
15     int ret;
16
17     /*
18      * This code gets used during boot-up, when task switching is
19      * not yet working and interrupts must remain disabled.  At
20      * such times we must not call down_write().
21      */
22     if (unlikely(system_state == SYSTEM_BOOTING))
23         return notifier_chain_unregister(&nh->head, n);
24
25     down_write(&nh->rwsem);
26     ret = notifier_chain_unregister(&nh->head, n);
27     up_write(&nh->rwsem);
28     return ret;
29 }
30 EXPORT_SYMBOL_GPL(blocking_notifier_chain_unregister);

6.2.3 回调

 1 /**
 2  *    __blocking_notifier_call_chain - Call functions in a blocking notifier chain
 3  *    @nh: Pointer to head of the blocking notifier chain
 4  *    @val: Value passed unmodified to notifier function
 5  *    @v: Pointer passed unmodified to notifier function
 6  *    @nr_to_call: See comment for notifier_call_chain.
 7  *    @nr_calls: See comment for notifier_call_chain.
 8  *
 9  *    Calls each function in a notifier chain in turn.  The functions
10  *    run in a process context, so they are allowed to block.
11  *
12  *    If the return value of the notifier can be and'ed
13  *    with %NOTIFY_STOP_MASK then blocking_notifier_call_chain()
14  *    will return immediately, with the return value of
15  *    the notifier function which halted execution.
16  *    Otherwise the return value is the return value
17  *    of the last notifier function called.
18  */
19 int __blocking_notifier_call_chain(struct blocking_notifier_head *nh,
20                    unsigned long val, void *v,
21                    int nr_to_call, int *nr_calls)
22 {
23     int ret = NOTIFY_DONE;
24
25     /*
26      * We check the head outside the lock, but if this access is
27      * racy then it does not matter what the result of the test
28      * is, we re-check the list after having taken the lock anyway:
29      */
30     if (rcu_dereference(nh->head)) {
31         down_read(&nh->rwsem);
32         ret = notifier_call_chain(&nh->head, val, v, nr_to_call,
33                     nr_calls);
34         up_read(&nh->rwsem);
35     }
36     return ret;
37 }
38 EXPORT_SYMBOL_GPL(__blocking_notifier_call_chain);
39 /*在进行上下文中调用, 可以阻塞*/
40 int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
41         unsigned long val, void *v)
42 {
43     return __blocking_notifier_call_chain(nh, val, v, -1, NULL);
44 }
45 EXPORT_SYMBOL_GPL(blocking_notifier_call_chain);

6.3 原始通知块操作

 1 /*
 2  *    Raw notifier chain routines.  There is no protection;
 3  *    the caller must provide it.  Use at your own risk!
 4  */
 5
 6 /**
 7  *    raw_notifier_chain_register - Add notifier to a raw notifier chain
 8  *    @nh: Pointer to head of the raw notifier chain
 9  *    @n: New entry in notifier chain
10  *
11  *    Adds a notifier to a raw notifier chain.
12  *    All locking must be provided by the caller.
13  *
14  *    Currently always returns zero.
15  */
16  /*
17 和基本原始块操作完全相同*/
18 int raw_notifier_chain_register(struct raw_notifier_head *nh,
19         struct notifier_block *n)
20 {
21     return notifier_chain_register(&nh->head, n);
22 }
23 EXPORT_SYMBOL_GPL(raw_notifier_chain_register);
24
25 /**
26  *    raw_notifier_chain_unregister - Remove notifier from a raw notifier chain
27  *    @nh: Pointer to head of the raw notifier chain
28  *    @n: Entry to remove from notifier chain
29  *
30  *    Removes a notifier from a raw notifier chain.
31  *    All locking must be provided by the caller.
32  *
33  *    Returns zero on success or %-ENOENT on failure.
34  */
35 int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
36         struct notifier_block *n)
37 {
38     return notifier_chain_unregister(&nh->head, n);
39 }
40 EXPORT_SYMBOL_GPL(raw_notifier_chain_unregister);
41
42 /**
43  *    __raw_notifier_call_chain - Call functions in a raw notifier chain
44  *    @nh: Pointer to head of the raw notifier chain
45  *    @val: Value passed unmodified to notifier function
46  *    @v: Pointer passed unmodified to notifier function
47  *    @nr_to_call: See comment for notifier_call_chain.
48  *    @nr_calls: See comment for notifier_call_chain
49  *
50  *    Calls each function in a notifier chain in turn.  The functions
51  *    run in an undefined context.
52  *    All locking must be provided by the caller.
53  *
54  *    If the return value of the notifier can be and'ed
55  *    with %NOTIFY_STOP_MASK then raw_notifier_call_chain()
56  *    will return immediately, with the return value of
57  *    the notifier function which halted execution.
58  *    Otherwise the return value is the return value
59  *    of the last notifier function called.
60  */
61 int __raw_notifier_call_chain(struct raw_notifier_head *nh,
62                   unsigned long val, void *v,
63                   int nr_to_call, int *nr_calls)
64 {
65     return notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
66 }
67 EXPORT_SYMBOL_GPL(__raw_notifier_call_chain);
68
69 int raw_notifier_call_chain(struct raw_notifier_head *nh,
70         unsigned long val, void *v)
71 {
72     return __raw_notifier_call_chain(nh, val, v, -1, NULL);
73 }
74 EXPORT_SYMBOL_GPL(raw_notifier_call_chain);

6.4 SRCU通知块

6.4.1 登记

 1 /**
 2  *    srcu_notifier_chain_register - Add notifier to an SRCU notifier chain
 3  *    @nh: Pointer to head of the SRCU notifier chain
 4  *    @n: New entry in notifier chain
 5  *
 6  *    Adds a notifier to an SRCU notifier chain.
 7  *    Must be called in process context.
 8  *
 9  *    Currently always returns zero.
10  */
11  /*必须在进程的上下文中调用, 和blocking通知类似*/
12 int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
13         struct notifier_block *n)
14 {
15     int ret;
16
17     /*
18      * This code gets used during boot-up, when task switching is
19      * not yet working and interrupts must remain disabled.  At
20      * such times we must not call mutex_lock().
21      */
22     if (unlikely(system_state == SYSTEM_BOOTING))
23         return notifier_chain_register(&nh->head, n);
24
25     mutex_lock(&nh->mutex);
26     ret = notifier_chain_register(&nh->head, n);
27     mutex_unlock(&nh->mutex);
28     return ret;
29 }
30 EXPORT_SYMBOL_GPL(srcu_notifier_chain_register);

6.4.2 撤销

 1 /**
 2  *    srcu_notifier_chain_unregister - Remove notifier from an SRCU notifier chain
 3  *    @nh: Pointer to head of the SRCU notifier chain
 4  *    @n: Entry to remove from notifier chain
 5  *
 6  *    Removes a notifier from an SRCU notifier chain.
 7  *    Must be called from process context.
 8  *
 9  *    Returns zero on success or %-ENOENT on failure.
10  */
11  /*必须在进程的上下文中调用, 和blocking通知类似*/
12 int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
13         struct notifier_block *n)
14 {
15     int ret;
16
17     /*
18      * This code gets used during boot-up, when task switching is
19      * not yet working and interrupts must remain disabled.  At
20      * such times we must not call mutex_lock().
21      */
22     if (unlikely(system_state == SYSTEM_BOOTING))
23         return notifier_chain_unregister(&nh->head, n);
24
25     mutex_lock(&nh->mutex);
26     ret = notifier_chain_unregister(&nh->head, n);
27     mutex_unlock(&nh->mutex);
28     synchronize_srcu(&nh->srcu);
29     return ret;
30 }
31 EXPORT_SYMBOL_GPL(srcu_notifier_chain_unregister);

6.4.3 回调

 1 /**
 2  *    __srcu_notifier_call_chain - Call functions in an SRCU notifier chain
 3  *    @nh: Pointer to head of the SRCU notifier chain
 4  *    @val: Value passed unmodified to notifier function
 5  *    @v: Pointer passed unmodified to notifier function
 6  *    @nr_to_call: See comment for notifier_call_chain.
 7  *    @nr_calls: See comment for notifier_call_chain
 8  *
 9  *    Calls each function in a notifier chain in turn.  The functions
10  *    run in a process context, so they are allowed to block.
11  *
12  *    If the return value of the notifier can be and'ed
13  *    with %NOTIFY_STOP_MASK then srcu_notifier_call_chain()
14  *    will return immediately, with the return value of
15  *    the notifier function which halted execution.
16  *    Otherwise the return value is the return value
17  *    of the last notifier function called.
18  */
19 int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
20                    unsigned long val, void *v,
21                    int nr_to_call, int *nr_calls)
22 {
23     int ret;
24     int idx;
25
26     idx = srcu_read_lock(&nh->srcu);    /*使用srcu来加锁*/
27     ret = notifier_call_chain(&nh->head, val, v, nr_to_call, nr_calls);
28     srcu_read_unlock(&nh->srcu, idx);
29     return ret;
30 }
31 EXPORT_SYMBOL_GPL(__srcu_notifier_call_chain);
32 /*在进程的上下文中调用, 可以阻塞*/
33 int srcu_notifier_call_chain(struct srcu_notifier_head *nh,
34         unsigned long val, void *v)
35 {
36     return __srcu_notifier_call_chain(nh, val, v, -1, NULL);
37 }
38 EXPORT_SYMBOL_GPL(srcu_notifier_call_chain);

6.4.4 初始化

 1 /**
 2  *    srcu_init_notifier_head - Initialize an SRCU notifier head
 3  *    @nh: Pointer to head of the srcu notifier chain
 4  *
 5  *    Unlike other sorts of notifier heads, SRCU notifier heads require
 6  *    dynamic initialization.  Be sure to call this routine before
 7  *    calling any of the other SRCU notifier routines for this head.
 8  *
 9  *    If an SRCU notifier head is deallocated, it must first be cleaned
10  *    up by calling srcu_cleanup_notifier_head().  Otherwise the head's
11  *    per-cpu data (used by the SRCU mechanism) will leak.
12  */
13  /*因为SRCU通知不能通过宏来初始化,必须要专门定义一个初始化函数来初始化srcu的通知块参数*/
14 void srcu_init_notifier_head(struct srcu_notifier_head *nh)
15 {
16     mutex_init(&nh->mutex);
17     if (init_srcu_struct(&nh->srcu) < 0)
18         BUG();
19     nh->head = NULL;
20 }
21 EXPORT_SYMBOL_GPL(srcu_init_notifier_head);

本文参考：

http://blog.csdn.net/tommy_wxie/article/details/7963926

http://blog.sina.com.cn/s/blog_5426448c0100ntqb.html

http://hi.baidu.com/yskcg/item/8947658d7cbdd8c0b07154a5

http://geyingzhen.blog.163.com/blog/static/6558665520091165531675/