驱动程序学习（四）并发控制（2）自旋锁控制

在概念上，自旋锁非常简单。一个自旋锁就是一个互斥设备，它只有两个值：“锁定”

和“解锁”。它通常实现为某个整数值中的单个位。希望获得某特定锁的代码测试的相关

的位。如果锁可用，则“锁定”位被设置，而代码进入临界区；相反，如果锁被其他人获得，

则代码进入忙循环并重复坚持这个锁，直到该锁可用为止。这个循环就是自旋锁的“自旋”部分。

        自旋锁不会引起调用者休眠，如果自旋锁已经被别的执行单元保持，调用者就一直

循环查看是否该把自旋锁的保持者已经释放了锁，“自旋”就是“在原地打转”。

而信号量会引起调用者的休眠，它把进程从运行队列上移出。

无论信号量还是自旋锁在任何时刻最多只能有一个保持者，即在任何时刻最多只有

一个执行单元获得锁。

鉴于自旋锁和信号量的上述特点，一般而言，自旋锁适合于保持非常短的时间的情况，

它可以在任何上下文中使用；信号量适合于保持时间较长的情况，只能在进程上下文中使用

如果被保护的共享资源只在进程上下文访问，则可以以信号量来保护该共享资源。如果对共享

资源的访问时间非常短，则自旋锁是最好的选择。但是，如果被保护的共享资源，需要在中断

上下文访问，（包括底半部即中断处理句柄和顶半部即软中断）就必选使用自旋锁。

与自旋锁相关的API

1定义自旋锁函数：

spinlock_t spin;

2初始化自旋锁代码如下

该宏用于获得自旋锁lock，如果能够立即获得锁，它马上返回，否则，它就自旋在那里，直到

自旋锁的保持者释放。

spin_lock(lock)

下面的函数尝试获得锁，如果能立即获得锁，则它得到锁并返回真，否则立即返回假，并不“自旋”

spin_trylock(lock)

3释放自旋锁代码

spin_unlock(lock)

与2中两个函数配套使用。

代码示例如下：

chardev_spin_lock.c

#include<linux/module.h>
#include<linux/init.h>
#include<asm/uaccess.h>
#include<asm/semaphore.h>
#include<linux/fs.h>


MODULE_LICENSE("GPL");


#define MAJOR_NUM 111


static ssize_t chardev_read(struct file *,char *,size_t,loff_t *);
static ssize_t chardev_write(struct file *,const char *,size_t,loff_t *);
static int chardev_open(struct inode *inode,struct file *filp);
static int chardev_release(struct inode *inode,struct file *filp);


struct file_operations chardev_fops=
{
read:chardev_read,
write:chardev_write,
open:chardev_open,
release:chardev_release,
}; 


static int chardev_var=0;
static int chardev_count=0;
static struct semaphore sem;
static spinlock_t spin=SPIN_LOCK_UNLOCKED;


static int chardev_init(void)
{
int ret;
ret=register_chrdev(MAJOR_NUM,"chardev",&chardev_fops);
if(ret)
{
printk("chardev register failure");
}
else
{
printk("chardev register success");
init_MUTEX(&sem);
}
return ret;
}




static void chardev_exit(void)
{
unregister_chrdev(MAJOR_NUM,"chardev");
}


static int chardev_open(struct inode *inode,struct file *filp)
{
spin_lock(&spin);
if(chardev_count)
{
spin_unlock(&spin);
return -EBUSY;
}
chardev_count++;
spin_unlock(&spin);
return 0;
}


static int chardev_release(struct inode *inode,struct file *filp)
{
chardev_count--;
return 0;
}


static ssize_t chardev_read(struct file *filp,char *buf,size_t len,loff_t  *off)
{
if(down_interruptible(&sem))
{
return -ERESTARTSYS;
}
if(copy_to_user(&chardev_var,buf,sizeof(int)))
{
up(&sem);
return -EFAULT;
}
up(&sem);
return sizeof(int);
}
//static ssize_t chardev_write(struct file *,const char *,size_t,loff_t *);
static ssize_t chardev_write(struct file *filp,const char *buf,size_t len,loff_t *off)
{
if(down_interruptible(&sem))
{
return -ERESTARTSYS;
}
if(copy_from_user(&chardev_var,buf,sizeof(int)))
{
up(&sem);
return -EFAULT;
}
up(&sem);
return sizeof(int);
}


module_init(chardev_init);
module_exit(chardev_exit);

makefile 代码

KERNELDIR?= /lib/modules/2.6.25-14.fc9.i686/build/


PWD := $(shell pwd)
CC=$(CROSS_COMPILE)gcc
obj-m := chardev_spin_lock.o
modules:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
modules_install:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install
编译成功后，创建设备节点

mknod  /dev/chardev   c 111 0

clean:
测试函数代码

#include<sys/types.h>
#include<sys/stat.h>
#include<stdio.h>
#include<fcntl.h>
main()
{
int fd,num;
fd=open("/dev/chardev",O_RDWR,S_IRUSR|S_IWUSR);
if(fd!=-1)
{
read(fd,&num,sizeof(int));
printf("The chardev is %d\n",num);
printf("Please input the num written to chardev\n");
scanf("%d",&num);
write(fd,&num,sizeof(int));
read(fd,&num,sizeof(int));
printf("The chardev is %d\n",num);
close(fd);
}
else
{
printf("Device open failure\n");
}
}

编译完成后，在两个终端中运行程序。发现一个终端中可以打开成功，第二返回打开设备失败。