POLL机制

于 2024-08-11 12:17:50 发布
阅读量897 收藏 30
点赞数 11
分类专栏： Linux + ARM 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d0203/article/details/141103510
版权

POLL 机制的适用场景

在前面引入中断时，我们曾经举过一个例子： 妈妈怎么知道卧室里小孩醒了？

POLL方式：妈妈要干很多活，但是可以陪小孩睡一会，定个闹钟要浪费点时间，但是可以继续干活。妈妈要么是被小孩吵醒，要么是被闹钟吵醒。

使用休眠-唤醒的方式等待某个事件发生时，有一个缺点： 等待的时间可能很久。我们可以加上一个超时时间，这时就可以使用 poll 机制。

步骤

  1. APP 不知道驱动程序中是否有数据，可以先调用 poll 函数查询一下，poll 函数可以传入超时时间；
  2. APP 进入内核态，调用到驱动程序的 poll 函数，如果有数据则立刻返回；
  3. 如果发现没有数据就休眠一段时间；
  4. 当有数据时，比如按下按键时，驱动程序的中断服务程序被调用，他会记录数据、唤醒APP；
  5. 当超时时间到之后，内核也会唤醒APP；
  6. APP 根据POLL 函数的返回值就可以知道是否有数据，如果有数据就调用 read 得到数据。

使用流程

妈妈进入房间时，会先看小孩醒没醒，闹钟响起之后走出房间之前又会再看小孩醒没醒；

注意： 这里看了小孩两次

POLL 机制也是类似的，流程如下：
在这里插入图片描述
函数执行流程如上图 1 - 8 所示，重点从 3 开始看。假设一开始无按键数据：
③ APP调用 poll 之后，进入内核态；
④ 驱动程序 drv_poll 被调用；
注意： drv_poll要把自己这个线程挂入等待队列wq中；假设不放入队列里，那以后发生中断时，中断服务程序去哪里找到你嘛？ drv_poll 还会判断一下：有没有数据啊？返回这个状态
⑤ 当前没有数据，则会休眠一会；
⑥ 过程中，按下了按键，发生了中断

  • 在中断服务程序里记录了按键值，并且从 wq 中把线程唤醒。
    ⑦ 从休眠中被唤醒，继续执行 for 循环，再次调用 drv_poll
  • drv_poll 返回数据状态
    ⑧ 有数据，那从内核态返回到应用态；
    ⑨ APP 调用 read 函数读取数据。

如果一直没有数据，调用流程也是类似的，重点从③开始看，如下：
③ APP调用poll之后，进入内核态；
④ 导致驱动程序的drv_poll被调用：
注意： drv_poll 要把自己这个线程挂入等待队列 wq 中；假设不放入队列里，那以后发生中断时，中断服务程序去哪里找到你嘛？drv_poll 还会判断一下：有没有数据啊？返回这个状态。
⑤ 假设当前没有数据，则休眠一会；
⑥ 在休眠过程中，一直没有按下了按键，超时时间到：内核把这个线程唤醒；
⑦ 线程从休眠中被唤醒，继续执行 for 循环，再次调用 drv_poll： drv_poll 返回数据状态；
⑧ 如果还是没有数据，但是超时时间到了，那从内核态返回到应用态；
⑨ APP 不能调用 read 函数读数据；

注意几点：

  1. drv_poll 要把线程挂入队列 wq，但是并不是在 drv_poll 中进入休眠，而是在调用 drv_poll 之后休眠。
  2. drv_poll 要返回数据状态
  3. APP 调用一次 poll，有可能会导致 drv_poll 被调用 2 次
  4. 线程被唤醒的原因有 2：中断发生了去队列 wq 中把它唤醒 和 超时时间到了内核把它唤醒
  5. APP 要判断 poll 返回的原因：有数据，还是超时。有数据时再去调用 read函数

驱动编程

使用 poll 机制时，驱动程序的核心就是提供对应的 drv_poll 函数。在drv_poll 函数中要做 2 件事：

第一件事

把当前线程挂入队列 wq：poll_wait

  • APP 调用一次 poll，可能导致 drv_poll 被调用 2 次，但是我们并不需要把当前线程挂入队列 2 次。
  • 可以使用内核的函数 poll_wait 把线程挂入队列，如果线程已经在队列里了，它就不会再次挂入。

第二件事

返回设备状态：
APP 调用 poll 函数时，有可能是查询“有没有数据可以读”： POLLIN，也有可能是查询“你有没有空间给我写数据”： POLLOUT。所以 drv_poll 要返回自己的当前状态： (POLLIN | POLLRDNORM) 或 (POLLOUT | POLLWRNORM)。

  • POLLRDNORM 等同于 POLLIN，为了兼容某些 APP 把它们一起返回。
  • POLLWRNORM 等同于 POLLOUT ，为了兼容某些 APP 把它们一起返回。

APP 调用 poll 后，很有可能会休眠。对应的，在按键驱动的中断服务程序，也要唤醒操作

驱动程序中 poll 的代码如下。（在上一节环形的基础上）

static unsigned int gpio_key_drv_poll(struct file *fp, poll_table * wait)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	poll_wait(fp, &gpio_key_wait, wait);
	return is_key_buf_empty() ? 0 : POLLIN | POLLRDNORM;
}

应用编程

注意： APP 可以调用 poll 或 select 函数，这 2 个函数的作用是一样的。
poll / select 函数可以监测多个文件，可以监测多种事件：

事件类型说明
POLLIN有数据可读
POLLRDNORM等同于 POLLIN
POLLRDBANDPriority band data can be read，有优先级较较高的“ band data”可读, Linux 系统中很少使用这个事件
POLLPRI高优先级数据可读
POLLOUT可以写数据
POLLWRNORM等同于 POLLOUT
POLLWRBANDPriority data may be written
POLLERR发生了错误
POLLHUP挂起
POLLNVAL无效的请求，一般是 fd 未 open

在调用 poll 函数时，要指明：

  1. 你要监测哪一个文件：哪一个 fd
  2. 你想监测这个文件的哪种事件：是 POLLIN、还是 POLLOUT
  3. 最后，在 poll 函数返回时，要判断状态

应用程序代码如下：

struct pollfd fds[1];
int timeout_ms = 5000;
int ret;
fds[0].fd = fd;
fds[0].events = POLLIN;
ret = poll(fds, 1, timeout_ms);
if ((ret == 1) && (fds[0].revents & POLLIN))
{
    read(fd, &val, 4);
    printf("get button : 0x%x\n", val);
}
完整代码

button_test.c


#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <poll.h>

/*
 * ./button_test /dev/100ask_gpio_key
 *
 */
int main(int argc, char **argv)
{
	int fd;
	int val;
	struct pollfd fds[1];
	int timeout_ms = 5000;
	int ret;
	
	/* 1. 判断参数 */
	if (argc != 2) 
	{
		printf("Usage: %s <dev>\n", argv[0]);
		return -1;
	}

	/* 2. 打开文件 */
	fd = open(argv[1], O_RDWR);
	if (fd == -1)
	{
		printf("can not open file %s\n", argv[1]);
		return -1;
	}

	fds[0].fd = fd;
	fds[0].events = POLLIN;
	

	while (1)
	{
		/* 3. 读文件 */
		ret = poll(fds, 1, timeout_ms);
		if ((ret == 1) && (fds[0].revents & POLLIN))
		{
			read(fd, &val, 4);
			printf("get button : 0x%x\n", val);
		}
		else
		{
			printf("timeout\n");
		}
	}
	
	close(fd);
	
	return 0;
}

gpio_key_drv.c

#include <linux/module.h>
#include <linux/poll.h>

#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>


struct gpio_key{
	int gpio;
	struct gpio_desc *gpiod;
	int flag;
	int irq;
} ;

static struct gpio_key *gpio_keys_100ask;

/* 主设备号                                                                 */
static int major = 0;
static struct class *gpio_key_class;

/* 环形缓冲区 */
#define BUF_LEN 128
static int g_keys[BUF_LEN];
static int r, w;

#define NEXT_POS(x) ((x+1) % BUF_LEN)

static int is_key_buf_empty(void)
{
	return (r == w);
}

static int is_key_buf_full(void)
{
	return (r == NEXT_POS(w));
}

static void put_key(int key)
{
	if (!is_key_buf_full())
	{
		g_keys[w] = key;
		w = NEXT_POS(w);
	}
}

static int get_key(void)
{
	int key = 0;
	if (!is_key_buf_empty())
	{
		key = g_keys[r];
		r = NEXT_POS(r);
	}
	return key;
}


static DECLARE_WAIT_QUEUE_HEAD(gpio_key_wait);

/* 实现对应的open/read/write等函数，填入file_operations结构体                   */
static ssize_t gpio_key_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{
	//printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	int err;
	int key;
	
	wait_event_interruptible(gpio_key_wait, !is_key_buf_empty());
	key = get_key();
	err = copy_to_user(buf, &key, 4);
	
	return 4;
}

static unsigned int gpio_key_drv_poll(struct file *fp, poll_table * wait)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	poll_wait(fp, &gpio_key_wait, wait);
	return is_key_buf_empty() ? 0 : POLLIN | POLLRDNORM;
}


/* 定义自己的file_operations结构体                                              */
static struct file_operations gpio_key_drv = {
	.owner	 = THIS_MODULE,
	.read    = gpio_key_drv_read,
	.poll    = gpio_key_drv_poll,
};


static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
	struct gpio_key *gpio_key = dev_id;
	int val;
	int key;
	
	val = gpiod_get_value(gpio_key->gpiod);
	

	printk("key %d %d\n", gpio_key->gpio, val);
	key = (gpio_key->gpio << 8) | val;
	put_key(key);
	wake_up_interruptible(&gpio_key_wait);
	
	return IRQ_HANDLED;
}

/* 1. 从platform_device获得GPIO
 * 2. gpio=>irq
 * 3. request_irq
 */
static int gpio_key_probe(struct platform_device *pdev)
{
	int err;
	struct device_node *node = pdev->dev.of_node;
	int count;
	int i;
	enum of_gpio_flags flag;
		
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

	count = of_gpio_count(node);
	if (!count)
	{
		printk("%s %s line %d, there isn't any gpio available\n", __FILE__, __FUNCTION__, __LINE__);
		return -1;
	}

	gpio_keys_100ask = kzalloc(sizeof(struct gpio_key) * count, GFP_KERNEL);
	for (i = 0; i < count; i++)
	{
		gpio_keys_100ask[i].gpio = of_get_gpio_flags(node, i, &flag);
		if (gpio_keys_100ask[i].gpio < 0)
		{
			printk("%s %s line %d, of_get_gpio_flags fail\n", __FILE__, __FUNCTION__, __LINE__);
			return -1;
		}
		gpio_keys_100ask[i].gpiod = gpio_to_desc(gpio_keys_100ask[i].gpio);
		gpio_keys_100ask[i].flag = flag & OF_GPIO_ACTIVE_LOW;
		gpio_keys_100ask[i].irq  = gpio_to_irq(gpio_keys_100ask[i].gpio);
	}

	for (i = 0; i < count; i++)
	{
		err = request_irq(gpio_keys_100ask[i].irq, gpio_key_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "100ask_gpio_key", &gpio_keys_100ask[i]);
	}

	/* 注册file_operations 	*/
	major = register_chrdev(0, "100ask_gpio_key", &gpio_key_drv);  /* /dev/gpio_key */

	gpio_key_class = class_create(THIS_MODULE, "100ask_gpio_key_class");
	if (IS_ERR(gpio_key_class)) {
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		unregister_chrdev(major, "100ask_gpio_key");
		return PTR_ERR(gpio_key_class);
	}

	device_create(gpio_key_class, NULL, MKDEV(major, 0), NULL, "100ask_gpio_key"); /* /dev/100ask_gpio_key */
        
    return 0;
    
}

static int gpio_key_remove(struct platform_device *pdev)
{
	//int err;
	struct device_node *node = pdev->dev.of_node;
	int count;
	int i;

	device_destroy(gpio_key_class, MKDEV(major, 0));
	class_destroy(gpio_key_class);
	unregister_chrdev(major, "100ask_gpio_key");

	count = of_gpio_count(node);
	for (i = 0; i < count; i++)
	{
		free_irq(gpio_keys_100ask[i].irq, &gpio_keys_100ask[i]);
	}
	kfree(gpio_keys_100ask);
    return 0;
}


static const struct of_device_id ask100_keys[] = {
    { .compatible = "100ask,gpio_key" },
    { },
};

/* 1. 定义platform_driver */
static struct platform_driver gpio_keys_driver = {
    .probe      = gpio_key_probe,
    .remove     = gpio_key_remove,
    .driver     = {
        .name   = "100ask_gpio_key",
        .of_match_table = ask100_keys,
    },
};

/* 2. 在入口函数注册platform_driver */
static int __init gpio_key_init(void)
{
    int err;
    
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	
    err = platform_driver_register(&gpio_keys_driver); 
	
	return err;
}

/* 3. 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数
 *     卸载platform_driver
 */
static void __exit gpio_key_exit(void)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

    platform_driver_unregister(&gpio_keys_driver);
}


/* 7. 其他完善：提供设备信息，自动创建设备节点                                     */

module_init(gpio_key_init);
module_exit(gpio_key_exit);

MODULE_LICENSE("GPL");

Makefile


# 1. 使用不同的开发板内核时, 一定要修改KERN_DIR
# 2. KERN_DIR中的内核要事先配置、编译, 为了能编译内核, 要先设置下列环境变量:
# 2.1 ARCH,          比如: export ARCH=arm64
# 2.2 CROSS_COMPILE, 比如: export CROSS_COMPILE=aarch64-linux-gnu-
# 2.3 PATH,          比如: export PATH=$PATH:/home/book/100ask_roc-rk3399-pc/ToolChain-6.3.1/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin 
# 注意: 不同的开发板不同的编译器上述3个环境变量不一定相同,
#       请参考各开发板的高级用户使用手册

KERN_DIR =  # 板子所用内核源码的目录

all:
	make -C $(KERN_DIR) M=`pwd` modules 
	$(CROSS_COMPILE)gcc -o button_test button_test.c
clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf modules.order  button_test

# 参考内核源码drivers/char/ipmi/Makefile
# 要想把a.c, b.c编译成ab.ko, 可以这样指定:
# ab-y := a.o b.o
# obj-m += ab.o

obj-m += gpio_key_drv.o

编译

在这里插入图片描述

测试

把编译出来的设备树文件拷贝到/boot目录下

在这里插入图片描述
reboot重启
安装驱动，强制安装

insmod -f gpio_key_drv.ko

在这里插入图片描述

执行测试程序

./button_test /dev/100ask_gpio_key

在这里插入图片描述
什么都不做，5秒超时，调用两次drv_poll函数（打印两次）。按下按键后，则会打印数据。
第一次把线程放进wq队列，会调用drv_poll；第二次超时了，再次返回drv_poll中查看状态。

执念、坚持
关注
专栏目录
Linux Poll机制
12-16 1674
一、Poll什么？ Poll某个fd特定的event。 二、event的总类包括？ POLLIN– This bit must be set if the device can be read without blocking. POLLRDNORM– This bit must be set if “normal” data is available for reading. A readable device returns(POLLIN | POLLRDNORM). P...
Linux poll机制
m0_49328056的博客
03-13 5014
一、在用户空间应用程序向驱动程序请求数据时，有以下几种方式： 1.不管查询，条件不满足的情况下就是死循环，非常耗cpu 2.休眠唤醒的方式，如果条件不满足，应用程序则一直睡眠下去 3.poll机制：如果条件不满足，休眠指定的时间，休眠时间内条件满足唤醒，条件一直不满足时间到达自动唤醒 4.异步通知：应用程序注册信号处理函数函数，驱动程序发信号。类似于QT的信号与槽机制 二、函数 2.1.函数原型 int poll(struct pollfd *fds, nfds_t nfds, int ti
poll机制分析
09-08
poll机制分析,poll机制分析,poll机制分析,poll机制分析,poll机制分析,poll机制分析
poll 机制
a drip
07-23 352
poll mechanism1. (user space) poll >> sys_poll > >do_sys_poll >>poll_initwaitfs/select.c文件中 asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds, long timeout_msecs) { ... ret
Poll机制实现以及应用实例
最新发布
我的博客
06-06 1008
Poll机制实现以及应用实例
poll机制
win9
11-29 1166
用中断来实现按键驱动程序里面，如果我们一直没有按键按下触发中断应用程序会一直的在休眠，现在我们想让它隔一段时间就返回一个值要怎么做呢，这就是POLL机制，我们可以用poll机制来实现它，下面来分析一下这个poll机制： 我们知道当我们应用程序open,write..时，驱动程序里面也会有相应的open,write等函数（其实是产生了一个软中断，swi异常处理函数指针被组织成了一个表格，swi
POLL 机制
zmjames2000 Just record
02-19 193
static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p) //驱动中使用的函数 { if (p && wait_address) p->qproc(filp, wait_address, p); //_...
Poll机制
好记性不如烂笔头的专栏
06-17 1013
Server/************************************************************************* > File Name: poll.cpp > Author: > Mail: > Created Time: 2017年06月17日 星期六 14时28分03秒 *******************
POLL机制讲解
FangsTun的博客
11-03 370
POLL机制讲解
Poll 机制的简单分析
ll148305879的博客
06-19 364
Poll 机制的简单分析 用户空间应用程序向设备驱动请求数据时，一般有以下几种方式： 1.不断查询，条件不满足的情况下就是死循环，这种情况下非常耗费CPU。 2.休眠唤醒的方式，如果条件不满足，应用程序则一直休眠下去。 3.poll机制，如果条件不满足，休眠指定时间，休眠时间内条件满足唤醒进程； 如果条件一直不满足，达到指定超时时间后，进程自动唤醒在来判断条件是否满足。 4,异步...
linux poll机制
06-04
Linux中的poll机制是一种多路复用I/O模型，可以同时监视多个文件描述符，当其中任意一个文件描述符就绪时就会通知应用程序进行操作。poll机制可以替代早期的select机制，它的优点在于支持的文件描述符数量更大，同时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值