libuv 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d09dbd548f07b923954c84a68c379cd6f505a57
-  data.tar.gz: eca4be71daa05339d195feb72bda34ec883495e3
+  metadata.gz: efca251c5022c8b1930338e419d3b18768aefd24
+  data.tar.gz: a8083cd695fbed0357daf6fb5bfa143d8117b3e2
 SHA512:
-  metadata.gz: 46dd78c6788302bd6219ce150fed9fd04853a3a526950d92469c65c0be56ef6a2854e4c4a942c3efc93c10460683b380d1949fc40d9774f8391be1dbf6328395
-  data.tar.gz: 1019298eef2701c03264d1c18380d3f9a4d3d6733b60cb6f856c4923a792f8d8d580ba52c2096f844dabbcae3fbd36fd475d0717ae3954c60fbfd914e1b087f6
+  metadata.gz: 90c1818cc42e10b76edb107f8a1bbb8582c511dafd12a1ed9c4b883e617146af01922eac241b0a3c012d9a449193c9177bbf401dfae88ce901ade0963f196c83
+  data.tar.gz: 8b4bd90f4adeddc3c94fe0eeecfabe27b569bd327c7945d4193f8108cc9720655a5b8d94a9405ff243c789f3c80318a0f88919ac3c322727e0b15d762b96d427

data/ext/libuv/AUTHORS

@@ -214,3 +214,7 @@ Roger A. Light <roger@atchoo.org>
 chenttuuvv <chenttuuvv@yahoo.com>
 Richard Lau <riclau@uk.ibm.com>
 ronkorving <rkorving@wizcorp.jp>
+Corbin Simpson <MostAwesomeDude@gmail.com>
+Zachary Hamm <zsh@imipolexg.org>
+Karl Skomski <karl@skomski.com>
+Jeremy Whitlock <jwhitlock@apache.org>

data/ext/libuv/ChangeLog

@@ -1,3 +1,44 @@
+2015.08.20, Version 1.7.1 (Stable), 44f4b6bd82d8ae4583ccc4768a83af778ef69f85
+
+Changes since version 1.7.0:
+
+* doc: document the procedure for verifying releases (Saúl Ibarra Corretgé)
+
+* doc: add note about Windows binaries to the README (Saúl Ibarra Corretgé)
+
+* doc: use long GPG IDs in MAINTAINERS.md (Saúl Ibarra Corretgé)
+
+* Revert "stream: squelch ECONNRESET error if already closed" (Saúl Ibarra
+  Corretgé)
+
+* doc: clarify uv_read_stop() is idempotent (Corbin Simpson)
+
+* unix: OpenBSD's setsockopt needs an unsigned char for multicast (Zachary
+  Hamm)
+
+* test: Fix two memory leaks (Karl Skomski)
+
+* unix,win: return EINVAL on nullptr args in uv_fs_{read,write} (Karl Skomski)
+
+* win: set accepted TCP sockets as non-inheritable (Saúl Ibarra Corretgé)
+
+* unix: remove superfluous parentheses in fs macros (Ben Noordhuis)
+
+* unix: don't copy arguments for sync fs requests (Ben Noordhuis)
+
+* test: plug small memory leak in unix test runner (Ben Noordhuis)
+
+* unix,windows: allow NULL loop for sync fs requests (Ben Noordhuis)
+
+* unix,windows: don't assert on unknown error code (Ben Noordhuis)
+
+* stream: retry write on EPROTOTYPE on OSX (Brian White)
+
+* common: fix use of snprintf on Windows (Saúl Ibarra Corretgé)
+
+* tests: refactored fs watch_dir tests for stability (Jeremy Whitlock)
+
+
 2015.08.06, Version 1.7.0 (Stable), 415a865d6365ba58d02b92b89d46ba5d7744ec8b
 
 Changes since version 1.6.1:

data/ext/libuv/appveyor.yml

@@ -1,4 +1,4 @@
-version: v1.7.0.build{build}
+version: v1.7.1.build{build}
 
 install:
   - cinst -y nsis

data/ext/libuv/configure.ac

@@ -13,7 +13,7 @@
 # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 AC_PREREQ(2.57)
-AC_INIT([libuv], [1.7.0], [https://github.com/libuv/libuv/issues])
+AC_INIT([libuv], [1.7.1], [https://github.com/libuv/libuv/issues])
 AC_CONFIG_MACRO_DIR([m4])
 m4_include([m4/libuv-extra-automake-flags.m4])
 m4_include([m4/as_case.m4])

data/ext/libuv/docs/src/errors.rst

@@ -322,8 +322,10 @@ API
 
 .. c:function:: const char* uv_strerror(int err)
 
-    Returns the error message for the given error code.
+    Returns the error message for the given error code.  Leaks a few bytes
+    of memory when you call it with an unknown error code.
 
 .. c:function:: const char* uv_err_name(int err)
 
-    Returns the error name for the given error code.
+    Returns the error name for the given error code.  Leaks a few bytes
+    of memory when you call it with an unknown error code.

data/ext/libuv/docs/src/stream.rst

@@ -142,6 +142,8 @@ API
     Stop reading data from the stream. The :c:type:`uv_read_cb` callback will
     no longer be called.
 
+    This function is idempotent and may be safely called on a stopped stream.
+
 .. c:function:: int uv_write(uv_write_t* req, uv_stream_t* handle, const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb)
 
     Write data to stream. Buffers are written in order. Example:

data/ext/libuv/include/uv-version.h

@@ -32,7 +32,7 @@
 
 #define UV_VERSION_MAJOR 1
 #define UV_VERSION_MINOR 7
-#define UV_VERSION_PATCH 0
+#define UV_VERSION_PATCH 1
 #define UV_VERSION_IS_RELEASE 1
 #define UV_VERSION_SUFFIX ""
 

data/ext/libuv/src/unix/fs.c

@@ -58,52 +58,63 @@
 # include <sys/sendfile.h>
 #endif
 
-#define INIT(type)                                                            \
+#define INIT(subtype)                                                         \
   do {                                                                        \
-    uv__req_init((loop), (req), UV_FS);                                       \
-    (req)->fs_type = UV_FS_ ## type;                                          \
-    (req)->result = 0;                                                        \
-    (req)->ptr = NULL;                                                        \
-    (req)->loop = loop;                                                       \
-    (req)->path = NULL;                                                       \
-    (req)->new_path = NULL;                                                   \
-    (req)->cb = (cb);                                                         \
+    req->type = UV_FS;                                                        \
+    if (cb != NULL)                                                           \
+      uv__req_init(loop, req, UV_FS);                                         \
+    req->fs_type = UV_FS_ ## subtype;                                         \
+    req->result = 0;                                                          \
+    req->ptr = NULL;                                                          \
+    req->loop = loop;                                                         \
+    req->path = NULL;                                                         \
+    req->new_path = NULL;                                                     \
+    req->cb = cb;                                                             \
   }                                                                           \
   while (0)
 
 #define PATH                                                                  \
   do {                                                                        \
-    (req)->path = uv__strdup(path);                                           \
-    if ((req)->path == NULL)                                                  \
-      return -ENOMEM;                                                         \
+    assert(path != NULL);                                                     \
+    if (cb == NULL) {                                                         \
+      req->path = path;                                                       \
+    } else {                                                                  \
+      req->path = uv__strdup(path);                                           \
+      if (req->path == NULL)                                                  \
+        return -ENOMEM;                                                       \
+    }                                                                         \
   }                                                                           \
   while (0)
 
 #define PATH2                                                                 \
   do {                                                                        \
-    size_t path_len;                                                          \
-    size_t new_path_len;                                                      \
-    path_len = strlen((path)) + 1;                                            \
-    new_path_len = strlen((new_path)) + 1;                                    \
-    (req)->path = uv__malloc(path_len + new_path_len);                        \
-    if ((req)->path == NULL)                                                  \
-      return -ENOMEM;                                                         \
-    (req)->new_path = (req)->path + path_len;                                 \
-    memcpy((void*) (req)->path, (path), path_len);                            \
-    memcpy((void*) (req)->new_path, (new_path), new_path_len);                \
+    if (cb == NULL) {                                                         \
+      req->path = path;                                                       \
+      req->new_path = new_path;                                               \
+    } else {                                                                  \
+      size_t path_len;                                                        \
+      size_t new_path_len;                                                    \
+      path_len = strlen(path) + 1;                                            \
+      new_path_len = strlen(new_path) + 1;                                    \
+      req->path = uv__malloc(path_len + new_path_len);                        \
+      if (req->path == NULL)                                                  \
+        return -ENOMEM;                                                       \
+      req->new_path = req->path + path_len;                                   \
+      memcpy((void*) req->path, path, path_len);                              \
+      memcpy((void*) req->new_path, new_path, new_path_len);                  \
+    }                                                                         \
   }                                                                           \
   while (0)
 
 #define POST                                                                  \
   do {                                                                        \
-    if ((cb) != NULL) {                                                       \
-      uv__work_submit((loop), &(req)->work_req, uv__fs_work, uv__fs_done);    \
+    if (cb != NULL) {                                                         \
+      uv__work_submit(loop, &req->work_req, uv__fs_work, uv__fs_done);        \
       return 0;                                                               \
     }                                                                         \
     else {                                                                    \
-      uv__fs_work(&(req)->work_req);                                          \
-      uv__fs_done(&(req)->work_req, 0);                                       \
-      return (req)->result;                                                   \
+      uv__fs_work(&req->work_req);                                            \
+      return req->result;                                                     \
     }                                                                         \
   }                                                                           \
   while (0)
@@ -886,8 +897,7 @@ static void uv__fs_done(struct uv__work* w, int status) {
     req->result = -ECANCELED;
   }
 
-  if (req->cb != NULL)
-    req->cb(req);
+  req->cb(req);
 }
 
 
@@ -1071,6 +1081,9 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req,
                unsigned int nbufs,
                int64_t off,
                uv_fs_cb cb) {
+  if (bufs == NULL || nbufs == 0)
+    return -EINVAL;
+
   INIT(READ);
   req->file = file;
 
@@ -1193,6 +1206,9 @@ int uv_fs_write(uv_loop_t* loop,
                 unsigned int nbufs,
                 int64_t off,
                 uv_fs_cb cb) {
+  if (bufs == NULL || nbufs == 0)
+    return -EINVAL;
+
   INIT(WRITE);
   req->file = file;
 
@@ -1212,7 +1228,14 @@ int uv_fs_write(uv_loop_t* loop,
 
 
 void uv_fs_req_cleanup(uv_fs_t* req) {
-  uv__free((void*)req->path);
+  /* Only necessary for asychronous requests, i.e., requests with a callback.
+   * Synchronous ones don't copy their arguments and have req->path and
+   * req->new_path pointing to user-owned memory.  UV_FS_MKDTEMP is the
+   * exception to the rule, it always allocates memory.
+   */
+  if (req->path != NULL && (req->cb != NULL || req->fs_type == UV_FS_MKDTEMP))
+    uv__free((void*) req->path);  /* Memory is shared with req->new_path. */
+
   req->path = NULL;
   req->new_path = NULL;
 

data/ext/libuv/src/unix/stream.c

@@ -809,7 +809,17 @@ start:
     do {
       n = sendmsg(uv__stream_fd(stream), &msg, 0);
     }
+#if defined(__APPLE__)
+    /*
+     * Due to a possible kernel bug at least in OS X 10.10 "Yosemite",
+     * EPROTOTYPE can be returned while trying to write to a socket that is
+     * shutting down. If we retry the write, we should get the expected EPIPE
+     * instead.
+     */
+    while (n == -1 && (errno == EINTR || errno == EPROTOTYPE));
+#else
     while (n == -1 && errno == EINTR);
+#endif
   } else {
     do {
       if (iovcnt == 1) {
@@ -818,7 +828,17 @@ start:
         n = writev(uv__stream_fd(stream), iov, iovcnt);
       }
     }
+#if defined(__APPLE__)
+    /*
+     * Due to a possible kernel bug at least in OS X 10.10 "Yosemite",
+     * EPROTOTYPE can be returned while trying to write to a socket that is
+     * shutting down. If we retry the write, we should get the expected EPIPE
+     * instead.
+     */
+    while (n == -1 && (errno == EINTR || errno == EPROTOTYPE));
+#else
     while (n == -1 && errno == EINTR);
+#endif
   }
 
   if (n < 0) {

data/ext/libuv/src/unix/udp.c

@@ -668,6 +668,8 @@ static int uv__setsockopt_maybe_char(uv_udp_t* handle,
                                      int val) {
 #if defined(__sun) || defined(_AIX)
   char arg = val;
+#elif defined(__OpenBSD__)
+  unsigned char arg = val;
 #else
   int arg = val;
 #endif
@@ -702,13 +704,13 @@ int uv_udp_set_ttl(uv_udp_t* handle, int ttl) {
  * so hardcode the size of these options on this platform,
  * and use the general uv__setsockopt_maybe_char call on other platforms.
  */
-#if defined(__sun) || defined(_AIX)
+#if defined(__sun) || defined(_AIX) || defined(__OpenBSD__)
   return uv__setsockopt(handle,
                         IP_TTL,
                         IPV6_UNICAST_HOPS,
                         &ttl,
                         sizeof(ttl));
-#endif /* defined(__sun) || defined(_AIX) */
+#endif /* defined(__sun) || defined(_AIX) || defined (__OpenBSD__) */
 
   return uv__setsockopt_maybe_char(handle,
                                    IP_TTL,

data/ext/libuv/src/uv-common.c

@@ -137,14 +137,27 @@ uv_buf_t uv_buf_init(char* base, unsigned int len) {
 }
 
 
+static const char* uv__unknown_err_code(int err) {
+  char buf[32];
+  char* copy;
+
+#ifndef _WIN32
+  snprintf(buf, sizeof(buf), "Unknown system error %d", err);
+#else
+  _snprintf(buf, sizeof(buf), "Unknown system error %d", err);
+#endif
+  copy = uv__strdup(buf);
+
+  return copy != NULL ? copy : "Unknown system error";
+}
+
+
 #define UV_ERR_NAME_GEN(name, _) case UV_ ## name: return #name;
 const char* uv_err_name(int err) {
   switch (err) {
     UV_ERRNO_MAP(UV_ERR_NAME_GEN)
-    default:
-      assert(0);
-      return NULL;
   }
+  return uv__unknown_err_code(err);
 }
 #undef UV_ERR_NAME_GEN
 
@@ -153,9 +166,8 @@ const char* uv_err_name(int err) {
 const char* uv_strerror(int err) {
   switch (err) {
     UV_ERRNO_MAP(UV_STRERROR_GEN)
-    default:
-      return "Unknown system error";
   }
+  return uv__unknown_err_code(err);
 }
 #undef UV_STRERROR_GEN
 

data/ext/libuv/src/win/fs.c

@@ -116,8 +116,8 @@ void uv_fs_init() {
 }
 
 
-INLINE static int fs__capture_path(uv_loop_t* loop, uv_fs_t* req,
-    const char* path, const char* new_path, const int copy_path) {
+INLINE static int fs__capture_path(uv_fs_t* req, const char* path,
+    const char* new_path, const int copy_path) {
   char* buf;
   char* pos;
   ssize_t buf_sz = 0, path_len, pathw_len = 0, new_pathw_len = 0;
@@ -1762,8 +1762,7 @@ static void uv__fs_done(struct uv__work* w, int status) {
     req->result = UV_ECANCELED;
   }
 
-  if (req->cb != NULL)
-    req->cb(req);
+  req->cb(req);
 }
 
 
@@ -1792,7 +1791,7 @@ int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
 
   uv_fs_req_init(loop, req, UV_FS_OPEN, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -1831,6 +1830,9 @@ int uv_fs_read(uv_loop_t* loop,
                unsigned int nbufs,
                int64_t offset,
                uv_fs_cb cb) {
+  if (bufs == NULL || nbufs == 0)
+    return UV_EINVAL;
+
   uv_fs_req_init(loop, req, UV_FS_READ, cb);
 
   req->file.fd = fd;
@@ -1864,6 +1866,9 @@ int uv_fs_write(uv_loop_t* loop,
                 unsigned int nbufs,
                 int64_t offset,
                 uv_fs_cb cb) {
+  if (bufs == NULL || nbufs == 0)
+    return UV_EINVAL;
+
   uv_fs_req_init(loop, req, UV_FS_WRITE, cb);
 
   req->file.fd = fd;
@@ -1896,7 +1901,7 @@ int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
 
   uv_fs_req_init(loop, req, UV_FS_UNLINK, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -1917,7 +1922,7 @@ int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
 
   uv_fs_req_init(loop, req, UV_FS_MKDIR, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -1940,7 +1945,7 @@ int uv_fs_mkdtemp(uv_loop_t* loop, uv_fs_t* req, const char* tpl,
 
   uv_fs_req_init(loop, req, UV_FS_MKDTEMP, cb);
 
-  err = fs__capture_path(loop, req, tpl, NULL, TRUE);
+  err = fs__capture_path(req, tpl, NULL, TRUE);
   if (err)
     return uv_translate_sys_error(err);
 
@@ -1959,7 +1964,7 @@ int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
 
   uv_fs_req_init(loop, req, UV_FS_RMDIR, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -1980,7 +1985,7 @@ int uv_fs_scandir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
 
   uv_fs_req_init(loop, req, UV_FS_SCANDIR, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -2003,7 +2008,7 @@ int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path,
 
   uv_fs_req_init(loop, req, UV_FS_LINK, cb);
 
-  err = fs__capture_path(loop, req, path, new_path, cb != NULL);
+  err = fs__capture_path(req, path, new_path, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -2024,7 +2029,7 @@ int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
 
   uv_fs_req_init(loop, req, UV_FS_SYMLINK, cb);
 
-  err = fs__capture_path(loop, req, path, new_path, cb != NULL);
+  err = fs__capture_path(req, path, new_path, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -2047,7 +2052,7 @@ int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
 
   uv_fs_req_init(loop, req, UV_FS_READLINK, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -2068,7 +2073,7 @@ int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid,
 
   uv_fs_req_init(loop, req, UV_FS_CHOWN, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -2102,7 +2107,7 @@ int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
 
   uv_fs_req_init(loop, req, UV_FS_STAT, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -2122,7 +2127,7 @@ int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
 
   uv_fs_req_init(loop, req, UV_FS_LSTAT, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -2157,7 +2162,7 @@ int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path,
 
   uv_fs_req_init(loop, req, UV_FS_RENAME, cb);
 
-  err = fs__capture_path(loop, req, path, new_path, cb != NULL);
+  err = fs__capture_path(req, path, new_path, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -2246,7 +2251,7 @@ int uv_fs_access(uv_loop_t* loop,
 
   uv_fs_req_init(loop, req, UV_FS_ACCESS, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err)
     return uv_translate_sys_error(err);
 
@@ -2268,7 +2273,7 @@ int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
 
   uv_fs_req_init(loop, req, UV_FS_CHMOD, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }
@@ -2308,7 +2313,7 @@ int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime,
 
   uv_fs_req_init(loop, req, UV_FS_UTIME, cb);
 
-  err = fs__capture_path(loop, req, path, NULL, cb != NULL);
+  err = fs__capture_path(req, path, NULL, cb != NULL);
   if (err) {
     return uv_translate_sys_error(err);
   }

data/ext/libuv/src/win/tcp.c

@@ -419,6 +419,15 @@ static void uv_tcp_queue_accept(uv_tcp_t* handle, uv_tcp_accept_t* req) {
     return;
   }
 
+  /* Make the socket non-inheritable */
+  if (!SetHandleInformation((HANDLE) accept_socket, HANDLE_FLAG_INHERIT, 0)) {
+    SET_REQ_ERROR(req, GetLastError());
+    uv_insert_pending_req(loop, (uv_req_t*)req);
+    handle->reqs_pending++;
+    closesocket(accept_socket);
+    return;
+  }
+
   /* Prepare the overlapped structure. */
   memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
   if (handle->flags & UV_HANDLE_EMULATE_IOCP) {

data/ext/libuv/test/benchmark-fs-stat.c

@@ -31,7 +31,7 @@
 
 #define sync_stat(req, path)                                                  \
   do {                                                                        \
-    uv_fs_stat(uv_default_loop(), (req), (path), NULL);                       \
+    uv_fs_stat(NULL, (req), (path), NULL);                                    \
     uv_fs_req_cleanup((req));                                                 \
   }                                                                           \
   while (0)

data/ext/libuv/test/echo-server.c

@@ -304,7 +304,7 @@ static int pipe_echo_start(char* pipeName) {
 #ifndef _WIN32
   {
     uv_fs_t req;
-    uv_fs_unlink(uv_default_loop(), &req, pipeName, NULL);
+    uv_fs_unlink(NULL, &req, pipeName, NULL);
     uv_fs_req_cleanup(&req);
   }
 #endif

data/ext/libuv/test/runner-unix.c

@@ -267,15 +267,11 @@ int process_wait(process_info_t* vec, int n, int timeout) {
       kill(p->pid, SIGTERM);
     }
     retval = -2;
-
-    /* Wait for thread to finish. */
-    r = pthread_join(tid, NULL);
-    if (r) {
-      perror("pthread_join");
-      retval = -1;
-    }
   }
 
+  if (pthread_join(tid, NULL))
+    abort();
+
 terminate:
   close(args.pipe[0]);
   close(args.pipe[1]);