文章目录

• 自旋锁的概念
• • 什么是自旋锁？
  • 自旋锁的API函数（一）
  • 自旋锁的使用步骤
  • 其他自旋锁API函数（二）
  • 自旋锁的注意事项
  • 内核中自旋锁的实例
• 自旋锁死锁
• 写代码
• • 临界区在哪？
  • 最简单的实现逻辑
  • 完整实现

自旋锁的概念

什么是自旋锁？

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

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

自旋锁的API函数（一）

自旋锁的使用步骤

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

其他自旋锁API函数（二）

自旋锁的注意事项

1. 由于自旋锁会“原地等待”，因为“原地等待”会继续占用CPU，会消耗CPU资源。所以锁的时间不能太长，也就是临界区的代码不能太多。
2. 在自旋锁保护的临界区里面不能调用可能会导致线程休眠的函数，否则可能会发生死锁。
3. 自旋锁一般是用在多核的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          //初始化头文件
#include        //最基本的文件，支持动态添加和卸载模块。
#include    //包含了miscdevice结构的定义及相关的操作函数。
#include            //文件系统头文件，定义文件表结构（file,buffer_head,m_inode等）
#include       //包含了copy_to_user、copy_from_user等内核访问用户进程内存地址的函数定义。
#include            //包含了ioremap、iowrite等内核访问IO内存等函数的定义。
#include 		//驱动要写入内核，与内核相关的头文件#include 
#include  #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 
#include 
#include 
#include 
#include 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 
#include 
#include 
#include 
#include 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打开。