03-自旋锁应用示例

 本系列文章主要讲述内核中的互斥与同步操作，主要包括内核中的锁机制，信号量和互斥体，讲述了基础概念和常用的API函数接口和代码示例，详细目录如下：
 01 - 内核中的互斥与同步概述
 02 - 原子变量应用示例
 03 - 自旋锁应用示例
 04 - 信号量的应用示例
 05 - 互斥量的应用示例

 上个示例 02-原子变量应用示例 使用原子变量实现了一次只能有一个应用程序访问一个设备，本节我们使用自旋锁来实现此功能。在使用自旋锁之前，先回顾一下自旋锁的使用注意事项：
 ①、自旋锁保护的临界区要尽可能的短，因此在 open 函数中申请自旋锁，然后在 release 函数中释放自旋锁的方法就不可取。我们可以使用一个变量来表示设备的使用情况，如果设备被使用了那么变量就一，设备被释放以后变量就减 1，我们只需要使用自旋锁保护这个变量即 可。
 ②、考虑驱动的兼容性，合理的选择 API 函数。

 综上所述，在本次例程中采用自旋锁和原子变量结合的方式来实现一次只能一个应用程序打开一个设备的功能，定义一个原子变量 lock_status 表示设备的使用状态，为1表示设备可用，0表示设备不可用。在open函数中首先上锁判断 lock_status 的状态，如果为1则表示设备可用，然后接着执行，将 lock_status 自减然后解锁执行下面的程序，如果 lock_status 为0，表示设备不可用直接 return 并解锁。

 自旋锁的使用步骤如下：

1. spinlock_t my_lock;						// 定义一个自旋锁	
2. spin_lock_init(&my_lock);				// 初始化自旋锁     
3. spin_lock_irqsave(&my_lock, flags);		// 上锁
4. ... ...									// 访问共享资源
5. spin_unlock_irqrestore(&my_lock, flags);	//解锁

 详细的代码实现过程如下，首先定义一个 demo_struct 结构体里面包含了自旋锁和设备使用状态的变量，在 demo_init 函数中开辟空间，并且初始化自旋锁和设备的初始使用状态值(初始值为1)，在 demo_open 和 demo_release 函数中对自旋锁进行了具体的操作，最后对整个代码的执行结果进行了验证，见本文1.4节测试结果一段。

1 示例代码

1.1 demo.c

 驱动部分的代码，主要包含了自旋锁的实现和判断，init、open和release函数的实现，具体内容在代码中进行注释。

#include <linux/module.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <asm/atomic.h>
#include <linux/slab.h>				// kzalloc和kfree的头文件

typedef struct 
{
	dev_t dev_no;
	char devname[20];
	char classname[20];
	struct cdev demo_cdev;
	struct class *cls;
	struct device *dev;
	atomic_t lock_status;			// 定义设备使用状态，1表示可用，0表示不可用
	spinlock_t my_lock;				// 定义一个自旋锁
}demo_struct;
demo_struct *my_demo_dev = NULL;	// 定义一个设备结构体指针，指向NULL

static int demo_open(struct inode *inode, struct file *filp)
{
	unsigned long flags;
	
	/* 首先判断设备是否可用 */
	spin_lock_irqsave(&my_demo_dev->my_lock, flags);		// 上锁，保存中断屏蔽状态到flags中，并禁止本地中断
	if (atomic_read(&my_demo_dev->lock_status) == 0)		// 设备不可用
	{
		printk("device busy");
		spin_unlock_irqrestore(&my_demo_dev->my_lock, flags);
		goto err0;
	}
	atomic_dec(&my_demo_dev->lock_status);
	spin_unlock_irqrestore(&my_demo_dev->my_lock, flags);	// 解锁，将中断状态恢复到之前的状态，并激活本地中断

	printk("%s -- %d.\n", __FUNCTION__, __LINE__);
	
	return 0;

err0:
	return -EBUSY;	/* Device or resource busy */
}

static int demo_release(struct inode *inode, struct file *filp)
{
	unsigned long flags;

	/* 首先判断设备是否可用 */
	spin_lock_irqsave(&my_demo_dev->my_lock, flags);		// 上锁，保存中断屏蔽状态到flags中，并禁止本地中断
	if (atomic_read(&my_demo_dev->lock_status) == 0) 		// 设备不可用
	{
		atomic_inc(&my_demo_dev->lock_status);				// 自加1，将其恢复到初始状态，一攻其他应用程序使用
	}
	spin_unlock_irqrestore(&my_demo_dev->my_lock, flags);	// 解锁，将中断状态恢复到之前的状态，并激活本地中断

	printk("%s -- %d.\n", __FUNCTION__, __LINE__);

	
	return 0;
}

struct file_operations demo_ops = {
	.open = demo_open,
	.release=  demo_release,
};

static int __init demo_init(void)
{
	int ret;

	printk("%s -- %d.\n", __FUNCTION__, __LINE__);

	/* 开辟空间 */
	my_demo_dev =  kzalloc(sizeof(demo_struct), GFP_KERNEL);
	if ( IS_ERR(my_demo_dev) )
	{
		printk("kzalloc failed.\n");
		ret = PTR_ERR(my_demo_dev);
		goto kzalloc_err;
	}
	strcpy(my_demo_dev->devname, "demo_chrdev");	// 给设备名字赋值
	strcpy(my_demo_dev->classname, "demo_class");	// 给设备类的名字赋值

	atomic_set(& my_demo_dev->lock_status , 1);		// 初始化锁的状态为1，表示此时可以用
	spin_lock_init(&my_demo_dev->my_lock);			// 初始化自旋锁
	
	ret = alloc_chrdev_region(&my_demo_dev->dev_no, 0, 0, my_demo_dev->devname);
	if (ret)
	{
		printk("alloc_chrdev_region failed.\n");
		goto region_err;
	}

	cdev_init(&my_demo_dev->demo_cdev, &demo_ops);

	ret = cdev_add(&my_demo_dev->demo_cdev, my_demo_dev->dev_no, 1);
	if (ret < 0)
	{
		printk("cdev_add failed.\n");
		goto add_err;
	}

	my_demo_dev->cls = class_create(THIS_MODULE, my_demo_dev->classname);	/* 在目录/sys/class/.. */
	if ( IS_ERR(my_demo_dev->cls) )
	{
		ret = PTR_ERR(my_demo_dev->cls);
		printk("class_create failed.\n");
		goto cls_err;
	}

	my_demo_dev->dev = device_create(my_demo_dev->cls, NULL, my_demo_dev->dev_no, NULL, "chrdev%d", 0);	/* 在目录/dev/.. */
	if ( IS_ERR(my_demo_dev->dev) )
	{
		ret = PTR_ERR(my_demo_dev->dev);
		printk("device_create failed.\n");
		goto dev_err;
	}
	
	return 0;

dev_err:
	class_destroy(my_demo_dev->cls);	
cls_err:
	cdev_del(&my_demo_dev->demo_cdev);
add_err:
	unregister_chrdev_region(my_demo_dev->dev_no, 1);
region_err:
	kfree(my_demo_dev);		// 释放空间，避免内存泄漏
kzalloc_err:
	return ret;
}


static void __exit demo_exit(void)
{
	printk("%s -- %d.\n", __FUNCTION__, __LINE__);

	device_destroy(my_demo_dev->cls, my_demo_dev->dev_no);
	class_destroy(my_demo_dev->cls);
	cdev_del(&my_demo_dev->demo_cdev);
	unregister_chrdev_region(my_demo_dev->dev_no, 1);
	kfree(my_demo_dev);		// 释放空间，避免内存泄漏
}

module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

1.2 test.c

 示例的应用层测试代码，包含了设备的打开和关闭函数，在打开和关闭之间延时5秒钟，方便测试第二个应用程序打开设备的结果。

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, const char *argv[])
{
	int fd;

	fd = open("/dev/chrdev0", O_RDWR, 0666);
	if (fd < 0)
	{
		perror("open");
		return -1;
	}

	sleep(5);

	close(fd);

	return 0;
}

1.3 Makefile

KERNELDIR ?= /home/linux/ti-processor-sdk-linux-am335x-evm-04.00.00.04/board-support/linux-4.9.28/
PWD := $(shell pwd)

all:
	make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -C $(KERNELDIR) M=$(PWD) modules
	arm-linux-gnueabihf-gcc test.c -o app
install:
	sudo cp *.ko  app /tftpboot
clean:
	make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -C $(KERNELDIR) M=$(PWD) clean
	rm app

obj-m += demo.o

1.4 测试结果

 示例的测试结果，结果详细分析过程标注在结果后面。

root@am335x-evm:~# insmod demo.ko 		// 加载模块
[	47.879080] demo_init -- 71.
root@am335x-evm:~# ./app &				// 后台运行
[1] 925
[	50.816857] demo_open -- 36.
root@am335x-evm:~# ./app  				// 在上一个运行期间，再运行一次
[	53.073234] device busy				// 内核打印的，连着打开两次，出现device busy
open: Device or resource busy			// 应用层打印的
[   55.820469] demo_release -- 56.		// 5秒之后，第一次打开的设备关闭
root@am335x-evm:~# ./app				// 再次打开，
[	64.482860] demo_open -- 36.			// 可以成功打开
[	69.486465] demo_release -- 56.		// 5秒之后关闭	
root@am335x-evm:~# rmmod demo.ko 		// 卸载模块
[	76.329375] demo_exit -- 136.