驱动程序中的原子变量、自旋锁、互斥锁mutex的介绍

最新推荐文章于 2024-12-11 18:02:31 发布
最新推荐文章于 2024-12-11 18:02:31 发布
阅读量344 收藏
点赞数 1
文章标签： linux 驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_74936872/article/details/131762779
版权

在介绍这几个概念之前，我们先了解一下上下文

一、上下文和并发场合

执行流：有开始有结束总体顺序执行的一段代码 又称上下文

应用编程：任务上下文 内核编程：

  1. 任务上下文：五状态 可阻塞 a. 应用进程或线程运行在用户空间 b. 应用进程或线程运行在内核空间（通过调用syscall来间接使用内核空间） c. 内核线程始终在内核空间

  2. 异常上下文：不可阻塞 中断上下文

竞态：多任务并行执行时，如果在一个时刻同时操作同一个资源，会引起资源的错乱，这种错乱情形被称为竞态

共享资源：可能会被多个任务同时使用的资源

临界区：操作共享资源的代码段

为了解决竞态，需要提供一种控制机制，来避免在同一时刻使用共享资源，这种机制被称为并发控制机制

并发控制机制分类：

  1. 原子操作类

  2. 忙等待类

  3. 阻塞类

二、原子变量

原子变量：

       存取不可被打断的特殊整型变量，他是一种多线程编程中常用的同步机制，它能够确保对共享变量的操作在执行时不会被其他线程的操作干扰，从而避免竞态条件（race condition）和死锁（deadlock）等问题。原子变量可以看作是一种特殊的类型，它具有类似于普通变量的操作，但是这些操作都是原子级别的，即要么全部完成，要么全部未完成。

在驱动中的一些基本使用函数：   

  a.设置原子量的值

  •  void atomic_set(atomic_t *v,int i); //设置原子量的值为i ，需在驱动初始化中将其打开

   b.获取原子量的值

  • atomic_read(atomic_t *v); //返回原子量的值

   c.原子变量加减

  •  void atomic_add(int i,atomic_t *v);//原子变量增加i
  •  void atomic_sub(int i,atomic_t *v);//原子变量减少i

   d.原子变量自增自减

  •  void atomic_inc(atomic_t *v);//原子变量增加1
  •  void atomic_dec(atomic_t *v);//原子变量减少1

   e.操作并测试：运算后结果为0则返回真，否则返回假

  • int atomic_inc_and_test(atomic_t *v); //返回原子变量自增后的值
  • int atomic_dec_and_test(atomic_t *v);//返回原子变量自减后的值
  • int atomic_sub_and_test(int i,atomic_t *v);//返回原子变量减去i后的值

原子位操作方法：

a.设置位 void set_bit(nr, void *addr); //设置addr的第nr位为1

b.清除位 void clear_bit(nr , void *addr); //清除addr的第nr位为0

c.改变位 void change_bit(nr , void *addr); //改变addr的第nr位为1

d.测试位 void test_bit(nr , void *addr); //测试addr的第nr位是否为1

适用场合：共享资源为单个整型变量的互斥场合

代码展示：在同一时间只能打开一次的代码

#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/fs.h>
#include<linux/cdev.h>
#include<asm/uaccess.h>
#include<asm/atomic.h>
#include<linux/wait.h>
#define BUF_LEN 100
int major = 12;//主设备号
int minor = 0; //次设备号
int openonce_num = 1;//设备数量

struct openonce_dev{
	struct cdev mydev;//自定义字符驱动结构体

	atomic_t openflag;//初始化原子变量的标志位，1为程序能开，0不能开

}pmydev;

int openonce_open(struct inode *pnode,struct file *pfile){
	
	pfile->private_data = (void *)(container_of(pnode->i_cdev,struct openonce_dev,mydev));
	struct openonce_dev *gmydev = NULL;
	gmydev = (struct openonce_dev*)pfile->private_data;

    /*在程序被打开时判断标志位的值，
    因为此函数运算结果为0时返回真，我们设定这个标志位为1时程序可以被打开，
    所以当其自减后的值等于0时表示标志位为1，程序可以被打开，这时标识符的值由1减为0，
    所以之后此程序将不能再被打开，若原来的状态就为不能打开，则函数的运算值0-1=-1返回假，
    就会执行else中的语句，但此时的标志位已经变成了-1而不是我们所设定的判断值0和1
    所以需要执行自增函数使其变回0来继续表示程序无法被打开。*/
	if(atomic_dec_and_test(&gmydev->openflag)){
		return 0;
	}else{
		atomic_inc(&gmydev->openflag);
		printk("can not open\n");
		return -1;
	
	}

}

    //程序结束时只需要将标志位的值设定为可以打开即可
int openonce_close(struct inode *pnode,struct file *pfile){
	struct openonce_dev *gmydev = (struct openonce_dev *)pfile->private_data;
	atomic_set(&gmydev->openflag,1);
	return 0;
}



struct file_operations myops = {
	.owner = THIS_MODULE,//该结构体对象属于哪个内核模块
	.open = openonce_open,//打开设备
	.release = openonce_close,//关闭设备 

};

int __init openonce_init(void){
	/* 将主设备号和次设备号组合成32位完整的设备号*/
	dev_t devno = MKDEV(major,minor);
	int ret = 0;
	//申请设备号，方式为手动申请
	ret = register_chrdev_region(devno,openonce_num,"openonce");
	//手动申请失败则使用动态申请
	if(ret != 0){
		ret = alloc_chrdev_region(&devno,minor,openonce_num,"openonce");
		if(ret != 0){
			printk("get chrdev failed\n");
			return -1;
		}
		major = MAJOR(devno);//自动申请的主设备号需要重新赋值

	}
	
		//给struct cdev对象制定操作函数集
		cdev_init(&pmydev.mydev,&myops);

		//将其添加到内核对应的数据结构里
		pmydev.mydev.owner = THIS_MODULE;
		
		//将指定的字符设备添加到内核中
		cdev_add(&pmydev.mydev,devno,openonce_num);
		
        //将标志位的值初始化为可以打开
		atomic_set(&pmydev.openflag,1);
}

void __exit openonce_exit(void){
	//获取设备的32位设备号
	dev_t devno = MKDEV(major,minor);
	//移除对应的设备
	cdev_del(&pmydev.mydev);
	//将申请的设备号释放
	unregister_chrdev_region(devno,openonce_num);
	
}

module_init(openonce_init);
module_exit(openonce_exit);

三、自旋锁：基于忙等待的并发控制机制

自旋锁：他的机制就是他的名字——自旋，也就是一直在获得自旋锁的位置停留直到他被释放。

a.定义自旋锁 spinlock_t lock;

b.初始化自旋锁 spin_lock_init(spinlock_t *);

c.获得自旋锁 spin_lock(spinlock_t *); //成功获得自旋锁立即返回，否则自旋在那里直到该自旋锁的保持者释放

spin_trylock(spinlock_t *); //成功获得自旋锁立即返回真，否则返回假，而不是像上一个那样"在原地打转”

d.释放自旋锁 spin_unlock(spinlock_t *);

#include <linux/spinlock.h>
定义spinlock_t类型的变量lock
spin_lock_init(&lock)后才能正常使用spinlock
​
​
spin_lock(&lock);
临界区
spin_unlock(&lock);

适用场合：

  1. 异常上下文之间或异常上下文与任务上下文之间共享资源时

  2. 任务上下文之间且临界区执行时间很短时

  3. 互斥问题

用自旋锁实现在同一时间只能被打开一次的程序：

#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/fs.h>
#include<linux/cdev.h>
#include<asm/uaccess.h>
#include<asm/atomic.h>
#include<linux/wait.h>
#define BUF_LEN 100
int major = 12;//主设备号
int minor = 0; //次设备号
int openonce_num = 1;//设备数量

struct openonce_dev{
	struct cdev mydev;//自定义字符驱动结构体

	spinlock_t openflag;

	int oo;//自定义自旋锁的标志位，1能开0不能开

}pmydev;


int openonce_open(struct inode *pnode,struct file *pfile){
	
	pfile->private_data = (void *)(container_of(pnode->i_cdev,struct openonce_dev,mydev));
	struct openonce_dev *gmydev = NULL;
	gmydev = (struct openonce_dev*)pfile->private_data;

    //打开之前上锁，然后判断自定义标志位的值，若能开则将标志位设置为0，不能开则打印提示语句
	spin_lock(&gmydev->openflag);
	if(gmydev->oo){
		spin_unlock(&gmydev->openflag);
		gmydev->oo = 0;
		return 0;
	}else{
		spin_unlock(&gmydev->openflag);
		printk("can not open\n");
		return -1;
	
	}

}
int openonce_close(struct inode *pnode,struct file *pfile){
	struct openonce_dev *gmydev = (struct openonce_dev *)pfile->private_data;
	gmydev->oo = 1;
	spin_unlock(&gmydev->openflag);
	return 0;
}



struct file_operations myops = {
	.owner = THIS_MODULE,//该结构体对象属于哪个内核模块
	.open = openonce_open,//打开设备
	.release = openonce_close,//关闭设备 

};

int __init openonce_init(void){
	/* 将主设备号和次设备号组合成32位完整的设备号*/
	dev_t devno = MKDEV(major,minor);
	int ret = 0;
	//申请设备号，方式为手动申请
	ret = register_chrdev_region(devno,openonce_num,"openonce");
	//手动申请失败则使用动态申请
	if(ret != 0){
		ret = alloc_chrdev_region(&devno,minor,openonce_num,"openonce");
		if(ret != 0){
			printk("get chrdev failed\n");
			return -1;
		}
		major = MAJOR(devno);//自动申请的主设备号需要重新赋值

	}
	
		//给struct cdev对象制定操作函数集
		cdev_init(&pmydev.mydev,&myops);

		//将其添加到内核对应的数据结构里
		pmydev.mydev.owner = THIS_MODULE;
		
		//将指定的字符设备添加到内核中
		cdev_add(&pmydev.mydev,devno,openonce_num);
		
        //初始化自旋锁并将自定义标志位设置为可以打开
		pmydev.oo = 1;
		spin_lock_init(&pmydev.openflag);
}

void __exit openonce_exit(void){
	//获取设备的32位设备号
	dev_t devno = MKDEV(major,minor);
	//移除对应的设备
	cdev_del(&pmydev.mydev);
	//将申请的设备号释放
	unregister_chrdev_region(devno,openonce_num);
	
}

module_init(openonce_init);
module_exit(openonce_exit);

四、互斥锁：基于阻塞的互斥机制

a.初始化

  • 在自定义设备结构体中定义：struct mutex my_mutex
  • 在初始化函数中初始化： mutex_init(&my_mutex);

b.获取互斥体 void mutex_lock(struct mutex *lock);

c.释放互斥体 void mutex_unlock(struct mutex *lock);

  1. 定义对应类型的变量

  2. 初始化对应变量

适用场合：任务上下文之间且临界区执行时间较长时的互斥问题

五、选择并发控制机制的原则

  1. 不允许睡眠的上下文需要采用忙等待类，可以睡眠的上下文可以采用阻塞类。在异常上下文中访问的竞争资源一定采用忙等待类。

  2. 临界区操作较长的应用建议采用阻塞类，临界区很短的操作建议采用忙等待类。

  3. 中断屏蔽仅在有与中断上下文共享资源时使用。

  4. 共享资源仅是一个简单整型量时用原子变量

Linux内核笔记（驱动篇）之 【自旋锁的简单介绍】
哆哆jarvis的博客
02-08 251
自旋锁与互斥锁类似，但是自旋锁不会引起调用者睡眠。如果自旋锁被其他执行单元保持，则调用者会一直循环等待保持者释放锁。想像这么一个场景，早上醒来你要上厕所（临界区），进入该厕所需要一把钥匙（自旋锁），你发现厕所关着，里面有人了（锁被保持了），你敲门申请，在门外一直等待（循环等待，不会挂起睡眠，而互斥锁会），直到里面的人出来，把钥匙给你（保持着释放锁，你获得锁），进入厕所。自旋锁的效率远高于互斥锁。
linux 自旋锁(spinlock)和互斥锁(mutex)
QQ135102692的博客
05-29 560
互斥锁(mutex)无法获取到互斥锁时，会发生上下文切换并休眠，上下文切换的开销相对较大，因此在需要保护的临界区较小时，宜选用自旋锁，否则选用互斥锁。互斥锁在原子操作API的基础上实现，同一时间只能有一个任务持有互斥锁，而且只有这个任务可以对互斥锁进行解锁。3、使用场景：互斥锁(mutex)只能在进程上下文中使用，不能在中断上下文中使用，而自旋锁(spinlock)可以在中断上下文中使用。与自旋锁不同，互斥锁不能进行递归锁定或解锁，只能在同一线程里对应使用，所以它只能用于线程的互斥。
Linux 设备驱动 ====> 并发控制 --- 自旋锁
蓝色妖姬
03-28 157
自旋锁的使用 自旋锁（spin_lock）是一种典型的对临界资源进行互斥访问的手段，顾名思义，为了获得一个自旋锁，在某CPU上运行的代码需要先执行一个原子操作，该操作测试并设置某个内存变量，在该操作完成之前其他执行单元不可能访问到这个内存变量。 如果测试结果表明锁已经空闲，则程序获得这个自旋锁并继续执行；如果测试表明锁仍被占用，程序将在一个小的循环内重复这个“测试并设置”操作，就是“自旋”的动...
自旋锁(spin lock)与互斥量(mutex)的比较——多核编程学习笔记2
swordmanwk的专栏
09-25 8684
自旋锁是一种非阻塞锁，也就是说，如果某线程需要获取自旋锁，但该锁已经被其他线程占用时，该线程不会被挂起，而是在不断的消耗CPU的时间，不停的试图获取自旋锁。 互斥量是阻塞锁，当某线程无法获取互斥量时，该线程会被直接挂起，该线程不再消耗CPU时间，当其他线程释放互斥量后，操作系统
【Linux-驱动】驱动策略----自旋锁
anpiga0111的博客
01-18 163
自旋锁 自旋锁最多只能被一个内核任务持有。要是锁未被持有，请求它的内核任务便会立即得到它并继续执行。如果一个内核任务试图请求一个已经被别的内核任务持有的自旋锁，那么CPU就会一直尽心循环---旋转---等待锁重新可用。 Spinlock_t my_lock = SPIN_LOCK_UNLOCKED; 或者在运行时使用： Void spin_lock_init(spinlock_t...
驱动开发：内核中的自旋锁结构
热门推荐
优快云
09-28 1万+
文章中简单实用链表结构来存储进程信息列表，相信读者应该已经理解了内核链表的基本使用，本篇文章将讲解自旋锁的简单应用，自旋锁是为了解决内核链表读写时存在线程同步问题，解决多线程同步问题必须要用锁，通常使用自旋锁，自旋锁是内核中提供的一种高IRQL锁，用同步以及独占的方式访问某个资源。首先以简单的链表为案例，链表主要分为单向链表与双向链表，单向链表的链表节点中只有一个链表指针，其指向后一个链表元素，而双向链表节点中有两个链表节点指针，其中。提到自旋锁那就必须要说链表，在上一篇。指向后一个节点，以双向链表为例。
信号量、互斥体和自旋锁的区别
07-21
自旋锁适用于那些保持时间非常短的场景，例如在中断处理程序中。 #### 五、关键区别 1. **保持时间**： - **信号量**和**读写信号量**适用于保持时间较长的情况，它们会导致调用者睡眠。 - **自旋锁**则适用于...
用原子自旋读写锁代替互斥锁提高多线程访问公共资源效率
04-12
在本文中，我们将会深入探讨原子自旋锁的工作原理、如何使用以及它相比互斥锁的优点和潜在问题。首先，原子自旋锁的核心在于原子操作，如CAS（Compare and Swap）指令，这是一个无锁编程中的基础操作，可以确保在多...
自旋锁和互斥锁的区别
lx123010的专栏
03-26 927
单CPU非抢占内核下：自旋锁会在编译时被忽略（因为单CPU且非抢占模式情况下，不可能发生进程切换，时钟只有一个进程处于临界区（自旋锁实际没什么用了）单CPU抢占内核下：自选锁仅仅当作一个设置抢占的开关（因为单CPU不可能有并发访问临界区的情况，禁止抢占就可以保证临街区唯一被拥有）多CPU下：此时才能完全发挥自旋锁的作用，自旋锁在内核中主要用来防止多处理器中并发访问临界区，防止内核抢占造成的竞争。
操作系统中的锁：自旋锁、互斥锁、条件变量、信号量、死锁
weixin_45783996的博客
08-23 1188
一直对这些概念学了又忘忘了又学，究其根本是因为始终没搞清楚这几个概念之间的关系，每次都是钻进细节里面，所以就很容易忘了。所以这里整理一下，以后回忆起来也方便。首先锁是什么？操作系统中的锁是用于协调进程或线程对的访问（即多个线程同时只有一个线程可以进入临界区代码），以防止竞争条件和数据不一致的问题，以及实现进程之间的同步（本来两个不同的进程是各干各的，互不影响，这叫异步，如果我想要让进程A运行完某行代码之后进程B再运行，这叫作同步），比如读写进程之间就需要同步，写好了之后才能读。
Windows驱动编程视频教程 提升IRQ与自旋锁
08-19
Windows驱动编程视频教程 详尽的讲解 里面还有屏幕录制的录像
windows驱动 - 自旋锁
qq726232111的博客
12-21 488
0x00 文档 https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/introduction-to-spin-locks 0x01 相关函数 KeDelayExecutionThread 在指定的时间间隔内将当前线程置于可报警或不可报警的等待状态(sleep) KeDelayExecutionThread(KernelMode, 0, ( 10^-6)*10 ); KeInitializeSpinLock...
Linux驱动之自旋锁、读写自旋锁
02-05 781
自旋锁： 自旋锁实际上是一种忙等待，只有SMP或者支持抢占内核支持。 A 定义： typedef struct { raw_spinlock_t raw_lock; #ifdef CONFIG_GENERIC_LOCKBREAK unsigned int break_lock; #endif #ifdef CONFIG_DEBUG_SPINLOCK unsigned int mag
【Linux驱动篇】同步机制（2）— 互斥锁
Soky的博客
08-07 9104
Linux驱动相关的简单笔记知识
驱动程序学习（四）并发控制（2）自旋锁控制
星河_SR的专栏
08-16 1167
在概念上，自旋锁非常简单。一个自旋锁就是一个互斥设备，它只有两个值：“锁定” 和“解锁”。它通常实现为某个整数值中的单个位。希望获得某特定锁的代码测试的相关 的位。如果锁可用，则“锁定”位被设置，而代码进入临界区；相反，如果锁被其他人获得， 则代码进入忙循环并重复坚持这个锁，直到该锁可用为止。这个循环就是自旋锁的“自旋”部分。         自旋锁不会引起调用者休眠，如果自旋锁已经被别的
Linux设备驱动中的并发控制之五（自旋锁）
xiezhi123456的博客
05-20 1085
7.5　自旋锁7.5.1　自旋锁的使用自旋锁（Spin Lock）是一种典型的对临界资源进行互斥访问的手段，名称来源于它的工作方式。为了获得一个自旋锁，在某CPU上运行的代码需先执行一个原子操作，该操作测试并设置（Test-And-Set）某个内存变量。由于它是原子操作，所以在在该操作完成之前其他执行单元不可能访问这个内存变量。如果测试结果表明锁已经空闲，则程序获得这个自旋锁并继续执行；如果测试结...
linux驱动中的自旋锁死锁
最新发布
2401_84888945的博客
12-11 576
中断处理程序会一直等待获取这把锁（自旋等待），但锁无法释放，因为被中断的线程已经被打断了，结果就是，中断和线程相互等待，出现死锁。简单来说，线程A持有资源1，等待资源2，而线程B持有资源2，等待资源1，这种交叉等待会导致死锁。如果一个线程已经持有了自旋锁，他不能再次请求同一把锁，否则会自旋等待自己释放锁，被卡住。线程A持有资源1，并尝试获取资源2，此时资源2已被线程B持有，所以线程A被阻塞。线程B持有资源2，并尝试获取资源1，但资源1已被线程A持有，所以线程B也被阻塞。
【Linux驱动】LED 互斥控制 —— 原子操作变量、信号量、互斥锁
challenglistic的博客
07-06 182
【Linux驱动】LED 互斥控制 —— 原子操作变量、信号量、互斥锁
自旋锁
weixin_52849254的博客
02-08 785
设计自旋锁的最初目的是在多处理器系统中提供对共享数据的保护，其背后的核心思想是：设置一个在多处理器之间共享的全局变量锁v,并定义当V=I时为上锁状态，V=0为解锁状态·如果处理器A上的代码要进入临界区．它要先读取V的值，判断其是否为0，如果V不等于0表明有其他处理器上的代码正在对共享数据进行访问，此时处理器A进入忙等待即自旋状态，如果V=O表明当前没有其他处理器上的代码进入临界区，此时处理器A可以访问该资源，它先把V置1（自旋锁的上锁状态).然后进入临界区，访问完毕离开临界区时将V置0（自旋锁的解锁状态）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值