Skip to content
This repository has been archived by the owner. It is now read-only.
Permalink
Browse files

Unix: implement uv_poll

  • Loading branch information
piscisaureus committed May 2, 2012
1 parent 87b7e29 commit 7e8ab521b842da3233bade3aa9b305d1d99e9fcc
Showing with 152 additions and 0 deletions.
  1. +1 −0 config-unix.mk
  2. +7 −0 include/uv-private/uv-unix.h
  3. +9 −0 src/unix/core.c
  4. +4 −0 src/unix/internal.h
  5. +130 −0 src/unix/poll.c
  6. +1 −0 uv.gyp
@@ -37,6 +37,7 @@ OBJS += src/unix/fs.o
OBJS += src/unix/idle.o
OBJS += src/unix/loop.o
OBJS += src/unix/pipe.o
OBJS += src/unix/poll.o
OBJS += src/unix/prepare.o
OBJS += src/unix/process.o
OBJS += src/unix/stream.o
@@ -45,6 +45,8 @@ typedef struct {

typedef int uv_file;

typedef int uv_platform_socket_t;

This comment has been minimized.

Copy link
@bnoordhuis

bnoordhuis May 3, 2012

Contributor

So wordy... What about uv_sock_t or uv_socket_t?


#define UV_ONCE_INIT PTHREAD_ONCE_INIT

typedef pthread_once_t uv_once_t;
@@ -162,6 +164,11 @@ typedef void* uv_lib_t;
const char* pipe_fname; /* strdup'ed */


/* UV_POLL */
#define UV_POLL_PRIVATE_FIELDS \
ev_io io_watcher;


/* UV_PREPARE */ \
#define UV_PREPARE_PRIVATE_FIELDS \
ev_prepare prepare_watcher; \
@@ -107,6 +107,10 @@ void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
uv__fs_event_close((uv_fs_event_t*)handle);
break;

case UV_POLL:
uv__poll_close((uv_poll_t*)handle);
break;

default:
assert(0);
}
@@ -249,6 +253,9 @@ void uv__finish_close(uv_handle_t* handle) {
case UV_FS_EVENT:
break;

case UV_POLL:
break;

default:
assert(0);
break;
@@ -285,6 +292,8 @@ int64_t uv_now(uv_loop_t* loop) {

int uv_is_active(const uv_handle_t* handle) {
switch (handle->type) {
case UV_POLL:
return uv__poll_active((const uv_poll_t*)handle);
case UV_CHECK:
return uv__check_active((const uv_check_t*)handle);
case UV_IDLE:
@@ -141,6 +141,10 @@ int uv__tcp_keepalive(uv_tcp_t* handle, int enable, unsigned int delay);
int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb);
void uv__pipe_accept(EV_P_ ev_io* watcher, int revents);

/* poll */
void uv__poll_close(uv_poll_t* handle);
int uv__poll_active(const uv_poll_t* handle);

/* various */
int uv__check_active(const uv_check_t* handle);
int uv__idle_active(const uv_idle_t* handle);
@@ -0,0 +1,130 @@
/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/

#include "uv.h"
#include "internal.h"

#include <unistd.h>
#include <assert.h>
#include <errno.h>


static void uv__poll_io(EV_P_ ev_io* watcher, int ev_events) {
uv_poll_t* handle = watcher->data;
int events;

if (ev_events & EV_ERROR) {
/* An error happened. Libev has implicitly stopped the watcher, but we */
/* need to fix the refcount. */
uv_ref(handle->loop);
uv__set_sys_error(handle->loop, EBADF);
handle->poll_cb(handle, -1, 0);
return;
}

assert(ev_events & (EV_READ | EV_WRITE));
assert((ev_events & ~(EV_READ | EV_WRITE)) == 0);

events = 0;
if (ev_events & EV_READ)
events |= UV_READABLE;
if (ev_events & EV_WRITE)
events |= UV_WRITABLE;

handle->poll_cb(handle, 0, events);
}


int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd) {
uv__handle_init(loop, (uv_handle_t*) handle, UV_POLL);
loop->counters.poll_init++;

handle->fd = fd;
handle->poll_cb = NULL;

ev_init(&handle->io_watcher, uv__poll_io);
handle->io_watcher.data = handle;

return 0;
}


int uv_poll_init_socket(uv_loop_t* loop, uv_poll_t* handle,
uv_platform_socket_t socket) {
return uv_poll_init(loop, handle, socket);
}


static void uv__poll_stop(uv_poll_t* handle) {
if (ev_is_active(&handle->io_watcher)) {
ev_io_stop(handle->loop->ev, &handle->io_watcher);
uv_ref(handle->loop);
}
}


int uv_poll_stop(uv_poll_t* handle) {
assert(!(handle->flags & (UV_CLOSING | UV_CLOSED)));
uv__poll_stop(handle);
return 0;
}


int uv_poll_start(uv_poll_t* handle, int events, uv_poll_cb poll_cb) {
int ev_events;
int was_active;

assert((events & ~(UV_READABLE | UV_WRITABLE)) == 0);
assert(!(handle->flags & (UV_CLOSING | UV_CLOSED)));

if (events == 0) {
uv__poll_stop(handle);
return 0;
}

ev_events = 0;
if (events & UV_READABLE)
ev_events |= EV_READ;
if (events & UV_WRITABLE)
ev_events |= EV_WRITE;

was_active = ev_is_active(&handle->io_watcher);

ev_io_set(&handle->io_watcher, handle->fd, ev_events);
ev_io_start(handle->loop->ev, &handle->io_watcher);

if (!was_active)
uv_unref(handle->loop);

handle->poll_cb = poll_cb;

return 0;
}


void uv__poll_close(uv_poll_t* handle) {
uv__poll_stop(handle);
}


int uv__poll_active(const uv_poll_t* handle) {
return ev_is_active(&handle->io_watcher);
}
1 uv.gyp
@@ -199,6 +199,7 @@
'src/unix/internal.h',
'src/unix/loop.c',
'src/unix/pipe.c',
'src/unix/poll.c',
'src/unix/prepare.c',
'src/unix/process.c',
'src/unix/stream.c',

1 comment on commit 7e8ab52

@bnoordhuis

This comment has been minimized.

Copy link
Contributor

bnoordhuis commented on 7e8ab52 May 3, 2012

LGTM

Please sign in to comment.
You can’t perform that action at this time.