Linux教程
Linux驱动开发七.并发与竞争——2.实际操作
本文主要是介绍Linux驱动开发七.并发与竞争——2.实际操作，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
我们在前面讲了处理竞争和并发问题的四种机制，下面可以通过一些驱动来检验一下。
原子操作
原子操作用了最基础的一个虚拟的设备来演示，在设备模块被加载后生成了设备节点，我们使用APP程序打开设备节点后是有个线程访问了该设备里的数据，当另外一个APP重新要打开这个数据时就无法正常访问了。
1 /**
2 * @file atomic.c
3 * @author your name (you@domain.com)
4 * @brief 原子变量测试
5 * @version 0.1
6 * @date 2022-07-07
7 *
8 * @copyright Copyright (c) 2022
9 *
10 */
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/init.h>
14 #include <linux/fs.h>
15 #include <linux/uaccess.h>
16 #include <linux/io.h>
17 #include <linux/types.h>
18 #include <linux/cdev.h>
19 #include <linux/device.h>
20 #include <linux/of.h>
21 #include <linux/of_address.h>
22 #include <linux/of_irq.h>
23 #include <linux/gpio.h>
24 #include <linux/of_gpio.h>
25 #include <linux/atomic.h>
26
27 #define DEVICE_CNT 1
28 #define DEVICE_NAME "DEV"
29
30 struct test_dev
31 {
32 dev_t dev_id;
33 int major;
34 int minor;
35 struct class *class;
36 struct device *device;
37 struct cdev cdev;
38 struct device_node *dev_nd;
39 atomic_t atomic_data; //原子变量
40 };
41
42 struct test_dev dev;
43
44 static ssize_t dev_open(struct inode *inode, struct file *filp)
45 {
46 filp->private_data = &dev; //设置私有数据
47 //首次打开文件时，流程为else，原子变量值减1为0,再次打开后值为0走if流程，返回-EBUSY状态
48 if(atomic_read(&dev.atomic_data) <= 0){ //获取原子变量值
49 return -EBUSY;
50 }
51 else{
52 atomic_dec(&dev.atomic_data);
53 }
54 return 0;
55 }
56
57 static ssize_t dev_write(struct file *filp,const char __user *buf,
58 size_t count,loff_t *ppos)
59 {
60 int ret = 0;
61 return ret;
62 }
63
64 static int dev_release(struct inode *inode,struct file *filp)
65 {
66 //文件关闭，原子变量自增(打开文件时减一为0,关闭后变成1,可以再次打开文件)
67 struct test_dev *dev = filp->private_data;
68 atomic_inc(&dev->atomic_data);
69 return 0;
70 }
71
72 /**
73 * @brief 文件操作集合
74 *
75 */
76 static const struct file_operations gpiofops = {
77 .owner = THIS_MODULE,
78 .open = dev_open,
79 .release = dev_release,
80 };
81
82 static int __init dev_init(void){
83
84 int ret = 0;
85 //初始化原子变量，赋值为1
86 atomic_set(&dev.atomic_data,1);
87
88 //申请设备号
89 dev.major = 0;
90 if(dev.major){
91 //手动指定设备号，使用指定的设备号
92 dev.dev_id = MKDEV(dev.major,0);
93 ret = register_chrdev_region(dev.dev_id,DEVICE_CNT,DEVICE_NAME);
94 }
95 else{
96 //设备号未指定，申请设备号
97 ret = alloc_chrdev_region(&dev.dev_id,0,DEVICE_CNT,DEVICE_NAME);
98 dev.major = MAJOR(dev.dev_id);
99 dev.minor = MINOR(dev.dev_id);
100 }
101 printk("dev id geted!\r\n");
102
103 if(ret<0){
104 //设备号申请异常，跳转至异常处理
105 goto faile_devid;
106 }
107
108 //字符设备cdev初始化
109 dev.cdev.owner = THIS_MODULE;
110
111 cdev_init(&dev.cdev,&gpiofops); //文件操作集合映射
112
113 ret = cdev_add(&dev.cdev,dev.dev_id,DEVICE_CNT);
114 if(ret<0){
115 //cdev初始化异常，跳转至异常处理
116 goto fail_cdev;
117 }
118
119 printk("chr dev inited!\r\n");
120
121 //自动创建设备节点
122 dev.class = class_create(THIS_MODULE,DEVICE_NAME);
123 if(IS_ERR(dev.class)){
124 //class创建异常处理
125 printk("class err!\r\n");
126 ret = PTR_ERR(dev.class);
127 goto fail_class;
128 }
129 printk("dev class created\r\n");
130 dev.device = device_create(dev.class,NULL,dev.dev_id,NULL,DEVICE_NAME);
131 if(IS_ERR(dev.device)){
132 //设备创建异常处理
133 printk("device err!\r\n");
134 ret = PTR_ERR(dev.device);
135 goto fail_device;
136 }
137 printk("device created!\r\n");
138
139 return 0;
140
141 fail_device:
142 //device创建失败，意味着class创建成功，应该将class销毁
143 printk("device create err,class destroyed\r\n");
144 class_destroy(dev.class);
145 fail_class:
146 //类创建失败，意味着设备应该已经创建成功，此刻应将其释放掉
147 printk("class create err,cdev del\r\n");
148 cdev_del(&dev.cdev);
149 fail_cdev:
150 //cdev初始化异常，意味着设备号已经申请完成，应将其释放
151 printk("cdev init err,chrdev register\r\n");
152 unregister_chrdev_region(dev.dev_id,DEVICE_CNT);
153 faile_devid:
154 //设备号申请异常，由于是第一步操作，不需要进行其他处理
155 printk("dev id err\r\n");
156 return ret;
157 }
158
159 static void __exit dev_exit(void)
160 {
161 cdev_del(&dev.cdev);
162 unregister_chrdev_region(dev.dev_id,DEVICE_CNT);
163
164 device_destroy(dev.class,dev.dev_id);
165 class_destroy(dev.class);
166 }
167
168 module_init(dev_init);
169 module_exit(dev_exit);
170
171 MODULE_LICENSE("GPL");
172 MODULE_AUTHOR("ZeqiZ");
整个程序比较简单，就是在驱动框架的基础上进行了写小变动，主要是文件操作的几个函数做了相应的修改。
第39行，在设备结构体中，我们定义了一个原子变量atomic_data，注意这个变量为整形变量
第86行，驱动模块在初始化过程中对原子变量进行初始化，并赋值为1
第44-55行，设备结构体dev被作为文件的私有数据，在文件首次被打开时，由于atomic_data初始值为1，文件能正常打开，文件打开后atomic_data进行自减操作变成0。此刻如果有另外一个线程进行了文件打开操作，atomic_data值为0，函数返回-EBUSY异常
第64到69行，设备文件被关闭，atomic_data进行自增操作，值重新为1，文件可以再次被打开。
这个APP需要修改一下
1 /**
2 * @file atomicAPP.c
3 * @author your name (you@domain.com)
4 * @brief 原子数据测试APP
5 * @version 0.1
6 * @date 2022-07-07
7 *
8 * @copyright Copyright (c) 2022
9 *
10 */
11 #include <sys/types.h>
12 #include <sys/stat.h>
13 #include <fcntl.h>
14 #include <unistd.h>
15 #include <stdio.h>
16 #include <stdlib.h>
17
18 /**
19 * @brief
20 *
21 * @param argc //参数个数
22 * @param argv //参数
23 * @return int
24 */
25 int main(int argc,char *argv[])
26 {
27 char *filename; //文件名
28 filename = argv[1]; //文件名为命令行后第二个参数(索引值为1)
29
30 int ret = 0; //初始化操作返回值
31 int f = 0; //初始化文件句柄
32 int cnt=0;
33
34 if(argc != 2){ //输入参数个数不为3,提示输入格式错误
35 printf("input format error!\r\n");
36 }
37
38 f = open(filename, O_RDWR); //打开文件
39 if(f < 0){
40 printf("file open error\r\n");
41 return -1;
42 }
43
44 while(1){
45 printf("file opened\r\n");
46 sleep(5);
47 cnt++;
48 printf("App running times:%d\r\n",cnt);
49 if(cnt>=3){
50 break;
51 }
52 }
53
54 printf("App running finished\r\n");
55
56 close(f); //关闭文件
57 printf("file closed!\r\n");
58 return 0;
59 }
在APP里主要处理一个文件打开的操作，由于我们没发模拟线程访问数据的过程，只能通过开启文件然后延时来模拟线程持有数据的过程。然后用了个for循环3次显示程序正在运行。最后程序运行的效果如下图
我在运行程序时加了个&符号，意思是后台运行程序，运行期间再在终端重新使用命令打开文件，就会有错误提示。如果在运行程序期间使用ps命令打印进程，就可以看到我们运行的程序
注意上面那个图最下面还显示出来程序正在运行(APP里打印文件打开的语句应该放在for循环外面，这里实在不想改了。。。)
程序优化
这个上面的过程我们使用了下面两组原子变量的操作
atomic_dec(&dev.atomic_data); atomic_inc(&dev.atomic_data);
另外还结合了if语句进行判定加上else来选择流程，但是Linux内核给我们提供了另一个API，在自增/减的时候直接判定
static ssize_t dev_open(struct inode *inode, struct file *filp)
{
filp->private_data = &dev; //设置私有数据
//首次打开文件时，流程为else，原子变量值减1为0,再次打开后值为0走if流程，返回-EBUSY状态
#if 0
if(atomic_read(&dev.atomic_data) <= 0){ //获取原子变量值
return -EBUSY;
}
else{
atomic_dec(&dev.atomic_data);
}
#endif
if(!atomic_dec_and_test(&dev.atomic_data)){
atomic_inc(&dev.atomic_data);
return -EBUSY;
}
return 0;
}
注意函数操作顺序
atomic_dec_and_test(&dev.atomic_data)
先将变量减一，再判定，如果减一后结果为0则返回1，否则返回0。我们开始将变量初始化为1，进行减一后变成0,函数返回1，用来一个非运算，就不用执行if结构里的代码直接return，如果文件已经打开，变量值为0，自减后不为0,返回1，非运算后执行if结构体里内容，因为前面判定时减了1,所以要再加回去，返回异常值。这种结构是Linux内核中驱动开发的主要使用方法，在内核里搜索一下很多案例可以供我们参考。总之，这种整形的原子变量，在我们用作计数器的时候非常普遍。
自旋锁操作
自旋锁的演示和前面原子操作差不多，不放全部代码了，区别就是在定义设备结构体时要定义一个锁和一个状态字。
struct test_dev
{
dev_t dev_id;
int major;
int minor;
struct class *class;
struct device *device;
struct cdev cdev;
struct device_node *dev_nd;
int dev_status; //设备状态，0时可被使用，1时不可使用
spinlock_t lock; //自旋锁
};
在设备初始化的时候要将锁和状态字初始化，
static int __init dev_init(void){
int ret = 0;
//初始化自旋锁
spin_lock_init(&dev.lock);
dev.dev_status = 0;
//.....后面省略
把状态初始化为0,表示0未上锁，1时上锁
锁的操作在open和release对应的函数中
static ssize_t dev_open(struct inode *inode, struct file *filp)
{
filp->private_data = &dev; //设置私有数
printk("open\r\n");
spin_lock(&dev.lock);
if(dev.dev_status){ //判定是否被占用
spin_unlock(&dev.lock);
return -EBUSY;
}
dev.dev_status++; //自增，非0表示被占用
spin_unlock(&dev.lock);
return 0;
}
static int dev_release(struct inode *inode,struct file *filp)
{
struct test_dev *dev = filp->private_data;
spin_lock(&dev->lock);
if(dev->dev_status){
dev->dev_status--; //未被占用，自减至0,表示未被占用
}
spin_unlock(&dev->lock);
return 0;
}
注意看一下，我们在前面讲过，自旋锁是一种轻量锁，所以自旋锁锁定的是状态字而不是数据，如果是锁数据，当数据量很大的情况下自旋锁操作就不方便了。这就是我们在前面讲到的，自旋锁主要用来锁临界区。其实上面这种效果用原子操作是比较合适的，这么用主要是为了演示自旋锁的用法
这里应用演示和前面的效果一样，我就不在截图了(主要是没想好怎么模拟两条线程访问的方法)
自旋锁中断处理
在上一章里讲到过，因为系统中的中断是不好控制的，如果使用自旋锁最好将本地中断禁止掉，所以上面open和release两个函数最好使用中断禁止的自旋锁请求
static ssize_t dev_open(struct inode *inode, struct file *filp)
{
unsigned long irqflag;
filp->private_data = &dev; //设置私有数
printk("open\r\n");
spin_lock_irqsave(&dev.lock,irqflag);
if(dev.dev_status){
spin_unlock_irqrestore(&dev.lock);
return -EBUSY;}
//if条件为真，不能使用
dev.dev_status++;
spin_unlock_irqrestore(&dev.lock,irqflag);
return 0;
}
static int dev_release(struct inode *inode,struct file *filp)
{
struct test_dev *dev = filp->private_data;
unsigned long irqflag; //中断标志
spin_lock_irqsave(&dev->lock,irqflag);
if(dev->dev_status){
dev->dev_status--;
}
spin_unlock_irqrestore(&dev->lock,irqflag);
return 0;
}
整个流程差不多，只用声明一个变量来描述中断标志就可以了。
信号量
信号量的使用要简单的多，直接看代码
struct test_dev
{
dev_t dev_id;
int major;
int minor;
struct class *class;
struct device *device;
struct cdev cdev;
struct device_node *dev_nd;
struct semaphore sem; //信号量
};
struct test_dev dev;
static ssize_t dev_open(struct inode *inode, struct file *filp)
{
filp->private_data = &dev; //设置私有数
printk("open\r\n");
down(&dev.sem); //获取信号量
return 0;
}
static int dev_release(struct inode *inode,struct file *filp)
{
struct test_dev *dev = filp->private_data;
up(&dev->sem)；
return 0;
}
在初始化函数要对变量进行初始化
static int __init dev_init(void){
int ret = 0;
//初始化信号量
sema_init(&dev.sem,1);
将信号量初始化为1，在打开文件时会down操作将信号量自减1，如果自减后变成0线程就会休眠，直到有up操作将信号量恢复到非0状态(注意变量类型，如果在定义设备结构体时没有加*指针后面使用时要加取址符，加了*后面初始化和up,down是就不加取址符了！还有关键字是semaphore，还有另外一个关键字跟他很像：semphore，用自动补全时一定要注意，当初在这里卡了半天！)。是不是简单的多！把APP程序稍微修改一下
/**
* @file semaAPP.c
* @author your name (you@domain.com)
* @brief
* @version 0.1
* @date 2022-07-10
*
* @copyright Copyright (c) 2022
*
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
/**
* @brief
*
* @param argc //参数个数
* @param argv //参数
* @return int
*/
int main(int argc,char *argv[])
{
char *filename; //文件名
filename = argv[1]; //文件名为命令行后第二个参数(索引值为1)
char *id;
id = argv[2];
int ret = 0; //初始化操作返回值
int f = 0; //初始化文件句柄
int cnt=0;
if(argc != 3){ //输入参数个数不为3,提示输入格式错误
printf("input format error!\r\n");
}
f = open(filename, O_RDWR); //打开文件
printf("id=%s file open\r\n",id);
if(f < 0){
printf("file open error\r\n");
return -1;
}
while(1){
sleep(5);
cnt++;
printf("App id = %s running times:%d\r\n",id,cnt);
if(cnt>=5){
break;
}
}
printf("App id=%s running finished\r\n" ,id);
close(f); //关闭文件
return 0;
}
运行程序时，第三个参数为程序id，运行一下看看效果
运行APP测试一下，当我们第一次运行程序，程序正常执行，当第2个程序调用的时候，由于信号量初始值为1，就会被挂起来，直到第一个程序运行完后执行力up命令恢复了信号量后第二个程序开始运行，注意打印的id号。如果初始化信号量时候将信号量的值设置为大于1时，那么可以同时运行的程序就不止1个了。
互斥体
互斥体的使用方法和信号量差不多，把部分代码放下面
struct test_dev
{
dev_t dev_id;
int major;
int minor;
struct class *class;
struct device *device;
struct cdev cdev;
struct device_node *dev_nd;
struct mutex mut;
};
struct test_dev dev;
static ssize_t dev_open(struct inode *inode, struct file *filp)
{
filp->private_data = &dev; //设置私有数
printk("open\r\n");
mutex_lock(&dev.mut);
return 0;
}
static int dev_release(struct inode *inode,struct file *filp)
{
struct test_dev *dev = filp->private_data;
mutex_unlock(&dev->mut);
return 0;
}
还有初始化
static int __init dev_init(void){
int ret = 0;
//初始化
mutex_init(&dev.mut);
使用效果跟前面的信号量值为1时是一样的。
信号量和互斥体还有个用法是在休眠时允许信号打断，这个用法以后用到的概率会比较大，这里就先不讲了，后面肯定会用到。
这篇关于Linux驱动开发七.并发与竞争——2.实际操作的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
git仓库有更新，jenkins 自动触发拉代码怎么配置的？-icode9专业技术文章分享12-18
-
Jenkins webhook 方式怎么配置指定的分支？-icode9专业技术文章分享12-18
-
Linux C++项目实战入门教程12-13
-
Linux C++编程项目实战入门教程12-13
-
Linux部署Scrapy教程：新手入门指南12-11
-
怎么将在本地创建的 Maven 仓库迁移到 Linux 服务器上？-icode9专业技术文章分享12-11
-
Linux常用命令12-10
-
谁看谁服！ Linux 创始人对于进程和线程的理解是…12-06
-
操作系统教程：新手入门及初级技巧详解12-04
-
操作系统入门：新手必学指南12-04
-
操作系统入门指南：从零开始学习操作系统12-04
-
linux 系统宝塔查看网站访问的命令是什么？-icode9专业技术文章分享11-23
-
如何创建可引导的 ESXi USB 安装介质 (macOS, Linux, Windows)11-12
-
linux的 vi编辑器中搜索关键字有哪些常用的命令和技巧？-icode9专业技术文章分享11-08
-
在 Linux 的 vi 或 vim 编辑器中什么命令可以直接跳到文件的结尾？-icode9专业技术文章分享11-08
栏目导航
