一种细粒度资源锁的内核模块实现

已于 2024-06-09 14:38:42 修改
阅读量304 收藏 1
点赞数 2
分类专栏： Linux 嵌入式系统 文件系统 文章标签： linux
于 2023-07-02 18:57:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tugouxp/article/details/131503938
版权
嵌入式系统 同时被 3 个专栏收录
355 篇文章 58 订阅
订阅专栏
Linux
217 篇文章 30 订阅
订阅专栏
文件系统
5 篇文章 0 订阅
订阅专栏

参考Linux内核细粒度锁同步的核心实现的内核代码如下，为每个资源的每个功能建立一把锁，可以用于各类资源的保护和同步。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/stat.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/pid.h>
#include <linux/version.h>
#include <linux/kthread.h>
#include <linux/sched/signal.h>

#define RES_WAIT_TABLE_BITS 5
#define RES_WAIT_TABLE_SIZE (1 << RES_WAIT_TABLE_BITS)
struct res_def {
	unsigned long flags;
	void *private;
	atomic_t refcount;
};

enum behavior {
	EXCLUSIVE,
	SHARED,
};

struct wait_res_queue {
	struct res_def *res;
	int bit_nr;
	wait_queue_entry_t wait;
};

struct wait_res_key {
	struct res_def *res;
	int bit_nr;
	int res_match;
};

static wait_queue_head_t res_wait_table[RES_WAIT_TABLE_SIZE] __cacheline_aligned;
static wait_queue_head_t *res_waitqueue(struct res_def *res)
{
	// hash code val * GOLDEN_RATIO_64 >> (64 - bits);
	return &res_wait_table[hash_ptr(res, RES_WAIT_TABLE_BITS)];
}

int res_lock_init(void)
{
	int i;

	for (i = 0; i < RES_WAIT_TABLE_SIZE; i ++) {
		init_waitqueue_head(&res_wait_table[i]);
	}

	return 0;
}

static int wake_res_function(wait_queue_entry_t *wait, unsigned mode, int sync, void *arg)
{
	struct wait_res_key *key = arg;
	struct wait_res_queue *wait_res
	        = container_of(wait, struct wait_res_queue, wait);

	if (wait_res->res != key->res) {
		return 0;
	}

	key->res_match = 1;

	if (wait_res->bit_nr != key->bit_nr) {
		return 0;
	}

	if (test_bit(key->bit_nr, &key->res->flags)) {
		return -1;
	}

	return autoremove_wake_function(wait, mode, sync, key);
}

static int wait_on_res_bit_common(wait_queue_head_t *q,
                                  struct res_def *res, int bit_nr, int state, enum behavior behavior)
{
	struct wait_res_queue wait_res;
	wait_queue_entry_t *wait = &wait_res.wait;
	bool bit_is_set;
	int ret = 0;

	init_wait(wait);
	wait->flags = behavior == EXCLUSIVE ? WQ_FLAG_EXCLUSIVE : 0;
	wait->func = wake_res_function;
	wait_res.res = res;
	wait_res.bit_nr = bit_nr;

	for (;;) {
		spin_lock_irq(&q->lock);
		if (likely(list_empty(&wait->entry))) {
			__add_wait_queue_entry_tail(q, wait);
			atomic_set(&res->refcount, 1);
		}

		set_current_state(state);
		spin_unlock_irq(&q->lock);

		bit_is_set = test_bit(bit_nr, &res->flags);;
		if (likely(bit_is_set)) {
			schedule();
		}

		if (behavior == EXCLUSIVE) {
			if (!test_and_set_bit_lock(bit_nr, &res->flags)) {
				break;
			}
		} else if (behavior == SHARED) {
			if (!test_bit(bit_nr, &res->flags)) {
				break;
			}
		}

		if (signal_pending_state(state, current)) {
			ret = -EINTR;
			break;
		}
	}

	finish_wait(q, wait);

	return ret;
}

void lock_res(struct res_def *res, int bit_nr)
{
	wait_queue_head_t *q = res_waitqueue(res);
	wait_on_res_bit_common(q, res, bit_nr, TASK_UNINTERRUPTIBLE,
	                       EXCLUSIVE);
}

static void wake_up_res_bit(struct res_def *res, int bit_nr)
{
	wait_queue_head_t *q = res_waitqueue(res);
	struct wait_res_key key;
	wait_queue_entry_t bookmark;
	unsigned long flags;

	key.res = res;
	key.bit_nr = bit_nr;
	key.res_match = 0;

	bookmark.flags = 0;
	bookmark.private = NULL;
	bookmark.func = NULL;
	INIT_LIST_HEAD(&bookmark.entry);

	spin_lock_irqsave(&q->lock, flags);
	__wake_up_locked_key_bookmark(q, TASK_NORMAL, &key, &bookmark);

	while (bookmark.flags & WQ_FLAG_BOOKMARK) {
		spin_unlock_irqrestore(&q->lock, flags);
		cpu_relax();
		spin_lock_irqsave(&q->lock, flags);
		__wake_up_locked_key_bookmark(q, TASK_NORMAL, &key, &bookmark);
	}

	if (!waitqueue_active(q) || !key.res_match) {
		atomic_set(&res->refcount, 1);
	}

	spin_unlock_irqrestore(&q->lock, flags);
}

void unlock_res(struct res_def *res, int bit_nr)
{
	clear_bit_unlock(bit_nr, &res->flags);
	if (atomic_read(&res->refcount)) {
		wake_up_res_bit(res, bit_nr);
	}

}

#define LOCK_RES_NUM 100

struct lock_res_args {
	struct completion *sync;
	struct res_def *res;
};

static int locker_res_task1(void *data)
{
	struct lock_res_args *args = (struct lock_res_args *)data;
	struct completion *done = args->sync;
	struct res_def *res = args->res;
	int i, j;

	for (i = 0; i < LOCK_RES_NUM; i ++) {
		for (j = 0; j < 64; j ++) {
			lock_res(&res[i], j);
			pr_err("%s line %d, lock res %d, bit %d.\n", __func__, __LINE__, i, j);
		}
	}

	for (i = 0; i < LOCK_RES_NUM; i ++) {
		for (j = 0; j < 64; j ++) {
			unlock_res(&res[i], j);
			pr_err("%s line %d, unlock res %d, bit %d.\n", __func__, __LINE__, i, j);
		}
	}

	complete(done);
	printk("%s line %d, test success.\n", __func__, __LINE__);
	return 0;
}

static int locker_res_task2(void *data)
{
	struct lock_res_args *args = (struct lock_res_args *)data;
	struct completion *done = args->sync;
	struct res_def *res = args->res;
	int i, j;

	for (i = 0; i < LOCK_RES_NUM; i ++) {
		for (j = 0; j < 64; j ++) {
			lock_res(&res[i], j);
			pr_err("%s line %d, lock res %d, bit %d.\n", __func__, __LINE__, i, j);
		}
	}

	for (i = 0; i < LOCK_RES_NUM; i ++) {
		for (j = 0; j < 64; j ++) {
			unlock_res(&res[i], j);
			pr_err("%s line %d, unlock res %d, bit %d.\n", __func__, __LINE__, i, j);
		}
	}

	complete(done);
	printk("%s line %d, test success.\n", __func__, __LINE__);
	return 0;
}

int lock_res_test(void)
{
	struct task_struct *task1, *task2;
	struct lock_res_args args1, args2;

	DECLARE_COMPLETION_ONSTACK(done1);
	DECLARE_COMPLETION_ONSTACK(done2);

	struct res_def *res = kzalloc(sizeof(*res) * LOCK_RES_NUM, GFP_KERNEL);
	if (res == NULL) {
		pr_err("%s line %d, kmalloc res obj failure.\n", __func__, __LINE__);
		return -1;
	}

	res_lock_init();

	args1.res = args2.res = res;
	args1.sync = &done1;
	args2.sync = &done2;

	lock_res(&res[0], 2);
	printk("%s line %d, lock res bit 2.\n", __func__, __LINE__);
	lock_res(&res[0], 1);
	printk("%s line %d, lock res bit 1.\n", __func__, __LINE__);

	unlock_res(&res[0], 2);
	printk("%s line %d, unlock res bit 2.\n", __func__, __LINE__);

	unlock_res(&res[0], 1);
	printk("%s line %d, unlock res bit 1.\n", __func__, __LINE__);

	task1 = kthread_run(locker_res_task1, &args1, "locker1");
	if (IS_ERR(task1)) {
		printk(KERN_ERR "seqfile: unable to create kernel thread: %ld\n",
		       PTR_ERR(task1));
		return PTR_ERR(task1);
	}

	task2 = kthread_run(locker_res_task2, &args2, "locker2");
	if (IS_ERR(task2)) {
		printk(KERN_ERR "seqfile: unable to create kernel thread: %ld\n",
		       PTR_ERR(task2));
		return PTR_ERR(task2);
	}

	wait_for_completion(&done1);
	wait_for_completion(&done2);

	kfree(&res[0]);

	return 0;
}

static int run_work(void *data)
{
	lock_res_test();

	return 0;
}

static int lock_init(void)
{
	struct task_struct *task;
	task = kthread_run(run_work, NULL, "test_work");
	if (IS_ERR(task)) {
		printk(KERN_ERR "unable to create kernel thread: %ld\n",
		       PTR_ERR(task));
		return PTR_ERR(task);
	}

	return 0;
}

static void lock_exit(void)
{
	printk("%s line %d, moule unloading!\n", __func__, __LINE__);
}

module_init(lock_init);
module_exit(lock_exit);
MODULE_AUTHOR("zlcao");
MODULE_LICENSE("GPL");

Makefile

ifneq ($(KERNELRELEASE),)
obj-m:=lockres.o
else
KERNELDIR:=/lib/modules/$(shell uname -r)/build
PWD:=$(shell pwd)
all:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
 
clean:
	rm -rf *.o *.mod.c *.mod.o *.ko *.symvers *.mod .*.cmd *.order
format:
	astyle --options=linux.astyle *.[ch]
endif

模块中生成了100个资源，每个资源有64把锁，一共有6400把锁用于同步实现逻辑中的各种状态，创建两个内核线程，分别获取和释放这6400把锁。

测试结果

这是一个通用逻辑，内核中有很多资源用这种细粒度的方式进行保护，比如page对象，磁盘读写请求BIO,buffer_head等等。

上面的代码经过重构，两个测试线程函数可以合并为一个

#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/stat.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/pid.h>
#include <linux/version.h>
#include <linux/kthread.h>
#include <linux/sched/signal.h>

#define RES_WAIT_TABLE_BITS 5
#define RES_WAIT_TABLE_SIZE (1 << RES_WAIT_TABLE_BITS)
struct res_def {
	unsigned long flags;
	void *private;
	atomic_t refcount;
};

enum behavior {
	EXCLUSIVE,
	SHARED,
};

struct wait_res_queue {
	struct res_def *res;
	int bit_nr;
	wait_queue_entry_t wait;
};

struct wait_res_key {
	struct res_def *res;
	int bit_nr;
	int res_match;
};

static wait_queue_head_t res_wait_table[RES_WAIT_TABLE_SIZE] __cacheline_aligned;
static wait_queue_head_t *res_waitqueue(struct res_def *res)
{
	// hash code val * GOLDEN_RATIO_64 >> (64 - bits);
	return &res_wait_table[hash_ptr(res, RES_WAIT_TABLE_BITS)];
}

int res_lock_init(void)
{
	int i;

	for (i = 0; i < RES_WAIT_TABLE_SIZE; i ++) {
		init_waitqueue_head(&res_wait_table[i]);
	}

	return 0;
}

static int wake_res_function(wait_queue_entry_t *wait, unsigned mode, int sync, void *arg)
{
	struct wait_res_key *key = arg;
	struct wait_res_queue *wait_res
	        = container_of(wait, struct wait_res_queue, wait);

	if (wait_res->res != key->res) {
		return 0;
	}

	key->res_match = 1;

	if (wait_res->bit_nr != key->bit_nr) {
		return 0;
	}

	if (test_bit(key->bit_nr, &key->res->flags)) {
		return -1;
	}

	return autoremove_wake_function(wait, mode, sync, key);
}

static int wait_on_res_bit_common(wait_queue_head_t *q,
                                  struct res_def *res, int bit_nr, int state, enum behavior behavior)
{
	struct wait_res_queue wait_res;
	wait_queue_entry_t *wait = &wait_res.wait;
	bool bit_is_set;
	int ret = 0;

	init_wait(wait);
	wait->flags = behavior == EXCLUSIVE ? WQ_FLAG_EXCLUSIVE : 0;
	wait->func = wake_res_function;
	wait_res.res = res;
	wait_res.bit_nr = bit_nr;

	for (;;) {
		spin_lock_irq(&q->lock);
		if (likely(list_empty(&wait->entry))) {
			__add_wait_queue_entry_tail(q, wait);
			atomic_set(&res->refcount, 1);
		}

		set_current_state(state);
		spin_unlock_irq(&q->lock);

		bit_is_set = test_bit(bit_nr, &res->flags);;
		if (likely(bit_is_set)) {
			schedule();
		}

		if (behavior == EXCLUSIVE) {
			if (!test_and_set_bit_lock(bit_nr, &res->flags)) {
				break;
			}
		} else if (behavior == SHARED) {
			if (!test_bit(bit_nr, &res->flags)) {
				break;
			}
		}

		if (signal_pending_state(state, current)) {
			ret = -EINTR;
			break;
		}
	}

	finish_wait(q, wait);

	return ret;
}

void lock_res(struct res_def *res, int bit_nr)
{
	wait_queue_head_t *q = res_waitqueue(res);
	wait_on_res_bit_common(q, res, bit_nr, TASK_UNINTERRUPTIBLE,
	                       EXCLUSIVE);
}

static void wake_up_res_bit(struct res_def *res, int bit_nr)
{
	wait_queue_head_t *q = res_waitqueue(res);
	struct wait_res_key key;
	wait_queue_entry_t bookmark;
	unsigned long flags;

	key.res = res;
	key.bit_nr = bit_nr;
	key.res_match = 0;

	bookmark.flags = 0;
	bookmark.private = NULL;
	bookmark.func = NULL;
	INIT_LIST_HEAD(&bookmark.entry);

	spin_lock_irqsave(&q->lock, flags);
	__wake_up_locked_key_bookmark(q, TASK_NORMAL, &key, &bookmark);

	while (bookmark.flags & WQ_FLAG_BOOKMARK) {
		spin_unlock_irqrestore(&q->lock, flags);
		cpu_relax();
		spin_lock_irqsave(&q->lock, flags);
		__wake_up_locked_key_bookmark(q, TASK_NORMAL, &key, &bookmark);
	}

	if (!waitqueue_active(q) || !key.res_match) {
		atomic_set(&res->refcount, 1);
	}

	spin_unlock_irqrestore(&q->lock, flags);
}

void unlock_res(struct res_def *res, int bit_nr)
{
	clear_bit_unlock(bit_nr, &res->flags);
	if (atomic_read(&res->refcount)) {
		wake_up_res_bit(res, bit_nr);
	}

}

#define LOCK_RES_NUM 100

struct lock_res_args {
	struct completion *sync;
	struct res_def *res;
};

static int locker_res_task1(void *data)
{
	struct lock_res_args *args = (struct lock_res_args *)data;
	struct completion *done = args->sync;
	struct res_def *res = args->res;
	int i, j;

	for (i = 0; i < LOCK_RES_NUM; i ++) {
		for (j = 0; j < 64; j ++) {
			lock_res(&res[i], j);
			pr_err("%s line %d, lock res %d, bit %d.\n", __func__, __LINE__, i, j);
		}
	}

	for (i = 0; i < LOCK_RES_NUM; i ++) {
		for (j = 0; j < 64; j ++) {
			unlock_res(&res[i], j);
			pr_err("%s line %d, unlock res %d, bit %d.\n", __func__, __LINE__, i, j);
		}
	}

	complete(done);
	printk("%s line %d, test success.\n", __func__, __LINE__);
	return 0;
}

static int __maybe_unused locker_res_task2(void *data)
{
	struct lock_res_args *args = (struct lock_res_args *)data;
	struct completion *done = args->sync;
	struct res_def *res = args->res;
	int i, j;

	for (i = 0; i < LOCK_RES_NUM; i ++) {
		for (j = 0; j < 64; j ++) {
			lock_res(&res[i], j);
			pr_err("%s line %d, lock res %d, bit %d.\n", __func__, __LINE__, i, j);
		}
	}

	for (i = 0; i < LOCK_RES_NUM; i ++) {
		for (j = 0; j < 64; j ++) {
			unlock_res(&res[i], j);
			pr_err("%s line %d, unlock res %d, bit %d.\n", __func__, __LINE__, i, j);
		}
	}

	complete(done);
	printk("%s line %d, test success.\n", __func__, __LINE__);
	return 0;
}

int lock_res_test(void)
{
	struct task_struct *task1, *task2;
	struct lock_res_args args1, args2;

	DECLARE_COMPLETION_ONSTACK(done1);
	DECLARE_COMPLETION_ONSTACK(done2);

	struct res_def *res = kzalloc(sizeof(*res) * LOCK_RES_NUM, GFP_KERNEL);
	if (res == NULL) {
		pr_err("%s line %d, kmalloc res obj failure.\n", __func__, __LINE__);
		return -1;
	}

	res_lock_init();

	args1.res = args2.res = res;
	args1.sync = &done1;
	args2.sync = &done2;

	lock_res(&res[0], 2);
	printk("%s line %d, lock res bit 2.\n", __func__, __LINE__);
	lock_res(&res[0], 1);
	printk("%s line %d, lock res bit 1.\n", __func__, __LINE__);

	unlock_res(&res[0], 2);
	printk("%s line %d, unlock res bit 2.\n", __func__, __LINE__);

	unlock_res(&res[0], 1);
	printk("%s line %d, unlock res bit 1.\n", __func__, __LINE__);

	task1 = kthread_run(locker_res_task1, &args1, "locker1");
	if (IS_ERR(task1)) {
		printk(KERN_ERR "seqfile: unable to create kernel thread: %ld\n",
		       PTR_ERR(task1));
		return PTR_ERR(task1);
	}

	task2 = kthread_run(locker_res_task1, &args2, "locker2");
	if (IS_ERR(task2)) {
		printk(KERN_ERR "seqfile: unable to create kernel thread: %ld\n",
		       PTR_ERR(task2));
		return PTR_ERR(task2);
	}

	wait_for_completion(&done1);
	wait_for_completion(&done2);

	kfree(&res[0]);

	return 0;
}

static int run_work(void *data)
{
	lock_res_test();

	return 0;
}

static int lock_init(void)
{
	struct task_struct *task;
	task = kthread_run(run_work, NULL, "test_work");
	if (IS_ERR(task)) {
		printk(KERN_ERR "unable to create kernel thread: %ld\n",
		       PTR_ERR(task));
		return PTR_ERR(task);
	}

	return 0;
}

static void lock_exit(void)
{
	printk("%s line %d, moule unloading!\n", __func__, __LINE__);
}

module_init(lock_init);
module_exit(lock_exit);
MODULE_AUTHOR("zlcao");
MODULE_LICENSE("GPL");

总结：

本实现参考内核模块中的lock_page/unlock_page以及wait_bit实现,以LOCK PAGE为例，struct page数据结构中的成员flags定义了一个标志位PG_locked,内核通常利用PG_locked来设置一个页锁，lock_page函数用于申请页锁，如果页锁被其他进程占用了，那么进程会睡眠等待。

结束

papaofdoudou
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
细粒度图像分割 (FGIS)
小白学视觉
11-13 1590
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达如今，照片逼真的编辑需要仔细处理自然场景中经常出现的颜色混合，这些颜色混合通常通过场景或对象颜色的软选择来建模。因此，...
在CNN中学习一个鉴别过滤库进行细粒度识别Learning a Discriminative Filter Bank within a CNN for Fine-grained Recognition
Nyte2018的博客
07-15 1633
这次翻译的论文也是CVPR2018的，关于细粒度识别的论文，链接为：http://openaccess.thecvf.com/content_cvpr_2018/papers/Wang_Learning_a_Discriminative_CVPR_2018_paper.pdf 摘要 与之前使用CNN特征的多级框架相比，最近的端到端的细粒度识别深度方法本质上提高了CNNs的中间层mid-level的...
通过浪潮AIStation实现细粒度高性能的GPU资源共享
CSDN云计算
04-12 2939
作者 | 张荣国 供稿 | 浪潮 GPU（Graphics Processing Unit），即图形处理器，是一种由大量核心组成的大规模并行计算架构，专为同时处理多重任务而设计。GPU在大规模并行运算上具有巨大优势，为大数据、人工智能训练和推理任务以及图像渲染等场景提供了显著的计算性能加速支持，但在实际使用中会产生资源管理困难、利用率低等问题。AIStation是浪潮推出的一款人工智能开发平台，可实现GPU资源的精细化调度。本文将重点介绍浪潮AIStation推理平台的GPU共享技术能力和应用场景。
Flink 细粒度资源管理新特性解读
微信搜：import_bigdata，大数据领域硬核原创作者
04-20 509
点击上方蓝色字体，选择“设为星标”回复"面试"获取更多惊喜八股文教给我，你们专心刷题和面试Hi，我是王知无，一个大数据领域的原创作者。放心关注我，获取更多行业的一手消息。ApacheFlink努力为所有现成的应用程序自动导出合理的默认资源需求。对于希望根据特定场景的知识微调资源消耗的用户，Flink提供细粒度资源管理。一、可能受益于细粒度资源管理的典型场景包括 1、任务具...
Mesos—一个细粒度的资源共享调度平台
NewB20143864的博客
01-31 1215
文章目录一个细粒度的资源共享调度平台——Mesos背景基本架构工作原理设计要点 一个细粒度的资源共享调度平台——Mesos Mesos是一个应用于大型云计算中心的系统资源调度系统。在大数据与云计算中心，都部署着大规模的计算机集群，并对外提供各种各样的服务与应用，这些形式多样、需求各异的服务与应用通常依赖特定的计算框架（Hadoop，Spark，Flink，MPI…）来完成计算任务。而Mesos则是...
AKEN（细粒度图像分类）
最新发布
weixin_45409613的博客
05-18 1010
本周阅读了 Attentional Kernel Encoding Networks forFine-Grained Visual Categorization 这篇文章，在本文中，作者提出了用于细粒度视觉分类的注意力核编码网络（AKEN）。AKEN 聚合来自 ConvNets 最后一个卷积层的特征图，以获得整体特征表示。通过傅里叶嵌入，它对纵向和横向的特征进行编码，很大程度上保留了空间布局信息。
细粒度分类：ACNet（Attention Convolutional Binary Neural Tree）
DaZheng121的博客
05-06 2355
文章目录前言摘要一、简介二、相关工作三、Attention Convolutional Binary Neural Tree3.1 ArchitectureBackbone network moduleBranch routing moduleAttention transformerLabel prediction3.2 TrainingData augmentationLoss functionOptimization四、实验五、结论其他 前言 本文主要介绍 Attention Convolution
Linux 内核裁剪框架初探
我相信......
07-15 1619
大约是在2000年的时候，老码农还很年轻，当时希望将Linux 作为手机的操作系统，于是才有了进行内核裁剪的想法并辅助实践，效果尚好，已经能在PDA上执行手机的功能了。一晃20多年过去了，Linux 已经有了太大的变化，内核裁剪的技术和方式也有了较大的不同。Linux 的内核裁剪是为了减少目标应用中不需要的内核代码，在安全性和高性能(快速启动时间和减少内存占用)方面有着...
AMD GPU 内核驱动分析(一)总览
tugouxp的专栏
09-11 3820
和CPU相比，GPU中包含了大量的并行计算单元，适合处理像素，矩阵，坐标等大量同类型的数据，因此，很多LINUX上的应用程序为了能够利用GPU的加速功能，都试图和GPU直接打交道，因此，系统中可能有多个组件或者程序同时使用GPU，比如桌面系统中OpenGL的实现MESA。
4.内核中的锁
wangdapao12138的博客
08-26 1103
1.为什么要加锁？ 假设我们需要处理一个队列上的所有请求。我们假定该队列通过链表得以实现，链表中每个节点就代表一个请求。有两个函数来操作此队列：一个函数将新请求添加到队列尾部，另一个函数从队列头删除请求，然后处理它。内核各个部分都会调用这两个函数，所以内核会不断地在队列中加入请求，从队列中删除和处理请求。对请求队列的操作无疑要用到多条指令。如果一个线程试图读取队列，而这时正好另一个线程正在处理该...
Linux内核设计与实现(第2版)
10-09
- **SELinux**：基于安全增强的Linux，提供细粒度的访问控制机制，增强了系统的安全性。 - **AppArmor**：通过路径名和文件类型定义安全策略，限制应用程序的权限。 #### 7. 调试与性能优化 - **gdb**：GNU调试器，...
Linux安全模块实现的研究.pdf
09-06
以SELinux为例，它是在2001年提出的，实现了细粒度的强制访问控制（MAC），起初是作为内核补丁实现的。然而，这种补丁形式的解决方案并不理想，因为它需要对内核进行频繁的修改。LSM的引入解决了这个问题，使得如...
Linux内核的实时支持的研究与实现
04-30
本文探讨了如何通过改进Linux内核的关键组件——中断控制、实时调度策略、内核抢占机制以及细粒度定时器等方面，来增强Linux内核的实时特性。这些改进措施旨在将Linux内核转变为一个能够满足实时应用需求的操作系统...
Linux可加载内核模块LKM机制安全性研究.pdf
09-06
2. **基于capabilities的能力机制**：capabilities是一种将传统root权限分解为多个更细粒度权限的方法。通过限制LKM的权限，可以降低攻击面，防止模块滥用权限。 3. **加密模块技术**：通过对LKM进行加密，可以在...
灵活且可扩展的内核亲和锁
03-10
内核亲和锁是一种在操作系统内核中使用的同步机制，它能够提高多处理器计算机系统（特别是NUMA架构的系统）中多线程程序的性能。NUMA（Non-Uniform Memory Access）系统中，内存访问时间依赖于处理单元与内存模块...
使用OpenCV识别二维码
热门推荐
tugouxp的专栏
09-12 1万+
程序： # -*-coding:utf-8 -*- import cv2 as cv import numpy as np # 加载图片 src_image = cv.imread("./webwxgetmsgimg.jpeg") # 实例化 qrcoder = cv.QRCodeDetector() # qr检测并解码 codeinfo, points, straight_qrcode = qrcoder.detectAndDecode(src_image) # 绘制qr的检测结果 cv.dr
不同函数的梯度图像
tugouxp的专栏
08-29 1万+
1. 函数图像为： 梯度图像： 2. 三维图像： 梯度图像： 3.z=x+y 三维图像 梯度图像： 3. 梯度图 结束！
cuda-z/gpu-z/cpu-z工具分析GPU显卡和CPU算力信息
tugouxp的专栏
02-06 9575
类似于Windows下使用CPU-Z工具查看CPU信息，Linux下也可以使用CUDA-Z工具来查看显卡资源/支持信息。
RISCV-OpenSBI 主流程分析与总结
tugouxp的专栏
08-11 9056
OpenSBI的简要分析：
Android内核详解：底层架构与移植策略
3. Linux权限控制：Android内核实现了细粒度的权限管理，确保了用户数据的安全和隐私，这是Android系统安全模型的核心部分。 4. 驱动程序和硬件适配：由于Android支持多种硬件设备，文档可能会涉及如何编写和维护...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

papaofdoudou

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值