linux设备驱动开发-高级字符设备操作poll
2014-06-23 14:02
721 查看
在用户程序中,select()和poll()也是与设备阻塞与非阻塞访问息息相关的,使用非阻塞I/O的应用程序通常会使用select和poll系统调用查询是否可对设备进行无阻塞的访问。select系统调用最终会引发设备驱动中的poll函数被执行。
一、select()系统调用:
用于多路监控,当没有一个文件满足要求时,select将阻塞调用进程。
1.select()原型:
返回值:
(1)正常情况下返回满足要求的文件描述符个数;
(2)经过了timeout等待后仍无文件满足要求,返回0;
(3)如果select被某个信号中断,将返回-1并设置errno为EINTR;
(4)若出错,返回-1并设置相应的errno;
2.select的使用方法:
(1)将要监控的文件添加到文件描述符集;
(2)调用select开始监控;
(3)判断文件是否发生变化;
3.系统提供四个宏对描述符集进行操作:
二、Poll方法:
1.poll函数原型:
这个函数应该进行以下两项工作:
(1)对可能引起设备文件状态变化的等待队列调用poll_wait()函数,将对应等待队列添加到poll_table中;
(2)返回表示是否能对设备进行无阻塞可读或可写访问的掩码;
位掩码:POLLRDNORM, POLLIN,POLLOUT,POLLWRNORM
设备可读,通常返回:(POLLIN | POLLRDNORM)
设备可写,通常返回:(POLLOUT | POLLWRNORM)
三、调用过程:
Linux下select调用的过程:
1、用户层应用程序调用select(),底层调用poll())
2、核心层调用sys_select() ------> do_select()
最终调用文件描述符fd对应的struct file类型变量的struct file_operations *f_op的poll函数。
poll指向的函数返回当前可否读写的信息。
1)如果当前可读写,返回读写信息。
2)如果当前不可读写,则阻塞进程,并等待驱动程序唤醒,重新调用poll函数,或超时返回。
3、驱动需要实现poll函数。
当驱动发现有数据可以读写时,通知核心层,核心层重新调用poll指向的函数查询信息。
在中断中使用wake_up_interruptible(&wait_q)唤醒等待队列。
四、实例分析:
1.memdev.h
2.memdev.c
3.app-write.c
4.app-read.c
无意中看到这篇文章,写得非常详细且实用,自己又正想写一篇类似的文章。特此转载
我在补充一个类似的例子,但我觉得可以更好的理解poll的工作,poll 是在每次描述符状态发生变化是调用,并且更具返回值来判断是否需要继续阻塞。
poll的基本使用结构
本文转载:http://www.cnblogs.com/geneil/archive/2011/12/04/2275559.html
一、select()系统调用:
用于多路监控,当没有一个文件满足要求时,select将阻塞调用进程。
1.select()原型:
int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *exceptfds,const struct timeval *timeout); /* *@maxfd : 需要检查的文件描述符个数,数值应该比是三组fd_set中最大数更大(即一般取所有文件描述符的最大值加1),而不是实际文件描述符的总数。 *@readfds: 用来检查可读性的一组文件描述符。 *@writesfds: 用来检查可写性的一组文件描述符。 *@exceptsfds:用来检查意外状态的文件描述符。(注:错误并不是意外状态) *@timeout:NULL指针代表无限等待,否则是指向timeval结构的指针,代表最长等待时间。(如果其中tv_sec和tv_usec都等于0, 则文件描述符的状态不被影响,但函数并不挂起)
返回值:
(1)正常情况下返回满足要求的文件描述符个数;
(2)经过了timeout等待后仍无文件满足要求,返回0;
(3)如果select被某个信号中断,将返回-1并设置errno为EINTR;
(4)若出错,返回-1并设置相应的errno;
2.select的使用方法:
(1)将要监控的文件添加到文件描述符集;
(2)调用select开始监控;
(3)判断文件是否发生变化;
3.系统提供四个宏对描述符集进行操作:
void FD_SET(int fd, fd_set *fdset); //将文件描述符fd添加到文件描述符集fdset中; void FD_CLR(int fd, fd_set *fdset); //从文件描述符集fdset中清除文件描述符fd; void FD_ISSET(int fd, fd_set *fdset); //在调用select后使用FD_ISSET来检测文件描述符集中的文件fd发生了变化 void FD_ZERO(fd_set *fdset);//清空文件描述符集
二、Poll方法:
1.poll函数原型:
unsigned int(*poll)(struct file *filp, struct poll_table *wait); //第一个参数为file结构体指针,第二个参数为轮询表指针。
这个函数应该进行以下两项工作:
(1)对可能引起设备文件状态变化的等待队列调用poll_wait()函数,将对应等待队列添加到poll_table中;
(2)返回表示是否能对设备进行无阻塞可读或可写访问的掩码;
位掩码:POLLRDNORM, POLLIN,POLLOUT,POLLWRNORM
设备可读,通常返回:(POLLIN | POLLRDNORM)
设备可写,通常返回:(POLLOUT | POLLWRNORM)
三、调用过程:
Linux下select调用的过程:
1、用户层应用程序调用select(),底层调用poll())
2、核心层调用sys_select() ------> do_select()
最终调用文件描述符fd对应的struct file类型变量的struct file_operations *f_op的poll函数。
poll指向的函数返回当前可否读写的信息。
1)如果当前可读写,返回读写信息。
2)如果当前不可读写,则阻塞进程,并等待驱动程序唤醒,重新调用poll函数,或超时返回。
3、驱动需要实现poll函数。
当驱动发现有数据可以读写时,通知核心层,核心层重新调用poll指向的函数查询信息。
poll_wait(filp,&wait_q,wait) // 此处将当前进程加入到等待队列中,但并不阻塞
在中断中使用wake_up_interruptible(&wait_q)唤醒等待队列。
四、实例分析:
1.memdev.h
#ifndef _MEMDEV_H_ #define _MEMDEV_H_ #ifndef MEMDEV_MAJOR #define MEMDEV_MAJOR 0 /*预设的mem的主设备号*/ #endif #ifndef MEMDEV_NR_DEVS #define MEMDEV_NR_DEVS 2 /*设备数*/ #endif #ifndef MEMDEV_SIZE #define MEMDEV_SIZE 4096 #endif <pre><span style="color:#008000;">/*</span><span style="color:#008000;">mem设备描述结构体</span><span style="color:#008000;">*/</span> <span style="color:#0000ff;">struct</span> mem_dev { <span style="color:#0000ff;">char</span> *data; unsigned <span style="color:#0000ff;">long</span> size; wait_queue_head_t inq; }; <span style="color:#0000ff;">#endif</span> /* _MEMDEV_H_ */
2.memdev.c
#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/init.h> #include <linux/cdev.h> #include <asm/io.h> #include <asm/system.h> #include <asm/uaccess.h> #include <linux/poll.h> #include "memdev.h" static mem_major = MEMDEV_MAJOR; bool have_data = false; /*表明设备有足够数据可供读*/ module_param(mem_major, int, S_IRUGO); struct mem_dev *mem_devp; /*设备结构体指针*/ struct cdev cdev; /*文件打开函数*/ int mem_open(struct inode *inode, struct file *filp) { struct mem_dev *dev; /*获取次设备号*/ int num = MINOR(inode->i_rdev); if (num >= MEMDEV_NR_DEVS) return -ENODEV; dev = &mem_devp[num]; /*将设备描述结构指针赋值给文件私有数据指针*/ filp->private_data = dev; return 0; } /*文件释放函数*/ int mem_release(struct inode *inode, struct file *filp) { return 0; } /*读函数*/ static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos) { unsigned long p = *ppos; unsigned int count = size; int ret = 0; struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/ /*判断读位置是否有效*/ if (p >= MEMDEV_SIZE) return 0; if (count > MEMDEV_SIZE - p) count = MEMDEV_SIZE - p; while (!have_data) /* 没有数据可读,考虑为什么不用if,而用while */ { if (filp->f_flags & O_NONBLOCK) return -EAGAIN; wait_event_interruptible(dev->inq,have_data); } /*读数据到用户空间*/ if (copy_to_user(buf, (void*)(dev->data + p), count)) { ret = - EFAULT; } else { *ppos += count; ret = count; printk(KERN_INFO "read %d bytes(s) from %d\n", count, p); } have_data = false; /* 表明不再有数据可读 */ /* 唤醒写进程 */ return ret; } /*写函数*/ static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos) { unsigned long p = *ppos; unsigned int count = size; int ret = 0; struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/ /*分析和获取有效的写长度*/ if (p >= MEMDEV_SIZE) return 0; if (count > MEMDEV_SIZE - p) count = MEMDEV_SIZE - p; /*从用户空间写入数据*/ if (copy_from_user(dev->data + p, buf, count)) ret = - EFAULT; else { *ppos += count; ret = count; printk(KERN_INFO "written %d bytes(s) from %d\n", count, p); } have_data = true; /* 有新的数据可读 */ /* 唤醒读进程 */ wake_up(&(dev->inq)); return ret; } /* seek文件定位函数 */ static loff_t mem_llseek(struct file *filp, loff_t offset, int whence) { loff_t newpos; switch(whence) { case 0: /* SEEK_SET */ newpos = offset; break; case 1: /* SEEK_CUR */ newpos = filp->f_pos + offset; break; case 2: /* SEEK_END */ newpos = MEMDEV_SIZE -1 + offset; break; default: /* can't happen */ return -EINVAL; } if ((newpos<0) || (newpos>MEMDEV_SIZE)) return -EINVAL; filp->f_pos = newpos; return newpos; } unsigned int mem_poll(struct file *filp, poll_table *wait) { struct mem_dev *dev = filp->private_data; unsigned int mask = 0; /*将等待队列添加到poll_table */ poll_wait(filp, &dev->inq, wait); if (have_data) mask |= POLLIN | POLLRDNORM; /* readable */ return mask; } /*文件操作结构体*/ static const struct file_operations mem_fops = { .owner = THIS_MODULE, .llseek = mem_llseek, .read = mem_read, .write = mem_write, .open = mem_open, .release = mem_release, .poll = mem_poll, }; /*设备驱动模块加载函数*/ static int memdev_init(void) { int result; int i; dev_t devno = MKDEV(mem_major, 0); /* 静态申请设备号*/ if (mem_major) result = register_chrdev_region(devno, 2, "memdev"); else /* 动态分配设备号 */ { result = alloc_chrdev_region(&devno, 0, 2, "memdev"); mem_major = MAJOR(devno); } if (result < 0) return result; /*初始化cdev结构*/ cdev_init(&cdev, &mem_fops); cdev.owner = THIS_MODULE; cdev.ops = &mem_fops; /* 注册字符设备 */ cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS); /* 为设备描述结构分配内存*/ mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL); if (!mem_devp) /*申请失败*/ { result = - ENOMEM; goto fail_malloc; } memset(mem_devp, 0, sizeof(struct mem_dev)); /*为设备分配内存*/ for (i=0; i < MEMDEV_NR_DEVS; i++) { mem_devp[i].size = MEMDEV_SIZE; mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL); memset(mem_devp[i].data, 0, MEMDEV_SIZE); /*初始化等待队列*/ init_waitqueue_head(&(mem_devp[i].inq)); //init_waitqueue_head(&(mem_devp[i].outq)); } return 0; fail_malloc: unregister_chrdev_region(devno, 1); return result; } /*模块卸载函数*/ static void memdev_exit(void) { cdev_del(&cdev); /*注销设备*/ kfree(mem_devp); /*释放设备结构体内存*/ unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/ } MODULE_AUTHOR("David Xie"); MODULE_LICENSE("GPL"); module_init(memdev_init); module_exit(memdev_exit);
3.app-write.c
#include <stdio.h> int main() { FILE *fp = NULL; char Buf[128]; /*打开设备文件*/ fp = fopen("/dev/memdev0","r+"); if (fp == NULL) { printf("Open Dev memdev Error!\n"); return -1; } /*写入设备*/ strcpy(Buf,"memdev is char dev!"); printf("Write BUF: %s\n",Buf); fwrite(Buf, sizeof(Buf), 1, fp); sleep(5); fclose(fp); return 0; }
4.app-read.c
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/ioctl.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <sys/select.h> #include <sys/time.h> #include <errno.h> int main() { int fd; fd_set rds; int ret; char Buf[128]; /*初始化Buf*/ strcpy(Buf,"memdev is char dev!"); printf("BUF: %s\n",Buf); /*打开设备文件*/ fd = open("/dev/memdev0",O_RDWR); FD_ZERO(&rds); FD_SET(fd, &rds); /*清除Buf*/ strcpy(Buf,"Buf is NULL!"); printf("Read BUF1: %s\n",Buf); ret = select(fd + 1, &rds, NULL, NULL, NULL); if (ret < 0) { printf("select error!\n"); exit(1); } if (FD_ISSET(fd, &rds)) read(fd, Buf, sizeof(Buf)); /*检测结果*/ printf("Read BUF2: %s\n",Buf); close(fd); return 0; }
无意中看到这篇文章,写得非常详细且实用,自己又正想写一篇类似的文章。特此转载
我在补充一个类似的例子,但我觉得可以更好的理解poll的工作,poll 是在每次描述符状态发生变化是调用,并且更具返回值来判断是否需要继续阻塞。
poll的基本使用结构
2 poll / select: 3 4 mypoll(filp, pt) 5 { 6 poll_wait(filp, &wq, pt); // wq 指定可能睡眠的队列头 7 if (condi) // 检查等待的条件是否满足 8 return POLLIN | POLLRDNORM; // 如果满足 则返回相应的标志位 9 return 0; // 不满足 则返回0 10 } 11 12 struct file_operations fops = { 13 .poll = mypoll, 14 };
#include <linux/init.h> #include <linux/module.h> #include <linux/fs.h> #include <linux/cdev.h> #include <linux/uaccess.h> #include <linux/poll.h> #define SIZE 1024 #define NR 4 static int major = 100, minor = 0; module_param(major, int, 0400); module_param(minor, int, 0400); // ================================================================= struct mypipe_t { char buf[SIZE]; int in, out; }; static void mypipe_init(struct mypipe_t *pipe) { pipe->in = pipe->out = 0; } static int mypipe_is_full(struct mypipe_t *pipe) { return (pipe->in + 1) % SIZE == pipe->out; } static int mypipe_is_empty(struct mypipe_t *pipe) { return pipe->in == pipe->out; } static int mypipe_read_one_char(struct mypipe_t *pipe, char *ch) { if (mypipe_is_empty(pipe)) { return -1; } *ch = pipe->buf[pipe->out]; pipe->out = (pipe->out + 1) % SIZE; return 0; } static int mypipe_write_one_char(struct mypipe_t *pipe, char ch) { if (mypipe_is_full(pipe)) { return -1; } pipe->buf[pipe->in] = ch; pipe->in = (pipe->in + 1) % SIZE; return 0; } // ================================================================= struct mydev_t { dev_t devno; struct cdev cdev; wait_queue_head_t rq, wq; struct mypipe_t pipe; }; struct mydev_t mydev[NR]; //================================================================== static int myopen(struct inode *inode, struct file *filp) { #if 0 //MINOR(inode->i_rdev); int index = iminor(inode); filp->private_data = &mydev[index]; #else filp->private_data = container_of(inode->i_cdev, struct mydev_t, cdev); #endif return 0; } static ssize_t myread(struct file *filp, char __user *buf, size_t len, loff_t *off) { int i, ret; char ch; struct mydev_t *devp = filp->private_data; ret = wait_event_interruptible(devp->rq, !mypipe_is_empty(&devp->pipe)); if (ret != 0) { return -EINTR; } for (i = 0; i < len; ++i) { ret = mypipe_read_one_char(&devp->pipe, &ch); if (ret != 0) break; //buf[i] = ch; //copy_to_user(&buf[i], &ch, 1); put_user(ch, &buf[i]); } wake_up_interruptible(&devp->wq); return i; } static ssize_t mywrite(struct file *filp, const char __user *buf, size_t len, loff_t *off) { int i, ret; char ch; struct mydev_t *devp = filp->private_data; ret = wait_event_interruptible(devp->wq, !mypipe_is_full(&devp->pipe)); if (ret != 0) { return -EINTR; } for (i = 0; i < len; ++i) { get_user(ch, &buf[i]); ret = mypipe_write_one_char(&devp->pipe, ch); if (ret != 0) break; } wake_up_interruptible(&devp->rq); return i; } static int myrelease(struct inode *inode, struct file *filp) { return 0; } unsigned int mypoll(struct file *filp, struct poll_table_struct *pt) { int mask = 0; struct mydev_t *devp = filp->private_data; poll_wait(filp, &devp->rq, pt); poll_wait(filp, &devp->wq, pt); if (!mypipe_is_empty(&devp->pipe)) { mask |= POLLIN | POLLRDNORM; } if (!mypipe_is_full(&devp->pipe)) { mask |= POLLOUT | POLLWRNORM; } return mask; } struct file_operations pipe_ops = { .open = myopen, .release = myrelease, .read = myread, .write = mywrite, .poll = mypoll, }; //================================================================== static int __init test_init(void) { int i; dev_t devno; struct mydev_t *devp; devno = MKDEV(major, minor); register_chrdev_region(devno, NR, "mypipe"); for (i = 0; i < NR; ++i) { devp = &mydev[i]; init_waitqueue_head(&devp->rq); init_waitqueue_head(&devp->wq); mypipe_init(&devp->pipe); cdev_init(&devp->cdev, &pipe_ops); devno = MKDEV(major, minor + i); cdev_add(&devp->cdev, devno, 1); } return 0; } static void __exit test_exit(void) { int i; dev_t devno; struct mydev_t *devp; for (i = 0; i < NR; ++i) { devp = &mydev[i]; cdev_del(&devp->cdev); } devno = MKDEV(major, minor); unregister_chrdev_region(devno, NR); } module_init(test_init); module_exit(test_exit); MODULE_LICENSE("GPL");
本文转载:http://www.cnblogs.com/geneil/archive/2011/12/04/2275559.html
相关文章推荐
- linux驱动开发--字符设备:设备轮询操作select/poll
- Linux设备驱动程序第三版学习(7)- 高级字符驱动程序操作(续2)- poll/select
- Linux高级字符设备之Poll操作
- Linux设备驱动程式学习(5)-高级字符驱动程式操作[(2)阻塞型I/O和休眠]
- linux 高级字符设备驱动 ioctl操作介绍 例程分析实现
- Linux高级字符设备之Poll操作
- Linux设备驱动程式学习(6)-高级字符驱动程式操作[(3)设备文档的访问控制]
- 【Linux 驱动】第六章 高级字符驱动程序操作----poll,select,epoll
- Linux高级字符设备之Poll操作
- Linux高级字符设备之Poll操作
- Linux高级字符设备驱动 poll方法(select多路监控原理与实现)
- linux 高级字符设备驱动 ioctl操作介绍 例程分析实现
- Linux设备驱动第六篇:高级字符驱动操作之iotcl
- linux 高级字符设备驱动 ioctl操作介绍 例程分析实现【转】
- 【转】Linux高级字符设备之Poll操作
- linux高级字符设备驱动之 四 poll方法(select多路监控原理与实现)
- Linux高级字符设备驱动 poll方法(select多路监控原理与实现)
- Linux设备驱动程序——高级字符驱动程序操作(poll机制)
- Linux高级字符设备之Poll操作
- Linux 字符设备驱动开发--内存读写操作