本文详细介绍了Linux内核中的自旋锁，包括其特点、加锁步骤、存在的问题及解决方案，强调了自旋锁在多核处理器上的应用。自旋锁通过CAS函数和PAUSE指令实现轻量级加锁，避免上下文调度带来的系统开销。此外，还讨论了原子操作的优缺点，指出其仅适用于简单的计数操作。文章最后列举了自旋锁的相关API函数及其使用示例。
文章目录
一、总结
-
1、短时间、轻量级加锁。
进程调度也要消耗系统资源，时间短的进程切换进行进程调度反而不划算。 -
2、忙等，不会休眠
-
3、可用于中断
但是在中断里面会用到自旋锁时，普通函数使用自旋锁时，一定要先关中断，否则可能导致死锁。
线程 A 先运行，并且获取到了 lock 这个锁，当线程 A 运行 functionA 函数的时候中断发生了，中断抢走了 CPU 使用权。右边的中断服务函数也要获取 lock 这个锁，但是这个锁被线程 A 占有着，中断就会一直自旋，等待锁有效。但是在中断服务函数执行完之前，线程 A 是不可能执行的，线程 A 说“你先放手”，中断说“你先放手”，场面就这么僵持着，死锁发生！
因此最好的解决方法就是获取锁之前关闭本地中断。 -
4、Linux 内核提供了相应的 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) | 将中断状态恢复到以前的状态，并且激活本地中断，释放自旋锁。 |
二、原子操作的特点
- 优点：
简单易用 - 缺点：
只能作计数操作，保护的东西太少
三、自旋锁
主要用于多核处理器
-
短时间的轻量级加锁
-
加锁失败时，原地打转、忙等待（在等待的过程中依然占用处理机资源）
-
自旋锁的优点：
避免上下文调度、系统开销较小
其他类型的锁可能引起进程、线程休眠，进程调度和线程调度也会有开销。若等待时间不长，调度反而不划算，死等划算。
1、加锁步骤
- 查看锁的状态，如果锁是空闲的
- 将锁设置为当前线程持有
2、存在问题
在没有 CAS 函数前，多个线程同时执行这 2 个步骤是会出错的。
3、解决方案
CAS 函数把这 2 个步骤合并为一条硬件级指令。这样第 1 步比较锁状态和第 2 步锁变量赋值，将变为不可分割的原子指令(硬件同步原语)
4、CAS 函数
自旋锁使用CPU 提供的 CAS 函数（Compare And Swap），在用户态代码中完成加锁与解锁操作
5、PAUSE 指令
自旋锁并不一直"忙等待"，会与 CPU紧密配合 ，它通过 CPU 提供的 PAUSE 指令，减少循环等待时的耗电量；
对于单核CPU，忙等待并没有意义，此时仍然占用处理机，要等待的事件无法进行，此时它会主动把线程休眠。
6、自旋锁原理
- 设自旋锁为变量 lock，整数 0 表示锁是空闲状态，整数 pid 表示线程 ID
- CAS(lock, 0, pid) 就表示自旋锁的加锁操作
- CAS(lock, pid,0) 则表示自旋锁的解锁操作
自旋锁伪代码
while (true)
{
//因为判断lock变量的值比CAS操作更快，所以先判断lock再调用CAS效率更高
if (lock == 0 && CAS(lock, 0, pid) == 1)
{
return;
}
if (CPU_count > 1 )
{
//如果是多核CPU，“忙等待”才有意义
for(n = 1; n < 2048; n <<= 1)
{
//pause的时间，应当越来越长
for (i = 0; i < n; i++)
{
pause();//CPU专为自旋锁设计了pause指令
}
if (lock == 0 && CAS(lock, 0, pid))
{
return;//pause后再尝试获取锁
}
}
}
sched_yield();//单核CPU，或者长时间不能获取到锁，应主动休眠，让出CPU
}
7、自旋锁相关API
定义自旋锁
spinlock_t s_lock ;
初始化自旋锁
int spin_lock_init(spinlock_t *lock);
获取自旋锁函数
加锁操作
void spin_lock(spinlock_t *lock)
尝试获取自旋锁函数
尝试获取一次，获取成功返回“true”,获取失败返回“false”。程序继续往下执行
与上面的区别就是非阻塞
int spin_trylock(spinlock_t *lock)
释放自旋锁
void spin_unlock(spinlock_t *lock)
四、例程
- test.c
#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/init.h>
#include <linux/fs.h>
#include<linux/slab.h>
#include<linux/io.h>
#include<linux/uaccess.h>
#include<linux/cdev.h>
#include<linux/device.h>
#include<linux/of.h>
#include<linux/of_address.h>
#include<linux/of_irq.h>
#define DTSLED_NAME "dtsled"
#define LED_OFF 0
#define LED_ON 1
// 定义一组全局变量，用于存放映射得到的虚拟地址
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;
// 定义一个自旋锁变量
spinlock_t s_lock;
// 使用自旋锁来保护这个字符变量
char flag;
extern struct dtsled_dev dtsled;
static void led_switch(u8 state)
{
u32 val = 0;
if(state == LED_ON)
{
val = readl(GPIO1_DR);
val &= (~(1<<3));
writel(val, GPIO1_DR);
}
else if(state == LED_OFF)
{
val = readl(GPIO1_DR);
val |= (1<<3);
writel(val, GPIO1_DR);
}
}
static int dtsled_open(struct inode *inode, struct file *filp)
{
spin_lock(&s_lock);
if(flag)
{
spin_unlock(&s_lock);
printk("%s(%d):the dev is used now.\n", __FILE__, __LINE__);
// 如果这里返回的是0，那么open函数会被判断成执行成功，下一步write还是能够操作led
return -EBUSY;
}
else
{
flag++;
}
spin_unlock(&s_lock);
// struct file 结构体定义在 include/linux/fs.h 中
// struct file 有一个成员（空指针）：void *private_data
printk("%s(%d):%s\n", __FILE__, __LINE__, __func__);
filp->private_data = &dtsled;
return 0;
}
static int dtsled_release(struct inode *inode, struct file *filp)
{
//struct dtsled_dev *dev = (struct dtsled_dev *)filp->private_data;
spin_lock(&s_lock);
if(flag)
{
flag--;
printk("%s(%d):flag--\n", __FILE__, __LINE__);
}
else
{
printk("%s(%d):\n", __FILE__, __LINE__);;
}
spin_unlock(&s_lock);
return 0;
}
static ssize_t dtsled_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
{
int ret;
u8 databuf[1];
//struct dtsled_dev *dev = (struct dtsled_dev *)filp->private_data;
printk("%s(%d):%s\n", __FILE__, __LINE__, __func__);
printk("%s(%d):buf=(%s), count=%d\n", __FILE__, __LINE__, buf, count);
ret = copy_from_user(databuf, buf, count);
printk("%s(%d):databuf=(%s)\n", __FILE__, __LINE__, databuf);
if(ret < 0)
{
printk("Kernel write failed.\r\n");
return -1;
}
printk("%s(%d):%s\n", __FILE__, __LINE__, __func__);
led_switch(databuf[0]-'0');
return 0;
}
// 操作集结构体，是 struct cdev 的成员
static const struct file_operations dtsled_fops =
{
.owner = THIS_MODULE,
.write = dtsled_write,
.open = dtsled_open,
.release = dtsled_release,
};
// 自定义结构体类型来描述 LED
struct dtsled_dev
{
dev_t devid;
struct cdev cdev; // 用于注册字符设备，操作集结构体是其成员变量
struct file_operations dtsled_fops; // 操作集结构体
struct class *class; // 用于自动创建设备节点
struct device *device; // 用于自动创建设备节点
u32 major;
u32 minor;
struct device_node *nd; // 设备树结点，用来表示 LED 设备节点
};
// 自定结构体来描述 LED
struct dtsled_dev dtsled;
// 驱动入口函数
static int __init dtsled_init(void)
{
int ret = 0;
int val = 0;
const char *str;
u32 regdata[10];
u8 i;
// 1、使用新方法来获取设备号
dtsled.major = 0;
if(dtsled.major)
{
dtsled.devid = MKDEV(dtsled.major, 0);
ret = register_chrdev_region(dtsled.devid, 1, DTSLED_NAME);
}
else
{
ret = alloc_chrdev_region(&dtsled.devid, 0, 1, DTSLED_NAME);
dtsled.major = MAJOR(dtsled.devid);
dtsled.minor = MINOR(dtsled.devid);
}
if(ret < 0)
{
printk("%d:Register char dev error.\r\n", __LINE__);
goto fail_devid;
}
// 2、添加（注册）字符设备
dtsled.cdev.owner = THIS_MODULE;
// zhu yi liang ge qu di zhi fu !
cdev_init(&dtsled.cdev, &dtsled_fops);
ret = cdev_add(&dtsled.cdev, dtsled.devid, 1);
if(ret < 0)
{
goto fail_cdev;
}
// 3、自动创建设备节点，需要一个 struct class，一个 struct device
dtsled.class = class_create(THIS_MODULE, DTSLED_NAME);
if(IS_ERR(dtsled.class))
{
ret = PTR_ERR(dtsled.class);
goto fail_class;
}
// 第一个 NULL 表示副设备, 第二个 NULL 表示 drvdata
dtsled.device = device_create(dtsled.class, NULL, dtsled.devid, NULL, DTSLED_NAME);
if(IS_ERR(dtsled.device))
{
ret = PTR_ERR(dtsled.device);
goto fail_device;
}
// 4、设备树相关，读取属性值
dtsled.nd = of_find_node_by_path("/alpha_led");
if(dtsled.nd == NULL)
{
goto fail_findnd;
}
// 获取状态属性，注意是指针的指针
ret = of_property_read_string(dtsled.nd, "status", &str);
if(ret)
{
printk("%d:fail\r\n", __LINE__);
goto fail_rs;
}
else
{
printk("%d:status = \"%s\"\r\n", __LINE__, str);
}
// 获取属性值
ret = of_property_read_string(dtsled.nd, "compatible", &str);
if(ret)
{
printk("%d:fail\r\n", __LINE__);
goto fail_rs;
}
else
{
printk("%d:compatible = \"%s\"\r\n", __LINE__, str);
}
// 获取 reg 属性, 也就是获取 u32 类型属性值的方法
ret = of_property_read_u32_array(dtsled.nd, "reg", regdata, 10);
if(ret < 0)
{
printk("%d:fail\r\n", __LINE__);
goto fail_rs;
}
else
{
printk("< reg > = < ");
for(i=0; i<10; i++)
{
printk("%#X ", regdata[i]);
}
printk(">\r\n");
}
// 5、初始化 LED
IMX6U_CCM_CCGR1 = of_iomap(dtsled.nd, 0);
SW_MUX_GPIO1_IO03 = of_iomap(dtsled.nd, 1);
SW_PAD_GPIO1_IO03 = of_iomap(dtsled.nd, 2);
GPIO1_DR = of_iomap(dtsled.nd, 3);
GPIO1_GDIR = of_iomap(dtsled.nd, 4);
// 初始化 LED 相关寄存器
val = readl(IMX6U_CCM_CCGR1);
val &= (~(3<<26));
val |= (3<<26);
writel(val, IMX6U_CCM_CCGR1);
writel(0X5, SW_MUX_GPIO1_IO03);//io mux
writel(0X10B0, SW_PAD_GPIO1_IO03); // set electrical properity
val = readl(GPIO1_GDIR); // set bit3, out
val |= (1<<3);
writel(val, GPIO1_GDIR);
val = readl(GPIO1_DR);
val &= (~(1<<3));//turn on led
writel(val, GPIO1_DR);
// chushihua zixuansuo
spin_lock_init(&s_lock);
return 0;
fail_rs:
fail_findnd:
device_destroy(dtsled.class, dtsled.devid);
fail_device:
class_destroy(dtsled.class);
fail_class:
cdev_del(&dtsled.cdev);
fail_cdev:
unregister_chrdev_region(dtsled.devid, 1);
fail_devid:
return ret;
}
// 出口函数
static void __exit dtsled_exit(void)
{
unsigned int val = 0;
val = readl(GPIO1_DR);
val |= (1<<3); // turn off led
writel(val, GPIO1_DR);
// 取消地址映射
iounmap(IMX6U_CCM_CCGR1);
iounmap(SW_MUX_GPIO1_IO03);
iounmap(SW_PAD_GPIO1_IO03);
iounmap(GPIO1_DR);
iounmap(GPIO1_GDIR);
// 删除字符设备
cdev_del(&dtsled.cdev);
// 释放设备号
unregister_chrdev_region(dtsled.devid, 1);
// 删除设备
device_destroy(dtsled.class, dtsled.devid);
// 删除类
class_destroy(dtsled.class);
}
// 注册出口函数和入口函数
module_init(dtsled_init);
module_exit(dtsled_exit);
MODULE_LICENSE("GPL");
- app.c
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
int main(int argc, char *argv[])
{
int error;
int fd;
if(argc != 3)
{
printf(" command error ! \n");
return -1;
}
/*打开文件*/
fd = open(argv[1], O_RDWR);
if(fd < 0)
{
printf("%s(%d):fail to open file : %s !!!\n", __FILE__, __LINE__, argv[1]);
return -1;
}
error = write(fd,argv[2],sizeof(argv[2]));
if(error < 0)
{
printf("%s(%d):write file error! \n", __FILE__, __LINE__);
close(fd);
/*判断是否关闭成功*/
}
printf("%s(%d):wait for 10s! \n", __FILE__, __LINE__);
sleep(10);
printf("%s(%d):will release the dev! \n", __FILE__, __LINE__);
/*关闭文件*/
error = close(fd);
if(error < 0)
{
printf("%s(%d):close file error! \n", __FILE__, __LINE__);
}
return 0;
}
扫一扫
168
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
