Linux的并发与竞争

文章目录

一、并发
二、竞争
三、保护内容是什么
四、解决并发与竞争的几种常用方法
- 1.原子操作
- - 原子整型API函数
  - 原子位操作 API 函数
- 2.自旋锁
- - 自旋锁格式如下：
  - 自旋锁 API 函数
  - 自旋锁的使用注意事项
- 3.信号量
- - 信号量 API 函数
  - 信号量格式如下：
- 4.互斥体
- - API函数如下
  - 格式如下
- 5.举例
- - 原子变量举例
  - 自旋锁举例
  - 信号量举例
  - 互斥体举例

一、并发

💦并发就是多个“用户”同时访问同一个共享资源
举例:比如在公司，两个人同时使用打印机，这就是一个并发的例子。
💦在Linux中并发是如何体现的呢，Linux是个多任务的操作系统，会存在多个任务同时访问一段内存区域，这个结果就会造成内存区域的数据错乱，严重的话会导致内核崩溃。
💦现在的 Linux 系统并发产生的原因很复杂，总结一下有下面几个主要原因：
①、多线程并发访问，Linux 是多任务(线程)的系统，所以多线程访问是最基本的原因。
②、抢占式并发访问，从 2.6 版本内核开始，Linux 内核支持抢占，也就是说调度程序可以在任意时刻抢占正在运行的线程，从而运行其他的线程。
③、中断程序并发访问，这个无需多说，学过 STM32 的同学应该知道，硬件中断的权利可是很大的。
④、SMP(多核)核间并发访问，现在 ARM 架构的多核 SOC 很常见，多核 CPU 存在核间并发访问。

二、竞争

💦并发访问带来的问题就是竞争，学过FreeRTOS和UCOS应该知道临界区这个概念，所谓的临界区就是共享数据段，对于临界区必须保证一次只有一个线程访问，也就是要保证临界区是原子访问的，原子是化学反应不可再分的基本微粒，这里的原子访问就表示这一个访问是一个步骤，不能再进行拆分。如果多个线程同时操作临界区就表示存在竞争，我们在编写驱动的时候一定要注意避免并发和防止竞争访问。
💦所以在编写 Linux 驱动初学者往往不注意这一点，在驱动程序中埋下了隐患，这类问题往往又很不容易查找，导致驱动调试难度加大、费时费力。所以我们一般在编写驱动的时候就要考虑到并发与竞争，而不是驱动都编写完了然后再处理并发与竞争。

三、保护内容是什么

💦那么问题来了，当发生竞争时，多个任务会访问同一个内存段或者共享资源，那什么是共享资源？
现实生活中的公共电话、共享单车这些是共享资源，我们都很容易理解，那么在程序中什么是共享资源？也就是保护的内容是什么？
💦我们保护的不是代码，而是数据！某个线程的局部变量不需要保护，我们要保护的是多个线程都会访问的共享数据。
💦比如：一个整形的全局变量 a 是数据，一份要打印的文档也是数据，虽然我们知道了要对共享数据进行保护，那么怎么判断哪些共享数据要保护呢？找到要保护的数据才是重点，而这个也是难点，因为驱动程序各不相同，那么数据也千变万化，一般像全局变量，设备结构体这些肯定是要保护的，至于其他的数据就要根据实际的驱动程序而定了。
💦当我们发现驱动程序中存在并发和竞争的时候一定要处理掉，接下来我们依次来学习一下Linux 内核提供的几种并发和竞争的处理方法。

四、解决并发与竞争的几种常用方法

1.原子操作

💦原子操作就是程序无法在分割，最终的执行方式。

原子整型API函数

💦原子整形操作，Linux中提供了相关的API函数，原子整形操作 API 函数格式：Linux 内核定义了叫做 atomic_t 的结构体来完成整形数据的原子操作，在使用中用原子变量来代替整形变量，此结构体定义在 include/linux/types.h 文件中，定义如下：

175 typedef struct {
176 int counter;
177 } atomic_t;

💦如果要使用原子操作 API 函数，首先要先定义一个 atomic_t 的变量，如下所示：

atomic_t a; //定义 a

💦也可以在定义原子变量的时候给原子变量赋初值，如下所示：

atomic_t b = ATOMIC_INIT(0); //定义原子变量 b 并赋初值为 0
在给原子变量赋值的话，必须使用Linux提供的API函数。

💦原子变量有了，然后就是对原子变量进行操作，比如读、写、增加、减少等等，Linux 内核提供了大量的原子操作 API 函数：
在这里插入图片描述
💦如果使用 64 位的 SOC 的话，就要用到 64 位的原子变量，Linux 内核也定义了 64 位原子结构体就可以了。

原子位操作 API 函数

💦位操作也是很常用的操作，Linux 内核也提供了一系列的原子位操作 API 函数，只不过原子位操作不像原子整形变量那样有个 atomic_t 的数据结构，原子位操作是直接对内存进行操作，API 函数如下：
在这里插入图片描述

2.自旋锁

💦原子操作只能对整形变量或者位进行保护，但是，在实际的项目中怎么可能只有整形变量或位这么简单的临界区。
💦比如，设备结构体变量就不是整型变量，我们对于结构体中成员变量的操作也要保证原子性，在线程 A 对结构体变量使用期间，应该禁止其他的线程来访问此结构体变量，这些工作原子操作都不能胜任，需要一种新的方式，所以在 Linux内核中就是自旋锁。
当一个线程要访问某个共享资源的时候首先要先获取相应的锁，锁只能被一个线程持有，只要此线程不释放持有的锁，那么其他的线程就不能获取此锁。对于自旋锁而言，如果自旋锁正在被线程 A 持有，线程 B 想要获取自旋锁，那么线程 B 就会处于忙循环-旋转-等待状态，线程 B 不会进入休眠状态或者说去做其他的处理，而是会一直傻傻的在那里“转圈圈”的等待锁可用。
💦比如现在有个公用电话亭，一次肯定只能进去一个人打电话，现在电话亭里面有人正在打电话，相当于获得了自旋锁。此时你到了电话亭门口，因为里面有人，所以你不能进去打电话，相当于没有获取自旋锁，这个时候你肯定是站在原地等待，你可能因为无聊的等待而转圈圈消遣时光，反正就是哪里也不能去，要一直等到里面的人打完电话出来。终于，里面的人打完电话出来了，相当于释放了自旋锁，这个时候你就可以使用电话亭打电话了，相当于获取到了自旋锁。
💦自旋锁的“自旋”也就是“原地打转”的意思，“原地打转”的目的是为了等待自旋锁可以用，可以访问共享资源。把自旋锁比作一个变量 a，变量 a=1 的时候表示共享资源可用，当 a=0的时候表示共享资源不可用。现在线程 A 要访问共享资源，发现 a=0(自旋锁被其他线程持有)，那么线程 A 就会不断的查询 a 的值，直到 a=1。
💦所以自旋锁的一个缺点：那就等待自旋锁的线程会一直处于自旋状态，这样会浪费处理器时间，降低系统性能，所以自旋锁的持有时间不能太长。所以自旋锁适用于短时期的轻量级加锁，不适用遇到需要长时间持有锁的场景。

自旋锁格式如下：

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

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;

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

spinlock_t lock; //定义自旋锁

自旋锁 API 函数

在这里插入图片描述
💦上图中的自旋锁API 函数适用于SMP或支持抢占的单CPU下线程之间的并发访问，也就是用于线程与线程之间，被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API 函数，否则的话会可能会导致死锁现象的发生。
💦自旋锁会自动禁止抢占，也就说当线程 A得到锁以后会暂时禁止内核抢占。如果线程 A 在持有锁期间进入了休眠状态，那么线程 A 会自动放弃 CPU 使用权。线程 B 开始运行，线程 B 也想要获取锁，但是此时锁被 A 线程持有，而且内核抢占还被禁止了！线程 B 无法被调度出去，那么线程 A 就无法运行，锁也就无法释放，死锁也就发生了！上图中API 函数用于线程之间的并发访问，如果此时中断也想访问共享资源，那该怎么办呢？首先可以肯定的是，中断里面可以使用自旋锁，但是在中断里面使用自旋锁的时候，在获取锁之前一定要先禁止本地中断(也就是本 CPU 中断，对于多核 SOC来说会有多个 CPU 核)，否则可能导致锁死现象的发生，如图下图所示：
在这里插入图片描述
线程 A 先运行，并且获取到了 lock 这个锁，当线程 A 运行 functionA 函数的时候中断发生了，中断抢走了 CPU 使用权。右边的中断服务函数也要获取 lock 这个锁，但是这个锁被线程 A 占有着，中断就会一直自旋，等待锁有效。但是在中断服务函数执行完之前，线程 A 是不可能执行的，线程 A 说“你先放手”，中断说“你先放手”，场面就这么僵持着，死锁发生！
💦所以在中断发生的时候，如何解决死锁的问题发生呢，最好的办法就是在获取锁之前就关闭本地中断，
Linux 内核提供了相应的 API 函数。
在这里插入图片描述
💦使用 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，格式如下：

1 DEFINE_SPINLOCK(lock) /* 定义并初始化一个锁 */
2 
3 /* 线程 A */
4 void functionA (){
5 unsigned long flags; /* 中断状态 */
6 spin_lock_irqsave(&lock, flags) /* 获取锁 */
7 /* 临界区 */
8 spin_unlock_irqrestore(&lock, flags) /* 释放锁 */
9 }
10
11 /* 中断服务函数 */
12 void irq() {
13 spin_lock(&lock) /* 获取锁 */
14 /* 临界区 */
15 spin_unlock(&lock) /* 释放锁 */
16 }

自旋锁的使用注意事项

①、因为在等待自旋锁的时候处于“自旋”状态，因此锁的持有时间不能太长，一定要短，否则的话会降低系统性能。如果临界区比较大，运行时间比较长的话要选择其他的并发处理方式，比如使用信号量和互斥体。
②、自旋锁保护的临界区内不能调用任何可能导致线程休眠的 API 函数，否则的话可能导致死锁。
③、不能递归申请自旋锁，因为一旦通过递归的方式申请一个你正在持有的锁，那么你就必须“自旋”，等待锁被释放，然而你正处于“自旋”状态，根本没法释放锁。结果就是自己把自己锁死了！
④、在编写驱动程序的时候我们必须考虑到驱动的可移植性，因此不管你用的是单核的还是多核的 SOC，都将其当做多核 SOC 来编写驱动程序。
总结：
线程与线程之间，在执行时，线程不能休眠
线程与中断，关闭本地中断

3.信号量

💦信号量是同步的一种方式，跟 FreeRTOS 或者 UCOS 信号量一样。Linux 内核也提供了信号量机制，信号量常常用于控制对共享资源的访问。
举一个很常见的例子，某个停车场有 100 个停车位，这 100 个停车位大家都可以用，对于大家来说这100 个停车位就是共享资源。假设现在这个停车场正常运行，你要把车停到这个这个停车场肯定要先看一下现在停了多少车了？还有没有停车位？当前停车数量就是一个信号量，具体的停车数量就是这个信号量值，当这个值到 100 的时候说明停车场满了。停车场满的时你可以等一会看看有没有其他的车开出停车场，当有车开出停车场的时候停车数量就会减一，也就是说信号量减一，此时你就可以把车停进去了，你把车停进去以后停车数量就会加一，也就是信号量加一。这就是一个典型的使用信号量进行共享资源管理的案例，在这个案例中使用的就是计数型信号量。
💦相比于自旋锁，信号量可以使线程进入休眠状态，比如 A 与 B、C 合租了一套房子，这个房子只有一个厕所，一次只能一个人使用。某一天早上 A 去上厕所了，过了一会 B 也想用厕所，因为 A 在厕所里面，所以 B 只能等到 A 用来了才能进去。B 要么就一直在厕所门口等着，等 A 出来，这个时候就相当于自旋锁。B 也可以告诉 A，让 A 出来以后通知他一下，然后 B 继续回房间睡觉，这个时候相当于信号量。可以看出，使用信号量会提高处理器的使用效率，毕竟不用一直傻乎乎的在那里“自旋”等待。
💦但是，信号量也是有缺点的，信号量的开销要比自旋锁大，因为信号量使线程进入休眠状态以后会切换线程，切换线程就会有开销。
总结一下信号量的特点：
①、因为信号量可以使等待资源线程进入休眠状态，因此适用于那些占用资源比较久的场合。
②、信号量不能用于中断中，因为信号量会引起休眠，中断不能休眠。
③、如果共享资源的持有时间比较短，那就不适合使用信号量了，因为频繁的休眠、切换线程引起的开销要远大于信号量带来的那点优势。
💦信号量有一个信号量值，相当于一个房子有 10 把钥匙，这 10 把钥匙就相当于信号量值为10。因此，可以通过信号量来控制访问共享资源的访问数量，如果要想进房间，那就要先获取一把钥匙，信号量值减 1，直到 10 把钥匙都被拿走，信号量值为 0，这个时候就不允许任何人进入房间了，因为没钥匙了。如果有人从房间出来，那他要归还他所持有的那把钥匙，信号量值加 1，此时有 1 把钥匙了，那么可以允许进去一个人。相当于通过信号量控制访问资源的线程数，在初始化的时候将信号量值设置的大于 1，那么这个信号量就是计数型信号量，计数型信号量不能用于互斥访问，因为它允许多个线程同时访问共享资源。如果要互斥的访问共享资源那么信号量的值就不能大于 1，此时的信号量就是一个二值信号量。

信号量 API 函数

💦Linux 内核使用 semaphore 结构体表示信号量，结构体内容如下所示：

struct semaphore {
 raw_spinlock_t lock;
 unsigned int count;
 struct list_head wait_list;
};

要想使用信号量就得先定义，然后初始化信号量。有关信号量的 API 函数如下：
在这里插入图片描述

信号量格式如下：

struct semaphore sem; /* 定义信号量 */
sema_init(&sem, 1); /* 初始化信号量 */
down(&sem); /* 申请信号量 */
/* 临界区 */
up(&sem); /* 释放信号量 */

4.互斥体

💦在 FreeRTOS 和 UCOS 中也有互斥体，将信号量的值设置为 1 就可以使用信号量进行互斥访问了，虽然可以通过信号量实现互斥，但是 Linux 提供了一个比信号量更专业的机制来进行互斥，它就是互斥体—mutex。互斥访问表示一次只有一个线程可以访问共享资源，不能递归申请互斥体。在我们编写 Linux 驱动的时候遇到需要互斥访问的地方建议使用 mutex。Linux 内核使用 mutex 结构体表示互斥体，定义如下：

struct mutex {
 /* 1: unlocked, 0: locked, negative: locked, possible waiters */
 atomic_t count;
 spinlock_t wait_lock;
};

在使用 mutex 之前要先定义一个 mutex 变量。在使用 mutex 的时候要注意如下几点：
①、mutex 可以导致休眠，因此不能在中断中使用 mutex，中断中只能使用自旋锁。
②、和信号量一样，mutex 保护的临界区可以调用引起阻塞的 API 函数。
③、因为一次只有一个线程可以持有 mutex，因此，必须由 mutex 的持有者释放 mutex。并且 mutex 不能递归上锁和解锁。

API函数如下

在这里插入图片描述

格式如下

1 struct mutex lock; /* 定义一个互斥体 */
2 mutex_init(&lock); /* 初始化互斥体 */
3
4 mutex_lock(&lock); /* 上锁 */
5 /* 临界区 */
6 mutex_unlock(&lock); /* 解锁 */

5.举例

原子变量举例

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/export.h>
#include <linux/types.h>
#include <linux/uaccess.h>			//  copy_to_user() & copy_from_user
#include <asm/io.h>      //ioremap
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
MODULE_AUTHOR("Jim Cromie <jim.cromie@gmail.com>");
MODULE_DESCRIPTION("NatSemi/Winbond PC-8736x GPIO Pin Driver");
MODULE_LICENSE("GPL");
#define DEVNAME "gpioled"
/*设备结构体*/
struct gpioled_dev{
    dev_t devid;/*设备号*/
    int major; /*主设备号*/
    int minor; /*次设备号*/
    struct cdev cdev;/*字符设备结构体*/
    struct class *class;/*类*/
    struct device *device;/*设备*/
    struct device_node *node;/*设备节点*/
    int led_gpio;
    atomic_t lock;  /*原子变量*/
};

struct gpioled_dev gpioled;/*led结构体变量*/
static int gpioled_open(struct inode *inode, struct file *filp)
{
      filp->private_data = &gpioled;
    /* 通过判断原子变量的值来检查 LED 有没有被别的应用使用
    当gpioled.lock小雨等于0时，表示驱动正在被使用 */
    if(atomic_read(&gpioled.lock) <= 0)
    {
        return -EBUSY;
    }else{
        atomic_dec(&gpioled.lock);
    }
  
    printk("gpioled_open\n\r");
    return 0;
}
static int gpioled_release(struct inode *inode, struct file *filp)
{
    struct  gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
   /* 关闭的时候释放原子变量*/
    atomic_inc(&dev->lock);
    //printk("gpioled_open\n\r");
    return 0;
}
static ssize_t gpioled_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    //struct gpioled *gpioled = (struct gpioled *)filp->private_data;
    //printk("gpioled_open\n\r");
    return 0;
}

static ssize_t gpioled_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) 
{
    struct gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
    int ret = 0;
    unsigned char databuff[1];
    ret = copy_from_user(databuff, buf, count);
    if(ret < 0)
    {
        printk("copy_from_user error\n\r");
        return -EPERM;
    }
    if(databuff[0] == 0)
    {
        gpio_set_value(dev->led_gpio, 0);
    }
    if(databuff[0] == 1)
    {
        gpio_set_value(dev->led_gpio, 1);
    }
    //printk("gpioled_open\n\r");
    return 0;
}

const struct file_operations gpioled_fops = {
    //.owner = THIS_MODULE,
   .open = gpioled_open,
   .release = gpioled_release,
   .read = gpioled_read,
   .write = gpioled_write,
};


static int __init gpioled_init(void)
{
    /*注册*/
    int ret = -1;
    /*初始化原子变量*/  
    atomic_set(&gpioled.lock, 1);
    /*设备号申请*/   
    if(gpioled.major){
        gpioled.devid = MKDEV(gpioled.major,0);
        ret = register_chrdev_region(gpioled.devid, 1, DEVNAME);
        

    }else{
        ret = alloc_chrdev_region(&gpioled.devid, 0, 1, DEVNAME);
        gpioled.major = MAJOR(gpioled.devid);
        gpioled.minor = MINOR(gpioled.devid);
    }
    if (ret < 0)
    {
        printk("alloc_chrdev_region failed\n");
        goto devid_fail;
    }
    printk("major=%d, minor=%d\n", gpioled.major, gpioled.minor);
    /*字符设备初始化*/
    cdev_init(&gpioled.cdev,&gpioled_fops);
    gpioled.cdev.owner = THIS_MODULE;
    gpioled.cdev.ops = &gpioled_fops;
    ret = cdev_add(&gpioled.cdev, gpioled.devid,1);
    if (ret < 0)
    {
        printk("cdev_add failed\n");
        goto cdev_add_fail;
    }
    /*类创建*/
    gpioled.class = class_create(THIS_MODULE, DEVNAME);
    if (IS_ERR(gpioled.class))
    {
        printk("class_create failed\n");
        goto class_create_fail;
    }
    /*设备创建*/
    gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, DEVNAME);
    if (IS_ERR(gpioled.device))
    {
        printk("device_create failed\n");
        goto device_create_fail;
    }
    //获取设备属性信息
    //1获取节点
    gpioled.node = of_find_node_by_path("/gpioled");
    if(gpioled.node == NULL)
    { 
        printk("of_find_node_by_path error\n\r");
        goto of_find_node_by_path_failed;
    }
   //2获取led灯gpio的编号
   gpioled.led_gpio = of_get_named_gpio(gpioled.node,"led-gpios",0);
   if(gpioled.led_gpio < 0)
   {
       printk("of_get_named_gpio error\n\r");
       goto of_get_named_gpio_failed;
   }
    printk("of_get_named_gpio=%d\n\r",gpioled.led_gpio);
    //3申请gpio,申请成功要记得释放
    ret = gpio_request(gpioled.led_gpio, "led-gpio");
	if (ret) {
		printk("gpio_request failed\n");
		goto gpio_request_failed;
	}
    //4使用io，设置输出
    ret = gpio_direction_output(gpioled.led_gpio, 1);
    if (ret) {
        printk("gpio_direction_output failed\n");
        goto gpio_direction_output_failed;
    }
    //5设置io为低电平
    gpio_set_value(gpioled.led_gpio, 0);
    return 0;
gpio_direction_output_failed:
    gpio_free(gpioled.led_gpio);
gpio_request_failed:
of_get_named_gpio_failed:
of_find_node_by_path_failed:
device_create_fail:
    class_destroy(gpioled.class);
class_create_fail:
    cdev_del(&gpioled.cdev);
cdev_add_fail:
    unregister_chrdev_region(gpioled.devid, 1);
devid_fail:
    return ret;

}
static void __exit gpioled_exit(void)
{   
     gpio_set_value(gpioled.led_gpio, 1);
    /*注销*/
    device_destroy(gpioled.class, gpioled.devid);
    class_destroy(gpioled.class);
    cdev_del(&gpioled.cdev);
    unregister_chrdev_region(gpioled.devid, 1);
    printk(KERN_INFO "gpioled_exit\n");
    /*释放io*/
    gpio_free(gpioled.led_gpio);

}
/*驱动入口函数和出口函数*/
module_init(gpioled_init);
module_exit(gpioled_exit);

自旋锁举例

💦我们使用原子变量实现了一次只能有一个应用程序访问 LED 灯，当使用自旋锁来实现此功能。在使用自旋锁之前，先回顾一下自旋锁的使用注意事项：
①、自旋锁保护的临界区要尽可能的短，因此在 open 函数中申请自旋锁，然后在 release 函数中释放自旋锁的方法就不可取。我们可以使用一个变量来表示设备的使用情况，如果设备被使用了那么变量就加一，设备被释放以后变量就减 1，我们只需要使用自旋锁保护这个变量即可。
②、考虑驱动的兼容性，合理的选择 API 函数。
综上所述，我们通过定义一个变量dev_status表示设备的使用情况，dev_status为 0 的时候表示设备没有被使用，dev_status大于 0 的时候表示设备被使用。驱动 open 函数中先判断 dev_status 是否为 0，也就是判断设备是否可用，如果为 0 的话就使用设备，并且将 dev_status加 1，表示设备被使用了。使用完以后在 release 函数中将dev_status减 1，表示设备没有被使用了。因此真正实现设备互斥访问的是变量 dev_stats，但是我们要使用自旋锁对 dev_status来做保护。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/export.h>
#include <linux/types.h>
#include <linux/uaccess.h>			//  copy_to_user() & copy_from_user
#include <asm/io.h>      //ioremap
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/spinlock.h>
MODULE_AUTHOR("Jim Cromie <jim.cromie@gmail.com>");
MODULE_DESCRIPTION("NatSemi/Winbond PC-8736x GPIO Pin Driver");
MODULE_LICENSE("GPL");
#define DEVNAME "gpioled"
/*设备结构体*/
struct gpioled_dev{
    dev_t devid;/*设备号*/
    int major; /*主设备号*/
    int minor; /*次设备号*/
    struct cdev cdev;/*字符设备结构体*/
    struct class *class;/*类*/
    struct device *device;/*设备*/
    struct device_node *node;/*设备节点*/
    int led_gpio;
    int status; 
    spinlock_t lock;  /*原子变量*/
};

struct gpioled_dev gpioled;/*led结构体变量*/
static int gpioled_open(struct inode *inode, struct file *filp)
{
    unsigned long flags;
      filp->private_data = &gpioled;
    /* 通过判断原子变量的值来检查 LED 有没有被别的应用使用*/
    //上锁
   spin_lock_irqsave(&gpioled.lock,flags);
  if(gpioled.status > 0){//设备已经被使用了
   spin_unlock_irqrestore(&gpioled.lock,flags);
    return -EBUSY;
  }
  gpioled.status++;
  spin_unlock_irqrestore(&gpioled.lock,flags);//解锁
    printk("gpioled_open\n\r");
    return 0;
}
static int gpioled_release(struct inode *inode, struct file *filp)
{
    unsigned long flags;
    struct  gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
   /* 释放*/
      //上锁
   spin_lock_irqsave(&dev->lock,flags);
   if(dev->status > 0){//设备已经被使用了
   gpioled.status--;
  }
  spin_unlock_irqrestore(&dev->lock,flags);//解锁
    return 0;
}
static ssize_t gpioled_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    //struct gpioled *gpioled = (struct gpioled *)filp->private_data;
    //printk("gpioled_open\n\r");
    return 0;
}

static ssize_t gpioled_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) 
{
    struct gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
    int ret = 0;
    unsigned char databuff[1];
    ret = copy_from_user(databuff, buf, count);
    if(ret < 0)
    {
        printk("copy_from_user error\n\r");
        return -EPERM;
    }
    if(databuff[0] == 0)
    {
        gpio_set_value(dev->led_gpio, 0);
    }
    if(databuff[0] == 1)
    {
        gpio_set_value(dev->led_gpio, 1);
    }
    //printk("gpioled_open\n\r");
    return 0;
}

const struct file_operations gpioled_fops = {
    //.owner = THIS_MODULE,
   .open = gpioled_open,
   .release = gpioled_release,
   .read = gpioled_read,
   .write = gpioled_write,
};


static int __init gpioled_init(void)
{
    /*注册*/
    int ret = -1;
    /*初始化自旋锁*/  
    spin_lock_init(&gpioled.lock);
  gpioled.status = 0;
    /*设备号申请*/   
    if(gpioled.major){
        gpioled.devid = MKDEV(gpioled.major,0);
        ret = register_chrdev_region(gpioled.devid, 1, DEVNAME);
        

    }else{
        ret = alloc_chrdev_region(&gpioled.devid, 0, 1, DEVNAME);
        gpioled.major = MAJOR(gpioled.devid);
        gpioled.minor = MINOR(gpioled.devid);
    }
    if (ret < 0)
    {
        printk("alloc_chrdev_region failed\n");
        goto devid_fail;
    }
    printk("major=%d, minor=%d\n", gpioled.major, gpioled.minor);
    /*字符设备初始化*/
    cdev_init(&gpioled.cdev,&gpioled_fops);
    gpioled.cdev.owner = THIS_MODULE;
    gpioled.cdev.ops = &gpioled_fops;
    ret = cdev_add(&gpioled.cdev, gpioled.devid,1);
    if (ret < 0)
    {
        printk("cdev_add failed\n");
        goto cdev_add_fail;
    }
    /*类创建*/
    gpioled.class = class_create(THIS_MODULE, DEVNAME);
    if (IS_ERR(gpioled.class))
    {
        printk("class_create failed\n");
        goto class_create_fail;
    }
    /*设备创建*/
    gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, DEVNAME);
    if (IS_ERR(gpioled.device))
    {
        printk("device_create failed\n");
        goto device_create_fail;
    }
    //获取设备属性信息
    //1获取节点
    gpioled.node = of_find_node_by_path("/gpioled");
    if(gpioled.node == NULL)
    { 
        printk("of_find_node_by_path error\n\r");
        goto of_find_node_by_path_failed;
    }
   //2获取led灯gpio的编号
   gpioled.led_gpio = of_get_named_gpio(gpioled.node,"led-gpios",0);
   if(gpioled.led_gpio < 0)
   {
       printk("of_get_named_gpio error\n\r");
       goto of_get_named_gpio_failed;
   }
    printk("of_get_named_gpio=%d\n\r",gpioled.led_gpio);
    //3申请gpio,申请成功要记得释放
    ret = gpio_request(gpioled.led_gpio, "led-gpio");
	if (ret) {
		printk("gpio_request failed\n");
		goto gpio_request_failed;
	}
    //4使用io，设置输出
    ret = gpio_direction_output(gpioled.led_gpio, 1);
    if (ret) {
        printk("gpio_direction_output failed\n");
        goto gpio_direction_output_failed;
    }
    //5设置io为低电平
    gpio_set_value(gpioled.led_gpio, 0);
    return 0;
gpio_direction_output_failed:
    gpio_free(gpioled.led_gpio);
gpio_request_failed:
of_get_named_gpio_failed:
of_find_node_by_path_failed:
device_create_fail:
    class_destroy(gpioled.class);
class_create_fail:
    cdev_del(&gpioled.cdev);
cdev_add_fail:
    unregister_chrdev_region(gpioled.devid, 1);
devid_fail:
    return ret;

}
static void __exit gpioled_exit(void)
{   
     gpio_set_value(gpioled.led_gpio, 1);
    /*注销*/
    device_destroy(gpioled.class, gpioled.devid);
    class_destroy(gpioled.class);
    cdev_del(&gpioled.cdev);
    unregister_chrdev_region(gpioled.devid, 1);
    printk(KERN_INFO "gpioled_exit\n");
    /*释放io*/
    gpio_free(gpioled.led_gpio);

}
/*驱动入口函数和出口函数*/
module_init(gpioled_init);
module_exit(gpioled_exit);

信号量举例

💦使用信号量实现了一次只能有一个应用程序访问 LED 灯，信号量可以导致休眠，因此信号量保护的临界区没有运行时间限制，可以在驱动的 open 函数申请信号量，然后在release 函数中释放信号量，如果执行了两次程序访问LED，会自动唤醒下次执行。但是信号量不能用在中断中，实验我们不会在中断中使用信号量。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/export.h>
#include <linux/types.h>
#include <linux/uaccess.h>			//  copy_to_user() & copy_from_user
#include <asm/io.h>      //ioremap
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/spinlock.h>
#include <linux/semaphore.h>
MODULE_AUTHOR("Jim Cromie <jim.cromie@gmail.com>");
MODULE_DESCRIPTION("NatSemi/Winbond PC-8736x GPIO Pin Driver");
MODULE_LICENSE("GPL");
#define DEVNAME "gpioled"
/*设备结构体*/
struct gpioled_dev{
    dev_t devid;/*设备号*/
    int major; /*主设备号*/
    int minor; /*次设备号*/
    struct cdev cdev;/*字符设备结构体*/
    struct class *class;/*类*/
    struct device *device;/*设备*/
    struct device_node *node;/*设备节点*/
    int led_gpio;
   
    struct semaphore sem;  /*信号量*/
};

struct gpioled_dev gpioled;/*led结构体变量*/
static int gpioled_open(struct inode *inode, struct file *filp)
{

      filp->private_data = &gpioled;
    /* 获取信号量，进入休眠的状态进程可以被信号打断*/
    if(down_interruptible(&gpioled.sem))
    {
        printk("gpioled.sem = %ld\n\r",gpioled.sem);
        return -1;
    }
    printk("gpioled_open\n\r");
    return 0;
}
static int gpioled_release(struct inode *inode, struct file *filp)
{
    
    struct  gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
   /* 释放信号量，值增加1*/
  up(&dev->sem);
  printk("gpioled.sem = %ld\n\r",&dev->sem);
    return 0;
}
static ssize_t gpioled_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    //struct gpioled *gpioled = (struct gpioled *)filp->private_data;
    //printk("gpioled_open\n\r");
    return 0;
}

static ssize_t gpioled_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) 
{
    struct gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
    int ret = 0;
    unsigned char databuff[1];
    ret = copy_from_user(databuff, buf, count);
    if(ret < 0)
    {
        printk("copy_from_user error\n\r");
        return -EPERM;
    }
    if(databuff[0] == 0)
    {
        gpio_set_value(dev->led_gpio, 0);
    }
    if(databuff[0] == 1)
    {
        gpio_set_value(dev->led_gpio, 1);
    }
    //printk("gpioled_open\n\r");
    return 0;
}

const struct file_operations gpioled_fops = {
    //.owner = THIS_MODULE,
   .open = gpioled_open,
   .release = gpioled_release,
   .read = gpioled_read,
   .write = gpioled_write,
};


static int __init gpioled_init(void)
{
    /*注册*/
    int ret = -1;
    /*初始化信号量*/  
    sema_init(&gpioled.sem,1);
    /*设备号申请*/   
    if(gpioled.major){
        gpioled.devid = MKDEV(gpioled.major,0);
        ret = register_chrdev_region(gpioled.devid, 1, DEVNAME);
        

    }else{
        ret = alloc_chrdev_region(&gpioled.devid, 0, 1, DEVNAME);
        gpioled.major = MAJOR(gpioled.devid);
        gpioled.minor = MINOR(gpioled.devid);
    }
    if (ret < 0)
    {
        printk("alloc_chrdev_region failed\n");
        goto devid_fail;
    }
    printk("major=%d, minor=%d\n", gpioled.major, gpioled.minor);
    /*字符设备初始化*/
    cdev_init(&gpioled.cdev,&gpioled_fops);
    gpioled.cdev.owner = THIS_MODULE;
    gpioled.cdev.ops = &gpioled_fops;
    ret = cdev_add(&gpioled.cdev, gpioled.devid,1);
    if (ret < 0)
    {
        printk("cdev_add failed\n");
        goto cdev_add_fail;
    }
    /*类创建*/
    gpioled.class = class_create(THIS_MODULE, DEVNAME);
    if (IS_ERR(gpioled.class))
    {
        printk("class_create failed\n");
        goto class_create_fail;
    }
    /*设备创建*/
    gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, DEVNAME);
    if (IS_ERR(gpioled.device))
    {
        printk("device_create failed\n");
        goto device_create_fail;
    }
    //获取设备属性信息
    //1获取节点
    gpioled.node = of_find_node_by_path("/gpioled");
    if(gpioled.node == NULL)
    { 
        printk("of_find_node_by_path error\n\r");
        goto of_find_node_by_path_failed;
    }
   //2获取led灯gpio的编号
   gpioled.led_gpio = of_get_named_gpio(gpioled.node,"led-gpios",0);
   if(gpioled.led_gpio < 0)
   {
       printk("of_get_named_gpio error\n\r");
       goto of_get_named_gpio_failed;
   }
    printk("of_get_named_gpio=%d\n\r",gpioled.led_gpio);
    //3申请gpio,申请成功要记得释放
    ret = gpio_request(gpioled.led_gpio, "led-gpio");
	if (ret) {
		printk("gpio_request failed\n");
		goto gpio_request_failed;
	}
    //4使用io，设置输出
    ret = gpio_direction_output(gpioled.led_gpio, 1);
    if (ret) {
        printk("gpio_direction_output failed\n");
        goto gpio_direction_output_failed;
    }
    //5设置io为低电平
    gpio_set_value(gpioled.led_gpio, 0);
    return 0;
gpio_direction_output_failed:
    gpio_free(gpioled.led_gpio);
gpio_request_failed:
of_get_named_gpio_failed:
of_find_node_by_path_failed:
device_create_fail:
    class_destroy(gpioled.class);
class_create_fail:
    cdev_del(&gpioled.cdev);
cdev_add_fail:
    unregister_chrdev_region(gpioled.devid, 1);
devid_fail:
    return ret;

}
static void __exit gpioled_exit(void)
{   
     gpio_set_value(gpioled.led_gpio, 1);
    /*注销*/
    device_destroy(gpioled.class, gpioled.devid);
    class_destroy(gpioled.class);
    cdev_del(&gpioled.cdev);
    unregister_chrdev_region(gpioled.devid, 1);
    printk(KERN_INFO "gpioled_exit\n");
    /*释放io*/
    gpio_free(gpioled.led_gpio);

}
/*驱动入口函数和出口函数*/
module_init(gpioled_init);
module_exit(gpioled_exit);

💦注意两个命令都是运行在后台，第一条命令先获取到信号量，因此可以操作 LED 灯，将LED 灯打开，并且占有 25S。第二条命令因为获取信号量失败而进入休眠状态，等待第一条命令运行完毕并释放信号量以后才拥有 LED 灯使用权，将 LED 灯关闭
在这里插入图片描述
💦从上图可以看出，连续两次执行led程序，它会等到第一次执行结束，在换醒第二次执行。
💦总结一下，当信号量 sem 为 1 的时候表示 LED 灯还没有被使用，如果应用程序 A 要使用LED 灯，先调用 open 函数打开/dev/gpioled，这个时候会获取信号量 sem，获取成功以后 sem 的值减 1 变为 0。如果此时应用程序 B 也要使用 LED 灯，调用 open 函数打开/dev/gpioled 就会因为信号量无效(值为 0)而进入休眠状态。当应用程序 A 运行完毕，调用 close 函数关闭/dev/gpioled的时候就会释放信号量 sem，此时信号量 sem 的值就会加 1，变为 1。信号量 sem 再次有效，表示其他应用程序可以使用 LED 灯了，此时在休眠状态的应用程序 B 就会获取到信号量 sem，获取成功以后就开始使用 LED 灯。

互斥体举例

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/export.h>
#include <linux/types.h>
#include <linux/uaccess.h>			//  copy_to_user() & copy_from_user
#include <asm/io.h>      //ioremap
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/spinlock.h>
#include <linux/semaphore.h>
MODULE_AUTHOR("Jim Cromie <jim.cromie@gmail.com>");
MODULE_DESCRIPTION("NatSemi/Winbond PC-8736x GPIO Pin Driver");
MODULE_LICENSE("GPL");
#define DEVNAME "gpioled"
/*设备结构体*/
struct gpioled_dev{
    dev_t devid;/*设备号*/
    int major; /*主设备号*/
    int minor; /*次设备号*/
    struct cdev cdev;/*字符设备结构体*/
    struct class *class;/*类*/
    struct device *device;/*设备*/
    struct device_node *node;/*设备节点*/
    int led_gpio;
   
    struct mutex lock;  /*互斥量*/
};

struct gpioled_dev gpioled;/*led结构体变量*/
static int gpioled_open(struct inode *inode, struct file *filp)
{

      filp->private_data = &gpioled;
    /* 获取信号量，进入休眠的状态进程可以被信号打断*/
    if(mutex_lock_interruptible(&gpioled.lock))
    {
       // printk("gpioled.sem = %ld\n\r",gpioled.sem);
        return -1;
    }
    printk("gpioled_open\n\r");
    return 0;
}
static int gpioled_release(struct inode *inode, struct file *filp)
{
    
    struct  gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
   /* 释放互斥锁*/
  mutex_unlock(&dev->lock);
  //printk("gpioled.sem = %ld\n\r",&dev->sem);
    return 0;
}
static ssize_t gpioled_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    //struct gpioled *gpioled = (struct gpioled *)filp->private_data;
    //printk("gpioled_open\n\r");
    return 0;
}

static ssize_t gpioled_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) 
{
    struct gpioled_dev *dev = (struct gpioled_dev *)filp->private_data;
    int ret = 0;
    unsigned char databuff[1];
    ret = copy_from_user(databuff, buf, count);
    if(ret < 0)
    {
        printk("copy_from_user error\n\r");
        return -EPERM;
    }
    if(databuff[0] == 0)
    {
        gpio_set_value(dev->led_gpio, 0);
    }
    if(databuff[0] == 1)
    {
        gpio_set_value(dev->led_gpio, 1);
    }
    //printk("gpioled_open\n\r");
    return 0;
}

const struct file_operations gpioled_fops = {
    //.owner = THIS_MODULE,
   .open = gpioled_open,
   .release = gpioled_release,
   .read = gpioled_read,
   .write = gpioled_write,
};


static int __init gpioled_init(void)
{
    /*注册*/
    int ret = -1;
    /*初始化互斥量*/  
    mutex_init(&gpioled.lock);
    /*设备号申请*/   
    if(gpioled.major){
        gpioled.devid = MKDEV(gpioled.major,0);
        ret = register_chrdev_region(gpioled.devid, 1, DEVNAME);
        

    }else{
        ret = alloc_chrdev_region(&gpioled.devid, 0, 1, DEVNAME);
        gpioled.major = MAJOR(gpioled.devid);
        gpioled.minor = MINOR(gpioled.devid);
    }
    if (ret < 0)
    {
        printk("alloc_chrdev_region failed\n");
        goto devid_fail;
    }
    printk("major=%d, minor=%d\n", gpioled.major, gpioled.minor);
    /*字符设备初始化*/
    cdev_init(&gpioled.cdev,&gpioled_fops);
    gpioled.cdev.owner = THIS_MODULE;
    gpioled.cdev.ops = &gpioled_fops;
    ret = cdev_add(&gpioled.cdev, gpioled.devid,1);
    if (ret < 0)
    {
        printk("cdev_add failed\n");
        goto cdev_add_fail;
    }
    /*类创建*/
    gpioled.class = class_create(THIS_MODULE, DEVNAME);
    if (IS_ERR(gpioled.class))
    {
        printk("class_create failed\n");
        goto class_create_fail;
    }
    /*设备创建*/
    gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, DEVNAME);
    if (IS_ERR(gpioled.device))
    {
        printk("device_create failed\n");
        goto device_create_fail;
    }
    //获取设备属性信息
    //1获取节点
    gpioled.node = of_find_node_by_path("/gpioled");
    if(gpioled.node == NULL)
    { 
        printk("of_find_node_by_path error\n\r");
        goto of_find_node_by_path_failed;
    }
   //2获取led灯gpio的编号
   gpioled.led_gpio = of_get_named_gpio(gpioled.node,"led-gpios",0);
   if(gpioled.led_gpio < 0)
   {
       printk("of_get_named_gpio error\n\r");
       goto of_get_named_gpio_failed;
   }
    printk("of_get_named_gpio=%d\n\r",gpioled.led_gpio);
    //3申请gpio,申请成功要记得释放
    ret = gpio_request(gpioled.led_gpio, "led-gpio");
	if (ret) {
		printk("gpio_request failed\n");
		goto gpio_request_failed;
	}
    //4使用io，设置输出
    ret = gpio_direction_output(gpioled.led_gpio, 1);
    if (ret) {
        printk("gpio_direction_output failed\n");
        goto gpio_direction_output_failed;
    }
    //5设置io为低电平
    gpio_set_value(gpioled.led_gpio, 0);
    return 0;
gpio_direction_output_failed:
    gpio_free(gpioled.led_gpio);
gpio_request_failed:
of_get_named_gpio_failed:
of_find_node_by_path_failed:
device_create_fail:
    class_destroy(gpioled.class);
class_create_fail:
    cdev_del(&gpioled.cdev);
cdev_add_fail:
    unregister_chrdev_region(gpioled.devid, 1);
devid_fail:
    return ret;

}
static void __exit gpioled_exit(void)
{   
     gpio_set_value(gpioled.led_gpio, 1);
    /*注销*/
    device_destroy(gpioled.class, gpioled.devid);
    class_destroy(gpioled.class);
    cdev_del(&gpioled.cdev);
    unregister_chrdev_region(gpioled.devid, 1);
    printk(KERN_INFO "gpioled_exit\n");
    /*释放io*/
    gpio_free(gpioled.led_gpio);

}
/*驱动入口函数和出口函数*/
module_init(gpioled_init);
module_exit(gpioled_exit);

💦在 open 函数中调用 mutex_lock_interruptible 或者 mutex_lock 获取 mutex，成功的话就表示可以使用 LED 灯，失败的话就会进入休眠状态，和信号量一样。
💦在 release 函数中调用 mutex_unlock 函数释放 mutex，这样其他应用程序就可以获取 mutex 了。在驱动入口函数中调用 mutex_init 初始化 mutex。
💦互斥体和二值信号量类似，只不过互斥体是专门用于互斥访问的。