linux poll机制窥探

已于 2022-05-28 20:51:57 修改
阅读量255 收藏
点赞数
分类专栏： linux 文章标签： linux 驱动开发 运维
于 2022-05-24 15:43:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43300893/article/details/124947038
版权

linux poll机制窥探

内核框架

对于系统调用poll或select，它们对应的内核函数都是sys_poll，文件位于fs/select.c

sys_poll 源码

SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds,
		int, timeout_msecs)
{
	struct timespec64 end_time, *to = NULL;
	int ret;

	if (timeout_msecs >= 0) {
		to = &end_time;
		poll_select_set_timeout(to, timeout_msecs / MSEC_PER_SEC,
			NSEC_PER_MSEC * (timeout_msecs % MSEC_PER_SEC));
	}

	ret = do_sys_poll(ufds, nfds, to);  //我们需要关注的
    ....
	return ret;
}

它对超时参数稍作处理后，直接调用do_sys_poll

static int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds,
		struct timespec64 *end_time)
{
    ....
	poll_initwait(&table);
	fdcount = do_poll(head, &table, end_time);//我们需要关注的
   ....
}

//注册__pollwait函数，在poll_wait里面最终会掉这个函数
void poll_initwait(struct poll_wqueues *pwq)
{
	init_poll_funcptr(&pwq->pt, __pollwait);
	pwq->polling_task = current;
	pwq->triggered = 0;
	pwq->error = 0;
	pwq->table = NULL;
	pwq->inline_index = 0;
}

static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
{
	pt->_qproc = qproc;
	pt->_key   = ~(__poll_t)0; /* all events enabled */
}

static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
{
	if (p && p->_qproc && wait_address)
		p->_qproc(filp, wait_address, p);
}

poll_initwait 函数非常简单，它初始化一个poll_wqueues变量table：
poll_initwait > init_poll_funcptr(&pwq->pt, __pollwait); > pt->qproc = qproc;
即table->pt->qproc = __pollwait，__pollwait将在驱动的poll函数里会用到。poll_wait->__pollwait

do_poll函数位于fs/select.c文件中，代码如下：

static int do_poll(struct poll_list *list, struct poll_wqueues *wait,
		   struct timespec64 *end_time)
{
	poll_table* pt = &wait->pt;
	ktime_t expire, *to = NULL;
	int timed_out = 0, count = 0;
	u64 slack = 0;
	__poll_t busy_flag = net_busy_loop_on() ? POLL_BUSY_LOOP : 0;
	unsigned long busy_start = 0;

	/* Optimise the no-wait case */
	if (end_time && !end_time->tv_sec && !end_time->tv_nsec)     
	{
		pt->_qproc = NULL;
		timed_out = 1;
	}

	if (end_time && !timed_out)
		slack = select_estimate_accuracy(end_time);

	for (;;) {//死循环，注意退出的条件
		struct poll_list *walk;
		bool can_busy_loop = false;

		for (walk = list; walk != NULL; walk = walk->next) {
			struct pollfd * pfd, * pfd_end;

			pfd = walk->entries;
			pfd_end = pfd + walk->len;
			for (; pfd != pfd_end; pfd++) {

				if (do_pollfd(pfd, pt, &can_busy_loop,
					      busy_flag)) {
					count++;
					pt->_qproc = NULL;
					/* found something, stop busy polling */
					busy_flag = 0;
					can_busy_loop = false;
				}
			}
		}
		pt->_qproc = NULL;
		if (!count) {
			count = wait->error;
			if (signal_pending(current))
				count = -ERESTARTNOHAND;
		}
		if (count || timed_out)
			break;   //退出死循环

		if (can_busy_loop && !need_resched()) {
			if (!busy_start) {
				busy_start = busy_loop_current_time();
				continue;
			}
			if (!busy_loop_timeout(busy_start))
				continue;
		}
		busy_flag = 0;
		if (end_time && !to) {
			expire = timespec64_to_ktime(*end_time);
			to = &expire;
		}
         //睡眠当前进程
         //让本进程休眠一段时间，注意：应用程序执行poll调用后，
         //如果count || timed_out的条件不满足，进程就会进入休眠。那么，谁唤醒呢？
         //除了休眠到指定时间被系统唤醒外，还可以被驱动程序唤醒
         //──记住这点，这就是为什么驱动的poll里要调用poll_wait
         //的原因，poll_wait 就是让驱动自己将任务挂在自己创建的等待队列里面，如果有信号来了，就可以调用poll_wake唤醒任务。
		if (!poll_schedule_timeout(wait, TASK_INTERRUPTIBLE, to, slack))
			timed_out = 1;
	}
	return count;
}

do_pollfd 源码如下

static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait)
{
……
   if (file->f_op && file->f_op->poll)
    mask = file->f_op->poll(file, pwait);
……
}

可见，它就是调用我们的驱动程序里注册的poll函数。

驱动程序

驱动程序里与poll相关的地方有两处：一是构造file_operation结构时，要定义自己的poll函数。二是通过poll_wait来调用上面说到的__pollwait函数，pollwait的代码如下：

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);
}

p->qproc就是__pollwait函数，从它的代码可知，它只是把当前进程挂入我们驱动程序里定义的一个队列里而已。它的代码如下：

static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
    poll_table *p)
{
 struct poll_table_entry *entry = poll_get_entry(p);
 if (!entry)
  return;
 get_file(filp);
 entry->filp = filp;
 entry->wait_address = wait_address;
 init_waitqueue_entry(&entry->wait, current);
 add_wait_queue(wait_address, &entry->wait);
}

执行到驱动程序的poll_wait函数时，进程并没有休眠，我们的驱动程序里实现的poll函数是不会引起休眠的。让进程进入休眠，是前面分析的do_sys_poll函数的“poll_schedule_timeout(wait, TASK_INTERRUPTIBLE, to, slack)”。
poll_wait只是把本进程挂入等待队列里面，应用程序调用poll > sys_poll > do_sys_poll > poll_initwait，do_poll > do_pollfd > 我们自己写的poll函数后，再调用poll_schedule_timeout进入休眠。如果我们的驱动程序发现情况就绪，可以把这个队列上挂着的进程唤醒(poll_wake)。可见，poll_wait的作用，只是为了让驱动程序能找到要唤醒的进程。即使不用poll_wait，我们的程序也有机会被唤醒：poll_schedule_timeout(wait, TASK_INTERRUPTIBLE, to, slack)，只是休眠到时间to。

现在来总结一下poll机制：

  1. poll > sys_poll > do_sys_poll > poll_initwait，poll_initwait函数注册一下回调函数__pollwait，它就是我们的驱动程序执行poll_wait时，真正被调用的函数。

  2. 接下来执行file->f_op->poll，即我们驱动程序里自己实现的poll函数
    它会调用poll_wait把自己挂入某个队列，这个队列也是我们的驱动自己定义的；
    它还判断一下设备是否就绪。
    //if (listener->event_count != atomic_read(&idev->event))

  3. 如果设备未就绪，do_sys_poll里会让进程休眠一定时间

  4. 进程被唤醒的条件有2：一是上面说的“一定时间”到了，二是被驱动程序唤醒。驱动程序发现条件就绪时，就把“某个队列”上挂着的进程唤醒，这个队列，就是前面通过poll_wait把本进程挂过去的队列。

  5. 如果驱动程序没有去唤醒进程，那么poll_schedule_timeout(wait, TASK_INTERRUPTIBLE, to, slack)超时后，会重复上面2、3动作，直到应用程序的poll调用传入的时间到达(超时唤醒)。
    //poll_wait 就是让驱动自己将任务挂在自己创建的等待队列里面，如果有信号来了，就可以调用poll_wake唤醒任务，否则就要等到超时唤醒

UIO框架里面的poll实现

首先定义好file_operations


static const struct file_operations uio_fops = {
	.owner		= THIS_MODULE,
	.open		= uio_open,
	.release	= uio_release,
	.read		= uio_read,
	.write		= uio_write,
	.mmap		= uio_mmap,
	.poll		= uio_poll,
	.fasync		= uio_fasync,
	.llseek		= noop_llseek,
};

其中我们关注的是驱动poll的实现。

static __poll_t uio_poll(struct file *filep, poll_table *wait)
{
	struct uio_listener *listener = filep->private_data;
	struct uio_device *idev = listener->dev;
	__poll_t ret = 0;

	mutex_lock(&idev->info_lock);
	if (!idev->info || !idev->info->irq)
		ret = -EIO;
	mutex_unlock(&idev->info_lock);

	if (ret)
		return ret;

	poll_wait(filep, &idev->wait, wait);//将该进程加入驱动的等待队列里面，方便驱动后续唤醒
	if (listener->event_count != atomic_read(&idev->event))
		return EPOLLIN | EPOLLRDNORM;
	return 0;
}

一般唤醒是通过中断来唤醒的。

static irqreturn_t uio_interrupt(int irq, void *dev_id)
{
	struct uio_device *idev = (struct uio_device *)dev_id;
	irqreturn_t ret;

	ret = idev->info->handler(irq, idev->info);  //uio设备自己注册的处理函数
	if (ret == IRQ_HANDLED)
		uio_event_notify(idev->info);//重点在这

	return ret;
}

void uio_event_notify(struct uio_info *info)
{
	struct uio_device *idev = info->uio_dev;

	atomic_inc(&idev->event);  //加加计数变量，然后poll驱动里面就会执行下面的处理，最后系统调用的do_poll函数退出，唤醒我们的进程
		//if (listener->event_count != atomic_read(&idev->event))
		return EPOLLIN | EPOLLRDNORM;
	wake_up_interruptible(&idev->wait);
	kill_fasync(&idev->async_queue, SIGIO, POLL_IN);
}
a珍爱上了a强
关注
专栏目录
Linux poll机制
m0_49328056的博客
03-13 5057
一、在用户空间应用程序向驱动程序请求数据时，有以下几种方式： 1.不管查询，条件不满足的情况下就是死循环，非常耗cpu 2.休眠唤醒的方式，如果条件不满足，应用程序则一直睡眠下去 3.poll机制：如果条件不满足，休眠指定的时间，休眠时间内条件满足唤醒，条件一直不满足时间到达自动唤醒 4.异步通知：应用程序注册信号处理函数函数，驱动程序发信号。类似于QT的信号与槽机制 二、函数 2.1.函数原型 int poll(struct pollfd *fds, nfds_t nfds, int ti
linux poll机制 阻塞,linux poll机制使用(一)
weixin_30500365的博客
05-14 1199
一、poll机制的作用1.poll机制的作用在前面的使用中断的的方式来读取按键值(linux 中断管理(四))。使用这种方式读取按键，如果按键没有按下的时候，应用程序会一直处于睡眠的状态。如果想要即使按键没有按下，在一定的时间后也能返回，要实现这种功能，可以使用poll机制。(select IO复用和epoll也可以实现这种功能,这里只讲poll机制)二、poll机制的应用编程1.应用层函数接口1...
poll机制的总结
uunubt的专栏
10-13 781
②如果在在time_out的时间内发生了中断，在中断处理函数中，就会把中断事件标志置1，然后把进程唤醒，同时得到按键的值，中断处理完成后又会回到for死循环中，再次执行驱动程序的forth_drv_poll()函数，此时由于中断事件标志为1，所以会返回一个非零的mask，进而count++，打破break跳出死循环，然后poll()返回一个非零的ret同时在接下来执行read函数，获得键值之后，将键值打印出来。//上述条件不满足下面开始进入休眠，若有等待的事件发生了，超时或收到信号则唤醒。
Poll 机制的简单分析
u012830148的博客
05-28 6211
参考：韦东山老师视频教程用户空间应用程序向设备驱动请求数据时，一般有以下几种方式：1.不断查询，条件不满足的情况下就是死循环，这种情况下非常耗费CPU。2.休眠唤醒的方式，如果条件不满足，应用程序则一直休眠下去。3.poll机制，如果条件不满足，休眠指定时间，休眠时间内条件满足唤醒进程，条件一直不满足，达到指定时间，则自动唤醒。4,异步通知，应用程序注册信号处理函数，驱动程序发信号。poll在li...
linux驱动唤醒进程,深入理解linux驱动中的poll机制（在韦东山教程和linux驱动开发详解上的总结和补充）...
weixin_28818721的博客
05-04 737
在用户空间中用到的poll()函数其实就是起到一个把当前进程睡眠，通过轮询等待唤醒的作用。好处是在用户态就可以让进程睡眠，而不必在写驱动不同函数时在内核态重复的实现进程的挂起和唤醒。驱动中poll原型：unsigned poll(struct file *file, poll_table *wait)应用中poll原型：int poll(struct pollfd *fds, nfds_t nfd...
linux poll 和 等待队列休眠的关系
月出皎兮。 佼人僚兮。 舒窈纠兮。 劳心悄兮。
03-01 7077
说明：linux版本2.6.37.1 结合相关资料的概括和总结，在此做个记录，有误之处请网友指正，谢谢！ 1.poll机制和等待队列 应用层通过系统调用poll函数进入内核，内核执行相应的sys_poll函数。在sys_poll函数中调用do_sys_poll函数。do_sys_poll函数通过调用poll_initwait 函数初始化poll_wqueues变量table，并
Linux Poll机制
12-16 1689
一、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...
Poll机制实现以及应用实例
最新发布
我的博客
06-06 1030
Poll机制实现以及应用实例
Linux-高级IO之poll、epoll
weixin_45599288的博客
04-01 4966
poll基本知识 poll的优缺点 epoll epoll工作原理 epoll优点 epoll工作方式 简单的epoll LT服务器
Linux_11th_poll机制
weqpo的博客
12-30 387
poll机制： 在读取按键电平状态的时候，查询法是在应用程序的死循环中不断调用read函数去读取键值，这将占用几乎所有的CPU资源。 中断方法解决了在死循环中不断读取按键电平的问题，具体做法是：在read函数中判断，如果没有中断发生，就在read函数中就地休眠，当按键按下或松开时，触发中断，进入中断服务函数，在中断服务函数中读取引脚电平，然后在退出终端服务函数之前唤醒进程，让进
[个人推荐]理解poll_wait
六六哥的博客
09-28 3887
poll_wait()是用在select系统调用中的.  一般你的代码会有一个struct file_operations结构,  其中fop->poll函数指针指向一个你自己的函数,  在这个函数里应该调用poll_wait()  当用户调用select系统调用时,select系统调用会先调用  poll_initwait(&table);  然后调用你的  fop->poll();  从而将c
linux之poll机制（三）
yyyljw的博客
12-11 643
使用场景： 单片机编程中，主程序等待IIC设备一个事件的发生，如果在允许的时间内发生了就返回1（SUCCESS），否则返回0（ERROR）。 解释：主程序等待IIC返回一个回应值，如果回应就代表可以对IIC读写，如果IIC未启动时，是没有响应的，这时候主程序不可能一直等待，所以应该有一个等待超时机制，到时间后如果没有响应就直接返回失败，主程序继续其他后续操作。 对于类似上面的情况，linux是通过poll机制实现超时操作的。 linux在调用poll函数时，如果没有事件发生，则进入休眠状...
Linux内核：poll机制
JansonZhe
09-19 9083
在编写驱动程序的过程当中我们可以使用poll机制来非阻塞的打开我们的设备文件，我们知道，在之前我们编写CC1100的驱动程序以及倒车雷达的驱动程序的时候，在read函数中都有用到过wait_event_interruptible_timeout这个函数，这个函数的主要作用就是采用非阻塞的read，因为每一次我们read函数的时候，都会先判断是否有新的数据可以读，如果没有新的数据就会休眠等待有新的数
使用NDB调试Linux内核的线程切换过程
birdring_0xx0的博客
09-27 814
使用NDB调试Linux内核的线程切换过程
schedule_timeout 函数分析
寒霜落叶YIO的博客
11-16 5980
schedule_timeout 函数功能： 将当前task调度出cpu，并在timeout 1) kernel/time/timer.c signed long __sched schedule_timeout(signed long timeout) { struct process_timer timer; unsigned long expire; switch (timeout) { case MAX_SCHEDUL
记录一下在服务器上复现出来的多进程僵死的排查
weixin_39847103的博客
05-19 822
起因： 表现情况：在跑任务时出现了僵死情况，任务是晚上9点开始跑的，查看log发现在半夜3点多的时候进入了僵死。 接下来按照大佬的教程，用ps auxf查看我们的进程执行到了哪一步： 可以看到是子进程和信号量都还在，但是子进程上属的父进程没有了，应该是被系统杀掉了导致变成了孤儿进程。 因为子进程上属的父进程已经被杀掉了，所以我们无法根据strace -p $pid 来跟踪被杀的父进程。 因此，我们可以cd /proc/22653/，在这里我们可以查看进程状态。cd /proc/之后，你会发.
linux设备驱动 阻塞与非阻塞 I/O、异步通知与异步IO
lxllinux的博客
11-22 626
1、阻塞与非阻塞 I/O 阻塞操作是指在执行设备操作时，若不能获得资源，则挂起进程直到满足可操作的条件后再进行操作。被挂起的进程进入休眠状态，被从调度器的运行队列移走，直到等待的条件被满足。非阻塞操作的进程在不能进行设备操作时，并不挂起，它或者放弃，或者不停地查询，直至可以进行操作为止。        阻塞从字面上听起来似乎意味着低效率，实则不然，如果设备驱动不阻塞，则用户想获取设备资源只能不停...
异步串口 I/O操作 中遇到的一个问题及解决
yinyuanqings的专栏
11-22 695
<br />思路是这样，用CreateFile打开一个串口，然后ReadFile 从串口读取数据， 希望在读取数据后返回，或者如果没有数据读入的话必须在5000毫秒内返回.<br /> <br />API 调用顺序如下：<br /> <br />1。CreateFile <br />2。ReadFile with Overlapped struct.<br />3。WaitForSingleObject(overlap.event, 5000) 等待 Overlapped Event 成为受信状态，或者5秒
linux poll机制
06-04
Linux中的poll机制是一种多路复用I/O模型，可以同时监视多个文件描述符，当其中任意一个文件描述符就绪时就会通知应用程序进行操作。poll机制可以替代早期的select机制，它的优点在于支持的文件描述符数量更大，同时可以避免select中的“文件描述符集合复制”问题，从而提高了效率。使用poll机制需要调用系统函数poll()，该函数会阻塞进程直到有文件描述符就绪或者超时。在poll()函数返回后，可以通过遍历文件描述符数组来确定哪些文件描述符已经就绪，然后进行相应的操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值