i.MX6ULL终结者Linux并发与竞争实验原子操作

在本章的四个实验中使用LED灯设备驱动程序，在第三十五章的基础上修改完成。
在本节使用中我们使用原子操作来实现对 LED 这个设备的互斥访问，也就是一次只允许一个应用程序可以使用 LED 灯。

1 实验程序编写

本实验例程路径：i.MX6UL终结者光盘资料/06_Linux驱动例程/04_gpioled_atomic
首先创建新的文件gpioled_atomic.c，在LED驱动程序基础上进行修改。使用原子操作来实现一次只能允许一个应用访问LED灯。修改后的驱动内容如下：

1 #include <linux/types.h>
  2 #include <linux/kernel.h>
  3 #include <linux/delay.h>
  4 #include <linux/ide.h>
  5 #include <linux/init.h>
  6 #include <linux/module.h>
  7 #include <linux/errno.h>
  8 #include <linux/gpio.h>
  9 #include <linux/cdev.h>
 10 #include <linux/device.h>
 11 #include <linux/of.h>
 12 #include <linux/of_address.h>
 13 #include <linux/of_gpio.h>
 14 #include <asm/mach/map.h>
 15 #include <asm/uaccess.h>
 16 #include <asm/io.h>
 17 
 18 #define GPIOLED_CNT 1 /* 设备号个数 */
 19 #define GPIOLED_NAME "gpioled" /* 名字 */
 20 #define LEDOFF 0 /* 关灯 */
 21 #define LEDON 1 /* 开灯 */
 22 
 23 /* gpioled 设备结构体 */
 24 struct gpioled_dev{
 25         dev_t devid; /* 设备号 */
 26         struct cdev cdev; /* cdev */
 27         struct class *class; /* 类 */
 28         struct device *device; /* 设备 */
 29         int major; /* 主设备号 */
 30         int minor; /* 次设备号 */
 31         struct device_node *nd; /* 设备节点 */
 32         int led_gpio; /* led 所使用的 GPIO 编号 */
 33         atomic_t lock; /* 原子变量 */
 34 };
 35 
 36 struct gpioled_dev gpioled; /* led 设备 */
 37 
 38 /*
 39  * @description : 打开设备
 40  * @param – inode : 传递给驱动的 inode
 41  * @param - filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
 42  * 一般在 open 的时候将 private_data 指向设备结构体。
 43  * @return : 0 成功;其他 失败
 44  */
 45 static int led_open(struct inode *inode, struct file *filp)
 46 {
 47         /* 通过判断原子变量的值来检查 LED 有没有被别的应用使用 */
 48         if (!atomic_dec_and_test(&gpioled.lock)) {
 49                 atomic_inc(&gpioled.lock);/* 小于 0 的话就加 1,使其原子变量等于 0 */
 50                 return -EBUSY; /* LED 被使用，返回忙 */
 51         }
 52 
 53         filp->private_data = &gpioled; /* 设置私有数据 */
 54         return 0;
 55 }
 56 
 57 /*
 58  * @description : 从设备读取数据
 59  * @param - filp : 要打开的设备文件(文件描述符)
 60  * @param - buf : 返回给用户空间的数据缓冲区
 61  * @param – cnt : 要读取的数据长度
 62  * @param - offt : 相对于文件首地址的偏移
 63  * @return : 读取的字节数，如果为负值，表示读取失败
 64  */
 65 static ssize_t led_read(struct file *filp, char __user *buf,
 66                 size_t cnt, loff_t *offt)
 67 {
 68         return 0;
 69 }
 70 
 71 /*
 72  * @description : 向设备写数据
 73  * @param – filp : 设备文件，表示打开的文件描述符
 74  * @param - buf : 要写给设备写入的数据
 75  * @param - cnt : 要写入的数据长度
 76  * @param – offt : 相对于文件首地址的偏移
 77  * @return : 写入的字节数，如果为负值，表示写入失败
 78  */
 79 static ssize_t led_write(struct file *filp, const char __user *buf,
 80                 size_t cnt, loff_t *offt)
 81 {
 82         int retvalue;
 83         unsigned char databuf[1];
 84         unsigned char ledstat;
 85         struct gpioled_dev *dev = filp->private_data;
 86 
 87         retvalue = copy_from_user(databuf, buf, cnt);
 88         if(retvalue < 0) {
 89                 printk("kernel write failed!\r\n");
 90                 return -EFAULT;
 91         }
 92 
 93         ledstat = databuf[0]; /* 获取状态值 */
 94 
 95         if(ledstat == LEDON) {
 96                 gpio_set_value(dev->led_gpio, 0); /* 打开 LED 灯 */
 97         } else if(ledstat == LEDOFF) {
 98                 gpio_set_value(dev->led_gpio, 1); /* 关闭 LED 灯 */
 99         }
100         return 0;
101 }
102 
103 /*
104  * @description : 关闭/释放设备
105  * @param – filp : 要关闭的设备文件(文件描述符)
106  * @return : 0 成功;其他 失败
107  */
108 static int led_release(struct inode *inode, struct file *filp)
109 {
110         struct gpioled_dev *dev = filp->private_data;
111 
112         /* 关闭驱动文件的时候释放原子变量 */
113         atomic_inc(&dev->lock);
114         return 0;
115 }
116 
117 /* 设备操作函数 */
118 static struct file_operations gpioled_fops = {
119         .owner = THIS_MODULE,
120         .open = led_open,    
121         .read = led_read,
122         .write = led_write,
123         .release = led_release,
124 };
125 
126 /*
127  * @description : 驱动入口函数
128  * @param : 无
129  * @return : 无
130  */
131 static int __init led_init(void)
132 {
133         int ret = 0;
134 
135         /* 初始化原子变量 */
136         atomic_set(&gpioled.lock, 1); /* 原子变量初始值为 1 */
137 
138         /* 设置 LED 所使用的 GPIO */
139         /* 1、获取设备节点：gpioled */
140         gpioled.nd = of_find_node_by_path("/gpioled");
141         if(gpioled.nd == NULL) {
142                 printk("gpioled node not find!\r\n");
143                 return -EINVAL;
144         } else {
145                 printk("gpioled node find!\r\n");
146         }
147 
148         /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
149         gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
150         if(gpioled.led_gpio < 0) {
151                 printk("can't get led-gpio");
152                 return -EINVAL;
153         }
154         printk("led-gpio num = %d\r\n", gpioled.led_gpio);
155 
156         /* 3、设置 GPIO1_IO03 为输出，并且输出高电平，默认关闭 LED 灯 */
157         ret = gpio_direction_output(gpioled.led_gpio, 1);
158         if(ret < 0) {
159                 printk("can't set gpio!\r\n");
160         }
161 
162         /* 注册字符设备驱动 */
163         /* 1、创建设备号 */
164         if (gpioled.major) { /* 定义了设备号 */
165                 gpioled.devid = MKDEV(gpioled.major, 0);
166                 register_chrdev_region(gpioled.devid, GPIOLED_CNT,
167                                 GPIOLED_NAME);
168         } else { /* 没有定义设备号 */
169                 alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT,
170                                 GPIOLED_NAME); /* 申请设备号 */
171                 gpioled.major = MAJOR(gpioled.devid);/* 获取分配号的主设备号 */
172                 gpioled.minor = MINOR(gpioled.devid);/* 获取分配号的次设备号 */
173         }
174         printk("gpioled major=%d,minor=%d\r\n",gpioled.major,
175                         gpioled.minor);
176 
177         /* 2、初始化 cdev */
178         gpioled.cdev.owner = THIS_MODULE;
179         cdev_init(&gpioled.cdev, &gpioled_fops);
180 
181         /* 3、添加一个 cdev */
182         cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
183 
184         /* 4、创建类 */
185         gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
186         if (IS_ERR(gpioled.class)) {
187                 return PTR_ERR(gpioled.class);
188         }
189 
190         /* 5、创建设备 */
191                 gpioled.device = device_create(gpioled.class, NULL,
192                                 gpioled.devid, NULL, GPIOLED_NAME);
193         if (IS_ERR(gpioled.device)) {
194                 return PTR_ERR(gpioled.device);
195         }
196 
197         return 0;
198 }
199 
200 /*
201  * @description : 驱动出口函数
202  * @param : 无
203  * @return : 无
204  */
205 static void __exit led_exit(void)
206 {
207         /* 注销字符设备驱动 */
208         cdev_del(&gpioled.cdev);/* 删除 cdev */
209         unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);
210 
211         device_destroy(gpioled.class, gpioled.devid);
212         class_destroy(gpioled.class);
213 }
214 
215 module_init(led_init);
216 module_exit(led_exit);
217 MODULE_LICENSE("GPL");
218 MODULE_AUTHOR("topeet");

第33行，在LED的设备结构体中添加原子变量lock，用来实现一次只能允许一个应用访问LED灯，led_init入口函数会将lock的值设备为1。
第45~55行，当应用测试程序打开led设备时，先判读原子变量的值，检查当前LED设备有没有被其他应用使用。每次打开驱动设备的时候先使用 atomic_dec_and_test 函数将 lock 减 1，如果 atomic_dec_and_test函数返回值为真就表示 lock 当前值为 0，说明设备可以使用。如果 atomic_dec_and_test 函数返回值为假，就表示 lock 当前值为负数(lock 值默认是 1)，lock 值为负数的可能性只有一个，那就是其他设备正在使用 LED。其他设备正在使用 LED 灯，那么就只能退出了，在退出之前调用函数 atomic_inc 将 lock 加 1，因为此时 lock 的值被减成了负数，必须要对其加 1，将 lock 的值变为 0。
第113行，应用测试程序通过close关闭设备驱动文件，在led_release 函数中通过atomic_inc 释放 lcok，也就是将 lock 加 1。
第136行，初始化原子变量 lock，初始值设置为 1，这样每次就只允许一个应用使用 LED灯。

2 编写应用测试程序

创建应用测试文件gpioled_atomic_test.c文件，具体内容如下：

1 #include "stdio.h"
  2 #include "unistd.h"
  3 #include "sys/types.h"
  4 #include "sys/stat.h"
  5 #include "fcntl.h"
  6 #include "stdlib.h"
  7 #include "string.h"
  8 
  9 #define LEDOFF 0
 10 #define LEDON 1
 11 
 12 /*
 13  * @description : main 主程序
 14  * @param - argc : argv 数组元素个数
 15  * @param - argv : 具体参数
 16  * @return : 0 成功;其他 失败
 17  */
 18 int main(int argc, char *argv[])
 19 {
 20         int fd, retvalue;
 21         char *filename;
 22         unsigned char cnt = 0;
 23         unsigned char databuf[1];
 24 
 25         if(argc != 3){
 26                 printf("Error Usage!\r\n");
 27                 return -1;
 28         }
 29 
 30         filename = argv[1];
 31 
 32         /* 打开 led 驱动 */
 33         fd = open(filename, O_RDWR);
 34         if(fd < 0){
 35                 printf("file %s open failed!\r\n", argv[1]);
 36                 return -1;
 37         }
 38 
 39         databuf[0] = atoi(argv[2]); /* 要执行的操作：打开或关闭 */
 40 
 41         /* 向/dev/gpioled 文件写入数据 */
 42         retvalue = write(fd, databuf, sizeof(databuf));
 43         if(retvalue < 0){
 44                 printf("LED Control Failed!\r\n");
 45                 close(fd);
 46                 return -1;
 47         }
 48 
 49         /* 模拟占用 25S LED */
 50         while(1) {
 51                 sleep(5);
 52                 cnt++;
 53                 printf("App running times:%d\r\n", cnt);
 54                 if(cnt >= 5) break;
 55         }
 56 
 57         printf("App running finished!");
 58         retvalue = close(fd); /* 关闭文件 */
 59         if(retvalue < 0){
 60                 printf("file %s close failed!\r\n", argv[1]);
 61                 return -1;
 62         }
 63         return 0;
 64 }

应用测试程序也是在第三十五章的测试程序上修改而成的，重点是加入了第 49~55 行的模拟占用 25 秒 LED 的代码。应用测试程序在获取到 LED 灯驱动的使用权以后会使用 25S，在使用的这段时间如果有其他的应用也去获取 LED 灯使用权的话肯定会失败！

3 运行测试

1、编译驱动程序
编写Makefile文件，修改obj-m的值为gpioled_atomic.o，具体内容如下：

KERNELDIR := /home/topeet/kernel/linux-imx-rel_imx_4.1.15_2.1.0_ga
CURRENT_PATH := $(shell pwd)
obj-m := gpioled_atomic.o

build: kernel_modules

kernel_modules: 
        $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
        $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

首先我们在终端输入两个命令（设置两个环境变量）：
export ARCH=arm
export CROSS_COMPILE=arm-linux-gnueabihf-
然后使用“make”命令进行编译，生成gpioled_atomic.ko驱动模块文件。
2、编译应用测试程序
输入下列命令编译gpioled_atomic_test.c应用测试程序：
arm-linux-gnueabihf-gcc -o gpioled_atomic_test gpioled_atomic_test.c
编译成功后，就会生成gpioled_atomic_test应用可执行程序。
3、运行测试
启动开发板，将编译好的gpioled_atomic.ko驱动模块文件和gpioled_atomic_test应用测试程序拷贝到/lib/modules/4.1.15目录下（检查开发板根文件系统中有没有“/lib/modules/4.1.15”这个目录，如果没有的话需要自行创建一下。开发板中使用的是光盘资料里面提供的busybox文件系统，光盘资料的“i.MX6UL终结者光盘资料\08_开发板系统镜像\03_文件系统镜像\01_Busybox文件系统”目录下）。输入下面命令加载模块：
depmod
modprobe gpioled_atomic
模块加载成功有如图 3.1信息打印：

图 3.1

然后使用gpioled_atomic_test应用测试程序测试驱动文件。
输入下面的命令打开LED灯：
./gpioled_atomic_test /dev/gpioled 1 &
查看开发板上的红色LED灯是否点亮，“&”表示在后头打开程序，这样终端不会被占用。
运行结果如图 3.2所示：

图 3.2

可以看出gpioled_atomic_test应用测试程序正常运行，打印“App running times:1”和“App running times:2”，表示模拟25s的设备占用。如果在25s占用期间输入关闭LED灯的命令：
./gpioled_atomic_test /dev/gpioled 0
会有如图3.3信息产生：

图 3.3

错误信息“file /dev/gpioled open failed!”，/dev/gpioled设备文件打开失败，说明之前打开LED的命令，使gpioled_atomic_test正在占用/dev/gpioled设备文件，如果再次执行gpioled_atomic_test去打开/dev/gpioled设备文件则会失败。需要等25s结束之后，其他软件才能去使用/dev/gpioled设备文件。这个就是采用原子变量实现一次只能有一个应用程序访问 LED 灯。
卸载模块文件命令：
rmmod gpioled_atomic