emnapi 1.2.0 → 1.3.0

package/src/uv/threadpool.c

@@ -19,7 +19,7 @@
  * IN THE SOFTWARE.
  */
 
-// from libuv 1.43.0
+// from libuv 1.48.0
 
 #if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
 
@@ -43,10 +43,10 @@ static unsigned int slow_io_work_running;
 static unsigned int nthreads;
 static uv_thread_t* threads;
 static uv_thread_t default_threads[4];
-static QUEUE exit_message;
-static QUEUE wq;
-static QUEUE run_slow_work_message;
-static QUEUE slow_io_pending_wq;
+static struct uv__queue exit_message;
+static struct uv__queue wq;
+static struct uv__queue run_slow_work_message;
+static struct uv__queue slow_io_pending_wq;
 
 static unsigned int slow_work_thread_threshold(void) {
   return (nthreads + 1) / 2;
@@ -60,8 +60,8 @@ EMNAPI_INTERNAL_EXTERN void _emnapi_worker_unref(uv_thread_t pid);
 
 #ifdef __EMNAPI_WASI_THREADS__
 EMNAPI_INTERNAL_EXTERN
-void _emnapi_after_uvthreadpool_ready(void (*callback)(QUEUE* w, enum uv__work_kind kind),
-                                      QUEUE* w,
+void _emnapi_after_uvthreadpool_ready(void (*callback)(struct uv__queue* w, enum uv__work_kind kind),
+                                      struct uv__queue* w,
                                       enum uv__work_kind kind);
 EMNAPI_INTERNAL_EXTERN void _emnapi_tell_js_uvthreadpool(uv_thread_t* threads, unsigned int n);
 EMNAPI_INTERNAL_EXTERN void _emnapi_emit_async_thread_ready();
@@ -72,7 +72,7 @@ EMNAPI_INTERNAL_EXTERN void _emnapi_emit_async_thread_ready();
  */
 static void* worker(void* arg) {
   struct uv__work* w;
-  QUEUE* q;
+  struct uv__queue* q;
   int is_slow_work;
 #ifndef __EMNAPI_WASI_THREADS__
   uv_sem_post((uv_sem_t*) arg);
@@ -87,49 +87,49 @@ static void* worker(void* arg) {
 
     /* Keep waiting while either no work is present or only slow I/O
        and we're at the threshold for that. */
-    while (QUEUE_EMPTY(&wq) ||
-           (QUEUE_HEAD(&wq) == &run_slow_work_message &&
-            QUEUE_NEXT(&run_slow_work_message) == &wq &&
+    while (uv__queue_empty(&wq) ||
+           (uv__queue_head(&wq) == &run_slow_work_message &&
+            uv__queue_next(&run_slow_work_message) == &wq &&
             slow_io_work_running >= slow_work_thread_threshold())) {
       idle_threads += 1;
       uv_cond_wait(&cond, &mutex);
       idle_threads -= 1;
     }
 
-    q = QUEUE_HEAD(&wq);
+    q = uv__queue_head(&wq);
     if (q == &exit_message) {
       uv_cond_signal(&cond);
       uv_mutex_unlock(&mutex);
       break;
     }
 
-    QUEUE_REMOVE(q);
-    QUEUE_INIT(q);  /* Signal uv_cancel() that the work req is executing. */
+    uv__queue_remove(q);
+    uv__queue_init(q);  /* Signal uv_cancel() that the work req is executing. */
 
     is_slow_work = 0;
     if (q == &run_slow_work_message) {
       /* If we're at the slow I/O threshold, re-schedule until after all
          other work in the queue is done. */
       if (slow_io_work_running >= slow_work_thread_threshold()) {
-        QUEUE_INSERT_TAIL(&wq, q);
+        uv__queue_insert_tail(&wq, q);
         continue;
       }
 
       /* If we encountered a request to run slow I/O work but there is none
          to run, that means it's cancelled => Start over. */
-      if (QUEUE_EMPTY(&slow_io_pending_wq))
+      if (uv__queue_empty(&slow_io_pending_wq))
         continue;
 
       is_slow_work = 1;
       slow_io_work_running++;
 
-      q = QUEUE_HEAD(&slow_io_pending_wq);
-      QUEUE_REMOVE(q);
-      QUEUE_INIT(q);
+      q = uv__queue_head(&slow_io_pending_wq);
+      uv__queue_remove(q);
+      uv__queue_init(q);
 
       /* If there is more slow I/O work, schedule it to be run as well. */
-      if (!QUEUE_EMPTY(&slow_io_pending_wq)) {
-        QUEUE_INSERT_TAIL(&wq, &run_slow_work_message);
+      if (!uv__queue_empty(&slow_io_pending_wq)) {
+        uv__queue_insert_tail(&wq, &run_slow_work_message);
         if (idle_threads > 0)
           uv_cond_signal(&cond);
       }
@@ -137,13 +137,13 @@ static void* worker(void* arg) {
 
     uv_mutex_unlock(&mutex);
 
-    w = QUEUE_DATA(q, struct uv__work, wq);
+    w = uv__queue_data(q, struct uv__work, wq);
     w->work(w);
 
     uv_mutex_lock(&w->loop->wq_mutex);
     w->work = NULL;  /* Signal uv_cancel() that the work req is done
                         executing. */
-    QUEUE_INSERT_TAIL(&w->loop->wq, &w->wq);
+    uv__queue_insert_tail(&w->loop->wq, &w->wq);
     uv_async_send(&w->loop->wq_async);
     uv_mutex_unlock(&w->loop->wq_mutex);
 
@@ -159,12 +159,12 @@ static void* worker(void* arg) {
 }
 
 
-static void post(QUEUE* q, enum uv__work_kind kind) {
+static void post(struct uv__queue* q, enum uv__work_kind kind) {
   uv_mutex_lock(&mutex);
   // if (kind == UV__WORK_SLOW_IO) {
   //   /* Insert into a separate queue. */
-  //   QUEUE_INSERT_TAIL(&slow_io_pending_wq, q);
-  //   if (!QUEUE_EMPTY(&run_slow_work_message)) {
+  //   uv__queue_insert_tail(&slow_io_pending_wq, q);
+  //   if (!uv__queue_empty(&run_slow_work_message)) {
   //     /* Running slow I/O tasks is already scheduled => Nothing to do here.
   //        The worker that runs said other task will schedule this one as well. */
   //     uv_mutex_unlock(&mutex);
@@ -173,7 +173,7 @@ static void post(QUEUE* q, enum uv__work_kind kind) {
   //   q = &run_slow_work_message;
   // }
 
-  QUEUE_INSERT_TAIL(&wq, q);
+  uv__queue_insert_tail(&wq, q);
   if (idle_threads > 0)
     uv_cond_signal(&cond);
   uv_mutex_unlock(&mutex);
@@ -254,9 +254,9 @@ static void init_threads(void) {
   if (uv_mutex_init(&mutex))
     abort();
 
-  QUEUE_INIT(&wq);
-  QUEUE_INIT(&slow_io_pending_wq);
-  QUEUE_INIT(&run_slow_work_message);
+  uv__queue_init(&wq);
+  uv__queue_init(&slow_io_pending_wq);
+  uv__queue_init(&run_slow_work_message);
 
 #ifndef __EMNAPI_WASI_THREADS__
   if (uv_sem_init(&sem, 0))
@@ -331,12 +331,13 @@ void uv__work_submit(uv_loop_t* loop,
 static int uv__work_cancel(uv_loop_t* loop, uv_req_t* req, struct uv__work* w) {
   int cancelled;
 
+  uv_once(&once, init_once);  /* Ensure |mutex| is initialized. */
   uv_mutex_lock(&mutex);
   uv_mutex_lock(&w->loop->wq_mutex);
 
-  cancelled = !QUEUE_EMPTY(&w->wq) && w->work != NULL;
+  cancelled = !uv__queue_empty(&w->wq) && w->work != NULL;
   if (cancelled)
-    QUEUE_REMOVE(&w->wq);
+    uv__queue_remove(&w->wq);
 
   uv_mutex_unlock(&w->loop->wq_mutex);
   uv_mutex_unlock(&mutex);
@@ -346,7 +347,7 @@ static int uv__work_cancel(uv_loop_t* loop, uv_req_t* req, struct uv__work* w) {
 
   w->work = uv__cancelled;
   uv_mutex_lock(&loop->wq_mutex);
-  QUEUE_INSERT_TAIL(&loop->wq, &w->wq);
+  uv__queue_insert_tail(&loop->wq, &w->wq);
   uv_async_send(&loop->wq_async);
   uv_mutex_unlock(&loop->wq_mutex);
 
@@ -357,22 +358,39 @@ static int uv__work_cancel(uv_loop_t* loop, uv_req_t* req, struct uv__work* w) {
 void uv__work_done(uv_async_t* handle) {
   struct uv__work* w;
   uv_loop_t* loop;
-  QUEUE* q;
-  QUEUE wq;
+  struct uv__queue* q;
+  struct uv__queue wq;
   int err;
+  int nevents;
 
   loop = container_of(handle, uv_loop_t, wq_async);
   uv_mutex_lock(&loop->wq_mutex);
-  QUEUE_MOVE(&loop->wq, &wq);
+  uv__queue_move(&loop->wq, &wq);
   uv_mutex_unlock(&loop->wq_mutex);
 
-  while (!QUEUE_EMPTY(&wq)) {
-    q = QUEUE_HEAD(&wq);
-    QUEUE_REMOVE(q);
+  nevents = 0;
+
+  while (!uv__queue_empty(&wq)) {
+    q = uv__queue_head(&wq);
+    uv__queue_remove(q);
 
     w = container_of(q, struct uv__work, wq);
     err = (w->work == uv__cancelled) ? ECANCELED : 0;
     w->done(w, err);
+    nevents++;
+  }
+
+  /* This check accomplishes 2 things:
+   * 1. Even if the queue was empty, the call to uv__work_done() should count
+   *    as an event. Which will have been added by the event loop when
+   *    calling this callback.
+   * 2. Prevents accidental wrap around in case nevents == 0 events == 0.
+   */
+  if (nevents > 1) {
+    /* Subtract 1 to counter the call to uv__work_done(). */
+    uv__metrics_inc_events(loop, nevents - 1);
+    if (uv__get_internal_fields(loop)->current_timeout == 0)
+      uv__metrics_inc_events_waiting(loop, nevents - 1);
   }
 }
 
@@ -388,7 +406,7 @@ static void uv__queue_done(struct uv__work* w, int err) {
   uv_work_t* req;
 
   req = container_of(w, uv_work_t, work_req);
-  uv__req_unregister(req->loop, req);
+  uv__req_unregister(req->loop);
 
   if (req->after_work_cb == NULL)
     return;

package/src/uv/unix/async.c

@@ -24,38 +24,14 @@
 
 #if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
 
+#include "uv.h"
+#include "internal.h"
+
+#include <stdatomic.h>
 #include <stdlib.h>
 #include <sched.h>
-#include "../uv-common.h"
 #include "emnapi_common.h"
 
-#if defined(__clang__) ||                                                     \
-    defined(__GNUC__) ||                                                      \
-    defined(__INTEL_COMPILER)
-# define UV_UNUSED(declaration)     __attribute__((unused)) declaration
-#else
-# define UV_UNUSED(declaration)     declaration
-#endif
-
-UV_UNUSED(static int cmpxchgi(int* ptr, int oldval, int newval));
-
-UV_UNUSED(static int cmpxchgi(int* ptr, int oldval, int newval)) {
-  return __sync_val_compare_and_swap(ptr, oldval, newval);
-}
-
-#ifndef EMNAPI_NEXTTICK_TYPE
-#define EMNAPI_NEXTTICK_TYPE 0
-#endif
-#if EMNAPI_NEXTTICK_TYPE == 0
-EMNAPI_INTERNAL_EXTERN void _emnapi_set_immediate(void (*callback)(void*), void* data);
-#define NEXT_TICK(callback, data) _emnapi_set_immediate((callback), (data))
-#elif EMNAPI_NEXTTICK_TYPE == 1
-EMNAPI_INTERNAL_EXTERN void _emnapi_next_tick(void (*callback)(void*), void* data);
-#define NEXT_TICK(callback, data) _emnapi_next_tick((callback), (data))
-#else
-#error "Invalid EMNAPI_NEXTTICK_TYPE"
-#endif
-
 #if EMNAPI_USE_PROXYING
 #include <emscripten/threading.h>
 #include <emscripten/proxying.h>
@@ -88,36 +64,43 @@ void _emnapi_destroy_proxying_queue(uv_loop_t* loop) {}
 
 #endif
 
+static void uv__async_send(uv_loop_t* loop);
+static void uv__cpu_relax(void);
+
 int uv_async_init(uv_loop_t* loop, uv_async_t* handle, uv_async_cb async_cb) {
-  handle->loop = loop;
-  handle->type = UV_ASYNC;
+  uv__handle_init(loop, (uv_handle_t*)handle, UV_ASYNC);
   handle->async_cb = async_cb;
   handle->pending = 0;
-  QUEUE_INSERT_TAIL(&loop->async_handles, &handle->queue);
+  handle->u.fd = 0; /* This will be used as a busy flag. */
+
+  uv__queue_insert_tail(&loop->async_handles, &handle->queue);
+  uv__handle_start(handle);
   return 0;
 }
 
 /* Only call this from the event loop thread. */
-static int uv__async_spin(uv_async_t* handle) {
+static void uv__async_spin(uv_async_t* handle) {
+  _Atomic int* pending;
+  _Atomic int* busy;
   int i;
-  int rc;
+
+  pending = (_Atomic int*) &handle->pending;
+  busy = (_Atomic int*) &handle->u.fd;
+
+  /* Set the pending flag first, so no new events will be added by other
+   * threads after this function returns. */
+  atomic_store(pending, 1);
 
   for (;;) {
-    /* 997 is not completely chosen at random. It's a prime number, acyclical
-     * by nature, and should therefore hopefully dampen sympathetic resonance.
+    /* 997 is not completely chosen at random. It's a prime number, acyclic by
+     * nature, and should therefore hopefully dampen sympathetic resonance.
      */
     for (i = 0; i < 997; i++) {
-      /* rc=0 -- handle is not pending.
-       * rc=1 -- handle is pending, other thread is still working with it.
-       * rc=2 -- handle is pending, other thread is done.
-       */
-      rc = cmpxchgi(&handle->pending, 2, 0);
-
-      if (rc != 1)
-        return rc;
+      if (atomic_load(busy) == 0)
+        return;
 
       /* Other thread is busy with this handle, spin until it's done. */
-      // cpu_relax();
+      uv__cpu_relax();
     }
 
     /* Yield the CPU. We may have preempted the other thread while it's
@@ -129,20 +112,23 @@ static int uv__async_spin(uv_async_t* handle) {
 }
 
 static void uv__async_io(uv_loop_t* loop) {
-  QUEUE queue;
-  QUEUE* q;
+  struct uv__queue queue;
+  struct uv__queue* q;
   uv_async_t* h;
+  _Atomic int *pending;
 
-  QUEUE_MOVE(&loop->async_handles, &queue);
-  while (!QUEUE_EMPTY(&queue)) {
-    q = QUEUE_HEAD(&queue);
-    h = QUEUE_DATA(q, uv_async_t, queue);
+  uv__queue_move(&loop->async_handles, &queue);
+  while (!uv__queue_empty(&queue)) {
+    q = uv__queue_head(&queue);
+    h = uv__queue_data(q, uv_async_t, queue);
 
-    QUEUE_REMOVE(q);
-    QUEUE_INSERT_TAIL(&loop->async_handles, q);
+    uv__queue_remove(q);
+    uv__queue_insert_tail(&loop->async_handles, q);
 
-    if (0 == uv__async_spin(h))
-      continue;  /* Not pending. */
+    /* Atomically fetch and clear pending flag */
+    pending = (_Atomic int*) &h->pending;
+    if (atomic_exchange(pending, 0) == 0)
+      continue;
 
     if (h->async_cb == NULL)
       continue;
@@ -195,28 +181,45 @@ static void uv__async_send(uv_loop_t* loop) {
 #define ACCESS_ONCE(type, var) (*(volatile type*) &(var))
 
 int uv_async_send(uv_async_t* handle) {
+  _Atomic int* pending;
+  _Atomic int* busy;
+
+  pending = (_Atomic int*) &handle->pending;
+  busy = (_Atomic int*) &handle->u.fd;
+
   /* Do a cheap read first. */
-  if (ACCESS_ONCE(int, handle->pending) != 0)
+  if (atomic_load_explicit(pending, memory_order_relaxed) != 0)
     return 0;
 
-  /* Tell the other thread we're busy with the handle. */
-  if (cmpxchgi(&handle->pending, 0, 1) != 0)
-    return 0;
+  /* Set the loop to busy. */
+  atomic_fetch_add(busy, 1);
 
   /* Wake up the other thread's event loop. */
-  uv__async_send(handle->loop);
+  if (atomic_exchange(pending, 1) == 0)
+    uv__async_send(handle->loop);
 
-  /* Tell the other thread we're done. */
-  if (cmpxchgi(&handle->pending, 1, 2) != 1)
-    abort();
+  /* Set the loop to not-busy. */
+  atomic_fetch_add(busy, -1);
 
   return 0;
 }
 
 void uv__async_close(uv_async_t* handle) {
   uv__async_spin(handle);
-  QUEUE_REMOVE(&handle->queue);
-  NEXT_TICK(((void (*)(void *))handle->close_cb), handle);
+  uv__queue_remove(&handle->queue);
+  uv__handle_stop(handle);
+}
+
+static void uv__cpu_relax(void) {
+#if defined(__i386__) || defined(__x86_64__)
+  __asm__ __volatile__ ("rep; nop" ::: "memory");  /* a.k.a. PAUSE */
+#elif (defined(__arm__) && __ARM_ARCH >= 7) || defined(__aarch64__)
+  __asm__ __volatile__ ("yield" ::: "memory");
+#elif (defined(__ppc__) || defined(__ppc64__)) && defined(__APPLE__)
+  __asm volatile ("" : : : "memory");
+#elif !defined(__APPLE__) && (defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__))
+  __asm__ __volatile__ ("or 1,1,1; or 2,2,2" ::: "memory");
+#endif
 }
 
 #endif

package/src/uv/unix/core.c

@@ -1,10 +1,18 @@
 #if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
 
+#include "uv.h"
+#include "internal.h"
 #include <errno.h>
 #include <time.h>
-#include "../uv-common.h"
+
+uint64_t uv_hrtime(void) {
+  return uv__hrtime(UV_CLOCK_PRECISE);
+}
 
 void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
+  assert(!uv__is_closing(handle));
+
+  handle->flags |= UV_HANDLE_CLOSING;
   handle->close_cb = close_cb;
 
   switch (handle->type) {
@@ -14,6 +22,33 @@ void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
   default:
     assert(0);
   }
+
+  uv__make_close_pending(handle);
+}
+
+static void uv__finish_close(uv_handle_t* handle) {
+  assert(handle->flags & UV_HANDLE_CLOSING);
+  assert(!(handle->flags & UV_HANDLE_CLOSED));
+  handle->flags |= UV_HANDLE_CLOSED;
+
+  uv__handle_unref(handle);
+  uv__queue_remove(&handle->handle_queue);
+
+  if (handle->close_cb) {
+    handle->close_cb(handle);
+  }
+}
+
+void uv__make_close_pending(uv_handle_t* handle) {
+  assert(handle->flags & UV_HANDLE_CLOSING);
+  assert(!(handle->flags & UV_HANDLE_CLOSED));
+  // handle->next_closing = handle->loop->closing_handles;
+  // handle->loop->closing_handles = handle;
+  NEXT_TICK(((void (*)(void *))uv__finish_close), handle);
+}
+
+int uv_is_closing(const uv_handle_t* handle) {
+  return uv__is_closing(handle);
 }
 
 int nanosleep(const struct timespec *, struct timespec *);

package/src/uv/unix/internal.h

@@ -0,0 +1,54 @@
+/* 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.
+ */
+
+#ifndef UV_UNIX_INTERNAL_H_
+#define UV_UNIX_INTERNAL_H_
+
+#include "../uv-common.h"
+#include "emnapi_common.h"
+#include <stdint.h>
+
+#ifndef EMNAPI_NEXTTICK_TYPE
+#define EMNAPI_NEXTTICK_TYPE 0
+#endif
+#if EMNAPI_NEXTTICK_TYPE == 0
+EMNAPI_INTERNAL_EXTERN void _emnapi_set_immediate(void (*callback)(void*), void* data);
+#define NEXT_TICK(callback, data) _emnapi_set_immediate((callback), (data))
+#elif EMNAPI_NEXTTICK_TYPE == 1
+EMNAPI_INTERNAL_EXTERN void _emnapi_next_tick(void (*callback)(void*), void* data);
+#define NEXT_TICK(callback, data) _emnapi_next_tick((callback), (data))
+#else
+#error "Invalid EMNAPI_NEXTTICK_TYPE"
+#endif
+
+typedef enum {
+  UV_CLOCK_PRECISE = 0,  /* Use the highest resolution clock available. */
+  UV_CLOCK_FAST = 1      /* Use the fastest clock with <= 1ms granularity. */
+} uv_clocktype_t;
+
+uint64_t uv__hrtime(uv_clocktype_t type);
+
+#if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
+void uv__async_close(uv_async_t* handle);
+void uv__make_close_pending(uv_handle_t* handle);
+#endif
+
+#endif /* UV_UNIX_INTERNAL_H_ */

package/src/uv/unix/loop.c

@@ -1,16 +1,38 @@
 #if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
 
 #include "../uv-common.h"
+#include <errno.h>
+#include <string.h>
 
 int _emnapi_create_proxying_queue(uv_loop_t* loop);
 void _emnapi_destroy_proxying_queue(uv_loop_t* loop);
 
 int uv_loop_init(uv_loop_t* loop) {
+  uv__loop_internal_fields_t* lfields;
+  void* saved_data;
   int err;
-  QUEUE_INIT(&loop->wq);
-  QUEUE_INIT(&loop->async_handles);
+
+  saved_data = loop->data;
+  memset(loop, 0, sizeof(*loop));
+  loop->data = saved_data;
+
+  lfields = (uv__loop_internal_fields_t*) uv__calloc(1, sizeof(*lfields));
+  if (lfields == NULL)
+    return ENOMEM;
+  loop->internal_fields = lfields;
+
+  err = uv_mutex_init(&lfields->loop_metrics.lock);
+  if (err)
+    goto fail_metrics_mutex_init;
+  memset(&lfields->loop_metrics.metrics,
+         0,
+         sizeof(lfields->loop_metrics.metrics));
+
+  uv__queue_init(&loop->wq);
+  uv__queue_init(&loop->async_handles);
+  uv__queue_init(&loop->handle_queue);
   err = _emnapi_create_proxying_queue(loop);
-  if (err) return err;
+  if (err) goto fail_proxying_queue_init;
   err = uv_mutex_init(&loop->wq_mutex);
   if (err) goto fail_mutex_init;
   err = uv_async_init(loop, &loop->wq_async, uv__work_done);
@@ -21,16 +43,30 @@ fail_async_init:
   uv_mutex_destroy(&loop->wq_mutex);
 
 fail_mutex_init:
+
+fail_proxying_queue_init:
+
+fail_metrics_mutex_init:
+  uv__free(lfields);
+  loop->internal_fields = NULL;
+
   return err;
 }
 
 void uv__loop_close(uv_loop_t* loop) {
+  uv__loop_internal_fields_t* lfields;
+
   uv_mutex_lock(&loop->wq_mutex);
-  assert(QUEUE_EMPTY(&loop->wq) && "thread pool work queue not empty!");
+  assert(uv__queue_empty(&loop->wq) && "thread pool work queue not empty!");
   assert(!uv__has_active_reqs(loop));
   _emnapi_destroy_proxying_queue(loop);
   uv_mutex_unlock(&loop->wq_mutex);
   uv_mutex_destroy(&loop->wq_mutex);
+
+  lfields = uv__get_internal_fields(loop);
+  uv_mutex_destroy(&lfields->loop_metrics.lock);
+  uv__free(lfields);
+  loop->internal_fields = NULL;
 }
 
 #endif

package/src/uv/unix/posix-hrtime.c

@@ -0,0 +1,40 @@
+/* Copyright libuv project 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.
+ */
+
+#if !defined(__wasm__) || (defined(__EMSCRIPTEN__) || defined(__wasi__))
+
+#include "uv.h"
+#include "internal.h"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <time.h>
+
+uint64_t uv__hrtime(uv_clocktype_t type) {
+  struct timespec t;
+
+  if (clock_gettime(CLOCK_MONOTONIC, &t))
+    abort();
+
+  return t.tv_sec * (uint64_t) 1e9 + t.tv_nsec;
+}
+
+#endif