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

最新推荐文章于 2023-03-05 17:33:34 发布
最新推荐文章于 2023-03-05 17:33:34 发布
阅读量1k 收藏 3
点赞数 1
分类专栏： linux开发 文章标签： struct system module null semaphore linux内核

这篇文章是对以下两位博主的文章进行了简单整理转载引用，备忘。非常感谢两位的分享。

http://my.chinaunix.net/space.php?uid=25445243&do=blog&id=212959

http://yfydz.cublog.cn

 

一、概念：

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

二、数据结构：

通知链有四种类型：

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

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

  1.  
  2. 可阻塞通知链（ Blocking notifier chains ）：通知链元素的回调函数在进程上下文中运行，允许阻塞。对应的链表头：

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

  1.  
  2. 原始通知链（ Raw notifier chains ）：对通知链元素的回调函数没有任何限制，所有锁和保护机制都由调用者维护。对应的链表头：

struct raw_notifier_head
{
    struct notifier_block *head;
};

  1.  
  2. 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这种形式的变量名。

三、运作机制：

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

  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_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");




static RAW_NOTIFIER_HEAD(test_chain);


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


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


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


static struct notifier_block test_notifier1 =
{
    .notifier_call = test_event1,
};


static struct notifier_block test_notifier2 =
{
    .notifier_call = test_event2,
};


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");

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

 

 

附：

以下是一些宏来初始化各种类型的通知头结构, 一般在程序中使用:

#define ATOMIC_INIT_NOTIFIER_HEAD(name) do { \
  spin_lock_init(&(name)->lock); \
  (name)->head = NULL;  \
 } while (0)

#define BLOCKING_INIT_NOTIFIER_HEAD(name) do { \
  init_rwsem(&(name)->rwsem); \
  (name)->head = NULL;  \
 } while (0)

#define RAW_INIT_NOTIFIER_HEAD(name) do { \
  (name)->head = NULL;  \
 } while (0)

 

以下这些宏也是用来初始化各种类型的通知头结构, 但是在参数定义时使用（即作为赋值的右半部分，作为等号右边的部分）:

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

注意, 没有定义scru通知头结构的初始化, 因为scru是不能静态初始化的.

 

以下这些宏用来直接定义通知头结构:

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

 

4. 扩展的通知块操作


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


4.1 原子通知块


4.1.1 登记

 

 

// 只是在基本通知登记操作前后加锁解锁进行保护
int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
  struct notifier_block *n)
{
 unsigned long flags;
 int ret;

// 加锁
 spin_lock_irqsave(&nh->lock, flags);
 ret = notifier_chain_register(&nh->head, n);
// 解锁
 spin_unlock_irqrestore(&nh->lock, flags);
 return ret;
}

EXPORT_SYMBOL_GPL(atomic_notifier_chain_register);


4.1.2 撤销


// 只是在基本通知块撤销操作前后加锁解锁进行保护
int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
  struct notifier_block *n)
{
 unsigned long flags;
 int ret;
// 加锁
 spin_lock_irqsave(&nh->lock, flags);
 ret = notifier_chain_unregister(&nh->head, n);
// 解锁
 spin_unlock_irqrestore(&nh->lock, flags);
// 同步rcu, 等待一个grace period
 synchronize_rcu();
 return ret;
}

EXPORT_SYMBOL_GPL(atomic_notifier_chain_unregister);


4.1.3 原子回调


这个函数是在原子操作上下文中调用, 是不能阻塞的
 
int __kprobes atomic_notifier_call_chain(struct atomic_notifier_head *nh,
  unsigned long val, void *v)
{
 int ret;

// 禁止了抢占
 rcu_read_lock();
// 使用基本通知块回调
 ret = notifier_call_chain(&nh->head, val, v);
// 允许抢占
 rcu_read_unlock();
 return ret;
}

EXPORT_SYMBOL_GPL(atomic_notifier_call_chain);


4.2 可阻塞通知块


4.2.1 登记

int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
  struct notifier_block *n)
{
 int ret;

 
// 这是内核启动时就进行调用了, 虽然可能性很小, 直接执行基本登记函数
// 不用处理信号灯, 因为此时是不能阻塞
 if (unlikely(system_state == SYSTEM_BOOTING))
  return notifier_chain_register(&nh->head, n);
// 使用信号灯进行同步, 可能阻塞
 down_write(&nh->rwsem);
// 基本登记函数
 ret = notifier_chain_register(&nh->head, n);
 up_write(&nh->rwsem);
 return ret;
}

EXPORT_SYMBOL_GPL(blocking_notifier_chain_register);


4.2.2 撤销

该函数是在进程处理过程中调用,可阻塞:

int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
  struct notifier_block *n)
{
 int ret;

 
// 这是内核启动时就进行调用了, 虽然可能性很小, 直接执行基本撤销函数
// 不用处理信号灯, 因为此时是不能阻塞
 if (unlikely(system_state == SYSTEM_BOOTING))
  return notifier_chain_unregister(&nh->head, n);

// 使用信号灯进行同步, 可能阻塞
 down_write(&nh->rwsem);
// 基本撤销函数
 ret = notifier_chain_unregister(&nh->head, n);
 up_write(&nh->rwsem);
 return ret;
}

EXPORT_SYMBOL_GPL(blocking_notifier_chain_unregister);


4.2.3 回调


在进行上下文中调用, 可以阻塞:

 
int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
  unsigned long val, void *v)
{
 int ret;
// 信号灯同步
 down_read(&nh->rwsem);
// 进行基本回调处理
 ret = notifier_call_chain(&nh->head, val, v);
 up_read(&nh->rwsem);
 return ret;
}

EXPORT_SYMBOL_GPL(blocking_notifier_call_chain);


4.3 原始通知块操作


和基本原始块操作完全相同:


int raw_notifier_chain_register(struct raw_notifier_head *nh,
  struct notifier_block *n)
{
 return notifier_chain_register(&nh->head, n);
}

EXPORT_SYMBOL_GPL(raw_notifier_chain_register);

int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
  struct notifier_block *n)
{
 return notifier_chain_unregister(&nh->head, n);
}

EXPORT_SYMBOL_GPL(raw_notifier_chain_unregister);


int raw_notifier_call_chain(struct raw_notifier_head *nh,
  unsigned long val, void *v)
{
 return notifier_call_chain(&nh->head, val, v);
}

EXPORT_SYMBOL_GPL(raw_notifier_call_chain);


4.4 SRCU通知块操作


4.4.1 登记

必须在进程的上下文中调用, 和blocking通知类似

int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
  struct notifier_block *n)
{
 int ret;

 
 if (unlikely(system_state == SYSTEM_BOOTING))
  return notifier_chain_register(&nh->head, n);

 mutex_lock(&nh->mutex);
 ret = notifier_chain_register(&nh->head, n);
 mutex_unlock(&nh->mutex);
 return ret;
}

EXPORT_SYMBOL_GPL(srcu_notifier_chain_register);


4.4.2 撤销


必须在进程的上下文中调用, 和blocking通知类似

int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
  struct notifier_block *n)
{
 int ret;

 
 if (unlikely(system_state == SYSTEM_BOOTING))
  return notifier_chain_unregister(&nh->head, n);

 mutex_lock(&nh->mutex);
 ret = notifier_chain_unregister(&nh->head, n);
 mutex_unlock(&nh->mutex);
 synchronize_srcu(&nh->srcu);
 return ret;
}

EXPORT_SYMBOL_GPL(srcu_notifier_chain_unregister);


4.4.3 回调


在进程的上下文中调用, 可以阻塞:

int srcu_notifier_call_chain(struct srcu_notifier_head *nh,
  unsigned long val, void *v)
{
 int ret;
 int idx;
// 使用srcu读锁来加锁
 idx = srcu_read_lock(&nh->srcu);
 ret = notifier_call_chain(&nh->head, val, v);
 srcu_read_unlock(&nh->srcu, idx);
 return ret;
}

EXPORT_SYMBOL_GPL(srcu_notifier_call_chain);

4.4.4 初始化

因为SRCU通知不能通过宏来初始化, 必须要专门定义一个初始化函数来初始化srcu的通知块参数:

void srcu_init_notifier_head(struct srcu_notifier_head *nh)
{
// 初始化锁
 mutex_init(&nh->mutex);
// 初始化scru结构
 if (init_srcu_struct(&nh->srcu) < 0)
  BUG();
 nh->head = NULL;
}

EXPORT_SYMBOL_GPL(srcu_init_notifier_head);

adaptiver
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式Linux之我行——内核通知链机制的原理及实现.pdf
09-14
嵌入式Linux之我行——内核通知链机制的原理及实现.pdf嵌入式Linux之我行——内核通知链机制的原理及实现.pdf
Windows内核安全驱动开发(随书光盘)
08-02
第1章 内核上机指导 2 1.1 下载和使用WDK 2 1.1.1 下载并安装WDK 2 1.1.2 编写第一个C文件 4 1.1.3 编译一个工程 5 1.2 安装与运行 6 1.2.1 下载一个安装工具 6 1.2.2 运行与查看输出信息 7 1.2.3 在虚拟机...
鸿蒙驱动框架
lhm的博客
12-21 4693
本文首发于：LHM’s notes 欢迎关注我的新博客 鸿蒙驱动是基于HDF(Harmony Driver Foundation)驱动框架，为开发者提供了一系列统一接口供其调用，包括驱动加载、驱动服务管理和驱动消息机制。我们要做的，是学习如何使用这些接口，并基于这些接口的使用实现某些业务功能。 设备驱动概述 相信每个人都有给电脑安装驱动的经历，驱动的使用就是去某个官网去下载个软件包，然后一路点击安装就行了。这里可以明确一个定义：驱动是一段程序代码。那么设备呢？ 鼠标、键盘、显示器、这些都叫做设备，但是和我们
Java 回调 和 kotlin的回调
u010194271的博客
11-06 1015
函数类型 Kotlin中一切皆是对象，函数也不例外。在Kotlin中，函数本身也是对象，可以拥有类型并实例化。Kotlin 使用类似 (Int) -> String 的一系列函数类型来处理函数的声明，比如我们常见的点击回调函数： val onClick:(View)->Unit={} 生成Person类及MyInterface 接口 class Person { val name:String = "Person" lateinit var mListen:MyIn
read函数头文件 window_Windows系统调用中API的3环部分(依据分析重写ReadProcessMemory函数)...
weixin_39605578的博客
12-29 336
Windows内核分析索引目录：https://www.cnblogs.com/onetrainee/p/11675224.htmlWindows系统调用中API的3环部分一、R3环API分析的重要性Windows所提供给R3环的API，实质就是对操作系统接口的封装，其实现部分都是在R0实现的。很多恶意程序会利用钩子来钩取这些API，从而达到截取内容，修改数据的意图。现在我们使用olldbg对Re...
（八）Knockout 组件 Components
weixin_30955617的博客
05-13 759
概述 ：组件和自定义元素 Components 是将UI代码组织成自包含的、可重用的块的一种强大而干净的方法。他们： …可以表示单个控件/窗口小部件或应用程序的整个部分 …包含它们自己的视图，并且通常(可选地)包含它们自己的视图模型 …可以通过AMD或其他模块系统预加载，也可以(按需)异步加载 …可以接收参数，并选择性地将更改写回参数或调用回调 …可以组合在一起(嵌套)或从其他组件继承 …可以轻...
Linux 下的notifier chain 机制的注册和触发讲解
sunweizhong1024的专栏
09-03 1万+
Linux 下的notifier chain 机制的注册和触发讲解  notifier_chain_register 本文以tegra jack 为例。讲解了notifier_cain   1 概 述 内核许多子系统之间关联紧密，因此在一个子系统发生或者检测到的事件信息很可能对其他子系统来说也是有价值的。为了满足其他子系统对这些事件信息的需求，即在某个子系统内发生或检测到事件时，其他
2022-11-26 linux 通过blocking_notifier_chain_register、blocking_notifier_call_chain 接收温度变化信息控制风扇
海月汐辰
11-26 1016
【代码】2022-11-26 linux 通过blocking_notifier_call_chain 接收温度变化信息控制风扇。
notifier 示例
weixin_44740132的博客
02-18 130
notifier
linux-内核通知链相关（关机、重启通知，kernel-5.10为例）
weixin_39223971的博客
03-05 1621
linux-关机或重启通知链的一些细节
Linux内核基础--事件通知链(notifier chain)
热门推荐
每一天为明天@liitokala
10-16 2万+
内核通知链 1.1. 概述        Linux内核中各个子系统相互依赖，当其中某个子系统状态发生改变时，就必须使用一定的机制告知使用其服务的其他子系统，以便其他子系统采取相应的措施。为满足这样的需求，内核实现了事件通知链机制（notificationchain）。        通知链只能用在各个子系统之间，而不能在内核和用户空间进行事件的通知。组成内核的核心系统代码均位于kernel
linux内核编程-可睡眠锁之SRCU
cajan2的专栏
05-12 2685
linux内核编程-可睡眠锁之SRCU DEFINE_SRCU DEFINE_SRCU_STATIC static修饰的定义只能在该c文件中使用，用于保护命名空间。 如果一个函数里面使用了static，这是相当与一个全局变量，但是他的有效范围只能在该函数内，其他地方不能使用。 /*  * define and init a srcu struct at build ti
Windows内核安全与驱动开发光盘源码
07-11
第1章 内核上机指导 2 1.1 下载和使用WDK 2 1.1.1 下载并安装WDK 2 1.1.2 编写第一个C文件 4 1.1.3 编译一个工程 5 1.2 安装与运行 6 1.2.1 下载一个安装工具 6 1.2.2 运行与查看输出信息 7 1.2.3 在虚拟机...
socket编程原理
11-22
第二章socket 编程原理 2.1 问题的引入 UNIX 系统的 I/O 命令集，是从 Maltics 和早期系统中的命令演变出来的，其模式为打开一读/写一 关闭（open-write-read-close）。在一个用户进程进行 I/O 操作时，它首先调用...
Socket的编程原理的介绍和程序说明
07-07
当所有的传输操作完成后，用户进程关闭调用，通知操作系统已经完成了对某对象的使用。   TCP/IP协议被集成到UNIX内核中时，相当于在UNIX系统引入了一种新型的I/O操作。UNIX用户进程与网络协议的交互作用比...
电力系统调度过程连续潮流matlab代码.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
【基于Java+Springboot的毕业设计】付费问答系统(源码+演示视频+说明).rar
04-26
【基于Java+Springboot的毕业设计】付费问答系统(源码+演示视频+说明).rar 【项目技术】 开发语言：Java 框架：Spingboot+vue 架构：B/S 数据库：mysql 【演示视频-编号：330】 https://pan.quark.cn/s/8dea014f4d36 【实现功能】 付费问答系统通过MySQL数据库与Spring Boot框架进行开发，付费问答系统能够实现新闻类型管理，问题帖子管理，付费记录管理，新闻信息管理，用户管理，轮播图管理等功能。
关于旁路电容和耦合电容-(详细说明)
最新发布
04-26
关于旁路电容和耦合电容-(详细说明)
Git 与 Simulink 测试：远程测试的最佳实践.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
linux信号机制的原理
03-17
它基于操作系统内核提供的信号处理机制，通过向进程发送信号来通知进程发生了某些事件，例如键盘中断、定时器到期、进程异常等。进程可以通过注册信号处理函数来处理这些信号，以便采取适当的措施来应对这些事件。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值