linux设备驱动之阻塞与非阻塞I/O

最新推荐文章于 2021-03-16 00:36:19 发布

置顶算法+数据结构

最新推荐文章于 2021-03-16 00:36:19 发布

阅读量604

点赞数

分类专栏： linux设备驱动文章标签：驱动内核阻塞

本文链接：https://blog.csdn.net/ningxiaowei2013/article/details/15943425

版权

linux设备驱动专栏收录该内容

6 篇文章 2 订阅

订阅专栏

先做一下与内核阻塞有关的知识储备：

1）进程休眠：

进程休眠，简单的说就是正在运行的进程让出CPU。休眠的进程会被内核搁置在在一边，只有当内核再次把休眠的进程唤醒，进程才会会重新在CPU运行。这是内核中的进程调度。一个CPU在同一时间只能有一个进程在运行，微观串行宏观并行，在宏观上，我们觉得是所有进程同时进行的。实际上并不是这样，内核给每个进程分配了4G的虚拟内存，并且让每个进程傻乎乎的以为自己霸占着CPU运行。同时，内核暗中的将所有的进程按一定的算法将CPU轮流的给每个进程使用，而休眠就是进程没有被运行时的一种形式。在休眠下，进程不占用CPU，等待被唤醒

2）等待队列

等待队列是一个存放着等待某个特定事件进程链表。用于存放等待唤醒的进程，等待队列结构

1.先看一下队列头的样子：

/*linux/wait.h*/

struct __wait_queue_head {

spinlock_t lock; //这个是自旋锁，在这里不需要理会。

struct list_head task_list; //这就是队列头中的核心，链表头。

};

typedef struct __wait_queue_head wait_queue_head_t;

2.定义并初始化一个链表，在这个链表添加需要等待的进程

1）静态定义并初始化，一个函数执行完两个操作

DECLARE_WAIT_QUEUE_HEAD(name)

使用：定义并初始化一个叫name的等待队列。

2）分开两步执行。

2.1）定义

wait_queue_head_t test_queue;

2.2）初始化

init_waitqueue_head(&test_queue);

初始化函数的位置，它必须在cdev添加函数”cdev_add”前。因为”cdev_add”执行成功就意味着设备可以被操作，设备被操作前当然需要把所有的事情都干完，包括等待队列的初始化。

3）进程休眠

唤醒休眠进程

void wake_up_interruptible(wait_queue_head_t *queue); //唤醒等待队列中所有可中断睡眠的进程

知识点已经介绍完，总结一下上面驱动函数的操作：

1）首先需要定义并初始化一个等待队列。

2）test_read函数中，如果条件不符合，调用该函数的进程就会进入休眠。

3）每当另一个进程调用test_write函数唤醒等待队列，test_read中的函数就会再一次判断条件是否符合，如果不符合，就会继续休眠，直到哪次的唤醒时条件符合。

非阻塞实现--只需要加上判定条件

if(filp->f_flags&O_NONBLOCK)

（下面函数实现了阻塞与非阻塞）

阻塞

  #include <linux/module.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <asm/system.h>
#include <asm/io.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/fcntl.h>

MODULE_LICENSE("Dual BSD/GPL");

#define GLOBALMEM_SIZE 0x1000
#define MEM_CLEAR 0x1
//#define GLOBALMEM_MAJOR 250

static int globalmem_major=0;
static const struct file_operations globalmem_fops;
struct globalmem_dev{
	struct cdev cdev;
	unsigned char mem[GLOBALMEM_SIZE];
	unsigned int cur_size;
	wait_queue_head_t test_queue;
};

static struct globalmem_dev dev;

static ssize_t globalmem_read(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
	unsigned long p=*ppos;
	int ret=0;

	if(!wait_event_interruptible(dev.test_queue,dev.cur_size)){
		if(p>=GLOBALMEM_SIZE-p)
			return 0;
			if(count>GLOBALMEM_SIZE-p)
				count=GLOBALMEM_SIZE-p;
			if(copy_to_user(buf,(void*)(dev.mem+p),count))
				return -EFAULT;
			else{
				*ppos+=count;
				ret=count;
				dev.cur_size-=ret;
				printk(KERN_INFO "read %d bytes(s) from %d\n",\
					count,p);
				return count;
				}	
		}else
			return -ERESTARTSYS;

	}
}

static ssize_t globalmem_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
	unsigned long p=*ppos;
	int ret=0;

	if(p>=GLOBALMEM_SIZE-p)
		return 0;
	if(count>GLOBALMEM_SIZE-p)
		count=GLOBALMEM_SIZE-p;
	if(copy_from_user(dev.mem+p,buf,count))
		ret=-EFAULT;
	else{
		*ppos+=count;
		ret=count;
		printk(KERN_INFO "written %d bytes(s) from %d\n",count,p);
	}
	
	dev.cur_size+=ret;
	wake_up_interruptible(&dev.test_queue);
	return ret;	
}
static void globalmem_setup_cdev()
{
	int err;
	dev_t devno=MKDEV(globalmem_major,0);

	cdev_init(&dev.cdev,&globalmem_fops);
	dev.cdev.owner=THIS_MODULE;
	
	init_waitqueue_head(&dev.test_queue);

	err=cdev_add(&dev.cdev,devno,1);
	if(err){
		printk(KERN_NOTICE "Error %d adding globalmem",err);
	}
}

static const struct file_operations globalmem_fops={
	.owner=THIS_MODULE,
	.write=globalmem_write,
	.read=globalmem_read,
};

int globalmem_init(void)
{
	int result;
	dev_t devno=MKDEV(globalmem_major,0);

	if(globalmem_major){
		result=register_chrdev_region(devno,1,"my_globalmem");
	}else{
		result=alloc_chrdev_region(&devno,0,1,"my_globalmem");
		globalmem_major=MAJOR(devno);
	}
	if(result<0){
		return result;
	}
	
	globalmem_setup_cdev();
	return 0;
}

void globalmem_exit(void)
{
	cdev_del(&dev.cdev);
	unregister_chrdev_region(MKDEV(globalmem_major,0),1);
	printk("leavel kernel\n");
	return;
}

module_init(globalmem_init);
module_exit(globalmem_exit);
MODULE_AUTHOR("nw");




 
 
非阻塞
 
 
 
 
#include <linux/module.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <asm/system.h>
#include <asm/io.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/fcntl.h>

MODULE_LICENSE("Dual BSD/GPL");

#define GLOBALMEM_SIZE 0x1000
#define MEM_CLEAR 0x1
//#define GLOBALMEM_MAJOR 250

static int globalmem_major=0;
static const struct file_operations globalmem_fops;
struct globalmem_dev{
	struct cdev cdev;
	unsigned char mem[GLOBALMEM_SIZE];
	unsigned int cur_size;
	wait_queue_head_t test_queue;
};

static struct globalmem_dev dev;

static ssize_t globalmem_read(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
	unsigned long p=*ppos;
	int ret=0;
	if(filp->f_flags&O_NONBLOCK){
		if(dev.cur_size>0){
			if(!wait_event_interruptible(dev.test_queue,dev.cur_size)){
				if(p>=GLOBALMEM_SIZE-p)
					return 0;
				if(count>GLOBALMEM_SIZE-p)
					count=GLOBALMEM_SIZE-p;
				if(copy_to_user(buf,(void*)(dev.mem+p),count))
					return -EFAULT;
				else{
					*ppos+=count;
					ret=count;
					dev.cur_size-=ret;
					printk(KERN_INFO "read %d bytes(s) from %d\n",\
						count,p);
					return count;
					}	
			}else
				return -ERESTARTSYS;
		}else
			return -EAGAIN;
	}
}

static ssize_t globalmem_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
	unsigned long p=*ppos;
	int ret=0;

	if(p>=GLOBALMEM_SIZE-p)
		return 0;
	if(count>GLOBALMEM_SIZE-p)
		count=GLOBALMEM_SIZE-p;
	if(copy_from_user(dev.mem+p,buf,count))
		ret=-EFAULT;
	else{
		*ppos+=count;
		ret=count;
		printk(KERN_INFO "written %d bytes(s) from %d\n",count,p);
	}
	
	dev.cur_size+=ret;
	wake_up_interruptible(&dev.test_queue);
	return ret;	
}
static void globalmem_setup_cdev()
{
	int err;
	dev_t devno=MKDEV(globalmem_major,0);

	cdev_init(&dev.cdev,&globalmem_fops);
	dev.cdev.owner=THIS_MODULE;
	
	init_waitqueue_head(&dev.test_queue);

	err=cdev_add(&dev.cdev,devno,1);
	if(err){
		printk(KERN_NOTICE "Error %d adding globalmem",err);
	}
}

static const struct file_operations globalmem_fops={
	.owner=THIS_MODULE,
	.write=globalmem_write,
	.read=globalmem_read,
};

int globalmem_init(void)
{
	int result;
	dev_t devno=MKDEV(globalmem_major,0);

	if(globalmem_major){
		result=register_chrdev_region(devno,1,"my_globalmem");
	}else{
		result=alloc_chrdev_region(&devno,0,1,"my_globalmem");
		globalmem_major=MAJOR(devno);
	}
	if(result<0){
		return result;
	}
	
	globalmem_setup_cdev();
	return 0;
}

void globalmem_exit(void)
{
	cdev_del(&dev.cdev);
	unregister_chrdev_region(MKDEV(globalmem_major,0),1);
	printk("leavel kernel\n");
	return;
}

module_init(globalmem_init);
module_exit(globalmem_exit);
MODULE_AUTHOR("nw");
调试app函数略

算法+数据结构

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
linux设备驱动之阻塞与非阻塞I/O

先做一下与内核阻塞有关的知识储备：1）进程休眠：进程休眠，简单的说就是正在运行的进程让出CPU。休眠的进程会被内核搁置在在一边，只有当内核再次把休眠的进程唤醒，进程才会会重新在CPU运行。这是内核中的进程调度。一个CPU在同一时间只能有一个进程在运行，微观串行宏观并行，在宏观上，我们觉得是所有进程同时进行的。实际上并不是这样，内核给每个进程分配了4G的虚拟内存，并且让每个进程傻乎乎
复制链接

扫一扫

专栏目录