Linux驱动（竞争&IO模型）

提示：本文为系统的本地化文档，想要按照本文档完成系统的移植，需要你提前准备好Android的原生SDK。

---

前言

提示：感谢北京迅为电子

感谢【北京迅为电子】，本文是参考北京迅为电子的相关视频总结而成。

---

提示：以下是本篇文章正文内容

第一部分 并发与竞争

一、概念

并发

并行

并发+并行

并发可能会造成多个程序同时访问一个共享资源，这时候由并发同时访问一个共享资源产生的问题就叫做竞争。

竞争产生的原因如下所示：

• 多线程的并发访问。由于 Linux 是多任务操作系统，所以多线程访问是竞争产生的基本原因。
• 中断程序的并发访问。中断任务产生后，CPU会立刻停止当前工作，从而去执行中断中的任务，如果中断任务对共享资源进行了修改，就会产生竞争。
• 抢占式并发访问。linux2.6及更高版本引入了抢占式内核，高优先级的任务可以打断低优先级的任务。在线程访问共享资源的时候，另一个线程打断了现在正在访问共享资源的线程同时也对共享资源进行操作，从而造成了竞争。
• 多处理器(SMP）并发访问。多核处理器之间存在核间并发访问。

二、原子操作 set_bit

static atomic64_t v = ATOMIC_INIT(1);// 初始化原子类型变量 v, 并设置为 1
static int open_test(struct inode *inode,struct file *file)
{
	if(atomic64_read(&v) != 1) {// 读取原子类型变量 v 的值并判断是否等于 1
		return -EBUSY;
	}
	atomic64_set(&v,0);// 将原子类型变量 v 的值设置为 0
	return 0;
}

static int release_test(struct inode *inode,struct file *file)
{
	atomic64_set(&v,1);// 将原子类型变量 v 的值赋 1
	return 0;
}

函数	描述
ATOMIC_INIT(int i)	定义原子变量的时候对其初始化，赋值为 i
int atomic_read(atomic_t *v)	读取 v 的值，并且返回。
void atomic_set(atomic_t *v, int i)	向原子变量 v 写入 i 值。
void atomic_add(int i, atomic_t *v)	原子变量 v 加上 i 值。
void atomic_sub(int i, atomic_t *v)	原子变量 v 减去 i 值。
void atomic_inc(atomic_t *v)	原子变量 v 加 1
void atomic_dec(atomic_t *v)	原子变量 v 减 1
int atomic_dec_return(atomic_t *v)	原子变量 v 减 1，并返回 v 的值。
int atomic_inc_return(atomic_t *v)	原子变量 v 加 1，并返回 v 的值。
int atomic_sub_and_test(int i, atomic_t *v)	原子变量 v 减 i，如果结果为 0 就返回真，否则返回假
int atomic_dec_and_test(atomic_t *v)	原子变量 v 减 1，如果结果为 0 就返回真，否则返回假
int atomic_inc_and_test(atomic_t *v)	原子变量 v 加 1，如果结果为 0 就返回真，否则返回假
int atomic_add_negative(int i, atomic_t *v)	原子变量 v 加 i，如果结果为负就返回真，否则返回假

函数	描述
void set_bit(int nr, void *p)	将 p 地址的第 nr 位置 1。
void clear_bit(int nr, void *p)	将 p 地址的第 nr 位清零。
void change_bit(int nr, void *p)	将 p 地址的第 nr 位进行翻转。
int test_bit(int nr, void *p)	获取 p 地址的第 nr 位的值。
int test_and_set_bit(int nr, void *p)	将 p 地址的第 nr 位置 1，并返回 nr 位原来的值。
int test_and_clear_bit(int nr, void *p)	将 p 地址的第 nr 位清零，并返回 nr 位原来的值。
int test_and_change_bit(int nr, void *p)	将 p 地址的第 nr 位翻转，并返回 nr 位原来的值。

三、自旋锁 spin_lock_init spin_lock spin_unlock

static spinlock_t spinlock_test;// 定义 spinlock_t 类型的自旋锁变量 spinlock_test
static int flag = 1;// 定义 flag 标准为， flag 等于 1 表示设备没有被打开，等于 0 则证明设备已经被打开了
static int open_test(struct inode *inode,struct file *file)
{
	//printk("\nthis is open_test \n");
	spin_lock(&spinlock_test);// 自旋锁加锁
	if(flag != 1) {// 判断标志位 flag 的值是否等于 1
		spin_unlock(&spinlock_test);// 自旋锁解锁
		return -EBUSY;
	}
	flag = 0;// 将标志位的值设置为 0
	spin_unlock(&spinlock_test);// 自旋锁解锁
	return 0;
}

static int release_test(struct inode *inode,struct file *file)
{
	printk("\nthis is release_test \n");
	spin_lock(&spinlock_test);// 自旋锁加锁
	flag = 1;
	spin_unlock(&spinlock_test);// 自旋锁解锁
	return 0;
}

static int __init atomic_init(void)
{
	spin_lock_init(&spinlock_test);
	...
}

函数	描述
DEFINE_SPINLOCK(spinlock_t lock)	定义并初始化自旋锁。
int spin_lock_init(spinlock_t *lock)	初始化自旋锁。
void spin_lock(spinlock_t *lock)	获取指定的自旋锁，也叫做加锁。
void spin_unlock(spinlock_t *lock)	释放指定的自旋锁。
int spin_trylock(spinlock_t *lock)	尝试获取指定的自旋锁，如果没有获取到就返回 0。
int spin_is_locked(spinlock_t *lock)	检查指定的自旋锁是否被获取，如果没有被获取就返回非 0，否则返回 0。

三、自旋锁死锁 spin_lock_init spin_lock spin_unlock

static spinlock_t spinlock_test;//定义 spinlock_t 类型的自旋锁变量 spinlock_test
static int open_test(struct inode *inode,struct file *file)
{
	spin_lock(&spinlock_test);// 自旋锁加锁
	return 0;
}

static int release_test(struct inode *inode,struct file *file)
{
	spin_unlock(&spinlock_test);// 自旋锁解锁
	return 0;
}

static int __init atomic_init(void)
{
	spin_lock_init(&spinlock_test);
	...
}

函数	描述
void spin_lock_irq(spinlock_t *lock)	禁止本地中断，并获取自旋锁。
void spin_unlock_irq(spinlock_t *lock)	激活本地中断，并释放自旋锁。
void spin_lock_irqsave(spinlock_t *lock, unsigned long flags)	恢复中断状态，关闭中断并获取自旋锁。
void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)	将中断状态恢复到以前的状态，打开中断并释放自旋锁。
void spin_lock_bh(spinlock_t *lock)	关闭下半部，获取自旋锁。
void spin_unlock_bh(spinlock_t *lock)	打开下半部，获取自旋锁。

四、信号量 sema_init up down

struct semaphore {
	raw_spinlock_t lock;
	unsigned int count;
	struct list_head wait_list;
};

struct semaphore semaphore_test;//定义一个 semaphore 类型的结构体变量 semaphore_test
static int open_test(struct inode *inode,struct file *file)
{
	printk("\nthis is open_test \n");
	down(&semaphore_test);// 信号量数量减 1
	return 0;
}

static int release_test(struct inode *inode,struct file *file)
{
	up(&semaphore_test);// 信号量数量加 1
	printk("\nthis is release_test \n");
	return 0;
}

static int __init atomic_init(void)
{
	sema_init(&semaphore_test,1);//初始化信号量结构体 semaphore_test，并设置信号量的数量为 1
	...
}

函数	描述
DEFINE_SEMAPHORE(name)	定义信号量，并且设置信号量的值为 1。
void sema_init(struct semaphore *sem, int val)	初始化信号量 sem，设置信号量值为 val。
void down(struct semaphore *sem)	获取信号量，不能被中断打断，如 Ctrl+C。
int down_interruptible(struct semaphore *sem)	获取信号量，可以被中断打断，如 Ctrl+C。
void up(struct semaphore *sem)	释放信号量。
int down_trylock(struct semaphore *sem)	尝试获取信号量，如果能获取到信号量就获取，并且返回 0。 如果不能就返回非 0。

五、互斥锁 mutex_init mutex_lock

struct mutex {
	atomic_long_t owner;
	spinlock_t wait_lock;
	#ifdef CONFIG_MUTEX_SPIN_ON_OWNER
	struct optimistic_spin_queue osq; /* Spinner MCS lock */
	#endif
	struct list_head wait_list;
	#ifdef CONFIG_DEBUG_MUTEXES
	void *magic;
	#endif
	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	struct lockdep_map dep_map;
	#endif
};

struct mutex mutex_test;// 定义 mutex 类型的互斥锁结构体变量 mutex_test
static int open_test(struct inode *inode,struct file *file)
{
	printk("\nthis is open_test \n");
	mutex_lock(&mutex_test);// 互斥锁加锁
	return 0;
}

struct mutex mutex_test;// 定义 mutex 类型的互斥锁结构体变量 mutex_test
static int open_test(struct inode *inode,struct file *file)
{
	printk("\nthis is open_test \n");
	mutex_lock(&mutex_test);// 互斥锁加锁
	return 0;
}

static int __init atomic_init(void)
{
	mutex_init(&mutex_test);//对互斥体进行初始化
	...
}

函数	描述
DEFINE_MUTEX(name)	定义并初始化一个 mutex 变量。
void mutex_init(mutex *lock)	初始化 mutex。
void mutex_lock(struct mutex *lock)	获取 mutex，也就是给 mutex 上锁。如果获取不到就进休眠。
void mutex_unlock(struct mutex *lock)	释放 mutex，也就给 mutex 解锁。
int mutex_is_locked(struct mutex *lock)	判断 mutex 是否被获取，如果是的话就返回 1，否则返回 0。

第二部分 IO模型

一、概念

二、阻塞IO wait_event_interruptible wake_up_interruptible

DECLARE_WAIT_QUEUE_HEAD(read_wq); //定义并初始化等待队列头

/*向设备写入数据函数*/
static ssize_t cdev_test_write(struct file *file, const char __user *buf, size_t size, loff_t *off)
{
	struct device_test *test_dev=(struct device_test *)file->private_data;
	if (copy_from_user(test_dev->kbuf, buf, size) != 0)
	{
		printk("copy_from_user error\r\n");
		return -1;
	}
	test_dev->flag=1;//将条件置 1
	wake_up_interruptible(&read_wq); //并使用 wake_up_interruptible 唤醒等待队列中的休眠进程
	return 0;
}

/**从设备读取数据*/
static ssize_t cdev_test_read(struct file *file, char __user *buf, size_t size, loff_t *off)
{
	struct device_test *test_dev=(struct device_test *)file->private_data;
	wait_event_interruptible(read_wq,test_dev->flag); //可中断的阻塞等待，使进程进入休眠态
	if (copy_to_user(buf, test_dev->kbuf, strlen( test_dev->kbuf)) != 0)
	{
		printk("copy_to_user error\r\n");
		return -1;
	}
	return 0;
}

//结构体--等待队列头
struct _wait_queue_head{
	spinlock_t lock; //自旋锁
	struct list_head task_list //链表头
}；
typefef struct _wait_queue_head wait_queue_head_t;
//结构体--等待队列项
struct _wait_queue{
	unsigned int flags;
	void *private;
	wait_queue_func_t func;
	struct list_head task_list;
};
typedef struct _wait_queue wait_queue_t;

//定义初始化队列头--方法一
#define DECLARE_WAIT_QUEUE_HEAD(name) \
wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
//定义初始化队列头--方法二
#define init_waitqueue_head(q) \
do { \
	static struct lock_class_key __key; \
	__init_waitqueue_head((q), #q, &__key); \
} while (0)

//创建等待队列项
#define DECLARE_WAITQUEUE(name, tsk) \
struct wait_queue_entry name = __WAITQUEUE_INITIALIZER(name, tsk)

//增加队列
void add_wait_queue(wait_queue_head_t *q,wait_queue_t *wait)
//删除队列
void remove_wait_queue(wait_queue_head_t *q,wait_queue_t *wait)

//不可中断阻塞等待--唤醒条件：condition为true
#define __wait_event(wq_head, condition) \
(void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 0, 0, \
schedule())


//★★★可中断阻塞等待--唤醒条件：condition为true  或  信号打断
#define __wait_event_interruptible(wq_head, condition) \
___wait_event(wq_head, condition, TASK_INTERRUPTIBLE, 0, 0, \
schedule())

//唤醒所有休眠进程
wake_up(wait_queue_head_t *q)

//★★★唤醒可中断的休眠进程
wake_up_interruptible(wait_queue_head_t *q)

三、非阻塞IO O_NONBLOCK

DECLARE_WAIT_QUEUE_HEAD(read_wq);

static ssize_t cdev_test_write(struct file *file, const char __user *buf, size_t size, loff_t *off)
{
	struct device_test *test_dev=(struct device_test *)file->private_data;
	if (copy_from_user(test_dev->kbuf, buf, size) != 0)
	{
		printk("copy_from_user error\r\n");
		return -1;
	}
	test_dev->flag=1;
	wake_up_interruptible(&read_wq);
	return 0;

/**从设备读取数据*/
static ssize_t cdev_test_read(struct file *file, char __user *buf, size_t size, loff_t *off)
{
	struct device_test *test_dev=(struct device_test *)file->private_data;
	if(file->f_flags & O_NONBLOCK ){ //★★★
		if (test_dev->flag !=1)
		return -EAGAIN;
	}
	wait_event_interruptible(read_wq,test_dev->flag);
	if (copy_to_user(buf, test_dev->kbuf, strlen( test_dev->kbuf)) != 0)
	{
		printk("copy_to_user error\r\n");
		return -1;
	}
	return 0;
}

/* 阻塞方式打开 */
int fd;
int data = 0;
fd = open("/dev/xxx_dev", O_RDWR); /* 阻塞方式打开 */
ret = read(fd, &data, sizeof(data)); /* 读取数据 */

/* 非阻塞方式打开 */
int fd;
int data = 0;
fd = open("/dev/xxx_dev", O_RDWR | O_NONBLOCK); /* 非阻塞方式打开 */
ret = read(fd, &data, sizeof(data)); /* 读取数据 */

四、多路复用IO

// 应用程序--读
int main(int argc, char *argv[])
{
	int fd;
	struct pollfd fds[1];
	fd = open("/dev/test", O_RDWR);
	fds[0] .fd =fd;
	fds[0].events = POLLIN;
	while (1)
	{
		ret = poll(fds,1,3000); //轮询文件是否可操作，超时 3000ms
		if(!ret){
		} else if (fds[0].revents == POLLIN) {
			read(fd,buf1,sizeof(buf1));
			printf("buf is %s \n,",buf1);
			sleep(1);
		}
	}
	close(fd);
	return 0;
}
// 应用程序--写
int main(int argc, char *argv[])
{
	int fd;
	char buf1[32] = {0};
	char buf2[32] = "nihao";
	fd = open("/dev/test",O_RDWR);
	write(fd,buf2,sizeof(buf2));
	close(fd);
	return 0;
}
// 驱动程序
DECLARE_WAIT_QUEUE_HEAD(read_wq);

struct device_test{
dev_t dev_num; //设备号
int major ; //主设备号
int minor ; //次设备号
struct cdev cdev_test; // cdev
struct class *class; //类
struct device *device; //设备
char kbuf[32];
int flag; //标志位
};
struct device_test dev1;

static int cdev_test_open(struct inode *inode, struct file *file)
{
	file->private_data=&dev1;//设置私有数据
}

static ssize_t cdev_test_write(struct file *file, const char __user *buf, size_t size, loff_t *off)
{
	struct device_test *test_dev=(struct device_test *)file->private_data;
	if (copy_from_user(test_dev->kbuf, buf, size) != 0)
	{
		printk("copy_from_user error\r\n");
		return -1;
	}
	test_dev->flag=1;
	wake_up_interruptible(&read_wq);
	return 0;
}

static ssize_t cdev_test_read(struct file *file, char __user *buf, size_t size, loff_t *off)
{
	struct device_test *test_dev=(struct device_test *)file->private_data;
	if(file->f_flags & O_NONBLOCK ){
		if (test_dev->flag !=1)
		return -EAGAIN;
	}
	wait_event_interruptible(read_wq,test_dev->flag);
	if (copy_to_user(buf, test_dev->kbuf, strlen( test_dev->kbuf)) != 0)
	{
		printk("copy_to_user error\r\n");
		return -1;
	}
	printk("This is cdev_test_read\r\n");
	return 0;
}

static __poll_t cdev_test_poll(struct file *file, struct poll_table_struct *p){
	struct device_test *test_dev=(struct device_test *)file->private_data;
	__poll_t mask=0;
	poll_wait(file,&read_wq,p);
	if (test_dev->flag == 1)
	{
		mask |= POLLIN;
	}
	return mask;
}

struct file_operations cdev_test_fops = {
	.owner = THIS_MODULE,
	.open = cdev_test_open,
	.read = cdev_test_read,
	.write = cdev_test_write,
	.release = cdev_test_release,
	.poll = cdev_test_poll, // 将 poll 字段指向 chrdev_poll(...) 函数
};

// 函数原型
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
// 第一个参数
struct pollfd {
	int fd; //被监视的文件描述符
	short events; //等待的事件
	short revents; //实际发生的事件
}；

POLLIN 有数据可以读取
POLLPRI 有紧急的数据需要读取
POLLOUT 可以写数据
POLLERR 指定的文件描述符发生错误
POLLHUP 指定的文件描述符挂起
POLLNVAL 无效的请求
POLLRDNORM 等同于 POLLIN
// 第二个参数 poll 函数要监视的文件描述符数量

// 第三个参数 timeout:指定等待的时间，单位是 ms。无论 I/O 是否准备好，时间到 POLL就会返回。如果 timepoll 大于 0 等待指定的时间，如果 timeout 等于 0，立即返回。如果 timeout 等于-1，事件发生以后才返回。

unsigned int (*poll)(struct file *filp,struct poll_table_struct *wait);
void poll_wait(struct file *filp,wait_queue_head_t *queue,poll_table *wait);

五、信号驱动IO

// read.c

static void func(int signum)
{
	read(fd,buf1,32);
	printf ("buf is %s\n",buf1);
}
int main(int argc, char *argv[])
{
	...
	//步骤一：使用 signal 函数注册 SIGIO 信号的信号处理函数
	signal(SIGIO,func); 
	//步骤二：设置能接收这个信号的进程
	//fcntl 函数用来操作文件描述符，
	//F_SETOWN 设置当前接收的 SIGIO 的进程 ID
	fcntl(fd,F_SETOWN,getpid());
	flags = fcntl(fd,F_GETFD); //获取文件描述符标志
	//步骤三 开启信号驱动 IO 使用 fcntl 函数的 F_SETFL 命令打开 FASYNC 标志
	fcntl(fd,F_SETFL,flags| FASYNC);
	while(1);
	close(fd); //关闭文件
	return 0;
}

//module.ko
static ssize_t cdev_test_write(struct file *file, const char __user *buf, size_t size, loff_t *off)
{
	struct device_test *test_dev=(struct device_test *)file->private_data;
	if (copy_from_user(test_dev->kbuf, buf, size) != 0) {
		printk("copy_from_user error\r\n");
		return -1;
	}
	test_dev->flag=1;
	wake_up_interruptible(&read_wq);
	kill_fasync(&test_dev->fasync,SIGIO,POLLIN);
	return 0;
}

static int cdev_test_fasync (int fd, struct file *file, int on)
{
	struct device_test *test_dev=(struct device_test *)file->private_data; // 设置私有数据
	return fasync_helper(fd,file,on,&test_dev->fasync);
}

struct file_operations cdev_test_fops = {
	.owner = THIS_MODULE, //将 owner 字段指向本模块，可以避免在模块的操作正在被使用时卸载该模块
	.open = cdev_test_open, //将 open 字段指向 chrdev_open(...)函数
	.read = cdev_test_read, //将 open 字段指向 chrdev_read(...)函数
	.write = cdev_test_write, //将 open 字段指向 chrdev_write(...)函数
	.release = cdev_test_release, //将 open 字段指向 chrdev_release(...)函数
	.poll = cdev_test_poll, //将 poll 字段指向 chrdev_poll(...)函数
	.fasync = cdev_test_fasync, // 将 fasync 字段指向 cdev_test_fasync(...) 函数
};

int fcntl(int fd,int cmd, ...)

int (*fasync) (int fd,struct file *filp,int on)
int fasync_helper(int fd,struct file *filp,int on,struct fasync_struct **fapp)
void kill_fasync(struct fasync_struct **fp,int sig,int band)

命令名	描述
F_DUPFD	复制文件描述符
F_GETFD	获取文件描述符标志
F_SETFD	设置文件描述符标志
F_GETFL	获取文件状态标志
F_SETFL	设置文件状态标志
F_GETLK	获取文件锁
F_SETLK	设置文件锁
F_SETLKW	类似 F_SETLK，但等待返回
F_GETOWN	获取当前接收 SIGIO 和 SIGURG 信号的进程 ID 和进程组 ID
F_SETOWN	设置当前接收 SIGIO 和 SIGURG 信号的进程 ID 和进程组 ID