澳门新蒲京娱乐

新蒲京娱乐场777 4
函数实例深入分析新蒲京娱乐场777:
新蒲京娱乐场777 14
十一个甲级的Git,上一流的图形化

【新蒲京娱乐场777】内核通知链机制的原理及实现

三、运作机制:

公告链的运作体制包括三个剧中人物:

  1. 被通告者:对某意气风发平地风波感兴趣一方。定义了当事件发生时,相应的管理函数,即回调函数。但供给事情发生此前将其注册到通报链中(被通告者注册的动作正是在文告链中扩充生机勃勃项)。
  2. 通告者:事件的通告者。当检验到某一件事件,或许本人产惹祸件时,通告全数对该事件感兴趣的一方事件产生。他定义了叁个通告链,个中保存了每二个被公告者对事件的管理函数(回调函数)。文告那么些进程实际上正是遍历公告链中的每黄金时代项,然后调用相应的事件管理函数。

总结以下进度:

  1. 文告者定义公告链。
  2. 被通告者向文告链中注册回调函数。
  3. 当事件产生时,公告者发出通报(实施文告链中全体因素的回调函数)。

被通告者调用 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 函数通告事件的达到,那几个函数会遍历公告链中全体的成分,然后挨门挨户调用每一个的回调函数(即成功通告动作):

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回调函数的重临值恐怕取值为以下多少个:

  1. NOTIFY_DONE:表示对相关的风云类型不爱惜。
  2. NOTIFY_OK:顺遂进行。
  3. NOTIFY_BAD:实行有错。
  4. NOTIFY_新蒲京娱乐场777 ,STOP:甘休奉行后边的回调函数。
  5. NOTIFY_STOP_MASK:停止实行的掩码。

Notifier_call_chain(卡塔尔(قطر‎把最后三个被调用的回调函数的再次来到值作为它的重返值。

四、举例应用:

在这里边,写了四个简约的照顾链表的代码。实际上,整个布告链的编辑也就七个经过:

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

运行(注意insmod要root权限):

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

二、数据构造:

布告链有三种档期的顺序:

1.原子布告链( Atomic notifier chains ):布告链成分的回调函数(当事件爆发时要履行的函数)只好在脚刹踏板的里面下文中运作,差异意堵塞。对应的链表头布局:

struct atomic_notifier_head 
{
    spinlock_t lock;
    struct notifier_block *head;
};

2.可拥塞布告链( Blocking notifier chains ):布告链成分的回调函数在进度上下文中运行,允许窒碍。对应的链表头:

struct blocking_notifier_head 
{
    struct rw_semaphore rwsem;
    struct notifier_block *head;
};

3.原来公告链( Raw notifier chains ):对通报链成分的回调函数未有其他约束,全数锁和保险体制都由调用者维护。对应的链表头:

struct raw_notifier_head 
{
    struct notifier_block *head;
};

4.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这种方式的变量名。

一、概念:

大多内核子系统都以互相独立的,由此有些子系统或然对别的子系统发生的风浪感兴趣。为了满足这么些必要,也便是让某块头系统在发生有个别事件时通报任何的子
系统,Linux内核提供了通知链的机制。通告链表只好够在根底的子系统之间接选举拔,而不可以预知在根本与用户空间之间开展事件的通报。
布告链表是一个函数链表,链表上的每二个节点都登记了三个函数。当有些事情时有发生时,链表上所有节点对应的函数就能够被实行。所以对于通报链表来讲有叁个通报
方与二个接纳方。在通报那几个事件时所运转的函数由被公告方决定,实际上也便是被通告方注册了有些函数,在发生某些事件时这一个函数就赢得推行。其实和系统调
用signal的观念大约。

相关文章

No Comments, Be The First!
近期评论
    功能
    网站地图xml地图