#define wait_event_interruptible(wq, condition) 
({ 
int __ret = 0; 
if (!(condition)) 
__wait_event_interruptible(wq, condition, __ret); 
__ret; 
})

#define __wait_event_interruptible(wq, condition, ret) 
do { 
DEFINE_WAIT(__wait); 

for (;;) { 
prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE); //将进程设置成INTERRUPTIBLE 
if (condition)             //通常第一次进来条件为假 
break; 
if (!signal_pending(current)) { //signal_pending无信号处理返回0，反之非0 
schedule(); //调用schedule()一直等待返回，进程睡眠直到有wake_up唤醒后 schedule()返回 执行continue结束本次循环，接着执行下次循环condition为真break出来
//wait_event_interruptible()返回0；
continue; 
} 
ret = -ERESTARTSYS; 
break; 
} 
finish_wait(&wq, &__wait); 
} while (0)



void
prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)
{
unsigned long flags;

wait->flags &= ~WQ_FLAG_EXCLUSIVE;
spin_lock_irqsave(&q->lock, flags);
if (list_empty(&wait->task_list))
__add_wait_queue(q, wait);
set_current_state(state);
spin_unlock_irqrestore(&q->lock, flags);
}
EXPORT_SYMBOL(prepare_to_wait);

void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
{
unsigned long flags;

__set_current_state(TASK_RUNNING);
/*
* We can check for list emptiness outside the lock
* IFF:
*  - we use the "careful" check that verifies both
*    the next and prev pointers, so that there cannot
*    be any half-pending updates in progress on other
*    CPU's that we haven't seen yet (and that might
*    still change the stack area.
* and
*  - all other users take the lock (ie we can only
*    have _one_ other CPU that looks at or modifies
*    the list).
*/
if (!list_empty_careful(&wait->task_list)) {
spin_lock_irqsave(&q->lock, flags);
list_del_init(&wait->task_list);
spin_unlock_irqrestore(&q->lock, flags);
}
}

static int wi629_poll(struct file *filep)
{
int ret;
unsigned int mask = 0;
struct poll_wqueues wait_table;
mm_segment_t oldfs;

poll_initwait(&wait_table);   /* register callback function: __pollwait() */

for(;;) {
set_current_state(TASK_INTERRUPTIBLE);

oldfs = get_fs(); set_fs(get_ds());
if (filep->f_op->poll) 
mask = filep->f_op->poll(filep, &wait_table.pt);
set_fs(oldfs);

if (mask & POLLIN) {  /* got data */
ret = 0;
break;
}

if (wait_table.error) {
printk(KERN_INFO "  error in f_op->poll()\n");
ret = wait_table.error;
break;
}

if (signal_pending(task_rx)) {  /* got signal */
ret = -ERESTARTSYS;
break;
}

poll_schedule(&wait_table,TASK_INTERRUPTIBLE); /* sleep, and wait to be wakeup */
}
set_current_state(TASK_RUNNING);
poll_freewait(&wait_table);

return ret;
}