Linux驱动之poll机制

最新推荐文章于 2024-03-06 14:35:57 发布
最新推荐文章于 2024-03-06 14:35:57 发布
阅读量1.3k 收藏 5
点赞数
分类专栏： Linux内核驱动 文章标签： java 服务器 junit
原文链接：https://blog.csdn.net/qq_36576792/article/details/84321872
版权


 

上一小节写到的中断方式获取按键值时，应用程序需要不停的查询，占用CPU资源太多，现在改用poll机制实现相同的按键效果。
1. poll机制流程

    当应用程序调用poll函数的时候（比如：poll(fds,1,5000)，fds是定义的一个poll类型的结构体），poll是一个系统调用，会调用到内核入口函数sys_poll(可在内核中找到该函数)，该函数最终会调用do_poll函数，do_poll函数中有一个死循环，在里面又会利用do_pollfd()函数去调用驱动中file_operations里的.poll函数。do_poll函数流程代码如下：

    do_poll(...)
    {
        for (;;)
        {
            set_current_state(TASK_INTERRUPTIBLE);    //设置当前任务状态为TASK_INTERRUPTIBLE
            ...
            for()
            {
                if(do_pollfd(pfd, pt))  //会调用到内核里file_operations里的.poll函数
                  {
                      count++;
                    pt = NULL;
                  }
            }
            ...
            if(count || !*timeout || signal_pending(current))
                break;
            ...
            __timeout = *timeout;
            *timeout = 0;
            ...
            __timeout= schedule_timeout(__timeout); // 休眠时间从应用程序传入
            ...
            *timeout += __timeout;
            ...
        }
        __set_current_state(TASK_RUNNING);    //设置当前任务状态为TASK_INTERRUPTIBLE
        return count;
    }

   当进入do_poll()死循环函数时,首先设置当前进程为TASK_INTERRUPTIBLE状态（该状态下的进程如果休眠的话可以被信号和wake_up()唤醒），然后执行到第一个if()语句do_pollfd(pfd, pt)，里面实际调用到对应驱动设备里file_operations里的.poll函数，该函数又会调用poll_wait()函数将该进程加入休眠队列（此时没有进入休眠）。
    驱动程序里的poll函数此时应该返回给if()函数为0，不执行if()语句里的内容，继续往下执行，第二个if()的3个判断条件都不满足所以也不执行break，最后调用schedule_timeout()这个休眠函数，进入休眠。
    接下来可能有两种情况：
    (1) 超时退出休眠
    程序调用schedule_timeout()进行休眠的时间到了，schedule_timeout()返回0，重新开始死循环，跑到第二个if()语句时满足判断条件*timeout为0，执行break退出死循环。调用poll系统调用的的应用程序继续往下执行。
    (2) 被wake_up()唤醒休眠
    在schedule_timeout()休眠时间没到时被wake_up()唤醒，此时重新执行for死循环，当循环到第一个if()语句时，do_pollfd(pfd, pt)函数（也就是驱动中file_operations里的.poll函数）如果返回非0值，满足条件执行count++，当执行到下一个if()语句也就满足条件执行break退出死循环。调用poll系统调用的的应用程序继续往下执行。

    因此，我们还知道应用程序调用poll有两种返回值，返回的count为1时表示对应驱动设备里file_operations里的.poll函数返回非0值，返回值为0时表示count并没有自增而是超时时间到了才退出死循环的）。当驱动程序没写.poll函数时，应用程序也能调用系统调用poll函数，此时只充当简单的延时作用。
2. 编写代码

驱动程序poll_drv.c完整代码如下：

    #include <linux/module.h>
    #include <linux/kernel.h>
    #include <linux/fs.h>
    #include <linux/init.h>
    #include <linux/delay.h>
    #include <linux/irq.h>
    #include <asm/uaccess.h>
    #include <asm/irq.h>
    #include <asm/io.h>
    #include <asm/arch/regs-gpio.h>
    #include <asm/hardware.h>
    #include <linux/poll.h>
    #include <linux/cdev.h>
     
    int major;
    static struct cdev button_cdev;
    static struct class *button_class;
     
    volatile unsigned long *gpfcon;
    volatile unsigned long *gpfdat;
     
    volatile unsigned long *gpgcon;
    volatile unsigned long *gpgdat;
     
    static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
     
    /* 中断事件标志, 中断服务程序将它置1，forth_drv_read将它清0 */
    static volatile int ev_press = 0;
     
    struct pin_desc{
        unsigned int pin;
        unsigned int key_val;
    };
     
    /* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
    /* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
    static unsigned char key_val;
     
    struct pin_desc pins_desc[4] = {
        {S3C2410_GPF0, 0x01},
        {S3C2410_GPF2, 0x02},
        {S3C2410_GPG3, 0x03},
        {S3C2410_GPG11, 0x04},
    };
     
    /*
      * 确定按键值
      */
    static irqreturn_t buttons_irq(int irq, void *dev_id)
    {
        struct pin_desc * pindesc = (struct pin_desc *)dev_id;
        unsigned int pinval;
        
        pinval = s3c2410_gpio_getpin(pindesc->pin);
     
        if (pinval)
        {
            /* 松开 */
            key_val = 0x80 | pindesc->key_val;
        }
        else
        {
            /* 按下 */
            key_val = pindesc->key_val;
        }
     
        ev_press = 1;                              /* 表示中断发生了 */
        wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
        
        return IRQ_RETVAL(IRQ_HANDLED);
    }
     
    static int button_open(struct inode *inode, struct file *file)
    {
        /* 配置GPF0,2为输入引脚 */
        /* 配置GPG3,11为输入引脚 */
        request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
        request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
        request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
        request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    
     
        return 0;
    }
     
    ssize_t button_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
    {
        int result;
        if (size != 1)
            return -EINVAL;
     
        /* 如果没有按键动作, 休眠 */
        wait_event_interruptible(button_waitq, ev_press);
     
        /* 如果有按键动作, 返回键值 */
        result=copy_to_user(buf, &key_val, 1);
        ev_press = 0;
        
        return result;
    }
     
    int button_close(struct inode *inode, struct file *file)
    {
        free_irq(IRQ_EINT0, &pins_desc[0]);
        free_irq(IRQ_EINT2, &pins_desc[1]);
        free_irq(IRQ_EINT11, &pins_desc[2]);
        free_irq(IRQ_EINT19, &pins_desc[3]);
        return 0;
    }
     
    static unsigned button_poll(struct file *file, poll_table *wait)
    {
        unsigned int mask = 0;
        poll_wait(file, &button_waitq, wait); // 不会立即休眠
     
        if (ev_press)
            mask |= POLLIN | POLLRDNORM;
     
        return mask;
    }
     
    static struct file_operations button_fops = {
        .owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
        .open    =  button_open,     
        .read     =    button_read,       
        .release =  button_close,
        .poll    =  button_poll,
    };
     
    static int button_init(void)
    {
        int result;
        dev_t devid = MKDEV(major, 0);    //从主设备号major，次设备号0得到dev_t类型
        if (major)
        {
            result=register_chrdev_region(devid, 1, "button");    //注册字符设备
        }
        else
        {
            result=alloc_chrdev_region(&devid, 0, 1, "button");    //注册字符设备
            major = MAJOR(devid);        //从dev_t类型得到主设备
        }
        if(result<0)
            return result;
        
        cdev_init(&button_cdev, &button_fops);
        cdev_add(&button_cdev, devid, 1);
     
        button_class = class_create(THIS_MODULE, "button_drv");
     
        class_device_create(button_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */
     
        gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
        gpfdat = gpfcon + 1;
     
        gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
        gpgdat = gpgcon + 1;
     
        return 0;
    }
     
    static void button_exit(void)
    {
        class_device_destroy(button_class, MKDEV(major, 0));
        class_destroy(button_class);
        cdev_del(&button_cdev);
        unregister_chrdev_region(MKDEV(major, 0), 1);
        
        iounmap(gpfcon);
        iounmap(gpgcon);
        return 0;
    }
     
    module_init(button_init);
    module_exit(button_exit);
    MODULE_LICENSE("GPL");
     

应用程序poll_test.c完整代码如下：

     
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <stdio.h>
    #include <poll.h>
     
    int main(int argc, char **argv)
    {
        int fd;
        unsigned char key_val;
        int ret;
     
        struct pollfd fds[1];
        
        fd = open("/dev/buttons", O_RDWR);
        if (fd < 0)
        {
            printf("can't open!\n");
        }
     
        fds[0].fd     = fd;
        fds[0].events = POLLIN;
        while (1)
        {
            ret = poll(fds, 1, 5000);
            if (ret == 0)
            {
                printf("time out\n");
            }
            else
            {
                read(fd, &key_val, 1);
                printf("key_val = 0x%x\n", key_val);
            }
        }
        
        return 0;
    }
     

Makefile如下：

    KERN_DIR = /work/system/linux-2.6.22.6    //内核目录
     
    all:
        make -C $(KERN_DIR) M=`pwd` modules
     
    clean:
        make -C $(KERN_DIR) M=`pwd` modules clean
        rm -rf modules.order
     
    obj-m    += poll_drv.o

3. 测试

内核：linux-2.6.22.6
编译器：arm-linux-gcc-3.4.5
环境：ubuntu9.10

将button_drv.c、button_test.c、Makefile三个文件放入网络文件系统内，在ubuntu该目录下执行：
    make
    arm-linux-gcc -o poll_test poll_test.c
在挂载了网络文件系统的开发板上进入相同目录，执行“ls”查看：

装载驱动：
    insmod poll_drv.ko
运行测试程序：
    ./poll_test
按下开发板的4个按键，结果如下：

长时间未操作，会打印time_out.
4. 程序说明

    当执行应用程序时，首先打开/dev/buttons设备，接着进入死循环调用poll(fds, 1, 5000)（第三个参数为休眠时间5秒），系统调用sys_poll最后调用到do_poll函数（死循环函数）里陷入休眠（休眠前先执行了一次驱动里的button_poll函数），当有按键按下时，调用wake_up_interruptible()唤醒休眠，重新循环执行do_poll函数第一个if()函数的判断语句，此时button_poll函数返回非0值，执行count++,再往下执行第二个if()语句break退出循环（即退出应用程序里的poll(fds, 1, 5000)），此时再将键值读出来。当5秒内没有操作按键时，也会退出poll(fds, 1, 5000)，打印time_out。
5. 知识点
poll相关函数

    与.write、.read、.open等函数一样，需要在file_operations里面填充.poll    =  button_poll,，在button_poll函数里面需要调用poll_wait，函数原型如下：

static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p);

参数：
filp：设备文件信息的 struct file 结构体的指针参数。
wait_address：等待队列头。
p：追加到设备驱动上的 poll_table结构体指针参数。
    调用完该函数时，进程并没有立即进入休眠，只是将进程加入wait_address队列。
PS:wake_up的参数就是想要唤醒的队列，这里就是poll_wait传入的队列。
————————————————
版权声明：本文为CSDN博主「墨、白」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_36576792/article/details/84321872

大吉机器人
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux 驱动
11-22
Linux 的 进程间同步异步的程序，互斥锁，信号量，完成量，poll 机制
Linux驱动入门（六）poll机制实现按键驱动_补充
qq_43214726的博客
05-05 172
中的poll实现标准输入阻塞的代码，下面是详细解释。请说明这一段C语言代码的作用。
Linux高级字符设备：Poll操作
m0_74282605的博客
06-27 1465
在用户程序中，select()和poll()也是与设备阻塞与非阻塞访问息息相关的，使用非阻塞I/O的应用程序通常会使用select和poll系统调用查询是否可对设备进行无阻塞的访问。（1）对可能引起设备文件状态变化的等待队列调用poll_wait()函数，将对应等待队列添加到poll_table中；2)如果当前不可读写，则阻塞进程，并等待驱动程序唤醒，重新调用poll函数，或超时返回。2、核心层调用sys_select() ------> do_select()（1）将要监控的文件添加到文件描述符集；
linux poll/poll_wqueues/wait_queue_head_t 梳理
最新发布
yyymmmmyyy的博客
03-06 824
poll结构体poll_wqueues等 和 等待队列链表wait_queue_head 联系
linux poll 作用,Linux中poll机制的理解
weixin_29866423的博客
05-13 1695
首先分析下应用程序的执行过程：int main(int argc, char **argv){int fd;unsigned char key_val;int ret;struct pollfd fds[1];fd = open("/dev/buttons", O_RDWR);if (fd < 0){printf("can't open!");}fds[0].fd = fd;fds[...
LINUX下poll函数用法
A7SS5的博客
06-09 4227
LINUX下poll函数用法 文章目录LINUX下poll函数用法一、函数介绍二、使用步骤1.引入库2.读入数据总结 一、函数介绍 int poll(struct pollfd *fds, nfds_t nfds, int timeout); 第一个参数为一个结构体数组，它存储需要监听的文件描述符和需要监听的事件。 结构体定义如下 struct pollfd { 　　　　　　　int fd; /* 待监听的文件描述符*/ 　　　　　　　short events;
Linux驱动poll机制_图解
homelook的博客
04-25 181
轮询并不是真的在一直消耗CPU去查询，而是如果没有数据，则会休眠，有数据到来的时候，就会唤醒线程。select 函数能够监视的文件描述符数量有最大的限制，一般为 1024。poll 函数没有最大文件描述符限制。
简单poll机制
03-29
系统调用poll,应的内核函数都是sys_poll,本文档主要是Linux下基于fs2410的poll按键驱动程序
Embedfire-imx6#embed_linux_tutorial_ppt#POLL机制基本概念1
07-25
POLL机制基本概念应用层poll()函数异步阻塞型IO同步阻塞：阻塞在一个文件的读写操作上(read\write)，自己设备驱动唤醒自己异步阻塞：阻塞在多个文
linux epoll机制详解
01-09
在linux 没有实现epoll事件驱动机制之前，我们一般选择用select或者poll等IO多路复用的方法来实现并发服务程序。在linux新的内核中，有了一种替换它的机制，就是epoll。 select()和poll() IO多路复用模型 select的...
浅谈Linux poll机制
weixin_43389824的博客
05-12 2932
poll是Linux的事件轮询机制函数，每个进程都可以管理一个`pollfd`队列，由poll函数进行事件注册和查询。
Linux poll机制
m0_49328056的博客
03-13 4666
一、在用户空间应用程序向驱动程序请求数据时，有以下几种方式： 1.不管查询，条件不满足的情况下就是死循环，非常耗cpu 2.休眠唤醒的方式，如果条件不满足，应用程序则一直睡眠下去 3.poll机制：如果条件不满足，休眠指定的时间，休眠时间内条件满足唤醒，条件一直不满足时间到达自动唤醒 4.异步通知：应用程序注册信号处理函数函数，驱动程序发信号。类似于QT的信号与槽机制 二、函数 2.1.函数原型 int poll(struct pollfd *fds, nfds_t nfds, int ti
Linux的poll机制
gzxb1995的博客
11-13 3061
目录前言1 应用层使用poll1.1 poll的原型1.2 使用示例2 驱动怎么支持poll2.1 字符设备驱动3 一些更深入的分析3.1 从系统调用poll到驱动的xxx_poll3.1.1 sys_poll3.1.2 do_sys_poll3.1.3 do_poll3.1.4 do_pollfd3.1.5 vfs_poll3.1.6 总结3.2 poll_wait做了什么4 select和po...
字符设备驱动之poll机制
qq_42230338的博客
01-26 1273
注：代码都有完整的注释，方便阅读 开发环境： ubuntu18.04 平台： JZ2440 kernel: Linux-3.4.2 交叉编译工具： arm-linux-gcc-4.4.3 驱动程序如下 #include <linux/module.h> #include <linux/kernel.h> #include <linux/fs.h> #include <linux/init.h> #include <linux/dela
【Linux】多路IO复用技术②——poll详解&如何使用poll模型实现简易的一对多服务器（附图解与代码实现）
m0_53133879的博客
11-04 897
​一个进程默认打开的最大文件描述符个数就是1024，我们可以通过ulimit -a命令在终端下查看，如下图所示 所以，当我们在poll函数中的最大监听数那个位置，填入比1024更大的数值的话，系统就会报错，警告Invalid argument——无效的参数 想要填入比1024更大的数值，我们就需要去修改默认的文件描述符数量，由于每个系统，甚至每个版本改动文件描述符数量的操作方式不一定一样，所以这里就不多作介绍了，感兴趣的同学可以去查一下对应自己系统、对应自己版本的修改方式
高级字符驱动程序操作(poll机制)
cjsycyl的专栏
03-10 3982
http://blog.chinaunix.net/uid-29339876-id-4070572.html         阻塞与非阻塞访问是I/O 操作的两种不同模式，前者在I/O 操作暂时不可进行时会让进程睡眠，后者则不然。(可参考上一篇阻塞型I/O示例)     在设备驱动中阻塞I/O 一般基于等待队列来实现，等待队列可用于同步驱动中事件发生的先后顺序。使用非阻塞I/O 的应用程序也
Linux内核poll机制分析
Bin_Watson的博客
05-07 603
本篇主要是进行poll内核实现，调用流程的分析。 应用程序调用poll()后，首先会进入内核的sys_poll()函数 asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds, long timeout_msecs) 这个函数主要完成两个部分，第一部是将应用程序传递下来的时间（poll的第三个参数timespec），从毫秒单位转为节拍单位。 s64 timeout_jiffies; if (timeout
Linux驱动入门（六）poll机制实现按键驱动
JT同学的博客
08-22 1925
Linux驱动入门系列 Linux驱动入门（一）字符设备驱动基础 Linux驱动入门（二）操作硬件 Linux驱动入门（三）Led驱动 Linux驱动入门（四）非阻塞方式实现按键驱动 Linux驱动入门（五）阻塞方式实现按键驱动 Linux驱动入门（六）poll机制实现按键驱动 Linux驱动入门（七）使用定时器消除按键抖动 Linux驱动入门（六）poll机制实现按键驱动 文章目录Linux驱动...
linux系统应用中select函数与poll函数详解
嵌入式技术开发
04-30 2145
select() 和 poll() 系统调用的本质一样，poll() 的机制与 select() 类似，与 select() 在本质上没有多大差别，管理多个描述符也是进行轮询，根据描述符的状态进行处理，但是 poll() 没有最大文件描述符数量的限制（但是数量过大后性能也是会下降）。poll() 和 select() 同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。= 0 等待指定的时间。
linux驱动中的poll机制
06-28
### 回答1： poll机制是Linux驱动中一种用于实现I/O多路复用的机制。在使用poll机制时，驱动程序可以在多个文件描述符上同时等待可读、可写或异常事件的发生，从而避免了在相应的文件描述符上使用阻塞IO时CPU周期的浪费。poll机制的主要思路是向内核注册多个文件描述符，内核会将这些文件描述符上的I/O事件传递给用户程序，用户程序能够根据得到的事件类型继续执行下去。 ### 回答2： poll机制是Linux驱动程序中实现异步输入输出操作的一种方法，通过这种机制，驱动程序可以将不同的设备进行组合，从而实现对这些设备进行统一的轮询操作。 在使用poll机制时，驱动程序需要提供一个poll方法，在该方法中，通过向用户空间返回一个特殊的文件描述符来表示设备状态的变化，然后用户空间通过读取这个描述符来判断设备是否有数据到达。如果有数据到达，用户空间再调用相应的读取方法来读取这些数据，从而实现异步读写。 在实现poll机制时，驱动程序通常需要调用内核提供的一些API接口，如file_operations结构体中的poll方法、wait_queue_head_t结构体、poll_table结构体等。 在使用poll机制时，用户空间可以通过调用poll函数来注册设备文件，并设置等待事件。当设备的状态改变时，内核会将读取操作挂起，并返回一个特殊的文件描述符。此时，用户空间可以通过调用相应的读取函数来读取数据，在读取完毕后，再次通过poll函数注册设备文件，等待下一次事件处理。 总之，poll机制可以帮助驱动程序实现异步输入输出操作，同时也可以帮助应用程序进行事件处理，提高了Linux的应用程序的可靠性和效率。 ### 回答3： poll机制是Linux内核提供的多路复用机制之一，它使得一个进程可以监视多个文件描述符上的读写情况。在进程需要同时监听多个文件描述符的读写情况时，若采用传统的阻塞式I/O方式，就需要使用多个线程或进程来处理，这种方式会导致系统资源的浪费。因此，poll机制的使用，避免了上述情况发生。 poll机制最常用于网络编程中。在一个服务器程序中，可能需要同时监听多个客户端的连接请求。使用poll机制可以将这些客户端的连接描述符放入一个pollfd数组中，同时对这个数组进行监听，以便及时处理。 poll的基本原理是：进程调用poll系统调用时，内核会挂起该进程，直到poll所监听的文件描述符中有读写事件发生时，内核会唤醒进程，通过返回值告知进程哪些文件描述符发生了事件，并将该事件信息写入对应的pollfd结构体中。这样，进程就可以根据返回的信息对文件描述符进行相应的操作。 poll机制存在以下优点： 1.单个进程可以同时监视多个文件描述符的读写情况，可以更好的利用CPU资源。 2.和select相比，poll没有描述符数量限制，select有FD_SETSIZE的限制。 3.poll在内核中将打开文件描述符的等待队列挂起，直到设备就绪，因此在多处理器系统中poll的性能要优于select。 4.使用poll不需要重新初始化文件描述符，不需要进行文件描述符拷贝操作。这使得poll的使用比较方便。 总之，poll机制是Linux系统中非常重要的一个多路复用机制，它极大地提高了系统的效率和可用性。在进行网络编程时，我们常常需要使用poll机制来提高代码的性能和实用性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值