asyncengine 0.0.1.testing

data/ext/asyncengine_ext/libuv/src/unix/eio/libeio.m4

@@ -0,0 +1,195 @@
+dnl openbsd in it's neverending brokenness requires stdint.h for intptr_t,
+dnl but that header isn't very portable...
+AC_CHECK_HEADERS([stdint.h sys/syscall.h sys/prctl.h])
+
+AC_SEARCH_LIBS(
+   pthread_create,
+   [pthread pthreads pthreadVC2],
+   ,
+   [AC_MSG_ERROR(pthread functions not found)]
+)
+
+AC_CACHE_CHECK(for utimes, ac_cv_utimes, [AC_LINK_IFELSE([[
+#include <sys/types.h>
+#include <sys/time.h>
+#include <utime.h>
+struct timeval tv[2];
+int res;
+int main (void)
+{
+   res = utimes ("/", tv);
+   return 0;
+}
+]],ac_cv_utimes=yes,ac_cv_utimes=no)])
+test $ac_cv_utimes = yes && AC_DEFINE(HAVE_UTIMES, 1, utimes(2) is available)
+
+AC_CACHE_CHECK(for futimes, ac_cv_futimes, [AC_LINK_IFELSE([[
+#include <sys/types.h>
+#include <sys/time.h>
+#include <utime.h>
+struct timeval tv[2];
+int res;
+int fd;
+int main (void)
+{
+   res = futimes (fd, tv);
+   return 0;
+}
+]],ac_cv_futimes=yes,ac_cv_futimes=no)])
+test $ac_cv_futimes = yes && AC_DEFINE(HAVE_FUTIMES, 1, futimes(2) is available)
+
+AC_CACHE_CHECK(for readahead, ac_cv_readahead, [AC_LINK_IFELSE([
+#include <fcntl.h>
+int main (void)
+{
+   int fd = 0;
+   size_t count = 2;
+   ssize_t res;
+   res = readahead (fd, 0, count);
+   return 0;
+}
+],ac_cv_readahead=yes,ac_cv_readahead=no)])
+test $ac_cv_readahead = yes && AC_DEFINE(HAVE_READAHEAD, 1, readahead(2) is available (linux))
+
+AC_CACHE_CHECK(for fdatasync, ac_cv_fdatasync, [AC_LINK_IFELSE([
+#include <unistd.h>
+int main (void)
+{
+   int fd = 0;
+   fdatasync (fd);
+   return 0;
+}
+],ac_cv_fdatasync=yes,ac_cv_fdatasync=no)])
+test $ac_cv_fdatasync = yes && AC_DEFINE(HAVE_FDATASYNC, 1, fdatasync(2) is available)
+
+AC_CACHE_CHECK(for pread and pwrite, ac_cv_preadwrite, [AC_LINK_IFELSE([
+#include <unistd.h>
+int main (void)
+{
+   int fd = 0;
+   size_t count = 1;
+   char buf;
+   off_t offset = 1;
+   ssize_t res;
+   res = pread (fd, &buf, count, offset);
+   res = pwrite (fd, &buf, count, offset);
+   return 0;
+}
+],ac_cv_preadwrite=yes,ac_cv_preadwrite=no)])
+test $ac_cv_preadwrite = yes && AC_DEFINE(HAVE_PREADWRITE, 1, pread(2) and pwrite(2) are available)
+
+AC_CACHE_CHECK(for sendfile, ac_cv_sendfile, [AC_LINK_IFELSE([
+# include <sys/types.h>
+#if __linux
+# include <sys/sendfile.h>
+#elif __FreeBSD__ || defined __APPLE__
+# include <sys/socket.h>
+# include <sys/uio.h>
+#elif __hpux
+# include <sys/socket.h>
+#else
+# error unsupported architecture
+#endif
+int main (void)
+{
+   int fd = 0;
+   off_t offset = 1;
+   size_t count = 2;
+   ssize_t res;
+#if __linux
+   res = sendfile (fd, fd, offset, count);
+#elif __FreeBSD__
+   res = sendfile (fd, fd, offset, count, 0, &offset, 0);
+#elif __hpux
+   res = sendfile (fd, fd, offset, count, 0, 0);
+#endif
+   return 0;
+}
+],ac_cv_sendfile=yes,ac_cv_sendfile=no)])
+test $ac_cv_sendfile = yes && AC_DEFINE(HAVE_SENDFILE, 1, sendfile(2) is available and supported)
+
+AC_CACHE_CHECK(for sync_file_range, ac_cv_sync_file_range, [AC_LINK_IFELSE([
+#include <fcntl.h>
+int main (void)
+{
+   int fd = 0;
+   off64_t offset = 1;
+   off64_t nbytes = 1;
+   unsigned int flags = SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE|SYNC_FILE_RANGE_WAIT_AFTER;
+   ssize_t res;
+   res = sync_file_range (fd, offset, nbytes, flags);
+   return 0;
+}
+],ac_cv_sync_file_range=yes,ac_cv_sync_file_range=no)])
+test $ac_cv_sync_file_range = yes && AC_DEFINE(HAVE_SYNC_FILE_RANGE, 1, sync_file_range(2) is available)
+
+AC_CACHE_CHECK(for fallocate, ac_cv_fallocate, [AC_LINK_IFELSE([
+#include <fcntl.h>
+int main (void)
+{
+   int fd = 0;
+   int mode = 0;
+   off_t offset = 1;
+   off_t len = 1;
+   int res;
+   res = fallocate (fd, mode, offset, len);
+   return 0;
+}
+],ac_cv_fallocate=yes,ac_cv_fallocate=no)])
+test $ac_cv_fallocate = yes && AC_DEFINE(HAVE_FALLOCATE, 1, fallocate(2) is available)
+
+AC_CACHE_CHECK(for sys_syncfs, ac_cv_sys_syncfs, [AC_LINK_IFELSE([
+#include <unistd.h>
+#include <sys/syscall.h>
+int main (void)
+{
+  int res = syscall (__NR_syncfs, (int)0);
+}
+],ac_cv_sys_syncfs=yes,ac_cv_sys_syncfs=no)])
+test $ac_cv_sys_syncfs = yes && AC_DEFINE(HAVE_SYS_SYNCFS, 1, syscall(__NR_syncfs) is available)
+
+AC_CACHE_CHECK(for prctl_set_name, ac_cv_prctl_set_name, [AC_LINK_IFELSE([
+#include <sys/prctl.h>
+int main (void)
+{
+  char name[] = "test123";
+  int res = prctl (PR_SET_NAME, (unsigned long)name, 0, 0, 0);
+}
+],ac_cv_prctl_set_name=yes,ac_cv_prctl_set_name=no)])
+test $ac_cv_prctl_set_name = yes && AC_DEFINE(HAVE_PRCTL_SET_NAME, 1, prctl(PR_SET_NAME) is available)
+
+dnl #############################################################################
+dnl # these checks exist for the benefit of IO::AIO
+
+dnl at least uclibc defines _POSIX_ADVISORY_INFO without *any* of the required
+dnl functionality actually being present. ugh.
+AC_CACHE_CHECK(for posix_madvise, ac_cv_posix_madvise, [AC_LINK_IFELSE([
+#include <sys/mman.h>
+int main (void)
+{
+   int res = posix_madvise ((void *)0, (size_t)0, POSIX_MADV_NORMAL);
+   int a = POSIX_MADV_SEQUENTIAL;
+   int b = POSIX_MADV_RANDOM;
+   int c = POSIX_MADV_WILLNEED;
+   int d = POSIX_MADV_DONTNEED;
+   return 0;
+}
+],ac_cv_posix_madvise=yes,ac_cv_posix_madvise=no)])
+test $ac_cv_posix_madvise = yes && AC_DEFINE(HAVE_POSIX_MADVISE, 1, posix_madvise(2) is available)
+
+AC_CACHE_CHECK(for posix_fadvise, ac_cv_posix_fadvise, [AC_LINK_IFELSE([
+#define _XOPEN_SOURCE 600
+#include <fcntl.h>
+int main (void)
+{
+   int res = posix_fadvise ((int)0, (off_t)0, (off_t)0, POSIX_FADV_NORMAL);
+   int a = POSIX_FADV_SEQUENTIAL;
+   int b = POSIX_FADV_NOREUSE;
+   int c = POSIX_FADV_RANDOM;
+   int d = POSIX_FADV_WILLNEED;
+   int e = POSIX_FADV_DONTNEED;
+   return 0;
+}
+],ac_cv_posix_fadvise=yes,ac_cv_posix_fadvise=no)])
+test $ac_cv_posix_fadvise = yes && AC_DEFINE(HAVE_POSIX_FADVISE, 1, posix_fadvise(2) is available)
+

data/ext/asyncengine_ext/libuv/src/unix/eio/xthread.h

@@ -0,0 +1,164 @@
+#ifndef XTHREAD_H_
+#define XTHREAD_H_
+
+/* whether word reads are potentially non-atomic.
+ * this is conservative, likely most arches this runs
+ * on have atomic word read/writes.
+ */
+#ifndef WORDACCESS_UNSAFE
+# if __i386 || __x86_64
+#  define WORDACCESS_UNSAFE 0
+# else
+#  define WORDACCESS_UNSAFE 1
+# endif
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef _WIN32
+
+#include <stdio.h>//D
+#include <fcntl.h>
+#include <io.h>
+#include <time.h>
+#include <winsock2.h>
+#include <process.h>
+#include <windows.h>
+#include <pthread.h>
+#define sigset_t int
+#define sigfillset(a)
+#define pthread_sigmask(a,b,c)
+#define sigaddset(a,b)
+#define sigemptyset(s)
+
+typedef pthread_mutex_t xmutex_t;
+#define X_MUTEX_INIT           PTHREAD_MUTEX_INITIALIZER
+#define X_MUTEX_CREATE(mutex)  pthread_mutex_init (&(mutex), 0)
+#define X_LOCK(mutex)          pthread_mutex_lock (&(mutex))
+#define X_UNLOCK(mutex)        pthread_mutex_unlock (&(mutex))
+
+typedef pthread_cond_t xcond_t;
+#define X_COND_INIT                     PTHREAD_COND_INITIALIZER
+#define X_COND_CREATE(cond)		pthread_cond_init (&(cond), 0)
+#define X_COND_SIGNAL(cond)             pthread_cond_signal (&(cond))
+#define X_COND_WAIT(cond,mutex)         pthread_cond_wait (&(cond), &(mutex))
+#define X_COND_TIMEDWAIT(cond,mutex,to) pthread_cond_timedwait (&(cond), &(mutex), &(to))
+
+typedef pthread_t xthread_t;
+#define X_THREAD_PROC(name) void *name (void *thr_arg)
+#define X_THREAD_ATFORK(a,b,c)
+
+static int
+thread_create (xthread_t *tid, void *(*proc)(void *), void *arg)
+{
+  int retval;
+  pthread_attr_t attr;
+
+  pthread_attr_init (&attr);
+  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+
+  retval = pthread_create (tid, &attr, proc, arg) == 0;
+
+  pthread_attr_destroy (&attr);
+
+  return retval;
+}
+
+#define respipe_read(a,b,c)  PerlSock_recv ((a), (b), (c), 0)
+#define respipe_write(a,b,c) send ((a), (b), (c), 0)
+#define respipe_close(a)     PerlSock_closesocket ((a))
+
+#else
+/////////////////////////////////////////////////////////////////////////////
+
+#if __linux && !defined(_GNU_SOURCE)
+# define _GNU_SOURCE
+#endif
+
+/* just in case */
+#define _REENTRANT 1
+
+#if __solaris
+# define _POSIX_PTHREAD_SEMANTICS 1
+/* try to bribe solaris headers into providing a current pthread API
+ * despite environment being configured for an older version.
+ */
+# define __EXTENSIONS__ 1
+#endif
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <limits.h>
+#include <pthread.h>
+
+typedef pthread_mutex_t xmutex_t;
+#if __linux && defined (PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP)
+# define X_MUTEX_INIT		PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
+# define X_MUTEX_CREATE(mutex)						\
+  do {									\
+    pthread_mutexattr_t attr;						\
+    pthread_mutexattr_init (&attr);					\
+    pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ADAPTIVE_NP);	\
+    pthread_mutex_init (&(mutex), &attr);				\
+  } while (0)
+#else
+# define X_MUTEX_INIT		PTHREAD_MUTEX_INITIALIZER
+# define X_MUTEX_CREATE(mutex)	pthread_mutex_init (&(mutex), 0)
+#endif
+#define X_LOCK(mutex)		pthread_mutex_lock   (&(mutex))
+#define X_UNLOCK(mutex)		pthread_mutex_unlock (&(mutex))
+
+typedef pthread_cond_t xcond_t;
+#define X_COND_INIT			PTHREAD_COND_INITIALIZER
+#define X_COND_CREATE(cond)		pthread_cond_init (&(cond), 0)
+#define X_COND_SIGNAL(cond)		pthread_cond_signal (&(cond))
+#define X_COND_WAIT(cond,mutex)		pthread_cond_wait (&(cond), &(mutex))
+#define X_COND_TIMEDWAIT(cond,mutex,to)	pthread_cond_timedwait (&(cond), &(mutex), &(to))
+
+typedef pthread_t xthread_t;
+#define X_THREAD_PROC(name) static void *name (void *thr_arg)
+#define X_THREAD_ATFORK(prepare,parent,child) pthread_atfork (prepare, parent, child)
+
+// the broken bsd's once more
+#ifndef PTHREAD_STACK_MIN
+# define PTHREAD_STACK_MIN 0
+#endif
+
+#ifndef XTHREAD_STACKSIZE
+# define XTHREAD_STACKSIZE sizeof (void *) * 4096
+#endif
+
+static int
+thread_create (xthread_t *tid, void *(*proc)(void *), void *arg)
+{
+  int retval;
+  sigset_t fullsigset, oldsigset;
+  pthread_attr_t attr;
+
+  pthread_attr_init (&attr);
+  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+  pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < X_STACKSIZE ? X_STACKSIZE : PTHREAD_STACK_MIN);
+#ifdef PTHREAD_SCOPE_PROCESS
+  pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);
+#endif
+
+  sigfillset (&fullsigset);
+
+  pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
+  retval = pthread_create (tid, &attr, proc, arg) == 0;
+  pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
+
+  pthread_attr_destroy (&attr);
+
+  return retval;
+}
+
+#define respipe_read(a,b,c)  read  ((a), (b), (c))
+#define respipe_write(a,b,c) write ((a), (b), (c))
+#define respipe_close(a)     close ((a))
+
+#endif
+
+#endif
+

data/ext/asyncengine_ext/libuv/src/unix/error.c

@@ -0,0 +1,98 @@
+/* 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.
+ */
+
+/*
+ * TODO Share this code with Windows.
+ * See https://github.com/joyent/libuv/issues/76
+ */
+
+#include "uv.h"
+#include "internal.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+
+/* TODO Expose callback to user to handle fatal error like V8 does. */
+void uv_fatal_error(const int errorno, const char* syscall) {
+  char* buf = NULL;
+  const char* errmsg;
+
+  if (buf) {
+    errmsg = buf;
+  } else {
+    errmsg = "Unknown error";
+  }
+
+  if (syscall) {
+    fprintf(stderr, "\nlibuv fatal error. %s: (%d) %s\n", syscall, errorno,
+        errmsg);
+  } else {
+    fprintf(stderr, "\nlibuv fatal error. (%d) %s\n", errorno, errmsg);
+  }
+
+  abort();
+}
+
+
+uv_err_code uv_translate_sys_error(int sys_errno) {
+  switch (sys_errno) {
+    case 0: return UV_OK;
+    case EPERM: return UV_EPERM;
+    case ENOSYS: return UV_ENOSYS;
+    case ENOTSOCK: return UV_ENOTSOCK;
+    case ENOENT: return UV_ENOENT;
+    case EACCES: return UV_EACCES;
+    case EAFNOSUPPORT: return UV_EAFNOSUPPORT;
+    case EBADF: return UV_EBADF;
+    case EPIPE: return UV_EPIPE;
+    case EAGAIN: return UV_EAGAIN;
+    case ECONNRESET: return UV_ECONNRESET;
+    case EFAULT: return UV_EFAULT;
+    case EMFILE: return UV_EMFILE;
+    case EMSGSIZE: return UV_EMSGSIZE;
+    case ENAMETOOLONG: return UV_ENAMETOOLONG;
+    case EINVAL: return UV_EINVAL;
+    case ENETUNREACH: return UV_ENETUNREACH;
+    case ECONNABORTED: return UV_ECONNABORTED;
+    case ELOOP: return UV_ELOOP;
+    case ECONNREFUSED: return UV_ECONNREFUSED;
+    case EADDRINUSE: return UV_EADDRINUSE;
+    case EADDRNOTAVAIL: return UV_EADDRNOTAVAIL;
+    case ENOTDIR: return UV_ENOTDIR;
+    case EISDIR: return UV_EISDIR;
+    case ENOTCONN: return UV_ENOTCONN;
+    case EEXIST: return UV_EEXIST;
+    case EHOSTUNREACH: return UV_EHOSTUNREACH;
+    case EAI_NONAME: return UV_ENOENT;
+    case ESRCH: return UV_ESRCH;
+    case ETIMEDOUT: return UV_ETIMEDOUT;
+    case EXDEV: return UV_EXDEV;
+    case EBUSY: return UV_EBUSY;
+    case ENOTEMPTY: return UV_ENOTEMPTY;
+    case ENOSPC: return UV_ENOSPC;
+    default: return UV_UNKNOWN;
+  }
+  UNREACHABLE();
+}