helium-3rd-party/meta-openembedded
1
0
Fork 0
mirror of git://git.openembedded.org/meta-openembedded synced 2026-09-05 21:56:29 +00:00
Code Issues Packages Projects Releases Wiki Activity
meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs/0001-Revert-io_uring-changes-from-libuv-1.46.0.patch
Martin Jansa d08453978c nodejs: Revert io_uring support from bundled libuv-1.46.0 
* Pseudo fails to intercept some of the syscalls used by the
  new version as documented in:
  https://github.com/shr-project/com.webos.app.minimal/tree/recipes

Now we have 3 options:

1) every use of nodejs-native where io_uring might be used (like in webpack)
   needs to export UV_USE_IO_URING=0 before using node, but be aware that
   the PR says it's only temporary and this variable might be removed in future.
   Unfortunately many people are lucky enough not to know what pseudo even is,
   so they might not realize that host-user-contamination QA issues or
   "KeyError: 'getpwuid(): uid not found" might be related to this (and they
   probably won't find this e-mail as well:
   https://lists.openembedded.org/g/openembedded-devel/message/105583

2) revert the io_uring changes from bundled libuv, to make sure it stays disabled.
   The changes are massive and it will be PIA to update them for every nodejs release
   I've already separated them for nodejs-20.3.0 where I've initialy tested this
   on top of libuv-1.45.0 and for 20.4.0 this need another patch for changes
   from libuv-1.46.0.
   Patch for keeping UV_USE_IO_URING support after it's removed from upstream libuv
   will be much smaller, but PIA to use UV_USE_IO_URING whenever using nodejs-native
   during build.

3) fix pseudo to correctly work with io_uring calls, definitely best long-term solution
   as more and more tools will now switch to io_uring, but without active maintainer
   of pseudo it might be _very_ difficult to implement this and there aren't many
   people willing to touch this beast.

Signed-off-by: Martin Jansa <martin.jansa@gmail.com>
Signed-off-by: Khem Raj <raj.khem@gmail.com>
2023-10-19 07:58:51 -07:00

3415 lines
121 KiB
Diff
Raw Blame History

From 937dfa70104b7401a7570a98cf6e0a534e250557 Mon Sep 17 00:00:00 2001
From: Martin Jansa <martin.jansa@gmail.com>
Date: Wed, 18 Oct 2023 22:43:55 +0200
Subject: [PATCH] Revert io_uring changes from libuv-1.46.0
Included in nodejs-20.4.0 with the libuv upgrade to 1.46.0 in:
https://github.com/nodejs/node/commit/6199e1946c9abd59bd71a61870a4f6c85e100b18
Revert "linux: work around io_uring IORING_OP_CLOSE bug (#4059)"
This reverts commit 1752791c9ea89dbf54e2a20a9d9f899119a2d179.
Revert "linux: fs_read to use io_uring if iovcnt > IOV_MAX (#4023)"
This reverts commit e7b96331703e929e75d93c574573c9736e34b0c0.
Revert "linux: add some more iouring backed fs ops (#4012)"
This reverts commit 962b8e626ceaaf296eecab1d008e8b70dc6da5e7.
Revert "android: disable io_uring support (#4016)"
This reverts commit 281e6185cc9e77c582ff6ca9e4c00d57e6b90d95.
Revert "unix,win: replace QUEUE with struct uv__queue (#4022)"
This reverts commit 1b01b786c0180d29f07dccbb98001a2b3148828a.
Revert "fs: use WTF-8 on Windows (#2970)"
This reverts commit 8f32a14afaaa47514a7d28e1e069a8329e2dd939.
Dropped deps/uv/docs deps/uv/test changes as these dirs aren't included
in nodejs tarballs.
Signed-off-by: Martin Jansa <martin.jansa@gmail.com>
---
Upstream-Status: Inappropriate [OE specific]
deps/uv/include/uv.h | 10 +-
deps/uv/include/uv/darwin.h | 6 +-
deps/uv/include/uv/linux.h | 2 +-
deps/uv/include/uv/threadpool.h | 2 +-
deps/uv/include/uv/unix.h | 44 ++--
deps/uv/include/uv/win.h | 4 +-
deps/uv/src/queue.h | 154 ++++++-----
deps/uv/src/threadpool.c | 72 +++---
deps/uv/src/unix/aix.c | 14 +-
deps/uv/src/unix/async.c | 52 ++--
deps/uv/src/unix/core.c | 53 ++--
deps/uv/src/unix/fs.c | 41 +--
deps/uv/src/unix/fsevents.c | 84 +++---
deps/uv/src/unix/internal.h | 11 -
deps/uv/src/unix/kqueue.c | 18 +-
deps/uv/src/unix/linux.c | 257 +++----------------
deps/uv/src/unix/loop-watcher.c | 20 +-
deps/uv/src/unix/loop.c | 28 +-
deps/uv/src/unix/os390-syscalls.c | 24 +-
deps/uv/src/unix/os390-syscalls.h | 2 +-
deps/uv/src/unix/os390.c | 14 +-
deps/uv/src/unix/pipe.c | 2 +-
deps/uv/src/unix/posix-poll.c | 14 +-
deps/uv/src/unix/process.c | 38 +--
deps/uv/src/unix/signal.c | 8 +-
deps/uv/src/unix/stream.c | 56 ++--
deps/uv/src/unix/sunos.c | 18 +-
deps/uv/src/unix/tcp.c | 4 +-
deps/uv/src/unix/tty.c | 2 +-
deps/uv/src/unix/udp.c | 76 +++---
deps/uv/src/uv-common.c | 28 +-
deps/uv/src/uv-common.h | 3 +-
deps/uv/src/win/core.c | 6 +-
deps/uv/src/win/fs.c | 311 ++++++++---------------
deps/uv/src/win/handle-inl.h | 2 +-
deps/uv/src/win/pipe.c | 26 +-
deps/uv/src/win/tcp.c | 4 +-
deps/uv/src/win/udp.c | 4 +-
deps/uv/test/test-fs.c | 53 ----
deps/uv/test/test-list.h | 2 -
deps/uv/test/test-queue-foreach-delete.c | 5 +-
deps/uv/test/test-threadpool-cancel.c | 5 -
42 files changed, 625 insertions(+), 954 deletions(-)
diff --git a/deps/uv/include/uv.h b/deps/uv/include/uv.h
index 02397dd0fdd..1af95289776 100644
--- a/deps/uv/include/uv.h
+++ b/deps/uv/include/uv.h
@@ -59,12 +59,6 @@ extern "C" {
#include <stdio.h>
#include <stdint.h>
-/* Internal type, do not use. */
-struct uv__queue {
- struct uv__queue* next;
- struct uv__queue* prev;
-};
-
#if defined(_WIN32)
# include "uv/win.h"
#else
@@ -466,7 +460,7 @@ struct uv_shutdown_s {
uv_handle_type type; \
/* private */ \
uv_close_cb close_cb; \
- struct uv__queue handle_queue; \
+ void* handle_queue[2]; \
union { \
int fd; \
void* reserved[4]; \
@@ -1870,7 +1864,7 @@ struct uv_loop_s {
void* data;
/* Loop reference counting. */
unsigned int active_handles;
- struct uv__queue handle_queue;
+ void* handle_queue[2];
union {
void* unused;
unsigned int count;
diff --git a/deps/uv/include/uv/darwin.h b/deps/uv/include/uv/darwin.h
index 06962bfda80..d226415820b 100644
--- a/deps/uv/include/uv/darwin.h
+++ b/deps/uv/include/uv/darwin.h
@@ -40,7 +40,7 @@
void* cf_state; \
uv_mutex_t cf_mutex; \
uv_sem_t cf_sem; \
- struct uv__queue cf_signals; \
+ void* cf_signals[2]; \
#define UV_PLATFORM_FS_EVENT_FIELDS \
uv__io_t event_watcher; \
@@ -48,8 +48,8 @@
int realpath_len; \
int cf_flags; \
uv_async_t* cf_cb; \
- struct uv__queue cf_events; \
- struct uv__queue cf_member; \
+ void* cf_events[2]; \
+ void* cf_member[2]; \
int cf_error; \
uv_mutex_t cf_mutex; \
diff --git a/deps/uv/include/uv/linux.h b/deps/uv/include/uv/linux.h
index 9f22f8cf726..9b38405a190 100644
--- a/deps/uv/include/uv/linux.h
+++ b/deps/uv/include/uv/linux.h
@@ -28,7 +28,7 @@
int inotify_fd; \
#define UV_PLATFORM_FS_EVENT_FIELDS \
- struct uv__queue watchers; \
+ void* watchers[2]; \
int wd; \
#endif /* UV_LINUX_H */
diff --git a/deps/uv/include/uv/threadpool.h b/deps/uv/include/uv/threadpool.h
index 24ce916fda4..9708ebdd530 100644
--- a/deps/uv/include/uv/threadpool.h
+++ b/deps/uv/include/uv/threadpool.h
@@ -31,7 +31,7 @@ struct uv__work {
void (*work)(struct uv__work *w);
void (*done)(struct uv__work *w, int status);
struct uv_loop_s* loop;
- struct uv__queue wq;
+ void* wq[2];
};
#endif /* UV_THREADPOOL_H_ */
diff --git a/deps/uv/include/uv/unix.h b/deps/uv/include/uv/unix.h
index 09f88a56742..95447b8dd67 100644
--- a/deps/uv/include/uv/unix.h
+++ b/deps/uv/include/uv/unix.h
@@ -92,8 +92,8 @@ typedef struct uv__io_s uv__io_t;
struct uv__io_s {
uv__io_cb cb;
- struct uv__queue pending_queue;
- struct uv__queue watcher_queue;
+ void* pending_queue[2];
+ void* watcher_queue[2];
unsigned int pevents; /* Pending event mask i.e. mask at next tick. */
unsigned int events; /* Current event mask. */
int fd;
@@ -220,21 +220,21 @@ typedef struct {
#define UV_LOOP_PRIVATE_FIELDS \
unsigned long flags; \
int backend_fd; \
- struct uv__queue pending_queue; \
- struct uv__queue watcher_queue; \
+ void* pending_queue[2]; \
+ void* watcher_queue[2]; \
uv__io_t** watchers; \
unsigned int nwatchers; \
unsigned int nfds; \
- struct uv__queue wq; \
+ void* wq[2]; \
uv_mutex_t wq_mutex; \
uv_async_t wq_async; \
uv_rwlock_t cloexec_lock; \
uv_handle_t* closing_handles; \
- struct uv__queue process_handles; \
- struct uv__queue prepare_handles; \
- struct uv__queue check_handles; \
- struct uv__queue idle_handles; \
- struct uv__queue async_handles; \
+ void* process_handles[2]; \
+ void* prepare_handles[2]; \
+ void* check_handles[2]; \
+ void* idle_handles[2]; \
+ void* async_handles[2]; \
void (*async_unused)(void); /* TODO(bnoordhuis) Remove in libuv v2. */ \
uv__io_t async_io_watcher; \
int async_wfd; \
@@ -257,7 +257,7 @@ typedef struct {
#define UV_PRIVATE_REQ_TYPES /* empty */
#define UV_WRITE_PRIVATE_FIELDS \
- struct uv__queue queue; \
+ void* queue[2]; \
unsigned int write_index; \
uv_buf_t* bufs; \
unsigned int nbufs; \
@@ -265,12 +265,12 @@ typedef struct {
uv_buf_t bufsml[4]; \
#define UV_CONNECT_PRIVATE_FIELDS \
- struct uv__queue queue; \
+ void* queue[2]; \
#define UV_SHUTDOWN_PRIVATE_FIELDS /* empty */
#define UV_UDP_SEND_PRIVATE_FIELDS \
- struct uv__queue queue; \
+ void* queue[2]; \
struct sockaddr_storage addr; \
unsigned int nbufs; \
uv_buf_t* bufs; \
@@ -286,8 +286,8 @@ typedef struct {
uv_connect_t *connect_req; \
uv_shutdown_t *shutdown_req; \
uv__io_t io_watcher; \
- struct uv__queue write_queue; \
- struct uv__queue write_completed_queue; \
+ void* write_queue[2]; \
+ void* write_completed_queue[2]; \
uv_connection_cb connection_cb; \
int delayed_error; \
int accepted_fd; \
@@ -300,8 +300,8 @@ typedef struct {
uv_alloc_cb alloc_cb; \
uv_udp_recv_cb recv_cb; \
uv__io_t io_watcher; \
- struct uv__queue write_queue; \
- struct uv__queue write_completed_queue; \
+ void* write_queue[2]; \
+ void* write_completed_queue[2]; \
#define UV_PIPE_PRIVATE_FIELDS \
const char* pipe_fname; /* NULL or strdup'ed */
@@ -311,19 +311,19 @@ typedef struct {
#define UV_PREPARE_PRIVATE_FIELDS \
uv_prepare_cb prepare_cb; \
- struct uv__queue queue; \
+ void* queue[2]; \
#define UV_CHECK_PRIVATE_FIELDS \
uv_check_cb check_cb; \
- struct uv__queue queue; \
+ void* queue[2]; \
#define UV_IDLE_PRIVATE_FIELDS \
uv_idle_cb idle_cb; \
- struct uv__queue queue; \
+ void* queue[2]; \
#define UV_ASYNC_PRIVATE_FIELDS \
uv_async_cb async_cb; \
- struct uv__queue queue; \
+ void* queue[2]; \
int pending; \
#define UV_TIMER_PRIVATE_FIELDS \
@@ -352,7 +352,7 @@ typedef struct {
int retcode;
#define UV_PROCESS_PRIVATE_FIELDS \
- struct uv__queue queue; \
+ void* queue[2]; \
int status; \
#define UV_FS_PRIVATE_FIELDS \
diff --git a/deps/uv/include/uv/win.h b/deps/uv/include/uv/win.h
index 6f8c47298e4..92a95fa15f1 100644
--- a/deps/uv/include/uv/win.h
+++ b/deps/uv/include/uv/win.h
@@ -357,7 +357,7 @@ typedef struct {
/* Counter to started timer */ \
uint64_t timer_counter; \
/* Threadpool */ \
- struct uv__queue wq; \
+ void* wq[2]; \
uv_mutex_t wq_mutex; \
uv_async_t wq_async;
@@ -486,7 +486,7 @@ typedef struct {
uint32_t payload_remaining; \
uint64_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \
} ipc_data_frame; \
- struct uv__queue ipc_xfer_queue; \
+ void* ipc_xfer_queue[2]; \
int ipc_xfer_queue_length; \
uv_write_t* non_overlapped_writes_tail; \
CRITICAL_SECTION readfile_thread_lock; \
diff --git a/deps/uv/src/queue.h b/deps/uv/src/queue.h
index 5f8489e9bc5..ff3540a0a51 100644
--- a/deps/uv/src/queue.h
+++ b/deps/uv/src/queue.h
@@ -18,73 +18,91 @@
#include <stddef.h>
-#define uv__queue_data(pointer, type, field) \
- ((type*) ((char*) (pointer) - offsetof(type, field)))
-
-#define uv__queue_foreach(q, h) \
- for ((q) = (h)->next; (q) != (h); (q) = (q)->next)
-
-static inline void uv__queue_init(struct uv__queue* q) {
- q->next = q;
- q->prev = q;
-}
-
-static inline int uv__queue_empty(const struct uv__queue* q) {
- return q == q->next;
-}
-
-static inline struct uv__queue* uv__queue_head(const struct uv__queue* q) {
- return q->next;
-}
-
-static inline struct uv__queue* uv__queue_next(const struct uv__queue* q) {
- return q->next;
-}
-
-static inline void uv__queue_add(struct uv__queue* h, struct uv__queue* n) {
- h->prev->next = n->next;
- n->next->prev = h->prev;
- h->prev = n->prev;
- h->prev->next = h;
-}
-
-static inline void uv__queue_split(struct uv__queue* h,
- struct uv__queue* q,
- struct uv__queue* n) {
- n->prev = h->prev;
- n->prev->next = n;
- n->next = q;
- h->prev = q->prev;
- h->prev->next = h;
- q->prev = n;
-}
-
-static inline void uv__queue_move(struct uv__queue* h, struct uv__queue* n) {
- if (uv__queue_empty(h))
- uv__queue_init(n);
- else
- uv__queue_split(h, h->next, n);
-}
-
-static inline void uv__queue_insert_head(struct uv__queue* h,
- struct uv__queue* q) {
- q->next = h->next;
- q->prev = h;
- q->next->prev = q;
- h->next = q;
-}
-
-static inline void uv__queue_insert_tail(struct uv__queue* h,
- struct uv__queue* q) {
- q->next = h;
- q->prev = h->prev;
- q->prev->next = q;
- h->prev = q;
-}
-
-static inline void uv__queue_remove(struct uv__queue* q) {
- q->prev->next = q->next;
- q->next->prev = q->prev;
-}
+typedef void *QUEUE[2];
+
+/* Private macros. */
+#define QUEUE_NEXT(q) (*(QUEUE **) &((*(q))[0]))
+#define QUEUE_PREV(q) (*(QUEUE **) &((*(q))[1]))
+#define QUEUE_PREV_NEXT(q) (QUEUE_NEXT(QUEUE_PREV(q)))
+#define QUEUE_NEXT_PREV(q) (QUEUE_PREV(QUEUE_NEXT(q)))
+
+/* Public macros. */
+#define QUEUE_DATA(ptr, type, field) \
+ ((type *) ((char *) (ptr) - offsetof(type, field)))
+
+/* Important note: mutating the list while QUEUE_FOREACH is
+ * iterating over its elements results in undefined behavior.
+ */
+#define QUEUE_FOREACH(q, h) \
+ for ((q) = QUEUE_NEXT(h); (q) != (h); (q) = QUEUE_NEXT(q))
+
+#define QUEUE_EMPTY(q) \
+ ((const QUEUE *) (q) == (const QUEUE *) QUEUE_NEXT(q))
+
+#define QUEUE_HEAD(q) \
+ (QUEUE_NEXT(q))
+
+#define QUEUE_INIT(q) \
+ do { \
+ QUEUE_NEXT(q) = (q); \
+ QUEUE_PREV(q) = (q); \
+ } \
+ while (0)
+
+#define QUEUE_ADD(h, n) \
+ do { \
+ QUEUE_PREV_NEXT(h) = QUEUE_NEXT(n); \
+ QUEUE_NEXT_PREV(n) = QUEUE_PREV(h); \
+ QUEUE_PREV(h) = QUEUE_PREV(n); \
+ QUEUE_PREV_NEXT(h) = (h); \
+ } \
+ while (0)
+
+#define QUEUE_SPLIT(h, q, n) \
+ do { \
+ QUEUE_PREV(n) = QUEUE_PREV(h); \
+ QUEUE_PREV_NEXT(n) = (n); \
+ QUEUE_NEXT(n) = (q); \
+ QUEUE_PREV(h) = QUEUE_PREV(q); \
+ QUEUE_PREV_NEXT(h) = (h); \
+ QUEUE_PREV(q) = (n); \
+ } \
+ while (0)
+
+#define QUEUE_MOVE(h, n) \
+ do { \
+ if (QUEUE_EMPTY(h)) \
+ QUEUE_INIT(n); \
+ else { \
+ QUEUE* q = QUEUE_HEAD(h); \
+ QUEUE_SPLIT(h, q, n); \
+ } \
+ } \
+ while (0)
+
+#define QUEUE_INSERT_HEAD(h, q) \
+ do { \
+ QUEUE_NEXT(q) = QUEUE_NEXT(h); \
+ QUEUE_PREV(q) = (h); \
+ QUEUE_NEXT_PREV(q) = (q); \
+ QUEUE_NEXT(h) = (q); \
+ } \
+ while (0)
+
+#define QUEUE_INSERT_TAIL(h, q) \
+ do { \
+ QUEUE_NEXT(q) = (h); \
+ QUEUE_PREV(q) = QUEUE_PREV(h); \
+ QUEUE_PREV_NEXT(q) = (q); \
+ QUEUE_PREV(h) = (q); \
+ } \
+ while (0)
+
+#define QUEUE_REMOVE(q) \
+ do { \
+ QUEUE_PREV_NEXT(q) = QUEUE_NEXT(q); \
+ QUEUE_NEXT_PREV(q) = QUEUE_PREV(q); \
+ } \
+ while (0)
#endif /* QUEUE_H_ */
diff --git a/deps/uv/src/threadpool.c b/deps/uv/src/threadpool.c
index dbef67f2f10..51962bf0021 100644
--- a/deps/uv/src/threadpool.c
+++ b/deps/uv/src/threadpool.c
@@ -37,10 +37,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 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 QUEUE exit_message;
+static QUEUE wq;
+static QUEUE run_slow_work_message;
+static QUEUE slow_io_pending_wq;
static unsigned int slow_work_thread_threshold(void) {
return (nthreads + 1) / 2;
@@ -56,7 +56,7 @@ static void uv__cancelled(struct uv__work* w) {
*/
static void worker(void* arg) {
struct uv__work* w;
- struct uv__queue* q;
+ QUEUE* q;
int is_slow_work;
uv_sem_post((uv_sem_t*) arg);
@@ -68,49 +68,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 (uv__queue_empty(&wq) ||
- (uv__queue_head(&wq) == &run_slow_work_message &&
- uv__queue_next(&run_slow_work_message) == &wq &&
+ while (QUEUE_EMPTY(&wq) ||
+ (QUEUE_HEAD(&wq) == &run_slow_work_message &&
+ 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 = uv__queue_head(&wq);
+ q = QUEUE_HEAD(&wq);
if (q == &exit_message) {
uv_cond_signal(&cond);
uv_mutex_unlock(&mutex);
break;
}
- uv__queue_remove(q);
- uv__queue_init(q); /* Signal uv_cancel() that the work req is executing. */
+ QUEUE_REMOVE(q);
+ 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()) {
- uv__queue_insert_tail(&wq, q);
+ 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 (uv__queue_empty(&slow_io_pending_wq))
+ if (QUEUE_EMPTY(&slow_io_pending_wq))
continue;
is_slow_work = 1;
slow_io_work_running++;
- q = uv__queue_head(&slow_io_pending_wq);
- uv__queue_remove(q);
- uv__queue_init(q);
+ q = QUEUE_HEAD(&slow_io_pending_wq);
+ QUEUE_REMOVE(q);
+ QUEUE_INIT(q);
/* If there is more slow I/O work, schedule it to be run as well. */
- if (!uv__queue_empty(&slow_io_pending_wq)) {
- uv__queue_insert_tail(&wq, &run_slow_work_message);
+ if (!QUEUE_EMPTY(&slow_io_pending_wq)) {
+ QUEUE_INSERT_TAIL(&wq, &run_slow_work_message);
if (idle_threads > 0)
uv_cond_signal(&cond);
}
@@ -118,13 +118,13 @@ static void worker(void* arg) {
uv_mutex_unlock(&mutex);
- w = uv__queue_data(q, struct uv__work, wq);
+ w = 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. */
- uv__queue_insert_tail(&w->loop->wq, &w->wq);
+ QUEUE_INSERT_TAIL(&w->loop->wq, &w->wq);
uv_async_send(&w->loop->wq_async);
uv_mutex_unlock(&w->loop->wq_mutex);
@@ -139,12 +139,12 @@ static void worker(void* arg) {
}
-static void post(struct uv__queue* q, enum uv__work_kind kind) {
+static void post(QUEUE* q, enum uv__work_kind kind) {
uv_mutex_lock(&mutex);
if (kind == UV__WORK_SLOW_IO) {
/* Insert into a separate queue. */
- uv__queue_insert_tail(&slow_io_pending_wq, q);
- if (!uv__queue_empty(&run_slow_work_message)) {
+ QUEUE_INSERT_TAIL(&slow_io_pending_wq, q);
+ if (!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);
@@ -153,7 +153,7 @@ static void post(struct uv__queue* q, enum uv__work_kind kind) {
q = &run_slow_work_message;
}
- uv__queue_insert_tail(&wq, q);
+ QUEUE_INSERT_TAIL(&wq, q);
if (idle_threads > 0)
uv_cond_signal(&cond);
uv_mutex_unlock(&mutex);
@@ -220,9 +220,9 @@ static void init_threads(void) {
if (uv_mutex_init(&mutex))
abort();
- uv__queue_init(&wq);
- uv__queue_init(&slow_io_pending_wq);
- uv__queue_init(&run_slow_work_message);
+ QUEUE_INIT(&wq);
+ QUEUE_INIT(&slow_io_pending_wq);
+ QUEUE_INIT(&run_slow_work_message);
if (uv_sem_init(&sem, 0))
abort();
@@ -285,9 +285,9 @@ static int uv__work_cancel(uv_loop_t* loop, uv_req_t* req, struct uv__work* w) {
uv_mutex_lock(&mutex);
uv_mutex_lock(&w->loop->wq_mutex);
- cancelled = !uv__queue_empty(&w->wq) && w->work != NULL;
+ cancelled = !QUEUE_EMPTY(&w->wq) && w->work != NULL;
if (cancelled)
- uv__queue_remove(&w->wq);
+ QUEUE_REMOVE(&w->wq);
uv_mutex_unlock(&w->loop->wq_mutex);
uv_mutex_unlock(&mutex);
@@ -297,7 +297,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);
- uv__queue_insert_tail(&loop->wq, &w->wq);
+ QUEUE_INSERT_TAIL(&loop->wq, &w->wq);
uv_async_send(&loop->wq_async);
uv_mutex_unlock(&loop->wq_mutex);
@@ -308,21 +308,21 @@ 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;
- struct uv__queue* q;
- struct uv__queue wq;
+ QUEUE* q;
+ QUEUE wq;
int err;
int nevents;
loop = container_of(handle, uv_loop_t, wq_async);
uv_mutex_lock(&loop->wq_mutex);
- uv__queue_move(&loop->wq, &wq);
+ QUEUE_MOVE(&loop->wq, &wq);
uv_mutex_unlock(&loop->wq_mutex);
nevents = 0;
- while (!uv__queue_empty(&wq)) {
- q = uv__queue_head(&wq);
- uv__queue_remove(q);
+ while (!QUEUE_EMPTY(&wq)) {
+ q = QUEUE_HEAD(&wq);
+ QUEUE_REMOVE(q);
w = container_of(q, struct uv__work, wq);
err = (w->work == uv__cancelled) ? UV_ECANCELED : 0;
diff --git a/deps/uv/src/unix/aix.c b/deps/uv/src/unix/aix.c
index 3af3009a216..f1afbed49ec 100644
--- a/deps/uv/src/unix/aix.c
+++ b/deps/uv/src/unix/aix.c
@@ -136,7 +136,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
struct pollfd pqry;
struct pollfd* pe;
struct poll_ctl pc;
- struct uv__queue* q;
+ QUEUE* q;
uv__io_t* w;
uint64_t base;
uint64_t diff;
@@ -151,18 +151,18 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
int reset_timeout;
if (loop->nfds == 0) {
- assert(uv__queue_empty(&loop->watcher_queue));
+ assert(QUEUE_EMPTY(&loop->watcher_queue));
return;
}
lfields = uv__get_internal_fields(loop);
- while (!uv__queue_empty(&loop->watcher_queue)) {
- q = uv__queue_head(&loop->watcher_queue);
- uv__queue_remove(q);
- uv__queue_init(q);
+ while (!QUEUE_EMPTY(&loop->watcher_queue)) {
+ q = QUEUE_HEAD(&loop->watcher_queue);
+ QUEUE_REMOVE(q);
+ QUEUE_INIT(q);
- w = uv__queue_data(q, uv__io_t, watcher_queue);
+ w = QUEUE_DATA(q, uv__io_t, watcher_queue);
assert(w->pevents != 0);
assert(w->fd >= 0);
assert(w->fd < (int) loop->nwatchers);
diff --git a/deps/uv/src/unix/async.c b/deps/uv/src/unix/async.c
index 0ff2669e30a..5751b6d02be 100644
--- a/deps/uv/src/unix/async.c
+++ b/deps/uv/src/unix/async.c
@@ -55,7 +55,7 @@ int uv_async_init(uv_loop_t* loop, uv_async_t* handle, uv_async_cb async_cb) {
handle->pending = 0;
handle->u.fd = 0; /* This will be used as a busy flag. */
- uv__queue_insert_tail(&loop->async_handles, &handle->queue);
+ QUEUE_INSERT_TAIL(&loop->async_handles, &handle->queue);
uv__handle_start(handle);
return 0;
@@ -124,7 +124,7 @@ static void uv__async_spin(uv_async_t* handle) {
void uv__async_close(uv_async_t* handle) {
uv__async_spin(handle);
- uv__queue_remove(&handle->queue);
+ QUEUE_REMOVE(&handle->queue);
uv__handle_stop(handle);
}
@@ -132,8 +132,8 @@ void uv__async_close(uv_async_t* handle) {
static void uv__async_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
char buf[1024];
ssize_t r;
- struct uv__queue queue;
- struct uv__queue* q;
+ QUEUE queue;
+ QUEUE* q;
uv_async_t* h;
_Atomic int *pending;
@@ -157,13 +157,13 @@ static void uv__async_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
abort();
}
- 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_MOVE(&loop->async_handles, &queue);
+ while (!QUEUE_EMPTY(&queue)) {
+ q = QUEUE_HEAD(&queue);
+ h = QUEUE_DATA(q, uv_async_t, queue);
- uv__queue_remove(q);
- uv__queue_insert_tail(&loop->async_handles, q);
+ QUEUE_REMOVE(q);
+ QUEUE_INSERT_TAIL(&loop->async_handles, q);
/* Atomically fetch and clear pending flag */
pending = (_Atomic int*) &h->pending;
@@ -241,8 +241,8 @@ static int uv__async_start(uv_loop_t* loop) {
void uv__async_stop(uv_loop_t* loop) {
- struct uv__queue queue;
- struct uv__queue* q;
+ QUEUE queue;
+ QUEUE* q;
uv_async_t* h;
if (loop->async_io_watcher.fd == -1)
@@ -251,13 +251,13 @@ void uv__async_stop(uv_loop_t* loop) {
/* Make sure no other thread is accessing the async handle fd after the loop
* cleanup.
*/
- 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_MOVE(&loop->async_handles, &queue);
+ while (!QUEUE_EMPTY(&queue)) {
+ q = QUEUE_HEAD(&queue);
+ h = QUEUE_DATA(q, uv_async_t, queue);
- uv__queue_remove(q);
- uv__queue_insert_tail(&loop->async_handles, q);
+ QUEUE_REMOVE(q);
+ QUEUE_INSERT_TAIL(&loop->async_handles, q);
uv__async_spin(h);
}
@@ -275,20 +275,20 @@ void uv__async_stop(uv_loop_t* loop) {
int uv__async_fork(uv_loop_t* loop) {
- struct uv__queue queue;
- struct uv__queue* q;
+ QUEUE queue;
+ QUEUE* q;
uv_async_t* h;
if (loop->async_io_watcher.fd == -1) /* never started */
return 0;
- 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_MOVE(&loop->async_handles, &queue);
+ while (!QUEUE_EMPTY(&queue)) {
+ q = QUEUE_HEAD(&queue);
+ h = QUEUE_DATA(q, uv_async_t, queue);
- uv__queue_remove(q);
- uv__queue_insert_tail(&loop->async_handles, q);
+ QUEUE_REMOVE(q);
+ QUEUE_INSERT_TAIL(&loop->async_handles, q);
/* The state of any thread that set pending is now likely corrupt in this
* child because the user called fork, so just clear these flags and move
diff --git a/deps/uv/src/unix/core.c b/deps/uv/src/unix/core.c
index 25c5181f370..55aa962787e 100644
--- a/deps/uv/src/unix/core.c
+++ b/deps/uv/src/unix/core.c
@@ -344,7 +344,7 @@ static void uv__finish_close(uv_handle_t* handle) {
}
uv__handle_unref(handle);
- uv__queue_remove(&handle->handle_queue);
+ QUEUE_REMOVE(&handle->handle_queue);
if (handle->close_cb) {
handle->close_cb(handle);
@@ -380,7 +380,7 @@ int uv_backend_fd(const uv_loop_t* loop) {
static int uv__loop_alive(const uv_loop_t* loop) {
return uv__has_active_handles(loop) ||
uv__has_active_reqs(loop) ||
- !uv__queue_empty(&loop->pending_queue) ||
+ !QUEUE_EMPTY(&loop->pending_queue) ||
loop->closing_handles != NULL;
}
@@ -389,8 +389,8 @@ static int uv__backend_timeout(const uv_loop_t* loop) {
if (loop->stop_flag == 0 &&
/* uv__loop_alive(loop) && */
(uv__has_active_handles(loop) || uv__has_active_reqs(loop)) &&
- uv__queue_empty(&loop->pending_queue) &&
- uv__queue_empty(&loop->idle_handles) &&
+ QUEUE_EMPTY(&loop->pending_queue) &&
+ QUEUE_EMPTY(&loop->idle_handles) &&
(loop->flags & UV_LOOP_REAP_CHILDREN) == 0 &&
loop->closing_handles == NULL)
return uv__next_timeout(loop);
@@ -399,7 +399,7 @@ static int uv__backend_timeout(const uv_loop_t* loop) {
int uv_backend_timeout(const uv_loop_t* loop) {
- if (uv__queue_empty(&loop->watcher_queue))
+ if (QUEUE_EMPTY(&loop->watcher_queue))
return uv__backend_timeout(loop);
/* Need to call uv_run to update the backend fd state. */
return 0;
@@ -431,8 +431,7 @@ int uv_run(uv_loop_t* loop, uv_run_mode mode) {
while (r != 0 && loop->stop_flag == 0) {
can_sleep =
- uv__queue_empty(&loop->pending_queue) &&
- uv__queue_empty(&loop->idle_handles);
+ QUEUE_EMPTY(&loop->pending_queue) && QUEUE_EMPTY(&loop->idle_handles);
uv__run_pending(loop);
uv__run_idle(loop);
@@ -448,7 +447,7 @@ int uv_run(uv_loop_t* loop, uv_run_mode mode) {
/* Process immediate callbacks (e.g. write_cb) a small fixed number of
* times to avoid loop starvation.*/
- for (r = 0; r < 8 && !uv__queue_empty(&loop->pending_queue); r++)
+ for (r = 0; r < 8 && !QUEUE_EMPTY(&loop->pending_queue); r++)
uv__run_pending(loop);
/* Run one final update on the provider_idle_time in case uv__io_poll
@@ -827,17 +826,17 @@ int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd) {
static void uv__run_pending(uv_loop_t* loop) {
- struct uv__queue* q;
- struct uv__queue pq;
+ QUEUE* q;
+ QUEUE pq;
uv__io_t* w;
- uv__queue_move(&loop->pending_queue, &pq);
+ QUEUE_MOVE(&loop->pending_queue, &pq);
- while (!uv__queue_empty(&pq)) {
- q = uv__queue_head(&pq);
- uv__queue_remove(q);
- uv__queue_init(q);
- w = uv__queue_data(q, uv__io_t, pending_queue);
+ while (!QUEUE_EMPTY(&pq)) {
+ q = QUEUE_HEAD(&pq);
+ QUEUE_REMOVE(q);
+ QUEUE_INIT(q);
+ w = QUEUE_DATA(q, uv__io_t, pending_queue);
w->cb(loop, w, POLLOUT);
}
}
@@ -892,8 +891,8 @@ static void maybe_resize(uv_loop_t* loop, unsigned int len) {
void uv__io_init(uv__io_t* w, uv__io_cb cb, int fd) {
assert(cb != NULL);
assert(fd >= -1);
- uv__queue_init(&w->pending_queue);
- uv__queue_init(&w->watcher_queue);
+ QUEUE_INIT(&w->pending_queue);
+ QUEUE_INIT(&w->watcher_queue);
w->cb = cb;
w->fd = fd;
w->events = 0;
@@ -919,8 +918,8 @@ void uv__io_start(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
return;
#endif
- if (uv__queue_empty(&w->watcher_queue))
- uv__queue_insert_tail(&loop->watcher_queue, &w->watcher_queue);
+ if (QUEUE_EMPTY(&w->watcher_queue))
+ QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
if (loop->watchers[w->fd] == NULL) {
loop->watchers[w->fd] = w;
@@ -945,8 +944,8 @@ void uv__io_stop(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
w->pevents &= ~events;
if (w->pevents == 0) {
- uv__queue_remove(&w->watcher_queue);
- uv__queue_init(&w->watcher_queue);
+ QUEUE_REMOVE(&w->watcher_queue);
+ QUEUE_INIT(&w->watcher_queue);
w->events = 0;
if (w == loop->watchers[w->fd]) {
@@ -955,14 +954,14 @@ void uv__io_stop(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
loop->nfds--;
}
}
- else if (uv__queue_empty(&w->watcher_queue))
- uv__queue_insert_tail(&loop->watcher_queue, &w->watcher_queue);
+ else if (QUEUE_EMPTY(&w->watcher_queue))
+ QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
}
void uv__io_close(uv_loop_t* loop, uv__io_t* w) {
uv__io_stop(loop, w, POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);
- uv__queue_remove(&w->pending_queue);
+ QUEUE_REMOVE(&w->pending_queue);
/* Remove stale events for this file descriptor */
if (w->fd != -1)
@@ -971,8 +970,8 @@ void uv__io_close(uv_loop_t* loop, uv__io_t* w) {
void uv__io_feed(uv_loop_t* loop, uv__io_t* w) {
- if (uv__queue_empty(&w->pending_queue))
- uv__queue_insert_tail(&loop->pending_queue, &w->pending_queue);
+ if (QUEUE_EMPTY(&w->pending_queue))
+ QUEUE_INSERT_TAIL(&loop->pending_queue, &w->pending_queue);
}
diff --git a/deps/uv/src/unix/fs.c b/deps/uv/src/unix/fs.c
index 6b051c124f2..00d385c24b7 100644
--- a/deps/uv/src/unix/fs.c
+++ b/deps/uv/src/unix/fs.c
@@ -62,6 +62,7 @@
#if defined(__linux__)
# include <sys/sendfile.h>
+# include <sys/utsname.h>
#endif
#if defined(__sun)
@@ -903,6 +904,31 @@ out:
#ifdef __linux__
+static unsigned uv__kernel_version(void) {
+ static _Atomic unsigned cached_version;
+ struct utsname u;
+ unsigned version;
+ unsigned major;
+ unsigned minor;
+ unsigned patch;
+
+ version = atomic_load_explicit(&cached_version, memory_order_relaxed);
+ if (version != 0)
+ return version;
+
+ if (-1 == uname(&u))
+ return 0;
+
+ if (3 != sscanf(u.release, "%u.%u.%u", &major, &minor, &patch))
+ return 0;
+
+ version = major * 65536 + minor * 256 + patch;
+ atomic_store_explicit(&cached_version, version, memory_order_relaxed);
+
+ return version;
+}
+
+
/* Pre-4.20 kernels have a bug where CephFS uses the RADOS copy-from command
* in copy_file_range() when it shouldn't. There is no workaround except to
* fall back to a regular copy.
@@ -1905,9 +1931,6 @@ int uv_fs_link(uv_loop_t* loop,
uv_fs_cb cb) {
INIT(LINK);
PATH2;
- if (cb != NULL)
- if (uv__iou_fs_link(loop, req))
- return 0;
POST;
}
@@ -1920,9 +1943,6 @@ int uv_fs_mkdir(uv_loop_t* loop,
INIT(MKDIR);
PATH;
req->mode = mode;
- if (cb != NULL)
- if (uv__iou_fs_mkdir(loop, req))
- return 0;
POST;
}
@@ -2074,9 +2094,6 @@ int uv_fs_rename(uv_loop_t* loop,
uv_fs_cb cb) {
INIT(RENAME);
PATH2;
- if (cb != NULL)
- if (uv__iou_fs_rename(loop, req))
- return 0;
POST;
}
@@ -2123,9 +2140,6 @@ int uv_fs_symlink(uv_loop_t* loop,
INIT(SYMLINK);
PATH2;
req->flags = flags;
- if (cb != NULL)
- if (uv__iou_fs_symlink(loop, req))
- return 0;
POST;
}
@@ -2133,9 +2147,6 @@ int uv_fs_symlink(uv_loop_t* loop,
int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
INIT(UNLINK);
PATH;
- if (cb != NULL)
- if (uv__iou_fs_unlink(loop, req))
- return 0;
POST;
}
diff --git a/deps/uv/src/unix/fsevents.c b/deps/uv/src/unix/fsevents.c
index df703f3635f..0535b4547aa 100644
--- a/deps/uv/src/unix/fsevents.c
+++ b/deps/uv/src/unix/fsevents.c
@@ -80,13 +80,13 @@ enum uv__cf_loop_signal_type_e {
typedef enum uv__cf_loop_signal_type_e uv__cf_loop_signal_type_t;
struct uv__cf_loop_signal_s {
- struct uv__queue member;
+ QUEUE member;
uv_fs_event_t* handle;
uv__cf_loop_signal_type_t type;
};
struct uv__fsevents_event_s {
- struct uv__queue member;
+ QUEUE member;
int events;
char path[1];
};
@@ -98,7 +98,7 @@ struct uv__cf_loop_state_s {
FSEventStreamRef fsevent_stream;
uv_sem_t fsevent_sem;
uv_mutex_t fsevent_mutex;
- struct uv__queue fsevent_handles;
+ void* fsevent_handles[2];
unsigned int fsevent_handle_count;
};
@@ -150,22 +150,22 @@ static void (*pFSEventStreamStop)(FSEventStreamRef);
#define UV__FSEVENTS_PROCESS(handle, block) \
do { \
- struct uv__queue events; \
- struct uv__queue* q; \
+ QUEUE events; \
+ QUEUE* q; \
uv__fsevents_event_t* event; \
int err; \
uv_mutex_lock(&(handle)->cf_mutex); \
/* Split-off all events and empty original queue */ \
- uv__queue_move(&(handle)->cf_events, &events); \
+ QUEUE_MOVE(&(handle)->cf_events, &events); \
/* Get error (if any) and zero original one */ \
err = (handle)->cf_error; \
(handle)->cf_error = 0; \
uv_mutex_unlock(&(handle)->cf_mutex); \
/* Loop through events, deallocating each after processing */ \
- while (!uv__queue_empty(&events)) { \
- q = uv__queue_head(&events); \
- event = uv__queue_data(q, uv__fsevents_event_t, member); \
- uv__queue_remove(q); \
+ while (!QUEUE_EMPTY(&events)) { \
+ q = QUEUE_HEAD(&events); \
+ event = QUEUE_DATA(q, uv__fsevents_event_t, member); \
+ QUEUE_REMOVE(q); \
/* NOTE: Checking uv__is_active() is required here, because handle \
* callback may close handle and invoking it after it will lead to \
* incorrect behaviour */ \
@@ -193,14 +193,14 @@ static void uv__fsevents_cb(uv_async_t* cb) {
/* Runs in CF thread, pushed event into handle's event list */
static void uv__fsevents_push_event(uv_fs_event_t* handle,
- struct uv__queue* events,
+ QUEUE* events,
int err) {
assert(events != NULL || err != 0);
uv_mutex_lock(&handle->cf_mutex);
/* Concatenate two queues */
if (events != NULL)
- uv__queue_add(&handle->cf_events, events);
+ QUEUE_ADD(&handle->cf_events, events);
/* Propagate error */
if (err != 0)
@@ -224,12 +224,12 @@ static void uv__fsevents_event_cb(const FSEventStreamRef streamRef,
char* path;
char* pos;
uv_fs_event_t* handle;
- struct uv__queue* q;
+ QUEUE* q;
uv_loop_t* loop;
uv__cf_loop_state_t* state;
uv__fsevents_event_t* event;
FSEventStreamEventFlags flags;
- struct uv__queue head;
+ QUEUE head;
loop = info;
state = loop->cf_state;
@@ -238,9 +238,9 @@ static void uv__fsevents_event_cb(const FSEventStreamRef streamRef,
/* For each handle */
uv_mutex_lock(&state->fsevent_mutex);
- uv__queue_foreach(q, &state->fsevent_handles) {
- handle = uv__queue_data(q, uv_fs_event_t, cf_member);
- uv__queue_init(&head);
+ QUEUE_FOREACH(q, &state->fsevent_handles) {
+ handle = QUEUE_DATA(q, uv_fs_event_t, cf_member);
+ QUEUE_INIT(&head);
/* Process and filter out events */
for (i = 0; i < numEvents; i++) {
@@ -318,10 +318,10 @@ static void uv__fsevents_event_cb(const FSEventStreamRef streamRef,
event->events = UV_CHANGE;
}
- uv__queue_insert_tail(&head, &event->member);
+ QUEUE_INSERT_TAIL(&head, &event->member);
}
- if (!uv__queue_empty(&head))
+ if (!QUEUE_EMPTY(&head))
uv__fsevents_push_event(handle, &head, 0);
}
uv_mutex_unlock(&state->fsevent_mutex);
@@ -403,7 +403,7 @@ static void uv__fsevents_destroy_stream(uv__cf_loop_state_t* state) {
static void uv__fsevents_reschedule(uv__cf_loop_state_t* state,
uv_loop_t* loop,
uv__cf_loop_signal_type_t type) {
- struct uv__queue* q;
+ QUEUE* q;
uv_fs_event_t* curr;
CFArrayRef cf_paths;
CFStringRef* paths;
@@ -446,9 +446,9 @@ static void uv__fsevents_reschedule(uv__cf_loop_state_t* state,
q = &state->fsevent_handles;
for (; i < path_count; i++) {
- q = uv__queue_next(q);
+ q = QUEUE_NEXT(q);
assert(q != &state->fsevent_handles);
- curr = uv__queue_data(q, uv_fs_event_t, cf_member);
+ curr = QUEUE_DATA(q, uv_fs_event_t, cf_member);
assert(curr->realpath != NULL);
paths[i] =
@@ -486,8 +486,8 @@ final:
/* Broadcast error to all handles */
uv_mutex_lock(&state->fsevent_mutex);
- uv__queue_foreach(q, &state->fsevent_handles) {
- curr = uv__queue_data(q, uv_fs_event_t, cf_member);
+ QUEUE_FOREACH(q, &state->fsevent_handles) {
+ curr = QUEUE_DATA(q, uv_fs_event_t, cf_member);
uv__fsevents_push_event(curr, NULL, err);
}
uv_mutex_unlock(&state->fsevent_mutex);
@@ -606,7 +606,7 @@ static int uv__fsevents_loop_init(uv_loop_t* loop) {
if (err)
goto fail_sem_init;
- uv__queue_init(&loop->cf_signals);
+ QUEUE_INIT(&loop->cf_signals);
err = uv_sem_init(&state->fsevent_sem, 0);
if (err)
@@ -616,7 +616,7 @@ static int uv__fsevents_loop_init(uv_loop_t* loop) {
if (err)
goto fail_fsevent_mutex_init;
- uv__queue_init(&state->fsevent_handles);
+ QUEUE_INIT(&state->fsevent_handles);
state->fsevent_need_reschedule = 0;
state->fsevent_handle_count = 0;
@@ -675,7 +675,7 @@ fail_mutex_init:
void uv__fsevents_loop_delete(uv_loop_t* loop) {
uv__cf_loop_signal_t* s;
uv__cf_loop_state_t* state;
- struct uv__queue* q;
+ QUEUE* q;
if (loop->cf_state == NULL)
return;
@@ -688,10 +688,10 @@ void uv__fsevents_loop_delete(uv_loop_t* loop) {
uv_mutex_destroy(&loop->cf_mutex);
/* Free any remaining data */
- while (!uv__queue_empty(&loop->cf_signals)) {
- q = uv__queue_head(&loop->cf_signals);
- s = uv__queue_data(q, uv__cf_loop_signal_t, member);
- uv__queue_remove(q);
+ while (!QUEUE_EMPTY(&loop->cf_signals)) {
+ q = QUEUE_HEAD(&loop->cf_signals);
+ s = QUEUE_DATA(q, uv__cf_loop_signal_t, member);
+ QUEUE_REMOVE(q);
uv__free(s);
}
@@ -735,22 +735,22 @@ static void* uv__cf_loop_runner(void* arg) {
static void uv__cf_loop_cb(void* arg) {
uv_loop_t* loop;
uv__cf_loop_state_t* state;
- struct uv__queue* item;
- struct uv__queue split_head;
+ QUEUE* item;
+ QUEUE split_head;
uv__cf_loop_signal_t* s;
loop = arg;
state = loop->cf_state;
uv_mutex_lock(&loop->cf_mutex);
- uv__queue_move(&loop->cf_signals, &split_head);
+ QUEUE_MOVE(&loop->cf_signals, &split_head);
uv_mutex_unlock(&loop->cf_mutex);
- while (!uv__queue_empty(&split_head)) {
- item = uv__queue_head(&split_head);
- uv__queue_remove(item);
+ while (!QUEUE_EMPTY(&split_head)) {
+ item = QUEUE_HEAD(&split_head);
+ QUEUE_REMOVE(item);
- s = uv__queue_data(item, uv__cf_loop_signal_t, member);
+ s = QUEUE_DATA(item, uv__cf_loop_signal_t, member);
/* This was a termination signal */
if (s->handle == NULL)
@@ -778,7 +778,7 @@ int uv__cf_loop_signal(uv_loop_t* loop,
item->type = type;
uv_mutex_lock(&loop->cf_mutex);
- uv__queue_insert_tail(&loop->cf_signals, &item->member);
+ QUEUE_INSERT_TAIL(&loop->cf_signals, &item->member);
state = loop->cf_state;
assert(state != NULL);
@@ -807,7 +807,7 @@ int uv__fsevents_init(uv_fs_event_t* handle) {
handle->realpath_len = strlen(handle->realpath);
/* Initialize event queue */
- uv__queue_init(&handle->cf_events);
+ QUEUE_INIT(&handle->cf_events);
handle->cf_error = 0;
/*
@@ -832,7 +832,7 @@ int uv__fsevents_init(uv_fs_event_t* handle) {
/* Insert handle into the list */
state = handle->loop->cf_state;
uv_mutex_lock(&state->fsevent_mutex);
- uv__queue_insert_tail(&state->fsevent_handles, &handle->cf_member);
+ QUEUE_INSERT_TAIL(&state->fsevent_handles, &handle->cf_member);
state->fsevent_handle_count++;
state->fsevent_need_reschedule = 1;
uv_mutex_unlock(&state->fsevent_mutex);
@@ -872,7 +872,7 @@ int uv__fsevents_close(uv_fs_event_t* handle) {
/* Remove handle from the list */
state = handle->loop->cf_state;
uv_mutex_lock(&state->fsevent_mutex);
- uv__queue_remove(&handle->cf_member);
+ QUEUE_REMOVE(&handle->cf_member);
state->fsevent_handle_count--;
state->fsevent_need_reschedule = 1;
uv_mutex_unlock(&state->fsevent_mutex);
diff --git a/deps/uv/src/unix/internal.h b/deps/uv/src/unix/internal.h
index fe588513603..6c5822e6a0d 100644
--- a/deps/uv/src/unix/internal.h
+++ b/deps/uv/src/unix/internal.h
@@ -335,30 +335,20 @@ int uv__iou_fs_close(uv_loop_t* loop, uv_fs_t* req);
int uv__iou_fs_fsync_or_fdatasync(uv_loop_t* loop,
uv_fs_t* req,
uint32_t fsync_flags);
-int uv__iou_fs_link(uv_loop_t* loop, uv_fs_t* req);
-int uv__iou_fs_mkdir(uv_loop_t* loop, uv_fs_t* req);
int uv__iou_fs_open(uv_loop_t* loop, uv_fs_t* req);
int uv__iou_fs_read_or_write(uv_loop_t* loop,
uv_fs_t* req,
int is_read);
-int uv__iou_fs_rename(uv_loop_t* loop, uv_fs_t* req);
int uv__iou_fs_statx(uv_loop_t* loop,
uv_fs_t* req,
int is_fstat,
int is_lstat);
-int uv__iou_fs_symlink(uv_loop_t* loop, uv_fs_t* req);
-int uv__iou_fs_unlink(uv_loop_t* loop, uv_fs_t* req);
#else
#define uv__iou_fs_close(loop, req) 0
#define uv__iou_fs_fsync_or_fdatasync(loop, req, fsync_flags) 0
-#define uv__iou_fs_link(loop, req) 0
-#define uv__iou_fs_mkdir(loop, req) 0
#define uv__iou_fs_open(loop, req) 0
#define uv__iou_fs_read_or_write(loop, req, is_read) 0
-#define uv__iou_fs_rename(loop, req) 0
#define uv__iou_fs_statx(loop, req, is_fstat, is_lstat) 0
-#define uv__iou_fs_symlink(loop, req) 0
-#define uv__iou_fs_unlink(loop, req) 0
#endif
#if defined(__APPLE__)
@@ -439,7 +429,6 @@ int uv__statx(int dirfd,
struct uv__statx* statxbuf);
void uv__statx_to_stat(const struct uv__statx* statxbuf, uv_stat_t* buf);
ssize_t uv__getrandom(void* buf, size_t buflen, unsigned flags);
-unsigned uv__kernel_version(void);
#endif
typedef int (*uv__peersockfunc)(int, struct sockaddr*, socklen_t*);
diff --git a/deps/uv/src/unix/kqueue.c b/deps/uv/src/unix/kqueue.c
index b78242d3be4..82916d65933 100644
--- a/deps/uv/src/unix/kqueue.c
+++ b/deps/uv/src/unix/kqueue.c
@@ -133,7 +133,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
struct timespec spec;
unsigned int nevents;
unsigned int revents;
- struct uv__queue* q;
+ QUEUE* q;
uv__io_t* w;
uv_process_t* process;
sigset_t* pset;
@@ -152,19 +152,19 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
int reset_timeout;
if (loop->nfds == 0) {
- assert(uv__queue_empty(&loop->watcher_queue));
+ assert(QUEUE_EMPTY(&loop->watcher_queue));
return;
}
lfields = uv__get_internal_fields(loop);
nevents = 0;
- while (!uv__queue_empty(&loop->watcher_queue)) {
- q = uv__queue_head(&loop->watcher_queue);
- uv__queue_remove(q);
- uv__queue_init(q);
+ while (!QUEUE_EMPTY(&loop->watcher_queue)) {
+ q = QUEUE_HEAD(&loop->watcher_queue);
+ QUEUE_REMOVE(q);
+ QUEUE_INIT(q);
- w = uv__queue_data(q, uv__io_t, watcher_queue);
+ w = QUEUE_DATA(q, uv__io_t, watcher_queue);
assert(w->pevents != 0);
assert(w->fd >= 0);
assert(w->fd < (int) loop->nwatchers);
@@ -307,8 +307,8 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
/* Handle kevent NOTE_EXIT results */
if (ev->filter == EVFILT_PROC) {
- uv__queue_foreach(q, &loop->process_handles) {
- process = uv__queue_data(q, uv_process_t, queue);
+ QUEUE_FOREACH(q, &loop->process_handles) {
+ process = QUEUE_DATA(q, uv_process_t, queue);
if (process->pid == fd) {
process->flags |= UV_HANDLE_REAP;
loop->flags |= UV_LOOP_REAP_CHILDREN;
diff --git a/deps/uv/src/unix/linux.c b/deps/uv/src/unix/linux.c
index 48b9c2c43e1..5f84ad0eea3 100644
--- a/deps/uv/src/unix/linux.c
+++ b/deps/uv/src/unix/linux.c
@@ -48,7 +48,6 @@
#include <sys/sysinfo.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
-#include <sys/utsname.h>
#include <time.h>
#include <unistd.h>
@@ -151,11 +150,6 @@ enum {
UV__IORING_OP_CLOSE = 19,
UV__IORING_OP_STATX = 21,
UV__IORING_OP_EPOLL_CTL = 29,
- UV__IORING_OP_RENAMEAT = 35,
- UV__IORING_OP_UNLINKAT = 36,
- UV__IORING_OP_MKDIRAT = 37,
- UV__IORING_OP_SYMLINKAT = 38,
- UV__IORING_OP_LINKAT = 39,
};
enum {
@@ -168,10 +162,6 @@ enum {
UV__IORING_SQ_CQ_OVERFLOW = 2u,
};
-enum {
- UV__MKDIRAT_SYMLINKAT_LINKAT = 1u,
-};
-
struct uv__io_cqring_offsets {
uint32_t head;
uint32_t tail;
@@ -267,7 +257,7 @@ STATIC_ASSERT(EPOLL_CTL_MOD < 4);
struct watcher_list {
RB_ENTRY(watcher_list) entry;
- struct uv__queue watchers;
+ QUEUE watchers;
int iterating;
char* path;
int wd;
@@ -310,31 +300,6 @@ static struct watcher_root* uv__inotify_watchers(uv_loop_t* loop) {
}
-unsigned uv__kernel_version(void) {
- static _Atomic unsigned cached_version;
- struct utsname u;
- unsigned version;
- unsigned major;
- unsigned minor;
- unsigned patch;
-
- version = atomic_load_explicit(&cached_version, memory_order_relaxed);
- if (version != 0)
- return version;
-
- if (-1 == uname(&u))
- return 0;
-
- if (3 != sscanf(u.release, "%u.%u.%u", &major, &minor, &patch))
- return 0;
-
- version = major * 65536 + minor * 256 + patch;
- atomic_store_explicit(&cached_version, version, memory_order_relaxed);
-
- return version;
-}
-
-
ssize_t
uv__fs_copy_file_range(int fd_in,
off_t* off_in,
@@ -420,9 +385,6 @@ int uv__io_uring_register(int fd, unsigned opcode, void* arg, unsigned nargs) {
static int uv__use_io_uring(void) {
-#if defined(__ANDROID_API__)
- return 0; /* Possibly available but blocked by seccomp. */
-#else
/* Ternary: unknown=0, yes=1, no=-1 */
static _Atomic int use_io_uring;
char* val;
@@ -437,7 +399,6 @@ static int uv__use_io_uring(void) {
}
return use > 0;
-#endif
}
@@ -542,10 +503,6 @@ static void uv__iou_init(int epollfd,
iou->sqelen = sqelen;
iou->ringfd = ringfd;
iou->in_flight = 0;
- iou->flags = 0;
-
- if (uv__kernel_version() >= /* 5.15.0 */ 0x050F00)
- iou->flags |= UV__MKDIRAT_SYMLINKAT_LINKAT;
for (i = 0; i <= iou->sqmask; i++)
iou->sqarray[i] = i; /* Slot -> sqe identity mapping. */
@@ -727,7 +684,7 @@ static struct uv__io_uring_sqe* uv__iou_get_sqe(struct uv__iou* iou,
req->work_req.loop = loop;
req->work_req.work = NULL;
req->work_req.done = NULL;
- uv__queue_init(&req->work_req.wq);
+ QUEUE_INIT(&req->work_req.wq);
uv__req_register(loop, req);
iou->in_flight++;
@@ -757,17 +714,6 @@ int uv__iou_fs_close(uv_loop_t* loop, uv_fs_t* req) {
struct uv__io_uring_sqe* sqe;
struct uv__iou* iou;
- /* Work around a poorly understood bug in older kernels where closing a file
- * descriptor pointing to /foo/bar results in ETXTBSY errors when trying to
- * execve("/foo/bar") later on. The bug seems to have been fixed somewhere
- * between 5.15.85 and 5.15.90. I couldn't pinpoint the responsible commit
- * but good candidates are the several data race fixes. Interestingly, it
- * seems to manifest only when running under Docker so the possibility of
- * a Docker bug can't be completely ruled out either. Yay, computers.
- */
- if (uv__kernel_version() < /* 5.15.90 */ 0x050F5A)
- return 0;
-
iou = &uv__get_internal_fields(loop)->iou;
sqe = uv__iou_get_sqe(iou, loop, req);
@@ -808,55 +754,6 @@ int uv__iou_fs_fsync_or_fdatasync(uv_loop_t* loop,
}
-int uv__iou_fs_link(uv_loop_t* loop, uv_fs_t* req) {
- struct uv__io_uring_sqe* sqe;
- struct uv__iou* iou;
-
- iou = &uv__get_internal_fields(loop)->iou;
-
- if (!(iou->flags & UV__MKDIRAT_SYMLINKAT_LINKAT))
- return 0;
-
- sqe = uv__iou_get_sqe(iou, loop, req);
- if (sqe == NULL)
- return 0;
-
- sqe->addr = (uintptr_t) req->path;
- sqe->fd = AT_FDCWD;
- sqe->addr2 = (uintptr_t) req->new_path;
- sqe->len = AT_FDCWD;
- sqe->opcode = UV__IORING_OP_LINKAT;
-
- uv__iou_submit(iou);
-
- return 1;
-}
-
-
-int uv__iou_fs_mkdir(uv_loop_t* loop, uv_fs_t* req) {
- struct uv__io_uring_sqe* sqe;
- struct uv__iou* iou;
-
- iou = &uv__get_internal_fields(loop)->iou;
-
- if (!(iou->flags & UV__MKDIRAT_SYMLINKAT_LINKAT))
- return 0;
-
- sqe = uv__iou_get_sqe(iou, loop, req);
- if (sqe == NULL)
- return 0;
-
- sqe->addr = (uintptr_t) req->path;
- sqe->fd = AT_FDCWD;
- sqe->len = req->mode;
- sqe->opcode = UV__IORING_OP_MKDIRAT;
-
- uv__iou_submit(iou);
-
- return 1;
-}
-
-
int uv__iou_fs_open(uv_loop_t* loop, uv_fs_t* req) {
struct uv__io_uring_sqe* sqe;
struct uv__iou* iou;
@@ -879,86 +776,16 @@ int uv__iou_fs_open(uv_loop_t* loop, uv_fs_t* req) {
}
-int uv__iou_fs_rename(uv_loop_t* loop, uv_fs_t* req) {
- struct uv__io_uring_sqe* sqe;
- struct uv__iou* iou;
-
- iou = &uv__get_internal_fields(loop)->iou;
-
- sqe = uv__iou_get_sqe(iou, loop, req);
- if (sqe == NULL)
- return 0;
-
- sqe->addr = (uintptr_t) req->path;
- sqe->fd = AT_FDCWD;
- sqe->addr2 = (uintptr_t) req->new_path;
- sqe->len = AT_FDCWD;
- sqe->opcode = UV__IORING_OP_RENAMEAT;
-
- uv__iou_submit(iou);
-
- return 1;
-}
-
-
-int uv__iou_fs_symlink(uv_loop_t* loop, uv_fs_t* req) {
- struct uv__io_uring_sqe* sqe;
- struct uv__iou* iou;
-
- iou = &uv__get_internal_fields(loop)->iou;
-
- if (!(iou->flags & UV__MKDIRAT_SYMLINKAT_LINKAT))
- return 0;
-
- sqe = uv__iou_get_sqe(iou, loop, req);
- if (sqe == NULL)
- return 0;
-
- sqe->addr = (uintptr_t) req->path;
- sqe->fd = AT_FDCWD;
- sqe->addr2 = (uintptr_t) req->new_path;
- sqe->opcode = UV__IORING_OP_SYMLINKAT;
-
- uv__iou_submit(iou);
-
- return 1;
-}
-
-
-int uv__iou_fs_unlink(uv_loop_t* loop, uv_fs_t* req) {
- struct uv__io_uring_sqe* sqe;
- struct uv__iou* iou;
-
- iou = &uv__get_internal_fields(loop)->iou;
-
- sqe = uv__iou_get_sqe(iou, loop, req);
- if (sqe == NULL)
- return 0;
-
- sqe->addr = (uintptr_t) req->path;
- sqe->fd = AT_FDCWD;
- sqe->opcode = UV__IORING_OP_UNLINKAT;
-
- uv__iou_submit(iou);
-
- return 1;
-}
-
-
int uv__iou_fs_read_or_write(uv_loop_t* loop,
uv_fs_t* req,
int is_read) {
struct uv__io_uring_sqe* sqe;
struct uv__iou* iou;
- /* If iovcnt is greater than IOV_MAX, cap it to IOV_MAX on reads and fallback
- * to the threadpool on writes */
- if (req->nbufs > IOV_MAX) {
- if (is_read)
- req->nbufs = IOV_MAX;
- else
- return 0;
- }
+ /* For the moment, if iovcnt is greater than IOV_MAX, fallback to the
+ * threadpool. In the future we might take advantage of IOSQE_IO_LINK. */
+ if (req->nbufs > IOV_MAX)
+ return 0;
iou = &uv__get_internal_fields(loop)->iou;
@@ -1265,7 +1092,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
struct uv__iou* ctl;
struct uv__iou* iou;
int real_timeout;
- struct uv__queue* q;
+ QUEUE* q;
uv__io_t* w;
sigset_t* sigmask;
sigset_t sigset;
@@ -1311,11 +1138,11 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
memset(&e, 0, sizeof(e));
- while (!uv__queue_empty(&loop->watcher_queue)) {
- q = uv__queue_head(&loop->watcher_queue);
- w = uv__queue_data(q, uv__io_t, watcher_queue);
- uv__queue_remove(q);
- uv__queue_init(q);
+ while (!QUEUE_EMPTY(&loop->watcher_queue)) {
+ q = QUEUE_HEAD(&loop->watcher_queue);
+ w = QUEUE_DATA(q, uv__io_t, watcher_queue);
+ QUEUE_REMOVE(q);
+ QUEUE_INIT(q);
op = EPOLL_CTL_MOD;
if (w->events == 0)
@@ -2272,8 +2099,8 @@ static int uv__inotify_fork(uv_loop_t* loop, struct watcher_list* root) {
struct watcher_list* tmp_watcher_list_iter;
struct watcher_list* watcher_list;
struct watcher_list tmp_watcher_list;
- struct uv__queue queue;
- struct uv__queue* q;
+ QUEUE queue;
+ QUEUE* q;
uv_fs_event_t* handle;
char* tmp_path;
@@ -2285,41 +2112,41 @@ static int uv__inotify_fork(uv_loop_t* loop, struct watcher_list* root) {
*/
loop->inotify_watchers = root;
- uv__queue_init(&tmp_watcher_list.watchers);
+ QUEUE_INIT(&tmp_watcher_list.watchers);
/* Note that the queue we use is shared with the start and stop()
- * functions, making uv__queue_foreach unsafe to use. So we use the
- * uv__queue_move trick to safely iterate. Also don't free the watcher
+ * functions, making QUEUE_FOREACH unsafe to use. So we use the
+ * QUEUE_MOVE trick to safely iterate. Also don't free the watcher
* list until we're done iterating. c.f. uv__inotify_read.
*/
RB_FOREACH_SAFE(watcher_list, watcher_root,
uv__inotify_watchers(loop), tmp_watcher_list_iter) {
watcher_list->iterating = 1;
- uv__queue_move(&watcher_list->watchers, &queue);
- while (!uv__queue_empty(&queue)) {
- q = uv__queue_head(&queue);
- handle = uv__queue_data(q, uv_fs_event_t, watchers);
+ QUEUE_MOVE(&watcher_list->watchers, &queue);
+ while (!QUEUE_EMPTY(&queue)) {
+ q = QUEUE_HEAD(&queue);
+ handle = QUEUE_DATA(q, uv_fs_event_t, watchers);
/* It's critical to keep a copy of path here, because it
* will be set to NULL by stop() and then deallocated by
* maybe_free_watcher_list
*/
tmp_path = uv__strdup(handle->path);
assert(tmp_path != NULL);
- uv__queue_remove(q);
- uv__queue_insert_tail(&watcher_list->watchers, q);
+ QUEUE_REMOVE(q);
+ QUEUE_INSERT_TAIL(&watcher_list->watchers, q);
uv_fs_event_stop(handle);
- uv__queue_insert_tail(&tmp_watcher_list.watchers, &handle->watchers);
+ QUEUE_INSERT_TAIL(&tmp_watcher_list.watchers, &handle->watchers);
handle->path = tmp_path;
}
watcher_list->iterating = 0;
maybe_free_watcher_list(watcher_list, loop);
}
- uv__queue_move(&tmp_watcher_list.watchers, &queue);
- while (!uv__queue_empty(&queue)) {
- q = uv__queue_head(&queue);
- uv__queue_remove(q);
- handle = uv__queue_data(q, uv_fs_event_t, watchers);
+ QUEUE_MOVE(&tmp_watcher_list.watchers, &queue);
+ while (!QUEUE_EMPTY(&queue)) {
+ q = QUEUE_HEAD(&queue);
+ QUEUE_REMOVE(q);
+ handle = QUEUE_DATA(q, uv_fs_event_t, watchers);
tmp_path = handle->path;
handle->path = NULL;
err = uv_fs_event_start(handle, handle->cb, tmp_path, 0);
@@ -2341,7 +2168,7 @@ static struct watcher_list* find_watcher(uv_loop_t* loop, int wd) {
static void maybe_free_watcher_list(struct watcher_list* w, uv_loop_t* loop) {
/* if the watcher_list->watchers is being iterated over, we can't free it. */
- if ((!w->iterating) && uv__queue_empty(&w->watchers)) {
+ if ((!w->iterating) && QUEUE_EMPTY(&w->watchers)) {
/* No watchers left for this path. Clean up. */
RB_REMOVE(watcher_root, uv__inotify_watchers(loop), w);
inotify_rm_watch(loop->inotify_fd, w->wd);
@@ -2356,8 +2183,8 @@ static void uv__inotify_read(uv_loop_t* loop,
const struct inotify_event* e;
struct watcher_list* w;
uv_fs_event_t* h;
- struct uv__queue queue;
- struct uv__queue* q;
+ QUEUE queue;
+ QUEUE* q;
const char* path;
ssize_t size;
const char *p;
@@ -2400,7 +2227,7 @@ static void uv__inotify_read(uv_loop_t* loop,
* What can go wrong?
* A callback could call uv_fs_event_stop()
* and the queue can change under our feet.
- * So, we use uv__queue_move() trick to safely iterate over the queue.
+ * So, we use QUEUE_MOVE() trick to safely iterate over the queue.
* And we don't free the watcher_list until we're done iterating.
*
* First,
@@ -2408,13 +2235,13 @@ static void uv__inotify_read(uv_loop_t* loop,
* not to free watcher_list.
*/
w->iterating = 1;
- uv__queue_move(&w->watchers, &queue);
- while (!uv__queue_empty(&queue)) {
- q = uv__queue_head(&queue);
- h = uv__queue_data(q, uv_fs_event_t, watchers);
+ QUEUE_MOVE(&w->watchers, &queue);
+ while (!QUEUE_EMPTY(&queue)) {
+ q = QUEUE_HEAD(&queue);
+ h = QUEUE_DATA(q, uv_fs_event_t, watchers);
- uv__queue_remove(q);
- uv__queue_insert_tail(&w->watchers, q);
+ QUEUE_REMOVE(q);
+ QUEUE_INSERT_TAIL(&w->watchers, q);
h->cb(h, path, events, 0);
}
@@ -2476,13 +2303,13 @@ int uv_fs_event_start(uv_fs_event_t* handle,
w->wd = wd;
w->path = memcpy(w + 1, path, len);
- uv__queue_init(&w->watchers);
+ QUEUE_INIT(&w->watchers);
w->iterating = 0;
RB_INSERT(watcher_root, uv__inotify_watchers(loop), w);
no_insert:
uv__handle_start(handle);
- uv__queue_insert_tail(&w->watchers, &handle->watchers);
+ QUEUE_INSERT_TAIL(&w->watchers, &handle->watchers);
handle->path = w->path;
handle->cb = cb;
handle->wd = wd;
@@ -2503,7 +2330,7 @@ int uv_fs_event_stop(uv_fs_event_t* handle) {
handle->wd = -1;
handle->path = NULL;
uv__handle_stop(handle);
- uv__queue_remove(&handle->watchers);
+ QUEUE_REMOVE(&handle->watchers);
maybe_free_watcher_list(w, handle->loop);
diff --git a/deps/uv/src/unix/loop-watcher.c b/deps/uv/src/unix/loop-watcher.c
index 2db8b515df7..b8c1c2a7102 100644
--- a/deps/uv/src/unix/loop-watcher.c
+++ b/deps/uv/src/unix/loop-watcher.c
@@ -32,7 +32,7 @@
int uv_##name##_start(uv_##name##_t* handle, uv_##name##_cb cb) { \
if (uv__is_active(handle)) return 0; \
if (cb == NULL) return UV_EINVAL; \
- uv__queue_insert_head(&handle->loop->name##_handles, &handle->queue); \
+ QUEUE_INSERT_HEAD(&handle->loop->name##_handles, &handle->queue); \
handle->name##_cb = cb; \
uv__handle_start(handle); \
return 0; \
@@ -40,21 +40,21 @@
\
int uv_##name##_stop(uv_##name##_t* handle) { \
if (!uv__is_active(handle)) return 0; \
- uv__queue_remove(&handle->queue); \
+ QUEUE_REMOVE(&handle->queue); \
uv__handle_stop(handle); \
return 0; \
} \
\
void uv__run_##name(uv_loop_t* loop) { \
uv_##name##_t* h; \
- struct uv__queue queue; \
- struct uv__queue* q; \
- uv__queue_move(&loop->name##_handles, &queue); \
- while (!uv__queue_empty(&queue)) { \
- q = uv__queue_head(&queue); \
- h = uv__queue_data(q, uv_##name##_t, queue); \
- uv__queue_remove(q); \
- uv__queue_insert_tail(&loop->name##_handles, q); \
+ QUEUE queue; \
+ QUEUE* q; \
+ QUEUE_MOVE(&loop->name##_handles, &queue); \
+ while (!QUEUE_EMPTY(&queue)) { \
+ q = QUEUE_HEAD(&queue); \
+ h = QUEUE_DATA(q, uv_##name##_t, queue); \
+ QUEUE_REMOVE(q); \
+ QUEUE_INSERT_TAIL(&loop->name##_handles, q); \
h->name##_cb(h); \
} \
} \
diff --git a/deps/uv/src/unix/loop.c b/deps/uv/src/unix/loop.c
index a9468e8e19c..90a51b339de 100644
--- a/deps/uv/src/unix/loop.c
+++ b/deps/uv/src/unix/loop.c
@@ -50,20 +50,20 @@ int uv_loop_init(uv_loop_t* loop) {
sizeof(lfields->loop_metrics.metrics));
heap_init((struct heap*) &loop->timer_heap);
- uv__queue_init(&loop->wq);
- uv__queue_init(&loop->idle_handles);
- uv__queue_init(&loop->async_handles);
- uv__queue_init(&loop->check_handles);
- uv__queue_init(&loop->prepare_handles);
- uv__queue_init(&loop->handle_queue);
+ QUEUE_INIT(&loop->wq);
+ QUEUE_INIT(&loop->idle_handles);
+ QUEUE_INIT(&loop->async_handles);
+ QUEUE_INIT(&loop->check_handles);
+ QUEUE_INIT(&loop->prepare_handles);
+ QUEUE_INIT(&loop->handle_queue);
loop->active_handles = 0;
loop->active_reqs.count = 0;
loop->nfds = 0;
loop->watchers = NULL;
loop->nwatchers = 0;
- uv__queue_init(&loop->pending_queue);
- uv__queue_init(&loop->watcher_queue);
+ QUEUE_INIT(&loop->pending_queue);
+ QUEUE_INIT(&loop->watcher_queue);
loop->closing_handles = NULL;
uv__update_time(loop);
@@ -85,7 +85,7 @@ int uv_loop_init(uv_loop_t* loop) {
err = uv__process_init(loop);
if (err)
goto fail_signal_init;
- uv__queue_init(&loop->process_handles);
+ QUEUE_INIT(&loop->process_handles);
err = uv_rwlock_init(&loop->cloexec_lock);
if (err)
@@ -152,9 +152,9 @@ int uv_loop_fork(uv_loop_t* loop) {
if (w == NULL)
continue;
- if (w->pevents != 0 && uv__queue_empty(&w->watcher_queue)) {
+ if (w->pevents != 0 && QUEUE_EMPTY(&w->watcher_queue)) {
w->events = 0; /* Force re-registration in uv__io_poll. */
- uv__queue_insert_tail(&loop->watcher_queue, &w->watcher_queue);
+ QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
}
}
@@ -180,7 +180,7 @@ void uv__loop_close(uv_loop_t* loop) {
}
uv_mutex_lock(&loop->wq_mutex);
- assert(uv__queue_empty(&loop->wq) && "thread pool work queue not empty!");
+ assert(QUEUE_EMPTY(&loop->wq) && "thread pool work queue not empty!");
assert(!uv__has_active_reqs(loop));
uv_mutex_unlock(&loop->wq_mutex);
uv_mutex_destroy(&loop->wq_mutex);
@@ -192,8 +192,8 @@ void uv__loop_close(uv_loop_t* loop) {
uv_rwlock_destroy(&loop->cloexec_lock);
#if 0
- assert(uv__queue_empty(&loop->pending_queue));
- assert(uv__queue_empty(&loop->watcher_queue));
+ assert(QUEUE_EMPTY(&loop->pending_queue));
+ assert(QUEUE_EMPTY(&loop->watcher_queue));
assert(loop->nfds == 0);
#endif
diff --git a/deps/uv/src/unix/os390-syscalls.c b/deps/uv/src/unix/os390-syscalls.c
index 7f90c270906..5861aaaa202 100644
--- a/deps/uv/src/unix/os390-syscalls.c
+++ b/deps/uv/src/unix/os390-syscalls.c
@@ -27,7 +27,7 @@
#include <termios.h>
#include <sys/msg.h>
-static struct uv__queue global_epoll_queue;
+static QUEUE global_epoll_queue;
static uv_mutex_t global_epoll_lock;
static uv_once_t once = UV_ONCE_INIT;
@@ -178,18 +178,18 @@ static void after_fork(void) {
static void child_fork(void) {
- struct uv__queue* q;
+ QUEUE* q;
uv_once_t child_once = UV_ONCE_INIT;
/* reset once */
memcpy(&once, &child_once, sizeof(child_once));
/* reset epoll list */
- while (!uv__queue_empty(&global_epoll_queue)) {
+ while (!QUEUE_EMPTY(&global_epoll_queue)) {
uv__os390_epoll* lst;
- q = uv__queue_head(&global_epoll_queue);
- uv__queue_remove(q);
- lst = uv__queue_data(q, uv__os390_epoll, member);
+ q = QUEUE_HEAD(&global_epoll_queue);
+ QUEUE_REMOVE(q);
+ lst = QUEUE_DATA(q, uv__os390_epoll, member);
uv__free(lst->items);
lst->items = NULL;
lst->size = 0;
@@ -201,7 +201,7 @@ static void child_fork(void) {
static void epoll_init(void) {
- uv__queue_init(&global_epoll_queue);
+ QUEUE_INIT(&global_epoll_queue);
if (uv_mutex_init(&global_epoll_lock))
abort();
@@ -225,7 +225,7 @@ uv__os390_epoll* epoll_create1(int flags) {
lst->items[lst->size - 1].revents = 0;
uv_once(&once, epoll_init);
uv_mutex_lock(&global_epoll_lock);
- uv__queue_insert_tail(&global_epoll_queue, &lst->member);
+ QUEUE_INSERT_TAIL(&global_epoll_queue, &lst->member);
uv_mutex_unlock(&global_epoll_lock);
}
@@ -352,14 +352,14 @@ int epoll_wait(uv__os390_epoll* lst, struct epoll_event* events,
int epoll_file_close(int fd) {
- struct uv__queue* q;
+ QUEUE* q;
uv_once(&once, epoll_init);
uv_mutex_lock(&global_epoll_lock);
- uv__queue_foreach(q, &global_epoll_queue) {
+ QUEUE_FOREACH(q, &global_epoll_queue) {
uv__os390_epoll* lst;
- lst = uv__queue_data(q, uv__os390_epoll, member);
+ lst = QUEUE_DATA(q, uv__os390_epoll, member);
if (fd < lst->size && lst->items != NULL && lst->items[fd].fd != -1)
lst->items[fd].fd = -1;
}
@@ -371,7 +371,7 @@ int epoll_file_close(int fd) {
void epoll_queue_close(uv__os390_epoll* lst) {
/* Remove epoll instance from global queue */
uv_mutex_lock(&global_epoll_lock);
- uv__queue_remove(&lst->member);
+ QUEUE_REMOVE(&lst->member);
uv_mutex_unlock(&global_epoll_lock);
/* Free resources */
diff --git a/deps/uv/src/unix/os390-syscalls.h b/deps/uv/src/unix/os390-syscalls.h
index d5f3bcf8b1c..9f504171d85 100644
--- a/deps/uv/src/unix/os390-syscalls.h
+++ b/deps/uv/src/unix/os390-syscalls.h
@@ -45,7 +45,7 @@ struct epoll_event {
};
typedef struct {
- struct uv__queue member;
+ QUEUE member;
struct pollfd* items;
unsigned long size;
int msg_queue;
diff --git a/deps/uv/src/unix/os390.c b/deps/uv/src/unix/os390.c
index bbd37692d1d..a87c2d77faf 100644
--- a/deps/uv/src/unix/os390.c
+++ b/deps/uv/src/unix/os390.c
@@ -815,7 +815,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
uv__os390_epoll* ep;
int have_signals;
int real_timeout;
- struct uv__queue* q;
+ QUEUE* q;
uv__io_t* w;
uint64_t base;
int count;
@@ -827,19 +827,19 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
int reset_timeout;
if (loop->nfds == 0) {
- assert(uv__queue_empty(&loop->watcher_queue));
+ assert(QUEUE_EMPTY(&loop->watcher_queue));
return;
}
lfields = uv__get_internal_fields(loop);
- while (!uv__queue_empty(&loop->watcher_queue)) {
+ while (!QUEUE_EMPTY(&loop->watcher_queue)) {
uv_stream_t* stream;
- q = uv__queue_head(&loop->watcher_queue);
- uv__queue_remove(q);
- uv__queue_init(q);
- w = uv__queue_data(q, uv__io_t, watcher_queue);
+ q = QUEUE_HEAD(&loop->watcher_queue);
+ QUEUE_REMOVE(q);
+ QUEUE_INIT(q);
+ w = QUEUE_DATA(q, uv__io_t, watcher_queue);
assert(w->pevents != 0);
assert(w->fd >= 0);
diff --git a/deps/uv/src/unix/pipe.c b/deps/uv/src/unix/pipe.c
index d332f351830..ce91ac49b30 100644
--- a/deps/uv/src/unix/pipe.c
+++ b/deps/uv/src/unix/pipe.c
@@ -297,7 +297,7 @@ out:
uv__req_init(handle->loop, req, UV_CONNECT);
req->handle = (uv_stream_t*)handle;
req->cb = cb;
- uv__queue_init(&req->queue);
+ QUEUE_INIT(&req->queue);
/* Force callback to run on next tick in case of error. */
if (err)
diff --git a/deps/uv/src/unix/posix-poll.c b/deps/uv/src/unix/posix-poll.c
index 2e016c2fbae..7e7de86845d 100644
--- a/deps/uv/src/unix/posix-poll.c
+++ b/deps/uv/src/unix/posix-poll.c
@@ -137,7 +137,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
sigset_t set;
uint64_t time_base;
uint64_t time_diff;
- struct uv__queue* q;
+ QUEUE* q;
uv__io_t* w;
size_t i;
unsigned int nevents;
@@ -149,19 +149,19 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
int reset_timeout;
if (loop->nfds == 0) {
- assert(uv__queue_empty(&loop->watcher_queue));
+ assert(QUEUE_EMPTY(&loop->watcher_queue));
return;
}
lfields = uv__get_internal_fields(loop);
/* Take queued watchers and add their fds to our poll fds array. */
- while (!uv__queue_empty(&loop->watcher_queue)) {
- q = uv__queue_head(&loop->watcher_queue);
- uv__queue_remove(q);
- uv__queue_init(q);
+ while (!QUEUE_EMPTY(&loop->watcher_queue)) {
+ q = QUEUE_HEAD(&loop->watcher_queue);
+ QUEUE_REMOVE(q);
+ QUEUE_INIT(q);
- w = uv__queue_data(q, uv__io_t, watcher_queue);
+ w = QUEUE_DATA(q, uv__io_t, watcher_queue);
assert(w->pevents != 0);
assert(w->fd >= 0);
assert(w->fd < (int) loop->nwatchers);
diff --git a/deps/uv/src/unix/process.c b/deps/uv/src/unix/process.c
index dd58c18d9b9..bbf367b57d3 100644
--- a/deps/uv/src/unix/process.c
+++ b/deps/uv/src/unix/process.c
@@ -108,17 +108,17 @@ void uv__wait_children(uv_loop_t* loop) {
int status;
int options;
pid_t pid;
- struct uv__queue pending;
- struct uv__queue* q;
- struct uv__queue* h;
+ QUEUE pending;
+ QUEUE* q;
+ QUEUE* h;
- uv__queue_init(&pending);
+ QUEUE_INIT(&pending);
h = &loop->process_handles;
- q = uv__queue_head(h);
+ q = QUEUE_HEAD(h);
while (q != h) {
- process = uv__queue_data(q, uv_process_t, queue);
- q = uv__queue_next(q);
+ process = QUEUE_DATA(q, uv_process_t, queue);
+ q = QUEUE_NEXT(q);
#ifndef UV_USE_SIGCHLD
if ((process->flags & UV_HANDLE_REAP) == 0)
@@ -149,18 +149,18 @@ void uv__wait_children(uv_loop_t* loop) {
assert(pid == process->pid);
process->status = status;
- uv__queue_remove(&process->queue);
- uv__queue_insert_tail(&pending, &process->queue);
+ QUEUE_REMOVE(&process->queue);
+ QUEUE_INSERT_TAIL(&pending, &process->queue);
}
h = &pending;
- q = uv__queue_head(h);
+ q = QUEUE_HEAD(h);
while (q != h) {
- process = uv__queue_data(q, uv_process_t, queue);
- q = uv__queue_next(q);
+ process = QUEUE_DATA(q, uv_process_t, queue);
+ q = QUEUE_NEXT(q);
- uv__queue_remove(&process->queue);
- uv__queue_init(&process->queue);
+ QUEUE_REMOVE(&process->queue);
+ QUEUE_INIT(&process->queue);
uv__handle_stop(process);
if (process->exit_cb == NULL)
@@ -176,7 +176,7 @@ void uv__wait_children(uv_loop_t* loop) {
process->exit_cb(process, exit_status, term_signal);
}
- assert(uv__queue_empty(&pending));
+ assert(QUEUE_EMPTY(&pending));
}
/*
@@ -978,7 +978,7 @@ int uv_spawn(uv_loop_t* loop,
UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS)));
uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS);
- uv__queue_init(&process->queue);
+ QUEUE_INIT(&process->queue);
process->status = 0;
stdio_count = options->stdio_count;
@@ -1041,7 +1041,7 @@ int uv_spawn(uv_loop_t* loop,
process->pid = pid;
process->exit_cb = options->exit_cb;
- uv__queue_insert_tail(&loop->process_handles, &process->queue);
+ QUEUE_INSERT_TAIL(&loop->process_handles, &process->queue);
uv__handle_start(process);
}
@@ -1103,10 +1103,10 @@ int uv_kill(int pid, int signum) {
void uv__process_close(uv_process_t* handle) {
- uv__queue_remove(&handle->queue);
+ QUEUE_REMOVE(&handle->queue);
uv__handle_stop(handle);
#ifdef UV_USE_SIGCHLD
- if (uv__queue_empty(&handle->loop->process_handles))
+ if (QUEUE_EMPTY(&handle->loop->process_handles))
uv_signal_stop(&handle->loop->child_watcher);
#endif
}
diff --git a/deps/uv/src/unix/signal.c b/deps/uv/src/unix/signal.c
index 63aba5a60e0..bb70523f561 100644
--- a/deps/uv/src/unix/signal.c
+++ b/deps/uv/src/unix/signal.c
@@ -291,16 +291,16 @@ int uv__signal_loop_fork(uv_loop_t* loop) {
void uv__signal_loop_cleanup(uv_loop_t* loop) {
- struct uv__queue* q;
+ QUEUE* q;
/* Stop all the signal watchers that are still attached to this loop. This
* ensures that the (shared) signal tree doesn't contain any invalid entries
* entries, and that signal handlers are removed when appropriate.
- * It's safe to use uv__queue_foreach here because the handles and the handle
+ * It's safe to use QUEUE_FOREACH here because the handles and the handle
* queue are not modified by uv__signal_stop().
*/
- uv__queue_foreach(q, &loop->handle_queue) {
- uv_handle_t* handle = uv__queue_data(q, uv_handle_t, handle_queue);
+ QUEUE_FOREACH(q, &loop->handle_queue) {
+ uv_handle_t* handle = QUEUE_DATA(q, uv_handle_t, handle_queue);
if (handle->type == UV_SIGNAL)
uv__signal_stop((uv_signal_t*) handle);
diff --git a/deps/uv/src/unix/stream.c b/deps/uv/src/unix/stream.c
index 28c4d5463c4..03f92b5045a 100644
--- a/deps/uv/src/unix/stream.c
+++ b/deps/uv/src/unix/stream.c
@@ -94,8 +94,8 @@ void uv__stream_init(uv_loop_t* loop,
stream->accepted_fd = -1;
stream->queued_fds = NULL;
stream->delayed_error = 0;
- uv__queue_init(&stream->write_queue);
- uv__queue_init(&stream->write_completed_queue);
+ QUEUE_INIT(&stream->write_queue);
+ QUEUE_INIT(&stream->write_completed_queue);
stream->write_queue_size = 0;
if (loop->emfile_fd == -1) {
@@ -439,15 +439,15 @@ int uv__stream_open(uv_stream_t* stream, int fd, int flags) {
void uv__stream_flush_write_queue(uv_stream_t* stream, int error) {
uv_write_t* req;
- struct uv__queue* q;
- while (!uv__queue_empty(&stream->write_queue)) {
- q = uv__queue_head(&stream->write_queue);
- uv__queue_remove(q);
+ QUEUE* q;
+ while (!QUEUE_EMPTY(&stream->write_queue)) {
+ q = QUEUE_HEAD(&stream->write_queue);
+ QUEUE_REMOVE(q);
- req = uv__queue_data(q, uv_write_t, queue);
+ req = QUEUE_DATA(q, uv_write_t, queue);
req->error = error;
- uv__queue_insert_tail(&stream->write_completed_queue, &req->queue);
+ QUEUE_INSERT_TAIL(&stream->write_completed_queue, &req->queue);
}
}
@@ -627,7 +627,7 @@ static void uv__drain(uv_stream_t* stream) {
uv_shutdown_t* req;
int err;
- assert(uv__queue_empty(&stream->write_queue));
+ assert(QUEUE_EMPTY(&stream->write_queue));
if (!(stream->flags & UV_HANDLE_CLOSING)) {
uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT);
uv__stream_osx_interrupt_select(stream);
@@ -714,7 +714,7 @@ static void uv__write_req_finish(uv_write_t* req) {
uv_stream_t* stream = req->handle;
/* Pop the req off tcp->write_queue. */
- uv__queue_remove(&req->queue);
+ QUEUE_REMOVE(&req->queue);
/* Only free when there was no error. On error, we touch up write_queue_size
* right before making the callback. The reason we don't do that right away
@@ -731,7 +731,7 @@ static void uv__write_req_finish(uv_write_t* req) {
/* Add it to the write_completed_queue where it will have its
* callback called in the near future.
*/
- uv__queue_insert_tail(&stream->write_completed_queue, &req->queue);
+ QUEUE_INSERT_TAIL(&stream->write_completed_queue, &req->queue);
uv__io_feed(stream->loop, &stream->io_watcher);
}
@@ -837,7 +837,7 @@ static int uv__try_write(uv_stream_t* stream,
}
static void uv__write(uv_stream_t* stream) {
- struct uv__queue* q;
+ QUEUE* q;
uv_write_t* req;
ssize_t n;
int count;
@@ -851,11 +851,11 @@ static void uv__write(uv_stream_t* stream) {
count = 32;
for (;;) {
- if (uv__queue_empty(&stream->write_queue))
+ if (QUEUE_EMPTY(&stream->write_queue))
return;
- q = uv__queue_head(&stream->write_queue);
- req = uv__queue_data(q, uv_write_t, queue);
+ q = QUEUE_HEAD(&stream->write_queue);
+ req = QUEUE_DATA(q, uv_write_t, queue);
assert(req->handle == stream);
n = uv__try_write(stream,
@@ -899,19 +899,19 @@ error:
static void uv__write_callbacks(uv_stream_t* stream) {
uv_write_t* req;
- struct uv__queue* q;
- struct uv__queue pq;
+ QUEUE* q;
+ QUEUE pq;
- if (uv__queue_empty(&stream->write_completed_queue))
+ if (QUEUE_EMPTY(&stream->write_completed_queue))
return;
- uv__queue_move(&stream->write_completed_queue, &pq);
+ QUEUE_MOVE(&stream->write_completed_queue, &pq);
- while (!uv__queue_empty(&pq)) {
+ while (!QUEUE_EMPTY(&pq)) {
/* Pop a req off write_completed_queue. */
- q = uv__queue_head(&pq);
- req = uv__queue_data(q, uv_write_t, queue);
- uv__queue_remove(q);
+ q = QUEUE_HEAD(&pq);
+ req = QUEUE_DATA(q, uv_write_t, queue);
+ QUEUE_REMOVE(q);
uv__req_unregister(stream->loop, req);
if (req->bufs != NULL) {
@@ -1174,7 +1174,7 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) {
stream->shutdown_req = req;
stream->flags &= ~UV_HANDLE_WRITABLE;
- if (uv__queue_empty(&stream->write_queue))
+ if (QUEUE_EMPTY(&stream->write_queue))
uv__io_feed(stream->loop, &stream->io_watcher);
return 0;
@@ -1227,7 +1227,7 @@ static void uv__stream_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
uv__write_callbacks(stream);
/* Write queue drained. */
- if (uv__queue_empty(&stream->write_queue))
+ if (QUEUE_EMPTY(&stream->write_queue))
uv__drain(stream);
}
}
@@ -1270,7 +1270,7 @@ static void uv__stream_connect(uv_stream_t* stream) {
stream->connect_req = NULL;
uv__req_unregister(stream->loop, req);
- if (error < 0 || uv__queue_empty(&stream->write_queue)) {
+ if (error < 0 || QUEUE_EMPTY(&stream->write_queue)) {
uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT);
}
@@ -1352,7 +1352,7 @@ int uv_write2(uv_write_t* req,
req->handle = stream;
req->error = 0;
req->send_handle = send_handle;
- uv__queue_init(&req->queue);
+ QUEUE_INIT(&req->queue);
req->bufs = req->bufsml;
if (nbufs > ARRAY_SIZE(req->bufsml))
@@ -1367,7 +1367,7 @@ int uv_write2(uv_write_t* req,
stream->write_queue_size += uv__count_bufs(bufs, nbufs);
/* Append the request to write_queue. */
- uv__queue_insert_tail(&stream->write_queue, &req->queue);
+ QUEUE_INSERT_TAIL(&stream->write_queue, &req->queue);
/* If the queue was empty when this function began, we should attempt to
* do the write immediately. Otherwise start the write_watcher and wait
diff --git a/deps/uv/src/unix/sunos.c b/deps/uv/src/unix/sunos.c
index 2d6bae79604..75b6fbad493 100644
--- a/deps/uv/src/unix/sunos.c
+++ b/deps/uv/src/unix/sunos.c
@@ -148,7 +148,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
struct port_event events[1024];
struct port_event* pe;
struct timespec spec;
- struct uv__queue* q;
+ QUEUE* q;
uv__io_t* w;
sigset_t* pset;
sigset_t set;
@@ -166,16 +166,16 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
int reset_timeout;
if (loop->nfds == 0) {
- assert(uv__queue_empty(&loop->watcher_queue));
+ assert(QUEUE_EMPTY(&loop->watcher_queue));
return;
}
- while (!uv__queue_empty(&loop->watcher_queue)) {
- q = uv__queue_head(&loop->watcher_queue);
- uv__queue_remove(q);
- uv__queue_init(q);
+ while (!QUEUE_EMPTY(&loop->watcher_queue)) {
+ q = QUEUE_HEAD(&loop->watcher_queue);
+ QUEUE_REMOVE(q);
+ QUEUE_INIT(q);
- w = uv__queue_data(q, uv__io_t, watcher_queue);
+ w = QUEUE_DATA(q, uv__io_t, watcher_queue);
assert(w->pevents != 0);
if (port_associate(loop->backend_fd,
@@ -316,8 +316,8 @@ void uv__io_poll(uv_loop_t* loop, int timeout) {
continue; /* Disabled by callback. */
/* Events Ports operates in oneshot mode, rearm timer on next run. */
- if (w->pevents != 0 && uv__queue_empty(&w->watcher_queue))
- uv__queue_insert_tail(&loop->watcher_queue, &w->watcher_queue);
+ if (w->pevents != 0 && QUEUE_EMPTY(&w->watcher_queue))
+ QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
}
uv__metrics_inc_events(loop, nevents);
diff --git a/deps/uv/src/unix/tcp.c b/deps/uv/src/unix/tcp.c
index d6c848f4610..ab4e06c2f67 100644
--- a/deps/uv/src/unix/tcp.c
+++ b/deps/uv/src/unix/tcp.c
@@ -124,7 +124,7 @@ int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* tcp, unsigned int flags) {
if (domain != AF_UNSPEC) {
err = new_socket(tcp, domain, 0);
if (err) {
- uv__queue_remove(&tcp->handle_queue);
+ QUEUE_REMOVE(&tcp->handle_queue);
if (tcp->io_watcher.fd != -1)
uv__close(tcp->io_watcher.fd);
tcp->io_watcher.fd = -1;
@@ -252,7 +252,7 @@ out:
uv__req_init(handle->loop, req, UV_CONNECT);
req->cb = cb;
req->handle = (uv_stream_t*) handle;
- uv__queue_init(&req->queue);
+ QUEUE_INIT(&req->queue);
handle->connect_req = req;
uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
diff --git a/deps/uv/src/unix/tty.c b/deps/uv/src/unix/tty.c
index d099bdb3b67..7a5390c1a8b 100644
--- a/deps/uv/src/unix/tty.c
+++ b/deps/uv/src/unix/tty.c
@@ -222,7 +222,7 @@ skip:
int rc = r;
if (newfd != -1)
uv__close(newfd);
- uv__queue_remove(&tty->handle_queue);
+ QUEUE_REMOVE(&tty->handle_queue);
do
r = fcntl(fd, F_SETFL, saved_flags);
while (r == -1 && errno == EINTR);
diff --git a/deps/uv/src/unix/udp.c b/deps/uv/src/unix/udp.c
index c2814512a5f..f556808fbae 100644
--- a/deps/uv/src/unix/udp.c
+++ b/deps/uv/src/unix/udp.c
@@ -62,18 +62,18 @@ void uv__udp_close(uv_udp_t* handle) {
void uv__udp_finish_close(uv_udp_t* handle) {
uv_udp_send_t* req;
- struct uv__queue* q;
+ QUEUE* q;
assert(!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT));
assert(handle->io_watcher.fd == -1);
- while (!uv__queue_empty(&handle->write_queue)) {
- q = uv__queue_head(&handle->write_queue);
- uv__queue_remove(q);
+ while (!QUEUE_EMPTY(&handle->write_queue)) {
+ q = QUEUE_HEAD(&handle->write_queue);
+ QUEUE_REMOVE(q);
- req = uv__queue_data(q, uv_udp_send_t, queue);
+ req = QUEUE_DATA(q, uv_udp_send_t, queue);
req->status = UV_ECANCELED;
- uv__queue_insert_tail(&handle->write_completed_queue, &req->queue);
+ QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
}
uv__udp_run_completed(handle);
@@ -90,16 +90,16 @@ void uv__udp_finish_close(uv_udp_t* handle) {
static void uv__udp_run_completed(uv_udp_t* handle) {
uv_udp_send_t* req;
- struct uv__queue* q;
+ QUEUE* q;
assert(!(handle->flags & UV_HANDLE_UDP_PROCESSING));
handle->flags |= UV_HANDLE_UDP_PROCESSING;
- while (!uv__queue_empty(&handle->write_completed_queue)) {
- q = uv__queue_head(&handle->write_completed_queue);
- uv__queue_remove(q);
+ while (!QUEUE_EMPTY(&handle->write_completed_queue)) {
+ q = QUEUE_HEAD(&handle->write_completed_queue);
+ QUEUE_REMOVE(q);
- req = uv__queue_data(q, uv_udp_send_t, queue);
+ req = QUEUE_DATA(q, uv_udp_send_t, queue);
uv__req_unregister(handle->loop, req);
handle->send_queue_size -= uv__count_bufs(req->bufs, req->nbufs);
@@ -121,7 +121,7 @@ static void uv__udp_run_completed(uv_udp_t* handle) {
req->send_cb(req, req->status);
}
- if (uv__queue_empty(&handle->write_queue)) {
+ if (QUEUE_EMPTY(&handle->write_queue)) {
/* Pending queue and completion queue empty, stop watcher. */
uv__io_stop(handle->loop, &handle->io_watcher, POLLOUT);
if (!uv__io_active(&handle->io_watcher, POLLIN))
@@ -280,20 +280,20 @@ static void uv__udp_sendmsg(uv_udp_t* handle) {
uv_udp_send_t* req;
struct mmsghdr h[20];
struct mmsghdr* p;
- struct uv__queue* q;
+ QUEUE* q;
ssize_t npkts;
size_t pkts;
size_t i;
- if (uv__queue_empty(&handle->write_queue))
+ if (QUEUE_EMPTY(&handle->write_queue))
return;
write_queue_drain:
- for (pkts = 0, q = uv__queue_head(&handle->write_queue);
+ for (pkts = 0, q = QUEUE_HEAD(&handle->write_queue);
pkts < ARRAY_SIZE(h) && q != &handle->write_queue;
- ++pkts, q = uv__queue_head(q)) {
+ ++pkts, q = QUEUE_HEAD(q)) {
assert(q != NULL);
- req = uv__queue_data(q, uv_udp_send_t, queue);
+ req = QUEUE_DATA(q, uv_udp_send_t, queue);
assert(req != NULL);
p = &h[pkts];
@@ -325,16 +325,16 @@ write_queue_drain:
if (npkts < 1) {
if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENOBUFS)
return;
- for (i = 0, q = uv__queue_head(&handle->write_queue);
+ for (i = 0, q = QUEUE_HEAD(&handle->write_queue);
i < pkts && q != &handle->write_queue;
- ++i, q = uv__queue_head(&handle->write_queue)) {
+ ++i, q = QUEUE_HEAD(&handle->write_queue)) {
assert(q != NULL);
- req = uv__queue_data(q, uv_udp_send_t, queue);
+ req = QUEUE_DATA(q, uv_udp_send_t, queue);
assert(req != NULL);
req->status = UV__ERR(errno);
- uv__queue_remove(&req->queue);
- uv__queue_insert_tail(&handle->write_completed_queue, &req->queue);
+ QUEUE_REMOVE(&req->queue);
+ QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
}
uv__io_feed(handle->loop, &handle->io_watcher);
return;
@@ -343,11 +343,11 @@ write_queue_drain:
/* Safety: npkts known to be >0 below. Hence cast from ssize_t
* to size_t safe.
*/
- for (i = 0, q = uv__queue_head(&handle->write_queue);
+ for (i = 0, q = QUEUE_HEAD(&handle->write_queue);
i < (size_t)npkts && q != &handle->write_queue;
- ++i, q = uv__queue_head(&handle->write_queue)) {
+ ++i, q = QUEUE_HEAD(&handle->write_queue)) {
assert(q != NULL);
- req = uv__queue_data(q, uv_udp_send_t, queue);
+ req = QUEUE_DATA(q, uv_udp_send_t, queue);
assert(req != NULL);
req->status = req->bufs[0].len;
@@ -357,25 +357,25 @@ write_queue_drain:
* why we don't handle partial writes. Just pop the request
* off the write queue and onto the completed queue, done.
*/
- uv__queue_remove(&req->queue);
- uv__queue_insert_tail(&handle->write_completed_queue, &req->queue);
+ QUEUE_REMOVE(&req->queue);
+ QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
}
/* couldn't batch everything, continue sending (jump to avoid stack growth) */
- if (!uv__queue_empty(&handle->write_queue))
+ if (!QUEUE_EMPTY(&handle->write_queue))
goto write_queue_drain;
uv__io_feed(handle->loop, &handle->io_watcher);
#else /* __linux__ || ____FreeBSD__ */
uv_udp_send_t* req;
struct msghdr h;
- struct uv__queue* q;
+ QUEUE* q;
ssize_t size;
- while (!uv__queue_empty(&handle->write_queue)) {
- q = uv__queue_head(&handle->write_queue);
+ while (!QUEUE_EMPTY(&handle->write_queue)) {
+ q = QUEUE_HEAD(&handle->write_queue);
assert(q != NULL);
- req = uv__queue_data(q, uv_udp_send_t, queue);
+ req = QUEUE_DATA(q, uv_udp_send_t, queue);
assert(req != NULL);
memset(&h, 0, sizeof h);
@@ -414,8 +414,8 @@ write_queue_drain:
* why we don't handle partial writes. Just pop the request
* off the write queue and onto the completed queue, done.
*/
- uv__queue_remove(&req->queue);
- uv__queue_insert_tail(&handle->write_completed_queue, &req->queue);
+ QUEUE_REMOVE(&req->queue);
+ QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
uv__io_feed(handle->loop, &handle->io_watcher);
}
#endif /* __linux__ || ____FreeBSD__ */
@@ -729,7 +729,7 @@ int uv__udp_send(uv_udp_send_t* req,
memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0]));
handle->send_queue_size += uv__count_bufs(req->bufs, req->nbufs);
handle->send_queue_count++;
- uv__queue_insert_tail(&handle->write_queue, &req->queue);
+ QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue);
uv__handle_start(handle);
if (empty_queue && !(handle->flags & UV_HANDLE_UDP_PROCESSING)) {
@@ -739,7 +739,7 @@ int uv__udp_send(uv_udp_send_t* req,
* away. In such cases the `io_watcher` has to be queued for asynchronous
* write.
*/
- if (!uv__queue_empty(&handle->write_queue))
+ if (!QUEUE_EMPTY(&handle->write_queue))
uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
} else {
uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
@@ -1007,8 +1007,8 @@ int uv__udp_init_ex(uv_loop_t* loop,
handle->send_queue_size = 0;
handle->send_queue_count = 0;
uv__io_init(&handle->io_watcher, uv__udp_io, fd);
- uv__queue_init(&handle->write_queue);
- uv__queue_init(&handle->write_completed_queue);
+ QUEUE_INIT(&handle->write_queue);
+ QUEUE_INIT(&handle->write_completed_queue);
return 0;
}
diff --git a/deps/uv/src/uv-common.c b/deps/uv/src/uv-common.c
index 916f3f4e006..cec771fab21 100644
--- a/deps/uv/src/uv-common.c
+++ b/deps/uv/src/uv-common.c
@@ -533,17 +533,17 @@ int uv_udp_recv_stop(uv_udp_t* handle) {
void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg) {
- struct uv__queue queue;
- struct uv__queue* q;
+ QUEUE queue;
+ QUEUE* q;
uv_handle_t* h;
- uv__queue_move(&loop->handle_queue, &queue);
- while (!uv__queue_empty(&queue)) {
- q = uv__queue_head(&queue);
- h = uv__queue_data(q, uv_handle_t, handle_queue);
+ QUEUE_MOVE(&loop->handle_queue, &queue);
+ while (!QUEUE_EMPTY(&queue)) {
+ q = QUEUE_HEAD(&queue);
+ h = QUEUE_DATA(q, uv_handle_t, handle_queue);
- uv__queue_remove(q);
- uv__queue_insert_tail(&loop->handle_queue, q);
+ QUEUE_REMOVE(q);
+ QUEUE_INSERT_TAIL(&loop->handle_queue, q);
if (h->flags & UV_HANDLE_INTERNAL) continue;
walk_cb(h, arg);
@@ -553,14 +553,14 @@ void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg) {
static void uv__print_handles(uv_loop_t* loop, int only_active, FILE* stream) {
const char* type;
- struct uv__queue* q;
+ QUEUE* q;
uv_handle_t* h;
if (loop == NULL)
loop = uv_default_loop();
- uv__queue_foreach(q, &loop->handle_queue) {
- h = uv__queue_data(q, uv_handle_t, handle_queue);
+ QUEUE_FOREACH(q, &loop->handle_queue) {
+ h = QUEUE_DATA(q, uv_handle_t, handle_queue);
if (only_active && !uv__is_active(h))
continue;
@@ -846,7 +846,7 @@ uv_loop_t* uv_loop_new(void) {
int uv_loop_close(uv_loop_t* loop) {
- struct uv__queue* q;
+ QUEUE* q;
uv_handle_t* h;
#ifndef NDEBUG
void* saved_data;
@@ -855,8 +855,8 @@ int uv_loop_close(uv_loop_t* loop) {
if (uv__has_active_reqs(loop))
return UV_EBUSY;
- uv__queue_foreach(q, &loop->handle_queue) {
- h = uv__queue_data(q, uv_handle_t, handle_queue);
+ QUEUE_FOREACH(q, &loop->handle_queue) {
+ h = QUEUE_DATA(q, uv_handle_t, handle_queue);
if (!(h->flags & UV_HANDLE_INTERNAL))
return UV_EBUSY;
}
diff --git a/deps/uv/src/uv-common.h b/deps/uv/src/uv-common.h
index cd57e5a3515..decde5362c8 100644
--- a/deps/uv/src/uv-common.h
+++ b/deps/uv/src/uv-common.h
@@ -323,7 +323,7 @@ void uv__threadpool_cleanup(void);
(h)->loop = (loop_); \
(h)->type = (type_); \
(h)->flags = UV_HANDLE_REF; /* Ref the loop when active. */ \
- uv__queue_insert_tail(&(loop_)->handle_queue, &(h)->handle_queue); \
+ QUEUE_INSERT_TAIL(&(loop_)->handle_queue, &(h)->handle_queue); \
uv__handle_platform_init(h); \
} \
while (0)
@@ -415,7 +415,6 @@ struct uv__iou {
size_t sqelen;
int ringfd;
uint32_t in_flight;
- uint32_t flags;
};
#endif /* __linux__ */
diff --git a/deps/uv/src/win/core.c b/deps/uv/src/win/core.c
index e9885a0f1ff..9a3be58849a 100644
--- a/deps/uv/src/win/core.c
+++ b/deps/uv/src/win/core.c
@@ -255,8 +255,8 @@ int uv_loop_init(uv_loop_t* loop) {
loop->time = 0;
uv_update_time(loop);
- uv__queue_init(&loop->wq);
- uv__queue_init(&loop->handle_queue);
+ QUEUE_INIT(&loop->wq);
+ QUEUE_INIT(&loop->handle_queue);
loop->active_reqs.count = 0;
loop->active_handles = 0;
@@ -358,7 +358,7 @@ void uv__loop_close(uv_loop_t* loop) {
}
uv_mutex_lock(&loop->wq_mutex);
- assert(uv__queue_empty(&loop->wq) && "thread pool work queue not empty!");
+ assert(QUEUE_EMPTY(&loop->wq) && "thread pool work queue not empty!");
assert(!uv__has_active_reqs(loop));
uv_mutex_unlock(&loop->wq_mutex);
uv_mutex_destroy(&loop->wq_mutex);
diff --git a/deps/uv/src/win/fs.c b/deps/uv/src/win/fs.c
index fc209c54f47..deb9438d689 100644
--- a/deps/uv/src/win/fs.c
+++ b/deps/uv/src/win/fs.c
@@ -144,97 +144,26 @@ void uv__fs_init(void) {
}
-static int32_t fs__decode_wtf8_char(const char** input) {
- uint32_t code_point;
- uint8_t b1;
- uint8_t b2;
- uint8_t b3;
- uint8_t b4;
-
- b1 = **input;
- if (b1 <= 0x7F)
- return b1; /* ASCII code point */
- if (b1 < 0xC2)
- return -1; /* invalid: continuation byte */
- code_point = b1;
-
- b2 = *++*input;
- if ((b2 & 0xC0) != 0x80)
- return -1; /* invalid: not a continuation byte */
- code_point = (code_point << 6) | (b2 & 0x3F);
- if (b1 <= 0xDF)
- return 0x7FF & code_point; /* two-byte character */
-
- b3 = *++*input;
- if ((b3 & 0xC0) != 0x80)
- return -1; /* invalid: not a continuation byte */
- code_point = (code_point << 6) | (b3 & 0x3F);
- if (b1 <= 0xEF)
- return 0xFFFF & code_point; /* three-byte character */
-
- b4 = *++*input;
- if ((b4 & 0xC0) != 0x80)
- return -1; /* invalid: not a continuation byte */
- code_point = (code_point << 6) | (b4 & 0x3F);
- if (b1 <= 0xF4)
- if (code_point <= 0x10FFFF)
- return code_point; /* four-byte character */
-
- /* code point too large */
- return -1;
-}
-
-
-static ssize_t fs__get_length_wtf8(const char* source_ptr) {
- size_t w_target_len = 0;
- int32_t code_point;
-
- do {
- code_point = fs__decode_wtf8_char(&source_ptr);
- if (code_point < 0)
- return -1;
- if (code_point > 0xFFFF)
- w_target_len++;
- w_target_len++;
- } while (*source_ptr++);
- return w_target_len;
-}
-
-
-static void fs__wtf8_to_wide(const char* source_ptr, WCHAR* w_target) {
- int32_t code_point;
-
- do {
- code_point = fs__decode_wtf8_char(&source_ptr);
- /* fs__get_length_wtf8 should have been called and checked first. */
- assert(code_point >= 0);
- if (code_point > 0x10000) {
- assert(code_point < 0x10FFFF);
- *w_target++ = (((code_point - 0x10000) >> 10) + 0xD800);
- *w_target++ = ((code_point - 0x10000) & 0x3FF) + 0xDC00;
- } else {
- *w_target++ = code_point;
- }
- } while (*source_ptr++);
-}
-
-
INLINE static int fs__capture_path(uv_fs_t* req, const char* path,
const char* new_path, const int copy_path) {
- WCHAR* buf;
- WCHAR* pos;
- size_t buf_sz = 0;
- size_t path_len = 0;
- ssize_t pathw_len = 0;
- ssize_t new_pathw_len = 0;
+ char* buf;
+ char* pos;
+ ssize_t buf_sz = 0, path_len = 0, pathw_len = 0, new_pathw_len = 0;
/* new_path can only be set if path is also set. */
assert(new_path == NULL || path != NULL);
if (path != NULL) {
- pathw_len = fs__get_length_wtf8(path);
- if (pathw_len < 0)
- return ERROR_INVALID_NAME;
+ pathw_len = MultiByteToWideChar(CP_UTF8,
+ 0,
+ path,
+ -1,
+ NULL,
+ 0);
+ if (pathw_len == 0) {
+ return GetLastError();
+ }
+
buf_sz += pathw_len * sizeof(WCHAR);
}
@@ -244,9 +173,16 @@ INLINE static int fs__capture_path(uv_fs_t* req, const char* path,
}
if (new_path != NULL) {
- new_pathw_len = fs__get_length_wtf8(new_path);
- if (new_pathw_len < 0)
- return ERROR_INVALID_NAME;
+ new_pathw_len = MultiByteToWideChar(CP_UTF8,
+ 0,
+ new_path,
+ -1,
+ NULL,
+ 0);
+ if (new_pathw_len == 0) {
+ return GetLastError();
+ }
+
buf_sz += new_pathw_len * sizeof(WCHAR);
}
@@ -258,7 +194,7 @@ INLINE static int fs__capture_path(uv_fs_t* req, const char* path,
return 0;
}
- buf = uv__malloc(buf_sz);
+ buf = (char*) uv__malloc(buf_sz);
if (buf == NULL) {
return ERROR_OUTOFMEMORY;
}
@@ -266,17 +202,29 @@ INLINE static int fs__capture_path(uv_fs_t* req, const char* path,
pos = buf;
if (path != NULL) {
- fs__wtf8_to_wide(path, pos);
- req->file.pathw = pos;
- pos += pathw_len;
+ DWORD r = MultiByteToWideChar(CP_UTF8,
+ 0,
+ path,
+ -1,
+ (WCHAR*) pos,
+ pathw_len);
+ assert(r == (DWORD) pathw_len);
+ req->file.pathw = (WCHAR*) pos;
+ pos += r * sizeof(WCHAR);
} else {
req->file.pathw = NULL;
}
if (new_path != NULL) {
- fs__wtf8_to_wide(new_path, pos);
- req->fs.info.new_pathw = pos;
- pos += new_pathw_len;
+ DWORD r = MultiByteToWideChar(CP_UTF8,
+ 0,
+ new_path,
+ -1,
+ (WCHAR*) pos,
+ new_pathw_len);
+ assert(r == (DWORD) new_pathw_len);
+ req->fs.info.new_pathw = (WCHAR*) pos;
+ pos += r * sizeof(WCHAR);
} else {
req->fs.info.new_pathw = NULL;
}
@@ -284,8 +232,8 @@ INLINE static int fs__capture_path(uv_fs_t* req, const char* path,
req->path = path;
if (path != NULL && copy_path) {
memcpy(pos, path, path_len);
- assert(path_len == buf_sz - (pos - buf) * sizeof(WCHAR));
- req->path = (char*) pos;
+ assert(path_len == buf_sz - (pos - buf));
+ req->path = pos;
}
req->flags |= UV_FS_FREE_PATHS;
@@ -311,115 +259,57 @@ INLINE static void uv__fs_req_init(uv_loop_t* loop, uv_fs_t* req,
}
-static int32_t fs__get_surrogate_value(const WCHAR* w_source_ptr,
- size_t w_source_len) {
- WCHAR u;
- WCHAR next;
-
- u = w_source_ptr[0];
- if (u >= 0xD800 && u <= 0xDBFF && w_source_len > 1) {
- next = w_source_ptr[1];
- if (next >= 0xDC00 && next <= 0xDFFF)
- return 0x10000 + ((u - 0xD800) << 10) + (next - 0xDC00);
- }
- return u;
-}
-
-
-static size_t fs__get_length_wide(const WCHAR* w_source_ptr,
- size_t w_source_len) {
- size_t target_len;
- int32_t code_point;
+static int fs__wide_to_utf8(WCHAR* w_source_ptr,
+ DWORD w_source_len,
+ char** target_ptr,
+ uint64_t* target_len_ptr) {
+ int r;
+ int target_len;
+ char* target;
+ target_len = WideCharToMultiByte(CP_UTF8,
+ 0,
+ w_source_ptr,
+ w_source_len,
+ NULL,
+ 0,
+ NULL,
+ NULL);
- target_len = 0;
- for (; w_source_len; w_source_len--, w_source_ptr++) {
- code_point = fs__get_surrogate_value(w_source_ptr, w_source_len);
- /* Can be invalid UTF-8 but must be valid WTF-8. */
- assert(code_point >= 0);
- if (code_point < 0x80)
- target_len += 1;
- else if (code_point < 0x800)
- target_len += 2;
- else if (code_point < 0x10000)
- target_len += 3;
- else {
- target_len += 4;
- w_source_ptr++;
- w_source_len--;
- }
+ if (target_len == 0) {
+ return -1;
}
- return target_len;
-}
-
-static int fs__wide_to_wtf8(WCHAR* w_source_ptr,
- size_t w_source_len,
- char** target_ptr,
- size_t* target_len_ptr) {
- size_t target_len;
- char* target;
- int32_t code_point;
-
- /* If *target_ptr is provided, then *target_len_ptr must be its length
- * (excluding space for null), otherwise we will compute the target_len_ptr
- * length and may return a new allocation in *target_ptr if target_ptr is
- * provided. */
- if (target_ptr == NULL || *target_ptr == NULL) {
- target_len = fs__get_length_wide(w_source_ptr, w_source_len);
- if (target_len_ptr != NULL)
- *target_len_ptr = target_len;
- } else {
- target_len = *target_len_ptr;
+ if (target_len_ptr != NULL) {
+ *target_len_ptr = target_len;
}
- if (target_ptr == NULL)
+ if (target_ptr == NULL) {
return 0;
-
- if (*target_ptr == NULL) {
- target = uv__malloc(target_len + 1);
- if (target == NULL) {
- SetLastError(ERROR_OUTOFMEMORY);
- return -1;
- }
- *target_ptr = target;
- } else {
- target = *target_ptr;
- }
-
- for (; w_source_len; w_source_len--, w_source_ptr++) {
- code_point = fs__get_surrogate_value(w_source_ptr, w_source_len);
- /* Can be invalid UTF-8 but must be valid WTF-8. */
- assert(code_point >= 0);
-
- if (code_point < 0x80) {
- *target++ = code_point;
- } else if (code_point < 0x800) {
- *target++ = 0xC0 | (code_point >> 6);
- *target++ = 0x80 | (code_point & 0x3F);
- } else if (code_point < 0x10000) {
- *target++ = 0xE0 | (code_point >> 12);
- *target++ = 0x80 | ((code_point >> 6) & 0x3F);
- *target++ = 0x80 | (code_point & 0x3F);
- } else {
- *target++ = 0xF0 | (code_point >> 18);
- *target++ = 0x80 | ((code_point >> 12) & 0x3F);
- *target++ = 0x80 | ((code_point >> 6) & 0x3F);
- *target++ = 0x80 | (code_point & 0x3F);
- w_source_ptr++;
- w_source_len--;
- }
}
- assert((size_t) (target - *target_ptr) == target_len);
- *target++ = '\0';
+ target = uv__malloc(target_len + 1);
+ if (target == NULL) {
+ SetLastError(ERROR_OUTOFMEMORY);
+ return -1;
+ }
+ r = WideCharToMultiByte(CP_UTF8,
+ 0,
+ w_source_ptr,
+ w_source_len,
+ target,
+ target_len,
+ NULL,
+ NULL);
+ assert(r == target_len);
+ target[target_len] = '\0';
+ *target_ptr = target;
return 0;
}
-INLINE static int fs__readlink_handle(HANDLE handle,
- char** target_ptr,
- size_t* target_len_ptr) {
+INLINE static int fs__readlink_handle(HANDLE handle, char** target_ptr,
+ uint64_t* target_len_ptr) {
char buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
REPARSE_DATA_BUFFER* reparse_data = (REPARSE_DATA_BUFFER*) buffer;
WCHAR* w_target;
@@ -549,8 +439,7 @@ INLINE static int fs__readlink_handle(HANDLE handle,
return -1;
}
- assert(target_ptr == NULL || *target_ptr == NULL);
- return fs__wide_to_wtf8(w_target, w_target_len, target_ptr, target_len_ptr);
+ return fs__wide_to_utf8(w_target, w_target_len, target_ptr, target_len_ptr);
}
@@ -1540,8 +1429,7 @@ void fs__scandir(uv_fs_t* req) {
uv__dirent_t* dirent;
size_t wchar_len;
- size_t wtf8_len;
- char* wtf8;
+ size_t utf8_len;
/* Obtain a pointer to the current directory entry. */
position += next_entry_offset;
@@ -1568,8 +1456,11 @@ void fs__scandir(uv_fs_t* req) {
info->FileName[1] == L'.')
continue;
- /* Compute the space required to store the filename as WTF-8. */
- wtf8_len = fs__get_length_wide(&info->FileName[0], wchar_len);
+ /* Compute the space required to store the filename as UTF-8. */
+ utf8_len = WideCharToMultiByte(
+ CP_UTF8, 0, &info->FileName[0], wchar_len, NULL, 0, NULL, NULL);
+ if (utf8_len == 0)
+ goto win32_error;
/* Resize the dirent array if needed. */
if (dirents_used >= dirents_size) {
@@ -1589,17 +1480,26 @@ void fs__scandir(uv_fs_t* req) {
* includes room for the first character of the filename, but `utf8_len`
* doesn't count the NULL terminator at this point.
*/
- dirent = uv__malloc(sizeof *dirent + wtf8_len);
+ dirent = uv__malloc(sizeof *dirent + utf8_len);
if (dirent == NULL)
goto out_of_memory_error;
dirents[dirents_used++] = dirent;
/* Convert file name to UTF-8. */
- wtf8 = &dirent->d_name[0];
- if (fs__wide_to_wtf8(&info->FileName[0], wchar_len, &wtf8, &wtf8_len) == -1)
+ if (WideCharToMultiByte(CP_UTF8,
+ 0,
+ &info->FileName[0],
+ wchar_len,
+ &dirent->d_name[0],
+ utf8_len,
+ NULL,
+ NULL) == 0)
goto win32_error;
+ /* Add a null terminator to the filename. */
+ dirent->d_name[utf8_len] = '\0';
+
/* Fill out the type field. */
if (info->FileAttributes & FILE_ATTRIBUTE_DEVICE)
dirent->d_type = UV__DT_CHAR;
@@ -1808,7 +1708,6 @@ void fs__closedir(uv_fs_t* req) {
INLINE static int fs__stat_handle(HANDLE handle, uv_stat_t* statbuf,
int do_lstat) {
- size_t target_length = 0;
FILE_FS_DEVICE_INFORMATION device_info;
FILE_ALL_INFORMATION file_info;
FILE_FS_VOLUME_INFORMATION volume_info;
@@ -1904,10 +1803,9 @@ INLINE static int fs__stat_handle(HANDLE handle, uv_stat_t* statbuf,
* to be treated as a regular file. The higher level lstat function will
* detect this failure and retry without do_lstat if appropriate.
*/
- if (fs__readlink_handle(handle, NULL, &target_length) != 0)
+ if (fs__readlink_handle(handle, NULL, &statbuf->st_size) != 0)
return -1;
statbuf->st_mode |= S_IFLNK;
- statbuf->st_size = target_length;
}
if (statbuf->st_mode == 0) {
@@ -2763,7 +2661,6 @@ static void fs__readlink(uv_fs_t* req) {
return;
}
- assert(req->ptr == NULL);
if (fs__readlink_handle(handle, (char**) &req->ptr, NULL) != 0) {
DWORD error = GetLastError();
SET_REQ_WIN32_ERROR(req, error);
@@ -2823,8 +2720,7 @@ static ssize_t fs__realpath_handle(HANDLE handle, char** realpath_ptr) {
return -1;
}
- assert(*realpath_ptr == NULL);
- r = fs__wide_to_wtf8(w_realpath_ptr, w_realpath_len, realpath_ptr, NULL);
+ r = fs__wide_to_utf8(w_realpath_ptr, w_realpath_len, realpath_ptr, NULL);
uv__free(w_realpath_buf);
return r;
}
@@ -2844,7 +2740,6 @@ static void fs__realpath(uv_fs_t* req) {
return;
}
- assert(req->ptr == NULL);
if (fs__realpath_handle(handle, (char**) &req->ptr) == -1) {
CloseHandle(handle);
SET_REQ_WIN32_ERROR(req, GetLastError());
diff --git a/deps/uv/src/win/handle-inl.h b/deps/uv/src/win/handle-inl.h
index 4722e85790a..5c843c241ef 100644
--- a/deps/uv/src/win/handle-inl.h
+++ b/deps/uv/src/win/handle-inl.h
@@ -75,7 +75,7 @@
#define uv__handle_close(handle) \
do { \
- uv__queue_remove(&(handle)->handle_queue); \
+ QUEUE_REMOVE(&(handle)->handle_queue); \
uv__active_handle_rm((uv_handle_t*) (handle)); \
\
(handle)->flags |= UV_HANDLE_CLOSED; \
diff --git a/deps/uv/src/win/pipe.c b/deps/uv/src/win/pipe.c
index f0cac382256..5e4276387ac 100644
--- a/deps/uv/src/win/pipe.c
+++ b/deps/uv/src/win/pipe.c
@@ -55,7 +55,7 @@ static const int pipe_prefix_len = sizeof(pipe_prefix) - 1;
typedef struct {
uv__ipc_socket_xfer_type_t xfer_type;
uv__ipc_socket_xfer_info_t xfer_info;
- struct uv__queue member;
+ QUEUE member;
} uv__ipc_xfer_queue_item_t;
/* IPC frame header flags. */
@@ -111,7 +111,7 @@ int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) {
handle->name = NULL;
handle->pipe.conn.ipc_remote_pid = 0;
handle->pipe.conn.ipc_data_frame.payload_remaining = 0;
- uv__queue_init(&handle->pipe.conn.ipc_xfer_queue);
+ QUEUE_INIT(&handle->pipe.conn.ipc_xfer_queue);
handle->pipe.conn.ipc_xfer_queue_length = 0;
handle->ipc = ipc;
handle->pipe.conn.non_overlapped_writes_tail = NULL;
@@ -637,13 +637,13 @@ void uv__pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) {
if (handle->flags & UV_HANDLE_CONNECTION) {
/* Free pending sockets */
- while (!uv__queue_empty(&handle->pipe.conn.ipc_xfer_queue)) {
- struct uv__queue* q;
+ while (!QUEUE_EMPTY(&handle->pipe.conn.ipc_xfer_queue)) {
+ QUEUE* q;
SOCKET socket;
- q = uv__queue_head(&handle->pipe.conn.ipc_xfer_queue);
- uv__queue_remove(q);
- xfer_queue_item = uv__queue_data(q, uv__ipc_xfer_queue_item_t, member);
+ q = QUEUE_HEAD(&handle->pipe.conn.ipc_xfer_queue);
+ QUEUE_REMOVE(q);
+ xfer_queue_item = QUEUE_DATA(q, uv__ipc_xfer_queue_item_t, member);
/* Materialize socket and close it */
socket = WSASocketW(FROM_PROTOCOL_INFO,
@@ -1124,20 +1124,20 @@ int uv__pipe_accept(uv_pipe_t* server, uv_stream_t* client) {
uv_loop_t* loop = server->loop;
uv_pipe_t* pipe_client;
uv_pipe_accept_t* req;
- struct uv__queue* q;
+ QUEUE* q;
uv__ipc_xfer_queue_item_t* item;
int err;
if (server->ipc) {
- if (uv__queue_empty(&server->pipe.conn.ipc_xfer_queue)) {
+ if (QUEUE_EMPTY(&server->pipe.conn.ipc_xfer_queue)) {
/* No valid pending sockets. */
return WSAEWOULDBLOCK;
}
- q = uv__queue_head(&server->pipe.conn.ipc_xfer_queue);
- uv__queue_remove(q);
+ q = QUEUE_HEAD(&server->pipe.conn.ipc_xfer_queue);
+ QUEUE_REMOVE(q);
server->pipe.conn.ipc_xfer_queue_length--;
- item = uv__queue_data(q, uv__ipc_xfer_queue_item_t, member);
+ item = QUEUE_DATA(q, uv__ipc_xfer_queue_item_t, member);
err = uv__tcp_xfer_import(
(uv_tcp_t*) client, item->xfer_type, &item->xfer_info);
@@ -1891,7 +1891,7 @@ static void uv__pipe_queue_ipc_xfer_info(
item->xfer_type = xfer_type;
item->xfer_info = *xfer_info;
- uv__queue_insert_tail(&handle->pipe.conn.ipc_xfer_queue, &item->member);
+ QUEUE_INSERT_TAIL(&handle->pipe.conn.ipc_xfer_queue, &item->member);
handle->pipe.conn.ipc_xfer_queue_length++;
}
diff --git a/deps/uv/src/win/tcp.c b/deps/uv/src/win/tcp.c
index 187f36e2a61..6b282e0b501 100644
--- a/deps/uv/src/win/tcp.c
+++ b/deps/uv/src/win/tcp.c
@@ -175,14 +175,14 @@ int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* handle, unsigned int flags) {
sock = socket(domain, SOCK_STREAM, 0);
if (sock == INVALID_SOCKET) {
err = WSAGetLastError();
- uv__queue_remove(&handle->handle_queue);
+ QUEUE_REMOVE(&handle->handle_queue);
return uv_translate_sys_error(err);
}
err = uv__tcp_set_socket(handle->loop, handle, sock, domain, 0);
if (err) {
closesocket(sock);
- uv__queue_remove(&handle->handle_queue);
+ QUEUE_REMOVE(&handle->handle_queue);
return uv_translate_sys_error(err);
}
diff --git a/deps/uv/src/win/udp.c b/deps/uv/src/win/udp.c
index eab53842d4f..8a982d1907d 100644
--- a/deps/uv/src/win/udp.c
+++ b/deps/uv/src/win/udp.c
@@ -146,14 +146,14 @@ int uv__udp_init_ex(uv_loop_t* loop,
sock = socket(domain, SOCK_DGRAM, 0);
if (sock == INVALID_SOCKET) {
err = WSAGetLastError();
- uv__queue_remove(&handle->handle_queue);
+ QUEUE_REMOVE(&handle->handle_queue);
return uv_translate_sys_error(err);
}
err = uv__udp_set_socket(handle->loop, handle, sock, domain);
if (err) {
closesocket(sock);
- uv__queue_remove(&handle->handle_queue);
+ QUEUE_REMOVE(&handle->handle_queue);
return uv_translate_sys_error(err);
}
}
Reference in New Issue View Git Blame Copy Permalink