精华内容
下载资源
问答
  • 通知链

    千次阅读 2011-11-08 08:33:48
    内核的很多子系统之间...为了实现这种交互需求,Linux使用了所谓的通知链通知链上的是一个个的notifiter_block结构: struct notifier_block { int (*notifier_call)(struct notifier_block *, unsigned long, v

        内核的很多子系统之间有很强的相互依赖性,因此,其中一个子系统侦测到的或者产生的事件,其他的子系统可能很感兴趣。为了实现这种交互需求,Linux使用了所谓的通知链。通知链上的是一个个的notifiter_block结构:

    struct notifier_block {
    	int (*notifier_call)(struct notifier_block *, unsigned long, void *);
    	struct notifier_block *next;
    	int priority;
    };
    priority代表的是该函数的优先级,较高的优先级的函数会先被执行,但是实际中几乎都不会理会该值。因此,执行的次序仅依赖于注册的顺序。回调函数notifier_call是在调用notifier_call_chain的进程上下文中执行,然而,回调函数也可以实现把通知信息安排在某处的队列,然后唤醒查看此通知信息的进程。

        在内存中不同的通知被放在不同的链上,在需要将通知加入的时候只要调用相应的注册函数就可以了,比如register_inetaddr_notifier函数:

    int register_inetaddr_notifier(struct notifier_block *nb){
    	return blocking_notifier_chain_register(&inetaddr_chain, nb);
    }
    一般的这些函数都是包裹函数,通过blocking_notifier_chain_register函数将notifier_block添加到不同的链表上:

    int blocking_notifier_chain_register(struct blocking_notifier_head *nh, struct notifier_block *n){
    	int ret;
    	// 如果是在开机的时候还不具备down_write的条件
    	if (unlikely(system_state < SYSTEM_RUNNING))
    		return notifier_chain_register(&nh->head, n);
    	down_write(&nh->rwsem);
    	ret = notifier_chain_register(&nh->head, n);
    	up_write(&nh->rwsem);
    	return ret;
    }
    down_write的问题应该是很多其他函数的情况下是不会出现的,不过在这里需要分开考虑。下面是将通知插入到对应链的尾部:

    static int notifier_chain_register(struct notifier_block **nl,struct notifier_block *n){
    	// 找到链表的尾部
    	while ((*nl) != NULL) {
    		if (n->priority > (*nl)->priority)
    			break;
    		nl = &((*nl)->next);
    	}
    	n->next = *nl;
    	// rcu机制
    	rcu_assign_pointer(*nl, n);
    	return 0;
    }
    RCU机制就是为了让读写并行,下面将节点插入:

    #define rcu_assign_pointer(p, v) \
    	({ \
    		if (!__builtin_constant_p(v) || \
    			((v) != NULL)) \
    			smp_wmb(); \
    		(p) = (v); \
    	})
    其中__builtin_constant_p是GCC的内联函数,用于判断v是不是编译时常数。而smp_wmb则保证了前面的代码执行完了才执行后面的代码。优化屏障的代码如下:

    #define barrier() __asm__ __volatile__("": : :"memory")
    __volatile__表示阻止编译器对该值进行优化,确保变量使用了用户定义的精确地址,而不是装有同一信息的一些别名。memory表示指令修改了内存单元。对不同的体系结构应该使用不同的内存屏障:

    内存屏障的宏定义功能说明
    mb()多(单)处理器的内存屏障
    rmb()多(单)处理器的读内存屏障
    wmb()多(单)处理器的写内存屏障
    smp_mb()多处理器的内存屏障
    smp_rmb()多处理器的读内存屏障
    smp_wmb()多处理器的写内存屏障

    对网络层代码表征特别重要事件的通知链有如下两个:

    inetaddr_chain本地接口上的IPv4地址的插入、删除、变更的通知信息
    netdev_chain有关网络设备注册状态的通知信息
    关于通知链的使用下面是一个例子,路由子系统用到的初始化函数:

    static struct notifier_block fib_inetaddr_notifier = {
    	.notifier_call =fib_inetaddr_event,
    };
    static struct notifier_block fib_netdev_notifier = {
    	.notifier_call =fib_netdev_event,
    };
    void __init ip_fib_init(void){
    	// ...
    	register_netdevice_notifier(&fib_netdev_notifier);
    	register_inetaddr_notifier(&fib_inetaddr_notifier);
    	// ...
    }
    ---------------------------------

    个人理解,欢迎拍砖。

    展开全文
  • linux内核notifier机制 linux通知链

    千次阅读 2014-09-23 21:02:18
    机制来获取由其它模块或子系统产生的它感兴趣的某些事 件。 使用notifier由通知者可以传递给被通知者整形参数与指针,在linux中有许多地  方用到,比如reboot通知,cpu调频通知,电池低 电警报等等。熟 悉使用...
    在linux内核系统中,各个模块、子系统之间是相互独立的。Linux内核可以通过通
    知链机制来获取由其它模块或子系统产生的它感兴趣的某些事件。
    使用notifier由通知者
    可以传递给被通知者长整型参数与指针。在linux中有许多地
    方用到,比如reboot通知,cpu调频通知,网卡事件,电池低电警报等等。熟
    悉使用notifier有助于linux内核驱动开发。
    

    notifier_block结构:
    struct notifier_block {
         int (*notifier_call)(struct notifier_block *, unsigned long, void *);
         struct notifier_block __rcu *next;
         int priority;
    };


    其中,
    1. notifier_call:通知链回调函数,由被通知方提供,第一个  参数notifier_block结构体指针,第二第三个参数分别是由call chain, 也就是通知链发起者传递过来的;
    2. notifier_block *next:用于链接成链表的指针;
    3. priority:回调函数的优先级,一般默认为0。

    何时调用到notifier_call?通常在通知链register与unregister定义文件中就有 notifier call发起函数;


    下面是具体应用实例:

    被通知文件中:
    1:在被通知链文件定义一个notifier call函数:
    static int xxxx_notify(struct notifier_block *nb,
             unsigned long status, void *unused)
    {
         int rc;
    
         if (!the_chip) {
             pr_err("not initialized\n");
             return -EINVAL;
         }
    
         switch (status) {
         case 0:
             pr_debug("0 received\n");
             break;
         case 1:
             pr_debug("1 received\n");
    
             break;
         case 2:
    
             break;
         default:
             pr_err("error received\n");
             break;
         }
    
         return 0;
    };



    2:定义alarm_notifier通知链,将上面定义的函数入口赋值给函数指针

    notifier_call;

    static struct notifier_block xxxx_notifier = {
         .notifier_call = xxxx_notify,
    };



    3:注册alarm_notifier通知链:
    probe函数里面:
         {
         -----
         rc = xxxx_register_notifier(&alarm_notifier);
         if (rc) {
             pr_err("unable to register alarm notifier rc=%d\n", rc);
             return rc;
         ------
         }




    通知文件中:

    1:定义notifier register函数,提供给被通知链调用:
    int xxxx_register_notifier(struct notifier_block *nb)
    {
         -------
         rc = srcu_notifier_chain_register(&chip->irq_notifier_list, nb);
         -------
         return rc;
    }
    EXPORT_SYMBOL(xxxx_register_notifier);



    2:notifier call发起的地方,这里是在中断的queue work里面调用 
    srcu_notifier_call_chain(),其被内核定义在
    notifier.c,注意后面的2个参数会传递给回调函数。
    static void xxxx_isr_work(struct work_struct *work)
    {
         struct xxxx_chip *chip
             = container_of(work, struct xxxx_chip, irq_work);
         int status;
    
         if (!chip)
             return;
    
         status = xxxx_status_read();
    
         srcu_notifier_call_chain(&chip->irq_notifier_list,
                             status, NULL);
    
    }



    展开全文
  • Linux内核通知链notifier

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

    Linux内核通知链notifier

     


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

    通知链技术可以概括为:事件的被通知者将事件发生时应该执行的操作通过函数指针方式保存在链表(通知链)中,然后当事件发生时通知者依次执行链表中每一个元素的回调函数完成通知。

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

    struct notifier_block {

    int (*notifier_call)(struct notifier_block *, unsigned long, void *);


    struct notifier_block *next;


    int priority;

    };

    notifier_call:该节点所对应的要运行的函数。
    *next:指向下一个节点,事件发生时,依次执行的

    3.内核通知链注册函数:
        在通知链注册时,需要有一个链表头,它指向这个通知链表的第一个元素。这样,之后的事件对该链表通知时就会根据这个链表头而找到这个链表中所有的元素。链表头的定义见本文第6节。
        注册的函数是:

    /*

    *
    Notifier chain core routines.
    The exported routines below


    *
    are layered on top of these, with appropriate locking added.


    */


    static int notifier_chain_register(struct notifier_block **nl,

    struct notifier_block *n)

    {

    while ((*nl) != NULL) {


    if (n->priority > (*nl)->priority)


    break;


    nl = &((*nl)->next);


    }


    n->next = *nl;


    rcu_assign_pointer(*nl, n);


    return 0;

    }

       从上面的函数实现来看,被通知者调用 notifier_chain_register 函数注册回调函数,该函数是按照优先级将回调函数加入到通知链中去的。


        卸载的函数是:
    static int notifier_chain_unregister(struct notifier_block **nl,

    struct notifier_block *n)

    {

    while ((*nl) != NULL) {


    if ((*nl) == n) {


    rcu_assign_pointer(*nl, n->next);


    return 0;


    }


    nl = &((*nl)->next);


    }


    return -ENOENT;

    }

    将节点nnl所指向的链表中删除。
    kernel/notifier.c中内核根据通知链的类型分别包装了上面这个函数:

    int atomic_notifier_chain_register(struct atomic_notifier_head *nh,

    struct notifier_block *n)


    int blocking_notifier_chain_register(struct blocking_notifier_head *nh,

    struct notifier_block *n)


    int raw_notifier_chain_register(struct raw_notifier_head *nh,

    struct notifier_block *n)


    int srcu_notifier_chain_register(struct srcu_notifier_head *nh,

    struct notifier_block *n)



    4.内核通知链通知函数:
        当有事件发生时,通知者调用 notifier_call_chain 函数通知事件的到达,这个函数会遍历n1指向的通知链中所有的元素,然后依次调用每一个的回调函数,完成通知动作。


    static int __kprobes notifier_call_chain(struct notifier_block **nl,

    unsigned long val, void *v,


    int nr_to_call,
    int *nr_calls)

    {

    int ret = NOTIFY_DONE;


    struct notifier_block *nb, *next_nb;



    nb = rcu_dereference_raw(*nl);



    while (nb && nr_to_call) {


    next_nb = rcu_dereference_raw(nb->next);


    #ifdef CONFIG_DEBUG_NOTIFIERS

    if (unlikely(!func_ptr_is_kernel_text(nb->notifier_call))) {


    WARN(1, "Invalid notifier called!");


    nb = next_nb;


    continue;


    }

    #endif

    ret = nb->notifier_call(nb, val, v);



    if (nr_calls)


    (*nr_calls)++;



    if ((ret & NOTIFY_STOP_MASK) == NOTIFY_STOP_MASK)


    break;


    nb = next_nb;


    nr_to_call--;


    }


    return ret;

    }

    kernel/notifier.c中内核根据通知链的类型分别包装了上面这个函数:

    int atomic_notifier_call_chain(struct atomic_notifier_head *nh,

    unsigned long val, void *v)


    int blocking_notifier_call_chain(struct blocking_notifier_head *nh,

    unsigned long val, void *v)


    int raw_notifier_call_chain(struct raw_notifier_head *nh,

    unsigned long val, void *v)


    int srcu_notifier_call_chain(struct srcu_notifier_head *nh,

    unsigned long val, void *v)


    5.通知链四种类型

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

    spinlock_t lock;


    struct notifier_block *head;

    };
    5.2)可阻塞通知链:
    通知链元素的回调函数在进程上下文中运行,允许阻塞。
    struct blocking_notifier_head {

    struct rw_semaphore rwsem;


    struct notifier_block *head;

    };
    5.3)原始通知链:
    对通知链元素的回调函数没有任何限制,所有锁和保护机制都由调用者维护。
    struct raw_notifier_head {

    struct notifier_block *head;

    };
    5.4SRCU 通知链:
    可阻塞通知链的变种。
    struct srcu_notifier_head {

    struct mutex mutex;


    struct srcu_struct srcu;


    struct notifier_block *head;

    };

    6)定义一个通知链的头部结点并初始化:
    include/linux/Notifier.h
    初始化宏定义:


    #define ATOMIC_NOTIFIER_INIT(name) {
    \


    .lock = __SPIN_LOCK_UNLOCKED(name.lock),
    \


    .head = NULL }

    #define BLOCKING_NOTIFIER_INIT(name) {
    \


    .rwsem = __RWSEM_INITIALIZER((name).rwsem),
    \


    .head = NULL }

    #define RAW_NOTIFIER_INIT(name)
    {
    \


    .head = NULL }

    /* srcu_notifier_heads cannot be initialized statically */

    定义通知链:

    #define ATOMIC_NOTIFIER_HEAD(name)
    \


    struct atomic_notifier_head name =
    \


    ATOMIC_NOTIFIER_INIT(name)

    #define BLOCKING_NOTIFIER_HEAD(name)
    \


    struct blocking_notifier_head name =
    \


    BLOCKING_NOTIFIER_INIT(name)

    #define RAW_NOTIFIER_HEAD(name)
    \


    struct raw_notifier_head name =
    \


    RAW_NOTIFIER_INIT(name)


    展开全文
  • Linux中的通知链技术

    千次阅读 2009-12-22 17:18:00
    Linux中的通知链技术在Linux内核中,各个子系统之间有很强的相互关系,某些子系统可能对其它子系统产生的事件感兴趣。为了让某个子系统在发生某个事件时通知感兴趣的子系统,Linux内核引入了通知链技术。通知链只...

    Linux中的通知链技术

    Linux内核中,各个子系统之间有很强的相互关系,某些子系统可能对其它子系统产生的事件感兴趣。为了让某个子系统在发生某个事件时通知感兴趣的子系统,Linux内核引入了通知链技术。通知链只能够在内核的子系统之间使用,而不能够在内核和用户空间进行事件的通知。

    数据结构:

    通知链有四种类型

    ·原子通知链( Atomic notifier chains ):通知链元素的回调函数(当事件发生时要执行的函数)只能在中断上下文中运行,不允许阻塞。对应的链表头结构:

    struct atomic_notifier_head {

    spinlock_t lock;

    struct notifier_block *head;

    };

    ·可阻塞通知链( Blocking notifier chains ):通知链元素的回调函数在进程上下文中运行,允许阻塞。对应的链表头:

    struct blocking_notifier_head {

    struct rw_semaphore rwsem;

    struct notifier_block *head;

    };

    ·原始通知链( Raw notifier chains ):对通知链元素的回调函数没有任何限制,所有锁和保护机制都由调用者维护。对应的链表头:

    struct raw_notifier_head {

    struct notifier_block *head;

    };

    ·SRCU 通知链( SRCU notifier chains ):可阻塞通知链的一种变体。对应的链表头:

    struct srcu_notifier_head {

    struct mutex mutex;

    struct srcu_struct srcu;

    struct notifier_block *head;

    };

    通知链的核心结构:

    struct notifier_block {

    int (*notifier_call)(struct notifier_block *, unsigned long, void *);

    struct notifier_block *next;

    int priority;

    };

    其中notifier_call是通知链要执行的函数指针,next用来连接其它的通知结构,priority是这个通知的优先级,同一条链上的notifier_block{}是按优先级排列的。内核代码中一般把通知链命名为xxx_chain, xxx_nofitier_chain这种形式的变量名。

    运作机制

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

    ·被通知者:对某一事件感兴趣一方。定义了当事件发生时,相应的处理函数,即回调函数。但需要事先将其注册到通知链中(被通知者注册的动作就是在通知链中增加一项)。

    ·通知者:事件的通知者。当检测到某事件,或者本身产生事件时,通知所有对该事件感兴趣的一方事件发生。他定义了一个通知链,其中保存了每一个被通知者对事件的处理函数(回调函数)。通知这个过程实际上就是遍历通知链中的每一项,然后调用相应的事件处理函数。

    包括以下过程:

    ·通知者定义通知链

    ·被通知者向通知链中注册回调函数

    ·当事件发生时,通知者发出通知(执行通知链中所有元素的回调函数)

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

    static int notifier_chain_register(struct notifier_block **nl,

    struct notifier_block *n)

    {

    while ((*nl) != NULL) {

    if (n->priority > (*nl)->priority)

    break;

    nl = &((*nl)->next);

    }

    n->next = *nl;

    rcu_assign_pointer(*nl, n);

    return 0;

    }

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

    static int notifier_chain_unregister(struct notifier_block **nl,

    struct notifier_block *n)

    {

    while ((*nl) != NULL) {

    if ((*nl) == n) {

    rcu_assign_pointer(*nl, n->next);

    return 0;

    }

    nl = &((*nl)->next);

    }

    return -ENOENT;

    }

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

    /**

     * 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 __kprobes notifier_call_chain(struct notifier_block **nl,

    unsigned long val, void *v,

    int nr_to_call, int *nr_calls)

    {

    int ret = NOTIFY_DONE;

    struct notifier_block *nb, *next_nb;

    nb = rcu_dereference(*nl);

    while (nb && nr_to_call) {

    next_nb = rcu_dereference(nb->next);

    #ifdef CONFIG_DEBUG_NOTIFIERS

    if (unlikely(!func_ptr_is_kernel_text(nb->notifier_call))) {

    WARN(1, "Invalid notifier called!");

    nb = next_nb;

    continue;

    }

    #endif

    ret = nb->notifier_call(nb, val, v);

    if (nr_calls)

    (*nr_calls)++;

    if ((ret & NOTIFY_STOP_MASK) == NOTIFY_STOP_MASK)

    break;

    nb = next_nb;

    nr_to_call--;

    }

    return ret;

    }

    参数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()把最后一个被调用的回调函数的返回值作为它的返回值。

    内核网络代码中对通知链的使用

    内核网络部分使用的一些通知链:

    ·inetaddr_chainipv4地址变动时的通知链

    ·netdev_chain:网络设备状态变动时的通知链

    网络代码中对通知链的调用一般都有一个包装函数,例如对netdev_chain的注册就是由register_netdevice_notifier()函数完成的:

    int register_netdevice_notifier(struct notifier_block *nb)

    {

    struct net_device *dev;

    struct net_device *last;

    struct net *net;

    int err;

    rtnl_lock();

    err = raw_notifier_chain_register(&netdev_chain, nb);

    if (err)

    goto unlock;

    if (dev_boot_phase)

    goto unlock;

    for_each_net(net) {

    for_each_netdev(net, dev) {

    err = nb->notifier_call(nb, NETDEV_REGISTER, dev);

    err = notifier_to_errno(err);

    if (err)

    goto rollback;

    if (!(dev->flags & IFF_UP))

    continue;

    nb->notifier_call(nb, NETDEV_UP, dev);

    }

    }

    unlock:

    rtnl_unlock();

    return err;

    rollback:

    last = dev;

    for_each_net(net) {

    for_each_netdev(net, dev) {

    if (dev == last)

    break;

    if (dev->flags & IFF_UP) {

    nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);

    nb->notifier_call(nb, NETDEV_DOWN, dev);

    }

    nb->notifier_call(nb, NETDEV_UNREGISTER, dev);

    }

    }

    raw_notifier_chain_unregister(&netdev_chain, nb);

    goto unlock;

    }

    这个函数主要完成两件事情:

    1)把参数struct notifier_block *nb注册到netdev_chain通知链上;

    2)系统中所有已经被注册过的或者激活的网络设备的事件都要被新增的这个通知的回调函数重新调用一遍,使设备更新到一个完整的状态。

    dev_boot_phase定义如下,表示在启动阶段。

    static int dev_boot_phase = 1;

    例如,在启动阶段的网络模块初始化过程中,有一个调用过程inet_init()-->ip_init()-->ip_rt_init()-->devinet_init(),会注册一个ip_netdev_notifier通知链:

    register_netdevice_notifier(&ip_netdev_notifier);

    ip_netdev_notifier定义为:

    static struct notifier_block ip_netdev_notifier = {

    .notifier_call = inetdev_event,

    };

    inetdev_event()实现为:

    static int inetdev_event(struct notifier_block *this, unsigned long event,

     void *ptr)

    {

    struct net_device *dev = ptr;

    struct in_device *in_dev = __in_dev_get_rtnl(dev);

    ASSERT_RTNL();

    if (!in_dev) {

    if (event == NETDEV_REGISTER) {

    in_dev = inetdev_init(dev);

    if (!in_dev)

    return notifier_from_errno(-ENOMEM);

    if (dev->flags & IFF_LOOPBACK) {

    IN_DEV_CONF_SET(in_dev, NOXFRM, 1);

    IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);

    }

    } else if (event == NETDEV_CHANGEMTU) {

    /* Re-enabling IP */

    if (inetdev_valid_mtu(dev->mtu))

    in_dev = inetdev_init(dev);

    }

    goto out;

    }

    switch (event) {

    case NETDEV_REGISTER:

    printk(KERN_DEBUG "inetdev_event: bug/n");

    dev->ip_ptr = NULL;

    break;

    case NETDEV_UP:

    if (!inetdev_valid_mtu(dev->mtu))

    break;

    if (dev->flags & IFF_LOOPBACK) {

    struct in_ifaddr *ifa;

    if ((ifa = inet_alloc_ifa()) != NULL) {

    ifa->ifa_local =

      ifa->ifa_address = htonl(INADDR_LOOPBACK);

    ifa->ifa_prefixlen = 8;

    ifa->ifa_mask = inet_make_mask(8);

    in_dev_hold(in_dev);

    ifa->ifa_dev = in_dev;

    ifa->ifa_scope = RT_SCOPE_HOST;

    memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);

    inet_insert_ifa(ifa);

    }

    }

    ip_mc_up(in_dev);

    /* fall through */

    case NETDEV_CHANGEADDR:

    if (IN_DEV_ARP_NOTIFY(in_dev))

    arp_send(ARPOP_REQUEST, ETH_P_ARP,

     in_dev->ifa_list->ifa_address,

     dev,

     in_dev->ifa_list->ifa_address,

     NULL, dev->dev_addr, NULL);

    break;

    case NETDEV_DOWN:

    ip_mc_down(in_dev);

    break;

    case NETDEV_CHANGEMTU:

    if (inetdev_valid_mtu(dev->mtu))

    break;

    /* disable IP when MTU is not enough */

    case NETDEV_UNREGISTER:

    inetdev_destroy(in_dev);

    break;

    case NETDEV_CHANGENAME:

    /* Do not notify about label change, this event is

     * not interesting to applications using netlink.

     */

    inetdev_changename(dev, in_dev);

    devinet_sysctl_unregister(in_dev);

    devinet_sysctl_register(in_dev);

    break;

    }

    out:

    return NOTIFY_DONE;

    }

    在注册的时候传递的是NETDEV_REGISTER事件,所以在in_dev不为空时,只做switch语句中的一个动作:dev->ip_ptr = NULL;在in_dev为空时,调用inetdev_init()函数分配一个struct in_device,此时如果是Loopback设备才有动作了。

    举例 

    这个例子由参考文章二给出。

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

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

        这里将第一个过程分成了两步来写,第一步是定义了头节点和一些自定义的注册函数(针对该头节点的),第二步则是使用自定义的注册函数注册了一些通知链节点。分别在代码buildchain.cregchain.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文件(我修改了)

    注意,记得先检查有没有安装当前linux版本的内核头文件:

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

    CURRENT_PATH := $(shell pwd)

    LINUX_KERNEL := $(shell uname -r)

    KERNELDIR := /usr/src/linux-headers-$(LINUX_KERNEL)

    all:

    make -C $(KERNELDIR) M=$(CURRENT_PATH) modules

    clean:

    make -C $(KERNELDIR) M=$(CURRENT_PATH) clean  

    运行(注意insmodroot权限)

    make

    insmod buildchain.ko
    insmod regchain.ko
    insmod notify.ko

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

    下面是我在自己的机器上面运行得到的结果(dmesg命令):

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

    参考文章:

    http://hi.baidu.com/mczyh/blog/item/80f4200098588c087bec2ce8.html

    http://www.yuanma.org/data/2009/0427/article_3645.htm

    http://blog.chinaunix.net/u2/67414/showart_1993495.html

    展开全文
  • notifier chain — 内核通知链

    千次阅读 2012-10-17 17:53:26
    为了满足这个需求,也即是让某个子系统在发生某个事件时通知其它的子系统,Linux内核提供了通知链的机制。通知链表只能够在内核的子系统之间使用,而不能够在内核与用户空间之间进行事件的通知。通知链表是一个函数...
  • Linux内核通知链 notifier chain

    千次阅读 2011-11-14 12:21:16
    1.内核通知链表简介(引用网络资料) ... 大多数内核子系统都是相互独立的,因此某个子系统可能...为了满足这个需求,也即是让某个子系统在发生某个事件时通知其它的子系统,Linux内核提供了通知链的机制。通知
  • Linux内核事件通知链(Linux Notifier Chains)简介 一、简单介绍    Linux内核中大多数内核子系统都是相互独立的,因此某个子系统可能对其它子系统产生的事件感兴趣。为了满足这个需求,也即是让某个...
  • Linux内核事件通知链(notifier chain)

    千次阅读 2018-12-13 16:42:03
    Linux内核基础--事件通知链(notifier chain) 简介: 内核许多子系统之间关联紧密,因此在一个子系统发生或者检测到的事件信息很可能对其他子系统来说也是有价值的。为了满足其他子系统对这些事件信息的需求,即在...
  • 深入理解linux网络技术内幕--通知链

    千次阅读 2014-02-24 20:11:02
    通知链概述:  大多数内核子系统都是相互独立的,因此某个子系统可能对其它子系统产生的事件感兴趣。为了满足这个需求,也即是让某个子系统在发生某个事件时通知其它的子系统, Linux内核提供了通知链的机制。...
  • Linux内核通知链(Notifier)

    千次阅读 2016-09-21 15:34:37
    在linux内核中,各个子系统之间有很强的相互关系,某些子系统可能对其他子系统产生的事件比较感兴趣。因此内核引入了notifier机制,当然了notifier机制只能用在内核子系统之间,不能用在内核与应用层之间。比如当...
  • Linux内核通知链——notifier_call_chain

    千次阅读 2012-09-28 17:40:03
    为了满足这个需求,也即是让某个子系统在发生某个事件时通知其它的子系统,Linux内核提供了通知链的机制。通知链表只能够在内核的子系统之间使用,而不能够在内核与用户空间之间进行事件的通知。  通知链表是一个...
  • 内核通知链 1.1. 概述 Linux内核中各个子系统相互依赖,当其中某个子系统状态发生改变时,就必须使用一定的机制告知使用其服务的其他子系统,以便其他子系统采取相应的措施。为满足这样的需求,内核实现了事件通知...
  • 这最基本的三个接口分别实现了对通知链上通知块的注册、卸载和遍历操作,可以想象,原子通知链、可阻塞通知链和原始通知链一定会对基本通知链的操作函数再进行一次包装的,事实也确实如此: //原子通知链 int...
  • JAVA设计模式--职责模式

    万次阅读 2017-02-08 00:48:03
    一、什么是职责模式 二、职责模式的结构 三、职责模式应用举例 四、职责模式的适用性 五、职责模式的优缺点 六、总结 一、什么是职责模式 职责(Chain of Responsibility)模式是一种对象的行为...
  • 英国知名供应专家Martin Christopher曾经说过一句非常深刻的话:“21世纪的竞争不是企业和企业之间的竞争,而是供应和供应之间的竞争。” 什么是供应 在风云变幻、寡头纷争的O2O战场,美团屡出重拳并...
  • 防盗机制

    千次阅读 2017-11-07 17:58:17
    防盗机制的几种实现 通常防盗是为了防止图片,视频被盗用。下面简单介绍几种防盗的机制:   1. 利用HTTP Referer字段    HTTP请求中会包含来自哪个url的点击来源,通过这个referer字段可以检测是否...
  • 私有和联盟的机会与挑战

    万次阅读 2019-05-10 10:59:02
    4 以太坊技术自身因此可谓是与具体的应用场景不相关的—— 无论是用于公有、联盟或私有的模式,因此我们的目标是让以太坊的多种 实例的互操作性实现最大化——如可以将为以太坊公有书写的合约和应用程 序导入...
  • 以太坊平台评估 私有和联盟的机会与挑战 作者:Vitalik Buterin  翻译:万向区块链实验室/ChinaLedger 联盟  排版/校对:区块链铅笔(ChainB.com) (注:本文属于学习资料,请勿用于商业用途。转载请注明作者与...
  • 一文说清“上”和“下”

    千次阅读 2020-05-09 17:21:55
    本文作者:张开翔,FISCO BCOS 首席架构师 ...“节点”指多个节点通过网络连接在一起,互相共享信息,其中的共识节点则联合执行共识算法,产生并确认区块。 交易“上链”的简要过程如下: 记账者们收录交易...
  • 本节带来的是Android中用于在状态栏显示通知信息的控件:Notification,相信大部分 学Android都对他都很熟悉,而网上很多关于Notification的使用教程都是基于2.x的,而 现在普遍的Android设备基本都在4.x以上,...
  • Android通知栏Notification适配8.0

    千次阅读 2018-04-26 16:33:04
    在 Android 8.0 中,我们已重新设计通知,以便为管理通知行为和设置提供更轻松和更统一的方式。这些变更包括:图 1. 用户可以长按应用启动器...要了解如何实现通知渠道的信息,请参阅通知渠道指南。通知标志:Andr...
  • Polkadot(波卡)白皮书

    万次阅读 2019-05-16 18:34:55
    Polkadot:畅想一种异构的多架构 草案1 Gavin Wood博士 以太坊&Parity 创始人 GAVIN@PARITY.IO 摘要:现有的区块链架构都存在诸多问题,不仅仅是从实用性角度所说的扩展性(extensibilty)和伸缩性...
  • 供应金融三大类模式

    万次阅读 2018-07-23 23:17:09
    供应金融可以解决中小企业供应中资金分配的不平衡问题,打通上下游物流、资金、商流、信息流,提升整个供应的群体竞争力。因此,供应金融,备受中小企业青睐。在“供应金融——电商企业——实体小微...
  • 区块链,供应金融的新机遇

    千次阅读 2017-10-31 17:48:50
    由于交易双方都是个体,相互之间很难产生信任关系,进而导致了巨大的“信用成本”。因为这种不信任,很难做到实时的交易交割。比如,一家公司和供应商签订合作关系,必须有1到6个月的账期,不可能货到付款。为了给...
  • Web网站通知系统设计

    千次阅读 2014-07-25 09:40:45
    写在前面: 通知系统是网站信息传播机制的重要的一部分,足够写一大章来说明。本文只梳理设计原则,后续相关内容会持续更新。 这里的通知包括但不限于公告、提醒或消息(不同使用场景下的功能定义不同)。 关于各...
  • DApp公选择需要考虑的问题

    千次阅读 2019-01-07 11:03:05
    DApp的运行基于所属公的共识机制、合约规范,DApp的代码和数据是数据的一部分。 不用担心DApp因为某个服务器奔溃而无法使用,也不用担心会被篡改逻辑和数据。实际上,DApp并不仅仅限于智能合约,而是包括智能...
  • 供应金融深度解析

    千次阅读 2017-11-10 15:29:26
    供应金融是基于真实的交易背景开展的金融活动,实质是帮助内成员盘活流动资产。国内供应金融业务倾向性:预付类>应收类>存货类。预付类产品改善了核心企业的财务报表,加速了资金回笼,并将企业间的商业信用...
  • 安卓5.0通知遇到的问题及原因

    千次阅读 2015-11-11 10:20:54
    首先是发送普通通知的一段代码。 public void send(String string) { NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this); mBuilder.setContentTitle("标题");// 设置通知栏...
  • O2O供应系统架构设计

    千次阅读 2016-12-16 09:54:06
    英国知名供应专家Martin Christopher曾经说过一句非常深刻的话:“21世纪的竞争不是企业和企业之间的竞争,而是供应和供应之间的竞争。” 1 什么是供应 在风云变幻、寡头纷争的O2O战场,美团屡出重拳...
  • 很多公司,除了自营商城以外,还有其它渠道(如天猫、京东等),多个渠道的订单该如何集中履约?订单履约全流程是怎样的?... 小Q:某医药互联网公司后台产品经理,着手规划重构公司的供应及电商后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 154,739
精华内容 61,895
关键字:

产生通知链信息