poll分析

转自： http://hi.baidu.com/rwen2012/blog/item/3140db827b42f3bd6c8119df.html struct pollfd {     int fd;     //当前描述符     short events;     //进程关心的该描述符的事件     short revents;    //返回的事件 }; asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,             long timeout_msecs) {     s64 timeout_jiffies; //超时时间处理     if (timeout_msecs > 0) { #if HZ > 1000         /* We can only overflow if HZ > 1000 */         if (timeout_msecs / 1000 > (s64)0x7fffffffffffffffULL / (s64)HZ)             timeout_jiffies = -1;         else #endif             timeout_jiffies = msecs_to_jiffies(timeout_msecs);     } else {         /* Infinite (< 0) or no (0) timeout */         timeout_jiffies = timeout_msecs;     } //实际处理函数     return do_sys_poll(ufds, nfds, &timeout_jiffies); } struct poll_list {     struct poll_list *next;     int len;     struct pollfd entries[0]; }; int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds, s64 *timeout) {     struct poll_wqueues table;      int fdcount, err;      unsigned int i;     struct poll_list *head;      struct poll_list *walk;     /* Allocate small arguments on the stack to save memory and be        faster - use long to make sure the buffer is aligned properly        on 64 bit archs to avoid unaligned access */     long stack_pps[POLL_STACK_ALLOC/sizeof(long)]; //栈的分配会更快     struct poll_list *stack_pp = NULL;     //检查描述符个数是否超过系统的限制     /* Do a sanity check on nfds ... */     if (nfds > current->signal->rlim[RLIMIT_NOFILE].rlim_cur)         return -EINVAL;     //首先是一个初始化工作, 主要初始化poll_table这个函数指针     poll_initwait(&table);     head = NULL;     walk = NULL;     i = nfds;     err = -ENOMEM;     //这个循环所作的工作就是将从用户传过来的多个pollfd结构信息拷贝到内核，         //由于可能结构的个数可能超过一页内存所能存储的范围，所以就用了循环来完成，         //每次拷贝一页内存能装载的个数。并且再将它们用链表链起来。     while(i!=0) {         struct poll_list *pp;         int num, size;         if (stack_pp == NULL)             num = N_STACK_PPS;         else             num = POLLFD_PER_PAGE; //这里保证kmalloc分配的空间不会超过一个页面         if (num > i)             num = i;         size = sizeof(struct poll_list) + sizeof(struct pollfd)*num;         //如果描述符的个数比较小时,或在比较大的时候,第一次会使用栈来存储         if (!stack_pp)              stack_pp = pp = (struct poll_list *)stack_pps;         else {             pp = kmalloc(size, GFP_KERNEL);              if (!pp)                 goto out_fds;         }         pp->next=NULL;         pp->len = num;         if (head == NULL)             head = pp;         else             walk->next = pp;         walk = pp;         if (copy_from_user(pp->entries, ufds + nfds-i,                  sizeof(struct pollfd)*num)) {             err = -EFAULT;             goto out_fds;         }         i -= pp->len;     }     //真正的POLL操作，返回的结果在head中     fdcount = do_poll(nfds, head, &table, timeout);     //双重循环，将事件拷贝回给用户空间     /* OK, now copy the revents fields back to user space. */     walk = head;     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:     walk = head;     while(walk!=NULL) {         struct poll_list *pp = walk->next;         if (walk != stack_pp)             kfree(walk);         walk = pp;     }     poll_freewait(&table);     return err; } //这个函数就是将当前进程加入等待队列，这个等待队列由驱动或文件系统或网络协议栈来提供 //这个函数是由驱动的file->poll中调用poll_wait()来间接调用的。 /* Add a new entry */ 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); } void poll_initwait(struct poll_wqueues *pwq) {     //在poll()中初始化为__pollwait(),注意在epoll中又会不同     init_poll_funcptr(&pwq->pt, __pollwait);      pwq->error = 0;     pwq->table = NULL;     pwq->inline_index = 0; } =========================================== static int do_poll(unsigned int nfds, struct poll_list *list,            struct poll_wqueues *wait, s64 *timeout) {     int count = 0;     poll_table* pt = &wait->pt;     /* Optimise the no-wait case */     if (!(*timeout))   //进程不设超时         pt = NULL;     for (;;) {         struct poll_list *walk;         long __timeout;         也是一个双重循环，处理每个文件描述符事件         set_current_state(TASK_INTERRUPTIBLE);         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++) {                 /*                 * Fish for events. If we found one, record it                 * and kill the poll_table, so we don't                 * needlessly register any other waiters after                 * this. They'll get immediately deregistered                 * when we break out and return.                 */                 if (do_pollfd(pfd, pt)) { //处理每个文件描述符                     count++;                     pt = NULL;                 }             }         }         //超时处理         /*         * All waiters have already been registered, so don't provide         * a poll_table to them on the next loop iteration.         */         pt = NULL;         if (count || !*timeout || signal_pending(current))             break;         count = wait->error;         if (count)             break;         if (*timeout < 0) {             /* Wait indefinitely */             __timeout = MAX_SCHEDULE_TIMEOUT;         } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT-1)) {             /*             * Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in             * a loop             */             __timeout = MAX_SCHEDULE_TIMEOUT - 1;             *timeout -= __timeout;         } else {             __timeout = *timeout;             *timeout = 0;         }         //进程切换         __timeout = schedule_timeout(__timeout);         //进程被唤醒, 继续执行         if (*timeout >= 0)             *timeout += __timeout;     }     __set_current_state(TASK_RUNNING);     return count; } /* * Fish for pollable events on the pollfd->fd file descriptor. We're only * interested in events matching the pollfd->events mask, and the result * matching that mask is both recorded in pollfd->revents and returned. The * pwait poll_table will be used by the fd-provided poll handler for waiting, * if non-NULL. */ static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait) {     unsigned int mask;     int fd;     mask = 0;     fd = pollfd->fd;     if (fd >= 0) {         int fput_needed;         struct file * file;         file = fget_light(fd, &fput_needed);         mask = POLLNVAL;         if (file != NULL) {             mask = DEFAULT_POLLMASK;             //调用驱动或文件系统的poll函数, 是否将当前进程加入驱动的等待队列,                       //取决是file->poll()第二个参数是否为空.             if (file->f_op && file->f_op->poll)                 mask = file->f_op->poll(file, pwait);              /* Mask out unneeded events. */             mask &= pollfd->events | POLLERR | POLLHUP;             fput_light(file, fput_needed);         }     }     pollfd->revents = mask; //更新参数返回值     return mask; //如果可读/写返回非0值 } ================================= 驱动或文件系统的poll()实现原型: test_poll(struct file *filep, poll_table *wait) {     ...     poll_wait(filep, &dev->wait_queue_head, wait);     ...     if (dev->readable)         mask |= POLLIN | POLLRDNORM;     if (dev->writable)         mask |= POLLOUT | POLLWRNORM;     ... } 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_initwait()初始化的__pollwait()了. }