1.等待队列应用有两种的写法
(1)手动定义以及添加
(2)自动定义以及添加
第一种,手动定义以及添加方法
(1)定义队列头
wait_queue_head_t &my_queue;
(2)定义队列以及添加到队列头中
DECLARE_WAIT_QUEUE(name,curreut);
add_wait_queue(&my_queue,&name);
(3)判断条件是否满足并且进行阻塞
while(!condition){
if(filp->f_flags & O_NONBLOCK){
ret = -EAGAIN;
break;
}
__set_current_state(TASK_INTERRUPTIBLE);
schedule();
if(signal_pending(current)){
ret = -ERESTARTSYS;
break;
}
}//条件不满足,则会一直阻塞
//设备资源区开始
......
//设备资源区结束
//从myuqeue队列链表中移除,方便下次访问,并设置好进程状态为running
remove_wait_queue(&my_queue,&name);
__set_curret_state(TASK_RUNNING);
(4)条件满足唤醒等待队列头,阻塞休眠的my_queue上的队列进程被唤醒
if(condition){
wake_up_interruptible(&my_queue);
}
第二种 自动添加以及删除的方法
(1)阻塞等待队列条件满足
wait_event_interruptible(my_queue,condition);
/**
*假如条件condition不满足,wait_event_interruptible会做2件事情
*(1)定义一个队列,并且将其添加到my_queue队列链表中
*(2)保存好原来进程的状态,然后设置目前继承为休眠状态,并调度出去
*假如条件conditioin满足的时候,wait_event_interruptible会跳出休眠,并且会将进程从等待队列中移除,并恢复原来进程的状态。
*/
(2)唤醒等待队列
wake_up_interruptible(&my_queue);
2代码实例(包含两种方法)
代码实例将会参考宋宝华的驱动设备编程写一个例子:
利用等待队列实现一个fifo。
当fifo里面没有数据时,读进程A fifo要阻塞(所谓的阻塞就是当操作设备条件不满足时,进程进入休眠,直到条件满足后才访问设备并且成功返回),要等写进程B写进数据后才唤醒通知读进程A可以读取;同样当fifo已经写满后,写进程B要阻塞,要等读进程A读取后才唤醒通知写进程B可以写入。
#include "globalmem.h"
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/completion.h>
#include <linux/wait.h>
#include <linux/signal.h>
#include <linux/sched/signal.h>
#define GLOBALMEM_BUFFER_SIZE 50
#define GLOBALMEM_MAJOR 255
struct globalmem_dev
{
dev_t devno;
struct cdev dev;
unsigned char globalmem_buf[GLOBALMEM_BUFFER_SIZE];
struct mutex globalmem_mutex;
wait_queue_head_t r_wait;
wait_queue_head_t w_wait;
unsigned long current_len;
//struct completion globalmem_complet;
};
struct globalmem_dev *globalmem_devp = NULL;
static int globalmem_open(struct inode *inode, struct file *filp)
{
if(!globalmem_devp)
return -ENODEV;
filp->private_data = globalmem_devp;
return 0;
}
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
int ret = 0;
unsigned long count = size;
struct globalmem_dev *dev = filp->private_data;
mutex_lock(&dev->globalmem_mutex);
if(dev->current_len == 0){
//判断上层访问是否使用不阻塞的标志,不阻塞直接返回再次访问错误。
if(filp->f_flags & O_NONBLOCK){
ret = -EAGAIN;
goto out;
}
//解除互斥量是因为在写进程的时候也会有用到&dev->globalmem_mutex,假如读线程阻塞的时候,不释放dev->globalmem_mutex,
//那么写进程无法持有dev->globalmem_mutex进入写进程资源访问,那么无法访问写进程资源,current_len一直为空,就无法唤醒读进程。
//这样会进入死锁状态。
mutex_unlock(&dev->globalmem_mutex);
wait_event_interruptible(dev->r_wait,dev->current_len!=0);//当currentcurrent!=0不满足阻塞
mutex_lock(&dev->globalmem_mutex);
//判断是否条件满足,不满足被唤醒可能是信号意外唤醒
if(dev->current_len == 0){
ret = -ERESTARTSYS;
goto out;
}
}
//开始访问设备资源
if(count > dev->current_len)
count = dev->current_len;
if(copy_to_user(buf,dev->globalmem_buf,count)){
ret = -EFAULT;
goto out;
}else{
memcpy(&dev->globalmem_buf,&dev->globalmem_buf+count,GLOBALMEM_BUFFER_SIZE-count);
dev->current_len -= count;
wake_up_interruptible(&dev->w_wait);
ret = count;
}
//访问设备资源结束
out:
mutex_unlock(&dev->globalmem_mutex);
return ret;
}
static ssize_t globalmem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
int ret = 0;
unsigned long count = size;
struct globalmem_dev *dev = filp->private_data;
DECLARE_WAITQUEUE(wait,current);
mutex_lock(&dev->globalmem_mutex);
add_wait_queue(&dev->w_wait,&wait);
while(dev->current_len == GLOBALMEM_BUFFER_SIZE){
if(filp->f_flags & O_NONBLOCK){
ret = -EAGAIN;
goto out;
}
__set_current_state(TASK_INTERRUPTIBLE);
mutex_unlock(&dev->globalmem_mutex);
schedule();
if(signal_pending(current)){
ret = -ERESTARTSYS;
goto out2;
}
mutex_lock(&dev->globalmem_mutex);
}
if(count > GLOBALMEM_BUFFER_SIZE -dev->current_len)
count = GLOBALMEM_BUFFER_SIZE - dev->current_len;
if(copy_from_user(dev->globalmem_buf+dev->current_len,buf,count)){
ret = -EFAULT;
}else{
dev->current_len += count;
wake_up_interruptible(&dev->r_wait);
ret = count;
}
out:
mutex_unlock(&dev->globalmem_mutex);
out2:
remove_wait_queue(&dev->w_wait,&wait);
__set_current_state(TASK_RUNNING);
return ret;
}
struct file_operations globalmem_fops = {
.open = globalmem_open,
.read = globalmem_read,
.write = globalmem_write
};
static int __init globalmem_init(void)
{
int ret ;
globalmem_devp = (struct globalmem_dev *)kzalloc(sizeof(struct globalmem_dev),GFP_KERNEL);
if(!globalmem_devp)
return -ENOMEM;
globalmem_devp->devno = MKDEV(GLOBALMEM_MAJOR,0);
if(GLOBALMEM_MAJOR)
ret = register_chrdev_region(globalmem_devp->devno,1,"globalmem");
else
ret = alloc_chrdev_region(&globalmem_devp->devno,0,1,"globalmem");
if(ret < 0)
return ret;
cdev_init(&globalmem_devp->dev,&globalmem_fops);
globalmem_devp->dev.owner = THIS_MODULE;
ret = cdev_add(&globalmem_devp->dev,globalmem_devp->devno,1);
if(ret < 0 ){
unregister_chrdev_region(globalmem_devp->devno,1);
kfree(globalmem_devp);
return ret;
}
globalmem_devp->current_len = 0;
mutex_init(&globalmem_devp->globalmem_mutex);
init_waitqueue_head(&globalmem_devp->r_wait);
init_waitqueue_head(&globalmem_devp->w_wait);
//init_completion(&globalmem_devp->globalmem_complet);
return 0;
}
static void __exit globalmem_exit(void)
{
cdev_del(&globalmem_devp->dev);
unregister_chrdev_region(globalmem_devp->devno,1);
kfree(globalmem_devp);
}
module_init(globalmem_init);
module_exit(globalmem_exit);
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("gentle");
代码程序参考宋宝华老师的驱动设备编程之阻塞章节,不敢说原创,只是说做了记录笔记总结。