lv14 并发控制：上下文、中断屏蔽和原子变量

1 上下文和并发场合

执行流：有开始有结束总体顺序执行的一段代码又称上下文

应用编程：任务上下文内核编程：

任务上下文：五状态可阻塞

a. 应用进程或线程运行在用户空间
b. 应用进程或线程运行在内核空间（通过调用syscall来间接使用内核空间）
c. 内核线程始终在内核空间

异常上下文：不可阻塞中断上下文

竞态：多任务并行执行时，如果在一个时刻同时操作同一个资源，会引起资源的错乱，这种错乱情形被称为竞态

共享资源：可能会被多个任务同时使用的资源

临界区：操作共享资源的代码段

为了解决竞态，需要提供一种控制机制，来避免在同一时刻使用共享资源，这种机制被称为并发控制机制

并发控制机制分类：

原子操作类
忙等待类
阻塞类

通用并发控制机制的一般使用套路：

/*互斥问题：*/
并发控制机制初始化为可用
P操作

临界区

V操作

/*同步问题：*/
//并发控制机制初始化为不可用
//先行方：
。。。。。
V操作//后行方：
P操作
。。。。。

2 中断屏蔽（了解）

一种同步机制的辅助手段

禁止本cpu中断	使能本cpu中断
local_irq_disable();	local_irq_enable();
local_irq_save(flags);	local_irq_restore(flags);	与cpu的中断位相关，即保存中断优先级
local_bh_disable();	local_bh_enable();	与中断低半部有关，关闭、打开软中断


禁止中断临界区 //临界区代码不能占用太长时间，需要很快完成打开中断

适用场合：中断上下文与某任务共享资源时，或多个不同优先级的中断上下文间共享资源时

3 原子变量（掌握）

原子变量：存取不可被打断的特殊整型变量

a.设置原子量的值

void atomic_set(atomic_t *v,int i); //设置原子量的值为iatomic_t v = ATOMIC_INIT(0); //定义原子变量v并初始化为0v = 10;//错误

b.获取原子量的值

atomic_read(atomic_t *v); //返回原子量的值

c.原子变量加减

void atomic_add(int i,atomic_t *v);//原子变量增加i 
void atomic_sub(int i,atomic_t *v);//原子变量减少i

d.原子变量自增自减

void atomic_inc(atomic_t *v);//原子变量增加1 
void atomic_dec(atomic_t *v);//原子变量减少1

e.操作并测试：运算后结果为0则返回真，否则返回假

int atomic_inc_and_test(atomic_t *v); 
int atomic_dec_and_test(atomic_t *v); 
int atomic_sub_and_test(int i,atomic_t *v);

原子位操作方法：

a.设置位

void set_bit(nr, void *addr); //设置addr的第nr位为1

b.清除位

void clear_bit(nr , void *addr); //清除addr的第nr位为0

c.改变位

void change_bit(nr , void *addr); //改变addr的第nr位为1

d.测试位

void test_bit(nr , void *addr); //测试addr的第nr位是否为1

适用场合：共享资源为单个整型变量的互斥场合

3.1 示例

创建一个全局变量作为原子变量，并添加到结构体中

初始化时先赋值1，表示可以打开

当打开操作时，如果能打开自减1，不能打开返回错误

关闭时，自增1

具体源码

openonce_atomic.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>int major = 11;
int minor = 0;
int openonce_num  = 1;struct openonce_dev
{struct cdev mydev;atomic_t openflag;//1 can open, 0 can not open
};struct openonce_dev gmydev;int openonce_open(struct inode *pnode,struct file *pfile)
{struct openonce_dev *pmydev = NULL;pfile->private_data =(void *) (container_of(pnode->i_cdev,struct openonce_dev,mydev));pmydev = (struct openonce_dev *)pfile->private_data;//运算后结果为0则返回真，否则返回假表示设备已经被打开if(atomic_dec_and_test(&pmydev->openflag)){return 0;}else{atomic_inc(&pmydev->openflag);printk("The device is opened already\n");return -1;}
}int openonce_close(struct inode *pnode,struct file *pfile)
{struct openonce_dev *pmydev = (struct openonce_dev *)pfile->private_data;atomic_set(&pmydev->openflag,1);return 0;
}struct file_operations myops = {.owner = THIS_MODULE,.open = openonce_open,.release = openonce_close,
};int __init openonce_init(void)
{int ret = 0;dev_t devno = MKDEV(major,minor);/*申请设备号*/ret = register_chrdev_region(devno,openonce_num,"openonce");if(ret){ret = alloc_chrdev_region(&devno,minor,openonce_num,"openonce");if(ret){printk("get devno failed\n");return -1;}major = MAJOR(devno);//容易遗漏，注意}/*给struct cdev对象指定操作函数集*/	cdev_init(&gmydev.mydev,&myops);/*将struct cdev对象添加到内核对应的数据结构里*/gmydev.mydev.owner = THIS_MODULE;cdev_add(&gmydev.mydev,devno,openonce_num);//初始化置位1atomic_set(&gmydev.openflag,1);return 0;
}void __exit openonce_exit(void)
{dev_t devno = MKDEV(major,minor);cdev_del(&gmydev.mydev);unregister_chrdev_region(devno,openonce_num);
}MODULE_LICENSE("GPL");module_init(openonce_init);
module_exit(openonce_exit);

Makefile

ifeq ($(KERNELRELEASE),)ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)modules:$(MAKE) -C $(KERNELDIR) M=$(PWD) modulesmodules_install:$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_installclean:rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versionselse
CONFIG_MODULE_SIG=n
obj-m += mychar.o
obj-m += mychar_poll.o
obj-m += openonce_atomic.oendif

testopenonce.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>#include "mychar.h"
#include <stdio.h>int main(int argc,char *argv[])
{int fd = -1;if(argc < 2){printf("The argument is too few\n");return 1;}fd = open(argv[1],O_RDONLY);if(fd < 0){printf("open %s failed\n",argv[1]);return 2;}while(1){};close(fd);fd = -1;return 0;
}

编译可能会报错缺少头文件，添加#include <asm/atomic.h>

插入内核模块，查看系统中已注册的设备类型，添加字符设备

执行打开两个终端去打开设备：终端1打开了，终端2无法重复打开

ctrl+c结束第一个程序后，终端1关闭，终端2可以打开

4 自旋锁：基于忙等待的并发控制机制

a.定义自旋锁

 spinlock_t lock;

b.初始化自旋锁

spin_lock_init(spinlock_t *);

c.获得自旋锁

spin_lock(spinlock_t *); //成功获得自旋锁立即返回，否则自旋在那里直到该自旋锁的保持者释放
spin_trylock(spinlock_t *); //成功获得自旋锁立即返回真，否则返回假，而不是像上一个那样"在原地打转”

d.释放自旋锁

spin_unlock(spinlock_t *);

#include <linux/spinlock.h>
定义spinlock_t类型的变量lock
spin_lock_init(&lock)后才能正常使用spinlock


spin_lock(&lock);
临界区
spin_unlock(&lock);

操作示例：

openonce_spinlock.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>int major = 11;
int minor = 0;
int openonce_num  = 1;struct openonce_dev
{struct cdev mydev;int openflag;//1 can open, 0 can not openspinlock_t lock;
};struct openonce_dev gmydev;int openonce_open(struct inode *pnode,struct file *pfile)
{struct openonce_dev *pmydev = NULL;pfile->private_data =(void *) (container_of(pnode->i_cdev,struct openonce_dev,mydev));pmydev = (struct openonce_dev *)pfile->private_data;//运算后结果为0则返回真，否则返回假表示设备已经被打开spin_lock(&pmydev->lock);if(pmydev->openflag){pmydev->openflag = 0;  //其他设备不能打开spin_unlock(&pmydev->lock);return 0;}else{printk("The device is opened already\n");return -1;}
}int openonce_close(struct inode *pnode,struct file *pfile)
{struct openonce_dev *pmydev = (struct openonce_dev *)pfile->private_data;spin_lock(&pmydev->lock);pmydev->openflag = 1;spin_unlock(&pmydev->lock);return 0;
}struct file_operations myops = {.owner = THIS_MODULE,.open = openonce_open,.release = openonce_close,
};int __init openonce_init(void)
{int ret = 0;dev_t devno = MKDEV(major,minor);/*申请设备号*/ret = register_chrdev_region(devno,openonce_num,"openonce");if(ret){ret = alloc_chrdev_region(&devno,minor,openonce_num,"openonce");if(ret){printk("get devno failed\n");return -1;}major = MAJOR(devno);//容易遗漏，注意}/*给struct cdev对象指定操作函数集*/	cdev_init(&gmydev.mydev,&myops);/*将struct cdev对象添加到内核对应的数据结构里*/gmydev.mydev.owner = THIS_MODULE;cdev_add(&gmydev.mydev,devno,openonce_num);//初始化,这个地方不用加锁，只有init后才会有设备使用gmydev.openflag = 1;	spin_lock_init(&gmydev.lock);return 0;
}void __exit openonce_exit(void)
{dev_t devno = MKDEV(major,minor);cdev_del(&gmydev.mydev);unregister_chrdev_region(devno,openonce_num);
}MODULE_LICENSE("GPL");module_init(openonce_init);
module_exit(openonce_exit);

Makefile

ifeq ($(KERNELRELEASE),)ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)modules:$(MAKE) -C $(KERNELDIR) M=$(PWD) modulesmodules_install:$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_installclean:rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versionselse
CONFIG_MODULE_SIG=n
obj-m += mychar.o
obj-m += mychar_poll.o
obj-m += openonce_atomic.o
obj-m += openonce_spinlock.oendif

testopenonce.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>#include "mychar.h"
#include <stdio.h>int main(int argc,char *argv[])
{int fd = -1;if(argc < 2){printf("The argument is too few\n");return 1;}fd = open(argv[1],O_RDONLY);if(fd < 0){printf("open %s failed\n",argv[1]);return 2;}while(1){};close(fd);fd = -1;return 0;
}

先编译Make

再插入内核模块，并检查设备是否注册

sudo ./insmod ./openonce_spinlock.ko
cat /proc/devices | grep openonce //openonce名称.c文件中命名

如找到openonce 11 0设备，即可添加字符设备

sudo mknod /dev/mydev c 11 0
sudo chmod 666 /dev/mydev

测试，只能打开一次

适用场合：

异常上下文之间或异常上下文与任务上下文之间共享资源时
任务上下文之间且临界区执行时间很短时
互斥问题