Linux下自旋锁的学习使用

前言

前面我们讲到定时器的使用,本篇讲下自旋锁的使用。想第一时间看我的文章的话可以点击公众号主页右上角有个设为星标，以免错过好文。本文源码采用Linux内核5.10

自旋锁简介

自旋锁是Linux内核里最常用的锁之一，自旋锁的概念很简单，就是如果加锁失败在等锁时候是使用休眠等待还是忙等待，如果是忙等待的话，就是自旋锁，这也是自旋锁名字的由来。如果是休眠等待的锁那就是互斥锁另外一个场景，下篇再讲互斥锁。自旋锁的效率远高于互斥锁

举个例子: 当一个线程要访问某个共享资源的时候首先要先获取相应的锁，锁只能被一个线程持有，只要次线程不释放持有的锁，那么其他的线程就不能获取此锁。对于自旋锁而言，如果自旋锁正在被线程A持有，线程B想要获取自旋锁，那么线程B想要获取自旋锁，那么线程B就会处于忙循环-旋转-等待状态，线程B不会进入休眠状态或者说去做其他的处理，而是会一直傻傻的在那里转圈圈原地打转锁可用。就比如现在有个公共电话亭，一次肯定只能进去一个人打电话，现在电话亭里面有人正在打电话，相当于获取自旋锁。此时你到了电话亭门口，因为里面有人，所以你不能进去打电话，相当于没有获取了自旋锁。此时你到了电话亭门口，因为里面有人，所以你不能进去打电话，相当于没有获取自旋锁，这时候你原地等待，你可能因为无聊的等待而转圈圈消磨时光，反正就是哪里也不能去，要一直等到里面的人打完电话出来。终于，里面的人打完电话出来了，相当于释放了自旋锁，这个时候你就可以使用电话亭打电话了，就相当于获取到了自旋锁。

注意: 等待自旋锁的线程会一直处于自旋状态，这样会浪费处理器时间，降低系统性能，所以自旋锁持有时间不能太长。所以自旋锁适用于短时期的轻量级加锁，如果遇到需要长时间持有锁的场景那就不适合用自旋锁，就像一个人在ATM里待了一天,其他人没法办业务

自旋锁的数据结构

Linux内核使用结构体spinlock_t表示自旋锁，结构体定义如下所示：

file:include/linux/spinlock_types.h

typedef struct spinlock{
     union{
         struct raw_spinlock rlock;

#ifdef CONFIG_DEBUG_LOCK_ALLOC
#define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
          struct {
               u8 __padding[LOCK_PADSIZE];
               struct lockdep_map dep_map;
          };
#endif
     };
}spinlock_t;

 
typedef struct raw_spinlock {
    arch_spinlock_t raw_lock;
#ifdef CONFIG_DEBUG_SPINLOCK
    unsigned int magic, owner_cpu;
    void *owner;
#endif
#ifdef CONFIG_DEBUG_LOCK_ALLOC
    struct lockdep_map dep_map;
#endif
} raw_spinlock_t;

在使用自旋锁之前，肯定要先定义一个自旋锁变量，定义方法如下所示: spinlock_t lock;定义如下:

spinlock_t lock; //定义自旋锁

或者用DEFINE_SPINLOCK(spinlock_t lock)函数来定义好自旋锁变量

自旋锁的API总结

自旋锁基本使用的API

自旋锁与中断的API

分析：

1、spin_lock和spin_lock_irq的区别是如果临界区发生中断，系统会暂停当前进程运行，转向处理中断，有人会问临界区会不会发生中断，如果调用spin_lock保护临界区的话，答案是一定会发生中断。但是如果调用spin_lock_irq保护临界区的话，就一定不会发生中断，因为spin_lock_irq比spin_lock的实现多了local_irq_disable函数，用于本地处理器中断关掉。

2、使用 spin_lock_irq/spin_unlock_irq 的时候需要用户能够确定加锁之前的中断状态，但实际 上内核很庞大，运行也是“千变万化”，我们是很难确定某个时刻的中断状态，因此不推荐使用 spin_lock_irq/spin_unlock_irq。建议使用 spin_lock_irqsave/ spin_unlock_irqrestore，因为这一组函数会保存中断状态，在释放锁的时候会恢复中断状态。一般在线程中使用 spin_lock_irqsave/spin_unlock_irqrestore，在中断中使用 spin_lock/spin_unlock，示例代码如下所示

DEFINE_SPINLOCK(lock) //定义并初始化一个锁

/*线程A*/
void functionA (){
    unsigned long flags;             //中断状态标志变量
    spin_lock_irqsave(&lock, flag);  //获取锁 
    
    //临界区
    
    spin_unlock_irqrestore(&lock,flag)//释放锁
}

/*中断服务函数*/
void irq() {
    spin_lock(&lock); //获取锁
    
    //临界区
    
    spin_unlock(&lcok); //释放锁
}

3、spin_lock_bh的作用：1.保护临界区。 2.禁止抢占。 3.禁止软中断

总结了下spin_lock API的功能差别如下表

非实时内核使用自旋锁的注意事项

1、用于多核SMP或者是单CPU下线程之间的并发访问，也就是线程与线程之间的

2、自旋锁可以在中断上下文中使用，但是临界区不能有睡眠和阻塞的API函数，像内存分配函数kmalloc，如果非要在中断里调用内存分配函数一定要加不可睡眠GFP_ATOMIC的掩码。

3、临界区持有时间较短

4、不能递归申请自旋锁

死锁场景：被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API函数，否则的话会可能导致死锁现象。自旋锁会自动禁止抢占，也就说当线程A得到锁以后会暂时禁止内核抢占，如果线程A在持有锁期间进入了休眠状态，那么线程A会自动放弃CPU使用权，线程B开始运行，线程B也想要获取锁，但是此时线程A持有，而且内核抢占还被禁止了，线程B无法被调度出去，那么线程A就无法运行，锁也就无法释放，好了死锁就发生了

一般内核源码中自旋锁中链表作为临界区比较多

补充一点冷知识:
打入实时补丁的内核当中,spin_lock变成可抢占和睡眠的锁，raw_spin_lock是不允许被抢占和睡眠的锁

自旋锁的使用示例

例如当多个APP应用程序抢占open一个驱动节点的时候，可以将下面的dev_status变量作为临界区加锁的保护变量。下面主要列出主要demo框架

 #include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/uaccess.h>
#include <asm/io.h>


/* gpioled设备结构体 */
struct gpioled_dev{
 ...
 int dev_status;   /* 设备使用状态，0，设备未使用;>0,设备已经被使用 */
 spinlock_t lock;  /* 自旋锁 */
};


static int led_open(struct inode *inode, struct file *filp)
{
 unsigned long flags;
 filp->private_data = &gpioled; /* 设置私有数据 */

 spin_lock(&gpioled.lock, flags); /* 上锁 */
 if (gpioled.dev_status) {     /* 如果设备被使用了 */
  spin_unlock(&gpioled.lock, flags);/* 解锁 */
  return -EBUSY;
 }
 gpioled.dev_status++; /* 如果设备没有打开，那么就标记已经打开了 */
 spin_unlock(&gpioled.lock, flags);/* 解锁 */

 return 0;
}

static int led_release(struct inode *inode, struct file *filp)
{
 unsigned long flags;
 struct gpioled_dev *dev = filp->private_data;

 /* 关闭驱动文件的时候将dev_stats减1 */
 spin_lock(&dev->lock, flags); /* 上锁 */
 if (dev->dev_stats) {
  dev->dev_stats--;
 }
 spin_unlock(&dev->lock, flags);/* 解锁 */

 return 0;
}

/* 设备操作函数 */
static struct file_operations gpioled_fops = {
 .owner = THIS_MODULE,
 .open = led_open,
 .read = led_read,
 .write = led_write,
 .release =  led_release,
};


static int __init led_init(void)
{
    /*  初始化自旋锁 */
 spin_lock_init(&gpioled.lock);
    ...
}

或者用spin_lock_irqsave函数以上场景也是合理

static int led_open(struct inode *inode, struct file *filp)
{
 unsigned long flags;
 filp->private_data = &gpioled; /* 设置私有数据 */

 spin_lock_irqsave(&gpioled.lock, flags); /* 上锁 */
 if (gpioled.dev_status) {     /* 如果设备被使用了 */
  spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */
  return -EBUSY;
 }
 gpioled.dev_status++; /* 如果设备没有打开，那么就标记已经打开了 */
 spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */

 return 0;
}

static int led_release(struct inode *inode, struct file *filp)
{
 unsigned long flags;
 struct gpioled_dev *dev = filp->private_data;

 /* 关闭驱动文件的时候将dev_stats减1 */
 spin_lock_irqsave(&dev->lock, flags); /* 上锁 */
 if (dev->dev_stats) {
  dev->dev_stats--;
 }
 spin_unlock_irqrestore(&dev->lock, flags);/* 解锁 */

 return 0;
}

static int __init led_init(void)
{

    /*  初始化自旋锁 */
 spin_lock_init(&gpioled.lock);
    
    ...
}

以上两种写法例子中，都说明下当dev_status为0的时候代表没有线程持有可以被打开，当dev_status为非0的时候代表有线程占有打开，所以此时线程不能被再次打开。

结语

本篇的主要是记录下自旋锁的使用，有啥疑问欢迎文末留言

作者潘小帅, 是一名Linux底层爱好者，平时写写技术原创文章，徒步，旅游，看电影的爱好，喜欢我的文章可以点赞收藏+关注，感谢你的支持，微信公众号【Linux随笔录】