Linux驱动等待队列与poll机制

Linux驱动等待队列与poll机制

    当我们在操作设备时，我们经常遇到当设备获取不到资源时就会挂起进程，当设备资源满足要求时再唤醒进程(如read函数，当读不到数据时就会挂起，读到了数据则可立刻返回)。这种通过阻塞方式访问设备，可以极大的减轻CPU负荷，在进程挂起是可以让CPU去执行其它资源。而通过等待队列的方式就可实现进程阻塞，满足要求时再唤醒进程。

      因为阻塞的进程会进入休眠状态， 因此， 必须确保有一个地方能够唤醒休眠的进程。 唤醒进程的地方最大可能发生在中断里面， 因为硬件资源获得的同时往往伴随着一个中断。

      在内核中，等待队列的合理应用可以极大的提供CPU执行效率，尤其是在中断处理、进程同步、定时等场合。可以使用等待队列实现阻塞进程的唤醒。它以队列为基础数据结构，与进程调度机制紧密结合，能够用于实现内核中的异步事件通知机制，同步对系统资源的访问等。

      等待队列是一种基于资源状态的线程管理的机制，它可以使线程在资源不满足的情况下处于休眠状态，让出CPU资源，而资源状态满足时唤醒线程，使其继续进行业务的处理。

      等待队列（wait queue）用于使线程等待某一特定的事件发生而无需频繁的轮询，进程在等待期间睡眠，在某件事发生时由内核自动唤醒。它是以双循环链表为基础数据结构，与进程的休眠唤醒机制紧密相联，是实现异步事件通知、跨进程通信、同步资源访问等技术的底层技术支撑。

1.等待队列相关接口函数

  在Linux中，等待队列是由等待队列头wait_queue_head_t *q进行管理，结构体信息如下：

struct __wait_queue_head {
	spinlock_t lock;
	struct list_head task_list;
};

1.1 等待队列头初始化

  初始化等待队列头可以静态初始化或者动态初始化

#define DECLARE_WAIT_QUEUE_HEAD(name)
功能： 静态初始化等待队列头
参数： name --等待队列头结构体变量名

#define init_waitqueue_head(q)
功能： 静态初始化等待队列头
参数： q–等待队列头结构体指针变量

  注意：动态初始化时需要手动创建一个等待队列头结构体变量，而静态初始化只需要填入等待队列头变量名即可。即：
  DECLARE_WAIT_QUEUE_HEAD(q)等价于下面两行代码：

wait_queue_head_t q;
init_waitqueue_head(&q);//动态初始化等待队列头

1.2 休眠进程

  休眠进程由两类函数：可中断休眠 和 不可中断休眠。可中断休眠可中断休眠是可以通过信号方式唤醒；不可中断休眠则在休眠期间无法收到信号(如CTRL+C、CTRL+)，信号将会被阻塞，必须等待进程唤醒后才能响应信号。

• 可中断休眠函数

#define wait_event_interruptible(wq, condition)				
({									
	int __ret = 0;							
	if (!(condition))						
		__wait_event_interruptible(wq, condition, __ret);	
	__ret;								
})
//不可中断休眠，但可以指定超时时间
#define __wait_event_timeout(wq, condition, ret)			
do {									
	DEFINE_WAIT(__wait);						
									
	for (;;) {							
		prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);	
		if (condition)						
			break;						
		ret = schedule_timeout(ret);				
		if (!ret)						
			break;						
	}								
	finish_wait(&wq, &__wait);					
} while (0)

  wq为等待队列头；
  condition为唤醒标志，condition为真唤醒进程，为假则为休眠状态；
  ret为要指定的超时时间，单位为时钟节拍jiffies

• 不可中断休眠函数

#define wait_event(wq, condition) 					
do {									
	if (condition)	 						
		break;							
	__wait_event(wq, condition);					
} while (0)
//可中断休眠，但可以指定超时时间
#define __wait_event_interruptible_timeout(wq, condition, ret)		
do {									
	DEFINE_WAIT(__wait);						
									
	for (;;) {							
		prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);	
		if (condition)						
			break;						
		if (!signal_pending(current)) {				
			ret = schedule_timeout(ret);			
			if (!ret)					
				break;					
			continue;					
		}							
		ret = -ERESTARTSYS;					
		break;							
	}								
	finish_wait(&wq, &__wait);					
} while (0)

  wq为等待队列头；
  condition为唤醒标志，condition为真唤醒进程，为假则为休眠状态。
  ret为要指定的超时时间，单位为时钟节拍jiffies

1.3 唤醒进程

  唤醒休眠进程函数分为两类：一是可唤醒可中断和不可中断休眠进程；二是只能唤醒可中断休眠进程。
  唤醒进程函数一般是在设备获取到资源时调用，调用位置常处于中断处理函数中。

//可唤醒可中断和不可中断休眠进程
#define wake_up(x)			__wake_up(x, TASK_NORMAL, 1, NULL)  //随机唤醒一个休眠进程
#define wake_up_nr(x, nr)		__wake_up(x, TASK_NORMAL, nr, NULL)  //唤醒多个休眠进程
#define wake_up_all(x)			__wake_up(x, TASK_NORMAL, 0, NULL)  //唤醒所有休眠进程
//只能唤醒可中断休眠进程
#define wake_up_interruptible(x)	__wake_up(x, TASK_INTERRUPTIBLE, 1, NULL) //随机唤醒一个休眠进程
#define wake_up_interruptible_nr(x, nr)	__wake_up(x, TASK_INTERRUPTIBLE, nr, NULL) //唤醒多个休眠进程
#define wake_up_interruptible_all(x)	__wake_up(x, TASK_INTERRUPTIBLE, 0, NULL) //唤醒所有休眠进程

1.4 等待队列应用示例
 下面以按键为例，实现中断方式按键检测，通过工作队列处理底半部分代码，杂项设备框架实现设备注册。在按键的工作函数中唤醒休眠进程。在位获取到按键信息时将进程休眠。
 Linux中断编程参考：https://blog.csdn.net/weixin_44453694/article/details/126812705

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 
#define KEY_CNT sizeof(key_info)/sizeof(struct key_info)  //按键个数

//static wait_queue_head_t key_q;/*等待队列头(动态初始化时需要定义)*/
DECLARE_WAIT_QUEUE_HEAD(key_q);//静态初始化等待队列头
struct key_info
{
	unsigned int gpio;//gpio口
	int irq;//中断号
	char key_name[20];//注册中断名字
	int key_num;//按键编号
};
//按键信息保存
static struct key_info key_info[]=
{
	{EXYNOS4_GPX3(2),0,"key1",1},
	{EXYNOS4_GPX3(3),0,"key2",2},
	{EXYNOS4_GPX3(4),0,"key3",3},
	{EXYNOS4_GPX3(5),0,"key4",4}
};
static struct key_info *key_p;
static struct work_struct key_work;/*工作结构体*/
static int key_val;
static int condition=0;/*唤醒标志*/
/*工作处理函数*/
void work_func(struct work_struct *work)
{
	msleep(10);//按键消抖
	if(gpio_get_value(key_p->gpio)==0)
	{
		//printk("KEY %d 按下n",key_p->key_num);
		key_val=key_p->key_num;
	}
	condition=1;//将唤醒标志置位
	wake_up(&key_q);
	
}
/*中断服务函数*/
static irqreturn_t key_exit_work(int irq, void *dev)
{
	key_p=(struct key_info *)dev;
	schedule_work(&key_work);//工作调度
	return IRQ_HANDLED;
}

static int key_open(struct inode *inode, struct file *file)
{
	printk("设备打开成功n");
	return 0;
}
static ssize_t key_read(struct file *file, char __user *data, size_t size, loff_t *offset)
{
	int ret;
	int key;
	//wait_event(key_q, condition);//休眠进程(不可中断休眠)
	wait_event_interruptible(key_q, condition);//休眠进程(可中断休眠)
	key=key_val;
	condition=0;//清除唤醒标志
	ret=copy_to_user(data,&key,sizeof(key));
	return sizeof(key)-ret;
}
static int key_release(struct inode *inode, struct file *file)
{
	printk("设备关闭成功n");
	return 0;
}
/*文件操早集合*/
static struct file_operations key_fops=
{
	.open=		key_open,
	.read=		key_read,
	.release=	key_release
};


/*杂项设备结构体*/
static struct miscdevice key_misc=
{
	.minor=MISC_DYNAMIC_MINOR,//次设备号，255，有内核分配
	.name="key_exit",//在/dev下生成的设备节点名字
	.fops=&key_fops
};
static int __init wbyq_key_exit_init(void)
{
	int i=0;
	int ret;
	/*初始化等待队列头*/
	//init_waitqueue_head(&key_q);
	/*初始化工作*/
	INIT_WORK(&key_work, work_func);
	for(i=0;i;i++)>

• 执行效果

 

 　　审核编辑：汤梓红