poll.c File Reference

#include <assert.h>
#include <io.h>
#include "uv.h"
#include "internal.h"
#include "handle-inl.h"
#include "req-inl.h"

Go to the source code of this file.

Classes
struct	uv_single_fd_set_s

Typedefs
typedef struct uv_single_fd_set_s	uv_single_fd_set_t

Functions
static void	uv__init_overlapped_dummy (void)
static OVERLAPPED *	uv__get_overlapped_dummy (void)
static AFD_POLL_INFO *	uv__get_afd_poll_info_dummy (void)
static void	uv__fast_poll_submit_poll_req (uv_loop_t *loop, uv_poll_t *handle)
static void	uv__fast_poll_process_poll_req (uv_loop_t *loop, uv_poll_t *handle, uv_req_t *req)
static SOCKET	uv__fast_poll_create_peer_socket (HANDLE iocp, WSAPROTOCOL_INFOW *protocol_info)
static SOCKET	uv__fast_poll_get_peer_socket (uv_loop_t *loop, WSAPROTOCOL_INFOW *protocol_info)
static DWORD WINAPI	uv__slow_poll_thread_proc (void *arg)
static void	uv__slow_poll_submit_poll_req (uv_loop_t *loop, uv_poll_t *handle)
static void	uv__slow_poll_process_poll_req (uv_loop_t *loop, uv_poll_t *handle, uv_req_t *req)
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 int	uv__poll_set (uv_poll_t *handle, int events, uv_poll_cb cb)
int	uv_poll_start (uv_poll_t *handle, int events, uv_poll_cb cb)
int	uv_poll_stop (uv_poll_t *handle)
void	uv_process_poll_req (uv_loop_t *loop, uv_poll_t *handle, uv_req_t *req)
int	uv_poll_close (uv_loop_t *loop, uv_poll_t *handle)
void	uv_poll_endgame (uv_loop_t *loop, uv_poll_t *handle)

Variables
static const GUID	uv_msafd_provider_ids [UV_MSAFD_PROVIDER_COUNT]
static OVERLAPPED	overlapped_dummy_
static uv_once_t	overlapped_dummy_init_guard_ = UV_ONCE_INIT
static AFD_POLL_INFO	afd_poll_info_dummy_

Typedef Documentation

uv_single_fd_set_t

typedef struct uv_single_fd_set_s uv_single_fd_set_t

Function Documentation

uv__fast_poll_create_peer_socket()

static SOCKET uv__fast_poll_create_peer_socket ( HANDLE  iocp, WSAPROTOCOL_INFOW *  protocol_info  )

static

Definition at line 203 of file poll.c.

                                      {
  SOCKET sock = 0;
 
  sock = WSASocketW(protocol_info->iAddressFamily,
                    protocol_info->iSocketType,
                    protocol_info->iProtocol,
                    protocol_info,
                    0,
                    WSA_FLAG_OVERLAPPED);
  if (sock == INVALID_SOCKET) {
    return INVALID_SOCKET;
  }
 
  if (!SetHandleInformation((HANDLE) sock, HANDLE_FLAG_INHERIT, 0)) {
    goto error;
  };
 
  if (CreateIoCompletionPort((HANDLE) sock,
                             iocp,
                             (ULONG_PTR) sock,
                             0) == NULL) {
    goto error;
  }
 
  return sock;
 
 error:
  closesocket(sock);
  return INVALID_SOCKET;
}

References error(), HANDLE, and NULL.

Referenced by uv__fast_poll_get_peer_socket().

uv__fast_poll_get_peer_socket()

static SOCKET uv__fast_poll_get_peer_socket ( uv_loop_t *  loop, WSAPROTOCOL_INFOW *  protocol_info  )

static

Definition at line 236 of file poll.c.

                                      {
  int index, i;
  SOCKET peer_socket;
 
  index = -1;
  for (i = 0; (size_t) i < ARRAY_SIZE(uv_msafd_provider_ids); i++) {
    if (memcmp((void*) &protocol_info->ProviderId,
               (void*) &uv_msafd_provider_ids[i],
               sizeof protocol_info->ProviderId) == 0) {
      index = i;
    }
  }
 
  /* Check if the protocol uses an msafd socket. */
  if (index < 0) {
    return INVALID_SOCKET;
  }
 
  /* If we didn't (try) to create a peer socket yet, try to make one. Don't try
   * again if the peer socket creation failed earlier for the same protocol. */
  peer_socket = loop->poll_peer_sockets[index];
  if (peer_socket == 0) {
    peer_socket = uv__fast_poll_create_peer_socket(loop->iocp, protocol_info);
    loop->poll_peer_sockets[index] = peer_socket;
  }
 
  return peer_socket;
}

References ARRAY_SIZE, i, loop, uv__fast_poll_create_peer_socket(), and uv_msafd_provider_ids.

Referenced by uv_poll_init_socket().

uv__fast_poll_process_poll_req()

static void uv__fast_poll_process_poll_req ( uv_loop_t *  loop, uv_poll_t *  handle, uv_req_t *  req  )

static

Definition at line 137 of file poll.c.

                   {
  unsigned char mask_events;
  AFD_POLL_INFO* afd_poll_info;
 
  if (req == &handle->poll_req_1) {
    afd_poll_info = &handle->afd_poll_info_1;
    handle->submitted_events_1 = 0;
    mask_events = handle->mask_events_1;
  } else if (req == &handle->poll_req_2) {
    afd_poll_info = &handle->afd_poll_info_2;
    handle->submitted_events_2 = 0;
    mask_events = handle->mask_events_2;
  } else {
    assert(0);
    return;
  }
 
  /* Report an error unless the select was just interrupted. */
  if (!REQ_SUCCESS(req)) {
    DWORD error = GET_REQ_SOCK_ERROR(req);
    if (error != WSAEINTR && handle->events != 0) {
      handle->events = 0; /* Stop the watcher */
      handle->poll_cb(handle, uv_translate_sys_error(error), 0);
    }
 
  } else if (afd_poll_info->NumberOfHandles >= 1) {
    unsigned char events = 0;
 
    if ((afd_poll_info->Handles[0].Events & (AFD_POLL_RECEIVE |
        AFD_POLL_DISCONNECT | AFD_POLL_ACCEPT | AFD_POLL_ABORT)) != 0) {
      events |= UV_READABLE;
      if ((afd_poll_info->Handles[0].Events & AFD_POLL_DISCONNECT) != 0) {
        events |= UV_DISCONNECT;
      }
    }
    if ((afd_poll_info->Handles[0].Events & (AFD_POLL_SEND |
        AFD_POLL_CONNECT_FAIL)) != 0) {
      events |= UV_WRITABLE;
    }
 
    events &= handle->events & ~mask_events;
 
    if (afd_poll_info->Handles[0].Events & AFD_POLL_LOCAL_CLOSE) {
      /* Stop polling. */
      handle->events = 0;
      if (uv__is_active(handle))
        uv__handle_stop(handle);
    }
 
    if (events != 0) {
      handle->poll_cb(handle, 0, events);
    }
  }
 
  if ((handle->events & ~(handle->submitted_events_1 |
      handle->submitted_events_2)) != 0) {
    uv__fast_poll_submit_poll_req(loop, handle);
  } else if ((handle->flags & UV_HANDLE_CLOSING) &&
             handle->submitted_events_1 == 0 &&
             handle->submitted_events_2 == 0) {
    uv_want_endgame(loop, (uv_handle_t*) handle);
  }
}

References AFD_POLL_ABORT, AFD_POLL_ACCEPT, AFD_POLL_CONNECT_FAIL, AFD_POLL_DISCONNECT, AFD_POLL_LOCAL_CLOSE, AFD_POLL_RECEIVE, AFD_POLL_SEND, assert(), DWORD, error(), _AFD_POLL_HANDLE_INFO::Events, GET_REQ_SOCK_ERROR, handle, _AFD_POLL_INFO::Handles, loop, _AFD_POLL_INFO::NumberOfHandles, req, REQ_SUCCESS, uv__fast_poll_submit_poll_req(), uv__handle_stop, uv__is_active, UV_DISCONNECT, UV_HANDLE_CLOSING, UV_READABLE, uv_translate_sys_error(), uv_want_endgame(), and UV_WRITABLE.

Referenced by uv_process_poll_req().

uv__fast_poll_submit_poll_req()

static void uv__fast_poll_submit_poll_req ( uv_loop_t *  loop, uv_poll_t *  handle  )

static

Definition at line 75 of file poll.c.

                                                                              {
  uv_req_t* req;
  AFD_POLL_INFO* afd_poll_info;
  int result;
 
  /* Find a yet unsubmitted req to submit. */
  if (handle->submitted_events_1 == 0) {
    req = &handle->poll_req_1;
    afd_poll_info = &handle->afd_poll_info_1;
    handle->submitted_events_1 = handle->events;
    handle->mask_events_1 = 0;
    handle->mask_events_2 = handle->events;
  } else if (handle->submitted_events_2 == 0) {
    req = &handle->poll_req_2;
    afd_poll_info = &handle->afd_poll_info_2;
    handle->submitted_events_2 = handle->events;
    handle->mask_events_1 = handle->events;
    handle->mask_events_2 = 0;
  } else {
    /* Just wait until there's an unsubmitted req. This will happen almost
     * immediately as one of the 2 outstanding requests is about to return.
     * When this happens, uv__fast_poll_process_poll_req will be called, and
     * the pending events, if needed, will be processed in a subsequent
     * request. */
    return;
  }
 
  /* Setting Exclusive to TRUE makes the other poll request return if there is
   * any. */
  afd_poll_info->Exclusive = TRUE;
  afd_poll_info->NumberOfHandles = 1;
  afd_poll_info->Timeout.QuadPart = INT64_MAX;
  afd_poll_info->Handles[0].Handle = (HANDLE) handle->socket;
  afd_poll_info->Handles[0].Status = 0;
  afd_poll_info->Handles[0].Events = 0;
 
  if (handle->events & UV_READABLE) {
    afd_poll_info->Handles[0].Events |= AFD_POLL_RECEIVE |
        AFD_POLL_DISCONNECT | AFD_POLL_ACCEPT | AFD_POLL_ABORT;
  } else {
    if (handle->events & UV_DISCONNECT) {
      afd_poll_info->Handles[0].Events |= AFD_POLL_DISCONNECT;
    }
  }
  if (handle->events & UV_WRITABLE) {
    afd_poll_info->Handles[0].Events |= AFD_POLL_SEND | AFD_POLL_CONNECT_FAIL;
  }
 
  memset(&req->u.io.overlapped, 0, sizeof req->u.io.overlapped);
 
  result = uv_msafd_poll((SOCKET) handle->peer_socket,
                         afd_poll_info,
                         afd_poll_info,
                         &req->u.io.overlapped);
  if (result != 0 && WSAGetLastError() != WSA_IO_PENDING) {
    /* Queue this req, reporting an error. */
    SET_REQ_ERROR(req, WSAGetLastError());
    uv_insert_pending_req(loop, req);
  }
}

References AFD_POLL_ABORT, AFD_POLL_ACCEPT, AFD_POLL_CONNECT_FAIL, AFD_POLL_DISCONNECT, AFD_POLL_RECEIVE, AFD_POLL_SEND, _AFD_POLL_HANDLE_INFO::Events, _AFD_POLL_INFO::Exclusive, handle, HANDLE, _AFD_POLL_HANDLE_INFO::Handle, _AFD_POLL_INFO::Handles, if(), INT64_MAX, loop, memset(), _AFD_POLL_INFO::NumberOfHandles, req, SET_REQ_ERROR, _AFD_POLL_HANDLE_INFO::Status, _AFD_POLL_INFO::Timeout, TRUE, UV_DISCONNECT, uv_insert_pending_req(), uv_msafd_poll(), UV_READABLE, and UV_WRITABLE.

Referenced by uv__fast_poll_process_poll_req(), and uv__poll_set().

uv__get_afd_poll_info_dummy()

static AFD_POLL_INFO* uv__get_afd_poll_info_dummy ( void  )

static

Definition at line 70 of file poll.c.

                                                        {
  return &afd_poll_info_dummy_;
}

References afd_poll_info_dummy_.

Referenced by uv_poll_close().

uv__get_overlapped_dummy()

static OVERLAPPED* uv__get_overlapped_dummy ( void  )

static

Definition at line 64 of file poll.c.

                                                  {
  uv_once(&overlapped_dummy_init_guard_, uv__init_overlapped_dummy);
  return &overlapped_dummy_;
}

References overlapped_dummy_, overlapped_dummy_init_guard_, uv__init_overlapped_dummy(), and uv_once().

Referenced by uv_poll_close().

uv__init_overlapped_dummy()

static void uv__init_overlapped_dummy ( void  )

static

Definition at line 52 of file poll.c.

                                            {
  HANDLE event;
 
  event = CreateEvent(NULL, TRUE, TRUE, NULL);
  if (event == NULL)
    uv_fatal_error(GetLastError(), "CreateEvent");
 
  memset(&overlapped_dummy_, 0, sizeof overlapped_dummy_);
  overlapped_dummy_.hEvent = (HANDLE) ((uintptr_t) event | 1);
}

References HANDLE, memset(), NULL, overlapped_dummy_, TRUE, and uv_fatal_error().

Referenced by uv__get_overlapped_dummy().

uv__poll_set()

static int uv__poll_set ( uv_poll_t *  handle, int  events, uv_poll_cb  cb  )

static

Definition at line 486 of file poll.c.

                                                                      {
  int submitted_events;
 
  assert(handle->type == UV_POLL);
  assert(!(handle->flags & UV_HANDLE_CLOSING));
  assert((events & ~(UV_READABLE | UV_WRITABLE | UV_DISCONNECT)) == 0);
 
  handle->events = events;
  handle->poll_cb = cb;
 
  if (handle->events == 0) {
    uv__handle_stop(handle);
    return 0;
  }
 
  uv__handle_start(handle);
  submitted_events = handle->submitted_events_1 | handle->submitted_events_2;
 
  if (handle->events & ~submitted_events) {
    if (handle->flags & UV_HANDLE_POLL_SLOW) {
      uv__slow_poll_submit_poll_req(handle->loop, handle);
    } else {
      uv__fast_poll_submit_poll_req(handle->loop, handle);
    }
  }
 
  return 0;
}

References assert(), cb, handle, uv__fast_poll_submit_poll_req(), uv__handle_start, uv__handle_stop, uv__slow_poll_submit_poll_req(), UV_DISCONNECT, UV_HANDLE_CLOSING, UV_HANDLE_POLL_SLOW, UV_READABLE, and UV_WRITABLE.

Referenced by uv_poll_start(), and uv_poll_stop().

uv__slow_poll_process_poll_req()

static void uv__slow_poll_process_poll_req ( uv_loop_t *  loop, uv_poll_t *  handle, uv_req_t *  req  )

static

Definition at line 366 of file poll.c.

                   {
  unsigned char mask_events;
  int err;
 
  if (req == &handle->poll_req_1) {
    handle->submitted_events_1 = 0;
    mask_events = handle->mask_events_1;
  } else if (req == &handle->poll_req_2) {
    handle->submitted_events_2 = 0;
    mask_events = handle->mask_events_2;
  } else {
    assert(0);
    return;
  }
 
  if (!REQ_SUCCESS(req)) {
    /* Error. */
    if (handle->events != 0) {
      err = GET_REQ_ERROR(req);
      handle->events = 0; /* Stop the watcher */
      handle->poll_cb(handle, uv_translate_sys_error(err), 0);
    }
  } else {
    /* Got some events. */
    int events = req->u.io.overlapped.InternalHigh & handle->events & ~mask_events;
    if (events != 0) {
      handle->poll_cb(handle, 0, events);
    }
  }
 
  if ((handle->events & ~(handle->submitted_events_1 |
      handle->submitted_events_2)) != 0) {
    uv__slow_poll_submit_poll_req(loop, handle);
  } else if ((handle->flags & UV_HANDLE_CLOSING) &&
             handle->submitted_events_1 == 0 &&
             handle->submitted_events_2 == 0) {
    uv_want_endgame(loop, (uv_handle_t*) handle);
  }
}

References assert(), err, GET_REQ_ERROR, handle, loop, req, REQ_SUCCESS, uv__slow_poll_submit_poll_req(), UV_HANDLE_CLOSING, uv_translate_sys_error(), and uv_want_endgame().

Referenced by uv_process_poll_req().

uv__slow_poll_submit_poll_req()

static void uv__slow_poll_submit_poll_req ( uv_loop_t *  loop, uv_poll_t *  handle  )

static

Definition at line 336 of file poll.c.

                                                                              {
  uv_req_t* req;
 
  /* Find a yet unsubmitted req to submit. */
  if (handle->submitted_events_1 == 0) {
    req = &handle->poll_req_1;
    handle->submitted_events_1 = handle->events;
    handle->mask_events_1 = 0;
    handle->mask_events_2 = handle->events;
  } else if (handle->submitted_events_2 == 0) {
    req = &handle->poll_req_2;
    handle->submitted_events_2 = handle->events;
    handle->mask_events_1 = handle->events;
    handle->mask_events_2 = 0;
  } else {
    assert(0);
    return;
  }
 
  if (!QueueUserWorkItem(uv__slow_poll_thread_proc,
                         (void*) req,
                         WT_EXECUTELONGFUNCTION)) {
    /* Make this req pending, reporting an error. */
    SET_REQ_ERROR(req, GetLastError());
    uv_insert_pending_req(loop, req);
  }
}

References assert(), handle, loop, req, SET_REQ_ERROR, uv__slow_poll_thread_proc(), and uv_insert_pending_req().

Referenced by uv__poll_set(), and uv__slow_poll_process_poll_req().

uv__slow_poll_thread_proc()

static DWORD WINAPI uv__slow_poll_thread_proc ( void *  arg )

static

Definition at line 267 of file poll.c.

                                                         {
  uv_req_t* req = (uv_req_t*) arg;
  uv_poll_t* handle = (uv_poll_t*) req->data;
  unsigned char reported_events;
  int r;
  uv_single_fd_set_t rfds, wfds, efds;
  struct timeval timeout;
 
  assert(handle->type == UV_POLL);
  assert(req->type == UV_POLL_REQ);
 
  if (handle->events & UV_READABLE) {
    rfds.fd_count = 1;
    rfds.fd_array[0] = handle->socket;
  } else {
    rfds.fd_count = 0;
  }
 
  if (handle->events & UV_WRITABLE) {
    wfds.fd_count = 1;
    wfds.fd_array[0] = handle->socket;
    efds.fd_count = 1;
    efds.fd_array[0] = handle->socket;
  } else {
    wfds.fd_count = 0;
    efds.fd_count = 0;
  }
 
  /* Make the select() time out after 3 minutes. If select() hangs because the
   * user closed the socket, we will at least not hang indefinitely. */
  timeout.tv_sec = 3 * 60;
  timeout.tv_usec = 0;
 
  r = select(1, (fd_set*) &rfds, (fd_set*) &wfds, (fd_set*) &efds, &timeout);
  if (r == SOCKET_ERROR) {
    /* Queue this req, reporting an error. */
    SET_REQ_ERROR(&handle->poll_req_1, WSAGetLastError());
    POST_COMPLETION_FOR_REQ(handle->loop, req);
    return 0;
  }
 
  reported_events = 0;
 
  if (r > 0) {
    if (rfds.fd_count > 0) {
      assert(rfds.fd_count == 1);
      assert(rfds.fd_array[0] == handle->socket);
      reported_events |= UV_READABLE;
    }
 
    if (wfds.fd_count > 0) {
      assert(wfds.fd_count == 1);
      assert(wfds.fd_array[0] == handle->socket);
      reported_events |= UV_WRITABLE;
    } else if (efds.fd_count > 0) {
      assert(efds.fd_count == 1);
      assert(efds.fd_array[0] == handle->socket);
      reported_events |= UV_WRITABLE;
    }
  }
 
  SET_REQ_SUCCESS(req);
  req->u.io.overlapped.InternalHigh = (DWORD) reported_events;
  POST_COMPLETION_FOR_REQ(handle->loop, req);
 
  return 0;
}

References assert(), DWORD, handle, POST_COMPLETION_FOR_REQ, r, req, select, SET_REQ_ERROR, SET_REQ_SUCCESS, timeout, UV_READABLE, and UV_WRITABLE.

Referenced by uv__slow_poll_submit_poll_req().

uv_poll_close()

int uv_poll_close	(	uv_loop_t *	loop,
		uv_poll_t *	handle
	)

Definition at line 535 of file poll.c.

                                                      {
  AFD_POLL_INFO afd_poll_info;
  DWORD error;
  int result;
 
  handle->events = 0;
  uv__handle_closing(handle);
 
  if (handle->submitted_events_1 == 0 &&
      handle->submitted_events_2 == 0) {
    uv_want_endgame(loop, (uv_handle_t*) handle);
    return 0;
  }
 
  if (handle->flags & UV_HANDLE_POLL_SLOW)
    return 0;
 
  /* Cancel outstanding poll requests by executing another, unique poll
   * request that forces the outstanding ones to return. */
  afd_poll_info.Exclusive = TRUE;
  afd_poll_info.NumberOfHandles = 1;
  afd_poll_info.Timeout.QuadPart = INT64_MAX;
  afd_poll_info.Handles[0].Handle = (HANDLE) handle->socket;
  afd_poll_info.Handles[0].Status = 0;
  afd_poll_info.Handles[0].Events = AFD_POLL_ALL;
 
  result = uv_msafd_poll(handle->socket,
                         &afd_poll_info,
                         uv__get_afd_poll_info_dummy(),
                         uv__get_overlapped_dummy());
 
  if (result == SOCKET_ERROR) {
    error = WSAGetLastError();
    if (error != WSA_IO_PENDING)
      return uv_translate_sys_error(error);
  }
 
  return 0;
}

References AFD_POLL_ALL, DWORD, error(), _AFD_POLL_HANDLE_INFO::Events, _AFD_POLL_INFO::Exclusive, handle, HANDLE, _AFD_POLL_HANDLE_INFO::Handle, _AFD_POLL_INFO::Handles, INT64_MAX, loop, _AFD_POLL_INFO::NumberOfHandles, _AFD_POLL_HANDLE_INFO::Status, _AFD_POLL_INFO::Timeout, TRUE, uv__get_afd_poll_info_dummy(), uv__get_overlapped_dummy(), uv__handle_closing, UV_HANDLE_POLL_SLOW, uv_msafd_poll(), uv_translate_sys_error(), and uv_want_endgame().

Referenced by uv_close().

uv_poll_endgame()

void uv_poll_endgame	(	uv_loop_t *	loop,
		uv_poll_t *	handle
	)

Definition at line 576 of file poll.c.

                                                         {
  assert(handle->flags & UV_HANDLE_CLOSING);
  assert(!(handle->flags & UV_HANDLE_CLOSED));
 
  assert(handle->submitted_events_1 == 0);
  assert(handle->submitted_events_2 == 0);
 
  uv__handle_close(handle);
}

References assert(), handle, uv__handle_close, UV_HANDLE_CLOSED, and UV_HANDLE_CLOSING.

Referenced by uv_process_endgames().

uv_poll_init()

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

Definition at line 408 of file poll.c.

                                                             {
  return uv_poll_init_socket(loop, handle, (SOCKET) uv__get_osfhandle(fd));
}

References err, fd, handle, loop, NULL, uv__fd_exists(), uv__get_osfhandle(), uv__handle_init, uv__io_check_fd(), uv__io_init(), uv__nonblock, uv__nonblock_fcntl(), uv__nonblock_ioctl(), uv__poll_io(), and 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 413 of file poll.c.

                         {
  WSAPROTOCOL_INFOW protocol_info;
  int len;
  SOCKET peer_socket, base_socket;
  DWORD bytes;
  DWORD yes = 1;
 
  /* Set the socket to nonblocking mode */
  if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR)
    return uv_translate_sys_error(WSAGetLastError());
 
/* Try to obtain a base handle for the socket. This increases this chances that
 * we find an AFD handle and are able to use the fast poll mechanism. This will
 * always fail on windows XP/2k3, since they don't support the. SIO_BASE_HANDLE
 * ioctl. */
#ifndef NDEBUG
  base_socket = INVALID_SOCKET;
#endif
 
  if (WSAIoctl(socket,
               SIO_BASE_HANDLE,
               NULL,
               0,
               &base_socket,
               sizeof base_socket,
               &bytes,
               NULL,
               NULL) == 0) {
    assert(base_socket != 0 && base_socket != INVALID_SOCKET);
    socket = base_socket;
  }
 
  uv__handle_init(loop, (uv_handle_t*) handle, UV_POLL);
  handle->socket = socket;
  handle->events = 0;
 
  /* Obtain protocol information about the socket. */
  len = sizeof protocol_info;
  if (getsockopt(socket,
                 SOL_SOCKET,
                 SO_PROTOCOL_INFOW,
                 (char*) &protocol_info,
                 &len) != 0) {
    return uv_translate_sys_error(WSAGetLastError());
  }
 
  /* Get the peer socket that is needed to enable fast poll. If the returned
   * value is NULL, the protocol is not implemented by MSAFD and we'll have to
   * use slow mode. */
  peer_socket = uv__fast_poll_get_peer_socket(loop, &protocol_info);
 
  if (peer_socket != INVALID_SOCKET) {
    /* Initialize fast poll specific fields. */
    handle->peer_socket = peer_socket;
  } else {
    /* Initialize slow poll specific fields. */
    handle->flags |= UV_HANDLE_POLL_SLOW;
  }
 
  /* Initialize 2 poll reqs. */
  handle->submitted_events_1 = 0;
  UV_REQ_INIT(&handle->poll_req_1, UV_POLL_REQ);
  handle->poll_req_1.data = handle;
 
  handle->submitted_events_2 = 0;
  UV_REQ_INIT(&handle->poll_req_2, UV_POLL_REQ);
  handle->poll_req_2.data = handle;
 
  return 0;
}

References assert(), bytes, DWORD, FIONBIO, handle, len, loop, NULL, SIO_BASE_HANDLE, socket, SOL_SOCKET, uv__fast_poll_get_peer_socket(), uv__handle_init, UV_HANDLE_POLL_SLOW, uv_poll_init(), UV_REQ_INIT, and uv_translate_sys_error().

Referenced by create_curl_context().

uv_poll_start()

int uv_poll_start	(	uv_poll_t *	handle,
		int	events,
		uv_poll_cb	cb
	)

Definition at line 516 of file poll.c.

                                                                {
  return uv__poll_set(handle, events, cb);
}

References assert(), cb, handle, poll_cb(), uv__handle_start, uv__io_start(), uv__is_closing, uv__poll_set(), uv__poll_stop(), UV__POLLPRI, UV__POLLRDHUP, UV_DISCONNECT, UV_PRIORITIZED, UV_READABLE, and UV_WRITABLE.

Referenced by handle_socket().

uv_poll_stop()

int uv_poll_stop

(

uv_poll_t *

handle

)

Definition at line 521 of file poll.c.

                                    {
  return uv__poll_set(handle, 0, handle->poll_cb);
}

References assert(), handle, uv__is_closing, uv__poll_set(), and uv__poll_stop().

Referenced by handle_socket().

uv_process_poll_req()

void uv_process_poll_req	(	uv_loop_t *	loop,
		uv_poll_t *	handle,
		uv_req_t *	req
	)

Definition at line 526 of file poll.c.

                                                                            {
  if (!(handle->flags & UV_HANDLE_POLL_SLOW)) {
    uv__fast_poll_process_poll_req(loop, handle, req);
  } else {
    uv__slow_poll_process_poll_req(loop, handle, req);
  }
}

References handle, loop, req, uv__fast_poll_process_poll_req(), uv__slow_poll_process_poll_req(), and UV_HANDLE_POLL_SLOW.

Referenced by uv_process_reqs().

Variable Documentation

afd_poll_info_dummy_

AFD_POLL_INFO afd_poll_info_dummy_

static

Definition at line 49 of file poll.c.

Referenced by uv__get_afd_poll_info_dummy().

overlapped_dummy_

OVERLAPPED overlapped_dummy_

static

Definition at line 46 of file poll.c.

Referenced by uv__get_overlapped_dummy(), and uv__init_overlapped_dummy().

overlapped_dummy_init_guard_

uv_once_t overlapped_dummy_init_guard_ = UV_ONCE_INIT

static

Definition at line 47 of file poll.c.

Referenced by uv__get_overlapped_dummy().

uv_msafd_provider_ids

const GUID uv_msafd_provider_ids[UV_MSAFD_PROVIDER_COUNT]

static

Initial value:

= {
  {0xe70f1aa0, 0xab8b, 0x11cf,
      {0x8c, 0xa3, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}},
  {0xf9eab0c0, 0x26d4, 0x11d0,
      {0xbb, 0xbf, 0x00, 0xaa, 0x00, 0x6c, 0x34, 0xe4}},
  {0x9fc48064, 0x7298, 0x43e4,
      {0xb7, 0xbd, 0x18, 0x1f, 0x20, 0x89, 0x79, 0x2a}}
}

Definition at line 31 of file poll.c.

Referenced by uv__fast_poll_get_peer_socket().