poll 源码分析
2.1 数据结构
/*
* Structures and helpers for sys_poll/sys_poll
*/
struct poll_wqueues {
poll_table pt;
struct poll_table_page * table;
int error;
};
/*
* structures and helpers for f_op->poll implementations
*/
typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);
typedef struct poll_table_struct {
poll_queue_proc qproc;
} poll_table;
//poll链表
struct poll_list {
struct poll_list *next;
int len;
struct pollfd entries[0];
};
//pollfd结构
struct pollfd {
int fd; //要监视的文件描述符
short events; //请求要监控的事件
short revents; //实际返回的事件
};
3, epoll源码分析
//poll系统调用入口
// ufds : 用户传入的要监视的pollfd数组首地址
// nfds : 要监控的fd的个数和pollfd的数组的成员个数相等
// timeout : 时间参数
asmlinkage long sys_poll(struct pollfd __user * ufds, unsigned int nfds, long timeout)
{
struct poll_wqueues table;
int fdcount, err;
unsigned int i;
struct poll_list *head;
struct poll_list *walk;
/* Do a sanity check on nfds ... */ //检查要检查的文件描述符的个数
if (nfds > current->files->max_fdset && nfds > OPEN_MAX)
return -EINVAL;
if (timeout) { //处理timeout参数
/* Careful about overflow in the intermediate values */
if ((unsigned long) timeout < MAX_SCHEDULE_TIMEOUT / HZ)
timeout = (unsigned long)(timeout*HZ+999)/1000+1;
else /* Negative or overflow */
timeout = MAX_SCHEDULE_TIMEOUT;
}
//初始化table，为table的qproc设置一个处理函数
poll_initwait(&table);
head = NULL; //初始化队列头
walk = NULL;
i = nfds; //获取监控的fd个数
err = -ENOMEM;
while(i!=0) { //个数大于0
struct poll_list *pp;
//为i个pollfd分配空间，若大于一页内存，则分配一页内存一般是(4096)
pp = kmalloc(sizeof(struct poll_list)+
sizeof(struct pollfd)*
(i>POLLFD_PER_PAGE?POLLFD_PER_PAGE:i),
GFP_KERNEL);
//分配失败
if(pp==NULL)
goto out_fds;
pp->next=NULL;
pp->len = (i>POLLFD_PER_PAGE?POLLFD_PER_PAGE:i);
//若链表头是NULL，这是第一个链表节点，直接把该节点的地址赋给head即可
if (head == NULL)
head = pp;
else
walk->next = pp; //如不是第一个节点，则把该节点插入到最后一个节点之后
walk = pp; //更新walk指针，它始终指向最后一个节点
//把用户的pollfd结构复制到相应节点的entries[i]中。
if (copy_from_user(pp->entries, ufds + nfds-i,
sizeof(struct pollfd)*pp->len)) {
err = -EFAULT;
goto out_fds;
}
i -= pp->len;
}
//以上代码实际上就是建立起一个用户要监视的pollfd链表
// 并把用户传入的参数从用户态复制到内核态的链表中。
fdcount = do_poll(nfds, head, &table, timeout);
/* OK, now copy the revents fields back to user space. */
walk = head;
err = -EFAULT;
while(walk != NULL) { //遍历pollfd链表，并检查每个链表节点中fd的实际返回的事件值
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:
walk = head;
while(walk!=NULL) {
struct poll_list *pp = walk->next;
kfree(walk);
walk = pp;
}
poll_freewait(&table);
return err;
}
//初始化pollwait队列
void __pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *p);
void poll_initwait(struct poll_wqueues *pwq)
{
init_poll_funcptr(&pwq->pt, __pollwait);
pwq->error = 0;
pwq->table = NULL;
}
static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
{
pt->qproc = qproc;
}
//__pollwait()系统调用
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);
if (!new_table) {
p->error = -ENOMEM;
__set_current_state(TASK_RUNNING);
return;
}
new_table->entry = new_table->entries;
new_table->next = table;
p->table = new_table;
table = new_table;
}
/* Add a new entry */
//向等待队列添加一个poll_table_entry实体，并把进程挂起
{
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);
}
}
//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;
if (!timeout)
pt = NULL;
for (;;) { //死循环
struct poll_list *walk;
set_current_state(TASK_INTERRUPTIBLE);
walk = list;
while(walk != NULL) { //遍历链表并调用do_pollfd函数对要检查的pollfd进行检查
do_pollfd( walk->len, walk->entries, &pt, &count);
walk = walk->next;
}
pt = NULL;
if (count || !timeout || signal_pending(current))
break;
count = wait->error;
if (count)
break;
timeout = schedule_timeout(timeout);
}
__set_current_state(TASK_RUNNING);
return count;
}
//do_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;
unsigned int mask;
struct pollfd *fdp;
mask = 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) //调用驱动程序的poll函数检查fd的事件
mask = file->f_op->poll(file, *pwait);
mask &= fdp->events | POLLERR | POLLHUP;
fput(file);
}
if (mask) {
*pwait = NULL;
(*count)++;
}
}
fdp->revents = mask;
}
}
//udp_poll->datagram_poll()...
unsigned int datagram_poll(struct file *file, struct socket *sock,
poll_table *wait)
{
struct sock *sk = sock->sk;
unsigned int mask;
poll_wait(file, sk->sk_sleep, wait); //其实就是调用__poll_wait
mask = 0;
...
...
}
总结：
*poll系统调用的流程如下：
(1) 先注册回调函数__poll_wait；
(2) 再初始化table变量（类型为struct poll_wqueues)；
(3) 拷贝用户传入的struct pollfd（其实主要是fd）；
(4) 轮流调用所有fd对应的poll，该poll调用一般是流程是：把current挂到各个fd对应的设备等待队列上；
(5) 在设备收到一条消息（网络设备）或填写完文件数据（磁盘设备）。
(6) 唤醒设备等待队列上的进程，此时current便被唤醒了。
(7) current醒来后离开sys_poll，并把结果返回给使用者。
*poll的优缺点
优点：不像select，poll对fd没有限制。
缺点：(1) 要把用户传入的fd复制到内核，并对每一个fd分配内存，把这些fd构造成一个链表。
(2) 遍历链表，并对用户传入的每一个fd（不管有没有事件产生），都调用do_pollfd函数。
此两者在fd个数比较小的情况下没事，但一点fd数量巨大，这将会造成poll性能的瓶颈。
附注：内核版本：2.6.11
