之前在Linux驱动之按键驱动编写(中断方式)中编写的驱动程序,如果没有按键按下。read函数是永远没有返回值的,现在想要做到即使没有按键按下,在一定时间之后也会有返回值。要做到这种功能,可以使用poll机制。分以下几部来介绍poll机制

1、poll机制的使用,编写测试程序

2、poll机制的调用过程分析

3、poll机制的驱动编写

1、poll机制的使用,编写测试程序。

直接看到测试程序的代码。

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <poll.h> /*
*usage ./buttonstest
*/
int main(int argc, char **argv)
{
int fd;
char* filename="dev/buttons";
unsigned char key_val;
unsigned long cnt=;
int ret;
struct pollfd *key_fds;//定义一个pollfd结构体key_fds fd = open(filename, O_RDWR);//打开dev/firstdrv设备文件
if (fd < )//小于0说明没有成功
{
printf("error, can't open %s\n", filename);
return ;
} if(argc !=)
{
printf("Usage : %s ",argv[]);
return ;
}
key_fds ->fd = fd;//文件
key_fds->events = POLLIN;//poll直接返回需要的条件
while()
{
ret = poll(key_fds, , );//调用sys_poll系统调用,如果5S内没有产生POLLIN事件,那么返回,如果有POLLIN事件,直接返回
if(!ret)
{
printf("time out\n");
}
else
{
if(key_fds->revents==POLLIN)//如果返回的值是POLLIN,说明有数据POLL才返回的
{
read(fd, &key_val, ); //读取按键值
printf("key_val: %x\n",key_val);//打印
}
} } return ;
}

从代码可以看出,相比较第三个测试程序third_test。程序源码见Linux驱动之按键驱动编写(中断方式)多定义了一个pollfd 结构体,它的结构如下:

struct pollfd {
int fd; //打开的文件节点
short events; //poll直接返回,需要产生的事件
short revents; //poll函数返回的事件
};

测试程序调用C库函数的poll函数时会用到这个结构体poll(key_fds, 1, 5000);其中第一个参数就是这个结构体的指针,对于多个目标文件来说是首地址,第二个参数为poll等待的文件个数,第三个参数为超时时间。那么poll是怎么实现的呢?

2、poll机制的调用过程分析

应用层利用C库函数调用poll函数的时候,会通过swi软件中断进入到内核层,然后调用sys_poll系统调用。它位于fs\Select.c中。

asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
long timeout_msecs)
{
s64 timeout_jiffies; if (timeout_msecs > ) {//超时参数验证以及处理
#if HZ > 1000
/* We can only overflow if HZ > 1000 */
if (timeout_msecs / > (s64)0x7fffffffffffffffULL / (s64)HZ)
timeout_jiffies = -;
else
#endif
timeout_jiffies = msecs_to_jiffies(timeout_msecs);
} else {
/* Infinite (< 0) or no (0) timeout */
timeout_jiffies = timeout_msecs;
} return do_sys_poll(ufds, nfds, &timeout_jiffies);//调用do_sys_poll
 }

可以看到sys_poll系统调用经过一些参数的验证之后直接调用了do_sys_poll,对于do_sys_poll做一个简单的介绍,它也位于fs\Select.c,它主要调用poll_initwait、do_poll函数

    int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds, s64 *timeout)
{
...
...
poll_initwait(&table);//最终table->pt->qproc = __pollwait
...
...
fdcount = do_poll(nfds, head, &table, timeout);
...
...
}

先看到poll_initwait函数,它的主要功能是将table->pt->qproc = __pollwait,后面会用到

void poll_initwait(struct poll_wqueues *pwq)
{
init_poll_funcptr(&pwq->pt, __pollwait);//pt->qproc = qproc;即table->pt->qproc = __pollwait
pwq->error = ;
pwq->table = NULL;
pwq->inline_index = ;
}

接着看到do_poll(nfds, head, &table, timeout),这里面的主要函数是do_pollfd(pfd, pt)与schedule_timeout(__timeout);下面分别介绍

static int do_poll(unsigned int nfds,  struct poll_list *list,
struct poll_wqueues *wait, s64 *timeout)
{
int count = ;
poll_table* pt = &wait->pt; /* Optimise the no-wait case */
if (!(*timeout))//处理没有超时的情况
pt = NULL; for (;;) {//大循环,一直等待超时时间到或者有相应的事件触发唤醒进程
struct poll_list *walk;
long __timeout; set_current_state(TASK_INTERRUPTIBLE);//设置当前进程为可中断状态
for (walk = list; walk != NULL; walk = walk->next) {//循环查找poll_fd列表
struct pollfd * pfd, * pfd_end; pfd = walk->entries;
pfd_end = pfd + walk->len;
for (; pfd != pfd_end; pfd++) {
/*
* Fish for events. If we found one, record it
* and kill the poll_table, so we don't
* needlessly register any other waiters after
* this. They'll get immediately deregistered
* when we break out and return.
*/
if (do_pollfd(pfd, pt)) {//pwait = table->pt。调用驱动的poll函数获取mask值,另外将进程放入等待队列
count++;
pt = NULL;
}
}
}
/*
* All waiters have already been registered, so don't provide
* a poll_table to them on the next loop iteration.
*/
pt = NULL;
if (count || !*timeout || signal_pending(current))//如果超时时间到了或者没有poll_fd或者事件发生了,直接退出
break;
count = wait->error;
if (count)
break; if (*timeout < ) {
/* Wait indefinitely */
__timeout = MAX_SCHEDULE_TIMEOUT;
} else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT-)) {
/*
* Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in
* a loop
*/
__timeout = MAX_SCHEDULE_TIMEOUT - ;
*timeout -= __timeout;
} else {
__timeout = *timeout;
*timeout = ;
} __timeout = schedule_timeout(__timeout);//设置超时时间,进程休眠
if (*timeout >= )
*timeout += __timeout;
}
__set_current_state(TASK_RUNNING);//重新运行调用sys_poll的进程
return count;
}

现在看到do_pollfd(pfd, pt)函数,它最终会调用驱动层的poll函数file->f_op->poll(file, pwait),这就跟驱动扯上关系了, __pollwait在这里就被用到了,它将当前进程放入驱动层的等待列表,但是这时候当前进程还未休眠。

static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait)
{
unsigned int mask;
int fd; mask = ;
fd = pollfd->fd;//根据pollfd找到文件节点
if (fd >= ) {
int fput_needed;
struct file * file; file = fget_light(fd, &fput_needed);//根据文件节点fd找到文件的file结构
mask = POLLNVAL;
if (file != NULL) {
mask = DEFAULT_POLLMASK;
if (file->f_op && file->f_op->poll)
mask = file->f_op->poll(file, pwait);//根据file结构找到驱动的f_op结构,然后调用它的poll函数,并且返回mask
//这个函数就跟驱动相关了,猜测调用poll_wati将当前进程放到驱动的等待列表。如果有数据的话,那么设置mask = POLLIN
/* Mask out unneeded events. */
mask &= pollfd->events | POLLERR | POLLHUP;
fput_light(file, fput_needed);
}
}
pollfd->revents = mask; return mask;
}

继续看到schedule_timeout(__timeout)函数,它位于kernel\Timer.c,它的主要作用就是设置一个定时器,当超时时间到的时候利用定时器的函数将进程唤醒。最后它还调用schedule(),进行进程的切换,因为在do_poll中已经被设置为TASK_INTERRUPTIBLE状态了。

fastcall signed long __sched schedule_timeout(signed long timeout)
{
struct timer_list timer;
unsigned long expire; switch (timeout)
{
case MAX_SCHEDULE_TIMEOUT:
/*
* These two special cases are useful to be comfortable
* in the caller. Nothing more. We could take
* MAX_SCHEDULE_TIMEOUT from one of the negative value
* but I' d like to return a valid offset (>=0) to allow
* the caller to do everything it want with the retval.
*/
schedule();
goto out;
default:
/*
* Another bit of PARANOID. Note that the retval will be
* 0 since no piece of kernel is supposed to do a check
* for a negative retval of schedule_timeout() (since it
* should never happens anyway). You just have the printk()
* that will tell you if something is gone wrong and where.
*/
if (timeout < ) {
printk(KERN_ERR "schedule_timeout: wrong timeout "
"value %lx\n", timeout);
dump_stack();
current->state = TASK_RUNNING;
goto out;
}
} expire = timeout + jiffies; setup_timer(&timer, process_timeout, (unsigned long)current);//设置一个定时器,处理函数为process_timeout,传入的参数为当前进程,作用是时间到唤醒当前进程
__mod_timer(&timer, expire);//修改定时器的定时时间
schedule();//调度其它进程运行
del_singleshot_timer_sync(&timer);//删除定时器 timeout = expire - jiffies; out:
return timeout < ? : timeout;
}

这就是整个poll机制的过程,接下来需要编写驱动程序file_operations 的poll函数

3、poll机制的驱动编写

直接看到源代码,从源码可以看到相比较third_drv.c驱动,这个在forth_drv_ops结构体中增加了一个forth_drv_poll函数,它的作用就是将调用sys_poll系统调用的的进程放入button_waitq等待队列。如果有按键值改变,那么将返回值设为POLLIN。这个函数在do_pollfd被调用。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <asm/io.h> //含有iomap函数iounmap函数
#include <asm/uaccess.h>//含有copy_from_user函数
#include <linux/device.h>//含有类相关的处理函数
#include <asm/arch/regs-gpio.h>//含有S3C2410_GPF0等相关的
#include <linux/irq.h> //含有IRQ_HANDLED\IRQ_TYPE_EDGE_RISING
#include <asm-arm/irq.h> //含有IRQT_BOTHEDGE触发类型
#include <linux/interrupt.h> //含有request_irq、free_irq函数
#include <linux/poll.h>
//#include <asm-arm\arch-s3c2410\irqs.h> static struct class *forth_drv_class;//类
static struct class_device *forth_drv_class_dev;//类下面的设备
static int forthmajor; static unsigned long *gpfcon = NULL;
static unsigned long *gpfdat = NULL;
static unsigned long *gpgcon = NULL;
static unsigned long *gpgdat = NULL; static unsigned int key_val; struct pin_desc
{
unsigned int pin;
unsigned int key_val;
}; static struct pin_desc pins_desc[] =
{
{S3C2410_GPF0,0x01},
{S3C2410_GPF2,0x02},
{S3C2410_GPG3,0x03},
{S3C2410_GPG11,0x04}
}; unsigned int ev_press;
DECLARE_WAIT_QUEUE_HEAD(button_waitq);//注册一个等待队列button_waitq /*
*0x01、0x02、0x03、0x04表示按键被按下
*/ /*
*0x81、0x82、0x83、0x84表示按键被松开
*/ /*
*利用dev_id的值为pins_desc来判断是哪一个按键被按下或松开
*/
static irqreturn_t buttons_irq(int irq, void *dev_id)
{
unsigned int pin_val;
struct pin_desc * pin_desc = (struct pin_desc *)dev_id;//取得哪个按键被按下的状态 pin_val = s3c2410_gpio_getpin(pin_desc->pin); if(pin_val) //按键松开
key_val = 0x80 | pin_desc->key_val;
else
key_val = pin_desc->key_val; wake_up_interruptible(&button_waitq); /* 唤醒休眠的进程 */
ev_press = ; return IRQ_HANDLED;
} static int forth_drv_open (struct inode * inode, struct file * file)
{
int ret;
ret = request_irq(IRQ_EINT0, buttons_irq, IRQT_BOTHEDGE, "s1", (void * )&pins_desc[]);
if(ret)
{
printk("open failed 1\n");
return -;
}
ret = request_irq(IRQ_EINT2, buttons_irq, IRQT_BOTHEDGE, "s2", (void * )& pins_desc[]);
if(ret)
{
printk("open failed 2\n");
return -;
}
ret = request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "s3", (void * )&pins_desc[]);
if(ret)
{
printk("open failed 3\n");
return -;
}
ret = request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "s4", (void * )&pins_desc[]);
if(ret)
{
printk("open failed 4\n");
return -;
} return ;
} static int forth_drv_close(struct inode * inode, struct file * file)
{
free_irq(IRQ_EINT0 ,(void * )&pins_desc[]); free_irq(IRQ_EINT2 ,(void * )& pins_desc[]); free_irq(IRQ_EINT11 ,(void * )&pins_desc[]); free_irq(IRQ_EINT19 ,(void * )&pins_desc[]); return ;
} static ssize_t forth_drv_read(struct file * file, char __user * userbuf, size_t count, loff_t * off)
{
int ret; if(count != )
{
printk("read error\n");
return -;
} // wait_event_interruptible(button_waitq, ev_press);//将当前进程放入等待队列button_waitq中 ret = copy_to_user(userbuf, &key_val, );
ev_press = ;//按键已经处理可以继续睡眠 if(ret)
{
printk("copy error\n");
return -;
} return ;
} static unsigned int forth_drv_poll(struct file *file, poll_table *wait)
{
unsigned int ret = ;
poll_wait(file, &button_waitq, wait);//将当前进程放到button_waitq列表 if(ev_press)
ret |=POLLIN;//说明有数据被取到了 return ret;
} static struct file_operations forth_drv_ops =
{
.owner = THIS_MODULE,
.open = forth_drv_open,
.read = forth_drv_read,
.release = forth_drv_close,
.poll = forth_drv_poll,
}; static int forth_drv_init(void)
{
forthmajor = register_chrdev(, "buttons", &forth_drv_ops);//注册驱动程序 if(forthmajor < )
printk("failes 1 buttons_drv register\n"); forth_drv_class = class_create(THIS_MODULE, "buttons");//创建类
if(forth_drv_class < )
printk("failes 2 buttons_drv register\n");
forth_drv_class_dev = class_device_create(forth_drv_class, NULL, MKDEV(forthmajor,), NULL,"buttons");//创建设备节点
if(forth_drv_class_dev < )
printk("failes 3 buttons_drv register\n"); gpfcon = ioremap(0x56000050, );//重映射
gpfdat = gpfcon + ;
gpgcon = ioremap(0x56000060, );//重映射
gpgdat = gpgcon + ; printk("register buttons_drv\n");
return ;
} static void forth_drv_exit(void)
{
unregister_chrdev(forthmajor,"buttons"); class_device_unregister(forth_drv_class_dev);
class_destroy(forth_drv_class); iounmap(gpfcon);
iounmap(gpgcon); printk("unregister buttons_drv\n");
} module_init(forth_drv_init);
module_exit(forth_drv_exit); MODULE_LICENSE("GPL");

再回到测试程序,可以看到如果在5s内按键没有按键则也会返回,而不会一直睡眠。

具体程序的编译参考Linux驱动之按键驱动编写(中断方式)

以上就是poll机制的实现过程以及使用方法。

Linux驱动之poll机制的理解与简单使用的更多相关文章

  1. linux字符驱动之poll机制按键驱动

    在上一节中,我们讲解了如何自动创建设备节点,实现一个中断方式的按键驱动.虽然中断式的驱动,效率是蛮高的,但是大家有没有发现,应用程序的死循环里的读函数是一直在读的:在实际的应用场所里,有没有那么一种情 ...

  2. linux IO多路复用POLL机制深入分析

    POLL机制的作用这里就不进行介绍,根据linux man手册,解释为在一个文件描述符上等待某个事件.按照抽象一点的理解,当某个事件被触发(条件被满足),文件描述符变为有状态,那么用户空间可以根据此进 ...

  3. 字符设备驱动笔记——poll机制分析(七)

    poll机制分析 所有的系统调用,基于都可以在它的名字前加上“sys_”前缀,这就是它在内核中对应的函数.比如系统调用open.read.write.poll,与之对应的内核函数为:sys_open. ...

  4. Linux通信之poll机制分析

    poll机制分析 韦东山 2009.12.10 所有的系统调用,基于都可以在它的名字前加上“sys_”前缀,这就是它在内核中对应的函数.比如系统调用open.read.write.poll,与之对应的 ...

  5. 【Linux 驱动】设备驱动程序再理解

    学习设备驱动编程也有一段时间了,也写过了几个驱动程序,因此有对设备驱动程序有了一些新的理解和认识,总结一下.学习设备驱动编程也有一段时间了,也写过了几个驱动程序.因此有对设备驱动程序有了一些新的理解和 ...

  6. linux驱动之poll操作

    POLL操作 1.POLL运行过程: poll是一个系统调用,其内核入口函数为sys_poll,sys_poll差点儿不做不论什么处理直接调用do_sys_poll,do_sys_poll的运行过程能 ...

  7. 3.字符设备驱动------Poll机制

    1.poll情景描述 以之前的按键驱动为例进行说明,用阻塞的方式打开按键驱动文件/dev/buttons,应用程序使用read()函数来读取按键的键值. ) { read(fd, &key_v ...

  8. linux驱动编写之poll机制

    一.概念 1.poll情景描述 以按键驱动为例进行说明,用阻塞的方式打开按键驱动文件/dev/buttons,应用程序使用read()函数来读取按键的键值.这样做的效果是:如果有按键按下了,调用该re ...

  9. 嵌入式Linux驱动学习之路(十二)按键驱动-poll机制

    实现的功能是在读取按键信息的时候,如果没有产生按键,则程序休眠在read函数中,利用poll机制,可以在没有退出的情况下让程序自动退出. 下面的程序就是在读取按键信息的时候,如果5000ms内没有按键 ...

随机推荐

  1. Flex布局教程及属性速查

    一.Flex布局介绍 伸缩盒模型(flexbox)是一个新的盒子模型,意为"弹性布局",用来为盒状模型提供最大的灵活性,主要优化了UI布局.Flexbox的功能主要包手:简单使用一 ...

  2. $modal

    $scope.open = function (size,data) {var modalInstance = $modal.open({ templateUrl: 'myModalContent.h ...

  3. 【转】Android中JNI的使用方法

    Android中JNI的使用方法 首先看一下Android平台的框架图:(网上盗用) 可以看到Android上层的Application和ApplicationFramework都是使用Java编写, ...

  4. T-SQL语句——UNION, EXCEPT, INTERSECT

    UNION,EXCEPT, INTERSECT关键字用于对集合的查询,它们的作用分别为: UNION:合并两个或多个 SELECT 语句的结果集,并把重复结果去除: UNIONALL:合并两个或多个 ...

  5. URL重写是实现PHP伪静态

    URL重写是实现PHP伪静态 应该这样说才是,URL重写是实现PHP伪静态的方式之一, 具体如: http://www.plframe.com/?x=1&y=2&z=3 换成 http ...

  6. 静态查找_Search

    #include <stdio.h> #define MAXSIZE 50 #define OK 1 #define ERROR 0 int F[MAXSIZE];//斐波那契数列 int ...

  7. datatable赋值行

    datatable复制行:DataTable dt = "";  //这里是填充DataTable数据(""中为一个为datatable类型的值,赋值给dt)D ...

  8. 【C语言】在两个数成对出现的数组中找到一个单独的数。

    //在两个数成对出现的数组中找到一个单独的数.比如{1,2,3.3,1,4.2},即找出4 #include <stdio.h> int find(int arr[], int len) ...

  9. CentOS6.5查看一port执行状态

    netstat -nap | grep 22 版权声明:本文博主原创文章,博客,未经同意不得转载.

  10. let 和const与var的不同

    1. let的作用域在代码块中仅限在当前的作用于中 { var str1 = 12; console.log(str1); let str2 = 20; console.log(str2); //20 ...