deps: upgrade libuv to 4fe1916

7 files changed, 116 insertions, 55 deletions

diff --git a/deps/uv/include/uv-private/uv-unix.h b/deps/uv/include/uv-private/uv-unix.h
index 7b86c0ea6d..40bbdf6ed8 100644
--- a/deps/uv/include/uv-private/uv-unix.h
+++ b/deps/uv/include/uv-private/uv-unix.h
@@ -105,11 +105,8 @@ struct uv__io_s {
 
 #if __linux__
 # define UV_LOOP_PRIVATE_PLATFORM_FIELDS              \
-  /* RB_HEAD(uv__inotify_watchers, uv_fs_event_s) */  \
-  struct uv__inotify_watchers {                       \
-    struct uv_fs_event_s* rbh_root;                   \
-  } inotify_watchers;                                 \
   uv__io_t inotify_read_watcher;                      \
+  void* inotify_watchers;                             \
   int inotify_fd;
 #elif defined(PORT_SOURCE_FILE)
 # define UV_LOOP_PRIVATE_PLATFORM_FIELDS              \
@@ -277,15 +274,11 @@ struct uv__io_s {
 #if defined(__linux__)
 
 #define UV_FS_EVENT_PRIVATE_FIELDS    \
-  /* RB_ENTRY(fs_event_s) node; */    \
-  struct {                            \
-    struct uv_fs_event_s* rbe_left;   \
-    struct uv_fs_event_s* rbe_right;  \
-    struct uv_fs_event_s* rbe_parent; \
-    int rbe_color;                    \
-  } node;                             \
+  ngx_queue_t watchers;               \
   uv_fs_event_cb cb;                  \
-  int fd;                             \
+  int wd;                             \
+  void* pad0;                         \
+  void* pad1;                         \
 
 #elif defined(__APPLE__)  \
   || defined(__FreeBSD__) \
diff --git a/deps/uv/src/unix/linux/inotify.c b/deps/uv/src/unix/linux/inotify.c
index 54525bc7f1..51ea996aee 100644
--- a/deps/uv/src/unix/linux/inotify.c
+++ b/deps/uv/src/unix/linux/inotify.c
@@ -33,6 +33,18 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+struct watcher_list {
+  RB_ENTRY(watcher_list) entry;
+  ngx_queue_t watchers;
+  char* path;
+  int wd;
+};
+
+struct watcher_root {
+  struct watcher_list* rbh_root;
+};
+#define CAST(p) ((struct watcher_root*)(p))
+
 
 /* Don't look aghast, this is exactly how glibc's basename() works. */
 static char* basename_r(const char* path) {
@@ -41,14 +53,15 @@ static char* basename_r(const char* path) {
 }
 
 
-static int compare_watchers(const uv_fs_event_t* a, const uv_fs_event_t* b) {
-  if (a->fd < b->fd) return -1;
-  if (a->fd > b->fd) return 1;
+static int compare_watchers(const struct watcher_list* a,
+                            const struct watcher_list* b) {
+  if (a->wd < b->wd) return -1;
+  if (a->wd > b->wd) return 1;
   return 0;
 }
 
 
-RB_GENERATE_STATIC(uv__inotify_watchers, uv_fs_event_s, node, compare_watchers)
+RB_GENERATE_STATIC(watcher_root, watcher_list, entry, compare_watchers)
 
 
 static void uv__inotify_read(uv_loop_t* loop, uv__io_t* w, int revents);
@@ -95,36 +108,27 @@ static int init_inotify(uv_loop_t* loop) {
 }
 
 
-static void add_watcher(uv_fs_event_t* handle) {
-  RB_INSERT(uv__inotify_watchers, &handle->loop->inotify_watchers, handle);
-}
-
-
-static uv_fs_event_t* find_watcher(uv_loop_t* loop, int wd) {
-  uv_fs_event_t handle;
-  handle.fd = wd;
-  return RB_FIND(uv__inotify_watchers, &loop->inotify_watchers, &handle);
-}
-
-
-static void remove_watcher(uv_fs_event_t* handle) {
-  RB_REMOVE(uv__inotify_watchers, &handle->loop->inotify_watchers, handle);
+static struct watcher_list* find_watcher(uv_loop_t* loop, int wd) {
+  struct watcher_list w;
+  w.wd = wd;
+  return RB_FIND(watcher_root, CAST(&loop->inotify_watchers), &w);
 }
 
 
-static void uv__inotify_read(uv_loop_t* loop, uv__io_t* w, int events) {
+static void uv__inotify_read(uv_loop_t* loop, uv__io_t* dummy, int events) {
   const struct uv__inotify_event* e;
-  uv_fs_event_t* handle;
-  const char* filename;
+  struct watcher_list* w;
+  uv_fs_event_t* h;
+  ngx_queue_t* q;
+  const char* path;
   ssize_t size;
   const char *p;
   /* needs to be large enough for sizeof(inotify_event) + strlen(filename) */
   char buf[4096];
 
   while (1) {
-    do {
-      size = read(loop->inotify_fd, buf, sizeof buf);
-    }
+    do
+      size = read(loop->inotify_fd, buf, sizeof(buf));
     while (size == -1 && errno == EINTR);
 
     if (size == -1) {
@@ -144,17 +148,20 @@ static void uv__inotify_read(uv_loop_t* loop, uv__io_t* w, int events) {
       if (e->mask & ~(UV__IN_ATTRIB|UV__IN_MODIFY))
         events |= UV_RENAME;
 
-      handle = find_watcher(loop, e->wd);
-      if (handle == NULL)
-        continue; /* Handle has already been closed. */
+      w = find_watcher(loop, e->wd);
+      if (w == NULL)
+        continue; /* Stale event, no watchers left. */
 
       /* inotify does not return the filename when monitoring a single file
        * for modifications. Repurpose the filename for API compatibility.
        * I'm not convinced this is a good thing, maybe it should go.
        */
-      filename = e->len ? (const char*) (e + 1) : basename_r(handle->filename);
+      path = e->len ? (const char*) (e + 1) : basename_r(w->path);
 
-      handle->cb(handle, filename, events, 0);
+      ngx_queue_foreach(q, &w->watchers) {
+        h = ngx_queue_data(q, uv_fs_event_t, watchers);
+        h->cb(h, path, events, 0);
+      }
     }
   }
 }
@@ -162,9 +169,10 @@ static void uv__inotify_read(uv_loop_t* loop, uv__io_t* w, int events) {
 
 int uv_fs_event_init(uv_loop_t* loop,
                      uv_fs_event_t* handle,
-                     const char* filename,
+                     const char* path,
                      uv_fs_event_cb cb,
                      int flags) {
+  struct watcher_list* w;
   int events;
   int wd;
 
@@ -184,26 +192,50 @@ int uv_fs_event_init(uv_loop_t* loop,
          | UV__IN_MOVED_FROM
          | UV__IN_MOVED_TO;
 
-  wd = uv__inotify_add_watch(loop->inotify_fd, filename, events);
-  if (wd == -1) return uv__set_sys_error(loop, errno);
+  wd = uv__inotify_add_watch(loop->inotify_fd, path, events);
+  if (wd == -1)
+    return uv__set_sys_error(loop, errno);
+
+  w = find_watcher(loop, wd);
+  if (w)
+    goto no_insert;
+
+  w = malloc(sizeof(*w) + strlen(path) + 1);
+  if (w == NULL)
+    return uv__set_sys_error(loop, ENOMEM);
 
+  w->wd = wd;
+  w->path = strcpy((char*)(w + 1), path);
+  ngx_queue_init(&w->watchers);
+  RB_INSERT(watcher_root, CAST(&loop->inotify_watchers), w);
+
+no_insert:
   uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
   uv__handle_start(handle); /* FIXME shouldn't start automatically */
-  handle->filename = strdup(filename);
+  ngx_queue_insert_tail(&w->watchers, &handle->watchers);
+  handle->filename = w->path;
   handle->cb = cb;
-  handle->fd = wd;
-  add_watcher(handle);
+  handle->wd = wd;
 
   return 0;
 }
 
 
 void uv__fs_event_close(uv_fs_event_t* handle) {
-  uv__inotify_rm_watch(handle->loop->inotify_fd, handle->fd);
-  remove_watcher(handle);
-  handle->fd = -1;
+  struct watcher_list* w;
+
+  w = find_watcher(handle->loop, handle->wd);
+  assert(w != NULL);
 
-  free(handle->filename);
+  handle->wd = -1;
   handle->filename = NULL;
   uv__handle_stop(handle);
+  ngx_queue_remove(&handle->watchers);
+
+  if (ngx_queue_empty(&w->watchers)) {
+    /* No watchers left for this path. Clean up. */
+    RB_REMOVE(watcher_root, CAST(&handle->loop->inotify_watchers), w);
+    uv__inotify_rm_watch(handle->loop->inotify_fd, w->wd);
+    free(w);
+  }
 }
diff --git a/deps/uv/src/unix/loop.c b/deps/uv/src/unix/loop.c
index 75fad43626..fcf9faf309 100644
--- a/deps/uv/src/unix/loop.c
+++ b/deps/uv/src/unix/loop.c
@@ -54,7 +54,7 @@ int uv__loop_init(uv_loop_t* loop, int default_loop) {
   eio_channel_init(&loop->uv_eio_channel, loop);
 
 #if __linux__
-  RB_INIT(&loop->inotify_watchers);
+  loop->inotify_watchers = NULL;
   loop->inotify_fd = -1;
 #endif
 #if HAVE_PORTS_FS
diff --git a/deps/uv/src/unix/thread.c b/deps/uv/src/unix/thread.c
index a267d337d7..67c7876988 100644
--- a/deps/uv/src/unix/thread.c
+++ b/deps/uv/src/unix/thread.c
@@ -78,7 +78,7 @@ int uv_mutex_trylock(uv_mutex_t* mutex) {
 
   r = pthread_mutex_trylock(mutex);
 
-  if (r && r != EAGAIN)
+  if (r && r != EBUSY && r != EAGAIN)
     abort();
 
   if (r)
@@ -119,7 +119,7 @@ int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock) {
 
   r = pthread_rwlock_tryrdlock(rwlock);
 
-  if (r && r != EAGAIN)
+  if (r && r != EBUSY && r != EAGAIN)
     abort();
 
   if (r)
@@ -146,7 +146,7 @@ int uv_rwlock_trywrlock(uv_rwlock_t* rwlock) {
 
   r = pthread_rwlock_trywrlock(rwlock);
 
-  if (r && r != EAGAIN)
+  if (r && r != EBUSY && r != EAGAIN)
     abort();
 
   if (r)
diff --git a/deps/uv/test/benchmark-sizes.c b/deps/uv/test/benchmark-sizes.c
index 6d16e3ca50..b9cf74f2fb 100644
--- a/deps/uv/test/benchmark-sizes.c
+++ b/deps/uv/test/benchmark-sizes.c
@@ -36,7 +36,9 @@ BENCHMARK_IMPL(sizes) {
   LOGF("uv_idle_t: %u bytes\n", (unsigned int) sizeof(uv_idle_t));
   LOGF("uv_async_t: %u bytes\n", (unsigned int) sizeof(uv_async_t));
   LOGF("uv_timer_t: %u bytes\n", (unsigned int) sizeof(uv_timer_t));
+  LOGF("uv_fs_event_t: %u bytes\n", (unsigned int) sizeof(uv_fs_event_t));
   LOGF("uv_process_t: %u bytes\n", (unsigned int) sizeof(uv_process_t));
   LOGF("uv_poll_t: %u bytes\n", (unsigned int) sizeof(uv_poll_t));
+  LOGF("uv_loop_t: %u bytes\n", (unsigned int) sizeof(uv_loop_t));
   return 0;
 }
diff --git a/deps/uv/test/test-fs-event.c b/deps/uv/test/test-fs-event.c
index fe7bce2afc..4d4cfbc31b 100644
--- a/deps/uv/test/test-fs-event.c
+++ b/deps/uv/test/test-fs-event.c
@@ -85,6 +85,13 @@ static void close_cb(uv_handle_t* handle) {
   close_cb_called++;
 }
 
+static void fail_cb(uv_fs_event_t* handle,
+                    const char* path,
+                    int events,
+                    int status) {
+  ASSERT(0 && "fail_cb called");
+}
+
 static void fs_event_cb_dir(uv_fs_event_t* handle, const char* filename,
   int events, int status) {
   ++fs_event_cb_called;
@@ -159,6 +166,13 @@ static void timer_cb_touch(uv_timer_t* timer, int status) {
   timer_cb_touch_called++;
 }
 
+static void timer_cb_watch_twice(uv_timer_t* handle, int status) {
+  uv_fs_event_t* handles = handle->data;
+  uv_close((uv_handle_t*) (handles + 0), NULL);
+  uv_close((uv_handle_t*) (handles + 1), NULL);
+  uv_close((uv_handle_t*) handle, NULL);
+}
+
 TEST_IMPL(fs_event_watch_dir) {
   uv_fs_t fs_req;
   uv_loop_t* loop = uv_default_loop();
@@ -225,6 +239,24 @@ TEST_IMPL(fs_event_watch_file) {
   return 0;
 }
 
+TEST_IMPL(fs_event_watch_file_twice) {
+  const char path[] = "test/fixtures/empty_file";
+  uv_fs_event_t watchers[2];
+  uv_timer_t timer;
+  uv_loop_t* loop;
+
+  loop = uv_default_loop();
+  timer.data = watchers;
+
+  ASSERT(0 == uv_fs_event_init(loop, watchers + 0, path, fail_cb, 0));
+  ASSERT(0 == uv_fs_event_init(loop, watchers + 1, path, fail_cb, 0));
+  ASSERT(0 == uv_timer_init(loop, &timer));
+  ASSERT(0 == uv_timer_start(&timer, timer_cb_watch_twice, 10, 0));
+  ASSERT(0 == uv_run(loop));
+
+  return 0;
+}
+
 TEST_IMPL(fs_event_watch_file_current_dir) {
   uv_timer_t timer;
   uv_loop_t* loop;
diff --git a/deps/uv/test/test-list.h b/deps/uv/test/test-list.h
index 7665149964..19670e5684 100644
--- a/deps/uv/test/test-list.h
+++ b/deps/uv/test/test-list.h
@@ -158,6 +158,7 @@ TEST_DECLARE   (fs_stat_missing_path)
 TEST_DECLARE   (fs_read_file_eof)
 TEST_DECLARE   (fs_event_watch_dir)
 TEST_DECLARE   (fs_event_watch_file)
+TEST_DECLARE   (fs_event_watch_file_twice)
 TEST_DECLARE   (fs_event_watch_file_current_dir)
 TEST_DECLARE   (fs_event_no_callback_on_close)
 TEST_DECLARE   (fs_event_immediate_close)
@@ -396,6 +397,7 @@ TASK_LIST_START
   TEST_ENTRY  (fs_file_open_append)
   TEST_ENTRY  (fs_event_watch_dir)
   TEST_ENTRY  (fs_event_watch_file)
+  TEST_ENTRY  (fs_event_watch_file_twice)
   TEST_ENTRY  (fs_event_watch_file_current_dir)
   TEST_ENTRY  (fs_event_no_callback_on_close)
   TEST_ENTRY  (fs_event_immediate_close)