linux设备驱动中的阻塞IO之等待队列-4

学习目的：学习等待队列用法

编程练习：在读写中加入等待队列

 

1- 阻塞IO

阻塞就是当我想要玩手机时，手机没电了，我得先充电，等有电了，我才能玩手机；当我想玩手机时，手机正好有电，那我就玩呗。

在手机没电的时候，我啥也不干，就躺床上（等待队列）发呆（睡眠）。当手机有电了，会自动重启播放音乐，我听到音乐就会从床上一跃而起（移除等待队列），去拿玩手机（任务处于RUNNING状态），开始玩手机（do something）。

基本原里就是这样，代码将这个基本的动作进行抽象而已。

 

2- 编程实践

代码改动：

在读函数中，如果数据块没有东西可读，任务就挂起；只要有东西读就读出来。并唤醒写任务：数据块没满，可以往里写。

写函数中，如果数据块写满了就挂起，没写满就往里写，并唤醒读队列：里面有东西可以读了。

效果：

模块编译好加载进内核后，开两个终端:

一个终端执行读：cat /dev/globalmem 。此时数据块为空，任务阻塞，

另一个终端写：echo “hello” >>/dev/globalmem。 一旦执行玩这条命令，读终端中就会打印出来，由于读完后数据块又没东西了，就会睡眠。

最终效果就是，写终端写完后，读终端就打印出来

讨论：

读函数中没有死循环，为何会退不出来？

因为cat会读两次，并且有while(dev->current_len == 0)保证！！

 

 

C代码：

//6- globalmem
#include<linux/module.h>
#include<linux/types.h>
#include<linux/fs.h>
#include<linux/errno.h>
#include<linux/mm.h>
#include<linux/sched.h>
#include <linux/sched/signal.h> //signal_pending()头文件
#include<linux/init.h>
#include<linux/cdev.h>
#include <linux/slab.h>
//#include <linux/mutex.h> //增加互斥量
#include<linux/sem.h> //增加互斥量
#include <linux/workqueue.h> //等待队列
#include<asm/io.h>
#include<asm/switch_to.h>
//#include<asm/uaccess.h>
#include <linux/uaccess.h>

#define GLOBALMEM_SIZE 0x1000 /*操作的mem内存大小，全局变量大小4k*/
#define MEM_CLEAR 0x1         /*ioctrl命令码*/
#define GLOBALMEM_MAJOR 243 /*设定globalmem的主设备号，查看已经注册的避免冲突cat /proc/devices*/

static int globalmem_major = GLOBALMEM_MAJOR;
/*globalmem结构体*/
struct globalmem_dev
{
	struct cdev cdev; //字符设备结构体
	unsigned int current_len; /*有效数据长度*/
	unsigned char mem[GLOBALMEM_SIZE]; //大小
	struct semaphore sem;
	wait_queue_head_t r_wait; /*读等待队列头*/
	wait_queue_head_t w_wait; /*写等待队列头*/
};

struct globalmem_dev *globalmem_devp;

/*以下为文件操作：打开、释放、ioctrl、读写、定位*/

/*文件打开操作*/
int globalmem_open(struct inode *inode, struct file *filp)
{
	filp->private_data = globalmem_devp;
	
	printk(KERN_INFO "funt:%s enter!\n",__FUNCTION__);
	return 0;	
}

/*文件释放*/
int globalmem_release(struct inode *inode, struct file *filp)
{
	printk(KERN_INFO "funt:%s enter!\n",__FUNCTION__);
	
	return 0;
}

/*ioctrl操作*/
static long globalmem_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)//和2.6内核不一样！！
{
	struct globalmem_dev *dev = filp->private_data;
	
	printk(KERN_INFO "funt:%s enter!\n",__FUNCTION__);
	
	switch(cmd)
	{
		case MEM_CLEAR: //增加信号量保护共享资源
		
		/*获取信号量*/
		if(down_interruptible(&dev->sem))
			return -ERESTARTSYS;
		
		/*共享资源操作*/
		memset(dev->mem,0,GLOBALMEM_SIZE);	
		
		/*释放信号量*/
		up(&dev->sem);
		
		printk(KERN_INFO "globalmem is set to zero\n");
		
		break;
		
		default:
		return -EINVAL;
	}
	
	return 0;
}

/*读函数*/
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
	int ret =0;
	//unsigned long p = *ppos;
	unsigned int count = size;
	struct globalmem_dev *dev = filp->private_data;
	DECLARE_WAITQUEUE(wait,current);
	
	
	printk(KERN_INFO "funt:%s enter!\n",__FUNCTION__);
	
	
	/*获取信号量*/
	down(&dev->sem); 
	
	add_wait_queue(&dev->r_wait, &wait); //加入读等待队列头
	
	/*等待FIFO非空*/
	while(dev->current_len == 0)
	{
		if(filp->f_flags & O_NONBLOCK)
		{
			ret  = -EAGAIN;
			goto out;
		}
		__set_current_state(TASK_INTERRUPTIBLE);//改变进程状态
		/*释放信号量*/
		up(&dev->sem);
		
		schedule(); //任务调度、切换
		
		if(signal_pending(current)) 
		{
			ret = -ERESTARTSYS;
			goto out2;
		}
		
		/*为保护共享资源互斥访问，再次获取信号量*/
		down(&dev->sem);
	}
	
	/*数据拷贝*/
	if(count > dev->current_len)
		count = dev->current_len;
	if(copy_to_user(buf, dev->mem, count))
	{
		ret = -EFAULT;
		goto out;
	}
	else
	{
		memcpy(dev->mem, dev->mem + count, dev->current_len -count);
		dev->current_len -= count;
		printk(KERN_INFO "read %d butes, current_len:%d\n",count,dev->current_len);
		
		wake_up_interruptible(&dev->w_wait); //唤醒写等待队列
		
		ret = count;
	}
	
	
	out:up(&dev->sem);
	out2:remove_wait_queue(&dev->r_wait, &wait); //移除写等待队列
	set_current_state(TASK_RUNNING);
	
	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 p = *ppos;
	unsigned int count = size;
	struct globalmem_dev *dev = filp->private_data;
	DECLARE_WAITQUEUE(wait, current); //定义等待队列
	
	printk(KERN_INFO "funt:%s enter!\n",__FUNCTION__);
	
	/*获取信号量*/
	down(&dev->sem);
	add_wait_queue(&dev->w_wait, &wait);
	
	while(dev->current_len == GLOBALMEM_SIZE)
	{
		if(filp->f_flags & O_NONBLOCK)
		{
			ret = -EAGAIN;
			goto out;
		}
		
		__set_current_state(TASK_INTERRUPTIBLE); //改变进程状态
		
		/*释放信号量*/
		up(&dev->sem);
		
		/*任务调度、切换*/
		schedule();
		
		if(signal_pending(current))
		{
			ret = -ERESTARTSYS;
			goto out2;
		}
		
		/*重新获取信号量*/
		down(&dev->sem);		
	}
	
	/*数据拷贝*/
	if(count > GLOBALMEM_SIZE - dev->current_len)
		count = GLOBALMEM_SIZE - dev->current_len;
	
	if(copy_from_user(dev->mem + dev->current_len, buf, count))
	{
		ret = -EFAULT;
		goto out;
	}
	else
	{
		dev->current_len += count;
		printk(KERN_INFO "written %d bytes, current_len:%d\n",count,dev->current_len);
		
		wake_up_interruptible(&dev->r_wait);
		ret = count;
	}
	
	
	out: up(&dev->sem);
	out2: remove_wait_queue(&dev->w_wait, &wait);
		  set_current_state(TASK_RUNNING);
		  
	return ret;
	
}

/*文件定位*/
static loff_t globalmem_llseek(struct file *filp, loff_t offset, int orig)
{
	loff_t ret = 0;
	
	switch(orig)
	{
		/*从文件开头偏移*/
		case 0: 
		if(offset < 0)
		{
			ret = -EINVAL;
			break;
		}
		if((unsigned int)offset > GLOBALMEM_SIZE)
		{
			ret = -EINVAL;
			break;
		}
		filp->f_pos = (unsigned int )offset;
		ret = filp->f_pos;
		break;
		
		/*从当前位置偏移*/
		case 1:
		if(filp->f_pos + offset < 0)
		{
			ret = -EINVAL;
			break;
		}
		if((filp->f_pos + offset) > GLOBALMEM_SIZE)
		{
			ret = -EINVAL;
			break;
		}
		filp->f_pos += (unsigned int )offset;
		ret = filp->f_pos;
		break;
		
		default:
		ret = -EINVAL;			
		break;
	}	

	return ret;	
}

/*文件操作结构体*/
static const struct file_operations globalmem_fops = 
{
	.owner = THIS_MODULE,
	.llseek = globalmem_llseek,
	.read = globalmem_read,
	.write = globalmem_write,
	.unlocked_ioctl = globalmem_ioctl,
	.open = globalmem_open,
	.release = globalmem_release,
};

/*初始化并向内核注册cdev*/
static void globalmem_setup_cdev(struct globalmem_dev *dev, int index)
{
	int err;
	int devno = MKDEV(globalmem_major,index);
	
	cdev_init(&dev->cdev,&globalmem_fops); //初始化cdev
	dev->cdev.ops = &globalmem_fops;
	err = cdev_add(&dev->cdev,devno,1);//向内核注册cdev
	if(err)
	{
		printk(KERN_NOTICE "Err %d adding LED%d",err,index);		
	}	
}


/*设备驱动模块加载*/
int globalmem_init(void)
{
	int result;	
	dev_t devno = MKDEV(globalmem_major,0);//如果有主设备号，先求出设备号，向系统注册
	
	if(globalmem_major)
	{
		result = register_chrdev_region(devno,1,"globalmem"); //向内核静态申请设备号，设备号devno已知
	}
	else
	{
		result = alloc_chrdev_region(&devno,0,1,"globalmem");//动态申请设备号，
		globalmem_major = MAJOR(devno);//根据申请到的设备号求出主设备号
	}	
	if(result < 0)
	{
		return result;
	}
	
	/*申请内存*/
	globalmem_devp = kmalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
	if(!globalmem_devp)
	{
		result = -ENOMEM;
		goto fail_malloc;
	}
	memset(globalmem_devp,0,sizeof(struct globalmem_dev));
	
	globalmem_setup_cdev(globalmem_devp,0);//向内核注册cdev
	
	sema_init(&globalmem_devp->sem,1); /*初始化信号量*/
	
	init_waitqueue_head(&globalmem_devp->r_wait); /*初始化读等待队列头*/
	init_waitqueue_head(&globalmem_devp->w_wait); /*初始化写等待队列头*/
		
	printk(KERN_INFO "module_init succ!\n");
	
	return 0;
	
fail_malloc:unregister_chrdev_region(devno,1);//解注册申请的设备号
	return result;
	
}

/*模块卸载*/
void globalmem_exit(void)
{
	cdev_del(&globalmem_devp->cdev);//解注册cdev
	kfree(globalmem_devp);
	unregister_chrdev_region(MKDEV(globalmem_major,0), 1);
	printk(KERN_INFO "module_exit succ!\n");
}

MODULE_AUTHOR("lhk");
MODULE_LICENSE("Dual BSD/GPL");

module_param(globalmem_major, int, S_IRUGO);

module_init(globalmem_init);
module_exit(globalmem_exit);

Makefile

ifneq ($(KERNELRELEASE),)
obj-m:=globalmem.o
else
KDIR:=/lib/modules/$(shell uname -r)/build
PWD:=$(shell pwd)
all:
	make -C $(KDIR) M=$(PWD) modules
clean:
	rm -rf *.ko *.o *.symvers *.cmd *.cmd.o
endif