linux设备驱动中的非阻塞IO之poll -6

学习目的：学习非阻塞IO的编程练习

主要用到poll进行阻塞等待。具体的还没理解好，只是比着代码敲了一遍。先贴上代码，后续有了新的认识再更新。

1- 阻塞IO的用法理解

poll（）理解：

 

2- 代码实现

代码实现原理：

现象：

之前的都是内核态代码，这里需要再用户态进行编程验证。

a- 用户态代码

C文件

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<sys/time.h>
#include<unistd.h>
#include<errno.h>
#include <unistd.h> //read
#include <sys/ioctl.h> //ioctl


#define MEM_CLEAR 0x1 //ioctl操作码
#define BUFFER_LEN 20

void main()
{
	int fd,num;
	char rd_ch[BUFFER_LEN];
	fd_set rfds,wfds;
	
	/*以阻塞方式打开/dev/globalmem文件*/
	fd = open("/dev/globalmem", O_RDONLY | O_NONBLOCK);
	if(fd == -1)
		printf("dev/globalmem open fail\n");
	else
	{
		if(ioctl(fd, MEM_CLEAR, 0) < 0)
			printf("ioctl command failed\n");
		while(1)
		{
			FD_ZERO(&rfds);
			FD_ZERO(&wfds);
			FD_SET(fd,&rfds);
			FD_SET(fd,&wfds);
			
			select(fd+1, &rfds, &wfds, NULL, NULL);
			if(FD_ISSET(fd, &rfds))
				printf("poll monitor: can be read\n");
			if(FD_ISSET(fd,&wfds))
				printf("poll monitor: can be write\n");		
			
			sleep(5);
		}
	}
	close(fd);
}

Makefile文件

#Makefile

main: main.o
	gcc -o main main.o
main.o:main.c
	gcc -c main.c
	
clean:
	rm -rf *.o main

 

b- 内核态代码

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 <linux/poll.h>  //poll()
#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;	
}

/*globalmem_pool驱动*/
static unsigned int globalmem_poll(struct file *filp, poll_table *wait)
{
	unsigned int mask = 0;
	struct globalmem_dev *dev = filp->private_data; /*获取设备结构体指针*/
	
	/*获取信号量*/
	down(&dev->sem);
	
	/*临界区*/
	poll_wait(filp, &dev->r_wait, wait);
	poll_wait(filp, &dev->w_wait, wait);
	
	if(dev->current_len != 0)
		mask |= POLLIN | POLLRDNORM;
	
	if(dev->current_len != GLOBALMEM_SIZE)
		mask |= POLLOUT |  POLLWRNORM;
	
	/*释放信号量*/
	up(&dev->sem);
	
	return mask;	
}

/*文件操作结构体*/
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,
	.poll = globalmem_poll,
};

/*初始化并向内核注册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 *.mod.c *.order
endif