poll.c File Reference

#include "uv.h"
#include "internal.h"
#include <unistd.h>
#include <assert.h>
#include <errno.h>

Go to the source code of this file.

Functions
static void	uv__poll_io (uv_loop_t *loop, uv__io_t *w, unsigned int events)
int	uv_poll_init (uv_loop_t *loop, uv_poll_t *handle, int fd)
int	uv_poll_init_socket (uv_loop_t *loop, uv_poll_t *handle, uv_os_sock_t socket)
static void	uv__poll_stop (uv_poll_t *handle)
int	uv_poll_stop (uv_poll_t *handle)
int	uv_poll_start (uv_poll_t *handle, int pevents, uv_poll_cb poll_cb)
void	uv__poll_close (uv_poll_t *handle)

Function Documentation

uv__poll_close()

void uv__poll_close

(

uv_poll_t *

handle

)

Definition at line 148 of file poll.c.

                                       {
  uv__poll_stop(handle);
}

References handle, and uv__poll_stop().

Referenced by uv_close().

uv__poll_io()

static void uv__poll_io ( uv_loop_t *  loop, uv__io_t *  w, unsigned int  events  )

static

Definition at line 30 of file poll.c.

                                                                           {
  uv_poll_t* handle;
  int pevents;
 
  handle = container_of(w, uv_poll_t, io_watcher);
 
  /*
   * As documented in the kernel source fs/kernfs/file.c #780
   * poll will return POLLERR|POLLPRI in case of sysfs
   * polling. This does not happen in case of out-of-band
   * TCP messages.
   *
   * The above is the case on (at least) FreeBSD and Linux.
   *
   * So to properly determine a POLLPRI or a POLLERR we need
   * to check for both.
   */
  if ((events & POLLERR) && !(events & UV__POLLPRI)) {
    uv__io_stop(loop, w, POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);
    uv__handle_stop(handle);
    handle->poll_cb(handle, UV_EBADF, 0);
    return;
  }
 
  pevents = 0;
  if (events & POLLIN)
    pevents |= UV_READABLE;
  if (events & UV__POLLPRI)
    pevents |= UV_PRIORITIZED;
  if (events & POLLOUT)
    pevents |= UV_WRITABLE;
  if (events & UV__POLLRDHUP)
    pevents |= UV_DISCONNECT;
 
  handle->poll_cb(handle, 0, pevents);
}

References container_of, handle, loop, uv__handle_stop, uv__io_stop(), UV__POLLPRI, UV__POLLRDHUP, UV_DISCONNECT, UV_PRIORITIZED, UV_READABLE, UV_WRITABLE, and w.

Referenced by uv_poll_init().

uv__poll_stop()

static void uv__poll_stop ( uv_poll_t *  handle )

static

Definition at line 102 of file poll.c.

                                             {
  uv__io_stop(handle->loop,
              &handle->io_watcher,
              POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);
  uv__handle_stop(handle);
  uv__platform_invalidate_fd(handle->loop, handle->io_watcher.fd);
}

References handle, uv__handle_stop, uv__io_stop(), uv__platform_invalidate_fd(), UV__POLLPRI, and UV__POLLRDHUP.

Referenced by uv__poll_close(), uv_poll_start(), and uv_poll_stop().

uv_poll_init()

int uv_poll_init	(	uv_loop_t *	loop,
		uv_poll_t *	handle,
		int	fd
	)

Definition at line 68 of file poll.c.

                                                             {
  int err;
 
  if (uv__fd_exists(loop, fd))
    return UV_EEXIST;
 
  err = uv__io_check_fd(loop, fd);
  if (err)
    return err;
 
  /* If ioctl(FIONBIO) reports ENOTTY, try fcntl(F_GETFL) + fcntl(F_SETFL).
   * Workaround for e.g. kqueue fds not supporting ioctls.
   */
  err = uv__nonblock(fd, 1);
  if (err == UV_ENOTTY)
    if (uv__nonblock == uv__nonblock_ioctl)
      err = uv__nonblock_fcntl(fd, 1);
 
  if (err)
    return err;
 
  uv__handle_init(loop, (uv_handle_t*) handle, UV_POLL);
  uv__io_init(&handle->io_watcher, uv__poll_io, fd);
  handle->poll_cb = NULL;
  return 0;
}

Referenced by uv_poll_init_socket().

uv_poll_init_socket()

int uv_poll_init_socket	(	uv_loop_t *	loop,
		uv_poll_t *	handle,
		uv_os_sock_t	socket
	)

Definition at line 96 of file poll.c.

                         {
  return uv_poll_init(loop, handle, socket);
}

Referenced by uv_poll_init().

uv_poll_start()

int uv_poll_start	(	uv_poll_t *	handle,
		int	pevents,
		uv_poll_cb	poll_cb
	)

Definition at line 118 of file poll.c.

                                                                      {
  int events;
 
  assert((pevents & ~(UV_READABLE | UV_WRITABLE | UV_DISCONNECT |
                      UV_PRIORITIZED)) == 0);
  assert(!uv__is_closing(handle));
 
  uv__poll_stop(handle);
 
  if (pevents == 0)
    return 0;
 
  events = 0;
  if (pevents & UV_READABLE)
    events |= POLLIN;
  if (pevents & UV_PRIORITIZED)
    events |= UV__POLLPRI;
  if (pevents & UV_WRITABLE)
    events |= POLLOUT;
  if (pevents & UV_DISCONNECT)
    events |= UV__POLLRDHUP;
 
  uv__io_start(handle->loop, &handle->io_watcher, events);
  uv__handle_start(handle);
  handle->poll_cb = poll_cb;
 
  return 0;
}

uv_poll_stop()

int uv_poll_stop

(

uv_poll_t *

handle

)

Definition at line 111 of file poll.c.

                                    {
  assert(!uv__is_closing(handle));
  uv__poll_stop(handle);
  return 0;
}