trusty (3) poll.3posix.gz

Provided by: manpages-posix-dev_2.16-1_all bug

NAME

       poll - input/output multiplexing

SYNOPSIS

       #include <poll.h>

       int poll(struct pollfd fds[], nfds_t nfds, int timeout);

DESCRIPTION

       The  poll()  function  provides applications with a mechanism for multiplexing input/output over a set of
       file descriptors.  For each member of the array pointed to by fds, poll() shall examine  the  given  file
       descriptor  for  the  event(s)  specified  in events. The number of pollfd structures in the fds array is
       specified by nfds. The poll() function shall identify those file descriptors on which an application  can
       read or write data, or on which certain events have occurred.

       The  fds  argument specifies the file descriptors to be examined and the events of interest for each file
       descriptor. It is a pointer to an array with one member for each open file descriptor  of  interest.  The
       array's  members  are  pollfd structures within which fd specifies an open file descriptor and events and
       revents are bitmasks constructed by OR'ing a combination of the following event flags:

       POLLIN Data other than high-priority data may be read without blocking.

       For STREAMS, this flag is set in revents even if the message is  of  zero  length.  This  flag  shall  be
       equivalent to POLLRDNORM | POLLRDBAND.

       POLLRDNORM
              Normal data may be read without blocking.

       For  STREAMS,  data on priority band 0 may be read without blocking.  This flag is set in revents even if
       the message is of zero length.

       POLLRDBAND
              Priority data may be read without blocking.

       For STREAMS, data on priority bands greater than 0 may be read without blocking.  This  flag  is  set  in
       revents even if the message is of zero length.

       POLLPRI
              High-priority data may be read without blocking.

       For STREAMS, this flag is set in revents even if the message is of zero length.

       POLLOUT
              Normal data may be written without blocking.

       For STREAMS, data on priority band 0 may be written without blocking.

       POLLWRNORM
              Equivalent to POLLOUT.

       POLLWRBAND
              Priority data may be written.

       For  STREAMS, data on priority bands greater than 0 may be written without blocking. If any priority band
       has been written to on this STREAM, this event only examines bands that have been  written  to  at  least
       once.

       POLLERR
              An  error has occurred on the device or stream. This flag is only valid in the revents bitmask; it
              shall be ignored in the events member.

       POLLHUP
              The device has been disconnected. This event and POLLOUT  are  mutually-exclusive;  a  stream  can
              never  be  writable  if  a  hangup  has  occurred.  However,  this  event  and POLLIN, POLLRDNORM,
              POLLRDBAND, or POLLPRI are not mutually-exclusive. This flag is only valid in the revents bitmask;
              it shall be ignored in the events member.

       POLLNVAL
              The specified fd value is invalid. This flag is only valid in the revents member; it shall ignored
              in the events member.

       The significance and semantics of normal, priority, and high-priority data are file and device-specific.

       If the value of fd is less than 0, events shall be ignored, and revents shall be set to 0 in  that  entry
       on return from poll().

       In  each  pollfd  structure,  poll()  shall  clear  the revents member, except that where the application
       requested a report on a condition by setting one of the bits of events listed above, poll() shall set the
       corresponding  bit  in  revents  if  the  requested condition is true.  In addition, poll() shall set the
       POLLHUP, POLLERR, and POLLNVAL flag in revents if the condition is true, even if the application did  not
       set the corresponding bit in events.

       If  none  of the defined events have occurred on any selected file descriptor, poll() shall wait at least
       timeout milliseconds for an event to occur on any of the selected file  descriptors.   If  the  value  of
       timeout  is 0, poll() shall return immediately. If the value of timeout is -1, poll() shall block until a
       requested event occurs or until the call is interrupted.

       Implementations may place limitations on the granularity of timeout intervals. If the  requested  timeout
       interval requires a finer granularity than the implementation supports, the actual timeout interval shall
       be rounded up to the next supported value.

       The poll() function shall not be affected by the O_NONBLOCK flag.

       The poll() function shall support regular files, terminal  and  pseudo-terminal  devices,  FIFOs,  pipes,
       sockets and  STREAMS-based files.  The behavior of poll() on elements of fds that refer to other types of
       file is unspecified.

       Regular files shall always poll TRUE for reading and writing.

       A file descriptor for a socket that is listening for connections shall indicate  that  it  is  ready  for
       reading, once connections are available. A file descriptor for a socket that is connecting asynchronously
       shall indicate that it is ready for writing, once a connection has been established.

RETURN VALUE

       Upon successful completion, poll() shall return a non-negative value.  A  positive  value  indicates  the
       total number of file descriptors that have been selected (that is, file descriptors for which the revents
       member is non-zero). A value of 0 indicates that the call timed out and no  file  descriptors  have  been
       selected. Upon failure, poll() shall return -1 and set errno to indicate the error.

ERRORS

       The poll() function shall fail if:

       EAGAIN The allocation of internal data structures failed but a subsequent request may succeed.

       EINTR  A signal was caught during poll().

       EINVAL The  nfds  argument  is greater than {OPEN_MAX},    or one of the fd members refers to a STREAM or
              multiplexer that is linked (directly or indirectly) downstream from a multiplexer.

       The following sections are informative.

EXAMPLES

   Checking for Events on a Stream
       The following example opens a pair of STREAMS devices and then waits for either one to  become  writable.
       This example proceeds as follows:

        1. Sets the timeout parameter to 500 milliseconds.

        2. Opens  the  STREAMS  devices  /dev/dev0  and  /dev/dev1,  and then polls them, specifying POLLOUT and
           POLLWRBAND as the events of interest.

       The STREAMS device names /dev/dev0 and /dev/dev1 are only examples of how STREAMS devices can  be  named;
       STREAMS naming conventions may vary among systems conforming to the IEEE Std 1003.1-2001.

        3. Uses  the  ret  variable to determine whether an event has occurred on either of the two STREAMS. The
           poll() function is given 500 milliseconds to wait for an event to occur (if it has not occurred prior
           to the poll() call).

        4. Checks the returned value of ret. If a positive value is returned, one of the following can be done:

            a. Priority  data  can  be  written to the open STREAM on priority bands greater than 0, because the
               POLLWRBAND event occurred on the open STREAM ( fds[0] or fds[1]).

            b. Data can be written to the open STREAM on priority-band 0, because the POLLOUT event occurred  on
               the open STREAM ( fds[0] or fds[1]).

        5. If  the  returned  value is not a positive value, permission to write data to the open STREAM (on any
           priority band) is denied.

        6. If the POLLHUP event occurs on the open STREAM ( fds[0] or fds[1]), the device on the open STREAM has
           disconnected.

              #include <stropts.h>
              #include <poll.h>
              ...
              struct pollfd fds[2];
              int timeout_msecs = 500;
              int ret;
                  int i;

              /* Open STREAMS device. */
              fds[0].fd = open("/dev/dev0", ...);
              fds[1].fd = open("/dev/dev1", ...);
                  fds[0].events = POLLOUT | POLLWRBAND;
                  fds[1].events = POLLOUT | POLLWRBAND;

              ret = poll(fds, 2, timeout_msecs);

              if (ret > 0) {
                  /* An event on one of the fds has occurred. */
                  for (i=0; i<2; i++) {
                      if (fds[i].revents & POLLWRBAND) {
                      /* Priority data may be written on device number i. */
              ...
                      }
                      if (fds[i].revents & POLLOUT) {
                      /* Data may be written on device number i. */
              ...
                      }
                      if (fds[i].revents & POLLHUP) {
                      /* A hangup has occurred on device number i. */
              ...
                      }
                  }
              }

APPLICATION USAGE

       None.

RATIONALE

       None.

FUTURE DIRECTIONS

       None.

SEE ALSO

       STREAMS  ,  getmsg()  ,  putmsg()  ,  read()  ,  select()  ,  write()  ,  the  Base Definitions volume of
       IEEE Std 1003.1-2001, <poll.h>, <stropts.h>

       Portions of this text are reprinted and reproduced in electronic form from IEEE Std 1003.1, 2003 Edition,
       Standard  for  Information Technology -- Portable Operating System Interface (POSIX), The Open Group Base
       Specifications Issue 6, Copyright (C) 2001-2003 by the Institute of Electrical and Electronics Engineers,
       Inc  and  The  Open Group. In the event of any discrepancy between this version and the original IEEE and
       The Open Group Standard, the original IEEE and The Open Group  Standard  is  the  referee  document.  The
       original Standard can be obtained online at http://www.opengroup.org/unix/online.html .