asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/ext/asyncengine/libuv/src/unix/sunos.c

@@ -28,7 +28,7 @@
 #include <assert.h>
 #include <errno.h>
 
-#ifdef SUNOS_HAVE_IFADDRS
+#ifndef SUNOS_NO_IFADDRS
 # include <ifaddrs.h>
 #endif
 #include <net/if.h>
@@ -42,6 +42,11 @@
 #if HAVE_PORTS_FS
 # include <sys/port.h>
 # include <port.h>
+
+# define PORT_FIRED 0x69
+# define PORT_UNUSED 0x0
+# define PORT_LOADED 0x99
+# define PORT_DELETED -1
 #endif
 
 #if (!defined(_LP64)) && (_FILE_OFFSET_BITS - 0 == 64)
@@ -70,7 +75,6 @@ uint64_t uv_hrtime() {
  */
 int uv_exepath(char* buffer, size_t* size) {
   ssize_t res;
-  pid_t pid;
   char buf[128];
 
   if (buffer == NULL)
@@ -79,8 +83,7 @@ int uv_exepath(char* buffer, size_t* size) {
   if (size == NULL)
     return (-1);
 
-  pid = getpid();
-  (void) snprintf(buf, sizeof (buf), "/proc/%d/path/a.out", pid);
+  (void) snprintf(buf, sizeof(buf), "/proc/%lu/path/a.out", (unsigned long) getpid());
   res = readlink(buf, buffer, *size - 1);
 
   if (res < 0)
@@ -109,36 +112,42 @@ void uv_loadavg(double avg[3]) {
 
 #if HAVE_PORTS_FS
 static void uv__fs_event_rearm(uv_fs_event_t *handle) {
-  if (port_associate(handle->fd,
+  if (handle->fd == -1)
+    return;
+
+  if (port_associate(handle->loop->fs_fd,
                      PORT_SOURCE_FILE,
                      (uintptr_t) &handle->fo,
                      FILE_ATTRIB | FILE_MODIFIED,
-                     NULL) == -1) {
+                     handle) == -1) {
     uv__set_sys_error(handle->loop, errno);
   }
+  handle->fd = PORT_LOADED;
 }
 
 
-static void uv__fs_event_read(EV_P_ ev_io* w, int revents) {
+static void uv__fs_event_read(uv_loop_t* loop, uv__io_t* w, int revents) {
   uv_fs_event_t *handle;
   timespec_t timeout;
   port_event_t pe;
   int events;
   int r;
 
-  handle = container_of(w, uv_fs_event_t, event_watcher);
+  (void) w;
+  (void) revents;
 
   do {
     /* TODO use port_getn() */
     do {
       memset(&timeout, 0, sizeof timeout);
-      r = port_get(handle->fd, &pe, &timeout);
+      r = port_get(loop->fs_fd, &pe, &timeout);
     }
     while (r == -1 && errno == EINTR);
 
     if (r == -1 && errno == ETIME)
       break;
 
+    handle = (uv_fs_event_t *)pe.portev_user;
     assert((r == 0) && "unexpected port_get() error");
 
     events = 0;
@@ -147,12 +156,12 @@ static void uv__fs_event_read(EV_P_ ev_io* w, int revents) {
     if (pe.portev_events & ~(FILE_ATTRIB | FILE_MODIFIED))
       events |= UV_RENAME;
     assert(events != 0);
-
+    handle->fd = PORT_FIRED;
     handle->cb(handle, NULL, events, 0);
   }
-  while (handle->fd != -1);
+  while (handle->fd != PORT_DELETED);
 
-  if (handle->fd != -1)
+  if (handle->fd != PORT_DELETED)
     uv__fs_event_rearm(handle);
 }
 
@@ -163,42 +172,49 @@ int uv_fs_event_init(uv_loop_t* loop,
                      uv_fs_event_cb cb,
                      int flags) {
   int portfd;
+  int first_run = 0;
 
   loop->counters.fs_event_init++;
 
   /* We don't support any flags yet. */
   assert(!flags);
-
-  if ((portfd = port_create()) == -1) {
-    uv__set_sys_error(loop, errno);
-    return -1;
+  if (loop->fs_fd == -1) {
+    if ((portfd = port_create()) == -1) {
+      uv__set_sys_error(loop, errno);
+      return -1;
+    }
+    loop->fs_fd = portfd;
+    first_run = 1;
   }
 
   uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
+  uv__handle_start(handle); /* FIXME shouldn't start automatically */
   handle->filename = strdup(filename);
-  handle->fd = portfd;
+  handle->fd = PORT_UNUSED;
   handle->cb = cb;
 
   memset(&handle->fo, 0, sizeof handle->fo);
   handle->fo.fo_name = handle->filename;
   uv__fs_event_rearm(handle);
 
-  ev_io_init(&handle->event_watcher, uv__fs_event_read, portfd, EV_READ);
-  ev_io_start(loop->ev, &handle->event_watcher);
-  ev_unref(loop->ev);
+  if (first_run) {
+    uv__io_init(&loop->fs_event_watcher, uv__fs_event_read, portfd, UV__IO_READ);
+    uv__io_start(loop, &loop->fs_event_watcher);
+  }
 
   return 0;
 }
 
 
 void uv__fs_event_close(uv_fs_event_t* handle) {
-  ev_ref(handle->loop->ev);
-  ev_io_stop(handle->loop->ev, &handle->event_watcher);
-  close(handle->fd);
-  handle->fd = -1;
+  if (handle->fd == PORT_FIRED) {
+    port_dissociate(handle->loop->fs_fd, PORT_SOURCE_FILE, (uintptr_t)&handle->fo);
+  }
+  handle->fd = PORT_DELETED;
   free(handle->filename);
   handle->filename = NULL;
   handle->fo.fo_name = NULL;
+  uv__handle_stop(handle);
 }
 
 #else /* !HAVE_PORTS_FS */
@@ -315,14 +331,6 @@ uv_err_t uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {
   lookup_instance = 0;
   while ((ksp = kstat_lookup(kc, (char *)"cpu_info", lookup_instance, NULL))) {
     if (kstat_read(kc, ksp, NULL) == -1) {
-      /*
-       * It is deeply annoying, but some kstats can return errors
-       * under otherwise routine conditions.  (ACPI is one
-       * offender; there are surely others.)  To prevent these
-       * fouled kstats from completely ruining our day, we assign
-       * an "error" member to the return value that consists of
-       * the strerror().
-       */
       cpu_info->speed = 0;
       cpu_info->model = NULL;
     } else {
@@ -332,7 +340,7 @@ uv_err_t uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {
 
       knp = (kstat_named_t *) kstat_data_lookup(ksp, (char *)"brand");
       assert(knp->data_type == KSTAT_DATA_STRING);
-      cpu_info->model = KSTAT_NAMED_STR_PTR(knp);
+      cpu_info->model = strdup(KSTAT_NAMED_STR_PTR(knp));
     }
 
     lookup_instance++;
@@ -391,7 +399,7 @@ void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count) {
 
 uv_err_t uv_interface_addresses(uv_interface_address_t** addresses,
   int* count) {
-#ifndef SUNOS_HAVE_IFADDRS
+#ifdef SUNOS_NO_IFADDRS
   return uv__new_artificial_error(UV_ENOSYS);
 #else
   struct ifaddrs *addrs, *ent;
@@ -424,7 +432,8 @@ uv_err_t uv_interface_addresses(uv_interface_address_t** addresses,
   address = *addresses;
 
   for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
-    bzero(&ip, sizeof (ip));
+    memset(&ip, 0, sizeof(ip));
+
     if (!(ent->ifa_flags & IFF_UP && ent->ifa_flags & IFF_RUNNING)) {
       continue;
     }
@@ -450,7 +459,7 @@ uv_err_t uv_interface_addresses(uv_interface_address_t** addresses,
   freeifaddrs(addrs);
 
   return uv_ok_;
-#endif  /* SUNOS_HAVE_IFADDRS */
+#endif  /* SUNOS_NO_IFADDRS */
 }
 
 

data/ext/asyncengine/libuv/src/unix/tcp.c

@@ -50,7 +50,9 @@ static int uv__bind(uv_tcp_t* tcp,
       goto out;
     }
 
-    if (uv__stream_open((uv_stream_t*)tcp, tcp->fd, UV_READABLE | UV_WRITABLE)) {
+    if (uv__stream_open((uv_stream_t*)tcp,
+                        tcp->fd,
+                        UV_STREAM_READABLE | UV_STREAM_WRITABLE)) {
       close(tcp->fd);
       tcp->fd = -1;
       status = -2;
@@ -181,7 +183,7 @@ int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
       return -1;
     }
 
-    if (uv__stream_open((uv_stream_t*)tcp, tcp->fd, UV_READABLE)) {
+    if (uv__stream_open((uv_stream_t*)tcp, tcp->fd, UV_STREAM_READABLE)) {
       close(tcp->fd);
       tcp->fd = -1;
       return -1;
@@ -199,9 +201,8 @@ int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
   tcp->connection_cb = cb;
 
   /* Start listening for connections. */
-  ev_io_set(&tcp->read_watcher, tcp->fd, EV_READ);
-  ev_set_cb(&tcp->read_watcher, uv__server_io);
-  ev_io_start(tcp->loop->ev, &tcp->read_watcher);
+  uv__io_set(&tcp->read_watcher, uv__server_io, tcp->fd, UV__IO_READ);
+  uv__io_start(tcp->loop, &tcp->read_watcher);
 
   return 0;
 }

data/ext/asyncengine/libuv/src/unix/thread.c

@@ -26,19 +26,6 @@
 #include <assert.h>
 #include <errno.h>
 
-#ifdef NDEBUG
-# define CHECK(r) ((void) (r))
-#else
-# include <stdio.h>
-# include <stdlib.h>
-# define CHECK(r)                                 \
-    do {                                          \
-      int __r = (r);                              \
-      if (__r) errno = __r, perror(#r), abort();  \
-    }                                             \
-    while (0)
-#endif
-
 
 int uv_thread_join(uv_thread_t *tid) {
   if (pthread_join(*tid, NULL))
@@ -49,20 +36,40 @@ int uv_thread_join(uv_thread_t *tid) {
 
 
 int uv_mutex_init(uv_mutex_t* mutex) {
+#ifdef NDEBUG
   if (pthread_mutex_init(mutex, NULL))
     return -1;
   else
     return 0;
+#else
+  pthread_mutexattr_t attr;
+  int r;
+
+  if (pthread_mutexattr_init(&attr))
+    abort();
+
+  if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK))
+    abort();
+
+  r = pthread_mutex_init(mutex, &attr);
+
+  if (pthread_mutexattr_destroy(&attr))
+    abort();
+
+  return r ? -1 : 0;
+#endif
 }
 
 
 void uv_mutex_destroy(uv_mutex_t* mutex) {
-  CHECK(pthread_mutex_destroy(mutex));
+  if (pthread_mutex_destroy(mutex))
+    abort();
 }
 
 
 void uv_mutex_lock(uv_mutex_t* mutex) {
-  CHECK(pthread_mutex_lock(mutex));
+  if (pthread_mutex_lock(mutex))
+    abort();
 }
 
 
@@ -72,7 +79,7 @@ int uv_mutex_trylock(uv_mutex_t* mutex) {
   r = pthread_mutex_trylock(mutex);
 
   if (r && r != EAGAIN)
-    CHECK(r);
+    abort();
 
   if (r)
     return -1;
@@ -82,7 +89,8 @@ int uv_mutex_trylock(uv_mutex_t* mutex) {
 
 
 void uv_mutex_unlock(uv_mutex_t* mutex) {
-  CHECK(pthread_mutex_unlock(mutex));
+  if (pthread_mutex_unlock(mutex))
+    abort();
 }
 
 
@@ -95,12 +103,14 @@ int uv_rwlock_init(uv_rwlock_t* rwlock) {
 
 
 void uv_rwlock_destroy(uv_rwlock_t* rwlock) {
-  CHECK(pthread_rwlock_destroy(rwlock));
+  if (pthread_rwlock_destroy(rwlock))
+    abort();
 }
 
 
 void uv_rwlock_rdlock(uv_rwlock_t* rwlock) {
-  CHECK(pthread_rwlock_rdlock(rwlock));
+  if (pthread_rwlock_rdlock(rwlock))
+    abort();
 }
 
 
@@ -110,7 +120,7 @@ int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock) {
   r = pthread_rwlock_tryrdlock(rwlock);
 
   if (r && r != EAGAIN)
-    CHECK(r);
+    abort();
 
   if (r)
     return -1;
@@ -120,12 +130,14 @@ int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock) {
 
 
 void uv_rwlock_rdunlock(uv_rwlock_t* rwlock) {
-  CHECK(pthread_rwlock_unlock(rwlock));
+  if (pthread_rwlock_unlock(rwlock))
+    abort();
 }
 
 
 void uv_rwlock_wrlock(uv_rwlock_t* rwlock) {
-  CHECK(pthread_rwlock_wrlock(rwlock));
+  if (pthread_rwlock_wrlock(rwlock))
+    abort();
 }
 
 
@@ -135,7 +147,7 @@ int uv_rwlock_trywrlock(uv_rwlock_t* rwlock) {
   r = pthread_rwlock_trywrlock(rwlock);
 
   if (r && r != EAGAIN)
-    CHECK(r);
+    abort();
 
   if (r)
     return -1;
@@ -145,10 +157,55 @@ int uv_rwlock_trywrlock(uv_rwlock_t* rwlock) {
 
 
 void uv_rwlock_wrunlock(uv_rwlock_t* rwlock) {
-  CHECK(pthread_rwlock_unlock(rwlock));
+  if (pthread_rwlock_unlock(rwlock))
+    abort();
 }
 
 
 void uv_once(uv_once_t* guard, void (*callback)(void)) {
-  CHECK(pthread_once(guard, callback));
+  if (pthread_once(guard, callback))
+    abort();
+}
+
+
+int uv_sem_init(uv_sem_t* sem, unsigned int value) {
+  return sem_init(sem, 0, value);
+}
+
+
+void uv_sem_destroy(uv_sem_t* sem) {
+  if (sem_destroy(sem))
+    abort();
+}
+
+
+void uv_sem_post(uv_sem_t* sem) {
+  if (sem_post(sem))
+    abort();
+}
+
+
+void uv_sem_wait(uv_sem_t* sem) {
+  int r;
+
+  do
+    r = sem_wait(sem);
+  while (r == -1 && errno == EINTR);
+
+  if (r)
+    abort();
+}
+
+
+int uv_sem_trywait(uv_sem_t* sem) {
+  int r;
+
+  do
+    r = sem_trywait(sem);
+  while (r == -1 && errno == EINTR);
+
+  if (r && errno != EAGAIN)
+    abort();
+
+  return r;
 }

data/ext/asyncengine/libuv/src/unix/timer.c

@@ -22,103 +22,114 @@
 #include "internal.h"
 #include <assert.h>
 
-
-static int uv__timer_repeating(const uv_timer_t* timer) {
-  return timer->flags & UV_TIMER_REPEAT;
+static int uv__timer_cmp(const uv_timer_t* a, const uv_timer_t* b) {
+  if (a->timeout < b->timeout)
+    return -1;
+  if (a->timeout > b->timeout)
+    return 1;
+  if (a < b)
+    return -1;
+  if (a > b)
+    return 1;
+  return 0;
 }
 
 
-static void uv__timer_cb(EV_P_ ev_timer* w, int revents) {
-  uv_timer_t* timer = container_of(w, uv_timer_t, timer_watcher);
-
-  assert(uv__timer_active(timer));
-
-  if (!uv__timer_repeating(timer)) {
-    timer->flags &= ~UV_TIMER_ACTIVE;
-    ev_ref(EV_A);
-  }
-
-  if (timer->timer_cb) {
-    timer->timer_cb(timer, 0);
-  }
-}
+RB_GENERATE_STATIC(uv__timers, uv_timer_s, tree_entry, uv__timer_cmp)
 
 
-int uv_timer_init(uv_loop_t* loop, uv_timer_t* timer) {
-  uv__handle_init(loop, (uv_handle_t*)timer, UV_TIMER);
+int uv_timer_init(uv_loop_t* loop, uv_timer_t* handle) {
   loop->counters.timer_init++;
 
-  ev_init(&timer->timer_watcher, uv__timer_cb);
+  uv__handle_init(loop, (uv_handle_t*)handle, UV_TIMER);
+  handle->timer_cb = NULL;
 
   return 0;
 }
 
 
-int uv_timer_start(uv_timer_t* timer, uv_timer_cb cb, int64_t timeout,
-    int64_t repeat) {
-  if (uv__timer_active(timer)) {
-    return -1;
-  }
+int uv_timer_start(uv_timer_t* handle,
+                   uv_timer_cb cb,
+                   int64_t timeout,
+                   int64_t repeat) {
+  assert(timeout >= 0);
+  assert(repeat >= 0);
 
-  timer->timer_cb = cb;
-  timer->flags |= UV_TIMER_ACTIVE;
+  if (uv__is_active(handle))
+    uv_timer_stop(handle);
 
-  if (repeat)
-    timer->flags |= UV_TIMER_REPEAT;
-  else
-    timer->flags &= ~UV_TIMER_REPEAT;
+  handle->timer_cb = cb;
+  handle->timeout = handle->loop->time + timeout;
+  handle->repeat = repeat;
 
-  ev_timer_set(&timer->timer_watcher, timeout / 1000.0, repeat / 1000.0);
-  ev_timer_start(timer->loop->ev, &timer->timer_watcher);
-  ev_unref(timer->loop->ev);
+  RB_INSERT(uv__timers, &handle->loop->timer_handles, handle);
+  uv__handle_start(handle);
 
   return 0;
 }
 
 
-int uv_timer_stop(uv_timer_t* timer) {
-  if (uv__timer_active(timer)) {
-    ev_ref(timer->loop->ev);
-  }
+int uv_timer_stop(uv_timer_t* handle) {
+  if (!uv__is_active(handle))
+    return 0;
 
-  timer->flags &= ~(UV_TIMER_ACTIVE | UV_TIMER_REPEAT);
-  ev_timer_stop(timer->loop->ev, &timer->timer_watcher);
+  RB_REMOVE(uv__timers, &handle->loop->timer_handles, handle);
+  uv__handle_stop(handle);
 
   return 0;
 }
 
 
-int uv_timer_again(uv_timer_t* timer) {
-  if (!uv__timer_active(timer)) {
-    uv__set_artificial_error(timer->loop, UV_EINVAL);
-    return -1;
+int uv_timer_again(uv_timer_t* handle) {
+  if (handle->timer_cb == NULL)
+    return uv__set_artificial_error(handle->loop, UV_EINVAL);
+
+  if (handle->repeat) {
+    uv_timer_stop(handle);
+    uv_timer_start(handle, handle->timer_cb, handle->repeat, handle->repeat);
   }
 
-  assert(uv__timer_repeating(timer));
-  ev_timer_again(timer->loop->ev, &timer->timer_watcher);
   return 0;
 }
 
 
-void uv_timer_set_repeat(uv_timer_t* timer, int64_t repeat) {
-  assert(timer->type == UV_TIMER);
-  timer->timer_watcher.repeat = repeat / 1000.0;
+void uv_timer_set_repeat(uv_timer_t* handle, int64_t repeat) {
+  assert(repeat >= 0);
+  handle->repeat = repeat;
+}
+
 
-  if (repeat)
-    timer->flags |= UV_TIMER_REPEAT;
-  else
-    timer->flags &= ~UV_TIMER_REPEAT;
+int64_t uv_timer_get_repeat(uv_timer_t* handle) {
+  return handle->repeat;
 }
 
 
-int64_t uv_timer_get_repeat(uv_timer_t* timer) {
-  assert(timer->type == UV_TIMER);
-  return (int64_t)(1000 * timer->timer_watcher.repeat);
+unsigned int uv__next_timeout(uv_loop_t* loop) {
+  uv_timer_t* handle;
+
+  handle = RB_MIN(uv__timers, &loop->timer_handles);
+
+  if (handle == NULL)
+    return (unsigned int) -1; /* block indefinitely */
+
+  if (handle->timeout <= loop->time)
+    return 0;
+
+  return handle->timeout - loop->time;
 }
 
 
-int uv__timer_active(const uv_timer_t* timer) {
-  return timer->flags & UV_TIMER_ACTIVE;
+void uv__run_timers(uv_loop_t* loop) {
+  uv_timer_t* handle;
+
+  while ((handle = RB_MIN(uv__timers, &loop->timer_handles))) {
+    if (handle->timeout > loop->time)
+      break;
+
+    uv_timer_stop(handle);
+    uv_timer_again(handle);
+    handle->timer_cb(handle, 0);
+  }
 }