Linux并发控制机制

优快云仅用于增加百度收录权重，排版未优化，日常不维护。请访问：www.hceng.cn 查看、评论。
本博文对应地址: https://hceng.cn/2017/04/05/Linux并发控制/#more
本文主要是简单记录下驱动中的并发控制。

1.并发控制

---

2.原子变量操作

测试代码：
{% codeblock lang:c [atomic_drv.c] https://github.com/hceng/learn/tree/master/atomic %}
#include <linux/module.h>
#include <linux/init.h>

#include <asm/atomic.h>//原子变量操作的头文件
#include <asm/bitops.h>//原子位操作的头文件

atomic_t a1 = ATOMIC_INIT(1);//定义和设置原子量；
unsigned long int a2;//操作函数传入参数的数据类型是unsigned long int；

static int test_drv_init(void)
{

//测试原子变量操作：
printk("test a1\nKERN_INFO:atomic_read(): a1 =  %d\n", a1); 

atomic_add(4, &a1);
printk("KERN_INFO:atomic_add(): a1 =  %d\n", a1); 

atomic_dec(&a1);
printk("KERN_INFO:atomic_dec(): a1 =  %d\n", a1); 

printk("KERN_INFO:atomic_dec_and_test(): judge_a1 = %d, new_a1 = %d\n",\
	atomic_dec_and_test(&a1),atomic_read(&a1));

//测试原子位操作：
set_bit(0,&a2);//设置a的0位为1;
printk("test a2\nKERN_INFO:set_bit(): a2 =  %ld\n", a2); 

printk("KERN_INFO:test_and_clear_bit(): return_a2 = %d, new_a2 = %ld\n",\
	test_and_clear_bit(0, &a2), a2);

printk("KERN_INFO:test_and_set_bit(): return_a2 = %d, new_a2 = %ld\n",\
	test_and_set_bit(0, &a2), a2);

return 0;

}

static void test_drv_exit(void)
{

}

module_init(test_drv_init);
module_exit(test_drv_exit);

MODULE_LICENSE(“GPL”);
MODULE_AUTHOR(“hceng”);
MODULE_DESCRIPTION(“Learn for atomic”);
{% endcodeblock %}

---

3.自旋锁

测试代码：
{% codeblock lang:c [lock_drv.c] https://github.com/hceng/learn/blob/master/lock/lock_drv.c %}
/设备驱动中，有些设备只允许打开一次，这里用count计数，lock对count进行保护/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/spinlock.h>//自旋锁头文件

static struct class *testdrv_class;
static struct class_device *testdrv_class_dev;

int count = 0 ;
spinlock_t lock;

static int test_drv_open(struct inode *inode, struct file *file)
{
spin_lock(&lock);
if(count)
{
spin_unlock(&lock);
printk(“kernel: open fail! count = %d\n”,count);
return -EBUSY;
}
count++;
spin_unlock(&lock);
printk(“kernel: open ok! count = %d\n”,count);

return 0;

}

static int test_drv_release(struct inode *inode, struct file *file)
{
spin_lock(&lock);
count–;
spin_unlock(&lock);
printk(“kernel: release ok! count = %d\n”,count);

return 0;

}

static struct file_operations test_drv_fops = {
.owner = THIS_MODULE,
.open = test_drv_open,
.release = test_drv_release,
};

int major;
static int test_drv_init(void)
{
major = register_chrdev(0, “test_drv”, &test_drv_fops);

testdrv_class = class_create(THIS_MODULE, "testdrv");

testdrv_class_dev = device_create(testdrv_class, NULL, MKDEV(major, 0), NULL, "locktest"); 

spin_lock_init(&lock);

printk("kernel: init ok!\n");

return 0;

}

static void test_drv_exit(void)
{
unregister_chrdev(major, “test_drv”);

device_destroy(testdrv_class,  MKDEV(major, 0));	

class_destroy(testdrv_class);

printk("kernel: exit ok!\n");

}

module_init(test_drv_init);
module_exit(test_drv_exit);

MODULE_LICENSE(“GPL”);
MODULE_AUTHOR(“hceng”);
MODULE_DESCRIPTION(“Learn for lock”);
{% endcodeblock %}
{% codeblock lang:c [lock_test.c] https://github.com/hceng/learn/blob/master/lock/lock_test.c %}
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

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

fd = open("/dev/locktest", O_RDWR);

if (fd < 0)
{
	printf("app: can't open!\n");
}
else printf("app: open ok!\n");

while(1);

return 0;

}
{% endcodeblock %}

---

4.信号量

{% codeblock lang:c [semaphore_drv.c] https://github.com/hceng/learn/blob/master/semaphore/semaphore_drv.c %}
/设备驱动中，有些资源只能被单一进程访问，这里用sem确保单一访问/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/semaphore.h>//信号量头文件

static struct class *testdrv_class;
static struct class_device *testdrv_class_dev;

struct semaphore sem;

static int test_drv_open(struct inode *inode, struct file *file)
{
printk(“kernel:down before sem.count = %d \n”, sem.count);
down(&sem);
/临界资源/
printk(“kernel:down after sem.count = %d \n”, sem.count);

return 0;

}

static int test_drv_release(struct inode *inode, struct file *file)
{
printk(“kernel:up before sem.count = %d \n”, sem.count);
up(&sem);
printk(“kernel:up after sem.count = %d \n”, sem.count);

return 0;

}

static struct file_operations test_drv_fops = {
.owner = THIS_MODULE,
.open = test_drv_open,
.release = test_drv_release,
};

int major;
static int test_drv_init(void)
{
major = register_chrdev(0, “test_drv”, &test_drv_fops);

testdrv_class = class_create(THIS_MODULE, "testdrv");

testdrv_class_dev = device_create(testdrv_class, NULL, MKDEV(major, 0), NULL, "semaphoretest"); 

sema_init(&sem, 2);//允许同时2个进程访问临界资源

printk("kernel: init ok!\n");

return 0;

}

static void test_drv_exit(void)
{
unregister_chrdev(major, “test_drv”);

device_destroy(testdrv_class,  MKDEV(major, 0));	

class_destroy(testdrv_class);

printk("kernel: exit ok!\n");

}

module_init(test_drv_init);
module_exit(test_drv_exit);

MODULE_LICENSE(“GPL”);
MODULE_AUTHOR(“hceng”);
MODULE_DESCRIPTION(“Learn for semaphore”);
{% endcodeblock %}

{% codeblock lang:c [semaphore_test.c] https://github.com/hceng/learn/blob/master/semaphore/semaphore_test.c %}
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

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

fd = open("/dev/semaphoretest", O_RDWR);

if (fd < 0)
{
	printf("app: can't open!\n");
}
else printf("app: open ok!\n");

while(1);

return 0;

}
{% endcodeblock %}

---

5.完成量