taglinefilesource code
wait935arch/i386/kernel/smp.cvoid smp_message_pass(int target, int msg, unsigned long data, int wait)
wait1065arch/i386/kernel/smp.cswitch(wait)
wait55arch/sparc/kernel/smp.cvoid smp_message_pass(int target, int msg, unsigned long data, int wait)
wait95arch/sparc/kernel/smp.cswitch(wait) {
wait151drivers/block/ll_rw_blk.cstruct wait_queue wait = { current, NULL };
wait153drivers/block/ll_rw_blk.cadd_wait_queue(&wait_for_request, &wait);
wait164drivers/block/ll_rw_blk.cremove_wait_queue(&wait_for_request, &wait);
wait293drivers/cdrom/cm206.cint sleep_or_timeout(struct wait_queue ** wait, int timeout)
wait295drivers/cdrom/cm206.ccd->timer.data=(unsigned long) wait;
wait298drivers/cdrom/cm206.cinterruptible_sleep_on(wait);
wait309drivers/cdrom/cm206.cstruct wait_queue * wait = NULL;
wait310drivers/cdrom/cm206.csleep_or_timeout(&wait, jiffies);
wait4621drivers/cdrom/sbpcd.cint wait;
wait4728drivers/cdrom/sbpcd.cwait=8;
wait4793drivers/cdrom/sbpcd.cwhile (wait--);
wait812drivers/char/apm_bios.cstruct wait_queue  wait = { current,  NULL };
wait822drivers/char/apm_bios.cadd_wait_queue(&process_list, &wait);
wait831drivers/char/apm_bios.cremove_wait_queue(&process_list, &wait);
wait848drivers/char/apm_bios.cselect_table * wait)
wait859drivers/char/apm_bios.cselect_wait(&process_list, wait);
wait68drivers/char/atixlmouse.cstruct wait_queue *wait;
wait89drivers/char/atixlmouse.cwake_up_interruptible(&mouse.wait);
wait173drivers/char/atixlmouse.cstatic int mouse_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
wait179drivers/char/atixlmouse.cselect_wait(&mouse.wait,wait);
wait223drivers/char/atixlmouse.cmouse.wait = NULL;
wait84drivers/char/busmouse.cwake_up_interruptible(&mouse.wait);
wait219drivers/char/busmouse.cstatic int mouse_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
wait224drivers/char/busmouse.cselect_wait(&mouse.wait, wait);
wait272drivers/char/busmouse.cmouse.wait = NULL;
wait2446drivers/char/cyclades.cstruct wait_queue wait = { current, NULL };
wait2508drivers/char/cyclades.cadd_wait_queue(&info->open_wait, &wait);
wait2571drivers/char/cyclades.cremove_wait_queue(&info->open_wait, &wait);
wait307drivers/char/ftape/fdc-io.cstruct wait_queue wait =
wait324drivers/char/ftape/fdc-io.cadd_wait_queue(&wait_intr, &wait);
wait329drivers/char/ftape/fdc-io.cremove_wait_queue(&wait_intr, &wait);
wait659drivers/char/istallion.cstatic int  stli_rawopen(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, int wait);
wait660drivers/char/istallion.cstatic int  stli_rawclose(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, int wait);
wait1131drivers/char/istallion.cstatic int stli_rawopen(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, int wait)
wait1140drivers/char/istallion.cprintk("stli_rawopen(brdp=%x,portp=%x,arg=%x,wait=%d)\n", (int) brdp, (int) portp, (int) arg, wait);
wait1178drivers/char/istallion.cif (wait == 0) {
wait1211drivers/char/istallion.cstatic int stli_rawclose(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, int wait)
wait1220drivers/char/istallion.cprintk("stli_rawclose(brdp=%x,portp=%x,arg=%x,wait=%d)\n", (int) brdp, (int) portp, (int) arg, wait);
wait1230drivers/char/istallion.cif (wait) {
wait1254drivers/char/istallion.cif (wait == 0) {
wait69drivers/char/lp.cint status, wait = 0;
wait89drivers/char/lp.cwhile(wait != LP_WAIT(minor)) wait++;
wait92drivers/char/lp.cwhile(wait) wait--;
wait103drivers/char/lp.cwait = (count > stats->meanwait)? count - stats->meanwait :
wait106drivers/char/lp.cstats->mdev = ((127 * stats->mdev) + wait + 64) / 128;
wait113drivers/char/lp.cint wait;
wait127drivers/char/lp.cwait = 0;
wait128drivers/char/lp.cwhile(wait != LP_WAIT(minor)) wait++;
wait131drivers/char/lp.cwhile(wait) wait--;
wait139drivers/char/lp.cwait = (count > stats->meanwait)? count - stats->meanwait :
wait142drivers/char/lp.cstats->mdev = ((127 * stats->mdev) + wait + 64) / 128;
wait77drivers/char/msbusmouse.cwake_up_interruptible(&mouse.wait);
wait149drivers/char/msbusmouse.cstatic int mouse_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
wait155drivers/char/msbusmouse.cselect_wait(&mouse.wait,wait);
wait184drivers/char/msbusmouse.cmouse.wait = NULL;
wait754drivers/char/n_tty.cstruct wait_queue wait = { current, NULL };
wait809drivers/char/n_tty.cadd_wait_queue(&tty->read_wait, &wait);
wait906drivers/char/n_tty.cremove_wait_queue(&tty->read_wait, &wait);
wait926drivers/char/n_tty.cstruct wait_queue wait = { current, NULL };
wait938drivers/char/n_tty.cadd_wait_queue(&tty->write_wait, &wait);
wait972drivers/char/n_tty.cremove_wait_queue(&tty->write_wait, &wait);
wait977drivers/char/n_tty.cstruct file * file, int sel_type, select_table *wait)
wait998drivers/char/n_tty.cselect_wait(&tty->read_wait, wait);
wait1003drivers/char/n_tty.cselect_wait(&tty->write_wait, wait);
wait234drivers/char/pcxx.cstruct wait_queue wait = { current, NULL };
wait251drivers/char/pcxx.cadd_wait_queue(&info->open_wait, &wait);
wait283drivers/char/pcxx.cremove_wait_queue(&info->open_wait, &wait);
wait421drivers/char/psaux.cstruct wait_queue wait = { current, NULL };
wait428drivers/char/psaux.cadd_wait_queue(&queue->proc_list, &wait);
wait436drivers/char/psaux.cremove_wait_queue(&queue->proc_list, &wait);
wait454drivers/char/psaux.cstatic int aux_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
wait460drivers/char/psaux.cselect_wait(&queue->proc_list, wait);
wait239drivers/char/random.cint sel_type, select_table * wait);
wait648drivers/char/random.cstruct wait_queue   wait = { current, NULL };
wait656drivers/char/random.cadd_wait_queue(&random_wait, &wait);
wait683drivers/char/random.cremove_wait_queue(&random_wait, &wait);
wait697drivers/char/random.cint sel_type, select_table * wait)
wait702drivers/char/random.cselect_wait(&random_wait, wait);
wait279drivers/char/selection.cstruct wait_queue wait = { current, NULL };
wait289drivers/char/selection.cadd_wait_queue(&vt->paste_wait, &wait);
wait2217drivers/char/serial.cstruct wait_queue wait = { current, NULL };
wait2286drivers/char/serial.cadd_wait_queue(&info->open_wait, &wait);
wait2332drivers/char/serial.cremove_wait_queue(&info->open_wait, &wait);
wait325drivers/char/tty_io.cstatic int hung_up_tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
wait1245drivers/char/tty_io.cstatic int tty_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
wait1254drivers/char/tty_io.creturn (tty->ldisc.select)(tty, inode, filp, sel_type, wait);
wait45drivers/char/tty_ioctl.cstruct wait_queue wait = { current, NULL };
wait53drivers/char/tty_ioctl.cadd_wait_queue(&tty->write_wait, &wait);
wait71drivers/char/tty_ioctl.cremove_wait_queue(&tty->write_wait, &wait);
wait772drivers/isdn/isdn_tty.cstruct wait_queue wait = {current, NULL};
wait837drivers/isdn/isdn_tty.cadd_wait_queue(&info->open_wait, &wait);
wait880drivers/isdn/isdn_tty.cremove_wait_queue(&info->open_wait, &wait);
wait198drivers/net/ppp.cstruct file *filp, int sel_type, select_table * wait);
wait2583drivers/net/ppp.cstruct file *filp, int sel_type, select_table * wait)
wait2623drivers/net/ppp.cselect_wait (&ppp->read_wait, wait);
wait2631drivers/net/ppp.cselect_wait (&ppp->write_wait, wait);
wait669drivers/scsi/aic7xxx_asm.cif (wait(&status) < 0) {
wait988drivers/scsi/scsi.cint wait)
wait1064drivers/scsi/scsi.cif (wait && SCwait && SCwait->request.rq_status != RQ_INACTIVE) {
wait1069drivers/scsi/scsi.cif (!wait) return NULL;
wait1078drivers/scsi/scsi.cif(!wait) return NULL;
wait532drivers/scsi/scsi.hstruct wait_queue wait = { current, NULL};  \
wait533drivers/scsi/scsi.hadd_wait_queue(QUEUE, &wait);        \
wait545drivers/scsi/scsi.hremove_wait_queue(QUEUE, &wait);\
wait459drivers/scsi/sg.cstatic int sg_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
wait470drivers/scsi/sg.cselect_wait(&scsi_generics[dev].read_wait, wait);
wait479drivers/scsi/sg.cselect_wait(&scsi_generics[dev].write_wait, wait);
wait476drivers/sound/audio.caudio_select (int dev, struct fileinfo *file, int sel_type, select_table_handle * wait)
wait491drivers/sound/audio.creturn DMAbuf_select (dev, file, sel_type, wait);
wait505drivers/sound/audio.creturn DMAbuf_select (dev, file, sel_type, wait);
wait1618drivers/sound/dmabuf.cDMAbuf_select (int dev, struct fileinfo *file, int sel_type, select_table_handle * wait)
wait1637drivers/sound/dmabuf.cmodule_select_wait (&in_sleeper[dev], wait);
wait1664drivers/sound/dmabuf.cmodule_select_wait (&in_sleeper[dev], wait);
wait1683drivers/sound/dmabuf.cmodule_select_wait (&out_sleeper[dev], wait);
wait1704drivers/sound/dmabuf.cmodule_select_wait (&out_sleeper[dev], wait);
wait507drivers/sound/midibuf.cMIDIbuf_select (int dev, struct fileinfo *file, int sel_type, select_table_handle * wait)
wait518drivers/sound/midibuf.cmodule_select_wait (&input_sleeper[dev], wait);
wait529drivers/sound/midibuf.cmodule_select_wait (&midi_sleeper[dev], wait);
wait1898drivers/sound/sequencer.csequencer_select (int dev, struct fileinfo *file, int sel_type, select_table_handle * wait)
wait1913drivers/sound/sequencer.cmodule_select_wait (&midi_sleeper, wait);
wait1928drivers/sound/sequencer.cmodule_select_wait (&seq_sleeper, wait);
wait21drivers/sound/sound_calls.hint DMAbuf_select(int dev, struct fileinfo *file, int sel_type, select_table_handle * wait);
wait37drivers/sound/sound_calls.hint audio_select(int dev, struct fileinfo *file, int sel_type, select_table_handle * wait);
wait57drivers/sound/sound_calls.hint sequencer_select(int dev, struct fileinfo *file, int sel_type, select_table_handle * wait);
wait73drivers/sound/sound_calls.hint MIDIbuf_select(int dev, struct fileinfo *file, int sel_type, select_table_handle * wait);
wait193drivers/sound/soundcard.csound_select (inode_handle * inode, file_handle * file, int sel_type, select_table_handle * wait)
wait208drivers/sound/soundcard.creturn sequencer_select (dev, &files[dev], sel_type, wait);
wait214drivers/sound/soundcard.creturn MIDIbuf_select (dev, &files[dev], sel_type, wait);
wait222drivers/sound/soundcard.creturn audio_select (dev, &files[dev], sel_type, wait);
wait128fs/buffer.cstruct wait_queue wait = { current, NULL };
wait131fs/buffer.cadd_wait_queue(&bh->b_wait, &wait);
wait139fs/buffer.cremove_wait_queue(&bh->b_wait, &wait);
wait154fs/buffer.cstatic int sync_buffers(kdev_t dev, int wait)
wait185fs/buffer.cif (!wait || !pass) {
wait194fs/buffer.cif (wait && buffer_req(bh) && !buffer_locked(bh) &&
wait226fs/buffer.cif (wait && retry && ++pass<=2)
wait964fs/buffer.cstruct wait_queue * wait;
wait966fs/buffer.cwait = ((volatile struct buffer_head *) bh)->b_wait;
wait968fs/buffer.c((volatile struct buffer_head *) bh)->b_wait = wait;
wait1157fs/buffer.cwake_up(&page->wait);
wait1225fs/buffer.cwake_up(&page->wait);
wait1819fs/buffer.cstatic void wakeup_bdflush(int wait)
wait1823fs/buffer.cif(wait) sleep_on(&bdflush_done);
wait159fs/dquot.cstruct wait_queue wait = {current, NULL};
wait161fs/dquot.cadd_wait_queue(&dquot->dq_wait, &wait);
wait169fs/dquot.cremove_wait_queue(&dquot->dq_wait, &wait);
wait202fs/dquot.cstruct wait_queue *wait;
wait207fs/dquot.cwait = ((volatile struct dquot *) dquot)->dq_wait;
wait211fs/dquot.c((volatile struct dquot *) dquot)->dq_wait = wait;
wait30fs/ext/fsync.cstatic int sync_block (struct inode * inode, unsigned long * block, int wait)
wait45fs/ext/fsync.cif (wait && buffer_req(bh) && !buffer_uptodate(bh)) {
wait49fs/ext/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh))
wait60fs/ext/fsync.cstruct buffer_head **bh, int wait) 
wait68fs/ext/fsync.crc = sync_block (inode, iblock, wait);
wait83fs/ext/fsync.cstatic int sync_direct(struct inode *inode, int wait)
wait89fs/ext/fsync.crc = sync_block (inode, inode->u.ext_i.i_data + i, wait);
wait98fs/ext/fsync.cstatic int sync_indirect(struct inode *inode, unsigned long *iblock, int wait)
wait104fs/ext/fsync.crc = sync_iblock (inode, iblock, &ind_bh, wait);
wait111fs/ext/fsync.cwait);
wait122fs/ext/fsync.cint wait)
wait128fs/ext/fsync.crc = sync_iblock (inode, diblock, &dind_bh, wait);
wait135fs/ext/fsync.cwait);
wait146fs/ext/fsync.cint wait)
wait152fs/ext/fsync.crc = sync_iblock (inode, tiblock, &tind_bh, wait);
wait159fs/ext/fsync.cwait);
wait171fs/ext/fsync.cint wait, err = 0;
wait176fs/ext/fsync.cfor (wait=0; wait<=1; wait++)
wait178fs/ext/fsync.cerr |= sync_direct(inode, wait);
wait179fs/ext/fsync.cerr |= sync_indirect(inode, inode->u.ext_i.i_data+9, wait);
wait180fs/ext/fsync.cerr |= sync_dindirect(inode, inode->u.ext_i.i_data+10, wait);
wait181fs/ext/fsync.cerr |= sync_tindirect(inode, inode->u.ext_i.i_data+11, wait);
wait890fs/ext/namei.cstatic struct wait_queue * wait = NULL;
wait895fs/ext/namei.csleep_on(&wait);
wait900fs/ext/namei.cwake_up(&wait);
wait30fs/ext2/fsync.cstatic int sync_block (struct inode * inode, u32 * block, int wait)
wait45fs/ext2/fsync.cif (wait && buffer_req(bh) && !buffer_uptodate(bh)) {
wait49fs/ext2/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh)) {
wait59fs/ext2/fsync.cstruct buffer_head ** bh, int wait) 
wait67fs/ext2/fsync.crc = sync_block (inode, iblock, wait);
wait82fs/ext2/fsync.cstatic int sync_direct (struct inode * inode, int wait)
wait88fs/ext2/fsync.crc = sync_block (inode, inode->u.ext2_i.i_data + i, wait);
wait97fs/ext2/fsync.cstatic int sync_indirect (struct inode * inode, u32 * iblock, int wait)
wait103fs/ext2/fsync.crc = sync_iblock (inode, iblock, &ind_bh, wait);
wait110fs/ext2/fsync.cwait);
wait120fs/ext2/fsync.cstatic int sync_dindirect (struct inode * inode, u32 * diblock, int wait)
wait126fs/ext2/fsync.crc = sync_iblock (inode, diblock, &dind_bh, wait);
wait133fs/ext2/fsync.cwait);
wait143fs/ext2/fsync.cstatic int sync_tindirect (struct inode * inode, u32 * tiblock, int wait)
wait149fs/ext2/fsync.crc = sync_iblock (inode, tiblock, &tind_bh, wait);
wait156fs/ext2/fsync.cwait);
wait168fs/ext2/fsync.cint wait, err = 0;
wait179fs/ext2/fsync.cfor (wait=0; wait<=1; wait++)
wait181fs/ext2/fsync.cerr |= sync_direct (inode, wait);
wait184fs/ext2/fsync.cwait);
wait187fs/ext2/fsync.cwait);
wait190fs/ext2/fsync.cwait);
wait174fs/inode.cstruct wait_queue * wait;
wait184fs/inode.cwait = ((volatile struct inode *) inode)->i_wait;
wait188fs/inode.c((volatile struct inode *) inode)->i_wait = wait;
wait647fs/inode.cstruct wait_queue wait = { current, NULL };
wait649fs/inode.cadd_wait_queue(&inode->i_wait, &wait);
wait656fs/inode.cremove_wait_queue(&inode->i_wait, &wait);
wait94fs/locks.cunsigned int wait);
wait96fs/locks.cunsigned int wait);
wait103fs/locks.cstatic void locks_delete_lock(struct file_lock **fl, unsigned int wait);
wait574fs/locks.cunsigned int wait)
wait608fs/locks.cif (wait) {
wait656fs/locks.cunsigned int wait)
wait670fs/locks.cif (wait) {
wait861fs/locks.cstatic void locks_delete_lock(struct file_lock **fl_p, unsigned int wait)
wait882fs/locks.cif (wait)
wait31fs/minix/fsync.cstatic int V1_sync_block (struct inode * inode, unsigned short * block, int wait)
wait46fs/minix/fsync.cif (wait && buffer_req(bh) && !buffer_uptodate(bh)) {
wait50fs/minix/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh))
wait61fs/minix/fsync.cstruct buffer_head **bh, int wait) 
wait70fs/minix/fsync.crc = V1_sync_block (inode, iblock, wait);
wait84fs/minix/fsync.cstatic int V1_sync_direct(struct inode *inode, int wait)
wait91fs/minix/fsync.c(unsigned short *) inode->u.minix_i.u.i1_data + i, wait);
wait100fs/minix/fsync.cstatic int V1_sync_indirect(struct inode *inode, unsigned short *iblock, int wait)
wait106fs/minix/fsync.crc = V1_sync_iblock (inode, iblock, &ind_bh, wait);
wait113fs/minix/fsync.cwait);
wait124fs/minix/fsync.cint wait)
wait130fs/minix/fsync.crc = V1_sync_iblock (inode, diblock, &dind_bh, wait);
wait137fs/minix/fsync.cwait);
wait149fs/minix/fsync.cint wait, err = 0;
wait155fs/minix/fsync.cfor (wait=0; wait<=1; wait++)
wait157fs/minix/fsync.cerr |= V1_sync_direct(inode, wait);
wait158fs/minix/fsync.cerr |= V1_sync_indirect(inode, inode->u.minix_i.u.i1_data + 7, wait);
wait159fs/minix/fsync.cerr |= V1_sync_dindirect(inode, inode->u.minix_i.u.i1_data + 8, wait);
wait168fs/minix/fsync.cstatic int V2_sync_block (struct inode * inode, unsigned long * block, int wait)
wait183fs/minix/fsync.cif (wait && buffer_req(bh) && !buffer_uptodate(bh)) {
wait187fs/minix/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh))
wait198fs/minix/fsync.cstruct buffer_head **bh, int wait) 
wait207fs/minix/fsync.crc = V2_sync_block (inode, iblock, wait);
wait221fs/minix/fsync.cstatic int V2_sync_direct(struct inode *inode, int wait)
wait228fs/minix/fsync.c(unsigned long *)inode->u.minix_i.u.i2_data + i, wait);
wait237fs/minix/fsync.cstatic int V2_sync_indirect(struct inode *inode, unsigned long *iblock, int wait)
wait243fs/minix/fsync.crc = V2_sync_iblock (inode, iblock, &ind_bh, wait);
wait250fs/minix/fsync.cwait);
wait261fs/minix/fsync.cint wait)
wait267fs/minix/fsync.crc = V2_sync_iblock (inode, diblock, &dind_bh, wait);
wait274fs/minix/fsync.cwait);
wait285fs/minix/fsync.cint wait)
wait291fs/minix/fsync.crc = V2_sync_iblock (inode, tiblock, &tind_bh, wait);
wait298fs/minix/fsync.cwait);
wait310fs/minix/fsync.cint wait, err = 0;
wait316fs/minix/fsync.cfor (wait=0; wait<=1; wait++)
wait318fs/minix/fsync.cerr |= V2_sync_direct(inode, wait);
wait320fs/minix/fsync.c(unsigned long *) inode->u.minix_i.u.i2_data + 7, wait);
wait322fs/minix/fsync.c(unsigned long *) inode->u.minix_i.u.i2_data + 8, wait);
wait324fs/minix/fsync.c(unsigned long *) inode->u.minix_i.u.i2_data + 9, wait);
wait821fs/minix/namei.cstatic struct wait_queue * wait = NULL;
wait826fs/minix/namei.csleep_on(&wait);
wait831fs/minix/namei.cwake_up(&wait);
wait239fs/ncpfs/inode.cserver->wait        = NULL;
wait417fs/ncpfs/sock.cremove_wait_queue(entry.wait_address, &entry.wait);
wait451fs/ncpfs/sock.cremove_wait_queue(entry.wait_address, &entry.wait);
wait681fs/ncpfs/sock.csleep_on(&server->wait);
wait694fs/ncpfs/sock.cwake_up(&server->wait);
wait83fs/nfs/bio.cwake_up(&page->wait);
wait110fs/nfs/bio.cwake_up(&page->wait);
wait142fs/nfs/bio.cwake_up(&page->wait);
wait140fs/nfs/inode.cserver->wait = NULL;
wait174fs/nfs/rpcsock.cremove_wait_queue(entry.wait_address, &entry.wait);
wait181fs/nfs/rpcsock.cremove_wait_queue(entry.wait_address, &entry.wait);
wait155fs/pipe.cstatic int pipe_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
wait161fs/pipe.cselect_wait(&PIPE_WAIT(*inode), wait);
wait166fs/pipe.cselect_wait(&PIPE_WAIT(*inode), wait);
wait171fs/pipe.cselect_wait(&inode->i_wait,wait);
wait182fs/pipe.cstatic int fifo_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
wait188fs/pipe.cselect_wait(&PIPE_WAIT(*inode), wait);
wait193fs/pipe.cselect_wait(&PIPE_WAIT(*inode), wait);
wait198fs/pipe.cselect_wait(&inode->i_wait,wait);
wait230fs/pipe.cstatic int connect_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait)
wait238fs/pipe.cselect_wait(&PIPE_WAIT(*inode), wait);
wait243fs/pipe.cselect_wait(&PIPE_WAIT(*inode), wait);
wait248fs/pipe.cselect_wait(&inode->i_wait,wait);
wait36fs/proc/kmsg.cstatic int kmsg_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
wait42fs/proc/kmsg.cselect_wait(&log_wait, wait);
wait55fs/select.cremove_wait_queue(entry->wait_address,&entry->wait);
wait70fs/select.cstatic int check(int flag, select_table * wait, struct file * file)
wait78fs/select.creturn select(inode, file, flag, wait)
wait79fs/select.c|| (wait && select(inode, file, flag, NULL));
wait89fs/select.cselect_table wait_table, *wait;
wait122fs/select.cwait = &wait_table;
wait126fs/select.cif (FD_ISSET(i,in) && check(SEL_IN,wait,current->files->fd[i])) {
wait129fs/select.cwait = NULL;
wait131fs/select.cif (FD_ISSET(i,out) && check(SEL_OUT,wait,current->files->fd[i])) {
wait134fs/select.cwait = NULL;
wait136fs/select.cif (FD_ISSET(i,ex) && check(SEL_EX,wait,current->files->fd[i])) {
wait139fs/select.cwait = NULL;
wait142fs/select.cwait = NULL;
wait229fs/smbfs/inode.cserver->wait = NULL;
wait391fs/smbfs/proc.csleep_on(&server->wait);
wait403fs/smbfs/proc.cwake_up(&server->wait);
wait318fs/super.cstruct wait_queue wait = { current, NULL };
wait320fs/super.cadd_wait_queue(&sb->s_wait, &wait);
wait327fs/super.cremove_wait_queue(&sb->s_wait, &wait);
wait29fs/sysv/fsync.cstatic int sync_block (struct inode * inode, unsigned long * blockp, int convert, int wait)
wait48fs/sysv/fsync.cif (wait && buffer_req(bh) && !buffer_uptodate(bh)) {
wait52fs/sysv/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh)) {
wait63fs/sysv/fsync.cstruct buffer_head * *bh, int wait)
wait74fs/sysv/fsync.crc = sync_block (inode, iblockp, convert, wait);
wait89fs/sysv/fsync.cstatic int sync_direct(struct inode *inode, int wait)
wait95fs/sysv/fsync.crc = sync_block (inode, inode->u.sysv_i.i_data + i, 0, wait);
wait104fs/sysv/fsync.cstatic int sync_indirect(struct inode *inode, unsigned long *iblockp, int convert, int wait)
wait111fs/sysv/fsync.crc = sync_iblock (inode, iblockp, convert, &ind_bh, wait);
wait119fs/sysv/fsync.cwait);
wait130fs/sysv/fsync.cint wait)
wait137fs/sysv/fsync.crc = sync_iblock (inode, diblockp, convert, &dind_bh, wait);
wait145fs/sysv/fsync.cwait);
wait156fs/sysv/fsync.cint wait)
wait163fs/sysv/fsync.crc = sync_iblock (inode, tiblockp, convert, &tind_bh, wait);
wait171fs/sysv/fsync.cwait);
wait183fs/sysv/fsync.cint wait, err = 0;
wait189fs/sysv/fsync.cfor (wait=0; wait<=1; wait++) {
wait190fs/sysv/fsync.cerr |= sync_direct(inode, wait);
wait191fs/sysv/fsync.cerr |= sync_indirect(inode, inode->u.sysv_i.i_data+10, 0, wait);
wait192fs/sysv/fsync.cerr |= sync_dindirect(inode, inode->u.sysv_i.i_data+11, 0, wait);
wait193fs/sysv/fsync.cerr |= sync_tindirect(inode, inode->u.sysv_i.i_data+12, 0, wait);
wait813fs/sysv/namei.cstatic struct wait_queue * wait = NULL;
wait818fs/sysv/namei.csleep_on(&wait);
wait823fs/sysv/namei.cwake_up(&wait);
wait29fs/xiafs/fsync.cstatic int sync_block (struct inode * inode, unsigned long * block, int wait)
wait44fs/xiafs/fsync.cif (wait && buffer_req(bh) && !buffer_uptodate(bh)) {
wait48fs/xiafs/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh))
wait59fs/xiafs/fsync.cstruct buffer_head **bh, int wait) 
wait67fs/xiafs/fsync.crc = sync_block (inode, iblock, wait);
wait82fs/xiafs/fsync.cstatic int sync_direct(struct inode *inode, int wait)
wait88fs/xiafs/fsync.crc = sync_block (inode, inode->u.ext_i.i_data + i, wait);
wait97fs/xiafs/fsync.cstatic int sync_indirect(struct inode *inode, unsigned long *iblock, int wait)
wait103fs/xiafs/fsync.crc = sync_iblock (inode, iblock, &ind_bh, wait);
wait110fs/xiafs/fsync.cwait);
wait121fs/xiafs/fsync.cint wait)
wait127fs/xiafs/fsync.crc = sync_iblock (inode, diblock, &dind_bh, wait);
wait134fs/xiafs/fsync.cwait);
wait146fs/xiafs/fsync.cint wait, err = 0;
wait151fs/xiafs/fsync.cfor (wait=0; wait<=1; wait++)
wait153fs/xiafs/fsync.cerr |= sync_direct(inode, wait);
wait154fs/xiafs/fsync.cerr |= sync_indirect(inode, &inode->u.xiafs_i.i_ind_zone, wait);
wait155fs/xiafs/fsync.cerr |= sync_dindirect(inode, &inode->u.xiafs_i.i_dind_zone, wait);
wait837fs/xiafs/namei.cstatic struct wait_queue * wait = NULL;
wait842fs/xiafs/namei.csleep_on(&wait);
wait847fs/xiafs/namei.cwake_up(&wait);
wait286include/asm-i386/unistd.hstatic inline pid_t wait(int * wait_stat)
wait1310include/asm-mips/unistd.hstatic inline pid_t wait(int * wait_stat)
wait97include/linux/busmouse.hstruct wait_queue *wait;
wait87include/linux/lp.h#define LP_WAIT(minor)  lp_table[(minor)].wait    /* strobe wait */
wait109include/linux/lp.hunsigned int wait;
wait121include/linux/mm.hstruct wait_queue *wait;
wait50include/linux/ncp_fs_sb.hstruct wait_queue *wait;
wait83include/linux/net.hstruct wait_queue  **wait;    /* ptr to place to wait on  */
wait107include/linux/net.hselect_table *wait);
wait12include/linux/nfs_fs_sb.hstruct wait_queue *wait;
wait5include/linux/pipe_fs_i.hstruct wait_queue * wait;
wait16include/linux/pipe_fs_i.h#define PIPE_WAIT(inode)  ((inode).u.pipe_i.wait)
wait400include/linux/sched.hextern inline void add_wait_queue(struct wait_queue ** p, struct wait_queue * wait)
wait405include/linux/sched.hif (wait->next) {
wait410include/linux/sched.hprintk("add_wait_queue (%08lx): wait->next = %08lx\n",pc,(unsigned long) wait->next);
wait416include/linux/sched.hwait->next = wait;
wait417include/linux/sched.h*p = wait;
wait419include/linux/sched.hwait->next = (*p)->next;
wait420include/linux/sched.h(*p)->next = wait;
wait425include/linux/sched.hextern inline void remove_wait_queue(struct wait_queue ** p, struct wait_queue * wait)
wait435include/linux/sched.hif ((*p == wait) &&
wait439include/linux/sched.h((*p = wait->next) == wait)) {
wait442include/linux/sched.htmp = wait;
wait443include/linux/sched.hwhile (tmp->next != wait) {
wait450include/linux/sched.htmp->next = wait->next;
wait452include/linux/sched.hwait->next = NULL;
wait459include/linux/sched.hprintk("list = %08lx, queue = %08lx\n",(unsigned long) p, (unsigned long) wait);
wait476include/linux/sched.hentry->wait.task = current;
wait477include/linux/sched.hentry->wait.next = NULL;
wait478include/linux/sched.hadd_wait_queue(wait_address,&entry->wait);
wait497include/linux/sched.hwake_up(&sem->wait);
wait444include/linux/skbuff.hextern int      datagram_select(struct sock *sk, int sel_type, select_table *wait);
wait26include/linux/smb_fs_sb.hstruct wait_queue *wait;
wait12include/linux/smp.hextern void smp_message_pass(int target, int msg, unsigned long data, int wait);
wait31include/linux/tty_ldisc.hstruct select_table_struct *wait);
wait18include/linux/wait.hstruct wait_queue * wait;
wait25include/linux/wait.hstruct wait_queue wait;
wait357include/net/sock.hselect_table *wait);
wait862init/main.cwhile (pid != wait(&i));
wait884init/main.cwhile (pid != wait(&i))
wait897init/main.cif (pid == wait(&i))
wait563kernel/exit.cstruct wait_queue wait = { current, NULL };
wait576kernel/exit.cadd_wait_queue(&current->wait_chldexit,&wait);
wait645kernel/exit.cremove_wait_queue(&current->wait_chldexit,&wait);
wait480kernel/sched.cstruct wait_queue wait = { current, NULL };
wait481kernel/sched.cadd_wait_queue(&sem->wait, &wait);
wait488kernel/sched.cremove_wait_queue(&sem->wait, &wait);
wait494kernel/sched.cstruct wait_queue wait = { current, NULL };
wait501kernel/sched.cadd_wait_queue(p, &wait);
wait505kernel/sched.cremove_wait_queue(p, &wait);
wait289mm/filemap.cstruct wait_queue wait = { current, NULL };
wait292mm/filemap.cadd_wait_queue(&page->wait, &wait);
wait300mm/filemap.cremove_wait_queue(&page->wait, &wait);
wait31mm/page_io.cvoid rw_swap_page(int rw, unsigned long entry, char * buf, int wait)
wait65mm/page_io.cif (!wait) {
wait71mm/page_io.cif (wait)
wait71mm/vmscan.cunsigned long address, pte_t * page_table, int dma, int wait)
wait118mm/vmscan.crw_swap_page(WRITE, entry, (char *) page, wait);
wait160mm/vmscan.cpmd_t *dir, unsigned long address, unsigned long end, int dma, int wait)
wait182mm/vmscan.cresult = try_to_swap_out(tsk, vma, address, pte, dma, wait);
wait192mm/vmscan.cpgd_t *dir, unsigned long address, unsigned long end, int dma, int wait)
wait212mm/vmscan.cint result = swap_out_pmd(tsk, vma, pmd, address, end, dma, wait);
wait222mm/vmscan.cpgd_t *pgdir, unsigned long start, int dma, int wait)
wait233mm/vmscan.cint result = swap_out_pgd(tsk, vma, pgdir, start, end, dma, wait);
wait242mm/vmscan.cstatic int swap_out_process(struct task_struct * p, int dma, int wait)
wait263mm/vmscan.cint result = swap_out_vma(p, vma, pgd_offset(p->mm, address), address, dma, wait);
wait275mm/vmscan.cstatic int swap_out(unsigned int priority, int dma, int wait)
wait314mm/vmscan.cswitch (swap_out_process(p, dma, wait)) {
wait333mm/vmscan.cint try_to_free_page(int priority, int dma, int wait)
wait349mm/vmscan.cif (swap_out(i, dma, wait))
wait1164net/appletalk/ddp.csk->sleep=sock->wait;
wait1864net/appletalk/ddp.cstatic int atalk_select(struct socket *sock , int sel_type, select_table *wait)
wait1868net/appletalk/ddp.creturn datagram_select(sk,sel_type,wait);
wait1124net/ax25/af_ax25.csk->sleep  = sock->wait;
wait2149net/ax25/af_ax25.cstatic int ax25_select(struct socket *sock , int sel_type, select_table *wait)
wait2153net/ax25/af_ax25.creturn datagram_select(sk, sel_type, wait);
wait179net/core/datagram.cint datagram_select(struct sock *sk, int sel_type, select_table *wait)
wait181net/core/datagram.cselect_wait(sk->sleep, wait);
wait675net/ipv4/af_inet.csk->sleep = sock->wait;
wait1052net/ipv4/af_inet.csk2->sleep = newsock->wait;
wait1183net/ipv4/af_inet.cstatic int inet_select(struct socket *sock, int sel_type, select_table *wait )
wait1190net/ipv4/af_inet.creturn(sk->prot->select(sk, sel_type, wait));
wait685net/ipv4/tcp.cstatic int tcp_listen_select(struct sock *sk, int sel_type, select_table *wait)
wait694net/ipv4/tcp.cselect_wait(&master_select_wakeup,wait);
wait708net/ipv4/tcp.cstatic int tcp_select(struct sock *sk, int sel_type, select_table *wait)
wait711net/ipv4/tcp.creturn tcp_listen_select(sk, sel_type, wait);
wait753net/ipv4/tcp.cselect_wait(sk->sleep, wait);
wait1347net/ipv4/tcp.cstruct wait_queue wait = { current, NULL };
wait1378net/ipv4/tcp.cadd_wait_queue(sk->sleep, &wait);
wait1578net/ipv4/tcp.cremove_wait_queue(sk->sleep, &wait);
wait1713net/ipx/af_ipx.csk->sleep=sock->wait;
wait2162net/ipx/af_ipx.cstatic int ipx_select(struct socket *sock , int sel_type, select_table *wait)
wait2166net/ipx/af_ipx.creturn datagram_select(sk,sel_type,wait);
wait451net/netrom/af_netrom.csk->sleep  = sock->wait;
wait1135net/netrom/af_netrom.cstatic int nr_select(struct socket *sock , int sel_type, select_table *wait)
wait1139net/netrom/af_netrom.creturn datagram_select(sk, sel_type, wait);
wait269net/socket.csock->wait = &inode->i_wait;
wait283net/socket.cwake_up_interruptible(peer->wait);
wait410net/socket.cstatic int sock_select(struct inode *inode, struct file *file, int sel_type, select_table * wait)
wait421net/socket.creturn(sock->ops->select(sock, sel_type, wait));
wait324net/unix/af_unix.csk->sleep=sock->wait;
wait1193net/unix/af_unix.cstatic int unix_select(struct socket *sock,  int sel_type, select_table *wait)
wait1195net/unix/af_unix.creturn datagram_select(sock->data,sel_type,wait);