文章目录

自旋锁的概念
自旋锁死锁
写代码

自旋锁的概念

什么是自旋锁？

自旋锁是为了实现保护共享资源提出的一种锁机制，也是内核中比较常见的锁机制。自旋锁是以“原地等待”的方式解决资源冲突。即当线程A获取到自旋锁以后，此时线程B也想获取到自旋锁。但是线程B获取不到，只能“原地打转”（仍然占用CPU，不会休眠），不断尝试获取自旋锁，直到获取成功，然后才退出循环。

只有一个厕所，A想去厕所，B已经在厕所了，所以A只能在外面等待B，知道B上完厕所出来，A才能进去上厕所。

自旋锁的API函数（一）

函数	描述
DEFINE_SPINLOCK(spinlock_t *lock)	定义并初始化一个变量
int spin_lock_init(spinlock_t *lock)	初始化自旋锁
void spin_lock(spinlock_t *lock)	获取自旋锁，也叫做加锁
void spin_unlock(spinlock_t *lock)	释放自旋锁，也叫做解锁
int spin_trylock(spinlock_t *lock)	尝试获取自旋锁，如果没有获取到就返回0
int spin_is_locked(spinlock_t *lock)	检查自旋锁是否被获取，如果没有被获取就返回非0，否则返回0

自旋锁的使用步骤

在访问临界资源的时候先申请自旋锁
获取到自旋锁以后就进入临界区，获取不到自旋锁就“原地等待”
退出临界区的时候要释放自旋锁

其他自旋锁API函数（二）

函数	描述
void spin_lock_irq(spinlock_t *lock)	关闭中断并获取自旋锁
void spin_unlock_irq(spinlock_t *lock)	打开中断并释放自旋锁
void spin_lock_irqsave(spinlock_t *lock, unsigned long flags)	保存中断状态，关闭中断并获取自旋锁
void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)	恢复之前保存的中断状态，打开中断并释放自旋锁
void spin_lock_bh(spinlock_t *lock)	关闭下半部，获取自旋锁
void spin_unlock_bh(spinlock_t *lock)	打开下半部，获取自旋锁

自旋锁的注意事项

由于自旋锁会“原地等待”，因为“原地等待”会继续占用CPU，会消耗CPU资源。所以锁的时间不能太长，也就是临界区的代码不能太多。
在自旋锁保护的临界区里面不能调用可能会导致线程休眠的函数，否则可能会发生死锁。
自旋锁一般是用在多核的SOC上面。

内核中自旋锁的实例

在这里插入图片描述

自旋锁死锁

在多核CPU或者支持抢占的单核CPU中，被自旋锁保护的临界区不能调用任何能够引起睡眠或者阻塞的函数，否则可能会发生死锁。

使用自旋锁会禁止抢占。比如在单核CPU中，A进程获取到自旋锁以后暂时关闭内核抢占，如果A进程此时进入了休眠（放弃了CPU的使用权），B进程此时也想获取到自旋锁，但是此时自旋锁被进程A持有，而且此时CPU的抢占被禁止了。因为是单核，进程B就无法被调度出去，只能在“原地旋转”等在锁被A释放。但是进程A无法运行，锁也就无法释放。死锁就发生了。

多核CPU不会发生上面的情况。因为其他的核会调度其他的进程。

当进程A获取到自旋锁以后，如果产生了中断，并且在中断里面也要访问共享资源（中断里面可以用自旋锁），此时中断里面无法获取到自旋锁，只能“原地旋转”，产生死锁。为了避免这种情况发生，可以使用spin_lock_irqsave等API来禁止中断并获取自旋锁。

写代码

临界区在哪？

在这里插入图片描述

...
static spinlock_t spinlock;
static int flag = 1;

int misc_open(struct inode *inode,struct file *file)
{
    
    
	spin_lock(&spinlock);
	/***********临界区开始***********/
  
	/**********临界区结束***********/
	spin_unlock(&spinlock);

	printk("hello misc_open\n ");
	return 0;
}
...

如上，在加自旋锁和解自旋锁中间的区域就是“临界区域”。

最简单的实现逻辑

static spinlock_t spinlock;
static int flag = 1;

int misc_open(struct inode *inode,struct file *file)
{
    
    
	spin_lock(&spinlock);
	if(flag != 1) // 第一次程序进来不会有任何问题
	{
    
    
		spin_unlock(&spinlock);
		return -EBUSY;
	}
	flag = 0; // 第一次进来的程序会置该标志位，让后面的程序无法进来。
	spin_unlock(&spinlock);

	printk("hello misc_open\n ");
	return 0;
}

int misc_release(struct inode *inode,struct file *file)
{
    
    
	spin_lock(&spinlock);
	if(flag != 1)
	flag = 1;
	spin_unlock(&spinlock);
	
	printk("hello misc_relaease bye bye \n ");
	return 0;
}

如上，这是一个设备节点的驱动，第一次程序A打开了该驱动是可以顺利打开的不会有问题，并且打开后就会把全局变量flag = 0，这样其他程序再想打开该驱动就会失败并返回错误。
程序A用完了该驱动就会将flag = 1，从而后面的程序可以打开该驱动。
逻辑相当简单，就是操作与判断flag的逻辑必须在临界区里面执行。

一种特殊情况：

程序A打开了驱动，代码跑到了flag = 0; 也就是flag还没有完全赋值的时候，来了程序B也要打开驱动，由于自旋锁锁定机制，它只能在临界区外spin_lock(&spinlock); //在这里等待等待。直到程序A跑完临界区，flag也被设置为了1，然后程序B还是无法打开驱动了！目的就达到了。

完整实现

led.c

#include <linux/init.h>         //初始化头文件
#include <linux/module.h>       //最基本的文件，支持动态添加和卸载模块。
#include <linux/miscdevice.h>   //包含了miscdevice结构的定义及相关的操作函数。
#include <linux/fs.h>           //文件系统头文件，定义文件表结构（file,buffer_head,m_inode等）
#include <linux/uaccess.h>      //包含了copy_to_user、copy_from_user等内核访问用户进程内存地址的函数定义。
#include <linux/io.h>           //包含了ioremap、iowrite等内核访问IO内存等函数的定义。
#include <linux/kernel.h>		//驱动要写入内核，与内核相关的头文件

#include <linux/atomic.h>
#include <asm/atomic.h> 

#define GPIO_DR 0xfdd60000     //LED物理地址，通过查看原理图得知
unsigned int *vir_gpio_dr;     //存放映射完的虚拟地址的首地址

static spinlock_t spinlock;
static int flag = 1;

int misc_open(struct inode *inode,struct file *file)
{
    
    
	spin_lock(&spinlock);
	if(flag != 1)
	{
    
    
		spin_unlock(&spinlock);
		return -EBUSY;
	}
	flag = 0;
	spin_unlock(&spinlock);

	printk("hello misc_open\n ");
	return 0;
}

int misc_release(struct inode *inode,struct file *file)
{
    
    
	spin_lock(&spinlock);
	flag = 1;
	spin_unlock(&spinlock);

	printk("hello misc_relaease bye bye \n ");
	return 0;
}

ssize_t misc_read (struct file *file, char __user *ubuf, size_t size, loff_t *loff_t)
{
    
    
	printk("misc_read\n ");
	return 0;
}

ssize_t misc_write (struct file *file, const char __user *ubuf, size_t size, loff_t *loff_t)
{
    
    	
    /*应用程序传入数据到内核空间，然后控制蜂鸣器的逻辑，在此添加*/
	// kbuf保存的是从应用层读取到的数据
    char kbuf[64] = {
    
    0};
    // copy_from_user 从应用层传递数据给内核层
	if(copy_from_user(kbuf,ubuf,size)!= 0) 
	{
    
    
        // copy_from_user 传递失败打印
		printk("copy_from_user error \n ");
		return -1;
	}
    //打印传递进内核的数据
    //printk("kbuf is %d\n ",kbuf[0]); 
	if(kbuf[0]==1) //传入数据为1 ,LED亮
	{
    
    
		*vir_gpio_dr = 0x80008000; 
	}
	else if(kbuf[0]==0) //传入数据为0，LED灭
		*vir_gpio_dr = 0x80000000;
	return 0;
}

//文件操作集
struct file_operations misc_fops={
    
    
	.owner = THIS_MODULE,
	.open = misc_open,
	.release = misc_release,
	.read = misc_read,
	.write = misc_write,
};
//miscdevice结构体
struct miscdevice  misc_dev = {
    
    
	.minor = MISC_DYNAMIC_MINOR,
	.name = "hello_misc",
	.fops = &misc_fops,
};
static int misc_init(void)
{
    
    
	int ret;
    //注册杂项设备
	ret = misc_register(&misc_dev);
	if(ret<0)
	{
    
    
		printk("misc registe is error \n");
	}
	printk("misc registe is succeed \n");
    //将物理地址转化为虚拟地址
	vir_gpio_dr = ioremap(GPIO_DR,4);
	if(vir_gpio_dr == NULL)
	{
    
    
	printk("GPIO_DR ioremap is error \n");
	return EBUSY;
	}
	printk("GPIO_DR ioremap is ok \n");	
	return 0;
}
static void misc_exit(void){
    
    
    //卸载杂项设备
	misc_deregister(&misc_dev);
	iounmap(vir_gpio_dr);
	printk(" misc gooodbye! \n");
}
module_init(misc_init);
module_exit(misc_exit);
MODULE_LICENSE("GPL");

Makefile

obj-m += led.o
KDIR =/home/liefyuan/Linux/rk356x_linux/kernel
PWD ?= $(shell pwd)
all:
	make -C  $(KDIR) M=$(PWD) modules modules ARCH=arm64 CROSS_COMPILE=/usr/local/arm64/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu-
clean:
	rm -rf modules.order *.o workqueue.o  Module.symvers *.mod.c *.ko

编译模块：

$ export ARCH=arm64
$ export CROSS_COMPILE=aarch64-linux-gnu-
$ make

测试应用：

app.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc,char *argv[])
{
    
    
	int fd;
	char buf[64] = {
    
    0};//定义buf缓存
	char val[1];
	//打开设备节点
	fd = open("/dev/hello_misc",O_RDWR);
	if(fd < 0)
	{
    
    
		//打开设备节点失败
		perror("open error \n"); 
		return fd;
	}
    sleep(10);
	close(fd);
	return 0;
}

app2.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc,char *argv[])
{
    
    
	int fd;
	char buf[64] = {
    
    0};//定义buf缓存
	char val[1];
	//打开设备节点
	fd = open("/dev/hello_misc",O_RDWR);
	if(fd < 0)
	{
    
    
		//打开设备节点失败
		perror("open error \n"); 
		return fd;
	}
	//把缓冲区数据写入文件中
	while(1)
	{
    
    
		val[0] = 1;
		write(fd, val, sizeof(val));
		sleep(1);
		val[0] = 0;
		write(fd, val, sizeof(val));
		sleep(1);
	}
	close(fd);
	return 0;
}

编译：

aarch64-linux-gnu-gcc app.c -o app.armelf
aarch64-linux-gnu-gcc app2.c -o app2.armelf

测试：

[root@RK356X:/opt]# insmod led.ko
[  787.424679] misc registe is succeed
[  787.425141] GPIO_DR ioremap is ok

[root@RK356X:/opt]# ./app.armelf &

[root@RK356X:/opt]# ./app2.armelf
open error
: Device or resource busy
[root@RK356X:/opt]# ./app2.armelf [  805.822972] hello misc_open
[  805.822972]

[  815.824861] hello misc_relaease bye bye
[  815.824861]
[  818.127234] hello misc_open
[  818.127234]

实现的逻辑：程序app运行起来以后会占用驱动10秒钟，这十秒内app2是无法打开驱动的，直到app释放掉自旋锁以后才可以被app2打开。

并发与竞争（三）自旋锁