linux驱动22：自旋锁spinlock_spinlock头文件-优快云博客

本文链接：https://blog.youkuaiyun.com/dongyoubin/article/details/124907460

自旋锁：

和信号量不同的是自旋锁可在不能休眠的代码中使用，如中断处理例程。在正确使用时，自旋锁通常比信号量具有更高的性能。

如果锁可用，则锁定位被设置，代码继续进入临界区；相反则代码进入忙循环并重复检查锁，直到该锁可用。

所有自旋锁在本质上是不可中断的，一旦调用了spin_lock，在获得锁之前一直处于自旋状态。

自旋锁的实现由于linux所支持的架构不同而不同。

自旋锁的核心规则是：任何拥有自旋锁的代码必须是原子的。自旋锁不能休眠。

自旋锁必须在可能的最短时间内拥有。

头文件：<linux/spinlock.h>

初始化：

静态：spinlock_t lock;

动态：void spin_lock_init(spinlock_t *lock);

获取锁：

void spin_lock(spinlock_t *lock);

void spin_lock_irqsave(spinlock_t *lock, unsigned long flags);

获得自旋锁之前禁止中断，先前的中断状态保存在flags中。

void spin_lock_irq(spinlock_t *lock);

确保释放自旋锁时应该启用中断时调用。

void spin_lock_bh(spinlock_t *lock);

获得锁之前禁止软件中断。

释放锁：

void spin_unlock(spinlock_t *lock);

void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags);

void spin_unlock_irq(spinlock_t *lock);

void spin_unlock_bh(spinlock_t *lock);

非阻塞自旋锁：

int spin_trylock(spinlock_t *lock);

int spin_trylock_bh(spinlock_t *lock);

获得自旋锁返回非零值，否则返回零。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/spinlock.h>

static int major = 277;
static int minor = 0;
static dev_t helloNum;
static struct class *helloClass = NULL;
static struct device *helloDev = NULL;
static spinlock_t lock;
int busyFlag = 0;

int hello_open(struct inode *pinode, struct file *pfile)
{
	printk("hello_open, minor:%d, major:%d\n", iminor(pinode), imajor(pinode));
	spin_lock(&lock);
	if (1 == busyFlag)
	{
		spin_unlock(&lock);
		return -EBUSY;
	}
	busyFlag = 1;
	spin_unlock(&lock);
	return 0;
}

int hello_release(struct inode *pinode, struct file *pfile)
{
	printk("hello_release, minor:%d, major:%d\n", iminor(pinode), imajor(pinode));
	busyFlag = 0;
	return 0;
}

static struct file_operations hello_ops = {
	.open = hello_open,
	.release = hello_release,
};

static int hello_init(void)
{
	int ret = 0;
	printk("hello_init\n");

	ret = register_chrdev( major, "hello", &hello_ops);
	if(ret < 0)
	{
		printk("register_chrdev failed.\n");
		return ret;
	}

	helloClass = class_create(THIS_MODULE, "hellocls");
	if (IS_ERR(helloClass)) 
	{
		printk("class_create failed.\n");
		ret = PTR_ERR(helloClass);
		goto error_exit1;
	}

	helloNum = MKDEV(major,minor);
	printk("major:%d, minor:%d\n", MAJOR(helloNum), MINOR(helloNum));

	helloDev = device_create(helloClass, NULL, helloNum, NULL, "hello0");
	if (IS_ERR(helloDev)) 
	{
		printk("device_create failed.\n");
		ret = PTR_ERR(helloDev);
		goto error_exit2;
	}
	
	return 0;

error_exit2:
	class_destroy(helloClass);

error_exit1:
	unregister_chrdev(major,"hello");

	return ret;
}

static void hello_exit(void)
{
	printk("hello_exit\n");
	device_destroy(helloClass, helloNum);
	class_destroy(helloClass);
	unregister_chrdev(major,"hello");
}

MODULE_LICENSE("GPL");
module_init(hello_init);
module_exit(hello_exit);