linux-2.6.38poll机制简析（以tiny6410按键中断程序为基础）

/*
struct pollfd {
int fd; //文件描述符
short events; //表示请求检测的事件
short revents; //表示检测之后返回的事件
};
*/
int fd;
struct pollfd fds[]; // 只用poll函数来检测一个描述符
fd = open("/dev/tiny6410_button", );
fds[].fd = fd; //存放文件描述符
fds[].events = POLLIN; //有数据可以读
while ()
{
ret = poll(fds, , ); // int poll(struct pollfd fds[], nfds_t nfds, int timeout)
if (ret == ) // fds[]:存放需要被检测状态的描述符 nfds:fds[]数组的个数 timeout:poll函数阻塞调用的时间
{
printf("timeout fds[0].revents = %d \n",fds[].revents);
}
else if (ret>)
{
printf("fds[0].revents = %d\n",fds[].revents);
read(fd, press_cnt, sizeof(press_cnt));
for (i = ; i < sizeof(press_cnt)/sizeof(press_cnt[]); i++)
{
if (press_cnt[i])
printf("K%d has been pressed %d times!\n", i+, press_cnt[i]);
}
}
else
{
return ;
}
}
close(fd);
return ;

SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds,
long, timeout_msecs)
{
....
//1.设置timeout时间
if (timeout_msecs >= ) {
to = &end_time;
poll_select_set_timeout(to, timeout_msecs / MSEC_PER_SEC,
NSEC_PER_MSEC * (timeout_msecs % MSEC_PER_SEC));
}
// 2.完成poll调用的主要任务
ret = do_sys_poll(ufds, nfds, to);
....
}

int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds,
struct timespec *end_time)
{
struct poll_wqueues table;
int err = -EFAULT, fdcount, len, size;
// 从这里开始都是分配内存空间，并将用户空间的fds[]拷贝到内核空间
long stack_pps[POLL_STACK_ALLOC/sizeof(long)];// 在栈上分配一个固定空间的
struct poll_list *const head = (struct poll_list *)stack_pps;//强制将上边分配的空间转换为poll_list
struct poll_list *walk = head;
unsigned long todo = nfds;//用户空间的fds[]数组的个数 if (nfds > rlimit(RLIMIT_NOFILE))
return -EINVAL; len = min_t(unsigned int, nfds, N_STACK_PPS);
for (;;) {
walk->next = NULL; //将指针先置为NULL
walk->len = len; //长度=len
if (!len)
break; if (copy_from_user(walk->entries, ufds + nfds-todo,
sizeof(struct pollfd) * walk->len))//拷贝的前提应该是不会超过分配内存的大小
goto out_fds; //当用户空间的fds[]超过所分配内存大小时，跳转 todo -= walk->len; //nfds-walk->len 求剩下多少个fds结构体组没有拷
if (!todo) //如果不剩即全部拷完了， 则break
break; len = min(todo, POLLFD_PER_PAGE); //若还剩todo个没考， 求下一次需要拷的个数
size = sizeof(struct poll_list) + sizeof(struct pollfd) * len;//求需要分配内存的大小
walk = walk->next = kmalloc(size, GFP_KERNEL);// 在分配size大小的内存，并将这块内存的首地址挂载walk->next上， 这样如果有很多fds[]的话，就可以够成一个一个的poll_list 链表， 链表之间通过poll_list->next 连接
if (!walk) {
err = -ENOMEM;
goto out_fds;
}
}
// 到这里已经分配完内存空间，并将所有的fds[]从用户空间拷贝到内核空间
poll_initwait(&table); // 这个函数就是初始化poll_wqueues类型的变量 table
初始化了什么，在下边分析
fdcount = do_poll(nfds, head, &table, end_time);// 核心函数
poll_freewait(&table); for (walk = head; walk; walk = walk->next) {
struct pollfd *fds = walk->entries;
int j; for (j = ; j < walk->len; j++, ufds++) // 分析到这里应该就很明朗了，这里是把revents从内核空间拷贝到用户空间，方便用户空间来查询哪些文件描述符的状态发生了变化
if (__put_user(fds[j].revents, &ufds->revents))
goto out_fds;
}
err = fdcount;
out_fds:
walk = head->next;
while (walk) {
struct poll_list *pos = walk;
walk = walk->next;
kfree(pos);
} return err;
}

struct poll_wqueues {
poll_table pt;
struct poll_table_page *table;
struct task_struct *polling_task;
int triggered;
int error;
int inline_index;
struct poll_table_entry inline_entries[N_INLINE_POLL_ENTRIES];
}; //这是table是什么 重点是poll_table成员typedef struct poll_table_struct {
poll_queue_proc qproc;
unsigned long key;
} poll_table; // 这是poll_table 是什么
static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
poll_table *p)
{
struct poll_wqueues *pwq = container_of(p, struct poll_wqueues, pt);
struct poll_table_entry *entry = poll_get_entry(pwq);
if (!entry)
return;
get_file(filp);
entry->filp = filp;
entry->wait_address = wait_address;
entry->key = p->key;
init_waitqueue_func_entry(&entry->wait, pollwake);
entry->wait.private = pwq;
add_wait_queue(wait_address, &entry->wait);
}
void poll_initwait(struct poll_wqueues *pwq)
{
init_poll_funcptr(&pwq->pt, __pollwait); //见下边，这table->pt ->qproc = qproc = _pollwait;
pwq->polling_task = current;
pwq->triggered = ;
pwq->error = ;
pwq->table = NULL;
pwq->inline_index = ;
}
static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
{
pt->qproc = qproc;
pt->key = ~0UL; /* all events enabled */
}

for (;;) { //这里三层循环嵌套，虽然复杂，但是就是遍历从用户空间拷贝的fds[]数组，然后执行do_pollfd(pfd,pt) ，这里的pt就是上边分析的wait->pt
struct poll_list *walk; 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)) {
count++;
pt = NULL;
}
}
}
pt = NULL;
if (!count) {
count = wait->error;
if (signal_pending(current))
count = -EINTR;
}
if (count || timed_out)
break;
if (end_time && !to) {
expire = timespec_to_ktime(*end_time);
to = &expire;
} if (!poll_schedule_timeout(wait, TASK_INTERRUPTIBLE, to, slack))
timed_out = ;
}

static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait)
{
// 先看传入参数：pollfd :fds[]数组中的某一个注意是拷贝到内核空间的fds[]
// pwait : 这个pwait就是之前初始化的table->pt
// pt下边挂着一个回调函数，在这里派上用处了
unsigned int mask;
int fd; mask = ;
fd = pollfd->fd; // 取出文件描述符
if (fd >= ) {
int fput_needed;
struct file * file; file = fget_light(fd, &fput_needed);
mask = POLLNVAL;
if (file != NULL) {
mask = DEFAULT_POLLMASK;
if (file->f_op && file->f_op->poll) { // 这里就和文件操作对应的结构体中中的内容就比较相似了，
//当我们驱动程序中定义了文件操作结构体，并且定义了poll函数，那么久执行驱动程序的poll函数
if (pwait)
pwait->key = pollfd->events |
POLLERR | POLLHUP;
mask = file->f_op->poll(file, pwait); // 这里执行驱动程序的poll函数， 传入参数有一个回调函数
//这个回调函数就是之前初始化table提到的
// 注意驱动程序poll函数执行完会返回一个值， 正是根据驱动程序中的poll函数的返回值来确定，我们的文件描述符的状态是否发生了变化
}
/* Mask out unneeded events. */
mask &= pollfd->events | POLLERR | POLLHUP;
fput_light(file, fput_needed);
}
}
pollfd->revents = mask; return mask;
}

unsigned int tiny6410_button_poll (struct file *file, struct poll_table_struct *wait)
{
unsigned int mask = ;
poll_wait(file, &button_waitq, wait);
if (ev_press)
mask |= POLLIN;
return mask;
}

static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
poll_table *p)
{
...
add_wait_queue(wait_address, &entry->wait); // add_wait_queue(&button_waitq, &entry->wait)
}