poll源码剖析

    民意调查系统调用，是在指定时间内轮询一定数量的文件描述符，以测试是否有就绪者。

民意调查系统调用原型：

#include <poll.h>
int poll（struct follfd * fds，nfds_t nfds，int timeout）;

· fds参数是一个pollfd结构类型的数组，指定所有感兴趣的文件描述符上发生的可读，可写和异常等事件。

· nfds参数指定被监听事件集合fds的大小。

    typedef unsigned long int nfds_t;

· timeout参数指定poll的超时值，单位是毫秒。

  当超时为-1时，轮询调用将一直阻塞，直到某个事件发生;当超时为0时，轮询调用立即返回。

基本数据结构

一个pollfd结构类型的数组，指定所有感兴趣的文件描述符上发生的可读，可写和异常等事件。

FD是文件描述符;事件是注册的事件，即监听FD上的事件; revents中是指实际发生的事情，由内核填充。

struct pollfd {
	int fd;
	短时间事件;
	短暂的启示;
};

poll_wqueues：

struct poll_wqueues {
	poll_table pt;
	struct poll_table_page * table;
	int错误;
};

poll_wqueues：

struct poll_wqueues {
	poll_table pt;
	struct poll_table_page * table;
	int错误;
};

poll_table_entry：

struct poll_table_entry {
	结构文件* filp;
	wait_queue_t等待; / *等待队列* /
	wait_queue_head_t * wait_address;
};

poll_list：

struct poll_list {
	struct poll_list * next;
	int len;
	struct pollfd entries [0];
};

基本结构关系：

民意调查系统调用原理：

    先注册回调函数__poll_wait，再初始化table variable（类型为struct poll_wqueues）;拷贝用户传入的struct pollfd;

    轮流调用所有FD对应的轮询（把电流挂到每个FD对应的设备等待队列上）。在设备收到一条消息或填写完文件数据（磁盘设备）后，会唤醒设备等待队列上的进程，这时电流便被唤醒了。

    当前唤醒后离开sys_poll。

（主要基于内核源代码2.6.9版本，在FD \ select.c中）

sys_poll

asmlinkage long sys_poll（struct pollfd __user * ufds，unsigned int nfds，long timeout）
{
	struct poll_wqueues表;
 	int fdcount，err;
 	unsigned int i;
	struct poll_list * head;
 	struct poll_list * walk;

	/ *对nfds进行健全性检查... OPEN_MAX = 256 * /
	如果（nfds> current-> files-> max_fdset && nfds> OPEN_MAX）
		返回-EINVAL;

	如果（超时）{
		/ *小心中间值溢出* /
		如果（（unsigned long）timeout <MAX_SCHEDULE_TIMEOUT / HZ）
			timeout =（unsigned long）（timeout * HZ + 999）/ 1000 + 1;
		其他/ *负或溢出* /
			timeout = MAX_SCHEDULE_TIMEOUT;
	}

	poll_initwait（表）;

	head = NULL;
	walk = NULL;
	我= nfds;
	err = -ENOMEM;
	while（i！= 0）{
		struct poll_list * pp;
		pp = kmalloc（sizeof（struct poll_list）+
				sizeof（struct pollfd）*
				（？I> POLLFD_PER_PAGE POLLFD_PER_PAGE：i）中，
					GFP_KERNEL）;
		如果（PP == NULL）
			goto out_fds;
		PP->下一= NULL;
		pp-> len =（i> POLLFD_PER_PAGE？POLLFD_PER_PAGE：i）;
		如果（head == NULL）
			head = pp;
		其他
			walk-> next = pp;

		walk = pp;
		如果（copy_from_user（pp-> entries，ufds + nfds-i， 
				sizeof（struct pollfd）* pp-> len））{
			err = -EFAULT;
			goto out_fds;
		}
		i  -  = pp-> len;
	}
	fdcount = do_poll（nfds，head，＆table，timeout）;

	/ *好了，现在将revents字段复制回用户空间。* /
	走=头;
	err = -EFAULT;
	while（walk！= NULL）{
		struct pollfd * fds = walk-> entries;
		int j;

		for（j = 0; j <walk-> len; j ++，ufds ++）{
			if（__ put_user（fds [j] .revents，＆ufds-> revents））
				goto out_fds;
		}
		walk = walk-> next;
  	}
	err = fdcount;
	if（！fdcount && signal_pending（current））
		err = -EINTR;
out_fds：
	走=头;
	while（walk！= NULL）{
		struct poll_list * pp = walk-> next;
		kfree（步行）;
		walk = pp;
	}
	poll_freewait（表）;
	返回错误;
}

   （1）poll_initwait（）

void poll_initwait（struct poll_wqueues * pwq）
{
	init_poll_funcptr（＆pwq-> pt，__pollwait）;
	pwq-> error = 0;
	pwq-> table = NULL;
}

注册回调函数__pollwait，

void __pollwait（struct file * filp，wait_queue_head_t * wait_address，poll_table * p）;

（2）调用copy_from_user（）

    这里的循环中，建立链表，然后调用copy_from_user将文件描述符从用户空间拷贝到内核空间。也就是把用户态的struct pollfd拷进进这些条目中。通常用户程序的poll调用就监控几个fd，所以上面这个链表通常也就只需要一个节点，即操作系统的一页。

但是，当用户传入的fd很多时，由于poll系统调用每次要把所有的struct pollfd拷进进内核，所以参数传递和页分配此时就成了poll系统调用的性能瓶颈。

/ **
 *从用户空间复制任意大小的块。
 * /
无符号长整数
copy_from_user（void * to，const void __user * from，unsigned long n）
{
	might_sleep（）;
	BUG_ON（（long）n <0）;
	if（access_ok（VERIFY_READ，from，n））
		n = __copy_from_user（to，from，n）;
	其他
		memset（to，0，n）;
	返回n;
}

（3）do_poll（）

static int do_poll（unsigned int nfds，struct poll_list * list，
			struct poll_wqueues * wait，long timeout）
{
	int count = 0;
	poll_table * pt =＆wait-> pt;

	如果（！超时）
		pt = NULL;
 
	for（;;）{
		struct poll_list * walk;
		set_current_state（TASK_INTERRUPTIBLE）;
		walk = list;
		while（walk！= NULL）{
			do_pollfd（walk-> len，walk-> entries，＆pt，＆count）;
			walk = walk-> next;
		}
		pt = NULL;
		if（count ||！timeout || signal_pending（current））
			打破;
		count = wait-> error;
		如果（计数）
			打破;
		timeout = schedule_timeout（timeout）;
	}
	__set_current_state（TASK_RUNNING）;
	返回计数;
}

在对循环中，直到计数大于0才跳出循环。而数主要是依靠do_pollfd函数处理。

而当用户传入的FD很多时（比如1000个），对do_pollfd就会调用很多次，调查效率出现瓶颈。

set_current _STATE和signal_pending函数

    保障了当用户程序在调用调查后挂起时，发信号可以让程序迅速退出民调调用，而通常的系统调用是不会被信号打断的。

do_pollfd（）

#define POLLFD_PER_PAGE（（PAGE_SIZE-sizeof（struct poll_list））/ sizeof（struct pollfd））

static void do_pollfd（unsigned int num，struct pollfd * fdpage，
	poll_table ** pwait，int * count）
{
	int i;

	for（i = 0; i <num; i ++）{
		int fd;
		无符号整型掩码;
		struct pollfd * fdp;

		掩码= 0;
		fdp = fdpage + i;
		fd = fdp-> fd;
		if（fd> = 0）{
			struct file * file = fget（fd）;
			mask = POLLNVAL;
			if（file！= NULL）{
				mask = DEFAULT_POLLMASK;
				if（file-> f_op && file-> f_op-> poll）
					mask = file-> f_op-> poll（file，* pwait）;
				mask＆= fdp-> events | POLLERR | POLLHUP;
				fput（文件）;
			}
			如果（掩码）{
				* pwait = NULL;
				（*计数）++;
			}
		}
		fdp-> revents = mask;
	}
}

    如果FD对应的是某个插座，do_pollfd调用的就是网络设备驱动实现的轮询;

    如果FD对应的是某个EXT3文件系统的一个打开文件，那么do_pollfd调用的就是EXT3文件系统驱动实现的民意调查。

这个文件- > f_op->调查的英文设备驱动程序实现的。

而设备驱动程序的标准实现是：

（1）调用poll_wait，即以设备自己的等待队列为参数（通常设备都有自己的等待队列）

（2）调用struct poll_talbe的回调函数。

__pollwait

    回调函数__pollwait的作用是创建一个poll_table_entry数据结构（一次__poll_wait即一次设备poll调用只创建一个poll_table_entry），并通过struct poll_table_entry的wait成员，把currrent挂在设备的等待队列上，此处的等待队列是wait_address，对应tcp_poll中的SK-Ⅱ> sk_sleep。

void __pollwait（struct file * filp，wait_queue_head_t * wait_address，poll_table * _p）
{
	struct poll_wqueues * p = container_of（_p，struct poll_wqueues，pt）;
	struct poll_table_page * table = p-> table;

	if（！table || POLL_TABLE_FULL（table））{
		struct poll_table_page * new_table;

		new_table =（struct poll_table_page *）__get_free_page（GFP_KERNEL）;
		如果（！new_table）{
			p-> error = -ENOMEM;
			__set_current_state（TASK_RUNNING）;
			返回;
		}
		new_table-> entry = new_table-> entries;
		new_table-> next = table;
		p-> table = new_table;
		table = new_table;
	}

	/ *添加一个新条目* /

		struct poll_table_entry * entry = table-> entry;
		table-> entry = entry + 1;
		get_file（的filp）;
		entry-> filp = filp;
		entry-> wait_address = wait_address;
		init_waitqueue_entry（＆entry-> wait，current）;
		add_wait_queue（wait_address，＆entry-> wait）;
}

tcp_poll（）

unsigned int tcp_poll（struct file *文件，struct socket * sock，poll_table * wait）

{

    无符号整型掩码;

    struct sock * sk = sock-> sk;

    struct tcp_sock * tp = tcp_sk（sk）;

    poll_wait（file，sk-> sk_sleep，wait）;

    ..... //省略判断状态，返回状态值

}