asyncengine 0.0.1.testing1 → 0.0.2.alpha1

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

@@ -42,12 +42,10 @@ static void uv__fs_event_start(uv_fs_event_t* handle) {
              handle->fd,
              EV_LIBUV_KQUEUE_HACK);
   ev_io_start(handle->loop->ev, &handle->event_watcher);
-  ev_unref(handle->loop->ev);
 }
 
 
 static void uv__fs_event_stop(uv_fs_event_t* handle) {
-  ev_ref(handle->loop->ev);
   ev_io_stop(handle->loop->ev, &handle->event_watcher);
 }
 
@@ -97,11 +95,6 @@ int uv_fs_event_init(uv_loop_t* loop,
   /* We don't support any flags yet. */
   assert(!flags);
 
-  if (cb == NULL) {
-    uv__set_sys_error(loop, EINVAL);
-    return -1;
-  }
-
   /* TODO open asynchronously - but how do we report back errors? */
   if ((fd = open(filename, O_RDONLY)) == -1) {
     uv__set_sys_error(loop, errno);
@@ -109,6 +102,7 @@ int uv_fs_event_init(uv_loop_t* loop,
   }
 
   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->fflags = 0;
   handle->cb = cb;
@@ -121,6 +115,7 @@ int uv_fs_event_init(uv_loop_t* loop,
 
 void uv__fs_event_close(uv_fs_event_t* handle) {
   uv__fs_event_stop(handle);
+  uv__handle_stop(handle);
   free(handle->filename);
   close(handle->fd);
   handle->fd = -1;

data/ext/asyncengine/libuv/src/unix/linux/inotify.c

@@ -51,7 +51,7 @@ static int compare_watchers(const uv_fs_event_t* a, const uv_fs_event_t* b) {
 RB_GENERATE_STATIC(uv__inotify_watchers, uv_fs_event_s, node, compare_watchers)
 
 
-static void uv__inotify_read(EV_P_ ev_io* w, int revents);
+static void uv__inotify_read(uv_loop_t* loop, uv__io_t* w, int revents);
 
 
 static int new_inotify_fd(void) {
@@ -85,12 +85,11 @@ static int init_inotify(uv_loop_t* loop) {
     return -1;
   }
 
-  ev_io_init(&loop->inotify_read_watcher,
-             uv__inotify_read,
-             loop->inotify_fd,
-             EV_READ);
-  ev_io_start(loop->ev, &loop->inotify_read_watcher);
-  ev_unref(loop->ev);
+  uv__io_init(&loop->inotify_read_watcher,
+              uv__inotify_read,
+              loop->inotify_fd,
+              UV__IO_READ);
+  uv__io_start(loop, &loop->inotify_read_watcher);
 
   return 0;
 }
@@ -113,22 +112,18 @@ static void remove_watcher(uv_fs_event_t* handle) {
 }
 
 
-static void uv__inotify_read(EV_P_ ev_io* w, int revents) {
+static void uv__inotify_read(uv_loop_t* loop, uv__io_t* w, int events) {
   const struct uv__inotify_event* e;
   uv_fs_event_t* handle;
-  uv_loop_t* uv_loop;
   const char* filename;
   ssize_t size;
-  int events;
   const char *p;
   /* needs to be large enough for sizeof(inotify_event) + strlen(filename) */
   char buf[4096];
 
-  uv_loop = container_of(w, uv_loop_t, inotify_read_watcher);
-
   while (1) {
     do {
-      size = read(uv_loop->inotify_fd, buf, sizeof buf);
+      size = read(loop->inotify_fd, buf, sizeof buf);
     }
     while (size == -1 && errno == EINTR);
 
@@ -149,7 +144,7 @@ static void uv__inotify_read(EV_P_ ev_io* w, int revents) {
       if (e->mask & ~(UV__IN_ATTRIB|UV__IN_MODIFY))
         events |= UV_RENAME;
 
-      handle = find_watcher(uv_loop, e->wd);
+      handle = find_watcher(loop, e->wd);
       if (handle == NULL)
         continue; /* Handle has already been closed. */
 
@@ -185,6 +180,7 @@ int uv_fs_event_init(uv_loop_t* loop,
          | UV__IN_MODIFY
          | UV__IN_DELETE
          | UV__IN_DELETE_SELF
+         | UV__IN_MOVE_SELF
          | UV__IN_MOVED_FROM
          | UV__IN_MOVED_TO;
 
@@ -192,6 +188,7 @@ int uv_fs_event_init(uv_loop_t* loop,
   if (wd == -1) return uv__set_sys_error(loop, errno);
 
   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->cb = cb;
   handle->fd = wd;
@@ -208,4 +205,5 @@ void uv__fs_event_close(uv_fs_event_t* handle) {
 
   free(handle->filename);
   handle->filename = NULL;
+  uv__handle_stop(handle);
 }

data/ext/asyncengine/libuv/src/unix/linux/{core.c → linux-core.c}

@@ -46,7 +46,7 @@
 #endif
 
 #undef NANOSEC
-#define NANOSEC 1000000000
+#define NANOSEC ((uint64_t) 1e9)
 
 /* This is rather annoying: CLOCK_BOOTTIME lives in <linux/time.h> but we can't
  * include that file because it conflicts with <time.h>. We'll just have to

data/ext/asyncengine/libuv/src/unix/linux/syscalls.c

@@ -49,6 +49,76 @@
 # endif
 #endif /* __NR_accept4 */
 
+#ifndef __NR_eventfd
+# if __x86_64__
+#  define __NR_eventfd 284
+# elif __i386__
+#  define __NR_eventfd 323
+# elif __arm__
+#  define __NR_eventfd (UV_SYSCALL_BASE + 351)
+# endif
+#endif /* __NR_eventfd */
+
+#ifndef __NR_eventfd2
+# if __x86_64__
+#  define __NR_eventfd2 290
+# elif __i386__
+#  define __NR_eventfd2 328
+# elif __arm__
+#  define __NR_eventfd2 (UV_SYSCALL_BASE + 356)
+# endif
+#endif /* __NR_eventfd2 */
+
+#ifndef __NR_epoll_create
+# if __x86_64__
+#  define __NR_epoll_create 213
+# elif __i386__
+#  define __NR_epoll_create 254
+# elif __arm__
+#  define __NR_epoll_create (UV_SYSCALL_BASE + 250)
+# endif
+#endif /* __NR_epoll_create */
+
+#ifndef __NR_epoll_create1
+# if __x86_64__
+#  define __NR_epoll_create1 291
+# elif __i386__
+#  define __NR_epoll_create1 329
+# elif __arm__
+#  define __NR_epoll_create1 (UV_SYSCALL_BASE + 357)
+# endif
+#endif /* __NR_epoll_create1 */
+
+#ifndef __NR_epoll_ctl
+# if __x86_64__
+#  define __NR_epoll_ctl 233 /* used to be 214 */
+# elif __i386__
+#  define __NR_epoll_ctl 255
+# elif __arm__
+#  define __NR_epoll_ctl (UV_SYSCALL_BASE + 251)
+# endif
+#endif /* __NR_epoll_ctl */
+
+#ifndef __NR_epoll_wait
+# if __x86_64__
+#  define __NR_epoll_wait 232 /* used to be 215 */
+# elif __i386__
+#  define __NR_epoll_wait 256
+# elif __arm__
+#  define __NR_epoll_wait (UV_SYSCALL_BASE + 252)
+# endif
+#endif /* __NR_epoll_wait */
+
+#ifndef __NR_epoll_pwait
+# if __x86_64__
+#  define __NR_epoll_pwait 281
+# elif __i386__
+#  define __NR_epoll_pwait 319
+# elif __arm__
+#  define __NR_epoll_pwait (UV_SYSCALL_BASE + 346)
+# endif
+#endif /* __NR_epoll_pwait */
+
 #ifndef __NR_inotify_init
 # if __x86_64__
 #  define __NR_inotify_init 253
@@ -115,7 +185,7 @@
 # elif __i386__
 #  define __NR_sendmmsg 345
 # elif __arm__
-#  define __NR_recvmmsg (UV_SYSCALL_BASE + 374)
+#  define __NR_sendmmsg (UV_SYSCALL_BASE + 374)
 # endif
 #endif /* __NR_sendmmsg */
 
@@ -147,6 +217,82 @@ int uv__accept4(int fd, struct sockaddr* addr, socklen_t* addrlen, int flags) {
 }
 
 
+int uv__eventfd(unsigned int count) {
+#if __NR_eventfd
+  return syscall(__NR_eventfd, count);
+#else
+  return errno = ENOSYS, -1;
+#endif
+}
+
+
+int uv__eventfd2(unsigned int count, int flags) {
+#if __NR_eventfd2
+  return syscall(__NR_eventfd2, count, flags);
+#else
+  return errno = ENOSYS, -1;
+#endif
+}
+
+
+int uv__epoll_create(void) {
+#if __NR_epoll_create
+  return syscall(__NR_epoll_create);
+#else
+  return errno = ENOSYS, -1;
+#endif
+}
+
+
+int uv__epoll_create1(int flags) {
+#if __NR_epoll_create1
+  return syscall(__NR_epoll_create1, flags);
+#else
+  return errno = ENOSYS, -1;
+#endif
+}
+
+
+int uv__epoll_ctl(int epfd, int op, int fd, struct uv__epoll_event* events) {
+#if __NR_epoll_ctl
+  return syscall(__NR_epoll_ctl, epfd, op, fd, events);
+#else
+  return errno = ENOSYS, -1;
+#endif
+}
+
+
+int uv__epoll_wait(int epfd,
+                   struct uv__epoll_event* events,
+                   int nevents,
+                   int timeout) {
+#if __NR_epoll_wait
+  return syscall(__NR_epoll_wait, epfd, events, nevents, timeout);
+#else
+  return errno = ENOSYS, -1;
+#endif
+}
+
+
+int uv__epoll_pwait(int epfd,
+                    struct uv__epoll_event* events,
+                    int nevents,
+                    int timeout,
+                    const sigset_t* sigmask) {
+#if __NR_epoll_pwait
+  return syscall(__NR_epoll_pwait,
+                 epfd,
+                 events,
+                 nevents,
+                 timeout,
+                 sigmask,
+                 sizeof(*sigmask));
+#else
+  return errno = ENOSYS, -1;
+#endif
+}
+
+
 int uv__inotify_init(void) {
 #if __NR_inotify_init
   return syscall(__NR_inotify_init);

data/ext/asyncengine/libuv/src/unix/linux/syscalls.h

@@ -25,6 +25,7 @@
 #undef  _GNU_SOURCE
 #define _GNU_SOURCE
 
+#include <signal.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <linux/types.h>
@@ -32,12 +33,29 @@
 #define UV__O_NONBLOCK        0x800
 #define UV__O_CLOEXEC         0x80000
 
-#define UV__SOCK_CLOEXEC      UV__O_CLOEXEC
-#define UV__SOCK_NONBLOCK     UV__O_NONBLOCK
+#define UV__EFD_CLOEXEC       UV__O_CLOEXEC
+#define UV__EFD_NONBLOCK      UV__O_NONBLOCK
 
 #define UV__IN_CLOEXEC        UV__O_CLOEXEC
 #define UV__IN_NONBLOCK       UV__O_NONBLOCK
 
+#define UV__SOCK_CLOEXEC      UV__O_CLOEXEC
+#define UV__SOCK_NONBLOCK     UV__O_NONBLOCK
+
+/* epoll flags */
+#define UV__EPOLL_CLOEXEC     UV__O_CLOEXEC
+#define UV__EPOLL_CTL_ADD     1
+#define UV__EPOLL_CTL_DEL     2
+#define UV__EPOLL_CTL_MOD     3
+
+#define UV__EPOLLIN           1
+#define UV__EPOLLOUT          4
+#define UV__EPOLLERR          8
+#define UV__EPOLLHUP          16
+#define UV__EPOLLONESHOT      0x40000000
+#define UV__EPOLLET           0x80000000
+
+/* inotify flags */
 #define UV__IN_ACCESS         0x001
 #define UV__IN_MODIFY         0x002
 #define UV__IN_ATTRIB         0x004
@@ -51,6 +69,11 @@
 #define UV__IN_DELETE_SELF    0x400
 #define UV__IN_MOVE_SELF      0x800
 
+struct uv__epoll_event {
+  __u32 events;
+  __u64 data;
+} __attribute__((packed));
+
 struct uv__inotify_event {
   __s32 wd;
   __u32 mask;
@@ -65,6 +88,20 @@ struct uv__mmsghdr {
 };
 
 int uv__accept4(int fd, struct sockaddr* addr, socklen_t* addrlen, int flags);
+int uv__eventfd(unsigned int count);
+int uv__epoll_create(void);
+int uv__epoll_create1(int flags);
+int uv__epoll_ctl(int epfd, int op, int fd, struct uv__epoll_event *ev);
+int uv__epoll_wait(int epfd,
+                   struct uv__epoll_event* events,
+                   int nevents,
+                   int timeout);
+int uv__epoll_pwait(int epfd,
+                    struct uv__epoll_event* events,
+                    int nevents,
+                    int timeout,
+                    const sigset_t* sigmask);
+int uv__eventfd2(unsigned int count, int flags);
 int uv__inotify_init(void);
 int uv__inotify_init1(int flags);
 int uv__inotify_add_watch(int fd, const char* path, __u32 mask);

data/ext/asyncengine/libuv/src/unix/loop-watcher.c

@@ -0,0 +1,63 @@
+/* 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"
+
+#define UV_LOOP_WATCHER_DEFINE(name, type)                                    \
+  int uv_##name##_init(uv_loop_t* loop, uv_##name##_t* handle) {              \
+    uv__handle_init(loop, (uv_handle_t*)handle, UV_##type);                   \
+    loop->counters.name##_init++;                                             \
+    handle->name##_cb = NULL;                                                 \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int uv_##name##_start(uv_##name##_t* handle, uv_##name##_cb cb) {           \
+    if (uv__is_active(handle)) return 0;                                      \
+    ngx_queue_insert_head(&handle->loop->name##_handles, &handle->queue);     \
+    handle->name##_cb = cb;                                                   \
+    uv__handle_start(handle);                                                 \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  int uv_##name##_stop(uv_##name##_t* handle) {                               \
+    if (!uv__is_active(handle)) return 0;                                     \
+    ngx_queue_remove(&handle->queue);                                         \
+    uv__handle_stop(handle);                                                  \
+    return 0;                                                                 \
+  }                                                                           \
+                                                                              \
+  void uv__run_##name(uv_loop_t* loop) {                                      \
+    uv_##name##_t* h;                                                         \
+    ngx_queue_t* q;                                                           \
+    ngx_queue_foreach(q, &loop->name##_handles) {                             \
+      h = ngx_queue_data(q, uv_##name##_t, queue);                            \
+      if (h->name##_cb) h->name##_cb(h, 0);                                   \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  void uv__##name##_close(uv_##name##_t* handle) {                            \
+    uv_##name##_stop(handle);                                                 \
+  }
+
+UV_LOOP_WATCHER_DEFINE(prepare, PREPARE)
+UV_LOOP_WATCHER_DEFINE(check, CHECK)
+UV_LOOP_WATCHER_DEFINE(idle, IDLE)

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

@@ -33,14 +33,32 @@ int uv__loop_init(uv_loop_t* loop, int default_loop) {
 #else
   int flags = EVFLAG_AUTO;
 #endif
-  RB_INIT(&loop->uv_ares_handles_);
-  loop->endgame_handles = NULL;
+
+  memset(loop, 0, sizeof(*loop));
+
+  RB_INIT(&loop->ares_handles);
+  RB_INIT(&loop->timer_handles);
+  ngx_queue_init(&loop->active_reqs);
+  ngx_queue_init(&loop->idle_handles);
+  ngx_queue_init(&loop->async_handles);
+  ngx_queue_init(&loop->check_handles);
+  ngx_queue_init(&loop->prepare_handles);
+  ngx_queue_init(&loop->handle_queue);
+  loop->closing_handles = NULL;
+  loop->channel = NULL;
+  loop->time = uv_hrtime() / 1000000;
+  loop->async_pipefd[0] = -1;
+  loop->async_pipefd[1] = -1;
   loop->ev = (default_loop ? ev_default_loop : ev_loop_new)(flags);
   ev_set_userdata(loop->ev, loop);
   eio_channel_init(&loop->uv_eio_channel, loop);
+
 #if __linux__
   RB_INIT(&loop->inotify_watchers);
   loop->inotify_fd = -1;
+#endif
+#if HAVE_PORTS_FS
+  loop->fs_fd = -1;
 #endif
   return 0;
 }
@@ -50,9 +68,14 @@ void uv__loop_delete(uv_loop_t* loop) {
   uv_ares_destroy(loop, loop->channel);
   ev_loop_destroy(loop->ev);
 #if __linux__
-  if (loop->inotify_fd == -1) return;
-  ev_io_stop(loop->ev, &loop->inotify_read_watcher);
-  close(loop->inotify_fd);
-  loop->inotify_fd = -1;
+  if (loop->inotify_fd != -1) {
+    uv__io_stop(loop, &loop->inotify_read_watcher);
+    close(loop->inotify_fd);
+    loop->inotify_fd = -1;
+  }
+#endif
+#if HAVE_PORTS_FS
+  if (loop->fs_fd != -1)
+    close(loop->fs_fd);
 #endif
 }