epoll_wait man page on Archlinux

Man page or keyword search:  
man Server   11224 pages
apropos Keyword Search (all sections)
Output format
Archlinux logo
[printable version]

EPOLL_WAIT(2)		   Linux Programmer's Manual		 EPOLL_WAIT(2)

       epoll_wait,  epoll_pwait	 -  wait  for  an  I/O	event on an epoll file

       #include <sys/epoll.h>

       int epoll_wait(int epfd, struct epoll_event *events,
		      int maxevents, int timeout);
       int epoll_pwait(int epfd, struct epoll_event *events,
		      int maxevents, int timeout,
		      const sigset_t *sigmask);

       The epoll_wait() system call waits for events on the epoll(7)  instance
       referred to by the file descriptor epfd.	 The memory area pointed to by
       events will contain the events that will be available for  the  caller.
       Up  to  maxevents are returned by epoll_wait().	The maxevents argument
       must be greater than zero.

       The  timeout  argument  specifies  the  number  of  milliseconds	  that
       epoll_wait() will block.	 The call will block until either:

       *  a file descriptor delivers an event;

       *  the call is interrupted by a signal handler; or

       *  the timout expires.

       Note  that  the timeout interval will be rounded up to the system clock
       granularity, and kernel scheduling delays mean that the blocking interÔÇÉ
       val  may	 overrun by a small amount.  Specifying a timeout of -1 causes
       epoll_wait() to block indefinitely, while specifying a timeout equal to
       zero  cause  epoll_wait()  to return immediately, even if no events are

       The struct epoll_event is defined as :

	   typedef union epoll_data {
	       void    *ptr;
	       int	fd;
	       uint32_t u32;
	       uint64_t u64;
	   } epoll_data_t;

	   struct epoll_event {
	       uint32_t	    events;    /* Epoll events */
	       epoll_data_t data;      /* User data variable */

       The data of each returned structure will contain the same data the user
       set  with  an  epoll_ctl(2)  (EPOLL_CTL_ADD,  EPOLL_CTL_MOD)  while the
       events member will contain the returned event bit field.

       The relationship between epoll_wait() and epoll_pwait() is analogous to
       the  relationship  between  select(2)  and pselect(2): like pselect(2),
       epoll_pwait() allows an application to safely wait until either a  file
       descriptor becomes ready or until a signal is caught.

       The following epoll_pwait() call:

	   ready = epoll_pwait(epfd, &events, maxevents, timeout, &sigmask);

       is equivalent to atomically executing the following calls:

	   sigset_t origmask;

	   sigprocmask(SIG_SETMASK, &sigmask, &origmask);
	   ready = epoll_wait(epfd, &events, maxevents, timeout);
	   sigprocmask(SIG_SETMASK, &origmask, NULL);

       The   sigmask  argument	may  be	 specified  as	NULL,  in  which  case
       epoll_pwait() is equivalent to epoll_wait().

       When successful, epoll_wait() returns the number	 of  file  descriptors
       ready for the requested I/O, or zero if no file descriptor became ready
       during the requested  timeout  milliseconds.   When  an	error  occurs,
       epoll_wait() returns -1 and errno is set appropriately.

       EBADF  epfd is not a valid file descriptor.

       EFAULT The  memory  area	 pointed  to  by events is not accessible with
	      write permissions.

       EINTR  The call was interrupted by a signal handler before  either  (1)
	      any of the requested events occurred or (2) the timeout expired;
	      see signal(7).

       EINVAL epfd is not an epoll file descriptor, or maxevents is less  than
	      or equal to zero.

       epoll_wait()  was  added to the kernel in version 2.6.  Library support
       is provided in glibc starting with version 2.3.2.

       epoll_pwait() was added to Linux in kernel 2.6.19.  Library support  is
       provided in glibc starting with version 2.6.

       epoll_wait() is Linux-specific.

       While  one thread is blocked in a call to epoll_pwait(), it is possible
       for another thread to add a file descriptor to  the  waited-upon	 epoll
       instance.   If the new file descriptor becomes ready, it will cause the
       epoll_wait() call to unblock.

       For a discussion of what may happen if a file descriptor	 in  an	 epoll
       instance	 being	monitored by epoll_wait() is closed in another thread,
       see select(2).

       In kernels before 2.6.37, a timeout  value  larger  than	 approximately
       LONG_MAX	 /  HZ	milliseconds is treated as -1 (i.e., infinity).	 Thus,
       for example, on a system where the sizeof(long) is 4 and the kernel  HZ
       value  is 1000, this means that timeouts greater than 35.79 minutes are
       treated as infinity.

       epoll_create(2), epoll_ctl(2), epoll(7)

       This page is part of release 3.65 of the Linux  man-pages  project.   A
       description  of	the project, and information about reporting bugs, can
       be found at http://www.kernel.org/doc/man-pages/.

Linux				  2014-01-31			 EPOLL_WAIT(2)

List of man pages available for Archlinux

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net