/*‘q’isthewaitqueuewewishtosleepon*/

DEFINE_WAIT(wait);

add_wait_queue(q,&wait);//这个函数调用是可选

while(!condition){/*conditionistheeventthatwearewaitingfor*/

prepare_to_wait(&q,&wait,TASK_INTERRUPTIBLE);

if(signal_pending(current))

/*handlesignal*/

schedule();

}

finish_wait(&q,&wait);

staticssize_t inotify_read(struct file *file, char __user *buf,

size_t count, loff_t *pos)

{

structfsnotify_group *group;

structfsnotify_event *kevent;

char__user *start;

intret;

DEFINE_WAIT(wait);

start= buf;

group= file->private_data;

while(1) {

prepare_to_wait(&group->notification_waitq,&wait,TASK_INTERRUPTIBLE);

mutex_lock(&group->notification_mutex);

kevent= get_one_event(group, count);

mutex_unlock(&group->notification_mutex);

if(kevent) {

ret= PTR_ERR(kevent);

if(IS_ERR(kevent))

break;

ret= copy_event_to_user(group, kevent, buf);

fsnotify_put_event(kevent);

if(ret < 0)

break;

buf+= ret;

count-= ret;

continue;

}

ret= -EAGAIN;

if(file->f_flags & O_NONBLOCK)

break;

ret= -EINTR;

if(signal_pending(current))

break;

if(start != buf)

break;

schedule();

}

finish_wait(&group->notification_waitq,&wait);

if(start != buf && ret != -EFAULT)

ret= buf - start;

returnret;

}

/*Helper thread */

staticint

my_thread(void*unused)

{

/**

*                wait_queue_t wait;

*                init_waitqueue_entry(&wait, current);

*/

DECLARE_WAITQUEUE(wait,current);

daemonize("my_thread");

add_wait_queue(&my_thread_wait,&wait);

while(1) {

/*Relinquish processor until event occurs */

set_current_state(TASK_INTERRUPTIBLE);

if(signal_pending(current))

/*##handlesingalevent##*/

schedule();

/*Control gets here when the thread is woken

upfrom the my_thread_wait wait queue */

/*Quit if let go */

if(pink_slip) {

break;

}

/*Do the real work */

/*... */

}

/*Bail out of the wait queue */

__set_current_state(TASK_RUNNING);

remove_wait_queue(&my_thread_wait,&wait);

/*Atomically signal completion and exit */

complete_and_exit(&my_thread_exit,0);

}